d-mark 0.1 → 0.2.0

data/lib/dmark.rb

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

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

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

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

@@ -1,49 +0,0 @@
-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/version.rb

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

data/samples/identifiers-and-patterns.html

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