d-mark 1.0.0a1 → 1.0.0b2

data/lib/d-mark/translator.rb

@@ -1,28 +1,57 @@
 module DMark
   class Translator
-    attr_reader :out
+    class UnhandledNode < StandardError
+      attr_reader :node
 
-    def initialize(nodes)
-      @nodes = nodes
+      def initialize(node)
+        @node = node
+      end
+
+      def message
+        case @node
+        when String
+          'Unhandled string node'
+        when DMark::ElementNode
+          "Unhandled element node #{@node.name.inspect}"
+        else
+          "Unhandled node #{@node.inspect}"
+        end
+      end
+    end
+
+    def self.translate(nodes, context = {})
+      new.translate(nodes, context)
+    end
 
-      @out = ''
+    def translate(nodes, context = {})
+      [nodes.map { |node| handle(node, context) }].flatten.join('')
     end
 
-    def run
-      @nodes.each do |node|
-        handle(node)
+    def handle(node, context = {})
+      case node
+      when String
+        handle_string(node, context)
+      when DMark::ElementNode
+        handle_element(node, context)
+      else
+        raise ArgumentError, "Cannot handle #{node.class}"
       end
-      @out
     end
 
-    private
+    # @abstract
+    def handle_string(string, _context)
+      raise DMark::Translator::UnhandledNode.new(string)
+    end
 
-    def handle(_node)
-      raise NotImplementedError
+    # @abstract
+    def handle_element(element, _context)
+      raise DMark::Translator::UnhandledNode.new(element)
     end
 
-    def handle_children(node)
-      node.children.each { |child| handle(child) }
+    private
+
+    def handle_children(node, context)
+      node.children.map { |child| handle(child, context) }
     end
   end
 end

data/lib/d-mark/version.rb

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

data/samples/trivial.dmark

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

data/spec/d-mark/parser_spec.rb

@@ -1,34 +1,88 @@
-def parse(s)
-  DMark::Parser.new(s).parse
+def parse(str)
+  DMark::Parser.new(str).parse
 end
 
 def element(name, attributes, children)
   DMark::ElementNode.new(name, attributes, children)
 end
 
+describe DMark::Parser::ParserError do
+  subject(:error) do
+    DMark::Parser.new(content).parse
+  rescue described_class => e
+    break e
+  end
+
+  let(:content) do
+    "#p Stuff\n\n#p More stuff }"
+  end
+
+  describe '#message' do
+    subject { error.message }
+
+    it { is_expected.to eq('parse error at line 3, col 15: unexpected } -- try escaping it as "%}"') }
+  end
+
+  describe '#fancy_message' do
+    subject { error.fancy_message }
+
+    it { is_expected.to eq("parse error at line 3, col 15: unexpected } -- try escaping it as \"%}\"\n\n#p More stuff }\n\e[31m              ↑\e[0m") }
+  end
+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 element with name containing dash' do
+    expect(parse('#intro-para hi')).to eq [
+      element('intro-para', {}, ['hi'])
+    ]
+  end
+
+  it 'parses element with name containing underscore' do
+    expect(parse('#intro_para hi')).to eq [
+      element('intro_para', {}, ['hi'])
+    ]
+  end
+
+  it 'parses element with name containing uppercase letters' do
+    expect(parse('#IntroPara hi')).to eq [
+      element('IntroPara', {}, ['hi'])
+    ]
+  end
+
+  it 'does not parse element with name starting with a dash' do
+    expect { parse('#-intro hi there') }.to raise_error(DMark::Parser::ParserError)
+  end
+
+  it 'does not parse element with name starting with an underscore' do
+    expect { parse('#_intro hi there') }.to raise_error(DMark::Parser::ParserError)
+  end
+
+  it 'does not parse element with name starting with a digit' do
+    expect { parse('#4ever best friends') }.to raise_error(DMark::Parser::ParserError)
   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,17 +93,18 @@ 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', {},
         [
           element('foo', {}, ['}'])
-        ])
+        ]
+      )
     ]
   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 +115,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 +126,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 +138,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 +159,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 +179,140 @@ 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 [
-      element('p', {}, %W(foo \n donkey))
+    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  %em{donkey}")).to eq [
+      element('p', {}, [element('em', {}, ['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 attribute with dash' do
+    expect(parse('#p[intended-audience=learner] hi')).to eq [
+      element('p', { 'intended-audience' => 'learner' }, ['hi'])
+    ]
+  end
+
+  it 'parses attribute with numbers' do
+    expect(parse('#p[is-over-9000=yup] hi')).to eq [
+      element('p', { 'is-over-9000' => 'yup' }, ['hi'])
+    ]
+  end
+
+  it 'parses attribute with underscore' do
+    expect(parse('#p[intended_audience=learner] hi')).to eq [
+      element('p', { 'intended_audience' => 'learner' }, ['hi'])
+    ]
+  end
+
+  it 'parses attribute with uppercase letters' do
+    expect(parse('#p[IntendedAudience=learner] hi')).to eq [
+      element('p', { 'IntendedAudience' => 'learner' }, ['hi'])
+    ]
+  end
+
+  it 'does not parse atttributes starting with -' do
+    expect { parse('#p[-this=is dog] hello yes') }.to raise_error(DMark::Parser::ParserError)
+  end
+
+  it 'does not parse atttributes starting with _' do
+    expect { parse('#p[_this=is dog] hello yes') }.to raise_error(DMark::Parser::ParserError)
+  end
+
+  it 'does not parse atttributes starting with a digit' do
+    expect { parse('#p[4this=is dog] hello yes') }.to raise_error(DMark::Parser::ParserError)
+  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 +328,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 +339,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 +350,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