cucumber-core 0.1.0

data/lib/cucumber/core/gherkin/document.rb

@@ -0,0 +1,20 @@
+require 'cucumber/initializer'
+
+module Cucumber
+  module Core
+    module Gherkin
+      class Document
+        include Cucumber.initializer(:uri, :body)
+        attr_reader :uri, :body
+
+        def to_s
+          body
+        end
+
+        def ==(other)
+          to_s == other.to_s
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/gherkin/parser.rb

@@ -0,0 +1,45 @@
+require 'cucumber/core/gherkin/ast_builder'
+require 'gherkin/parser/parser'
+
+module Cucumber
+  module Core
+    module Gherkin
+      ParseError = Class.new(StandardError)
+
+      class Parser
+        include Cucumber.initializer(:receiver)
+
+        def document(document)
+          builder = AstBuilder.new(document.uri)
+          parser = ::Gherkin::Parser::Parser.new(builder, true, "root", false)
+
+          begin
+            parser.parse(document.body, document.uri, 0)
+            builder.language = parser.i18n_language
+            receiver.feature builder.result
+          rescue *PARSER_ERRORS => e
+            raise Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
+          end
+        end
+
+        def done
+          receiver.done
+          self
+        end
+
+        private
+
+        PARSER_ERRORS = if Cucumber::JRUBY
+                          [
+                            ::Java::GherkinLexer::LexingError
+                          ]
+                        else
+                          [
+                            ::Gherkin::Lexer::LexingError,
+                            ::Gherkin::Parser::ParseError,
+                          ]
+                        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/gherkin/writer.rb

@@ -0,0 +1,220 @@
+require 'cucumber/core/gherkin/writer/helpers'
+require 'cucumber/core/gherkin/document'
+
+module Cucumber
+  module Core
+    module Gherkin
+
+      module Writer
+        NEW_LINE = ''
+        def gherkin(uri = nil, &source)
+          uri ||= 'features/test.feature'
+          builder = Gherkin.new(uri, &source)
+          builder.build
+        end
+
+        class Gherkin
+          def initialize(uri, &source)
+            @uri, @source = uri, source
+          end
+
+          def comment(line)
+            comment_lines << "# #{line}"
+          end
+
+          def comment_lines
+            @comment_lines ||= []
+          end
+
+          def feature(*args, &source)
+            @feature = Feature.new(comment_lines, *args).tap do |builder|
+              builder.instance_exec(&source) if source
+            end
+            self
+          end
+
+          def build
+            instance_exec(&@source)
+            Document.new(@uri, @feature.build.join("\n"))
+          end
+        end
+
+        class Feature
+          include HasElements
+          include HasOptionsInitializer
+          include HasDescription
+          include Indentation.level(0)
+
+          default_keyword 'Feature'
+
+          elements :background, :scenario, :scenario_outline
+
+          def build(source = [])
+            elements.inject(source + statements) { |acc, el| el.build(acc) + [NEW_LINE] }
+          end
+
+          private
+          def language
+            options[:language]
+          end
+
+          def statements
+            prepare_statements language_statement,
+              comments_statement,
+              tag_statement,
+              name_statement,
+              description_statement,
+              NEW_LINE
+          end
+
+          def language_statement
+            "# language: #{language}" if language
+          end
+        end
+
+        class Background
+          include HasElements
+          include HasOptionsInitializer
+          include HasDescription
+          include Indentation.level 2
+
+          default_keyword 'Background'
+
+          elements :step
+
+          private
+          def statements
+            prepare_statements comments_statement, tag_statement, name_statement, description_statement
+          end
+        end
+
+        class Scenario
+          include HasElements
+          include HasOptionsInitializer
+          include HasDescription
+          include Indentation.level 2
+
+          default_keyword 'Scenario'
+
+          elements :step
+
+          private
+          def statements
+            prepare_statements comments_statement,
+              tag_statement,
+              name_statement,
+              description_statement
+          end
+        end
+
+        class ScenarioOutline
+          include HasElements
+          include HasOptionsInitializer
+          include HasDescription
+          include Indentation.level 2
+
+          default_keyword 'Scenario Outline'
+
+          elements :step, :examples
+
+          private
+          def statements
+            prepare_statements comments_statement, tag_statement, name_statement, description_statement
+          end
+        end
+
+        class Step
+          include HasElements
+          include HasOptionsInitializer
+          include Indentation.level 4
+
+          default_keyword 'Given'
+
+          elements :table
+
+          def doc_string(string, content_type='')
+            elements << DocString.new(string, content_type)
+          end
+
+          private
+          def statements
+            prepare_statements comments_statement, name_statement
+          end
+
+          def name_statement
+            "#{keyword} #{name}"
+          end
+        end
+
+        class Table
+          include Indentation.level(6)
+          include HasRows
+
+          def initialize(*)
+          end
+
+          def build(source)
+            source + statements
+          end
+
+          private
+          def statements
+            row_statements
+          end
+        end
+
+        class DocString
+          include Indentation.level(6)
+
+          attr_reader :strings, :content_type
+          private :strings, :content_type
+
+          def initialize(string, content_type)
+            @strings = string.split("\n").map(&:strip)
+            @content_type = content_type
+          end
+
+          def build(source)
+            source + statements
+          end
+
+          private
+          def statements
+            prepare_statements doc_string_statement
+          end
+
+          def doc_string_statement
+            [
+              %["""#{content_type}],
+              strings,
+              '"""'
+            ]
+          end
+        end
+
+        class Examples
+          include HasOptionsInitializer
+          include HasRows
+          include HasDescription
+          include Indentation.level(4)
+
+          default_keyword 'Examples'
+
+          def build(source)
+            source + statements
+          end
+
+          private
+          def statements
+            prepare_statements NEW_LINE,
+              comments_statement,
+              tag_statement,
+              name_statement,
+              description_statement,
+              row_statements(2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/gherkin/writer/helpers.rb

@@ -0,0 +1,178 @@
+module Cucumber
+  module Core
+    module Gherkin
+      module Writer
+
+        module HasOptionsInitializer
+          def self.included(base)
+            base.extend HasDefaultKeyword
+          end
+
+          attr_reader :name, :options
+          private :name, :options
+
+          def initialize(*args)
+            @comments = args.shift if args.first.is_a?(Array)
+            @comments ||= []
+            @options = args.pop if args.last.is_a?(Hash)
+            @options ||= {}
+            @name = args.first
+          end
+
+          private
+
+          def comments_statement
+            @comments
+          end
+
+          def keyword
+            options.fetch(:keyword) { self.class.keyword }
+          end
+
+          def name_statement
+            "#{keyword}: #{name}".strip
+          end
+
+          def tag_statement
+            tags
+          end
+
+          def tags
+            options[:tags]
+          end
+
+          module HasDefaultKeyword
+            def default_keyword(keyword)
+              @keyword = keyword
+            end
+
+            def keyword
+              @keyword
+            end
+          end
+        end
+
+        module AcceptsComments
+          def comment(line)
+            comment_lines << "# #{line}"
+          end
+
+          def comment_lines
+            @comment_lines ||= []
+          end
+
+          def slurp_comments
+            # TODO: I can't think of another way to handle this?
+            # When we use the comments, we need to reset the collection
+            # for the next element...
+            slurped_comments = comment_lines.dup
+            @comment_lines = nil
+            slurped_comments
+          end
+        end
+
+        module HasElements
+          include AcceptsComments
+
+          def self.included(base)
+            base.extend HasElementBuilders
+          end
+
+          def build(source = [])
+            elements.inject(source + statements) { |acc, el| el.build(acc) }
+          end
+
+          private
+          def elements
+            @elements ||= []
+          end
+
+          module HasElementBuilders
+            def elements(*names)
+              names.each { |name| element(name) }
+            end
+
+            private
+            def element(name)
+              define_method name do |*args, &source|
+                factory_name = String(name).split("_").map(&:capitalize).join
+                factory = Writer.const_get(factory_name)
+                factory.new(slurp_comments, *args).tap do |builder|
+                  builder.instance_exec(&source) if source
+                  elements << builder
+                end
+                self
+              end
+            end
+          end
+        end
+
+        module Indentation
+          def self.level(number)
+            Module.new do
+              define_method :indent do |string, amount=nil|
+                amount ||= number
+                return string if string.nil? || string.empty?
+                (' ' * amount) + string
+              end
+
+              define_method :indent_level do
+                number
+              end
+
+              define_method :prepare_statements do |*statements|
+                statements.flatten.compact.map { |s| indent(s) }
+              end
+            end
+          end
+        end
+
+        module HasDescription
+          private
+          def description
+            options.fetch(:description) { '' }.split("\n").map(&:strip)
+          end
+
+          def description_statement
+            description.map { |s| indent(s,2) } unless description.empty?
+          end
+        end
+
+        module HasRows
+          def row(*cells)
+            rows << cells
+          end
+
+          def rows
+            @rows ||= []
+          end
+
+          private
+
+          def row_statements(indent=nil)
+            rows.map { |row| indent(table_row(row), indent) }
+          end
+
+          def table_row(row)
+            padded = pad(row)
+            "| #{padded.join(' | ')} |"
+          end
+
+          def pad(row)
+            row.map.with_index { |text, position| justify_cell(text, position) }
+          end
+
+          def column_length(column)
+            lengths = rows.transpose.map { |r| r.map(&:length).max }
+            lengths[column]
+          end
+
+          def justify_cell(cell, position)
+            cell.ljust(column_length(position))
+          end
+        end
+      end
+
+    end
+  end
+end