First version of Floki with some features

Parsing documents and finding elements by class name

This version also contains:
  - Floki.attribute/2 : get attribute values from parsed elements;
  - Floki.attribute/3 : get attribute values from parsed elements
  with a given class name;
  - Fixed README;
  - MIT license.

Author: philss

.gitignore

@@ -2,3 +2,5 @@
 /deps
 erl_crash.dump
 *.ez
+/tmp
+*.swp

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Philip Sampaio Silva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -1,24 +1,39 @@
 Floki
 =====
 
-Floki parses and query HTML documents using query selectors (like jQuery)
+Floki is useful to search inside HTML documents using query selectors (like jQuery).
+Under the hood, it uses the [Mochiweb](https://github.com/mochi/mochiweb) HTML parser.
+
+This version works with simple CSS class selectors (without nesting or group),
+like `.class-name`.
 
 ## API
 
-To parse a document, try:
+To parse a HTML document, try:
 
 ```elixir
 Floki.parse(html)
 ```
 
-To find elements with the class `js-action`, try:
+To find elements with the class `js-link`, try:
 
 ```elixir
-Floki.find(".js-action", html)
+Floki.find(html, ".js-link")
 ```
 
 To fetch some attribute from elements, try:
 
 ```elixir
-Floki.get_attribute("href", ".js-action", html)
+Floki.attribute(html, ".js-link", "href")
 ```
+
+You can also get attributes from elements that you already have:
+
+```elixir
+Floki.find(html, ".js-link")
+|> Floki.attribute("href")
+```
+
+## License
+
+Floki is under MIT license. Check the `LICENSE` file for more details.

lib/floki.ex

@@ -1,2 +1,63 @@
 defmodule Floki do
+  def parse(html) do
+    :mochiweb_html.parse(html)
+  end
+
+  def find(html, selector) when is_binary(html) do
+    parse(html)
+    |> find(selector)
+  end
+
+  def find(html_tree, "." <> class) do
+    find_by_class(class, html_tree, [])
+    |> Enum.reverse
+  end
+
+  def attribute(html, selector, attribute_name) do
+    html
+    |> find(selector)
+    |> get_attribute_values(attribute_name)
+  end
+
+  def attribute(elements, attribute_name) do
+    elements
+    |> get_attribute_values(attribute_name)
+  end
+
+  def class_match?(attributes, class) do
+    attribute_match?(attributes, "class", class)
+  end
+
+  defp attribute_match?(attributes, attribute_name, value) do
+    Enum.find(attributes, fn(attribute) ->
+      { attr_name, attr_value } = attribute
+
+      attr_name == attribute_name && String.contains?(attr_value, value)
+    end)
+  end
+
+  defp find_by_class(_class, {}, acc), do: acc
+  defp find_by_class(_class, [], acc), do: acc
+  defp find_by_class(_class, tree, acc) when is_binary(tree), do: acc
+  defp find_by_class(class, [h|t], acc) do
+    acc = find_by_class(class, h, acc)
+    find_by_class(class, t, acc)
+  end
+  defp find_by_class(class, { name, attributes, child_node }, acc) do
+    if class_match?(attributes, class) do
+      acc = [{name, attributes, child_node}|acc]
+    end
+
+    find_by_class(class, child_node, acc)
+  end
+
+  def get_attribute_values(elements, attr_name) do
+    Enum.map(elements, fn(el) ->
+      { _name, attributes, _childs } = el
+
+      attribute_match?(attributes, attr_name, "")
+    end)
+    |> Enum.reject(fn(x) -> is_nil(x) end)
+    |> Enum.map(fn({_attr_name, value}) -> value end)
+  end
 end

mix.exs

@@ -25,6 +25,8 @@ defmodule Floki.Mixfile do
   #
   # Type `mix help deps` for more examples and options
   defp deps do
-    []
+    [
+      {:mochiweb, git: "https://github.com/mochi/mochiweb.git", tag: "v2.9.2"}
+    ]
   end
 end

mix.lock

@@ -0,0 +1 @@
+%{"mochiweb": {:git, "https://github.com/mochi/mochiweb.git", "66a6535692da7b8830bd141eee26025af4928b8a", [tag: "v2.9.2"]}}

test/floki_test.exs

@@ -1,7 +1,86 @@
 defmodule FlokiTest do
   use ExUnit.Case
 
-  test "the truth" do
-    assert 1 + 1 == 2
+  @html """
+  <html>
+  <head>
+  <title>Test</title>
+  </head>
+  <body>
+    <div class='content'>
+      <a href='http://google.com' class='js-google js-cool'>Google</a>
+      <a href='http://elixir-lang.org' class='js-elixir js-cool'>Elixir lang</a>
+      <a href='http://java.com' class='js-java'>Java</a>
+    </div>
+  </body>
+  </html>
+  """
+
+  test "parse simple html" do
+    parsed = Floki.parse(@html)
+
+    assert parsed == {"html", [],
+                        [{"head", [], [{"title", [], ["Test"]}]},
+                          {"body", [],
+                            [{"div", [{"class", "content"}],
+                                [{"a", [{"href", "http://google.com"}, {"class", "js-google js-cool"}], ["Google"]},
+                                  {"a", [{"href", "http://elixir-lang.org"}, {"class", "js-elixir js-cool"}], ["Elixir lang"]},
+                                  {"a", [{"href", "http://java.com"}, {"class", "js-java"}], ["Java"]}]}]}]}
+  end
+
+  test "find elements with a given class" do
+    class_selector = ".js-cool"
+
+    assert Floki.find(@html, class_selector) == [{"a", [{"href", "http://google.com"}, {"class", "js-google js-cool"}], ["Google"]},
+      {"a", [{"href", "http://elixir-lang.org"}, {"class", "js-elixir js-cool"}], ["Elixir lang"]}]
+  end
+
+  test "does not find elements" do
+    class_selector = ".nothing"
+
+    assert Floki.find(@html, class_selector) == []
+  end
+
+  test "matching a class by a given name" do
+    class_name = "a-class"
+    attributes = [{"class", class_name}, {"title", "a title"}]
+
+    assert Floki.class_match?(attributes, class_name)
+  end
+
+  test "does not match by class name" do
+    class_name = "a-class"
+    attributes = [{"class", "another-class"}, {"title", "a title"}]
+
+    refute Floki.class_match?(attributes, class_name)
+  end
+
+  test "does not match when attributes list is empty" do
+    class_name = "a-class"
+    attributes = []
+
+    refute Floki.class_match?(attributes, class_name)
+  end
+
+  test "get attribute values from elements with a given class" do
+    class_selector = ".js-cool"
+    expected_hrefs = ["http://google.com", "http://elixir-lang.org"]
+
+    assert Floki.attribute(@html, class_selector, "href") == expected_hrefs
+  end
+
+  test "get attributes from elements" do
+    class_selector = ".js-cool"
+    expected_hrefs = ["http://google.com", "http://elixir-lang.org"]
+    elements = Floki.find(@html, class_selector)
+
+    assert Floki.attribute(elements, "href") == expected_hrefs
+  end
+
+  test "get attributes that does not exist" do
+    class_selector = ".js-cool"
+    elements = Floki.find(@html, class_selector)
+
+    assert Floki.attribute(elements, "title") == []
   end
 end