docbert 0.1.0

data/lib/docbert.rb

@@ -0,0 +1,9 @@
+require 'kramdown'
+
+require 'docbert/parser'
+require 'docbert/parser/example_node'
+require 'docbert/parser/definition_node'
+require 'docbert/parser/parameterized_content'
+require 'docbert/converters/gherkin'
+require 'docbert/converters/step_definitions'
+require 'docbert/converters/step_definitions/parameterized_content'

data/lib/docbert/converters/gherkin.rb

@@ -0,0 +1,69 @@
+require 'kramdown/parser/kramdown'
+
+module Docbert
+  module Converters
+    class Gherkin < Kramdown::Converter::Base
+      Kramdown::Converter::Gherkin = self
+
+      def convert(root)
+        root.
+          children.
+          map { |el| send("convert_#{el.type}", el) }.
+          compact.
+          join("\n")
+      end
+
+      private
+
+      def convert_example(el)
+        convert_example_generic('Scenario', el)
+      end
+
+      def convert_example_background(el)
+        _, body = el.children
+
+        "  Background:\n" << convert_example_body(body, "    ")
+      end
+
+      def convert_example_body(body, indent)
+        body.
+          value.
+          split(/\n/).
+          map { |step| "#{indent}#{step.strip}\n" }.
+          join
+      end
+
+      def convert_example_generic(type, el)
+        title, body = el.children
+
+        convert_example_title(title, "  ", type) +
+          convert_example_body(body, "    ")
+      end
+
+      def convert_example_title(title, indent, type)
+        "#{indent}#{type}: #{title.value}\n"
+      end
+
+      def convert_example_outline(el)
+        convert_example_generic('Scenario Outline', el)
+      end
+
+      # Convert a level 1 header to a feature title.
+      #
+      # Current limitations:
+      #   - Expects one and only one level 1 header to exist
+      #   - Doesn't allow additional markup to be specified in the header
+      def convert_header(el)
+        if el.options[:level] == 1
+          feature_title = el.children.first.value
+
+          "Feature: #{feature_title}\n"
+        end
+      end
+
+      def method_missing(name, *args)
+        super if name.to_s !~ /^convert_/
+      end
+    end
+  end
+end

data/lib/docbert/converters/step_definitions.rb

@@ -0,0 +1,52 @@
+require 'kramdown/parser/kramdown'
+
+module Docbert
+  module Converters
+    class StepDefinitions < Kramdown::Converter::Base
+      Kramdown::Converter::StepDefinitions = self
+
+      def convert(root)
+        root.
+          children.
+          map { |el| send("convert_#{el.type}", el) }.
+          compact.
+          join("\n")
+      end
+
+      private
+
+      def convert_example_definition(el)
+        title_el, body_el = el.children
+
+        title    = convert_example_definition_title(title_el)
+        par_list = if title.params.empty?
+                     ''
+                   else
+                     '|' << title.params.join(', ') << '|'
+                   end
+        body  = convert_example_definition_body(body_el)
+
+        <<-STEPD
+        Given(/^#{title}$/) do #{par_list}
+          steps <<-EOS
+          #{body}
+          EOS
+        end
+
+        STEPD
+      end
+
+      def convert_example_definition_body(el)
+        ParameterizedContent.new(el) { |p| '#{' + p + '}' }
+      end
+
+      def convert_example_definition_title(el)
+        ParameterizedContent.new(el) { |p| '(.+)' }
+      end
+
+      def method_missing(name, *args)
+        super if name.to_s !~ /^convert_/
+      end
+    end
+  end
+end

data/lib/docbert/converters/step_definitions/parameterized_content.rb

@@ -0,0 +1,38 @@
+module Docbert
+  module Converters
+    class StepDefinitions
+      class ParameterizedContent
+        def initialize(el, &block)
+          self.el    = el
+          self.block = block
+        end
+
+        def params
+          @params ||= el.
+            children.
+            select { |e| param?(e) }.
+            map    { |e| param(e) }
+        end
+
+        def to_s
+          @s ||= el.
+            children.
+            map { |e| param?(e) ? block.(param(e)) : e.value }.
+            join
+        end
+
+        private
+
+        attr_accessor :el, :block
+
+        def param?(el)
+          el.type == :example_definition_param
+        end
+
+        def param(el)
+          el.value.gsub(' ', '_')
+        end
+      end
+    end
+  end
+end

data/lib/docbert/parser.rb

@@ -0,0 +1,66 @@
+require 'kramdown/parser/kramdown'
+
+module Docbert
+  class Parser < Kramdown::Parser::Kramdown
+    EXAMPLE_START            = /#{BLANK_LINE}?^\s*Example:/
+    EXAMPLE_BACKGROUND_START = /#{BLANK_LINE}?^\s*Background:/
+    EXAMPLE_DEFINITION_START = /#{BLANK_LINE}?^\s*Definition:/
+    EXAMPLE_OUTLINE_START    = /#{BLANK_LINE}?^\s*Example Outline:/
+
+    def initialize(source, options)
+      super
+
+      register_example_background_parser
+      register_example_definition_parser
+      register_example_outline_parser
+      register_example_parser
+    end
+
+    public :new_block_el
+
+    def new_el(type, value)
+      Element.new(type, value)
+    end
+
+    private
+
+    def parse_example
+      @tree.children << ExampleNode.as_example(self, @src).to_element
+    end
+
+    def parse_example_background
+      @tree.children << ExampleNode.as_background(self, @src).to_element
+    end
+
+    def parse_example_definition
+      @tree.children << ExampleNode.as_definition(self, @src).to_element
+    end
+
+    def parse_example_outline
+      @tree.children << ExampleNode.as_example_outline(self, @src).to_element
+    end
+
+    def register_example_background_parser
+      @block_parsers.unshift(:example_background)
+    end
+
+    def register_example_definition_parser
+      @block_parsers.unshift(:example_definition)
+    end
+
+    def register_example_parser
+      @block_parsers.unshift(:example)
+    end
+
+    def register_example_outline_parser
+      @block_parsers.unshift(:example_outline)
+    end
+
+    Kramdown::Parser::Docbert = self
+
+    define_parser :example, /#{EXAMPLE_START}/
+    define_parser :example_background, /#{EXAMPLE_BACKGROUND_START}/
+    define_parser :example_definition, /#{EXAMPLE_DEFINITION_START}/
+    define_parser :example_outline, /#{EXAMPLE_OUTLINE_START}/
+  end
+end

data/lib/docbert/parser/definition_node.rb

@@ -0,0 +1,31 @@
+module Docbert
+  class Parser
+    class DefinitionNode < ExampleNode
+      def initialize(element_factory, fragment)
+        super :example_definition,
+              EXAMPLE_DEFINITION_START,
+              EXAMPLE_KEYWORDS,
+              element_factory,
+              fragment
+      end
+
+      protected
+
+      def parse_title(frag)
+        super.tap { |el|
+          content = ParameterizedContent.new(element_factory, el.value)
+
+          el.children.concat content.to_elements
+        }
+      end
+
+      def parse_body(frag)
+        super.tap { |el|
+          content = ParameterizedContent.new(element_factory, el.value)
+
+          el.children.concat content.to_elements
+        }
+      end
+    end
+  end
+end

data/lib/docbert/parser/example_node.rb

@@ -0,0 +1,83 @@
+module Docbert
+  class Parser
+    class ExampleNode
+      BLANK_LINE = Kramdown::Parser::Kramdown::BLANK_LINE
+
+      EXAMPLE_KEYWORDS         = 'Given|When|Then|And|But|\\||"""'
+      EXAMPLE_OUTLINE_KEYWORDS = "#{EXAMPLE_KEYWORDS}|Examples:"
+
+      def self.as_background(element_factory, fragment)
+        new(:example_background,
+            EXAMPLE_BACKGROUND_START,
+            EXAMPLE_KEYWORDS,
+            element_factory,
+            fragment)
+      end
+
+      def self.as_definition(element_factory, fragment)
+        DefinitionNode.new(element_factory, fragment)
+      end
+
+      def self.as_example(element_factory, fragment)
+        new(:example, EXAMPLE_START, EXAMPLE_KEYWORDS, element_factory, fragment)
+      end
+
+      def self.as_example_outline(element_factory, fragment)
+        new(:example_outline,
+            EXAMPLE_OUTLINE_START,
+            EXAMPLE_OUTLINE_KEYWORDS,
+            element_factory,
+            fragment)
+      end
+
+      def initialize(type, start_re, keywords, element_factory, fragment)
+        self.type            = type
+        self.start_re        = start_re
+        self.body_re         = /(?:\s*(?:#{keywords}).+?\n|#{BLANK_LINE})+/m
+        self.element_factory = element_factory
+        self.fragment        = fragment
+
+        parse
+      end
+
+      def to_element
+        element
+      end
+
+      private
+
+      attr_accessor :type, :start_re, :body_re, :element_factory, :fragment, :element
+
+      # Parse an example block.
+      #
+      # Currently only creates 2 nodes: one for the title and another for the
+      # example body.
+      def parse
+        skip_start fragment
+
+        self.element = parse_root(fragment)
+      end
+
+      def parse_body(frag)
+        body = frag.scan(body_re).gsub(/^ +/, '').strip
+
+        element_factory.new_el(:example_body, body)
+      end
+
+      def parse_root(frag)
+        element_factory.new_block_el(type).
+          tap { |el| el.children << parse_title(frag) << parse_body(frag) }
+      end
+
+      def parse_title(frag)
+        title = frag.scan(/.*?\n/).strip
+
+        element_factory.new_el(:example_title, title)
+      end
+
+      def skip_start(frag)
+        frag.skip start_re
+      end
+    end
+  end
+end

data/lib/docbert/parser/parameterized_content.rb

@@ -0,0 +1,43 @@
+module Docbert
+  class Parser
+    class ParameterizedContent
+      WORDS = /\w(?:\w+| )*\w/
+
+      def initialize(element_factory, fragment)
+        self.element_factory = element_factory
+        self.scanner         = StringScanner.new(fragment)
+        self.elements        = build_elements
+      end
+
+      def to_elements
+        elements
+      end
+
+      private
+
+      attr_accessor :element_factory, :scanner, :elements
+
+      def build_element
+        build_text || build_param
+      end
+
+      def build_elements(elements = [])
+        return elements if scanner.eos?
+
+        build_elements(elements << build_element)
+      end
+
+      def build_param
+        scanner.skip(/</) and name = scanner.scan(WORDS) and scanner.skip(/>/)
+
+        element_factory.new_el(:example_definition_param, name) if name
+      end
+
+      def build_text
+        if text = scanner.scan(/[^<]+/)
+          element_factory.new_el(:text, text)
+        end
+      end
+    end
+  end
+end

data/lib/docbert/version.rb

@@ -0,0 +1,3 @@
+module Docbert
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: docbert
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors:
+- David Leal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  name: kramdown
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: cucumber
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: rspec-expectations
+  type: :development
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: See https://github.com/mojotech/docbert/features/index.feature.md
+email:
+- dleal@mojotech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/docbert.rb
+- lib/docbert/converters/gherkin.rb
+- lib/docbert/converters/step_definitions.rb
+- lib/docbert/converters/step_definitions/parameterized_content.rb
+- lib/docbert/parser.rb
+- lib/docbert/parser/definition_node.rb
+- lib/docbert/parser/example_node.rb
+- lib/docbert/parser/parameterized_content.rb
+- lib/docbert/version.rb
+homepage: https://github.com/mojotech/docbert
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: ! '[none]'
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A tool to help write literate cucumber
+test_files: []