cucumber_analytics 0.0.1

data/lib/cucumber_analytics/feature_element.rb

@@ -0,0 +1,54 @@
+module CucumberAnalytics
+  class FeatureElement
+
+
+    attr_reader :name
+    attr_reader :description
+
+
+    # Creates a new FeatureElement object.
+    def initialize(source_lines = nil)
+      @name = ''
+      @description =[]
+    end
+
+
+    private
+
+
+    def parse_feature_element(source_lines)
+      parse_feature_element_name(source_lines)
+      parse_feature_element_description(source_lines)
+    end
+
+    #todo - move this elsewhere
+    def parse_feature_element_tags(source_lines)
+      source_lines.take_while { |line| !(line =~/^\s*(?:[A-Z a-z])+:/) }.tap do |tag_lines|
+        tag_lines.join(' ').delete(' ').split('@').each do |tag|
+          @tags << "@#{tag.strip}"
+        end
+      end
+      @tags.shift
+
+      while source_lines.first =~ /^\s*@/
+        source_lines.shift
+      end
+    end
+
+    def parse_feature_element_name(source_lines)
+      @name.replace source_lines.first.match(/^\s*(?:[A-Z a-z])+:(.*)/)[1].strip
+      source_lines.shift
+    end
+
+    def parse_feature_element_description(source_lines)
+      until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:\* ))/ or
+          source_lines.first =~ /^\s*\|/ or
+          source_lines.empty?
+
+        @description << source_lines.first.strip
+        source_lines.shift
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/outline_example.rb

@@ -0,0 +1,31 @@
+module CucumberAnalytics
+  class OutlineExample < FeatureElement
+
+
+    attr_accessor :tags
+    attr_accessor :rows
+
+
+    # Creates a new OutlineExample object and, if *source_lines* is provided,
+    # populates the object.
+    def initialize(source_lines = nil)
+      super
+
+      @tags = []
+      @rows = []
+
+      parse_example(source_lines) if source_lines
+    end
+
+
+    private
+
+
+    def parse_example(source_lines)
+      parse_feature_element_tags(source_lines)
+      parse_feature_element(source_lines)
+      rows.concat source_lines.collect { |line| line.strip }
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_background.rb

@@ -0,0 +1,23 @@
+module CucumberAnalytics
+  class ParsedBackground < TestElement
+
+
+    # Creates a new ParsedBackground object and, if *source_lines* is provided,
+    # populates the object.
+    def initialize(source_lines = nil)
+      super
+
+      parse_background(source_lines) if source_lines
+    end
+
+
+    private
+
+
+    def parse_background(source_lines)
+      parse_feature_element(source_lines)
+      parse_test_element_steps(source_lines)
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_directory.rb

@@ -0,0 +1,56 @@
+module CucumberAnalytics
+  class ParsedDirectory
+
+
+    attr_reader :feature_files
+    attr_reader :feature_directories
+
+
+    # Creates a new ParsedDirectory object and, if *directory_parsed* is
+    # provided, populates the object.
+    def initialize(directory_parsed = nil)
+      @directory = directory_parsed
+
+      @feature_files = []
+      @feature_directories = []
+
+      scan_directory if directory_parsed
+    end
+
+    # Returns the name of the directory.
+    def name
+      File.basename(@directory.gsub('\\', '/'))
+    end
+
+    # Returns the path of the directory.
+    def path
+      @directory
+    end
+
+    # Returns the number of features files contained in the directory.
+    def feature_file_count
+      @feature_files.count
+    end
+
+    def contains
+      @feature_files + @feature_directories
+    end
+
+
+    private
+
+
+    def scan_directory
+      entries = Dir.entries(@directory)
+      entries.delete '.'
+      entries.delete '..'
+
+      entries.each do |entry|
+        entry = @directory + '/' + entry
+        @feature_directories << ParsedDirectory.new(entry) if File.directory?(entry)
+        @feature_files << ParsedFile.new(entry) if entry =~ /\.feature$/
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_feature.rb

@@ -0,0 +1,70 @@
+module CucumberAnalytics
+  class ParsedFeature < FeatureElement
+
+
+    attr_reader :tags
+    attr_accessor :background
+    attr_accessor :tests
+
+
+    # Creates a new ParsedFeature object and, if *source_lines* is provided,
+    # populates the object.
+    def initialize(source_lines = nil)
+      super
+
+      @tags = []
+      @tests = []
+
+      parse_feature(source_lines) if source_lines
+    end
+
+    # Returns true if the feature contains a background, false otherwise.
+    def has_background?
+      !@background.nil?
+    end
+
+    # Returns the scenarios contained in the feature.
+    def scenarios
+      @tests.select { |test| test.is_a? ParsedScenario }
+    end
+
+    # Returns the outlines contained in the feature.
+    def outlines
+      @tests.select { |test| test.is_a? ParsedScenarioOutline }
+    end
+
+    # Returns the number scenarios contained in the feature.
+    def scenario_count
+      scenarios.count
+    end
+
+    # Returns the number outlines contained in the feature.
+    def outline_count
+      outlines.count
+    end
+
+    # Returns the number of tests contained in the feature.
+    def test_count
+      @tests.count
+    end
+
+    # Returns the number of test cases contained in the feature.
+    def test_case_count
+      scenario_count + outlines.reduce(0) { |sum, outline| sum += outline.examples.count }
+    end
+
+    def contains
+      [@background] + @tests
+    end
+
+
+    private
+
+
+    def parse_feature(source_lines)
+      parse_feature_element_tags(source_lines)
+      parse_feature_element(source_lines)
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_file.rb

@@ -0,0 +1,140 @@
+module CucumberAnalytics
+  class ParsedFile
+
+
+    attr_reader :feature
+
+
+    # Creates a new ParsedFile object and, if *file_parsed* is provided,
+    # populates the object.
+    def initialize(file_parsed = nil)
+      parse_file(file_parsed) if file_parsed
+    end
+
+    # Returns the name of the file.
+    def name
+      File.basename(@file.gsub('\\', '/'))
+    end
+
+    # Returns the path of the file.
+    def path
+      @file
+    end
+
+    def contains
+      [@feature]
+    end
+
+
+    private
+
+
+    def parse_file(file_parsed)
+      @file = file_parsed
+
+      file_lines = []
+      feature_lines = []
+      background_lines = []
+
+      File.open(@file, 'r') { |file| file_lines = file.readlines }
+
+      until file_lines.first =~ /^s*Feature:/
+        unless ignored_line?(file_lines.first)
+          feature_lines << file_lines.first
+        end
+        file_lines.shift
+      end
+
+      until file_lines.first =~ /^\s*(?:@|Background:|Scenario:|(?:Scenario Outline:))/ or file_lines.empty?
+        unless ignored_line?(file_lines.first)
+          feature_lines << file_lines.first
+        end
+        file_lines.shift
+      end
+
+      until file_lines.first =~ /^\s*(?:@|Scenario:|(?:Scenario Outline:))/ or file_lines.empty?
+        if file_lines.first =~ /^\s*"""/
+          background_lines.concat(extract_doc_string!(file_lines))
+        else
+          unless ignored_line?(file_lines.first)
+            background_lines << file_lines.first
+          end
+          file_lines.shift
+        end
+      end
+
+      @feature = ParsedFeature.new(feature_lines)
+
+      unless background_lines.empty?
+        @feature.background = ParsedBackground.new(background_lines)
+      end
+
+      parse_tests(file_lines)
+    end
+
+    def parse_tests(lines)
+      test_lines = []
+
+      until lines.empty?
+        current_test_line = lines.index { |line| line =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/ }
+
+        until lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/
+          unless ignored_line?(lines.first)
+            test_lines << lines.first
+          end
+          lines.shift
+        end
+
+        test_lines << lines.first
+        lines.shift
+
+        until (lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/) or lines.empty?
+          if (lines.first =~ /^\s*"""/)
+            test_lines.concat(extract_doc_string!(lines))
+          else
+            unless ignored_line?(lines.first)
+              test_lines << lines.first
+            end
+            lines.shift
+          end
+        end
+
+        unless lines.empty?
+          while  (test_lines.last =~ /^\s*@/)
+            lines = [test_lines.pop].concat(lines)
+          end
+        end
+
+        if test_lines[current_test_line] =~ /^\s*Scenario Outline:/
+          next_test = ParsedScenarioOutline.new(test_lines)
+        else
+          next_test = ParsedScenario.new(test_lines)
+        end
+
+        @feature.tests << next_test
+      end
+    end
+
+    def extract_doc_string!(lines)
+      doc_block = []
+
+      doc_block << lines.first
+      lines.shift
+
+      until lines.first =~ /^\s*"""/
+        doc_block << lines.first
+        lines.shift
+      end
+
+      doc_block << lines.first
+      lines.shift
+
+      doc_block
+    end
+
+    def ignored_line?(line)
+      line =~ /^\s*#/ or !(line =~ /\S/)
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_scenario.rb

@@ -0,0 +1,29 @@
+module CucumberAnalytics
+  class ParsedScenario < TestElement
+
+
+    attr_accessor :tags
+
+
+    # Creates a new ParsedScenario object and, if *source_lines* is provided,
+    # populates the object.
+    def initialize(source_lines = nil)
+      super
+
+      @tags = []
+
+      parse_scenario(source_lines) if source_lines
+    end
+
+
+    private
+
+
+    def parse_scenario(source_lines)
+      parse_feature_element_tags(source_lines)
+      parse_feature_element(source_lines)
+      parse_test_element_steps(source_lines)
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsed_scenario_outline.rb

@@ -0,0 +1,57 @@
+module CucumberAnalytics
+  class ParsedScenarioOutline < TestElement
+
+
+    attr_accessor :tags
+    attr_accessor :examples
+
+    # Creates a new ParsedScenarioOutline object and, if *source_lines* is
+    # provided, populates the object.
+    def initialize(source_lines = nil)
+      super
+
+      @tags = []
+      @examples = []
+
+      parse_outline(source_lines) if source_lines
+    end
+
+    def contains
+      @examples
+    end
+
+
+    private
+
+
+    def parse_outline(source_lines)
+      parse_feature_element_tags(source_lines)
+      parse_feature_element(source_lines)
+      parse_test_element_steps(source_lines)
+      parse_outline_examples(source_lines)
+    end
+
+    def parse_outline_examples(source_lines)
+      until source_lines.empty?
+        current_example_line = source_lines.index { |line| line =~ /^\s*Examples/ }
+
+        example_lines = source_lines.slice!(0..current_example_line)
+
+        next_example_line = source_lines.index { |line| line =~ /^\s*Examples:/ }
+
+        if next_example_line.nil?
+          example_lines.concat(source_lines.slice!(0..source_lines.count))
+        else
+          while  source_lines[next_example_line - 1] =~ /^\s*@/
+            next_example_line -= 1
+          end
+
+          example_lines.concat(source_lines.slice!(0...next_example_line))
+        end
+
+        @examples << OutlineExample.new(example_lines)
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/step.rb

@@ -0,0 +1,81 @@
+module CucumberAnalytics
+  class Step
+
+
+    attr_reader :keyword
+    attr_reader :base
+    attr_reader :block
+
+
+    # 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)
+      @base = step.sub(/#{World::STEP_KEYWORD_PATTERN}/, '')
+      @block = block
+      @keyword = step.slice(/#{World::STEP_KEYWORD_PATTERN}/).strip
+    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.
+    #
+    #  a_step = CucumberAnalytics.new('Given *some* step with a block:', ['block line 1', '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: World.left_delimiter,
+                 right_delimiter: World.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 @block if @block
+      else
+        step_text += stripped_step(@base, options[:left_delimiter], options[:right_delimiter])
+        final_step << step_text
+      end
+
+      final_step
+    end
+
+
+    private
+
+
+    # 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
+      end
+
+      begin
+        Regexp.new(right_delimiter)
+      rescue RegexpError
+        right_delimiter = '\\' + right_delimiter
+      end
+
+      step.gsub(Regexp.new("#{left_delimiter}.*?#{right_delimiter}"), original_left + original_right)
+    end
+
+  end
+end

data/lib/cucumber_analytics/test_element.rb

@@ -0,0 +1,93 @@
+module CucumberAnalytics
+  class TestElement < FeatureElement
+
+
+    attr_reader :steps
+
+
+    # Creates a new TestElement object.
+    def initialize(source_lines = nil)
+      super
+
+      @steps = []
+    end
+
+    # Return true if the two elements have the same steps, minus any keywords
+    # and arguments, and false otherwise.
+    def ==(other_element)
+      left_steps = steps.collect { |step| step.step_text(with_keywords: false, with_arguments: false) }.flatten
+      right_steps = other_element.steps.collect { |step| step.step_text(with_keywords: false, with_arguments: false) }.flatten
+
+      left_steps == right_steps
+    end
+
+
+    private
+
+
+    def parse_test_element_steps(source_lines)
+      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)
+            @steps[@steps.size - 1] = Step.new(@steps.last.keyword + ' ' + @steps.last.base, block)
+          when line =~ /^\s*\|/
+            block = extract_table_block(source_lines)
+            @steps[@steps.size - 1] = Step.new(@steps.last.keyword + ' ' + @steps.last.base, block)
+          else
+            @steps << Step.new(line.strip)
+            source_lines.shift
+        end
+      end
+    end
+
+    def extract_doc_block(source_lines)
+      step_block = []
+
+      line = source_lines.first
+      leading_whitespace = line[/^\s*/]
+
+      step_block << line.strip
+      source_lines.shift
+
+      line = source_lines.first
+      until line =~ /^\s*"""/
+
+        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
+      end
+
+      step_block << line.strip
+      source_lines.shift
+
+      step_block
+    end
+
+    def extract_table_block(source_lines)
+      step_block = []
+
+      line = source_lines.first
+
+      step_block << line.strip
+      source_lines.shift
+
+      line = source_lines.first
+      while line =~ /^\s*\|/
+        step_block << line.strip
+        source_lines.shift
+        line = source_lines.first
+      end
+
+      step_block
+    end
+
+  end
+end

data/lib/cucumber_analytics/version.rb

@@ -0,0 +1,3 @@
+module CucumberAnalytics
+  VERSION = "0.0.1"
+end