d-mark 1.0.0a1 → 1.0.0a2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a113f03eb0aba71874ec39fdb2eeeb53327da22a
-  data.tar.gz: 8a022441c7fb0ef0bb82b23d696e2d165f0e5193
+  metadata.gz: 686fe4c2cf9132e4bfd42debaac837d66b911c40
+  data.tar.gz: 3649616bac8b3eccb25de17e433ecea93af77bc9
 SHA512:
-  metadata.gz: 9b67ee738116a651db12715abf33da46b4d9ab78425b30d801ca6c5398be45bbd2bcae3092b7e48566538ec98d7a6620063a94d2da4a3546342229b143f9e991
-  data.tar.gz: a61696ac50d227e5b90c652d3593d300a46a66bed352e852c26feb5951c88c639fed7e9af32e6c304cb520b7edfd0b37e5b8716fddbedea77acb151f8aac02e0
+  metadata.gz: b419728d8c5bf01674fb87c1401f6a47c8a7d90883efce6fce0de6612f50060f5cb3dcf740e77ce6601df04992e7a2ad050a209631e8062fc2e1b5e89c63745b
+  data.tar.gz: 7404cc61b20b0c2fed2d7dd8fb76127e8c8ea30c6f42d2c6525297c027bf4d6b84a5deea1b311e621c305e9c82615f0ab0b8da187c6894ec690986e302edc166

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    d-mark (1.0.0a1)
+    d-mark (1.0.0a2)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
       json
       simplecov
       url
-    coderay (1.1.0)
+    coderay (1.1.1)
     diff-lcs (1.2.5)
     docile (1.1.5)
     ffi (1.9.10)
@@ -38,7 +38,7 @@ GEM
     notiffany (0.0.8)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    parser (2.3.0.4)
+    parser (2.3.0.6)
       ast (~> 2.2)
     powerpack (0.1.1)
     pry (0.10.3)
@@ -54,7 +54,7 @@ GEM
       rspec-core (~> 3.4.0)
       rspec-expectations (~> 3.4.0)
       rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.2)
+    rspec-core (3.4.3)
       rspec-support (~> 3.4.0)
     rspec-expectations (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)

data/NEWS.md

@@ -1,5 +1,11 @@
 # D★Mark news
 
+## 1.0.0a2 (2016-03-06)
+
+Changes:
+
+* Changed block form from `elem. content` to `#elem content` (#6)
+
 ## 1.0.0a1 (2016-02-20)
 
 Fixes:

data/README.adoc

@@ -8,214 +8,15 @@ image:http://img.shields.io/codecov/c/github/ddfreyne/d-mark.svg[Code Coverage,
 
 _D★Mark_ is a language for marking up prose. It facilitates writing semantically meaningful text, without limiting itself to the semantics provided by HTML or Markdown.
 
-Here’s an example of D★Mark:
-
-[source]
-----
-h2. Patterns
-
-para. Patterns are used to find items and layouts based on their identifier. They come in three varieties:
-
-list[unordered].
-  item. glob patterns
-  item. regular expression patterns
-  item. legacy patterns
-
-para. A glob pattern that matches every item is %pattern{/**/*}. A glob pattern that matches every item/layout with the extension %filename{md} is %glob{/**/*.md}.
-----
-
-== Samples
-
-The `samples/` directory contains some sample D★Mark files. They can be processed by invoking the appropriate script with the same filename. For example:
-
-....
-% bundle exec ruby samples/trivial.rb
-<p>I’m a <em>trivial</em> example!</p>
-....
-
-== Structure of a D★Mark document
-
-_D★Mark_ knows two constructs:
-
-Block-level elements::
-  Every non-blank line of a D★Mark document corresponds to a block. A block can be a paragraph, a list, a header, a source code listing, or more. They start with the name of the element, a period, a space character, followed by the content. For example:
-+
-[source]
-----
-para. Patterns are used to find items and layouts based on their identifier. They come in three varieties.
-----
-
-Inline elements::
-  Inside a block, text can be marked up using inline elements, which start with a percentage sign, the name of the element, and the content within braces. For example, `%emph{crazy}` is an `emph` element with the content `crazy`.
-
-Block-level elements can be nested. To do so, indent the nested block two spaces deeper than the enclosing block. For example, the following defines a `list` element with three `item` elements inside it:
-
-[source]
-----
-list[unordered].
-  item. glob patterns
-  item. regular expression patterns
-  item. legacy patterns
-----
-
-Block-level elements can also include plain text. In this case, the content is not wrapped inside a nested block-level element. This is particularly useful for source code listing. For example:
-
-[source]
-----
-listing[lang=ruby].
-  identifier = Nanoc::Identifier.new('/about.md')
-
-  identifier.without_ext
-  # => "/about"
-
-  identifier.ext
-  # => "md"
-----
-
-Block-level elements and inline elements are identical in the tree representation of D★Mark. This means that any inline element can be rewritten as a block-level element.
-
-NOTE: To do: Elaborate on the distinction and similarity of block-level and inline elements.
-
-NOTE: To do: Describe escaping rules.
-
-=== Attributes
-
-Both block and inline elements can also have attributes. Attributes are enclosed in square brackets after the element name, as a comma-separated list of key-value pairs separated by an equal sign. The value part, along with the equal sign, can be omitted, in which case the value will be equal to the key name.
-
-For example:
-
-* `%code[lang=ruby]{Nanoc::VERSION}` is an inline `code` element with the `lang` attribute set to `ruby`.
-
-* `%only[web]{Refer to the release notes for details.}` is an inline `only` element with the `web` attribute set to `web`.
-
-* `h2[id=donkey]. All about donkeys` is a block-level `h2` element with the `id` attribute set to `donkey`.
-
-* `p[print]. This is a paragraph that only readers of the book will see.` is a block-level `para` element with the `print` attribute set to `print`.
-
-NOTE: The behavior of keys with missing values might change to default to booleans rather than to the key name.
+If you’re a technical writer looking for a flexible markup language, D★Mark might be a good fit.
 
-== Goals
-
-Be extensible::
-  D★Mark defines only the syntax of the markup language, and doesn’t bother with semantics. It does not prescribe which element names are valid in the context of a vocabulary, because it does not come with a vocabulary.
-
-Be simple::
-  Simplicity implies being easy to write and easy to parse. D★Mark eschews ambiguity and aims to have a short formal syntactical definition. This also means that it is easy to syntax highlight.
-
-Be compact::
-  Introduce as little extra syntax as possible.
-
-== Comparison with other languages
-
-D★Mark takes inspiration from a variety of other languages.
-
-HTML::
-  HTML is syntactically unambiguous, but comparatively more verbose than other languages. It also prescribes only a small set of elements, which makes it awkward to use for prose that requires more thorough markup. It is possible use `span` or `div` elements with custom classes, but this approach turns an already verbose language into something even more verbose.
-+
-[source,html]
-----
-<p>A glob pattern that matches every item is <span class="pattern attr-kind-glob">/**/*</span>.</p>
-----
-+
-[source,d-mark]
-----
-para. A glob pattern that matches every item is %pattern[glob]{/**/*}.
-----
-
-XML::
-  Similar to HTML, with the major difference that XML does not prescribe a set of elements.
-+
-[source,xml]
-----
-<para>A glob pattern that matches every item is <pattern kind="glob">/**/*</pattern>.</para>
-----
-+
-[source,d-mark]
-----
-para. A glob pattern that matches every item is %pattern[glob]{/**/*}.
-----
+Here’s an example of D★Mark:
 
-Markdown::
-  Markdown has a compact syntax, but is complex and ambiguous, as evidenced by the many different mutually incompatible implementations. It prescribes a small set of elements (smaller even than HTML). It supports embedding raw HTML, which in theory makes it possible to combine the best of both worlds, but in practice leads to markup that is harder to read than either Markdown or HTML separately, and occasionally trips up the parser and syntax highlighter.
-+
 [source]
 ----
-A glob pattern that matches every item is <span class="glob attr-kind-glob">/**/*</span>.
-----
-+
-[source,d-mark]
-----
-para. A glob pattern that matches every item is %pattern[glob]{/**/*}.
-----
-
-AsciiDoc::
-  AsciiDoc, along with its AsciiDoctor variant, are syntactically unambiguous, but complex languages. They prescribe a comparatively large set of elements which translates well to DocBook and HTML. They do not support custom markup or embedding raw HTML, which makes them harder t use for prose that requires more complex markup.
-+
-_(No example, as this example cannot be represented with AsciiDoc.)_
-
-TeX, LaTeX::
-  TeX is a turing-complete programming language, as opposed to a markup language, intended for typesetting. This makes it impractical for using it as the source for converting it to other formats. Its syntax is simple and compact, and served as an inspiration for D★Mark.
-+
-[source,latex]
-----
-A glob pattern that matches every item is \pattern[glob]{/**/*}.
-----
-+
-[source,d-mark]
-----
-para. A glob pattern that matches every item is %pattern[glob]{/**/*}.
-----
-
-JSON, YAML::
-  JSON and YAML are data interchange formats rather than markup languages, and thus are not well-suited for marking up prose.
-+
-[source,json]
-----
-[
-  "A glob pattern that matches every item is ",
-  ["pattern", {"kind": "glob"}, ["/**/*"]],
-  "."
-]
-----
-+
-[source,d-mark]
-----
-para. A glob pattern that matches every item is %pattern[glob]{/**/*}.
-----
+para. This a paragraph; an element in block form containing some text.
 
-== Specification
-
-NOTE: To do: write this section.
-
-== Programmatic usage
-
-Handling a D★Mark file consists of two stages: parsing and translating.
-
-The parsing stage converts text into a list of nodes. Construct a parser with the tokens as input, and call `#run` to get the list of nodes.
-
-[source,ruby]
+note[only=web]. This is a note that will %emph{only} show up on web.
 ----
-content = File.read(ARGV[0])
-nodes = DMark::Parser.new(content).run
-----
-
-The translating stage is not the responsibility of D★Mark. A translator is part of the domain of the source text, and D★Mark only deals with syntax rather than semantics. A translator will run over the tree and convert it into something else (usually another string). To do so, handle each node type (`DMark::ElementNode` or `String`). For example, the following translator will convert the tree into something that resembles XML:
 
-[source,ruby]
-----
-class MyXMLLikeTranslator < DMark::Translator
-  def handle(node)
-    case node
-    when String
-      out << node
-    when DMark::ElementNode
-      out << "<#{node.name}>"
-      handle_children(node)
-      out << "</#{node.name}>"
-    end
-  end
-end
-
-result = MyXMLLikeTranslator.new(nodes).run
-puts result
-----
+For details, see the http://ddfreyne.github.io/d-mark/[D★Mark web page].

data/Rakefile

@@ -12,3 +12,7 @@ RuboCop::RakeTask.new(:rubocop) do |task|
 end
 
 task default: [:spec, :rubocop]
+
+rule 'doc.html' => 'doc.dmark' do |t|
+  sh "bundle exec ruby samples/doc2html.rb #{t.source} #{t.name}"
+end

data/lib/d-mark/parser.rb

@@ -133,32 +133,11 @@ module DMark
 
     # FIXME: ugly and duplicated
     def try_read_block_start
-      old_pos = @pos
-
-      success =
-        if try_read_identifier_head
-          read_identifier_tail
-
-          case peek_char
-          when '['
-            true
-          when '.'
-            advance
-            [' ', "\n", nil].include?(peek_char)
-          end
-        end
-
-      @pos = old_pos
-      success
-    end
-
-    # FIXME: ugly and duplicated
-    def try_read_identifier_head
-      char = peek_char
-      case char
-      when 'a'..'z'
-        advance
-        char
+      if peek_char == '#'
+        next_char = peek_char(@pos + 1)
+        ('a'..'z').cover?(next_char)
+      else
+        false
       end
     end
 
@@ -187,6 +166,7 @@ module DMark
     end
 
     def read_single_block
+      read_char('#')
       identifier = read_identifier
 
       attributes =
@@ -196,8 +176,6 @@ module DMark
           {}
         end
 
-      read_char('.')
-
       case peek_char
       when nil, "\n"
         advance
@@ -374,7 +352,7 @@ module DMark
     def read_percent_body
       char = peek_char
       case char
-      when '%', '}'
+      when '%', '}', '#'
         advance
         char.to_s
       when nil, "\n"

data/lib/d-mark/version.rb

@@ -1,3 +1,3 @@
 module DMark
-  VERSION = '1.0.0a1'.freeze
+  VERSION = '1.0.0a2'.freeze
 end

data/spec/d-mark/parser_spec.rb

@@ -9,26 +9,26 @@ end
 describe 'DMark::Parser#parser' do
   it 'parses' do
     expect(parse('')).to eq []
-    expect(parse('p.')).to eq [element('p', {}, [])]
-    expect(parse('p. hi')).to eq [element('p', {}, ['hi'])]
-    expect(parse('p. hi %%')).to eq [element('p', {}, ['hi ', '%'])]
-    expect(parse('p. hi %}')).to eq [element('p', {}, ['hi ', '}'])]
+    expect(parse('#p')).to eq [element('p', {}, [])]
+    expect(parse('#p hi')).to eq [element('p', {}, ['hi'])]
+    expect(parse('#p hi %%')).to eq [element('p', {}, ['hi ', '%'])]
+    expect(parse('#p hi %}')).to eq [element('p', {}, ['hi ', '}'])]
   end
 
   it 'parses escaped % in block' do
-    expect(parse('p. %%')).to eq [
+    expect(parse('#p %%')).to eq [
       element('p', {}, ['%'])
     ]
   end
 
   it 'parses escaped } in block' do
-    expect(parse('p. %}')).to eq [
+    expect(parse('#p %}')).to eq [
       element('p', {}, ['}'])
     ]
   end
 
   it 'parses escaped % in inline block' do
-    expect(parse('p. %foo{%%}')).to eq [
+    expect(parse('#p %foo{%%}')).to eq [
       element(
         'p', {},
         [
@@ -39,7 +39,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses escaped } in inline block' do
-    expect(parse('p. %foo{%}}')).to eq [
+    expect(parse('#p %foo{%}}')).to eq [
       element(
         'p', {},
         [
@@ -49,7 +49,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses block with text and element content' do
-    expect(parse('p. hi %em{ho}')).to eq [
+    expect(parse('#p hi %em{ho}')).to eq [
       element(
         'p', {}, [
           'hi ',
@@ -60,7 +60,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses block with text and element content, followed by newline' do
-    expect(parse("p. hi %em{ho}\n")).to eq [
+    expect(parse("#p hi %em{ho}\n")).to eq [
       element(
         'p', {}, [
           'hi ',
@@ -71,7 +71,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses children' do
-    expect(parse("p. hi %em{ho}\n  p. child p")).to eq [
+    expect(parse("#p hi %em{ho}\n  #p child p")).to eq [
       element(
         'p', {}, [
           'hi ',
@@ -83,7 +83,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses children multiple levels deep' do
-    expect(parse("p. hi %em{ho}\n  p. child p\n    p. subchild p")).to eq [
+    expect(parse("#p hi %em{ho}\n  #p child p\n    #p subchild p")).to eq [
       element(
         'p', {}, [
           'hi ',
@@ -104,7 +104,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'ignores blanks' do
-    expect(parse("p. foo\n \n  p. bar\n  \n\n    p. qux")).to eq [
+    expect(parse("#p foo\n \n  #p bar\n  \n\n    #p qux")).to eq [
       element(
         'p', {}, [
           'foo',
@@ -124,106 +124,104 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'reads multiple consecutive blocks' do
-    expect(parse("p. foo\np. bar")).to eq [
+    expect(parse("#p foo\n#p bar")).to eq [
       element('p', {}, ['foo']),
       element('p', {}, ['bar'])
     ]
   end
 
   it 'includes raw content' do
-    expect(parse("p. foo\n  donkey")).to eq [
+    expect(parse("#p foo\n  donkey")).to eq [
       element('p', {}, %W(foo \n donkey))
     ]
   end
 
   it 'includes raw content including initial indentation' do
-    expect(parse("p. foo\n    donkey")).to eq [
+    expect(parse("#p foo\n    donkey")).to eq [
       element('p', {}, ['foo', "\n", '  donkey'])
     ]
   end
 
   it 'includes raw content from multiple lines' do
-    expect(parse("p. foo\n    donkey\n  giraffe\n    zebra\n")).to eq [
+    expect(parse("#p foo\n    donkey\n  giraffe\n    zebra\n")).to eq [
       element('p', {}, ['foo', "\n", '  donkey', "\n", 'giraffe', "\n", '  zebra'])
     ]
   end
 
   it 'includes empty lines in raw content' do
-    expect(parse("p. foo\n\n  donkey\n\n    giraffe\n")).to eq [
+    expect(parse("#p foo\n\n  donkey\n\n    giraffe\n")).to eq [
       element('p', {}, ['foo', "\n", "\n", 'donkey', "\n", "\n", '  giraffe'])
     ]
   end
 
   it 'does not include line break after empty block element and before data lines' do
-    expect(parse("p.\n  donkey\n")).to eq [
+    expect(parse("#p\n  donkey\n")).to eq [
       element('p', {}, ['donkey'])
     ]
   end
 
   it 'parses inline element in data lines' do
-    expect(parse("p.\n  %emph{donkey}\n")).to eq [
-      element('p', {}, [
-                element('emph', {}, ['donkey'])
-              ])
+    expect(parse("#p\n  %emph{donkey}")).to eq [
+      element('p', {}, [element('emph', {}, ['donkey'])])
     ]
   end
 
   it 'parses empty attributes' do
-    expect(parse('p[]. hi')).to eq [
+    expect(parse('#p[] hi')).to eq [
       element('p', {}, ['hi'])
     ]
   end
 
   it 'parses single attribute' do
-    expect(parse('p[foo=bar]. hi')).to eq [
+    expect(parse('#p[foo=bar] hi')).to eq [
       element('p', { 'foo' => 'bar' }, ['hi'])
     ]
   end
 
   it 'parses single value-less attribute' do
-    expect(parse('p[foo]. hi')).to eq [
+    expect(parse('#p[foo] hi')).to eq [
       element('p', { 'foo' => 'foo' }, ['hi'])
     ]
   end
 
   it 'parses multiple attributes' do
-    expect(parse('p[foo=bar,qux=donkey]. hi')).to eq [
+    expect(parse('#p[foo=bar,qux=donkey] hi')).to eq [
       element('p', { 'foo' => 'bar', 'qux' => 'donkey' }, ['hi'])
     ]
   end
 
   it 'parses multiple value-less attributes' do
-    expect(parse('p[foo,qux]. hi')).to eq [
+    expect(parse('#p[foo,qux] hi')).to eq [
       element('p', { 'foo' => 'foo', 'qux' => 'qux' }, ['hi'])
     ]
   end
 
   it 'parses escaped attributes' do
-    expect(parse('p[foo=%],bar=%%,donkey=%,]. hi')).to eq [
+    expect(parse('#p[foo=%],bar=%%,donkey=%,] hi')).to eq [
       element('p', { 'foo' => ']', 'bar' => '%', 'donkey' => ',' }, ['hi'])
     ]
   end
 
   it 'parses attributes in empty block' do
-    expect(parse("p[foo=bar].\n  hi")).to eq [
+    expect(parse("#p[foo=bar]\n  hi")).to eq [
       element('p', { 'foo' => 'bar' }, ['hi'])
     ]
   end
 
   it 'parses block start on next line properly' do
-    expect(parse("p.\n  this is not a child block.")).to eq [
+    expect(parse("#p\n  this is not a child block.")).to eq [
       element('p', {}, ['this is not a child block.'])
     ]
   end
 
   it 'parses block start on next line with spacey' do
-    expect(parse("p.\n  foo.bar")).to eq [
+    expect(parse("#p\n  foo.bar")).to eq [
       element('p', {}, ['foo.bar'])
     ]
   end
 
   it 'parses child block without content' do
-    expect(parse("ul.\n  li.\n    p. You can.")).to eq [
+    expect(parse("#ul\n  #li\n    #p You can.")).to eq [
       element(
         'ul', {},
         [
@@ -239,7 +237,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses child block without content at end' do
-    expect(parse("ul.\n  li.")).to eq [
+    expect(parse("#ul\n  #li")).to eq [
       element(
         'ul', {},
         [
@@ -250,7 +248,7 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses child block with attributes' do
-    expect(parse("ul.\n  li[foo].")).to eq [
+    expect(parse("#ul\n  #li[foo]")).to eq [
       element(
         'ul', {},
         [
@@ -261,42 +259,55 @@ describe 'DMark::Parser#parser' do
   end
 
   it 'parses document starting with blank lines' do
-    expect(parse("  \n \np. Hi!")).to eq [
+    expect(parse("  \n \n#p Hi!")).to eq [
       element('p', {}, ['Hi!'])
     ]
   end
 
+  it 'parses escaped indented line' do
+    expect(parse("#listing\n  %#h1 Foo\n")).to eq [
+      element('listing', {}, ['#', 'h1 Foo'])
+    ]
+  end
+
+  it 'parses escaped indented line with attributes' do
+    expect(parse("#listing\n  %#h1[donkey] Foo\n")).to eq [
+      element('listing', {}, ['#', 'h1[donkey] Foo'])
+    ]
+  end
+
   it 'does not parse percent escapes' do
-    expect { parse('p. %ref[url=https://github.com/pulls?q=is%3Aopen+user%3Ananoc]{eek}') }
+    expect { parse('#p %ref[url=https://github.com/pulls?q=is%3Aopen+user%3Ananoc]{eek}') }
       .to raise_error(DMark::Parser::ParserError, 'parse error at line 1, col 43: expected "%", "," or "]" after "%", but got "3"')
   end
 
   it 'does not parse attribute values ending with an end-of-file' do
-    expect { parse('p. %ref[url=hello') }
+    expect { parse('#p %ref[url=hello') }
       .to raise_error(DMark::Parser::ParserError, 'parse error at line 1, col 18: unexpected file end in attribute value')
   end
 
   it 'does not parse attribute values ending with a line break' do
-    expect { parse("p. %ref[url=hello\n") }
+    expect { parse("#p %ref[url=hello\n") }
       .to raise_error(DMark::Parser::ParserError, 'parse error at line 1, col 18: unexpected line break in attribute value')
   end
 
   it 'does not parse escaped attribute values ending with an end-of-file' do
-    expect { parse('p. %ref[url=hello%') }
+    expect { parse('#p %ref[url=hello%') }
       .to raise_error(DMark::Parser::ParserError, 'parse error at line 1, col 19: unexpected file end in attribute value')
   end
 
   it 'does not parse escaped attribute values ending with a line break' do
-    expect { parse("p. %ref[url=hello%\n") }
+    expect { parse("#p %ref[url=hello%\n") }
       .to raise_error(DMark::Parser::ParserError, 'parse error at line 1, col 19: unexpected line break in attribute value')
   end
 
   it 'does not parse' do
+    expect { parse('#') }.to raise_error(DMark::Parser::ParserError)
     expect { parse('p') }.to raise_error(DMark::Parser::ParserError)
     expect { parse('0') }.to raise_error(DMark::Parser::ParserError)
     expect { parse('p0') }.to raise_error(DMark::Parser::ParserError)
-    expect { parse('0.') }.to raise_error(DMark::Parser::ParserError)
-    expect { parse('p. %') }.to raise_error(DMark::Parser::ParserError)
-    expect { parse('p. }') }.to raise_error(DMark::Parser::ParserError)
+    expect { parse('#0') }.to raise_error(DMark::Parser::ParserError)
+    expect { parse('#p %') }.to raise_error(DMark::Parser::ParserError)
+    expect { parse('#p }') }.to raise_error(DMark::Parser::ParserError)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: d-mark
 version: !ruby/object:Gem::Version
-  version: 1.0.0a1
+  version: 1.0.0a2
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-20 00:00:00.000000000 Z
+date: 2016-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -54,7 +54,6 @@ files:
 - lib/d-mark/parser.rb
 - lib/d-mark/translator.rb
 - lib/d-mark/version.rb
-- samples/identifiers-and-patterns.dmark
 - samples/trivial.dmark
 - samples/trivial.rb
 - spec/d-mark/element_node_spec.rb

data/samples/identifiers-and-patterns.dmark

@@ -1,539 +0,0 @@
-p. In Nanoc, every item (page or asset) and every layout has a unique %firstterm{identifier}: a string derived from the file’s path. A %firstterm{pattern} is an expression that is used to select items or layouts based on their identifier.
-
-h2. Identifiers
-
-p. Identifiers come in two types: the %emph{full} type, new in Nanoc 4, and the %emph{legacy} type, used in Nanoc 3.
-
-dl.
-  dt. full
-  dd. An identifier with the full type is the filename, with the path to the content directory removed. For example, the file %filename{/Users/denis/stoneship/content/about.md} will have the full identifier %identifier{/about.md}.
-
-  dt. legacy
-  dd. An identifier with the legacy type is the filename, with the path to the content directory removed, the extension removed, and a slash appended. For example, the file %filename{/Users/denis/stoneship/content/about.md} will have the legacy identifier %identifier{/about/}. This corresponds closely with paths in clean URLs.
-
-p. The following methods are useful for full identifiers:
-
-dl.
-  dt. %code{identifier.without_ext} → %class{String}
-  dd. identifier with the last extension removed
-
-  dt. %code{identifier.without_exts} → %class{String}
-  dd. identifier with all extensions removed
-
-  dt. %code{identifier.ext} → %class{String}
-  dd. the last extension of this identifier
-
-  dt. %code{identifier.exts} → %class{String}
-  dd. all extensions of this identifier
-
-  dt. %code{identifier + string} → %class{String}
-  dd. identifier with the given string appended
-
-p. Here are some examples:
-
-listing[lang=ruby].
-  identifier = Nanoc::Identifier.new('/about.md')
-
-  identifier.without_ext
-  # => "/about"
-
-  identifier.ext
-  # => "md"
-
-p. The following method is useful for legacy identifiers:
-
-dl[legacy].
-  dt. %code{identifier.chop} → %class{String}
-  dd. identifier with the last character removed
-
-p. Here are some examples:
-
-listing[lang=ruby].
-  identifier = Nanoc::Identifier.new('/about/', type: :legacy)
-
-  identifier.chop
-  # => "/about"
-
-  identifier.chop + '.html'
-  # => "/about.html"
-
-  identifier + 'index.html'
-  # => "/about/index.html"
-
-h2. Patterns
-
-p. Patterns are used to find items and layouts based on their identifier. They come in three varieties:
-
-ul.
-  li. glob patterns
-  li. regular expression patterns
-  li. legacy patterns
-
-h3. Glob patterns
-
-p. Glob patterns are strings that contain wildcard characters. Wildcard characters are characters that can be substituted for other characters in a identifier. An example of a glob pattern is %glob{/projects/*.md}, which matches all files with a %filename{md} extension in the %filename{/projects} directory.
-
-p. Globs are commonplace in Unix-like environments. For example, the Unix command for listing all files with the %filename{md} extension in the current directory is %command{ls *.md}. In this example, the argument to the %command{ls} command is a wildcard.
-
-p. Nanoc supports the following wildcards in glob patterns:
-
-dl.
-  dt. %code{*}
-  dd. Matches any file or directory name. Does not cross directory boundaries. For example, %glob{/projects/*.md} matches %identifier{/projects/nanoc.md}, but not %identifier{/projects/cri.adoc} nor %identifier{/projects/nanoc/about.md}.
-
-  dt. %code{**/}
-  dd. Matches zero or more levels of nested directories. For example, %glob{/projects/**/*.md} matches both %identifier{/projects/nanoc.md} and %identifier{/projects/nanoc/history.md}.
-
-  dt. %code{?}
-  dd. Matches a single character.
-
-  dt. %code{[abc]}
-  dd. Matches any single character in the set. For example, %glob{/people/[kt]im.md} matches only %identifier{/people/kim.md} and %identifier{/people/tim.md}.
-
-  dt. %code{{foo,bar%}}
-  dd. Matches either string in the comma-separated list. More than two strings are possible. For example, %glob{/c{at,ub,ount%}s.txt} matches %identifier{/cats.txt}, %identifier{/cubs.txt} and %identifier{/counts.txt}, but not %identifier{/cabs.txt}.
-
-p. A glob pattern that matches every item is %glob{/**/*}. A glob pattern that matches every item/layout with the extension %filename{md} is %glob{/**/*.md}.
-
-h3. Regular expression patterns
-
-p. You can use a regular expression to select items and layouts.
-
-p. For matching identifiers, the %code{%%r{…%}} syntax is (arguably) nicer than the %code{/…/} syntax. The latter is not a good fit for identifiers (or filenames), because all slashes need to be escaped. The %code{\A} and %code{\z} anchors are also useful to make sure the entire identifier is matched.
-
-p. An example of a regular expression pattern is %code{%%r{\A/projects/(cri|nanoc)\.md\z%}}, which matches both %identifier{/projects/nanoc.md} and %identifier{/projects/cri.md}.
-
-h3. Legacy patterns
-
-p. Legacy patterns are strings that contain wildcard characters. The wildcard characters behave differently than the glob wildcard characters.
-
-p. To enable legacy patterns, set %code{string_pattern_type} to %code{"legacy"} in the configuration. For example:
-
-listing[lang=yaml].
-  string_pattern_type: "legacy"
-
-p. For legacy patterns, Nanoc supports the following wildcards:
-
-dl.
-  dt. %code{*}
-  dd. Matches zero or more characters, including a slash. For example, %glob{/projects/*/} matches %glob{/projects/nanoc/} and %identifier{/projects/nanoc/about/}, but not %identifier{/projects/}.
-
-  dt. %code{+}
-  dd. Matches one or more characters, including a slash. For example, %glob{/projects/+} matches %identifier{/projects/nanoc/} and %identifier{/projects/nanoc/about/}, but not %identifier{/projects/}.
-
-p. Install Nanoc using RubyGems:
-
-listing.
-  %prompt{%%} %kbd{gem install nanoc}
-
-note. %entity{sudo-gem-install}
-
-p. After installing, head over to %ref[item=/doc/tutorial.*]{}! For detailed installation instructions, read on.
-
-h2. Installing Ruby
-
-p. Nanoc requires %ref[url=http://ruby-lang.org/]{Ruby} in order to run. Nanoc supports the official Ruby interpreter from version 2.1 up, as well as JRuby from version 9000 up.
-
-p. Ruby may already be installed on your system. To check, open a terminal window and type %kbd{ruby --version}. If you get “command not found”, Ruby is not yet installed. Otherwise, you will see which version of Ruby you have:
-
-listing.
-  %prompt{%%} %kbd{ruby --version}
-  %erb{config[:ruby_version_info]}
-  %prompt{%%}
-
-p. To install Ruby, follow the %ref[url=https://www.ruby-lang.org/en/documentation/installation/]{installation instructions on the Ruby web site}.
-
-h2. Installing Nanoc
-
-p. All dependencies are now taken care of, and installing Nanoc should now be easy:
-
-listing.
-  %prompt{%%} %kbd{gem install nanoc}
-
-note. %entity{sudo-gem-install}
-
-p. To make sure that Nanoc was installed correctly, run %kbd{nanoc --version}. It should print the version number along with some other information, like this:
-
-listing.
-  %prompt{%%} %kbd{nanoc --version}
-  %erb{config[:nanoc_version_info]}
-  %prompt{%%}
-
-p. If you get a “command not found” error when trying to run %command{nanoc}, you might have to adjust your %code{$PATH} to include the path to the directory where RubyGems installs executables.
-
-p. The current version of Nanoc is is %erb{latest_release_info[:version]}, released on %erb{latest_release_info[:date].format_as_date}. You can find the release notes for this version as well as release notes for older versions on %ref[item=/release-notes]{}.
-
-p. If you’re on Windows and are using the Windows console, it’s probably a good idea to install the %productname{win32console} gem using %kbd{gem install win32console} to allow Nanoc to use pretty colors when writing stuff to the terminal.
-
-h3. Installing from git
-
-p. You can also install Nanoc from the repository if you want to take advantage of the latest features and improvements in Nanoc. Be warned that the versions from the repository may be unstable, so it is recommended to install Nanoc from RubyGems if you want to stay safe. You can install Nanoc from the git repository like this:
-
-listing.
-  %prompt{~%%} %kbd{git clone git://github.com/nanoc/nanoc.git}
-  %prompt{~%%} %kbd{cd nanoc}
-  %prompt{~/nanoc%%} %kbd{gem build nanoc.gemspec}
-  %prompt{~/nanoc%%} %kbd{gem install nanoc-*.gem}
-
-p. Nanoc 4 takes a clean break from the past, removing anything that was holding back future development.
-
-p. The good news is that Nanoc 4.0 is quite similar to 3.8. Upgrading a Nanoc 3.x site to Nanoc 4.0 only takes minutes.
-
-h2. Why upgrade?
-
-ul[spacious].
-  li. Nanoc 4 brings identifiers with extensions, and thereby solves a long-standing usability issue. It also introduces glob patterns, which makes rules easier to write.
-
-  li. Nanoc 4 paves the way for new features and performance improvements. Nanoc 3 exposed its internals in a public API, making it hard to make significant changes.
-
-  li. Nanoc 3 is in maintenance mode, which means it will only get critical bug fixes.
-
-h2. Installing Nanoc 4
-
-p. Before installing, ensure you have a supported version of Ruby. Nanoc supports Ruby 2.2 and up, and JRuby 9000 and up:
-
-listing.
-  %prompt{%%} %kbd{ruby --version}
-  %erb{config[:ruby_version_info]}
-  %prompt{%%}
-
-p. To upgrade Ruby, follow the %ref[url=https://www.ruby-lang.org/en/documentation/installation/]{installation instructions on the Ruby web site}.
-
-p. You can install Nanoc 4 using RubyGems:
-
-listing.
-  %prompt{%%} %kbd{gem install nanoc}
-
-note. %entity{sudo-gem-install}
-
-p. We recommend using %ref[url=http://bundler.io/]{Bundler} to manage dependencies. When using Bundler, ensure there is a line for Nanoc in the %filename{Gemfile} that looks like this:
-
-listing[lang=ruby].
-  gem 'nanoc', '~> 4.0'
-
-h2[id=quick-upgrade-guide]. Quick upgrade guide
-
-p. The following steps will get a Nanoc 3 site working on Nanoc 4 with a minimal amount of changes.
-
-ol[spacious].
-  li. Change mentions of %code{Nanoc3} to %code{Nanoc}.
-
-  li. Change mentions of %code{@site.config} to %code{@config}.
-
-  li. Add %code{identifier_type: legacy} to the individual data source configurations. For example:
-
-    listing[lang=yaml,legacy].
-      data_sources:
-        -
-          type: filesystem
-
-    listing[lang=yaml,new].
-      data_sources:
-        -
-          type: filesystem
-          identifier_type: legacy
-
-  li. Add %code{string_pattern_type: legacy} to the configuration file. For example:
-
-    listing[lang=yaml,legacy].
-      data_sources:
-        -
-          type: filesystem
-          identifier_type: legacy
-
-    listing[lang=yaml,new].
-      string_pattern_type: legacy
-      data_sources:
-        -
-          type: filesystem
-          identifier_type: legacy
-
-  li. In Rules, remove the %code{rep.} prefix from %code{filter}, %code{layout} and %code{snapshot}. For example:
-
-    listing[lang=ruby,legacy].
-      compile '*' do
-        rep.filter :erb
-        rep.layout 'default'
-      end
-
-    listing[lang=ruby,new].
-      compile '*' do
-        filter :erb
-        layout 'default'
-      end
-
-  li. In the %code{preprocess} block, use %code{@items.create} rather than instantiating %code{Nanoc::Item}. For example:
-
-    listing[lang=ruby,legacy].
-      @items << Nanoc::Item.new('Hello', {%}, '/hello/')
-
-    listing[lang=ruby,new].
-      @items.create('Hello', {%}, '/hello/')
-
-  li. In data sources, use %code{#new_item} or %code{#new_layout} rather than instantiating %code{Nanoc::Item} or %code{Nanoc::Layout}. For example:
-
-    listing[lang=ruby,legacy].
-      def items
-        [Nanoc::Item.new('Hello', {%}, '/hello/')]
-      end
-
-    listing[lang=ruby,new].
-      def items
-        [new_item('Hello', {%}, '/hello/')]
-      end
-
-  li. Replace %code{.reps[0]} by %code{.reps[:default]}. For example:
-
-    listing[lang=ruby,legacy].
-      item.reps[0].path
-
-    listing[lang=ruby,new].
-      item.reps[:default].path
-
-  li. Replace calls to %code{#rep_named} by %code{reps[%var{something}]}, where %var{something} is the argument to %code{#rep_named}. For example:
-
-    listing[lang=ruby,legacy].
-      item.rep_named(:raw).path
-
-    listing[lang=ruby,new].
-      item.reps[:raw].path
-
-  li. If you use the static data source, disable it for now and follow the extended upgrade instructions below.
-
-h2. Extended upgrade guide
-
-p. This section describes how to upgrade a site to identifiers with extensions and glob patterns. For details, see %ref[item=/doc/identifiers-and-patterns.*]{}.
-
-p. This section assumes you have already upgraded the site following the instructions in %ref[frag=quick-upgrade-guide]{} above.
-
-p. Before you start, add %code{enable_output_diff: true} to the configuration file. This will let the %command{compile} command write out a diff with the changes to the compiled output. This diff will allow you to verify that no unexpected changes occur.
-
-tip. If you use a filter that minifies HTML content, such as %code{html5small}, we recommend turning it off before upgrading the site, so that the output diff becomes easier to read.
-
-h3. Enabling glob patterns
-
-p. Before enabling them, ensure you are familiar with glob patterns. For details, see %ref[item=/doc/identifiers-and-patterns.*,frag=glob-patterns]{}.
-
-p. To use glob patterns:
-
-ol[spacious].
-  li. Set %code{string_pattern_type} to %code{glob} in the configuration file. For example:
-
-    listing[lang=yaml,legacy].
-      string_pattern_type: legacy
-
-    listing[lang=yaml,new].
-      string_pattern_type: glob
-
-  li. Ensure that all string patterns in the %filename{Rules} file, as well as in calls to %code{@items[…]}, %code{@layouts[…]}, and %code{#render} throughout the site, start and end with a slash. This is an intermediate step. For example:
-
-    listing[lang=ruby,legacy].
-      # Before
-      compile 'articles/*' do
-        layout 'default'
-      end
-
-    listing[lang=ruby,legacy].
-      # After
-      compile '/articles/*/' do
-        layout '/default/'
-      end
-
-    listing[lang=ruby,legacy].
-      # Before
-      @items['foo']
-      @layouts['/bar']
-
-    listing[lang=ruby,legacy].
-      # After
-      @items['/foo/']
-      @layouts['/bar/']
-
-    listing[lang=rhtml,legacy].
-      <!-- Before -->
-      <%%= render 'header' %%>
-
-    listing[lang=rhtml,legacy].
-      <!-- After -->
-      <%%= render '/header/' %%>
-
-  li. Replace %code{*} and %code{+} with %code{**/*} in all string patterns in the %filename{Rules} file, as well as in calls to %code{@items[…]}, %code{@layouts[…]}, and %code{#render} throughout the site. For example:
-
-    listing[lang=ruby,legacy].
-      compile '/articles/*/' do
-        layout '/default/'
-      end
-
-    listing[lang=ruby,new].
-      compile '/articles/**/*/' do
-        layout '/default/'
-      end
-
-    listing[lang=ruby,legacy].
-      @items['/articles/*/']
-
-    listing[lang=ruby,new].
-      @items['/articles/**/*/']
-
-p. This approach should work out of the box: Nanoc should not raise errors and the output diff should be empty.
-
-h3. Enabling identifiers with extensions
-
-note. This section assumes that glob patterns have been enabled.
-
-p. Before enabling them, ensure you are familiar with identifiers with extensions. See %ref[item=/doc/identifiers-and-patterns.*,frag=identifiers]{} section for documentation.
-
-p. To use identifiers with extensions:
-
-ol[spacious].
-  li. Set %code{identifier_type} to %code{full} in the configuration file. For example:
-
-    listing[lang=yaml,legacy].
-      identifier_type: legacy
-
-    listing[lang=yaml,new].
-      identifier_type: full
-
-  li. Remove the trailing slash from any argument to %code{#compile}, %code{#route} and %code{#layout} in the %filename{Rules} file, as well as in calls to %code{@items[…]}, %code{@layouts[…]}, and %code{#render} throughout the site. If the pattern does not end with a “%code{*}”, add “%code{.*}”. For example:
-
-    listing[lang=ruby,legacy].
-      compile '/articles/**/*/' do
-        filter :kramdown
-        layout '/default/'
-      end
-
-      compile '/about/' do
-        layout '/default/'
-      end
-
-    listing[lang=ruby,new].
-      compile '/articles/**/*' do
-        filter :kramdown
-        layout '/default.*'
-      end
-
-      compile '/about.*' do
-        layout '/default.*'
-      end
-
-    listing[lang=ruby,legacy].
-      @items['/about/']
-      @layouts['/default/']
-
-    listing[lang=ruby,new].
-      @items['/about.*']
-      @layouts['/default.*']
-
-    listing[lang=rhtml,legacy].
-      <%%= render '/root/' %%>
-
-    listing[lang=rhtml,new].
-      <%%= render '/root.*' %%>
-
-  li. Update the routing rules to output the correct path. For example:
-
-    listing[lang=ruby,legacy].
-      route '/articles/*/' do
-        # /articles/foo/ gets written to /articles/foo/index.html
-        item.identifier + 'index.html'
-      end
-
-    listing[lang=ruby,new].
-      route '/articles/**/*' do
-        # /articles/foo.md gets written to /articles/foo/index.html
-        item.identifier.without_ext + '/index.html'
-      end
-
-  li. Create a routing rule that matches index files in the content directory (such as %filename{content/index.md} or %filename{content/blog/index.md}). For example, put the following _before_ any rules matching %code{/**/*}:
-
-    listing[lang=ruby,new].
-      route '/**/index.*' do
-        # /projects/index.md gets written to /projects/index.html
-        item.identifier.without_ext + '.html'
-      end
-
-  li. Replace calls to %code{#children} with a call to %code{#find_all}, passing a pattern that matches the children. For example:
-
-    listing[lang=ruby,legacy].
-      @items['/articles/'].children
-      @item.children
-
-    listing[lang=ruby,new].
-      @items.find_all('/articles/*')
-      @items.find_all(@item.identifier.without_ext + '/*')
-
-  li. Replace calls to %code{#parent} with a call to %code{#[]}, passing a pattern that matches the parent. For example:
-
-    listing[lang=ruby,legacy].
-      @item.parent
-
-    listing[lang=ruby,new].
-      @items[@item.identifier.to_s.sub(/[^\/]+$/, '').chop + '.*']
-
-note. When using identifiers with extensions, the children and parent of an item are no longer unambiguous. For example, the two items %filename{/foo.md} and %filename{/foo.adoc} both have %filename{/foo/bar.md} as a child, and %filename{/foo/bar.md} has two parents.
-
-h3. Upgrading from the static data source
-
-note. This section assumes that glob patterns and identifiers with extensions have been enabled.
-
-p. The static data source no longer exists in Nanoc 4. It existed in Nanoc 3 to work around the problem of identifiers not including the file extension, which is no longer the case in Nanoc 4.
-
-p. Theoretically, with identifiers with extensions enabled, it is possible to move the contents of the %filename{static/} directory into %filename{content/}. This can be tricky, however, because some rules that did not match any items in %filename{static/} might now match.
-
-p. Because of this, the recommend approach for upgrading is to keep the %filename{static/} directory, and set up a new data source that reads from this directory.
-
-p. In the site configuration, re-enable the static data source, change its type to %code{filesystem}, set %code{content_dir} to %code{"static"} and %code{layouts_dir} to %code{null}:
-
-listing[lang=yaml,new].
-  data_sources:
-    -
-      type: filesystem
-    -
-      type: filesystem
-      items_root: /static
-      content_dir: 'static'
-      layouts_dir: null
-
-p. The null value for the %code{layouts_dir} option prevents this data source from loading layouts—the other data source already does so.
-
-p. Lastly, update the rules to copy these items as-is, but without the %code{/static} prefix:
-
-listing[lang=ruby,new].
-  compile '/static/**/*' do
-  end
-
-  route '/static/**/*' do
-    # /static/foo.html → /foo.html
-    item.identifier.to_s.sub(/\A\/static/, '')
-  end
-
-p. This approach should work out of the box: Nanoc should not raise errors and the output diff should be empty.
-
-p. A final improvement would be to move the contents of the %filename{static/} directory into %filename{content/}. The main thing to watch out for with this approach is rules that accidentally match the wrong items.
-
-h2. Troubleshooting
-
-ol[spacious].
-  li. If you use Nanoc with a Gemfile, ensure you call Nanoc as %kbd{bundle exec nanoc}. Nanoc no longer attempts to load the Gemfile.
-
-  li. If you get a %code{NoMethodError} error on %code{Nanoc::Identifier}, call %code{.to_s} on the identifier before doing anything with it. In Nanoc 4.x, identifiers have their own class and are no longer strings.
-
-  listing[lang=ruby,legacy].
-    item.identifier[7..-2]
-
-  listing[lang=ruby,new].
-    item.identifier.to_s[7..-2]
-
-  li. If you get a %code{NoMethodError} that you did not expect, you might be using a private API that is no longer present in Nanoc 4.0. In case of doubt, ask for help on the %ref[url=http://nanoc.ws/community/#discussion-groups]{discussion group}.
-
-h2. Removed features
-
-p. The %code{watch} and %code{autocompile} commands have been removed. Both were deprecated in Nanoc 3.6. Use %ref[url=https://github.com/guard/guard-nanoc]{%productname{guard-nanoc}} instead.
-
-p. Because Nanoc’s focus is now more clearly on compiling content rather than managing it, the following features have been removed:
-
-ol.
-  li. the %code{create-item} and %code{create-layout} commands
-  li. the %code{update} and %code{sync} commands
-  li. VCS integration (along with %code{Nanoc::Extra::VCS})
-  li. the %code{DataSource#create_item} and %code{DataSource#create_layout} methods.