cucumber-core 0.1.0

data/lib/cucumber/core/ast/describes_itself.rb

@@ -0,0 +1,16 @@
+module Cucumber
+  module Core
+    module Ast
+      module DescribesItself
+        def describe_to(visitor, *args)
+          visitor.send(description_for_visitors, self, *args) do |child_visitor=visitor|
+            children.each do |child|
+              child.describe_to(child_visitor, *args)
+            end
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/doc_string.rb

@@ -0,0 +1,83 @@
+require 'cucumber/core/ast/describes_itself'
+module Cucumber
+  module Core
+    module Ast
+      # Represents an inline argument in a step. Example:
+      #
+      #   Given the message
+      #     """
+      #     I like
+      #     Cucumber sandwich
+      #     """
+      #
+      # The text between the pair of <tt>"""</tt> is stored inside a DocString,
+      # which is yielded to the StepDefinition block as the last argument.
+      #
+      # The StepDefinition can then access the String via the #to_s method. In the
+      # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
+      #
+      # Note how the indentation from the source is stripped away.
+      #
+      class DocString
+        include HasLocation
+        include DescribesItself
+        attr_accessor :file
+
+        def self.default_arg_name
+          "string"
+        end
+
+        attr_reader :content_type, :content
+
+        def initialize(string, content_type, location)
+          @content = string
+          @content_type = content_type
+          @location = location
+        end
+
+        def encoding
+          @content.encoding
+        end
+
+        def to_str
+          @content
+        end
+
+        def to_s
+          to_str
+        end
+
+        def gsub(*args)
+          @content.gsub(*args)
+        end
+
+        def map
+          raise ArgumentError, "No block given" unless block_given?
+          new_content = yield content
+          self.class.new(new_content, content_type, location)
+        end
+
+        def to_step_definition_arg
+          self
+        end
+
+        def ==(other)
+          if other.respond_to?(:content_type)
+            return false unless content_type == other.content_type
+          end
+          if other.respond_to?(:to_str)
+            return content == other.to_str
+          end
+          raise ArgumentError, "Can't compare a #{self.class.name} with a #{other.class.name}"
+        end
+
+        private
+
+        def description_for_visitors
+          :doc_string
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/empty_background.rb

@@ -0,0 +1,12 @@
+module Cucumber
+  module Core
+    module Ast
+      class EmptyBackground
+        def describe_to(*)
+          self
+        end
+      end
+    end
+  end
+end
+

data/lib/cucumber/core/ast/examples_table.rb

@@ -0,0 +1,95 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+
+      class ExamplesTable
+        include HasLocation
+        include DescribesItself
+
+        attr_reader :header, :keyword, :name, :tags, :comments
+
+        include Cucumber.initializer(
+          :location, :comments, :tags, :keyword, :name, :description, :header, :example_rows
+        )
+
+        private
+
+        def description_for_visitors
+          :examples_table
+        end
+
+        def children
+          @example_rows
+        end
+
+        class Header
+          include HasLocation
+
+          def initialize(cells, location)
+            @cells = cells
+            @location = location
+          end
+
+          def values
+            @cells
+          end
+
+          def build_row(row_cells, number, location)
+            Row.new(Hash[@cells.zip(row_cells)], number, location)
+          end
+        end
+
+        class Row
+          include DescribesItself
+          include HasLocation
+
+          attr_reader :number
+
+          def initialize(data, number, location)
+            raise ArgumentError, data.to_s unless data.is_a?(Hash)
+            @data = data
+            @number = number
+            @location = location
+          end
+
+          def ==(other)
+            return false unless other.class == self.class
+            other.number == number &&
+              other.location == location &&
+              other.data == data
+          end
+
+          def values
+            @data.values
+          end
+
+          def expand(string)
+            result = string.dup
+            @data.each do |key, value|
+              result.gsub!("<#{key}>", value.to_s)
+            end
+            result
+          end
+
+          def inspect
+            "#{self.class}: #{@data.inspect}"
+          end
+
+          protected
+
+          attr_reader :data
+
+          private
+
+          def description_for_visitors
+            :examples_table_row
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/feature.rb

@@ -0,0 +1,62 @@
+require 'cucumber/initializer'
+require 'cucumber/core/ast/describes_itself'
+require 'cucumber/core/ast/names'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  module Core
+    module Ast
+      # Represents the root node of a parsed feature.
+      class Feature #:nodoc:
+        include Names
+        include HasLocation
+        include DescribesItself
+
+        attr_accessor :language
+        attr_reader :feature_elements
+        attr_reader :comments, :background, :tags, :keyword, :location, :title
+
+        include Cucumber.initializer(:location, :background, :comments, :tags, :keyword, :title, :description, :feature_elements)
+        def initialize(*)
+          super
+          feature_elements.each { |e| e.feature = self }
+        end
+
+        def gherkin_statement(statement=nil)
+          @gherkin_statement ||= statement
+        end
+
+        def children
+          [background] + @feature_elements
+        end
+
+        def short_name
+          first_line = name.split(/\n/)[0]
+          if first_line =~ /#{language.keywords('feature')}:(.*)/
+            $1.strip
+          else
+            first_line
+          end
+        end
+
+        def to_sexp
+          sexp = [:feature, file, name]
+          comment = @comment.to_sexp
+          sexp += [comment] if comment
+          tags = @tags.to_sexp
+          sexp += tags if tags.any?
+          sexp += [@background.to_sexp] if @background
+          sexp += @feature_elements.map{|fe| fe.to_sexp}
+          sexp
+        end
+
+        private
+
+        def description_for_visitors
+          :feature
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/location.rb

@@ -0,0 +1,140 @@
+require 'forwardable'
+module Cucumber
+  module Core
+    module Ast
+      class Location < Struct.new(:filepath, :lines)
+        WILDCARD = :*
+
+        extend Forwardable
+
+        def_delegator :lines,    :include?
+        def_delegator :lines,    :line
+        def_delegator :filepath, :same_as?
+        def_delegator :filepath, :filename, :file
+
+        def initialize(filepath, lines=WILDCARD)
+          filepath || raise(ArgumentError, "file is mandatory")
+          lines || raise(ArgumentError, "line is mandatory")
+          super(FilePath.new(filepath), Lines.new(lines))
+        end
+
+        def match?(other)
+          other.same_as?(filepath) && other.include?(lines)
+        end
+
+        def to_s
+          [filepath.to_s, lines.to_s].reject { |v| v == WILDCARD.to_s }.join(":")
+        end
+
+        def to_str
+          to_s
+        end
+
+        def on_line(new_line)
+          Location.new(filepath.filename, new_line)
+        end
+
+        def inspect
+          "<#{self.class}: #{to_s}>"
+        end
+
+        class FilePath < Struct.new(:filename)
+          def same_as?(other)
+            filename == other.filename
+          end
+
+          def to_s
+            filename
+          end
+        end
+
+        require 'set'
+        class Lines
+          attr_reader :line
+          def initialize(line)
+            if Cucumber::JRUBY && line.is_a?(::Java::GherkinFormatterModel::Range)
+              line = Range.new(line.first, line.last)
+            end
+            @line = line
+            @data = Array(line).to_set
+          end
+
+          def include?(other)
+            return true if (data|other.data).include?(WILDCARD)
+            other.data.subset?(data) || data.subset?(other.data)
+          end
+
+          def to_s
+            boundary.join('..')
+          end
+
+          def ==(other)
+            other.data == data
+          end
+
+          protected
+
+          attr_reader :data
+
+          def boundary
+            first_and_last(value).uniq
+          end
+
+          def at_index(idx)
+            data.to_a[idx]
+          end
+
+          def value
+            method :at_index
+          end
+
+          def first_and_last(something)
+            [0, -1].map(&something)
+          end
+        end
+      end
+
+      module HasLocation
+        def file_colon_line
+          location.to_s
+        end
+
+        def file
+          location.file
+        end
+
+        def line
+          location.line
+        end
+
+        def location
+          raise('Please set @location in the constructor') unless defined?(@location)
+          @location
+        end
+
+        def match_locations?(queried_locations)
+          return true if attributes.any? { |node| node.match_locations? queried_locations }
+          queried_locations.any? { |queried_location| queried_location.match? location }
+        end
+
+        def attributes
+          # TODO: Remove compact when we have a null multiline arg object
+          [tags, comments, multiline_arg].flatten.compact
+        end
+
+        def tags
+          # will be overriden by nodes that actually have tags
+          []
+        end
+
+        def comments
+          []
+        end
+
+        def multiline_arg
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/core/ast/multiline_argument.rb

@@ -0,0 +1,33 @@
+require 'gherkin/rubify'
+
+module Cucumber
+  module Core
+    module Ast
+      module MultilineArgument
+
+        class << self
+          include Gherkin::Rubify
+
+          def from(argument, parent_location)
+            return unless argument
+            return argument if argument.respond_to?(:to_step_definition_arg)
+
+            argument = rubify(argument)
+            case argument
+            when String
+              Ast::DocString.new(argument, 'text/plain', parent_location)
+            when ::Gherkin::Formatter::Model::DocString
+              Ast::DocString.new(argument.value, argument.content_type, parent_location.on_line(argument.line_range))
+            when Array
+              location = parent_location.on_line(argument.first.line..argument.last.line)
+              Ast::DataTable.new(argument.map{|row| row.cells}, location)
+            else
+              raise ArgumentError, "Don't know how to convert #{argument.inspect} into a MultilineArgument"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end