Meeseeks v0.9.1 Meeseeks
Meeseeks is an Elixir library for parsing and extracting data from HTML and XML with CSS or XPath selectors.
import Meeseeks.CSS
html = HTTPoison.get!("https://news.ycombinator.com/").body
for story <- Meeseeks.all(html, css("tr.athing")) do
title = Meeseeks.one(story, css(".title a"))
%{title: Meeseeks.text(title),
url: Meeseeks.attr(title, "href")}
end
#=> [%{title: "...", url: "..."}, %{title: "...", url: "..."}, ...]
Dependencies
Meeseeks depends on html5ever via meeseeks_html5ever.
Because html5ever is a Rust library, you will need to have the Rust compiler installed.
This dependency is necessary because there are no HTML5 spec compliant parsers written in Elixir/Erlang.
Getting Started
Parse
Start by parsing a source (HTML/XML string or Meeseeks.TupleTree
) into
a Meeseeks.Document
so that it can be queried.
Meeseeks.parse/1
parses the source as HTML, but Meeseeks.parse/2
accepts a second argument of either :html
or :xml
that specifies how
the source is parsed.
document = Meeseeks.parse("<div id=main><p>1</p><p>2</p><p>3</p></div>")
#=> Meeseeks.Document<{...}>
The selection functions accept an unparsed source, parsing it as HTML, but parsing is expensive so parse ahead of time when running multiple selections on the same document.
Select
Next, use one of Meeseeks's selection functions - fetch_all
, all
,
fetch_one
, or one
- to search for nodes.
All these functions accept a queryable (a source, a document, or a
Meeseeks.Result
), one or more Meeseeks.Selector
s, and optionally an
initial context.
all
returns a (possibly empty) list of results representing every node
matching one of the provided selectors, while one
returns a result
representing the first node to match a selector (depth-first) or nil if
there is no match.
fetch_all
and fetch_one
work like all
and one
respectively, but
wrap the result in {:ok, ...}
if there is a match or return
{:error, %Meeseeks.Error{type: :select, reason: :no_match}}
if there is
not.
To generate selectors, use the css
macro provided by Meeseeks.CSS
or
the xpath
macro provided by Meeseeks.XPath
.
import Meeseeks.CSS
result = Meeseeks.one(document, css("#main p"))
#=> #Meeseeks.Result<{ <p>1</p> }>
import Meeseeks.XPath
result = Meeseeks.one(document, xpath("//*[@id='main']//p"))
#=> #Meeseeks.Result<{ <p>1</p> }>
Extract
Retrieve information from the Meeseeks.Result
with an extraction
function.
The extraction functions are attr
, attrs
, data
, dataset
, html
,
own_text
, tag
, text
, tree
.
Meeseeks.tag(result)
#=> "p"
Meeseeks.text(result)
#=> "1"
Meeseeks.tree(result)
#=> {"p", [], ["1"]}
The extraction functions html
and tree
work on Meeseeks.Document
s in
addition to Meeseeks.Result
s.
Meeseeks.html(document)
#=> "<html><head></head><body><div id=\"main\"><p>1</p><p>2</p><p>3</p></div></body></html>"
Custom Selectors
Meeseeks is designed to have extremely extensible selectors, and creating
a custom selector is as easy as defining a struct that implements the
Meeseeks.Selector
behaviour.
defmodule CommentContainsSelector do
use Meeseeks.Selector
alias Meeseeks.Document
defstruct value: ""
def match(selector, %Document.Comment{} = node, _document, _context) do
String.contains?(node.content, selector.value)
end
def match(_selector, _node, _document, _context) do
false
end
end
selector = %CommentContainsSelector{value: "TODO"}
Meeseeks.one("<!-- TODO: Close vuln! -->", selector)
#=> #Meeseeks.Result<{ <!-- TODO: Close vuln! --> }>
To learn more, check the documentation for Meeseeks.Selector
and
Meeseeks.Selector.Combinator
Summary
Functions
Returns [Result, ...]
if one or more nodes in the queryable match a
selector, or []
if none do
Returns the value of an attribute in a result, or nil if there isn't one
Returns a result's attributes list, which may be empty, or nil if the result represents a node without attributes
Returns the combined data of a result or the result's children, which may be an empty string
Returns a map of a result's data attributes, or nil if the result represents a node without attributes
Returns {:ok, [Result, ...]}
if one of more nodes in the queryable match
a selector, or {:error, %Meeseeks.Error{type: :select, reason: :no_match}}
if none do
Returns {:ok, Result}
for the first node in the queryable (depth-first)
matching a selector, or
{:error, %Meeseeks.Error{type: :select, reason: :no_match}}
if none do
Returns a string representing the combined HTML of a document or result and its descendants
Returns a Result
for the first node in the queryable (depth-first)
matching a selector, or nil
if none do
Returns the combined text of a result or the result's children, which may be an empty string
Parses a string or Meeseeks.TupleTree
into a Meeseeks.Document
Returns the accumulated result of walking the queryable, accumulating nodes
that match a selector. Prefer all
or one
- select
should only be used
when a custom accumulator is required
Returns a result's tag, or nil
if the result represents a node without a
tag
Returns the combined text of a result or the result's descendants, which may be an empty string
Returns the Meeseeks.TupleTree
of a document or result and its
descendants
Types
Functions
all(queryable, selectors) :: [Meeseeks.Result.t] | {:error, Meeseeks.Error.t}
Returns [Result, ...]
if one or more nodes in the queryable match a
selector, or []
if none do.
Optionally accepts a Meeseeks.Context
map.
Parses the source if it is not a Meeseeks.Document
or Meeseeks.Result
,
and may return {:error, %Meeseeks.Error{type: parser}
if there is a parse
error.
If multiple selections are being ran on the same unparsed source, parse first to avoid unnecessary computation.
Examples
iex> import Meeseeks.CSS
iex> Meeseeks.all("<div id=main><p>1</p><p>2</p><p>3</p></div>", css("#main p")) |> List.first()
#Meeseeks.Result<{ <p>1</p> }>
all(queryable, selectors, Meeseeks.Context.t) :: [Meeseeks.Result.t] | {:error, Meeseeks.Error.t}
Returns the value of an attribute in a result, or nil if there isn't one.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div id=example>Hi</div>", css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.attr(result, "id")
"example"
Returns a result's attributes list, which may be empty, or nil if the result represents a node without attributes.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div id=example>Hi</div>", css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.attrs(result)
[{"id", "example"}]
Returns the combined data of a result or the result's children, which may be an empty string.
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
.
Examples
iex> import Meeseeks.CSS
iex> result1 = Meeseeks.one("<div id=example>Hi</div>", css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.data(result1)
""
iex> result2 = Meeseeks.one("<script id=example>Hi</script>", css("#example"))
#Meeseeks.Result<{ <script id="example">Hi</script> }>
iex> Meeseeks.data(result2)
"Hi"
Returns a map of a result's data attributes, or nil if the result represents a node without attributes.
Behaves like HTMLElement.dataset; only valid data attributes are included, and attribute names have "data-" removed and are converted to camelCase.
See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dataset
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div id=example data-x-val=1 data-y-val=2></div>", css("#example"))
#Meeseeks.Result<{ <div id="example" data-x-val="1" data-y-val="2"></div> }>
iex> Meeseeks.dataset(result)
%{"xVal" => "1", "yVal" => "2"}
fetch_all(queryable, selectors) :: {:ok, [Meeseeks.Result.t]} | {:error, Meeseeks.Error.t}
Returns {:ok, [Result, ...]}
if one of more nodes in the queryable match
a selector, or {:error, %Meeseeks.Error{type: :select, reason: :no_match}}
if none do.
Optionally accepts a Meeseeks.Context
map.
Parses the source if it is not a Meeseeks.Document
or Meeseeks.Result
,
and may return {:error, %Meeseeks.Error{type: parser}
if there is a parse
error.
If multiple selections are being ran on the same unparsed source, parse first to avoid unnecessary computation.
Examples
iex> import Meeseeks.CSS
iex> Meeseeks.fetch_all("<div id=main><p>1</p><p>2</p><p>3</p></div>", css("#main p")) |> elem(1) |> List.first()
#Meeseeks.Result<{ <p>1</p> }>
fetch_all(queryable, selectors, Meeseeks.Context.t) :: {:ok, [Meeseeks.Result.t]} | {:error, Meeseeks.Error.t}
fetch_one(queryable, selectors) :: {:ok, Meeseeks.Result.t} | {:error, Meeseeks.Error.t}
Returns {:ok, Result}
for the first node in the queryable (depth-first)
matching a selector, or
{:error, %Meeseeks.Error{type: :select, reason: :no_match}}
if none do.
Optionally accepts a Meeseeks.Context
map.
Parses the source if it is not a Meeseeks.Document
or Meeseeks.Result
,
and may return {:error, %Meeseeks.Error{type: parser}
if there is a parse
error.
If multiple selections are being ran on the same unparsed source, parse first to avoid unnecessary computation.
Examples
iex> import Meeseeks.CSS
iex> Meeseeks.fetch_one("<div id=main><p>1</p><p>2</p><p>3</p></div>", css("#main p")) |> elem(1)
#Meeseeks.Result<{ <p>1</p> }>
fetch_one(queryable, selectors, Meeseeks.Context.t) :: {:ok, Meeseeks.Result.t} | {:error, Meeseeks.Error.t}
Returns a string representing the combined HTML of a document or result and its descendants.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> document = Meeseeks.parse("<div id=example>Hi</div>")
iex> Meeseeks.html(document)
"<html><head></head><body><div id=\"example\">Hi</div></body></html>"
iex> result = Meeseeks.one(document, css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.html(result)
"<div id=\"example\">Hi</div>"
one(queryable, selectors) :: Meeseeks.Result.t | nil | {:error, Meeseeks.Error.t}
Returns a Result
for the first node in the queryable (depth-first)
matching a selector, or nil
if none do.
Optionally accepts a Meeseeks.Context
map.
Parses the source if it is not a Meeseeks.Document
or Meeseeks.Result
,
and may return {:error, %Meeseeks.Error{type: parser}
if there is a parse
error.
If multiple selections are being ran on the same unparsed source, parse first to avoid unnecessary computation.
Examples
iex> import Meeseeks.CSS
iex> Meeseeks.one("<div id=main><p>1</p><p>2</p><p>3</p></div>", css("#main p"))
#Meeseeks.Result<{ <p>1</p> }>
one(queryable, selectors, Meeseeks.Context.t) :: Meeseeks.Result.t | nil | {:error, Meeseeks.Error.t}
Returns the combined text of a result or the result's children, which may be an empty string.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div>Hello, <b>World!</b></div>", css("div"))
#Meeseeks.Result<{ <div>Hello, <b>World!</b></div> }>
iex> Meeseeks.own_text(result)
"Hello,"
Parses a string or Meeseeks.TupleTree
into a Meeseeks.Document
.
parse/1
parses as HTML, while parse/2
accepts a second argument of
either :html
or :xml
that specifies how the source is parsed.
Examples
iex> Meeseeks.parse("<div id=main><p>Hello, Meeseeks!</p></div>")
#Meeseeks.Document<{...}>
iex> Meeseeks.parse({"div", [{"id", "main"}], [{"p", [], ["Hello, Meeseeks!"]}]})
#Meeseeks.Document<{...}>
iex> Meeseeks.parse("<book><author>GGK</author></book>", :xml)
#Meeseeks.Document<{...}>
parse(Meeseeks.Parser.source, Meeseeks.Parser.type) :: Meeseeks.Document.t | {:error, Meeseeks.Error.t}
select(queryable, selectors, Meeseeks.Context.t) :: any | {:error, Meeseeks.Error.t}
Returns the accumulated result of walking the queryable, accumulating nodes
that match a selector. Prefer all
or one
- select
should only be used
when a custom accumulator is required.
Requires that a Meeseeks.Accumulator
has been added to the context via
Meeseeks.Context.add_accumulator/2
, and will raise an error if it hasn't.
Parses the source if it is not a Meeseeks.Document
or Meeseeks.Result
,
and may return {:error, %Meeseeks.Error{type: parser}
if there is a parse
error.
If multiple selections are being ran on the same unparsed source, parse first to avoid unnecessary computation.
Examples
iex> import Meeseeks.CSS
iex> accumulator = %Meeseeks.Accumulator.One{}
iex> context = Meeseeks.Context.add_accumulator(%{}, accumulator)
iex> Meeseeks.select("<div id=main><p>1</p><p>2</p><p>3</p></div>", css("#main p"), context)
#Meeseeks.Result<{ <p>1</p> }>
Returns a result's tag, or nil
if the result represents a node without a
tag.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div id=example>Hi</div>", css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.tag(result)
"div"
Returns the combined text of a result or the result's descendants, which may be an empty string.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> result = Meeseeks.one("<div>Hello, <b>World!</b></div>", css("div"))
#Meeseeks.Result<{ <div>Hello, <b>World!</b></div> }>
iex> Meeseeks.text(result)
"Hello, World!"
Returns the Meeseeks.TupleTree
of a document or result and its
descendants.
Nil input returns nil
.
Examples
iex> import Meeseeks.CSS
iex> document = Meeseeks.parse("<div id=example>Hi</div>")
iex> Meeseeks.tree(document)
[{"html", [],
[{"head", [], []},
{"body", [], [{"div", [{"id", "example"}], ["Hi"]}]}]}]
iex> result = Meeseeks.one(document, css("#example"))
#Meeseeks.Result<{ <div id="example">Hi</div> }>
iex> Meeseeks.tree(result)
{"div", [{"id", "example"}], ["Hi"]}