pragdave / earmark Goto Github PK

<p>a “<strong>test</strong>“</p>\n

Earmark.to_html """
> hello <a name="n"
> href="javascript:alert('xss')">*you*</a>
"""

check the [Wikipedia article on PATH](https://en.wikipedia.org/wiki/PATH_(variable))

iex(4)> Earmark.to_html("## [Pygments](http://pygments.org/)")
"<h2>[Pygments](http://pygments.org/)</h2>\n"

......................................................

  1) test to_html handles empty input (MarkdownTest.EarmarkTest)
     test/ex_doc/markdown/earmark_test.exs:13
     ** (UndefinedFunctionError) undefined function: Earmark.InCline.update_context/1
     stacktrace:
       Earmark.InCline.update_context(%Earmark.Context{links: #HashDict<[]>, options: %Earmark.Options{breaks: false, do_sanitize: nil, do_smartypants: nil, gfm: true, pedantic: false, renderer: Earmark.HtmlRenderer, sanitize: false, smartypants: true}, rules: nil})
       lib/earmark.ex:170: Earmark.to_html/2
       test/ex_doc/markdown/earmark_test.exs:14

.

  2) test to_html generate the HTML from the markdown (MarkdownTest.EarmarkTest)
     test/ex_doc/markdown/earmark_test.exs:8
     ** (UndefinedFunctionError) undefined function: Earmark.InCline.update_context/1
     stacktrace:
       Earmark.InCline.update_context(%Earmark.Context{links: #HashDict<[]>, options: %Earmark.Options{breaks: false, do_sanitize: nil, do_smartypants: nil, gfm: true, pedantic: false, renderer: Earmark.HtmlRenderer, sanitize: false, smartypants: true}, rules: nil})
       lib/earmark.ex:170: Earmark.to_html/2
       test/ex_doc/markdown/earmark_test.exs:9

iex(13)> text = "`true\n and false`"
"`true\n and false`"
iex(14)> Earmark.to_html text       
"<p>`true\n and false`</p>\n"
iex(15)> 

Returns the value for `key` in `app`'s environment.`

    <!-- moduledoc: Earmark -->

  @doc """
    iex> {:ambiguous, am} = Kalends.DateTime.from_erl({{2014, 3, 9}, {1, 1, 1}}, "America/Montevideo"); am |> Kalends.AmbiguousDateTime.disamb_total_off(0)
    {:error, :no_matches}
  """

% mix docs
** (EXIT from #PID<0.47.0>) an exception was raised:
    ** (CondClauseError) no cond clause evaluated to a true value
        Earmark.HtmlRenderer.expand/2
        lib/earmark/html_renderer.ex:172: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:74: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:19: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3

    iex> {:ambiguous, am} = Kalends.DateTime.from_erl({{2014, 3, 9}, {1, 1, 1}}, "America/Montevideo"); am |> Kalends.AmbiguousDateTime.disamb_total_off(0)
      {:error, :no_matches}

** (ExUnit.DocTest.Error) indentation level mismatch: "    {:error, :no_matches}", should have been 2 spaces
    (ex_unit) lib/ex_unit/doc_test.ex:405: ExUnit.DocTest.adjust_indent/4

<no file>:42: warning: Closing unclosed backquotes ` at end of input
<no file>:392: warning: Closing unclosed backquotes ` at end of input
<no file>:36: warning: Closing unclosed backquotes ` at end of input

iex(4)> Earmark.to_html "`\\`"         
<no file>:1: warning: Closing unclosed backquotes ` at end of input
"<p><code class=\"inline\">\\</code></p>\n"

Some notes about this command:
   + ```_4.1.9_``` specifies the version of Rails in case you have multiple versions installed.
   + ```--database=postgresql``` sets the database as Postgres
   + There is no need to run ```Jruby -S``` before ```rails new``` since you're using RVM.

Elixir.ArgumentError argument error 
    unknown :io.put_chars(:standard_error, :unicode, [<<70, 97, 105, 108, 101, 100, 32, 116, 111, 32, 102, 105, 110, 100, 32, 99, 108, 111, 115, 105, 110, 103, 32, 60, 226, 62>>, 10])
    lib/earmark/block.ex:483 Earmark.Block.html_match_to_closing/3
    lib/earmark/block.ex:182 Earmark.Block.parse/2
    lib/earmark/block.ex:49 Earmark.Block.lines_to_blocks/1
    lib/earmark/block.ex:40 Earmark.Block.parse/1
    lib/earmark.ex:167 Earmark.to_html/2
    [...]

<"My dad goes all over the world and learns about the news. One time he met a king. I want to be a reporter too. If I was a reporter right now, I'd probably write a story about if NASA was going to launch a new rocket into space. I'd start by going to the Director of NASA. Then I'd ask him about his rockets. And if any of them were going to space."_

θ67° 1d [jadams:/home/jadams/elixir/earmark] feature/breaks_on_cowboy_readme 2s ± mix test
test/cowboy_test.exs:59: warning: this check/guard will always yield the same result


  1) test rendering the Cowboy webserver README (CowboyTest)
     test/cowboy_test.exs:57
     ** (EXIT from #PID<0.114.0>) an exception was raised:
         ** (FunctionClauseError) no function clause matching in Regex.match?/2
             (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
             (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
             (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
             (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
             (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
             (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3

.18:29:34.286 [error] Task #PID<0.128.0> started from #PID<0.114.0> terminating
Function: #Function<2.44617958/0 in Earmark.pmap/2>
    Args: []
** (exit) an exception was raised:
    ** (FunctionClauseError) no function clause matching in Regex.match?/2
        (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
        (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
        (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
.............18:29:34.287 [error] Task #PID<0.124.0> started from #PID<0.114.0> terminating
Function: #Function<2.44617958/0 in Earmark.pmap/2>
    Args: []
** (exit) an exception was raised:
    ** (FunctionClauseError) no function clause matching in Regex.match?/2
        (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
        (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
        (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
...........18:29:34.288 [error] Task #PID<0.134.0> started from #PID<0.114.0> terminating
Function: #Function<2.44617958/0 in Earmark.pmap/2>
    Args: []
** (exit) an exception was raised:
    ** (FunctionClauseError) no function clause matching in Regex.match?/2
        (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
        (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
        (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
..............18:29:34.288 [error] Task #PID<0.118.0> started from #PID<0.114.0> terminating
Function: #Function<2.44617958/0 in Earmark.pmap/2>
    Args: []
** (exit) an exception was raised:
    ** (FunctionClauseError) no function clause matching in Regex.match?/2
        (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
        (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
        (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
...........18:29:34.289 [error] Task #PID<0.131.0> started from #PID<0.114.0> terminating
Function: #Function<2.44617958/0 in Earmark.pmap/2>
    Args: []
** (exit) an exception was raised:
    ** (FunctionClauseError) no function clause matching in Regex.match?/2
        (elixir) lib/regex.ex:155: Regex.match?(~r/^\s*$/, nil)
        (earmark) lib/earmark/html_renderer.ex:177: Earmark.HtmlRenderer.expand/2
        (earmark) lib/earmark/html_renderer.ex:170: Earmark.HtmlRenderer.add_attrs/3
        (elixir) lib/task/supervised.ex:70: Task.Supervised.do_apply/2
        (elixir) lib/task/supervised.ex:15: Task.Supervised.async/3
        (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
................................................................................

````alpha````

<pre><code class="`"></code></pre>

This demonstrates inline $$\LaTeX$$ support, and the following demonstrates block support.

$$A = \frac{1}{2}\int_{a}^{b}\left( \left[f(\theta)\right]^2 - \left[g(\theta)\right]^2 \right)\,d\theta.$$

<p>This demonstrates inline <script type="math/tex">\LaTeX</script> support, and the following demonstrates block support.

<script type="math/tex; mode=display">A = \frac{1}{2}\int_{a}^{b}\left( \left[f(\theta)\right]^2 - \left[g(\theta)\right]^2 \right)\,d\theta.</script>

Built-in type         | Defined as
:-------------------- | :---------
`term`                | `any`
`binary`              | `one | two`
`bitstring`           | `three`

warning: variable pending_lnb is unused
  lib/earmark/helpers/lookahead_helpers.ex:34

warning: unused import Earmark.Helpers.StringHelpers
  lib/earmark/helpers/lookahead_helpers.ex:7

<pre><code class="language-css">p { color: red }</code></pre>

  ```language-ruby
  class Foo
    def bar
    end
  end
  ```

iex(1)> foo = """              
...(1)>   - `:foo` - Bar
...(1)>   Baz `:a`
...(1)> """
"  - `:foo` - Bar\n  Baz `:a`\n"

iex(2)> bar = """
...(2)>   - `:foo` - Bar
...(2)>   Baz `:a | :b`
...(2)> """
"  - `:foo` - Bar\n  Baz `:a | :b`\n"

iex(3)> foo |> Earmark.to_html |> IO.puts
<ul>
<li><code class="inline">:foo</code> - Bar
  Baz <code class="inline">:a</code>
</li>
</ul>

:ok

iex(4)> bar |> Earmark.to_html |> IO.puts
<ul>
<li><code class="inline">:foo</code> - Bar
</li>
</ul>
<p>  Baz <code class="inline">:a | :b</code></p>

:ok

iex(5)> baz = """
...(5)>   - `:foo` - Bar
...(5)>   - Baz `:a | :b`
...(5)> """
"  - `:foo` - Bar\n  - Baz `:a | :b`\n"
iex(6)> baz |> Earmark.to_html |> IO.puts
<ul>
<li><code class="inline">:foo</code> - Bar
</li>
<li>Baz <code class="inline">:a | :b</code>
</li>
</ul>

:ok

1) test handles multi-paragraph footnote bodies (FootnoteTest)
     test/footnote_test.exs:60
     Assertion with == failed
     code: result == expected
     lhs:  [%Earmark.Block.Para{attrs: nil,
             lines: ["This is a footnote[^fn-1]"]},
            %Earmark.Block.Para{attrs: nil,
             lines: ["[^fn-1]: line 1", "line 2"]},
            %Earmark.Block.Code{attrs: nil, language: nil,
             lines: ["Para 2 line 1", "Para 2 line 2", "", "* List Item 1",
              "  List Item 1 Cont", "* List Item 2"]}]
     rhs:  [%Earmark.Block.Para{attrs: nil,
             lines: ["This is a footnote[^fn-1]"]},
            %Earmark.Block.FnDef{attrs: nil,
             blocks: [%Earmark.Block.Para{attrs: nil,
               lines: ["line 1", "line 2"]},
              %Earmark.Block.Para{attrs: nil,
               lines: ["Para 2 line 1", "Para 2 line 2"]},
              %Earmark.Block.List{attrs: nil,
               blocks: [%Earmark.Block.ListItem{attrs: nil,
                 blocks: [%Earmark.Block.Para{attrs: nil,
                   lines: ["List Item 1", "  List Item 1 Cont"]}],
                 spaced: false, type: :ul},
                %Earmark.Block.ListItem{attrs: nil,
                 blocks: [%Earmark.Block.Para{attrs: nil,
                   lines: ["List Item 2"]}], spaced: false, type: :ul}],
               type: :ul}], id: "fn-1", number: nil}]
     stacktrace:
       test/footnote_test.exs:82