d-mark 0.1 → 0.2.0

data/samples/trivial.dmark

@@ -0,0 +1 @@
+p. I’m a %em{trivial} example!

data/samples/trivial.rb

@@ -0,0 +1,20 @@
+require 'd-mark'
+
+class MyHTMLTranslator < DMark::Translator
+  def handle(node)
+    case node
+    when String
+      out << node
+    when DMark::Parser::ElementNode
+      out << "<#{node.name}>"
+      handle_children(node)
+      out << "</#{node.name}>"
+    end
+  end
+end
+
+content = File.read('samples/trivial.dmark')
+parser = DMark::Parser.new(content)
+tree = parser.parse
+
+puts MyHTMLTranslator.new(tree).run

data/spec/d-mark/parser_spec.rb

@@ -0,0 +1,271 @@
+def parse(s)
+  DMark::Parser.new(s).parse
+end
+
+def element(name, attributes, children)
+  DMark::Parser::ElementNode.new(name, attributes, children)
+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 ', '}'])]
+  end
+
+  it 'parses escaped % in block' do
+    expect(parse('p. %%')).to eq [
+      element('p', {}, ['%'])
+    ]
+  end
+
+  it 'parses escaped } in block' do
+    expect(parse('p. %}')).to eq [
+      element('p', {}, ['}'])
+    ]
+  end
+
+  it 'parses escaped % in inline block' do
+    expect(parse('p. %foo{%%}')).to eq [
+      element(
+        'p', {},
+        [
+          element('foo', {}, ['%'])
+        ]
+      )
+    ]
+  end
+
+  it 'parses escaped } in inline block' do
+    expect(parse('p. %foo{%}}')).to eq [
+      element(
+        'p', {},
+        [
+          element('foo', {}, ['}'])
+        ])
+    ]
+  end
+
+  it 'parses block with text and element content' do
+    expect(parse('p. hi %em{ho}')).to eq [
+      element(
+        'p', {}, [
+          'hi ',
+          element('em', {}, ['ho'])
+        ]
+      )
+    ]
+  end
+
+  it 'parses block with text and element content, followed by newline' do
+    expect(parse("p. hi %em{ho}\n")).to eq [
+      element(
+        'p', {}, [
+          'hi ',
+          element('em', {}, ['ho'])
+        ]
+      )
+    ]
+  end
+
+  it 'parses children' do
+    expect(parse("p. hi %em{ho}\n  p. child p")).to eq [
+      element(
+        'p', {}, [
+          'hi ',
+          element('em', {}, ['ho']),
+          element('p', {}, ['child p'])
+        ]
+      )
+    ]
+  end
+
+  it 'parses children multiple levels deep' do
+    expect(parse("p. hi %em{ho}\n  p. child p\n    p. subchild p")).to eq [
+      element(
+        'p', {}, [
+          'hi ',
+          element('em', {}, ['ho']),
+          element(
+            'p', {}, [
+              'child p',
+              element(
+                'p', {}, [
+                  'subchild p'
+                ]
+              )
+            ]
+          )
+        ]
+      )
+    ]
+  end
+
+  it 'ignores blanks' do
+    expect(parse("p. foo\n \n  p. bar\n  \n\n    p. qux")).to eq [
+      element(
+        'p', {}, [
+          'foo',
+          element(
+            'p', {}, [
+              'bar',
+              element(
+                'p', {}, [
+                  'qux'
+                ]
+              )
+            ]
+          )
+        ]
+      )
+    ]
+  end
+
+  it 'reads multiple consecutive blocks' do
+    expect(parse("p. foo\np. bar")).to eq [
+      element('p', {}, ['foo']),
+      element('p', {}, ['bar'])
+    ]
+  end
+
+  it 'includes raw content' do
+    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 [
+      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 [
+      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 [
+      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 [
+      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'])
+              ])
+    ]
+  end
+
+  it 'parses empty attributes' do
+    expect(parse('p[]. hi')).to eq [
+      element('p', {}, ['hi'])
+    ]
+  end
+
+  it 'parses single attribute' do
+    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 [
+      element('p', { 'foo' => 'foo' }, ['hi'])
+    ]
+  end
+
+  it 'parses multiple attributes' do
+    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 [
+      element('p', { 'foo' => 'foo', 'qux' => 'qux' }, ['hi'])
+    ]
+  end
+
+  it 'parses escaped attributes' do
+    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 [
+      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 [
+      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 [
+      element('p', {}, ['foo.bar'])
+    ]
+  end
+
+  it 'parses child block without content' do
+    expect(parse("ul.\n  li.\n    p. You can.")).to eq [
+      element(
+        'ul', {},
+        [
+          element(
+            'li', {},
+            [
+              element('p', {}, ['You can.'])
+            ]
+          )
+        ]
+      )
+    ]
+  end
+
+  it 'parses child block without content at end' do
+    expect(parse("ul.\n  li.")).to eq [
+      element(
+        'ul', {},
+        [
+          element('li', {}, [])
+        ]
+      )
+    ]
+  end
+
+  it 'parses child block with attributes' do
+    expect(parse("ul.\n  li[foo].")).to eq [
+      element(
+        'ul', {},
+        [
+          element('li', { 'foo' => 'foo' }, [])
+        ]
+      )
+    ]
+  end
+
+  it 'does not parse' do
+    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)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require 'd-mark'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: d-mark
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.2.0
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-02-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -37,29 +51,27 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.md
+- README.adoc
 - NEWS.md
 files:
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - LICENSE
 - NEWS.md
-- README.md
+- README.adoc
 - Rakefile
 - d-mark.gemspec
-- lib/dmark.rb
-- lib/dmark/lexer.rb
-- lib/dmark/nodes.rb
-- lib/dmark/parser.rb
-- lib/dmark/tokens.rb
-- lib/dmark/translator.rb
-- lib/dmark/version.rb
+- lib/d-mark.rb
+- lib/d-mark/cli.rb
+- lib/d-mark/parser.rb
+- lib/d-mark/translator.rb
+- lib/d-mark/version.rb
 - samples/identifiers-and-patterns.dmark
-- samples/identifiers-and-patterns.html
-- scripts/translate-to-html.rb
-- tasks/doc.rake
-- tasks/rubocop.rake
-- tasks/test.rake
+- samples/trivial.dmark
+- samples/trivial.rb
+- spec/d-mark/parser_spec.rb
+- spec/spec_helper.rb
 homepage: http://rubygems.org/gems/d-mark
 licenses:
 - MIT
@@ -67,7 +79,7 @@ metadata: {}
 post_install_message: 
 rdoc_options:
 - "--main"
-- README.md
+- README.adoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -82,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: markup language for writing text

data/README.md

@@ -1,70 +0,0 @@
-D★Mark
-======
-
-**Status:** experimental — use at your own risk!
-
-_D★Mark_ is a markup language for writing text.
-
-It is aimed at being able to write semantically meaningful text without limiting itself to the semantics provided by HTML or Markdown.
-
-## Usage
-
-Handling a D★Mark file consists of three stages: lexing, parsing, and translating.
-
-The lexing stage converts the data into a stream of tokens. Construct a lexer with the data as input, and call `#run` to get the tokens, catching any `DMark::Lexer::LexerError`:
-
-    begin
-      tokens = DMark::Lexer.new(File.read(ARGV[0])).run
-    rescue DMark::Lexer::LexerError => e
-      $stderr.puts e.message_for_tty
-      exit 1
-    end
-
-The parsing stage converts the stream of tokens into a node tree. Construct a parser with the tokens as input, and call `#run` to get the tree.
-
-    tree = DMark::Parser.new(tokens).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 (`RootNode`, `TextNode`, `ElementNode`). For example, the following translator will convert the tree into something that resembles XML:
-
-    class MyXMLLikeTranslator < DMark::Translator
-      def handle(node)
-        case node
-        when DMark::Nodes::RootNode
-          handle_children(node)
-        when DMark::Nodes::TextNode
-          out << node.text
-        when DMark::Nodes::ElementNode
-          out << "<#{node.name}>"
-          handle_children(node)
-          out << "</#{node.name}>"
-        end
-      end
-    end
-
-    result = MyXMLLikeTranslator.new(tree).run
-    puts result
-
-## Samples
-
-The `samples/` directory contains some sample D★Mark files. They can be converted to HTML by running the `scripts/translate-to-html.rb` Ruby script, passing in the name of the file. The resulting HTML will be printed to standard output. For example:
-
-    ruby scripts/translate-to-html.rb samples/identifiers-and-patterns.dmark
-
-## Format
-
-_D★Mark_ knows two constructs:
-
-* Block-level elements. For example:
-
-        p. Patterns are used to find items and layouts based on their identifier. They come in three varieties.
-
-* Inline elements. For example:
-
-        p. Identifiers come in two types: the %emph{full} type, new in Nanoc 4, and the %emph{legacy} type, used in Nanoc 3.
-
-Block-level elements can be nested. For example:
-
-    ul.
-      li. glob patterns
-      li. regular expression patterns
-      li. legacy patterns