### Extracting Attributes with Floki.attribute/2 - Elixir

Source: https://context7_llms

These examples demonstrate Floki.attribute/2, which extracts a list of attribute values from elements. It takes the HTML structure and the attribute name, returning a list of corresponding values.

```Elixir
iex> Floki.attribute([{"a", [{"href", "https://google.com"}], ["Google"]}], "href")
    ["https://google.com"]

iex> Floki.attribute([{"a", [{"href", "https://google.com"}, {"data-name", "google"}], ["Google"]}], "data-name")
    ["google"]
```

--------------------------------

### Querying HTML Nodes with Floki.find/2 - Elixir

Source: https://context7_llms

These examples illustrate various ways to query the parsed HTML document using Floki.find/2 with different CSS selectors, including ID, class, tag name, attribute selectors, and combined selectors.

```Elixir
Floki.find(html, "#content")
Floki.find(html, ".headline")
Floki.find(html, "a")
Floki.find(html, "[data-model=user]")
Floki.find(html, "#content a")
Floki.find(html, ".headline, a")
```

--------------------------------

### Parsing HTML Document with Floki.parse_document! (Elixir)

Source: https://context7_llms

This example demonstrates `Floki.parse_document!/2`, a variant of `Floki.parse_document/1` that parses an HTML string. Unlike its counterpart, this function raises a `Floki.ParseError` if any error occurs during the parsing process, making it suitable for scenarios where immediate error feedback is desired.

```Elixir
Floki.parse_document!("    hello  ")
```

--------------------------------

### Finding Elements with Floki.find/2 (from fragment) - Elixir

Source: https://context7_llms

These examples demonstrate Floki.find/2 for locating elements within an HTML tree or string, often after parsing a fragment. It shows how to find elements using various CSS selectors like class, ID, and tag name, and also nested selectors.

```Elixir
iex> {:ok, html} = Floki.parse_fragment("  hello  ")
    iex> Floki.find(html, ".hint")
    [{"span", [{"class", "hint"}], ["hello"]}]

iex> {:ok, html} = Floki.parse_fragment("  Content  ")
    iex> Floki.find(html, "#important")
    [{"div", [{"id", "important"}], [{"div", [], ["Content"]}]}]

iex> {:ok, html} = Floki.parse_fragment("  Google  ")
    iex> Floki.find(html, "a")
    [{"a", [{"href", "https://google.com"}], ["Google"]}]

iex> Floki.find([{ "div", [], [{"a", [{"href", "https://google.com"}], ["Google"]}]}], "div a")
    [{"a", [{"href", "https://google.com"}], ["Google"]}]
```

--------------------------------

### Extracting Attributes with Floki.attribute/3 (with selector) - Elixir

Source: https://context7_llms

These examples illustrate Floki.attribute/3, which extracts attribute values for elements matching a given CSS selector. It takes the HTML structure, selector, and attribute name, returning a list of values.

```Elixir
iex> Floki.attribute([{"a", [{"href", "https://google.com"}], ["Google"]}], "a", "href")
    ["https://google.com"]

iex> Floki.attribute(
    [{"a", [{"class", "foo"}, {"href", "https://google.com"}], ["Google"]}],
    "a",
    "class"
)
    ["foo"]

iex> Floki.attribute(
    [{"a", [{"href", "https://e.corp.com"}, {"data-name", "e.corp"}], ["E.Corp"]}],
    "a[data-name]",
    "data-name"
)
    ["e.corp"]
```

--------------------------------

### Escaping Strings for CSS Identifiers with Floki.css_escape/1 - Elixir

Source: https://context7_llms

These examples demonstrate Floki.css_escape/1, which escapes a given string to make it safe for use as a CSS identifier. This is crucial for handling strings with special characters in CSS selectors.

```Elixir
iex> Floki.css_escape("hello world")
    "hello\\ world"

iex> Floki.css_escape("-123")
    "-\\31 23"
```

--------------------------------

### Finding HTML Element by ID with Floki.get_by_id (Elixir)

Source: https://context7_llms

This example illustrates `Floki.get_by_id/2`, which finds the first HTML element by its ID within a given HTML tree. It's particularly useful for IDs containing special characters that might be invalid in standard CSS selectors. The function returns the element if found, otherwise `nil`.

```Elixir
{:ok, html} = Floki.parse_fragment(~s[<span class="hint" id="id?foo_special:chars">  hello  </span>])
Floki.get_by_id(html, "id?foo_special:chars")
Floki.get_by_id(html, "does-not-exist")
```

--------------------------------

### Changing Attributes with Floki.attr/4 - Elixir

Source: https://context7_llms

These examples show how to use Floki.attr/4 to modify attribute values of elements matched by a CSS selector. It takes the HTML structure, selector, attribute name, and a mutation function, returning the updated element tree.

```Elixir
iex> Floki.attr([{"div", [{"id", "a"}], []}], "#a", "id", fn(id) -> String.replace(id, "a", "b") end)
    [{"div", [{"id", "b"}], []}]

iex> Floki.attr([{"div", [{"class", "name"}], []}], "div", "id", fn _ -> "b" end)
    [{"div", [{"id", "b"}, {"class", "name"}], []}]
```

--------------------------------

### Filtering Out Nodes with Floki.filter_out/2 - Elixir

Source: https://context7_llms

These examples illustrate Floki.filter_out/2, which removes nodes from an HTML tree that match a specified filter selector. It can filter by tag name, and even by special types like :comment or :text.

```Elixir
iex> Floki.filter_out({"div", [], [{"script", [], ["hello"]}, " world"]}, "script")
    {"div", [], [" world"]}

iex> Floki.filter_out([{"body", [], [{"script", [], []}, {"div", [], []}]}], "script")
    [{"body", [], [{"div", [], []}]}]

iex> Floki.filter_out({"div", [], [{:comment, "comment"}, " text"]}, :comment)
    {"div", [], [" text"]}

iex> Floki.filter_out({"div", [], ["text"]}, :text)
    {"div", [], []}
```

--------------------------------

### Accessing Child Nodes with Floki.children/2 - Elixir

Source: https://context7_llms

These examples show how Floki.children/2 retrieves the direct child nodes of an HTML node. It can optionally exclude text nodes using the include_text: false option and returns nil if the node is not an HTML tag.

```Elixir
iex> Floki.children({"div", [], ["text", {"span", [], []}]})
    ["text", {"span", [], []}]

iex> Floki.children({"div", [], ["text", {"span", [], []}]}, include_text: false)
    [{"span", [], []}]

iex> Floki.children({:comment, "comment"})
    nil
```

--------------------------------

### Deleting Span Tags and Counting with Floki.traverse_and_update/3 (Elixir)

Source: https://context7_llms

This example illustrates using Floki.traverse_and_update/3 to remove specific HTML tags (e.g., 'span' tags) from a tree. It also uses an accumulator to count the number of deleted nodes, returning 'nil' for the node to be deleted.

```Elixir
html = {"div", [], [{"span", [], ["hello"]}]}
Floki.traverse_and_update(html, [deleted: 0], fn
  {"span", _attrs, _children}, acc ->
    {nil, Keyword.put(acc, :deleted, acc[:deleted] + 1)}
  tag, acc ->
    {tag, acc}
end)
```

--------------------------------

### Configuring Floki HTML Parser (Elixir)

Source: https://context7_llms

This snippet shows two ways to configure the HTML parser in Floki. The first line demonstrates setting the parser for a single function call using the ':html_parser' option, while the second block shows how to set a global default parser for the ':floki' application using Mix.Config.

```Elixir
Floki.parse_document(document, html_parser: Floki.HTMLParser.FastHtml)

# Or:
use Mix.Config
config :floki, :html_parser, Floki.HTMLParser.Mochiweb
```

--------------------------------

### Sample HTML Document for Floki Parsing

Source: https://context7_llms

This HTML snippet represents a typical document structure that can be parsed and queried using the Floki library. It includes various elements with IDs, classes, and data attributes, demonstrating common HTML features.

```HTML
<!doctype html>
<html>
  <body>
    <section id="content">
      <p class="headline">Floki</p>
      <a href="http://github.com/philss/floki">Github page</a>
      <span data-model="user">philss</span>
    </section>
  </body>
</html>
```

--------------------------------

### Pretty Formatting HTML Output with Floki.raw_html/2 in Elixir

Source: https://context7_llms

Demonstrates using the `:pretty` option in `Floki.raw_html/2` to format the output HTML, ignoring original whitespace and adding newlines for readability. Useful for generating human-readable HTML.

```Elixir
Floki.raw_html({"div", [], ["\n   ", {"span", [], "Fully indented"}, "    \n"]}, pretty: true)
```

--------------------------------

### Converting HTML Tree to Raw HTML in Elixir

Source: https://context7_llms

Demonstrates the basic usage of `Floki.raw_html/2` to convert a simple HTML tuple structure into its raw HTML string representation. Shows how a `div` with content is rendered.

```Elixir
Floki.raw_html({"div", [{"class", "wrapper"}], ["my content"]})
```

--------------------------------

### Parsing HTML Document with Floki.parse_document (Elixir)

Source: https://context7_llms

This snippet shows how to parse a full HTML document string into an HTML tree using `Floki.parse_document/2`. It demonstrates parsing a simple string and applying options like `html_parser` to specify the backend parser and `attributes_as_maps` to represent attributes as maps instead of lists.

```Elixir
Floki.parse_document("    hello  ")
Floki.parse_document("    hello  ", html_parser: Floki.HTMLParser.Mochiweb)
Floki.parse_document(
  "    hello  ",
  attributes_as_maps: true,
  html_parser: Floki.HTMLParser.Mochiweb
)
```

--------------------------------

### Including Style Tag Content with Floki.text/2 in Elixir

Source: https://context7_llms

Demonstrates using the `:style` option set to `true` with `Floki.text/2` to include the content of `<style>` tags in the extracted text, useful for analyzing embedded CSS.

```Elixir
Floki.text({"div", [], [{"style", [], ["hello"]}, " world"]}, style: true)
```

--------------------------------

### Parsing HTML Document with Floki.parse_document/1 - Elixir

Source: https://context7_llms

This Elixir code demonstrates how to parse an HTML document string into a Floki-compatible data structure using Floki.parse_document/1. The function returns a tuple {:ok, html} where html is the parsed representation of the HTML.

```Elixir
{:ok, html} = Floki.parse_document(doc)
# =>
# [{"html", [],
#   [
#     {"body", [],
#      [
#        {"section", [{"id", "content"}],
#         [
#           {"p", [{"class", "headline"}], ["Floki"]},
#           {"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]},
#           {"span", [{"data-model", "user"}], ["philss"]}
#         ]}
#      ]}
#   ]}]
```

--------------------------------

### Including Input Field Values with Floki.text/2 in Elixir

Source: https://context7_llms

Shows how to use the `:include_inputs` option set to `true` with `Floki.text/2` to include the `value` attribute of `<input>` tags in the extracted text.

```Elixir
Floki.text([{"input", [{"type", "date"}, {"value", "2017-06-01"}], []}], include_inputs: true)
```

--------------------------------

### Including Script Tag Content with Floki.text/2 in Elixir

Source: https://context7_llms

Demonstrates using the `:js` option set to `true` with `Floki.text/2` to include the content of `<script>` tags in the extracted text, useful for analyzing embedded JavaScript.

```Elixir
Floki.text({"div", [], [{"script", [], ["hello"]}, " world"]}, js: true)
```

--------------------------------

### Updating HTML Tag Name with Floki.traverse_and_update/2 in Elixir

Source: https://context7_llms

Shows how to use `Floki.traverse_and_update/2` to transform a `div` tag into a `p` tag. The function receives the node tuple and returns a modified one, demonstrating basic node transformation.

```Elixir
html = [{"div", [], ["hello"]}]
Floki.traverse_and_update(html, fn
  {"div", attrs, children} -> {"p", attrs, children}
  other -> other
end)
```

--------------------------------

### Updating HTML Elements with Floki.find_and_update (Elixir)

Source: https://context7_llms

This snippet demonstrates how to use `Floki.find_and_update/3` to search for HTML elements matching a CSS selector and apply a transformation function to their tag and attributes. The function returns the updated HTML tree. If the provided function returns `:delete`, the matching node is removed.

```Elixir
Floki.find_and_update([{"a", [{"href", "http://elixir-lang.com"}], ["Elixir"]}], "a", fn
  {"a", [{"href", href}]} ->
    {"a", [{"href", String.replace(href, "http://", "https://")}]}
  other ->
    other
end)
```

--------------------------------

### Encoding HTML Entities with Floki.raw_html/2 in Elixir

Source: https://context7_llms

Illustrates how `Floki.raw_html/2` automatically encodes special HTML characters (like `>`) into HTML entities (`&gt;`) by default. This ensures valid HTML output.

```Elixir
Floki.raw_html({"div", [{"class", "wrapper"}], ["10 > 5"]})
```

--------------------------------

### Extracting Text from a List of HTML Nodes with Floki.text/2 in Elixir

Source: https://context7_llms

Shows that `Floki.text/2` can accept a list of HTML nodes as input and extract text from all of them, concatenating the results.

```Elixir
Floki.text([{"div", [], ["hello world"]}])
```

--------------------------------

### Transforming Div Tags to Paragraphs with Floki.traverse_and_update/3 (Elixir)

Source: https://context7_llms

This snippet demonstrates how to use Floki.traverse_and_update/3 to transform 'div' HTML tags into 'p' tags. It adds a 'data-count' attribute to each new 'p' tag, incrementing an accumulator for each transformation, while preserving other nodes.

```Elixir
html = [{"div", [], [{:comment, "I am a comment"}, "hello"]}, {"div", [], ["world"]}]
Floki.traverse_and_update(html, 0, fn
  {"div", attrs, children}, acc ->
    {{"p", [{"data-count", to_string(acc)} | attrs], children}, acc + 1}
  other, acc -> {other, acc}
end)
```

--------------------------------

### Using Custom Separator for Text Nodes with Floki.text/2 in Elixir

Source: https://context7_llms

Illustrates how to specify a custom separator string using the `:sep` option in `Floki.text/2`, which is inserted between the text content of different nodes.

```Elixir
Floki.text({"ul", [], [{"li", [], ["hello"]}, {"li", [], ["world"]}]}, sep: "-")
```

--------------------------------

### Shallow Text Extraction with Floki.text/2 in Elixir

Source: https://context7_llms

Demonstrates using the `:deep` option set to `false` with `Floki.text/2` to extract text only from the immediate children of the given HTML node, ignoring nested elements.

```Elixir
Floki.text({"div", [], [{"span", [], ["hello"]}, " world"]}, deep: false)
```

--------------------------------

### Deleting and Transforming Nodes with Floki.traverse_and_update/2 in Elixir

Source: https://context7_llms

Illustrates advanced usage of `Floki.traverse_and_update/2` to delete a `span` node by returning `nil` and transform a comment node into a `span` tag. This demonstrates conditional node manipulation.

```Elixir
html = [{"div", [], [{:comment, "I am comment"}, {"span", [], ["hello"]}]}]
Floki.traverse_and_update(html, fn
  {"span", _attrs, _children} -> nil
  {:comment, text} -> {"span", [], text}
  other -> other
end)
```

--------------------------------

### Extracting Text from Multiple Paragraphs with Floki.text/2 in Elixir

Source: https://context7_llms

Demonstrates `Floki.text/2` extracting text from a list containing multiple paragraph (`<p>`) nodes, concatenating their content without a default separator.

```Elixir
Floki.text([{"p", [], ["1"]},{"p", [], ["2"]}])
```

--------------------------------

### Ignoring Style Tag Content with Floki.text/2 in Elixir

Source: https://context7_llms

Illustrates that `Floki.text/2` by default ignores the content of `<style>` tags when extracting text, focusing on visible page content.

```Elixir
Floki.text({"div", [], [{"style", [], ["hello"]}, " world"]}, style: false)
```

--------------------------------

### Ignoring Script Tag Content with Floki.text/2 in Elixir

Source: https://context7_llms

Illustrates that `Floki.text/2` by default ignores the content of `<script>` tags when extracting text, focusing on visible page content.

```Elixir
Floki.text({"div", [], [{"script", [], ["hello"]}, " world"]})
```

--------------------------------

### Extracting Text Nodes from HTML Tree in Elixir

Source: https://context7_llms

Shows the basic usage of `Floki.text/2` to extract all text content from an HTML tree, performing a deep search by default. Concatenates text from nested elements.

```Elixir
Floki.text({"div", [], [{"span", [], ["hello"]}, " world"]})
```

--------------------------------

### Disabling HTML Entity Encoding with Floki.raw_html/2 in Elixir

Source: https://context7_llms

Shows how to disable HTML entity encoding using the `:encode` option set to `false` in `Floki.raw_html/2`. This preserves special characters as-is in the output.

```Elixir
Floki.raw_html({"div", [{"class", "wrapper"}], ["10 > 5"]}, encode: false)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.