d-mark 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e6f0ea7fb496bb3aadc7ea266b4a0a7650eaa05
+  data.tar.gz: 80049f389cec0e03ecf36c7d91320f99d2e45c89
+SHA512:
+  metadata.gz: 65ccc586b328445e4b76e4b6c0d020055b00c209f73a6c392449b47cc4ec14aef7c3d3a4ac2e72769ca34ba270fa0855148363eb1a5d046ddb248ee865e5e079
+  data.tar.gz: 1854baf6627c1c856255d855cc0f1e4b3dcac4b273843b64c205fc0c3902e5f651b31b152598a26618225a6b21ed89e80811769c77d372f8874203a2ab80314a

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :devel do
+  gem 'guard-rake'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'yard'
+end

data/Gemfile.lock

@@ -0,0 +1,84 @@
+PATH
+  remote: .
+  specs:
+    dmark (0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.2.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-rake (1.0.0)
+      guard
+      rake
+    listen (3.0.5)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parser (2.3.0.2)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.1.0)
+    rake (10.5.0)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    rubocop (0.36.0)
+      parser (>= 2.3.0.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+    ruby-progressbar (1.7.5)
+    shellany (0.0.1)
+    slop (3.6.0)
+    thor (0.19.1)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.11.2, < 2.0)
+  dmark!
+  guard-rake
+  rake
+  rspec
+  rubocop
+  yard
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Denis Defreyne and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/NEWS.md

@@ -0,0 +1,7 @@
+# D★Mark news
+
+## 0.1 (???)
+
+Features:
+
+* Initial release

data/README.md

@@ -0,0 +1,70 @@
+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

data/Rakefile

@@ -0,0 +1,3 @@
+Rake.add_rakelib 'tasks'
+
+task default: [:test, :rubocop]

data/d-mark.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/dmark/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'd-mark'
+  s.version     = DMark::VERSION
+  s.homepage    = 'http://rubygems.org/gems/d-mark'
+  s.summary     = 'markup language for writing text'
+  s.description = 'D★Mark is a markup language aimed at being able to write semantically meaningful text without limiting itself to the semantics provided by HTML or Markdown.'
+
+  s.author  = 'Denis Defreyne'
+  s.email   = 'denis.defreyne@stoneship.org'
+  s.license = 'MIT'
+
+  s.files =
+    Dir['[A-Z]*'] +
+    Dir['{bin,lib,tasks,spec,samples,scripts}/**/*'] +
+    ['d-mark.gemspec']
+  s.require_paths = ['lib']
+
+  s.rdoc_options     = ['--main', 'README.md']
+  s.extra_rdoc_files = ['LICENSE', 'README.md', 'NEWS.md']
+
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_development_dependency('bundler', '>= 1.11.2', '< 2.0')
+end

data/lib/dmark.rb

@@ -0,0 +1,9 @@
+module DMark
+end
+
+require_relative 'dmark/lexer'
+require_relative 'dmark/nodes'
+require_relative 'dmark/parser'
+require_relative 'dmark/tokens'
+require_relative 'dmark/translator'
+require_relative 'dmark/version'

data/lib/dmark/lexer.rb

@@ -0,0 +1,235 @@
+module DMark
+  class Lexer
+    INDENTATION = 2
+
+    def initialize(string)
+      @string = string
+
+      @element_stack = []
+      @tokens = []
+      @pending_blanks = 0
+    end
+
+    def run
+      @string.lines.each_with_index do |line, line_nr|
+        case line
+        when /^\s+$/
+          # blank line
+          @pending_blanks += 1
+        when /^(\s*)([a-z0-9-]+)(\[(.*?)\])?\.\s*$/
+          # empty element
+          indentation = Regexp.last_match[1]
+          element = Regexp.last_match[2]
+          attributes = parse_attributes(Regexp.last_match[4])
+
+          unwind_stack_until(indentation.size)
+
+          @element_stack << element
+          @tokens << DMark::Tokens::TagBeginToken.new(name: element, attributes: attributes)
+        when /^(\s*)([a-z0-9-]+)(\[(.*?)\])?\. (.*)$/
+          # element with inline content
+          indentation = Regexp.last_match[1]
+          element = Regexp.last_match[2]
+          attributes = parse_attributes(Regexp.last_match[4])
+          data = Regexp.last_match[5]
+
+          unwind_stack_until(indentation.size)
+
+          @tokens << DMark::Tokens::TagBeginToken.new(name: element, attributes: attributes)
+          @tokens.concat(lex_inline(data, line_nr + 1))
+          @tokens << DMark::Tokens::TagEndToken.new(name: element)
+        when /^(\s*)(.*)$/
+          # other line (e.g. data)
+          indentation = Regexp.last_match[1]
+          data = Regexp.last_match[2]
+
+          unwind_stack_until(indentation.size)
+
+          if @element_stack.empty?
+            # FIXME: unify format of messages (uppercase, lowercase, …)
+            raise LexerError.new("Can’t insert raw data at root level", line, line_nr, 1)
+          end
+
+          extra_indentation = [indentation.size - INDENTATION * @element_stack.size, 0].max
+
+          @tokens.concat(lex_inline(' ' * extra_indentation + data + "\n", line_nr + 1))
+        end
+      end
+
+      unwind_stack_until(0)
+
+      @tokens
+    end
+
+    private
+
+    def parse_attributes(data)
+      # FIXME: write a proper parser
+
+      (data || '').split(',').map { |part| part.split('=') }.each_with_object({}) do |pair, res|
+        res[pair.first] = pair.last || pair.first
+      end
+    end
+
+    def unwind_stack_until(num)
+      while @element_stack.size * INDENTATION > num
+        elem = @element_stack.pop
+
+        @tokens << DMark::Tokens::TagEndToken.new(name: elem)
+      end
+
+      append_text(@tokens, "\n" * @pending_blanks)
+      @pending_blanks = 0
+    end
+
+    def append_text(out, text)
+      if out.empty? || !out.last.is_a?(DMark::Tokens::TextToken)
+        out << DMark::Tokens::TextToken.new(text: text)
+      else
+        out.last.text << text
+      end
+    end
+
+    class LexerError < StandardError
+      def initialize(message, line, line_nr, col_nr)
+        @message = message
+        @line = line
+        @line_nr = line_nr
+        @col_nr = col_nr
+      end
+
+      class Coloriser
+        def red
+          "\e[31m".freeze
+        end
+
+        def bold
+          "\e[1m".freeze
+        end
+
+        def reset
+          "\e[0m".freeze
+        end
+      end
+
+      class NullColoriser
+        def red
+          ''.freeze
+        end
+
+        def bold
+          ''.freeze
+        end
+
+        def reset
+          ''.freeze
+        end
+      end
+
+      def message
+        formatted_message(NullColoriser.new)
+      end
+
+      def message_for_tty
+        formatted_message(Coloriser.new)
+      end
+
+      def formatted_message(coloriser)
+        line_excerpt_start = [@col_nr - 38, 0].max
+        line_excerpt_end = @col_nr + 38
+        line_excerpt = @line[line_excerpt_start..line_excerpt_end]
+
+        if line_excerpt_start > 0
+          line_excerpt[0] = '…'
+        end
+
+        if line_excerpt_end < @line.size
+          line_excerpt[-1] = '…'
+        end
+
+        [
+          "#{coloriser.red}#{coloriser.bold}ERROR#{coloriser.reset} (line #{@line_nr}, col #{@col_nr}): #{coloriser.red}#{@message}#{coloriser.reset}",
+          '',
+          line_excerpt,
+          coloriser.red + ' ' * (@col_nr - 1 - line_excerpt_start) + '^' + coloriser.reset,
+          '',
+        ].join("\n")
+      end
+    end
+
+    def lex_inline(string, line_nr)
+      stack = []
+      state = :root
+      tokens = []
+      name = ''
+      attributes = ''
+      col_nr = 0
+
+      string.chars.each_with_index do |char|
+        col_nr += 1
+
+        case state
+        when :root
+          case char
+          when '%'
+            state = :after_pct
+          when '}'
+            if stack.empty?
+              message = 'Unexpected `}`. Try escaping it as `%}`.'
+              raise LexerError.new(message, string, line_nr, col_nr)
+            else
+              data = stack.pop
+              case data.first
+              when :raw
+                append_text(tokens, data.last)
+              when :elem
+                tokens << DMark::Tokens::TagEndToken.new(name: data.last)
+              else
+                raise "Unexpected entry on stack: #{data.inspect}"
+              end
+            end
+          else
+            append_text(tokens, char)
+          end
+        when :after_pct
+          # FIXME: require at least one character after %
+
+          case char
+          when 'a'..'z', '0'..'9', '-'
+            name << char
+          when '%' # escaped
+            state = :root
+            col_nr -= 1
+            append_text(tokens, '%')
+          when '}' # escaped
+            state = :root
+            col_nr -= 1
+            append_text(tokens, '}')
+          when '['
+            state = :after_lbracket
+          when '{'
+            state = :root
+            stack << [:elem, name]
+            tokens << DMark::Tokens::TagBeginToken.new(name: name, attributes: parse_attributes(attributes))
+            name = ''
+            attributes = ''
+          else
+            raise LexerError.new("unexpected `#{char}` after `%`", string, line_nr, col_nr)
+          end
+        when :after_lbracket
+          case char
+          when ']'
+            # FIXME: might make sense to have after_rbracket instead (to prevent %foo[a][b]{…})
+            state = :after_pct
+          else
+            attributes << char
+          end
+        else
+          raise "Unexpected state: #{state.inspect}"
+        end
+      end
+
+      tokens
+    end
+  end
+end

data/lib/dmark/nodes.rb

@@ -0,0 +1,76 @@
+module DMark
+  module Nodes
+    class Node
+      attr_reader :children
+
+      def initialize
+        @children = []
+      end
+
+      def inspect(_indent = 0)
+        'Node()'
+      end
+    end
+
+    class RootNode < Node
+      def inspect(indent = 0)
+        io = ''
+        io << '  ' * indent
+        io << 'Root('
+        io << "\n" if children.any?
+        children.each { |c| io << c.inspect(indent + 1) }
+        io << '  ' * indent if children.any?
+        io << ')'
+        io << "\n"
+        io
+      end
+    end
+
+    class TextNode < Node
+      attr_reader :text
+
+      def initialize(text:)
+        super()
+        @text = text
+      end
+
+      def inspect(indent = 0)
+        io = ''
+        io << '  ' * indent
+        io << 'Text('
+        io << @text.inspect
+        io << "\n" if children.any?
+        children.each { |c| io << c.inspect(indent + 1) }
+        io << '  ' * indent if children.any?
+        io << ')'
+        io << "\n"
+        io
+      end
+    end
+
+    class ElementNode < Node
+      attr_reader :name
+      attr_reader :attributes
+
+      def initialize(name:, attributes:)
+        super()
+        @name = name
+        @attributes = attributes
+      end
+
+      def inspect(indent = 0)
+        io = ''
+        io << '  ' * indent
+        io << 'Element('
+        io << @name
+        io << ',' << @attributes.inspect unless @attributes.empty?
+        io << "\n" if children.any?
+        children.each { |c| io << c.inspect(indent + 1) }
+        io << '  ' * indent if children.any?
+        io << ')'
+        io << "\n"
+        io
+      end
+    end
+  end
+end

data/lib/dmark/parser.rb

@@ -0,0 +1,28 @@
+module DMark
+  class Parser
+    def initialize(tokens)
+      @tokens = tokens
+
+      @root_node = DMark::Nodes::RootNode.new
+    end
+
+    def run
+      node_stack = [@root_node]
+
+      @tokens.each do |token|
+        case token
+        when DMark::Tokens::TextToken
+          node_stack.last.children << DMark::Nodes::TextNode.new(text: token.text)
+        when DMark::Tokens::TagBeginToken
+          new_node = DMark::Nodes::ElementNode.new(name: token.name, attributes: token.attributes)
+          node_stack.last.children << new_node
+          node_stack.push(new_node)
+        when DMark::Tokens::TagEndToken
+          node_stack.pop
+        end
+      end
+
+      @root_node
+    end
+  end
+end

data/lib/dmark/tokens.rb

@@ -0,0 +1,49 @@
+module DMark
+  module Tokens
+    class Token
+      def to_s
+        raise NotImplementedError
+      end
+    end
+
+    class TextToken < Token
+      attr_reader :text
+
+      def initialize(text:)
+        @text = text
+      end
+
+      def to_s
+        "Text(#{@text.inspect})"
+      end
+    end
+
+    class AbstractTagToken < Token
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+    end
+
+    class TagBeginToken < AbstractTagToken
+      attr_reader :attributes
+
+      def initialize(name:, attributes:)
+        super(name: name)
+
+        @attributes = attributes
+      end
+
+      def to_s
+        "TagBegin(#{name.inspect}, #{attributes.inspect})"
+      end
+    end
+
+    class TagEndToken < AbstractTagToken
+      def to_s
+        "TagEnd(#{name.inspect})"
+      end
+    end
+  end
+end

data/lib/dmark/translator.rb

@@ -0,0 +1,26 @@
+module DMark
+  class Translator
+    attr_reader :out
+
+    def initialize(tree)
+      @tree = tree
+
+      @out = ''
+    end
+
+    def run
+      handle(@tree)
+      @out
+    end
+
+    private
+
+    def handle(_node)
+      raise NotImplementedError
+    end
+
+    def handle_children(node)
+      node.children.each { |child| handle(child) }
+    end
+  end
+end

data/lib/dmark/version.rb

@@ -0,0 +1,3 @@
+module DMark
+  VERSION = '0.1'.freeze
+end

data/samples/identifiers-and-patterns.dmark

@@ -0,0 +1,122 @@
+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/}.

data/samples/identifiers-and-patterns.html

@@ -0,0 +1,59 @@
+<p>In Nanoc, every item (page or asset) and every layout has a unique <i>identifier</i>: a string derived from the file’s path. A <i>pattern</i> is an expression that is used to select items or layouts based on their identifier.</p>
+<h2>Identifiers</h2>
+<p>Identifiers come in two types: the <i>full</i> type, new in Nanoc 4, and the <i>legacy</i> type, used in Nanoc 3.</p>
+<dl><dt>full</dt><dd>An identifier with the full type is the filename, with the path to the content directory removed. For example, the file <i>/Users/denis/stoneship/content/about.md</i> will have the full identifier <i>/about.md</i>.</dd>
+<dt>legacy</dt><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 <i>/Users/denis/stoneship/content/about.md</i> will have the legacy identifier <i>/about/</i>. This corresponds closely with paths in clean URLs.</dd></dl>
+<p>The following methods are useful for full identifiers:</p>
+<dl><dt><code>identifier.without_ext</code> → <i>String</i></dt><dd>identifier with the last extension removed</dd>
+<dt><code>identifier.without_exts</code> → <i>String</i></dt><dd>identifier with all extensions removed</dd>
+<dt><code donkey="true">identifier.ext</code> → <i>String</i></dt><dd>the last extension of this identifier</dd>
+<dt><code>identifier.exts</code> → <i>String</i></dt><dd>all extensions of this identifier</dd>
+<dt><code>identifier + string</code> → <i>String</i></dt><dd>identifier with the given string appended</dd></dl>
+<p>Here are some &lt; examples:</p>
+<pre>identifier = Nanoc::Identifier.new('/about.md')
+
+identifier.without_ext
+# => "/about"
+
+identifier.ext
+# => "md"
+</pre>
+<p>The following method is useful for legacy identifiers:</p>
+<dl><dt><code>identifier.chop</code> → <i>String</i></dt><dd>identifier with the last character removed</dd></dl>
+<p>Here are some examples:</p>
+<pre>identifier = Nanoc::Identifier.new('/about/', type: :legacy)
+
+identifier.chop
+# => "/about"
+
+identifier.chop + '.html'
+# => "/about.html"
+
+identifier + 'index.html'
+# => "/about/index.html"
+</pre>
+<h2>Patterns</h2>
+<p>Patterns are used to find items and layouts based on their identifier. They come in three varieties:</p>
+<ul><li>glob patterns</li><li>regular expression patterns</li><li>legacy patterns</li></ul>
+<h3>Glob patterns</h3>
+<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 <i>/projects/*.md</i>, which matches all files with a <i>md</i> extension in the <i>/projects</i> directory.</p>
+<p>Globs are commonplace in Unix-like environments. For example, the Unix command for listing all files with the <i>md</i> extension in the current directory is <code>ls *.md</code>. In this example, the argument to the <code>ls</code> command is a wildcard.</p>
+<p>Nanoc supports the following wildcards in glob patterns:</p>
+<dl><dt><code>*</code></dt><dd>Matches any file or directory name. Does not cross directory boundaries. For example, <i>/projects/*.md</i> matches <i>/projects/nanoc.md</i>, but not <i>/projects/cri.adoc</i> nor <i>/projects/nanoc/about.md</i>.</dd>
+<dt><code>**/</code></dt><dd>Matches zero or more levels of nested directories. For example, <i>/projects/**/*.md</i> matches both <i>/projects/nanoc.md</i> and <i>/projects/nanoc/history.md</i>.</dd>
+<dt><code>?</code></dt><dd>Matches a single character.</dd>
+<dt><code>[abc]</code></dt><dd>Matches any single character in the set. For example, <i>/people/[kt]im.md</i> matches only <i>/people/kim.md</i> and <i>/people/tim.md</i>.</dd>
+<dt><code>{foo,bar}</code></dt><dd>Matches either string in the comma-separated list. More than two strings are possible. For example, <i>/c{at,ub,ount}s.txt</i> matches <i>/cats.txt</i>, <i>/cubs.txt</i> and <i>/counts.txt</i>, but not <i>/cabs.txt</i>.</dd></dl>
+<p>A glob pattern that matches every item is <i>/**/*</i>. A glob pattern that matches every item/layout with the extension <i>md</i> is <i>/**/*.md</i>.</p>
+<h3>Regular expression patterns</h3>
+<p>You can use a regular expression to select items and layouts.</p>
+<p>For matching identifiers, the <code>%r{…}</code> syntax is (arguably) nicer than the <code>/…/</code> syntax. The latter is not a good fit for identifiers (or filenames), because all slashes need to be escaped. The <code>\A</code> and <code>\z</code> anchors are also useful to make sure the entire identifier is matched.</p>
+<p>An example of a regular expression pattern is <code>%r{\A/projects/(cri|nanoc)\.md\z}</code>, which matches both <i>/projects/nanoc.md</i> and <i>/projects/cri.md</i>.</p>
+<h3>Legacy patterns</h3>
+<p>Legacy patterns are strings that contain wildcard characters. The wildcard characters behave differently than the glob wildcard characters.</p>
+<p>To enable legacy patterns, set <code>string_pattern_type</code> to <code>"legacy"</code> in the configuration. For example:</p>
+<pre>string_pattern_type: "legacy"
+</pre>
+<p>For legacy patterns, Nanoc supports the following wildcards:</p>
+<dl><dt><code>*</code></dt><dd>Matches zero or more characters, including a slash. For example, <i>/projects/*/</i> matches <i>/projects/nanoc/</i> and <i>/projects/nanoc/about/</i>, but not <i>/projects/</i>.</dd>
+<dt><code>+</code></dt><dd>Matches one or more characters, including a slash. For example, <i>/projects/+</i> matches <i>/projects/nanoc/</i> and <i>/projects/nanoc/about/</i>, but not <i>/projects/</i>.</dd></dl>

data/scripts/translate-to-html.rb

@@ -0,0 +1,46 @@
+require_relative '../lib/dmark'
+
+class MyHTMLTranslator < 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 << "<#{translate_elem_name(node.name)}>"
+      handle_children(node)
+      out << "</#{translate_elem_name(node.name)}>"
+    end
+  end
+
+  def translate_elem_name(name)
+    case name
+    when 'listing'
+      'pre'
+    when 'firstterm', 'identifier', 'glob', 'emph', 'filename', 'class'
+      'i'
+    when 'command'
+      'code'
+    when 'p', 'dl', 'dt', 'dd', 'code', 'h1', 'h2', 'h3', 'ul', 'li'
+      name
+    else
+      raise "Cannot translate #{name}"
+    end
+  end
+end
+
+# Lex
+begin
+  tokens = DMark::Lexer.new(File.read(ARGV[0])).run
+rescue DMark::Lexer::LexerError => e
+  $stderr.puts e.message_for_tty
+  exit 1
+end
+
+# Parse
+tree = DMark::Parser.new(tokens).run
+
+# Translate
+result = MyHTMLTranslator.new(tree).run
+puts result

data/tasks/doc.rake

@@ -0,0 +1,13 @@
+require 'yard'
+
+YARD::Rake::YardocTask.new(:doc) do |yard|
+  yard.files   = Dir['lib/**/*.rb']
+  yard.options = [
+    '--markup',          'markdown',
+    '--markup-provider', 'kramdown',
+    '--charset',         'utf-8',
+    '--readme',          'README.md',
+    '--files',           'NEWS.md,LICENSE',
+    '--output-dir',      'doc/yardoc',
+  ]
+end

data/tasks/rubocop.rake

@@ -0,0 +1,6 @@
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options  = %w( --display-cop-names --format simple )
+  task.patterns = ['lib/**/*.rb', 'spec/**/*.rb']
+end

data/tasks/test.rake

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-r ./spec/spec_helper.rb --color'
+  t.verbose = false
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: d-mark
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Denis Defreyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: D★Mark is a markup language aimed at being able to write semantically
+  meaningful text without limiting itself to the semantics provided by HTML or Markdown.
+email: denis.defreyne@stoneship.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- NEWS.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- NEWS.md
+- README.md
+- 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
+- samples/identifiers-and-patterns.dmark
+- samples/identifiers-and-patterns.html
+- scripts/translate-to-html.rb
+- tasks/doc.rake
+- tasks/rubocop.rake
+- tasks/test.rake
+homepage: http://rubygems.org/gems/d-mark
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: markup language for writing text
+test_files: []
+has_rdoc: