Remove json parsing

.formatter.exs

@@ -0,0 +1,5 @@
+[
+  import_deps: [],
+  inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"],
+  subdirectories: []
+]

README.md

@@ -2,4 +2,95 @@
 
 Draft is a module that parses a JSON representation of [Draft.js](https://facebook.github.io/draft-js/) `convertToRaw` output and turns it into HTML.
 
-It is very work in progress.
+## Usage
+
+You can `use Draft` in your module, and then extend it with custom 
+`process_block`, `process_style`, and `process_entity` function signatures
+
+```elixir
+  # define your draft module
+  defmodule MyCustomDraft do
+    use Draft
+
+
+    def process_block(%{"type" => "atomic",
+                        "text" => "",
+                        "key" => _,
+                        "data" => %{"type" => "image", "url" => url},
+                        "depth" => _,
+                        "entityRanges" => _,
+                        "inlineStyleRanges" => _}, _) do
+      "<img src='#{url}' />"
+    end
+  end
+
+  # somewhere else you can pass your custom draft map to `to_html`
+  input = %{
+    "entityMap"=>%{},
+    "blocks"=>[
+      %{"key"=>"9d21d",
+        "text"=>"Hello",
+        "type"=>"header-one",
+        "depth"=>0,
+        "inlineStyleRanges"=>[],
+        "entityRanges"=>[],
+        "data"=>%{}}
+      %{"key"=>"d12d9",
+        "text"=>"",
+        "type"=>"atomic",
+        "depth"=>0,
+        "inlineStyleRanges"=>[],
+        "entityRanges"=>[],
+        "data"=>%{
+          "type"=>"atomic",
+          "url"=>"https://uploads.digitalonboarding.com/do_logo_long.png"}}]}
+
+  MyCustomDraft.to_html(input)
+```
+
+You can pass a third variable for context that your custom processors can hook 
+into.
+
+```elixir
+  # capture the relevant context vars in your custom processors
+  defmodule MyCustomDraft do
+    use Draft
+
+
+    def process_block(%{"type" => "atomic",
+                        "text" => "",
+                        "key" => _,
+                        "data" => %{"type" => "image", "url" => url},
+                        "depth" => _,
+                        "entityRanges" => _,
+                        "inlineStyleRanges" => _}, [user: user]) do
+      "<img src='#{url}' alt='#{user.name}' />"
+    end
+  end
+
+  # somewhere else you can pass any number of vars as the third argument
+
+  user = %{name: "Pablo"}
+
+  input = %{
+    "entityMap"=>%{},
+    "blocks"=>[
+      %{"key"=>"9d21d",
+        "text"=>"Hello",
+        "type"=>"header-one",
+        "depth"=>0,
+        "inlineStyleRanges"=>[],
+        "entityRanges"=>[],
+        "data"=>%{}}
+      %{"key"=>"d12d9",
+        "text"=>"",
+        "type"=>"atomic",
+        "depth"=>0,
+        "inlineStyleRanges"=>[],
+        "entityRanges"=>[],
+        "data"=>%{
+          "type"=>"atomic",
+          "url"=>"https://uploads.digitalonboarding.com/do_logo_long.png"}}]}
+
+  MyCustomDraft.to_html(input, user: user)
+```

lib/draft.ex

@@ -1,35 +1,67 @@
 defmodule Draft do
-  @moduledoc """
-  Provides functions for parsing DraftJS content.
-  """
-
-  @doc """
-  Parses the given DraftJS input and returns the blocks as a list of
-  maps.
-
-  ## Examples
-      iex> draft = ~s({"entityMap":{},"blocks":[{"key":"1","text":"Hello","type":"unstyled","depth":0,"inlineStyleRanges":[],"entityRanges":[],"data":{}}]})
-      iex> Draft.blocks draft
-      [%{"key" => "1", "text" => "Hello", "type" => "unstyled",
-         "depth" => 0,  "inlineStyleRanges" => [], "entityRanges" => [],
-         "data" => %{}}]
-  """
-  def blocks(input) do
-    Poison.Parser.parse!(input)["blocks"]
-  end
+  defmacro __using__(_) do
+    quote do
+      @moduledoc """
+      Provides functions for parsing DraftJS content.
+      """
 
-  @doc """
-  Renders the given DraftJS input as html.
+      @doc """
+      Renders the given DraftJS input as html.
 
-  ## Examples
-      iex> draft = ~s({"entityMap":{},"blocks":[{"key":"1","text":"Hello","type":"unstyled","depth":0,"inlineStyleRanges":[],"entityRanges":[],"data":{}}]})
+      ## Examples
+      iex> draft = %{"entityMap"=>%{},"blocks"=>[%{"key"=>"1","text"=>"Hello","type"=>"unstyled","depth"=>0,"inlineStyleRanges"=>[],"entityRanges"=>[],"data"=>%{}}]}
       iex> Draft.to_html draft
       "<p>Hello</p>"
-  """
-  def to_html(input) do
-    input
-      |> blocks
-      |> Enum.map(&Draft.Block.to_html/1)
-      |> Enum.join("")
+      """
+
+      use Draft.Block
+
+      def to_html(input, context \\ []) do
+        entity_map = Map.get(input, "entityMap")
+
+        input
+        |> Map.get("blocks")
+        |> Enum.reduce([], &group_list_items/2)
+        |> Enum.map(&process_block(&1, entity_map, context))
+        |> Enum.join("")
+      end
+
+      @doc """
+      Groups pertinent block types (i.e. ordered and unordered lists), allowing us to define
+      `process_block` signatures for both the wrapper component and their children (see
+      process_block signature for `unordered-list`, it's responsible for rendering its children)
+
+      ## Examples
+      iex> blocks = [%{"key"=>"1","text"=>"Hello","type"=>"unordered-list-item","depth"=>0,"inlineStyleRanges"=>[],"entityRanges"=>[],"data"=>%{}}]
+      iex> Enum.reduce(blocks, [], group_list_items())
+      [%{"type"=>"unordered-list","data"=>%{"children"=>[%{"key"=>"1","text"=>"Hello","type"=>"unordered-list-item","depth"=>0,"inlineStyleRanges"=>[],"entityRanges"=>[],"data"=>%{}}]}}]
+      """
+
+      def group_list_items(block, acc) do
+        case block["type"] do
+          type when type in ["unordered-list-item", "ordered-list-item"] ->
+            list_type = String.replace(block["type"], "-item", "")
+
+            # FIXME: this ignores depth
+            with {last_item, all_but_last_item} when not is_nil(last_item) <-
+                   List.pop_at(acc, length(acc) - 1),
+                 type when type == list_type <- Map.get(last_item, "type") do
+              all_but_last_item ++ [add_block_item_to_previous_list(last_item, block)]
+            else
+              _ -> acc ++ [%{"type" => list_type, "data" => %{"children" => [block]}}]
+            end
+
+          _ ->
+            acc ++ [block]
+        end
+      end
+
+      defp add_block_item_to_previous_list(previous_list, block) do
+        updated_children = previous_list["data"]["children"] ++ [block]
+        updated_data = Map.put(previous_list["data"], "children", updated_children)
+
+        Map.put(previous_list, "data", updated_data)
+      end
+    end
   end
 end

lib/draft/block.ex

@@ -1,68 +1,75 @@
 defmodule Draft.Block do
-  @moduledoc """
-  Converts a single DraftJS block to html.
-  """
+  defmacro __using__(_) do
+    quote do
+      @moduledoc """
+      Converts a single DraftJS block to html.
+      """
 
-  @doc """
-  Renders the given DraftJS input as html.
+      use Draft.Ranges
 
-  ## Examples
-      iex> block = %{"key" => "1", "text" => "Hello", "type" => "unstyled",
-      ...>   "depth" => 0,  "inlineStyleRanges" => [], "entityRanges" => [],
-      ...>   "data" => %{}}
-      iex> Draft.Block.to_html block
-      "<p>Hello</p>"
-  """
-  def to_html(block) do
-    process_block(block)
-  end
+      def process_block(%{"type" => "unstyled", "text" => ""}, _, _) do
+        "<br>"
+      end
 
-  defp process_block(%{"type" => "unstyled",
-                      "text" => "",
-                      "key" => _,
-                      "data" => _,
-                      "depth" => _,
-                      "entityRanges" => _,
-                      "inlineStyleRanges" => _}) do
-    "<br>"
-  end
+      def process_block(
+            %{"type" => "header-" <> header, "text" => text} = block,
+            entity_map,
+            context
+          ) do
+        tag = header_tags()[header]
+        "<#{tag}>#{apply_ranges(block, entity_map, context)}</#{tag}>"
+      end
 
-  defp process_block(%{"type" => "header-" <> header,
-                      "text" => text,
-                      "key" => _,
-                      "data" => _,
-                      "depth" => _,
-                      "entityRanges" => _,
-                      "inlineStyleRanges" => _}) do
-    tag = header_tags[header]
-    "<#{tag}>#{text}</#{tag}>"
-  end
+      def process_block(%{"type" => "blockquote", "text" => text} = block, entity_map, context) do
+        "<blockquote>#{apply_ranges(block, entity_map, context)}</blockquote>"
+      end
 
-  defp process_block(%{"type" => "blockquote",
-                      "text" => text,
-                      "key" => _,
-                      "data" => _,
-                      "depth" => _,
-                      "entityRanges" => _,
-                      "inlineStyleRanges" => _}) do
-    "<blockquote>#{text}</blockquote>"
-  end
+      def process_block(%{"type" => "unstyled", "text" => text} = block, entity_map, context) do
+        "<p>#{apply_ranges(block, entity_map, context)}</p>"
+      end
 
-  defp process_block(%{"type" => "unstyled",
-                      "text" => text,
-                      "key" => _,
-                      "data" => _,
-                      "depth" => _,
-                      "entityRanges" => _,
-                      "inlineStyleRanges" => _}) do
-    "<p>#{text}</p>"
-  end
+      def process_block(
+            %{"type" => "unordered-list", "data" => %{"children" => children}},
+            entity_map,
+            context
+          ) do
+        "<ul>#{Enum.map(children, &process_block(&1, entity_map, context)) |> Enum.join("")}</ul>"
+      end
+
+      def process_block(
+            %{"type" => "ordered-list", "data" => %{"children" => children}},
+            entity_map,
+            context
+          ) do
+        "<ol>#{Enum.map(children, &process_block(&1, entity_map, context)) |> Enum.join("")}</ol>"
+      end
+
+      def process_block(
+            %{"type" => "ordered-list-item", "text" => text} = block,
+            entity_map,
+            context
+          ) do
+        "<li style=\"mso-special-format:numbullet;\">#{apply_ranges(block, entity_map, context)}</li>"
+      end
+
+      def process_block(
+            %{"type" => "unordered-list-item", "text" => text} = block,
+            entity_map,
+            context
+          ) do
+        "<li style=\"mso-special-format:bullet;\">#{apply_ranges(block, entity_map, context)}</li>"
+      end
 
-  defp header_tags do
-    %{
-      "one"   => "h1",
-      "two"   => "h2",
-      "three" => "h3"
-    }
+      def header_tags do
+        %{
+          "one" => "h1",
+          "two" => "h2",
+          "three" => "h3",
+          "four" => "h4",
+          "five" => "h5",
+          "six" => "h6"
+        }
+      end
+    end
   end
 end