cucumber_analytics 0.0.9 → 1.0.0

data/lib/cucumber_analytics/step.rb

@@ -1,22 +1,67 @@
 module CucumberAnalytics
+
+  # A class modeling a Cucumber Feature.
+
   class Step
 
+    include Containing
+
+
+    # The step's keyword
+    attr_accessor :keyword
+
+    # The base text of the step
+    attr_accessor :base
+
+    # The step's passed block
+    attr_accessor :block
 
-    attr_reader :keyword
-    attr_reader :base
-    attr_reader :block
+    # The parent object that contains *self*
     attr_accessor :parent_element
 
+    # 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
 
-    # Creates a new Step object based on the passed string. If the optional
-    # string array is provided, it becomes the block for the step.
-    def initialize(step, block = nil)
-      CucumberAnalytics::Logging.logger.info('Step#initialize')
-      CucumberAnalytics::Logging.logger.debug("step: #{step}")
+    # 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
 
-      @base = step.sub(/#{World::STEP_KEYWORD_PATTERN}/, '')
-      @block = block
-      @keyword = step.slice(/#{World::STEP_KEYWORD_PATTERN}/).strip
+    # 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
@@ -28,16 +73,18 @@ module CucumberAnalytics
       left_step == right_step
     end
 
-    # Returns the 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.
+    # Deprecated
     #
-    #  a_step = CucumberAnalytics.new('Given *some* step with a block:', ['block line 1', 'block line 2'])
+    # 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 = CucumberAnalytics.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']
+    #  #=> ['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']
+    #  #=> ['*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 => '-'))
@@ -46,8 +93,8 @@ module CucumberAnalytics
     def step_text(options = {})
       options = {:with_keywords => true,
                  :with_arguments => true,
-                 :left_delimiter => World.left_delimiter,
-                 :right_delimiter => World.right_delimiter}.merge(options)
+                 :left_delimiter => self.left_delimiter,
+                 :right_delimiter => self.right_delimiter}.merge(options)
 
       final_step = []
       step_text = ''
@@ -57,7 +104,7 @@ module CucumberAnalytics
       if options[:with_arguments]
         step_text += @base
         final_step << step_text
-        final_step.concat @block if @block
+        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
@@ -66,28 +113,91 @@ module CucumberAnalytics
       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
+
 
     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)
+
+      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)
-      original_left = left_delimiter
-      original_right = right_delimiter
-
-      begin
-        Regexp.new(left_delimiter)
-      rescue RegexpError
-        left_delimiter = '\\' + left_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
 
-      begin
-        Regexp.new(right_delimiter)
-      rescue RegexpError
-        right_delimiter = '\\' + right_delimiter
+      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
 
-      step.gsub(Regexp.new("#{left_delimiter}.*?#{right_delimiter}"), original_left + original_right)
+      @block
+    end
+
+    def rebuild_block_text(blok)
+      blok.contents.collect { |row| "|#{row.join('|')}|" }
     end
 
   end

data/lib/cucumber_analytics/table.rb

@@ -0,0 +1,51 @@
+module CucumberAnalytics
+
+  # A class modeling the table of a Step.
+
+  class Table
+
+    # The parent object that contains *self*
+    attr_accessor :parent_element
+
+    # The contents of the table
+    attr_accessor :contents
+
+
+    # Creates a new Table object and, if *source* is provided, populates
+    # the object.
+    def initialize(source = nil)
+      @contents = []
+
+      parsed_table = process_source(source)
+
+      build_table(parsed_table) if parsed_table
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_table(source)
+        else
+          source
+      end
+    end
+
+    def parse_table(source_text)
+      base_file_string = "Feature:\nScenario:\n* step\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first['elements'].first['steps'].first['rows']
+    end
+
+    def build_table(table)
+      @contents = table.collect { |row| row['cells'] }
+    end
+
+  end
+end

data/lib/cucumber_analytics/taggable.rb

@@ -0,0 +1,35 @@
+module CucumberAnalytics
+
+  # A mix-in module containing methods used by elements that can be tagged.
+
+  module Taggable
+
+    # The tags which are directly assigned to the element
+    attr_accessor :tags
+
+
+    # Returns the tags which are indirectly assigned to the element (i.e. they
+    # have been inherited from a parent element).
+    def applied_tags
+      @parent_element.respond_to?(:all_tags) ? @parent_element.all_tags : []
+    end
+
+    # Returns all of the tags which are applicable to the element.
+    def all_tags
+      applied_tags + @tags
+    end
+
+
+    private
+
+
+    def populate_element_tags(parsed_element)
+      if parsed_element['tags']
+        parsed_element['tags'].each do |tag|
+          @tags << tag['name']
+        end
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/test_element.rb

@@ -1,123 +1,68 @@
 module CucumberAnalytics
+
+  # A class modeling an element that contains steps.
+
   class TestElement < FeatureElement
 
+    include Containing
 
-    attr_reader :steps
 
+    # The steps contained by the TestElement
+    attr_accessor :steps
 
-    # Creates a new TestElement object.
-    def initialize(source_lines = nil)
-      CucumberAnalytics::Logging.logger.info('TestElement#initialize')
 
+    # Creates a new TestElement object and, if *parsed_test_element* is provided,
+    # populates the object.
+    def initialize(parsed_test_element = nil)
       super
 
       @steps = []
+
+      build_test_element(parsed_test_element) if parsed_test_element
     end
 
-    # Returns true if the two elements have the same steps, minus any keywords
-    # and arguments, and false otherwise.
+    # Returns true if the two elements have equivalent steps and false otherwise.
     def ==(other_element)
       steps == other_element.steps
     end
 
-
-    private
-
-
-    def parse_test_element_steps(source_lines)
-      CucumberAnalytics::Logging.logger.info('TestElement#parse_test_element_steps')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      until source_lines.empty? or source_lines.first =~ /^\s*(?:@|Examples:)/
-        line = source_lines.first
-        block = nil
-
-        case
-          when line =~ /^\s*"""/
-            block = extract_doc_block(source_lines)
-
-            found_step = Step.new(@steps.last.keyword + ' ' + @steps.last.base, block)
-            found_step.parent_element = self
-
-            @steps[@steps.size - 1] = found_step
-          when line =~ /^\s*\|/
-            block = extract_table_block(source_lines)
-
-            found_step = Step.new(@steps.last.keyword + ' ' + @steps.last.base, block)
-            found_step.parent_element = self
-
-            @steps[@steps.size - 1] = found_step
-          else
-            unless World.ignored_line?(line)
-              found_step = Step.new(line.strip)
-              found_step.parent_element = self
-
-              @steps << found_step
-            end
-
-            source_lines.shift
-        end
-      end
+    # Returns the immediate child elements of the element.
+    def contains
+      @steps
     end
 
-    def extract_doc_block(source_lines)
-      CucumberAnalytics::Logging.logger.info('TestElement#extract_doc_block')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      step_block = []
 
-      line = source_lines.first
-      leading_whitespace = line[/^\s*/]
-
-      step_block << line.strip
-      source_lines.shift
-
-      line = source_lines.first
-      until line =~ /^\s*"""/
+    private
 
-        leading_whitespace.length.times do
-          line.slice!(0, 1) if line[0] =~ /\s/
-        end
 
-        step_block << line.chomp
-        source_lines.shift
-        line = source_lines.first
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_test_element(source)
+        else
+          source
       end
-
-      step_block << line.strip
-      source_lines.shift
-
-      step_block
     end
 
-    def extract_table_block(source_lines)
-      CucumberAnalytics::Logging.logger.info('TestElement#extract_table_block')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
+    def parse_test_element(source_text)
+      base_file_string = "Feature: Fake feature to parse\n"
+      source_text = base_file_string + source_text
 
-      step_block = []
+      parsed_file = Parsing::parse_text(source_text)
 
-      line = source_lines.first
+      parsed_file.first['elements'].first
+    end
 
-      step_block << line.strip
-      source_lines.shift
+    def build_test_element(parsed_test_element)
+      populate_test_element_steps(parsed_test_element)
+    end
 
-      line = source_lines.first
-      while line =~ /^\s*\|/
-        step_block << line.strip
-        source_lines.shift
-        line = source_lines.first
+    def populate_test_element_steps(parsed_test_element)
+      if parsed_test_element['steps']
+        parsed_test_element['steps'].each do |step|
+          @steps << build_child_element(Step, step)
+        end
       end
-
-      step_block
     end
 
   end

data/lib/cucumber_analytics/version.rb

@@ -1,3 +1,3 @@
 module CucumberAnalytics
-  VERSION = "0.0.9"
+  VERSION = '1.0.0'
 end