Merge pull request #72 from mischov/feature/refactor-extractors

Refactor extractors

Author: mischov

lib/meeseeks.ex

@@ -531,13 +531,24 @@ defmodule Meeseeks do
   Returns the combined data of a result or the result's children, which may
   be an empty string.
 
+  Once the data has been combined the whitespace is compacted by replacing
+  all instances of more than one whitespace character with a single space
+  and then trimmed.
+
   Data is the content of `<script>` or `<style>` tags, or the content of
   comments starting with "[CDATA[" and ending with "]]". The latter behavior
   is to support the extraction of CDATA from HTML, since HTML5 parsers parse
   CDATA as comments.
 
   Nil input returns `nil`.
 
+  ## Options
+
+    * `:collapse_whitespace` - Boolean determining whether or not to replace
+      blocks of whitespace with a single space character. Defaults to `true`.
+    * `:trim` - Boolean determining whether or not to trim the resulting
+      text. Defaults to `true`.
+
   ## Examples
 
       iex> import Meeseeks.CSS
@@ -550,11 +561,11 @@ defmodule Meeseeks do
       iex> Meeseeks.data(result2)
       "Hi"
   """
-  @spec data(extractable) :: String.t() | nil
-  def data(extractable)
-  def data(nil), do: nil
-  def data(%Result{} = result), do: Result.data(result)
-  def data(x), do: raise_cannot_extract(x, "data/1")
+  @spec data(extractable, Keyword.t()) :: String.t() | nil
+  def data(extractable, opts \\ [])
+  def data(nil, _), do: nil
+  def data(%Result{} = result, opts), do: Result.data(result, opts)
+  def data(x, _), do: raise_cannot_extract(x, "data/1")
 
   @doc """
   Returns a map of a result's data attributes, or nil if the result
@@ -609,8 +620,19 @@ defmodule Meeseeks do
   Returns the combined text of a result or the result's children, which may
   be an empty string.
 
+  Once the text has been combined the whitespace is compacted by replacing
+  all instances of more than one whitespace character with a single space
+  and then trimmed.
+
   Nil input returns `nil`.
 
+  ## Options
+
+    * `:collapse_whitespace` - Boolean determining whether or not to replace
+      blocks of whitespace with a single space character. Defaults to `true`.
+    * `:trim` - Boolean determining whether or not to trim the resulting
+      text. Defaults to `true`.
+
   ## Examples
 
       iex> import Meeseeks.CSS
@@ -619,11 +641,11 @@ defmodule Meeseeks do
       iex> Meeseeks.own_text(result)
       "Hello,"
   """
-  @spec own_text(extractable) :: String.t() | nil
-  def own_text(extractable)
-  def own_text(nil), do: nil
-  def own_text(%Result{} = result), do: Result.own_text(result)
-  def own_text(x), do: raise_cannot_extract(x, "own_text/1")
+  @spec own_text(extractable, Keyword.t()) :: String.t() | nil
+  def own_text(extractable, opts \\ [])
+  def own_text(nil, _), do: nil
+  def own_text(%Result{} = result, opts), do: Result.own_text(result, opts)
+  def own_text(x, _), do: raise_cannot_extract(x, "own_text/1")
 
   @doc """
   Returns a result's tag, or `nil` if the result represents a node without a
@@ -649,8 +671,19 @@ defmodule Meeseeks do
   Returns the combined text of a result or the result's descendants, which
   may be an empty string.
 
+  Once the text has been combined the whitespace is compacted by replacing
+  all instances of more than one whitespace character with a single space
+  and then trimmed.
+
   Nil input returns `nil`.
 
+  ## Options
+
+    * `:collapse_whitespace` - Boolean determining whether or not to replace
+      blocks of whitespace with a single space character. Defaults to `true`.
+    * `:trim` - Boolean determining whether or not to trim the resulting
+      text. Defaults to `true`.
+
   ## Examples
 
       iex> import Meeseeks.CSS
@@ -659,11 +692,11 @@ defmodule Meeseeks do
       iex> Meeseeks.text(result)
       "Hello, World!"
   """
-  @spec text(extractable) :: String.t() | nil
-  def text(extractable)
-  def text(nil), do: nil
-  def text(%Result{} = result), do: Result.text(result)
-  def text(x), do: raise_cannot_extract(x, "text/1")
+  @spec text(extractable, Keyword.t()) :: String.t() | nil
+  def text(extractable, opts \\ [])
+  def text(nil, _), do: nil
+  def text(%Result{} = result, opts), do: Result.text(result, opts)
+  def text(x, _), do: raise_cannot_extract(x, "text/1")
 
   @doc """
   Returns the `Meeseeks.TupleTree` of a document or result and its

lib/meeseeks/document.ex

@@ -57,7 +57,7 @@ defmodule Meeseeks.Document do
   ```
   """
 
-  alias Meeseeks.{Document, Error}
+  alias Meeseeks.{Document, Error, Extractor}
   alias Meeseeks.Document.{Element, Node}
 
   defstruct id_counter: nil, roots: [], nodes: %{}
@@ -76,9 +76,9 @@ defmodule Meeseeks.Document do
   def html(%Document{} = document) do
     document
     |> get_root_nodes()
-    |> Enum.reduce("", fn root_node, acc ->
-      acc <> Node.html(root_node, document)
-    end)
+    |> Enum.map(&Extractor.Html.from_node(&1, document))
+    |> IO.iodata_to_binary()
+    |> String.trim()
   end
 
   @doc """
@@ -87,7 +87,7 @@ defmodule Meeseeks.Document do
   def tree(%Document{} = document) do
     document
     |> get_root_nodes()
-    |> Enum.map(&Node.tree(&1, document))
+    |> Enum.map(&Extractor.Tree.from_node(&1, document))
   end
 
   # Query

lib/meeseeks/document/comment.ex

@@ -1,17 +1,6 @@
 defmodule Meeseeks.Document.Comment do
-  use Meeseeks.Document.Node
   @moduledoc false
 
   @enforce_keys [:id]
   defstruct parent: nil, id: nil, content: ""
-
-  @impl true
-  def html(node, _document) do
-    "<!--#{node.content}-->"
-  end
-
-  @impl true
-  def tree(node, _document) do
-    {:comment, node.content}
-  end
 end

lib/meeseeks/document/data.ex

@@ -1,29 +1,6 @@
 defmodule Meeseeks.Document.Data do
-  use Meeseeks.Document.Node
   @moduledoc false
 
-  alias Meeseeks.Document.{Data, Helpers}
-
   @enforce_keys [:id]
   defstruct parent: nil, id: nil, type: nil, content: ""
-
-  @impl true
-  def data(node, _document) do
-    Helpers.collapse_whitespace(node.content)
-  end
-
-  @impl true
-  def html(%Data{type: :cdata, content: content}, _document) do
-    "<![CDATA[#{content}]]>"
-  end
-
-  @impl true
-  def html(node, _document) do
-    node.content
-  end
-
-  @impl true
-  def tree(node, _document) do
-    node.content
-  end
 end

lib/meeseeks/document/doctype.ex

@@ -1,22 +1,6 @@
 defmodule Meeseeks.Document.Doctype do
-  use Meeseeks.Document.Node
   @moduledoc false
 
   @enforce_keys [:id]
   defstruct parent: nil, id: nil, name: "", public: "", system: ""
-
-  @impl true
-  def html(node, _document) do
-    "<!DOCTYPE #{node.name}#{format_legacy(node.public, node.system)}>"
-  end
-
-  @impl true
-  def tree(node, _document) do
-    {:doctype, node.name, node.public, node.system}
-  end
-
-  defp format_legacy("", ""), do: ""
-  defp format_legacy(public, ""), do: " PUBLIC \"#{public}\""
-  defp format_legacy("", system), do: " SYSTEM \"#{system}\""
-  defp format_legacy(public, system), do: " PUBLIC \"#{public}\" \"#{system}\""
 end

lib/meeseeks/document/element.ex

@@ -1,152 +1,6 @@
 defmodule Meeseeks.Document.Element do
-  use Meeseeks.Document.Node
   @moduledoc false
 
-  alias Meeseeks.Document
-  alias Meeseeks.Document.Helpers
-
   @enforce_keys [:id]
   defstruct parent: nil, id: nil, namespace: "", tag: "", attributes: [], children: []
-
-  @self_closing_tags [
-    "area",
-    "base",
-    "br",
-    "col",
-    "command",
-    "embed",
-    "hr",
-    "img",
-    "input",
-    "keygen",
-    "link",
-    "meta",
-    "param",
-    "source",
-    "track",
-    "wbr"
-  ]
-
-  @impl true
-  def attr(node, attribute) do
-    {_attr, value} = List.keyfind(node.attributes, attribute, 0, {nil, nil})
-    value
-  end
-
-  @impl true
-  def attrs(node) do
-    node.attributes
-  end
-
-  @impl true
-  def data(node, document) do
-    child_nodes(document, node)
-    |> Enum.filter(&data_node?/1)
-    |> Enum.reduce("", &join_data(&1, &2, document))
-    |> Helpers.collapse_whitespace()
-  end
-
-  @impl true
-  def html(node, document) do
-    if node.tag in @self_closing_tags and node.children == [] do
-      self_closing_tag(node)
-    else
-      opening_tag(node) <> child_html(node, document) <> closing_tag(node)
-    end
-  end
-
-  @impl true
-  def own_text(node, document) do
-    child_nodes(document, node)
-    |> Enum.filter(&text_node?/1)
-    |> Enum.reduce("", &join_text(&1, &2, document))
-    |> Helpers.collapse_whitespace()
-  end
-
-  @impl true
-  def tag(node) do
-    node.tag
-  end
-
-  @impl true
-  def text(node, document) do
-    child_nodes(document, node)
-    |> Enum.reduce("", &join_text(&1, &2, document))
-    |> Helpers.collapse_whitespace()
-  end
-
-  @impl true
-  def tree(node, document) do
-    child_nodes = child_nodes(document, node)
-    {node.tag, node.attributes, Enum.map(child_nodes, &Document.Node.tree(&1, document))}
-  end
-
-  # Helpers
-
-  defp self_closing_tag(node) do
-    tag = full_tag(node.namespace, node.tag)
-    attributes = join_attributes(node.attributes)
-    "<#{tag}#{attributes} />"
-  end
-
-  defp opening_tag(node) do
-    tag = full_tag(node.namespace, node.tag)
-    attributes = join_attributes(node.attributes)
-    "<#{tag}#{attributes}>"
-  end
-
-  defp child_html(node, document) do
-    child_nodes(document, node)
-    |> Enum.reduce("", &join_html(&1, &2, document))
-  end
-
-  defp closing_tag(node) do
-    tag = full_tag(node.namespace, node.tag)
-    "</#{tag}>"
-  end
-
-  defp full_tag("", tag), do: tag
-  defp full_tag(ns, tag), do: ns <> ":" <> tag
-
-  defp child_nodes(document, node) do
-    children = Document.children(document, node.id)
-
-    Document.get_nodes(document, children)
-  end
-
-  defp data_node?(%Document.Data{}), do: true
-  defp data_node?(_), do: false
-
-  defp text_node?(%Document.Text{}), do: true
-  defp text_node?(_), do: false
-
-  defp join_attributes([]) do
-    ""
-  end
-
-  defp join_attributes(attributes) do
-    Enum.reduce(attributes, "", &join_attribute(&1, &2))
-  end
-
-  defp join_attribute({attribute, value}, acc) do
-    "#{acc} #{attribute}=\"#{Helpers.html_escape_attribute_value(value)}\""
-  end
-
-  defp join_data(node, acc, document) do
-    case Document.Node.data(node, document) do
-      "" -> acc
-      data -> "#{acc} #{data}"
-    end
-  end
-
-  defp join_html(node, acc, document) do
-    acc <> Document.Node.html(node, document)
-  end
-
-  defp join_text(node, acc, document) do
-    case Document.Node.text(node, document) do
-      "" -> acc
-      text -> "#{acc} #{text}"
-    end
-  end
 end