philomena/lib/philomena/textile/renderer.ex

defmodule Philomena.Textile.Renderer do
  # todo: belongs in PhilomenaWeb
  alias Textile.Parser
  alias Philomena.Images.Image
  alias Philomena.Repo
  import Phoenix.HTML
  import Phoenix.HTML.Link
  import Ecto.Query

  @parser %Parser{
    image_transform: &Camo.Image.image_url/1
  }

  # Kill bogus compile time dependency on ImageView
  @image_view Module.concat(["PhilomenaWeb.ImageView"])

  def render_one(post, conn) do
    hd(render_collection([post], conn))
  end

  def render_collection(posts, conn) do
    parsed =
      posts
      |> Enum.map(fn post ->
        Parser.parse(@parser, post.body)
      end)

    images =
      parsed
      |> Enum.flat_map(fn tree ->
        tree
        |> Enum.flat_map(fn
            {:text, text} ->
              [text]
            _ ->
              []
          end)
      end)
      |> find_images

    parsed
    |> Enum.map(fn tree ->
      tree
      |> Enum.map(fn
        {:text, text} ->
          text
          |> replacement_entities()
          |> replacement_images(conn, images)

        {_k, markup} ->
          markup
      end)
      |> Enum.join()
    end)
  end

  defp replacement_entities(t) do
    t
    |> String.replace("->", "→")
    |> String.replace("--", "—")
    |> String.replace("...", "…")
    |> String.replace(~r|(\s)-(\s)|, "\\1—\\2")
    |> String.replace("(tm)", "&tm;")
    |> String.replace("(c)", "©")
    |> String.replace("(r)", "®")
    |> String.replace("'", "’")
  end

  defp replacement_images(t, conn, images) do
    t
    |> String.replace(~r|>>(\d+)([pts])?|, fn match ->
      # Stupid, but the method doesn't give us capture group information
      match_data = Regex.run(~r|>>(\d+)([pts])?|, match, capture: :all_but_first)
      [image_id | rest] = match_data
      image = images[String.to_integer(image_id)]

      case [image | rest] do
        [nil, _] ->
          match

        [nil] ->
          match

        [image, "p"] ->
          Phoenix.View.render(@image_view, "_image_target.html", image: image, size: :medium, conn: conn)
          |> safe_to_string()

        [image, "t"] ->
          Phoenix.View.render(@image_view, "_image_target.html", image: image, size: :small, conn: conn)
          |> safe_to_string()

        [image, "s"] ->
          Phoenix.View.render(@image_view, "_image_target.html", image: image, size: :thumb_small, conn: conn)
          |> safe_to_string()

        [image] ->
          link(">>#{image.id}", to: "/#{image.id}")
          |> safe_to_string()
      end
    end)
  end

  defp find_images(text_segments) do
    text_segments
    |> Enum.flat_map(fn t ->
      Regex.scan(~r|>>(\d+)|, t, capture: :all_but_first)
      |> Enum.map(fn [first] -> String.to_integer(first) end)
    end)
    |> find_image_ids()
  end

  defp find_image_ids([]), do: %{}
  defp find_image_ids(image_ids) do
    Image
    |> where([i], i.id in ^image_ids)
    |> where([i], i.hidden_from_users == false)
    |> join(:left, [i], _ in assoc(i, :tags))
    |> preload([_i, t], tags: t)
    |> Repo.all()
    |> Map.new(fn image -> {image.id, image} end)
  end
end