cuke_modeler 0.0.1

data/lib/cuke_modeler/feature_file.rb

@@ -0,0 +1,77 @@
+module CukeModeler
+
+  # A class modeling a Cucumber .feature file.
+
+  class FeatureFile
+
+    include Containing
+    include Nested
+
+
+    # The Feature objects contained by the FeatureFile
+    attr_accessor :features
+
+
+    # Creates a new FeatureFile object and, if *file_parsed* is provided,
+    # populates the object.
+    def initialize(file = nil)
+      @file = file
+      @features = []
+
+      if file
+        raise(ArgumentError, "Unknown file: #{file.inspect}") unless File.exists?(file)
+
+        parsed_file = parse_file(file)
+
+        build_file(parsed_file)
+      end
+    end
+
+    # Returns the name of the file.
+    def name
+      File.basename(@file.gsub('\\', '/'))
+    end
+
+    # Returns the path of the file.
+    def path
+      @file
+    end
+
+    # Returns the immediate child elements of the file(i.e. its Feature object).
+    def contains
+      @features
+    end
+
+    # Returns the number of features contained in the file.
+    def feature_count
+      @features.count
+    end
+
+    # Returns the Feature object contained by the FeatureFile.
+    def feature
+      @features.first
+    end
+
+    # Returns the path of the feature file.
+    def to_s
+      path.to_s
+    end
+
+
+    private
+
+
+    def parse_file(file_to_parse)
+      source_text = IO.read(file_to_parse)
+
+      Parsing::parse_text(source_text)
+    end
+
+    def build_file(parsed_file)
+      unless parsed_file.empty?
+        @features << build_child_element(Feature, parsed_file.first)
+      end
+    end
+
+  end
+end

data/lib/cuke_modeler/nested.rb

@@ -0,0 +1,34 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by elements that are nested inside
+  # of other elements.
+
+  module Nested
+
+    # The parent object that contains *self*
+    attr_accessor :parent_element
+
+
+    # Returns the ancestor of *self* that matches the given type.
+    def get_ancestor(ancestor_type)
+      ancestor = self.parent_element
+      target_type = {:directory => Directory,
+                     :feature_file => FeatureFile,
+                     :feature => Feature,
+                     :test => TestElement,
+                     :step => Step,
+                     :table => Table,
+                     :example => Example
+      }[ancestor_type]
+
+      raise(ArgumentError, "Unknown ancestor type '#{ancestor_type}'.") if target_type.nil?
+
+      until ancestor.is_a?(target_type) || ancestor.nil?
+        ancestor = ancestor.parent_element
+      end
+
+      ancestor
+    end
+
+  end
+end

data/lib/cuke_modeler/outline.rb

@@ -0,0 +1,68 @@
+module CukeModeler
+
+  # A class modeling a Cucumber Scenario Outline.
+
+  class Outline < TestElement
+
+    include Taggable
+
+
+    # The Example objects contained by the Outline
+    attr_accessor :examples
+
+
+    # Creates a new Outline object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_outline = process_source(source)
+
+      super(parsed_outline)
+
+      @tags = []
+      @tag_elements = []
+      @examples = []
+
+      build_outline(parsed_outline) if parsed_outline
+    end
+
+    # Returns the immediate child elements of the outline (i.e. its Example
+    # objects.
+    def contains
+      @examples + @steps
+    end
+
+    # Returns a gherkin representation of the outline.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Scenario Outline:#{name_output_string}"
+      text << "\n" + description_output_string unless description_text.empty?
+      text << "\n" unless steps.empty? || description_text.empty?
+      text << "\n" + steps_output_string unless steps.empty?
+      text << "\n\n" + examples_output_string unless examples.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def build_outline(parsed_outline)
+      populate_element_tags(parsed_outline)
+      populate_outline_examples(parsed_outline['examples']) if parsed_outline['examples']
+    end
+
+    def populate_outline_examples(parsed_examples)
+      parsed_examples.each do |example|
+        @examples << build_child_element(Example, example)
+      end
+    end
+
+    def examples_output_string
+      examples.empty? ? '' : examples.collect { |example| example.to_s }.join("\n\n")
+    end
+
+  end
+end

data/lib/cuke_modeler/parsing.rb

@@ -0,0 +1,32 @@
+require 'stringio'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin'
+require 'json'
+require 'multi_json'
+
+module CukeModeler
+
+  # A module providing source text parsing functionality.
+
+  module Parsing
+
+    class << self
+
+      # Parses the Cucumber feature given in *source_text* and returns an array
+      # containing the hash representation of its logical structure.
+      def parse_text(source_text)
+        raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+
+        io = StringIO.new
+        formatter = Gherkin::Formatter::JSONFormatter.new(io)
+        parser = Gherkin::Parser::Parser.new(formatter)
+        parser.parse(source_text, 'fake_file.txt', 0)
+        formatter.done
+
+        MultiJson.load(io.string)
+      end
+
+    end
+
+  end
+end

data/lib/cuke_modeler/raw.rb

@@ -0,0 +1,20 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by elements that store their
+  # underlying implementation
+
+  module Raw
+
+    # The raw representation of the element (i.e. the output of the gherkin gem)
+    attr_accessor :raw_element
+
+
+    private
+
+
+    def populate_raw_element(parsed_element)
+      @raw_element = parsed_element
+    end
+
+  end
+end

data/lib/cuke_modeler/row.rb

@@ -0,0 +1,64 @@
+module CukeModeler
+
+  # A class modeling a Cucumber Examples table row.
+
+  class Row
+
+    include Sourceable
+    include Raw
+    include Nested
+
+
+    # The cells that make up the row
+    attr_accessor :cells
+
+
+    # Creates a new Row object and, if *source* is provided, populates
+    # the object.
+    def initialize(source = nil)
+      parsed_row = process_source(source)
+
+      @cells = []
+
+      build_row(parsed_row) if parsed_row
+    end
+
+    # Returns a gherkin representation of the row.
+    def to_s
+      "| #{cells.join(' | ')} |"
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_row(source)
+        else
+          source
+      end
+    end
+
+    def parse_row(source_text)
+      base_file_string = "Feature: Fake feature to parse\nScenario Outline:\n* fake step\nExamples: fake examples\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first['elements'].first['examples'].first['rows'].first
+    end
+
+    def build_row(parsed_row)
+      populate_element_source_line(parsed_row)
+      populate_row_cells(parsed_row)
+      populate_raw_element(parsed_row)
+    end
+
+    def populate_row_cells(parsed_row)
+      @cells = parsed_row['cells']
+    end
+
+  end
+end

data/lib/cuke_modeler/scenario.rb

@@ -0,0 +1,45 @@
+module CukeModeler
+
+  # A class modeling a Cucumber Scenario.
+
+  class Scenario < TestElement
+
+    include Taggable
+
+
+    # Creates a new Scenario object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_scenario = process_source(source)
+
+      super(parsed_scenario)
+
+      @tags = []
+      @tag_elements = []
+
+      build_scenario(parsed_scenario) if parsed_scenario
+    end
+
+    # Returns gherkin representation of the scenario.
+    def to_s
+      text = ''
+
+      text << tag_output_string + "\n" unless tags.empty?
+      text << "Scenario:#{name_output_string}"
+      text << "\n" + description_output_string unless description_text.empty?
+      text << "\n" unless steps.empty? || description_text.empty?
+      text << "\n" + steps_output_string unless steps.empty?
+
+      text
+    end
+
+
+    private
+
+
+    def build_scenario(scenario)
+      populate_element_tags(scenario)
+    end
+
+  end
+end

data/lib/cuke_modeler/sourceable.rb

@@ -0,0 +1,20 @@
+module CukeModeler
+
+  # A mix-in module containing methods used by elements that know their
+  # source code line.
+
+  module Sourceable
+
+    # The line number where the element began in the source code
+    attr_reader :source_line
+
+
+    private
+
+
+    def populate_element_source_line(parsed_element)
+      @source_line = parsed_element['line']
+    end
+
+  end
+end

data/lib/cuke_modeler/step.rb

@@ -0,0 +1,214 @@
+module CukeModeler
+
+  # A class modeling a Cucumber Feature.
+
+  class Step
+
+    include Containing
+    include Sourceable
+    include Raw
+    include Nested
+
+
+    # The step's keyword
+    attr_accessor :keyword
+
+    # The base text of the step
+    attr_accessor :base
+
+    # The step's passed block
+    attr_accessor :block
+
+    # The step's arguments
+    attr_accessor :arguments
+
+
+    # Creates a new Step object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      @arguments = []
+
+      parsed_step = process_source(source)
+
+      build_step(parsed_step) if parsed_step
+    end
+
+    # Sets the delimiter that will be used by default when determining the
+    # boundaries of step arguments.
+    def delimiter=(new_delimiter)
+      self.left_delimiter = new_delimiter
+      self.right_delimiter = new_delimiter
+    end
+
+    # Returns the delimiter that is used to mark the beginning of a step
+    # argument.
+    def left_delimiter
+      @left_delimiter || World.left_delimiter
+    end
+
+    # Sets the left delimiter that will be used by default when determining
+    # step arguments.
+    def left_delimiter=(new_delimiter)
+      @left_delimiter = new_delimiter
+    end
+
+    # Returns the delimiter that is used to mark the end of a step
+    # argument.
+    def right_delimiter
+      @right_delimiter || World.right_delimiter
+    end
+
+    # Sets the right delimiter that will be used by default when determining
+    # step arguments.
+    def right_delimiter=(new_delimiter)
+      @right_delimiter = new_delimiter
+    end
+
+    # Returns true if the two steps have the same text, minus any keywords
+    # and arguments, and false otherwise.
+    def ==(other_step)
+      left_step = step_text(:with_keywords => false, :with_arguments => false)
+      right_step = other_step.step_text(:with_keywords => false, :with_arguments => false)
+
+      left_step == right_step
+    end
+
+    # Deprecated
+    #
+    # Returns the entire text of the step. Options can be set to selectively
+    # exclude certain portions of the text. *left_delimiter* and *right_delimiter*
+    # are used to determine which parts of the step are arguments.
+    #
+    #  a_step = CukeModeler::Step.new("Given *some* step with a block:\n|block line 1|\n|block line 2|")
+    #
+    #  a_step.step_text
+    #  #=> ['Given *some* step with a block:', '|block line 1|', '|block line 2|']
+    #  a_step.step_text(:with_keywords => false)
+    #  #=> ['*some* step with a block:', '|block line 1|', '|block line 2|']
+    #  a_step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '*')
+    #  #=> ['Given ** step with a block:']
+    #  a_step.step_text(:with_keywords => false, :with_arguments => false, :left_delimiter => '-', :right_delimiter => '-'))
+    #  #=> ['*some* step with a block:']
+    #
+    def step_text(options = {})
+      options = {:with_keywords => true,
+                 :with_arguments => true,
+                 :left_delimiter => self.left_delimiter,
+                 :right_delimiter => self.right_delimiter}.merge(options)
+
+      final_step = []
+      step_text = ''
+
+      step_text += "#{@keyword} " if options[:with_keywords]
+
+      if options[:with_arguments]
+        step_text += @base
+        final_step << step_text
+        final_step.concat(rebuild_block_text(@block)) if @block
+      else
+        step_text += stripped_step(@base, options[:left_delimiter], options[:right_delimiter])
+        final_step << step_text
+      end
+
+      final_step
+    end
+
+    # Populates the step's arguments based on the step's text and some method of
+    # determining which parts of the text are arguments. Methods include using
+    # a regular expression and using the step's delimiters.
+    def scan_arguments(*how)
+      if how.count == 1
+        pattern = how.first
+      else
+        left_delimiter = how[0] || self.left_delimiter
+        right_delimiter = how[1] || self.right_delimiter
+
+        return [] unless left_delimiter && right_delimiter
+
+        pattern = Regexp.new(Regexp.escape(left_delimiter) + '(.*?)' + Regexp.escape(right_delimiter))
+      end
+
+      @arguments = @base.scan(pattern).flatten
+    end
+
+    # Returns a gherkin representation of the step.
+    def to_s
+      text = "#{keyword} #{base}"
+      text << "\n" + block.to_s.split("\n").collect { |line| "  #{line}" }.join("\n") if block
+
+      text
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_step(source)
+        else
+          source
+      end
+    end
+
+    def parse_step(source_text)
+      base_file_string = "Feature: Fake feature to parse\nScenario:\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first['elements'].first['steps'].first
+    end
+
+    def build_step(step)
+      populate_base(step)
+      populate_block(step)
+      populate_keyword(step)
+      populate_element_source_line(step)
+      populate_raw_element(step)
+
+      scan_arguments
+    end
+
+    def populate_base(step)
+      @base = step['name']
+    end
+
+    def populate_block(step)
+      @block = build_block(step)
+    end
+
+    def populate_keyword(step)
+      @keyword = step['keyword'].strip
+    end
+
+    # Returns the step string minus any arguments based on the given delimiters.
+    def stripped_step(step, left_delimiter, right_delimiter)
+      unless left_delimiter.nil? || right_delimiter.nil?
+        pattern = Regexp.new(Regexp.escape(left_delimiter) + '.*?' + Regexp.escape(right_delimiter))
+        step = step.gsub(pattern, left_delimiter + right_delimiter)
+      end
+
+      step
+    end
+
+    def build_block(step)
+      case
+        when step['rows']
+          @block = build_child_element(Table, step['rows'])
+        when step['doc_string']
+          @block = build_child_element(DocString, step['doc_string'])
+        else
+          @block = nil
+      end
+
+      @block
+    end
+
+    def rebuild_block_text(blok)
+      blok.contents.collect { |row| "|#{row.join('|')}|" }
+    end
+
+  end
+end