cucumber_analytics 0.0.9 → 1.0.0

data/lib/cucumber_analytics/world.rb

@@ -1,207 +1,163 @@
 module CucumberAnalytics
-  module World
 
+# A module providing suite level analysis functionality.
 
-    SANITARY_STRING = '___!!!___'
-    STEP_KEYWORD_PATTERN = '\s*(?:Given|When|Then|And|But|\*)\s*'
-    TEST_ELEMENT_START_PATTERN = '^\s*(?:@|Background:|Scenario:|(?:Scenario Outline:))'
+  module World
 
+    # A placeholder string used to mark 'dirty' portions of input strings
+    SANITARY_STRING = '___SANITIZED_BY_CUCUMBER_ANALYTICS___'
 
-    # Returns the left delimiter, which is used to mark the beginning of a step
-    # argument.
-    def self.left_delimiter
-      @left_delimiter || @right_delimiter
-    end
+    # A pattern that matches a Cucumber step keyword
+    STEP_DEF_KEYWORD_PATTERN = '(?:Given|When|Then|And|But)'
 
-    # Sets the left delimiter that will be used by default when determining
-    # step arguments.
-    def self.left_delimiter=(new_delimiter)
-      @left_delimiter = new_delimiter
-    end
+    # A pattern that matches a 'clean' regular expression
+    REGEX_PATTERN_STRING = '\/[^\/]*\/'
 
-    # Returns the right delimiter, which is used to mark the end of a step
-    # argument.
-    def self.right_delimiter
-      @right_delimiter || @left_delimiter
-    end
+    # A pattern that matches a step definition declaration line
+    STEP_DEF_LINE_PATTERN = /^\s*#{World::STEP_DEF_KEYWORD_PATTERN}\s*\(?\s*#{REGEX_PATTERN_STRING}\s*\)?/
 
-    # Sets the right delimiter that will be used by default when determining
-    # step arguments.
-    def self.right_delimiter=(new_delimiter)
-      @right_delimiter = new_delimiter
-    end
+    # A pattern that captures the regular expression portion of a step definition declaration line
+    STEP_DEF_PATTERN_CAPTURE_PATTERN = /^\s*#{World::STEP_DEF_KEYWORD_PATTERN}\s*\(?\s*(#{REGEX_PATTERN_STRING})\s*\)?/
 
-    # Loads the step patterns contained in the given file into the World.
-    def self.load_step_file(file_path)
-      @@defined_expressions ||= []
 
-      File.open(file_path, 'r') do |file|
-        file.readlines.each do |line|
-          if step_def_line?(line)
-            the_reg_ex = extract_regular_expression(line)
-            @@defined_expressions << the_reg_ex
-          end
-        end
-      end
-    end
+    class << self
 
-    # Returns the step patterns that have been loaded into the World.
-    def self.defined_step_patterns
-      @@defined_expressions
-    end
-
-    # Returns all tags found in the passed container.
-    def self.tags_in(container)
-      Array.new.tap do |accumulated_tags|
-        collect_tags(accumulated_tags, container)
+      # Returns the left delimiter, which is used to mark the beginning of a step
+      # argument.
+      def left_delimiter
+        @left_delimiter
       end
-    end
 
-    # Returns all directories found in the passed container.
-    def self.directories_in(container)
-      Array.new.tap do |accumulated_directories|
-        collect_directories(accumulated_directories, container)
+      # Sets the left delimiter that will be used by default when determining
+      # step arguments.
+      def left_delimiter=(new_delimiter)
+        @left_delimiter = new_delimiter
       end
-    end
 
-    # Returns all feature files found in the passed container.
-    def self.files_in(container)
-      Array.new.tap do |accumulated_files|
-        collect_files(accumulated_files, container)
+      # Returns the right delimiter, which is used to mark the end of a step
+      # argument.
+      def right_delimiter
+        @right_delimiter
       end
-    end
 
-    # Returns all features found in the passed container.
-    def self.features_in(container)
-      Array.new.tap do |accumulated_features|
-        collect_features(accumulated_features, container)
+      # Sets the right delimiter that will be used by default when determining
+      # step arguments.
+      def right_delimiter=(new_delimiter)
+        @right_delimiter = new_delimiter
       end
-    end
 
-    # Returns all tests found in the passed container.
-    def self.tests_in(container)
-      Array.new.tap do |accumulated_tests|
-        collect_tests(accumulated_tests, container)
+      # 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
-    end
 
-    # Returns all steps found in the passed container.
-    def self.steps_in(container)
-      Array.new.tap do |accumulated_steps|
-        collect_steps(accumulated_steps, container)
+      # Loads the step patterns contained in the given file into the World.
+      def load_step_file(file_path)
+        File.open(file_path, 'r') do |file|
+          file.readlines.each do |line|
+            if step_def_line?(line)
+              the_reg_ex = extract_regular_expression(line)
+              loaded_step_patterns << the_reg_ex
+            end
+          end
+        end
       end
-    end
 
-    # Returns all undefined steps found in the passed container.
-    def self.undefined_steps_in(container)
-      all_steps = steps_in(container)
-
-      all_steps.select { |step| !World.defined_step_patterns.any? { |pattern| step.base =~ Regexp.new(pattern) } }
-    end
+      # Loads the step pattern into the World.
+      def load_step_pattern(pattern)
+        loaded_step_patterns << pattern
+      end
 
-    # Returns all defined steps found in the passed container.
-    def self.defined_steps_in(container)
-      all_steps = steps_in(container)
+      # Returns the step patterns that have been loaded into the World.
+      def loaded_step_patterns
+        @defined_expressions ||= []
+      end
 
-      all_steps.select { |step| World.defined_step_patterns.any? { |pattern| step.base =~ Regexp.new(pattern) } }
-    end
+      # Returns all tags found in the passed container.
+      def tags_in(container)
+        Array.new.tap { |accumulated_tags| collect_all_in(:tags, container, accumulated_tags) }
+      end
 
+      # Returns all directories found in the passed container.
+      def directories_in(container)
+        Array.new.tap { |accumulated_directories| collect_all_in(:directories, container, accumulated_directories) }
+      end
 
-    private
+      # Returns all feature files found in the passed container.
+      def feature_files_in(container)
+        Array.new.tap { |accumulated_files| collect_all_in(:feature_files, container, accumulated_files) }
+      end
 
+      # Returns all features found in the passed container.
+      def features_in(container)
+        Array.new.tap { |accumulated_features| collect_all_in(:features, container, accumulated_features) }
+      end
 
-    # Make life easier by ensuring that the only forward slashes in the
-    # regular expression are the important ones.
-    def self.sanitize_line(line)
-      line.gsub('\/', SANITARY_STRING)
-    end
+      # Returns all tests found in the passed container.
+      def tests_in(container)
+        Array.new.tap { |accumulated_tests| collect_all_in(:tests, container, accumulated_tests) }
+      end
 
-    # And be sure to restore the line to its original state.
-    def self.desanitize_line(line)
-      line.gsub(SANITARY_STRING, '\/')
-    end
+      # Returns all steps found in the passed container.
+      def steps_in(container)
+        Array.new.tap { |accumulated_steps| collect_all_in(:steps, container, accumulated_steps) }
+      end
 
-    # Returns whether or not the passed line is a step pattern.
-    def self.step_def_line?(line)
-      !!(sanitize_line(line) =~ /^#{World::STEP_KEYWORD_PATTERN}\/[^\/]*\//)
-    end
+      # Returns all undefined steps found in the passed container.
+      def undefined_steps_in(container)
+        all_steps = steps_in(container)
 
-    # Returns the regular expression portion of a step pattern line.
-    def self.extract_regular_expression(line)
-      desanitize_line(sanitize_line(line).match(/^#{World::STEP_KEYWORD_PATTERN}\/([^\/]*)\//)[1])
-    end
+        all_steps.select { |step| !World.loaded_step_patterns.any? { |pattern| step.base =~ Regexp.new(pattern) } }
+      end
 
-    # Recursively gathers all tags found in the passed container.
-    def self.collect_tags(accumulated_tags, container)
-      accumulated_tags.concat container.tags if container.respond_to?(:tags)
+      # Returns all defined steps found in the passed container.
+      def defined_steps_in(container)
+        all_steps = steps_in(container)
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_tags(accumulated_tags, child_container)
-        end
+        all_steps.select { |step| World.loaded_step_patterns.any? { |pattern| step.base =~ Regexp.new(pattern) } }
       end
-    end
 
-    # Recursively gathers all directories found in the passed container.
-    def self.collect_directories(accumulated_directories, container)
-      accumulated_directories.concat container.feature_directories if container.respond_to?(:feature_directories)
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_directories(accumulated_directories, child_container)
-        end
-      end
-    end
+      private
 
-    # Recursively gathers all feature files found in the passed container.
-    def self.collect_files(accumulated_files, container)
-      accumulated_files.concat container.feature_files if container.respond_to?(:feature_files)
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_files(accumulated_files, child_container)
-        end
+      # Make life easier by ensuring that the only forward slashes in the
+      # regular expression are the important ones.
+      def sanitize_line(line)
+        line.gsub('\/', SANITARY_STRING)
       end
-    end
 
-    # Recursively gathers all features found in the passed container.
-    def self.collect_features(accumulated_features, container)
-      accumulated_features << container.feature if container.respond_to?(:feature) && container.feature
+      # And be sure to restore the line to its original state.
+      def desanitize_line(line)
+        line.gsub(SANITARY_STRING, '\/')
+      end
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_features(accumulated_features, child_container)
-        end
+      # Returns whether or not the passed line is a step pattern.
+      def step_def_line?(line)
+        !!(sanitize_line(line) =~ STEP_DEF_LINE_PATTERN)
       end
-    end
 
-    # Recursively gathers all tests found in the passed container.
-    def self.collect_tests(accumulated_tests, container)
-      accumulated_tests.concat container.tests if container.respond_to?(:tests)
+      # Returns the regular expression portion of a step pattern line.
+      def extract_regular_expression(line)
+        line = desanitize_line(sanitize_line(line).match(STEP_DEF_PATTERN_CAPTURE_PATTERN)[1])
+        line = line.slice(1..(line.length - 2))
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_tests(accumulated_tests, child_container)
-        end
+        Regexp.new(line)
       end
-    end
 
-    # Recursively gathers all steps found in the passed container.
-    def self.collect_steps(accumulated_steps, container)
-      accumulated_steps.concat container.steps if container.respond_to?(:steps)
+      # Recursively gathers all things of the given type found in the passed container.
+      def collect_all_in(type_of_thing, container, accumulated_things)
+        accumulated_things.concat container.send(type_of_thing) if container.respond_to?(type_of_thing)
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_steps(accumulated_steps, child_container)
+        if container.respond_to?(:contains)
+          container.contains.each do |child_container|
+            collect_all_in(type_of_thing, child_container, accumulated_things)
+          end
         end
       end
-    end
 
-    # Returns true if the line is ignored when reading source code, false
-    # otherwise.
-    def self.ignored_line?(line)
-      line =~ /^\s*#/ or !(line =~ /\S/)
     end
-
   end
 end

data/lib/cucumber_analytics.rb

@@ -1,13 +1,17 @@
 require 'cucumber_analytics/version'
-require 'cucumber_analytics/logging'
-require 'cucumber_analytics/parsed_file'
-require 'cucumber_analytics/parsed_directory'
+require 'cucumber_analytics/parsing'
+require 'cucumber_analytics/containing'
+require 'cucumber_analytics/taggable'
+require 'cucumber_analytics/feature_file'
+require 'cucumber_analytics/directory'
 require 'cucumber_analytics/feature_element.rb'
-require 'cucumber_analytics/parsed_feature'
+require 'cucumber_analytics/feature'
 require 'cucumber_analytics/test_element.rb'
-require 'cucumber_analytics/parsed_background'
-require 'cucumber_analytics/parsed_scenario'
-require 'cucumber_analytics/parsed_scenario_outline'
-require 'cucumber_analytics/outline_example'
+require 'cucumber_analytics/background'
+require 'cucumber_analytics/scenario'
+require 'cucumber_analytics/outline'
+require 'cucumber_analytics/example'
 require 'cucumber_analytics/step'
+require 'cucumber_analytics/doc_string'
+require 'cucumber_analytics/table'
 require 'cucumber_analytics/world'

data/spec/integration/background_integration_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Background') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Background, Integration' do
+
+  it 'properly sets its child elements' do
+    source = ['  Background: Test background',
+              '    * a step']
+    source = source.join("\n")
+
+    background = CucumberAnalytics::Background.new(source)
+    step = background.steps.first
+
+    step.parent_element.should equal background
+  end
+
+end

data/spec/integration/directory_integration_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Directory') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Directory, Integration' do
+
+  it 'properly sets its child elements' do
+    nested_directory = "#{@default_file_directory}/nested_directory"
+    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
+
+    FileUtils.mkdir(nested_directory)
+    File.open(file_path, "w") { |file|
+      file.puts('Feature: Test feature')
+    }
+
+    directory = CucumberAnalytics::Directory.new(@default_file_directory)
+    nested_directory = directory.directories.first
+    file = directory.feature_files.first
+
+    nested_directory.parent_element.should equal directory
+    file.parent_element.should equal directory
+  end
+
+end

data/spec/{feature_spec.rb → integration/feature_file_integration_spec.rb}

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
-SimpleCov.command_name('ParsedFeature') unless RUBY_VERSION.to_s < '1.9.0'
+SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe "ParsedFeature" do
+describe 'FeatureFile, Integration' do
 
-  it 'knows its parent element' do
+  it 'properly sets its child elements' do
     file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
 
     File.open(file_path, "w") { |file|
       file.puts('Feature: Test feature')
     }
 
-    file = CucumberAnalytics::ParsedFile.new(file_path)
+    file = CucumberAnalytics::FeatureFile.new(file_path)
     feature = file.feature
 
     feature.parent_element.should equal file
   end
 
-end
+end

data/spec/integration/feature_integration_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Feature, Integration' do
+
+  clazz = CucumberAnalytics::Feature
+
+  before(:each) do
+    @feature = clazz.new
+  end
+
+  it 'properly sets its child elements' do
+    source = ['Feature: Test feature',
+              '  Background: Test background',
+              '  Scenario: Test scenario',
+              '  Scenario Outline: Test outline']
+    source = source.join("\n")
+
+
+    feature = CucumberAnalytics::Feature.new(source)
+    background = feature.background
+    scenario = feature.tests[0]
+    outline = feature.tests[1]
+
+
+    outline.parent_element.should equal feature
+    scenario.parent_element.should equal feature
+    background.parent_element.should equal feature
+  end
+
+  it 'can distinguish scenarios from outlines - #scenarios, #outlines' do
+    scenarios = [CucumberAnalytics::Scenario.new('Scenario: 1'), CucumberAnalytics::Scenario.new('Scenario: 2')]
+    outlines = [CucumberAnalytics::Outline.new('Scenario Outline: 1'), CucumberAnalytics::Outline.new('Scenario Outline: 2')]
+
+    @feature.tests = scenarios + outlines
+
+    @feature.scenarios.should =~ scenarios
+    @feature.outlines.should =~ outlines
+  end
+
+  it 'knows how many scenarios it has - #scenario_count' do
+    scenarios = [CucumberAnalytics::Scenario.new('Scenario: 1'), CucumberAnalytics::Scenario.new('Scenario: 2')]
+    outlines = [CucumberAnalytics::Outline.new('Scenario Outline: 1')]
+
+    @feature.tests = []
+    @feature.scenario_count.should == 0
+
+    @feature.tests = scenarios + outlines
+    @feature.scenario_count.should == 2
+  end
+
+  it 'knows how many outlines it has - #outline_count' do
+    scenarios = [CucumberAnalytics::Scenario.new('Scenario: 1')]
+    outlines = [CucumberAnalytics::Outline.new('Scenario Outline: 1'), CucumberAnalytics::Outline.new('Scenario Outline: 2')]
+
+    @feature.tests = []
+    @feature.outline_count.should == 0
+
+    @feature.tests = scenarios + outlines
+    @feature.outline_count.should == 2
+  end
+
+  it 'knows how many test cases it has - #test_case_count' do
+    source_1 = ['Feature: Test feature']
+    source_1 = source_1.join("\n")
+
+    source_2 = ['Feature: Test feature',
+              '  Scenario: Test scenario',
+              '  Scenario Outline: Test outline',
+              '    * a step',
+              '  Examples: Test examples',
+              '    |param|',
+              '    |value_1|',
+              '    |value_2|']
+    source_2 = source_2.join("\n")
+
+    feature_1 = CucumberAnalytics::Feature.new(source_1)
+    feature_2 = CucumberAnalytics::Feature.new(source_2)
+
+
+    feature_1.test_case_count.should == 0
+    feature_2.test_case_count.should == 3
+  end
+
+end

data/spec/integration/outline_integration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Outline, Integration' do
+
+  it 'properly sets its child elements' do
+    source = ['  Scenario Outline:',
+              '    * a step',
+              '  Examples:',
+              '    | param |']
+    source = source.join("\n")
+
+    outline = CucumberAnalytics::Outline.new(source)
+    example = outline.examples.first
+    step = outline.steps.first
+
+    example.parent_element.should equal outline
+    step.parent_element.should equal outline
+  end
+
+end

data/spec/integration/scenario_integration_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Scenario') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Scenario, Integration' do
+
+  it 'properly sets its child elements' do
+    source = ['Scenario: Test scenario',
+              '  * a step']
+    source = source.join("\n")
+
+    scenario = CucumberAnalytics::Scenario.new(source)
+    step = scenario.steps.first
+
+    step.parent_element.should equal scenario
+  end
+
+end

data/spec/integration/step_integration_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Step') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Step, Integration' do
+
+  it 'properly sets its child elements' do
+    source_1 = ['* a step',
+                '"""',
+                'a doc string',
+                '"""']
+    source_2 = ['* a step',
+                '| a block|']
+
+    step_1 = CucumberAnalytics::Step.new(source_1.join("\n"))
+    step_2 = CucumberAnalytics::Step.new(source_2.join("\n"))
+
+
+    doc_string = step_1.block
+    table = step_2.block
+
+    doc_string.parent_element.should equal step_1
+    table.parent_element.should equal step_2
+  end
+
+  it 'defaults to the World delimiters if its own are not set' do
+    world = CucumberAnalytics::World
+    world.left_delimiter = '"'
+    world.right_delimiter = '"'
+
+    step = CucumberAnalytics::Step.new
+    step.right_delimiter = nil
+    step.left_delimiter = nil
+
+    step.right_delimiter.should == '"'
+    step.left_delimiter.should == '"'
+  end
+
+  it 'attempts to determine its arguments during creation' do
+    source = 'Given a test step with *parameter 1* and "parameter 2" and *parameter 3*'
+
+    world = CucumberAnalytics::World
+    world.left_delimiter = '"'
+    world.right_delimiter = '"'
+
+    step = CucumberAnalytics::Step.new(source)
+
+    step.arguments.should == ['parameter 2']
+  end
+
+  it 'finds nothing when no regular expression or delimiters are available' do
+    world = CucumberAnalytics::World
+    world.left_delimiter = nil
+    world.right_delimiter = nil
+
+    source = 'Given a test step with *parameter 1* and "parameter 2" and *parameter 3*'
+    step = CucumberAnalytics::Step.new(source)
+
+    step.scan_arguments
+
+    step.arguments.should == []
+  end
+
+  it 'can determine its equality with another Step' do
+      source_1 = "Given a test step with *parameter 1* and *parameter 2*\n|a block|"
+      source_2 = "Given a test step with *parameter 3* and *parameter 4*\n|another block|"
+      source_3 = 'Given a different *parameterized* step'
+
+      step_1 = CucumberAnalytics::Step.new(source_1)
+      step_2 = CucumberAnalytics::Step.new(source_2)
+      step_3 = CucumberAnalytics::Step.new(source_3)
+
+      step_1.delimiter = '*'
+      step_2.delimiter = '*'
+      step_3.delimiter = '*'
+
+
+      (step_1 == step_2).should be_true
+      (step_1 == step_3).should be_false
+  end
+
+  context '#step_text ' do
+
+      before(:each) do
+        source = "Given a test step with -parameter 1- ^and@ *parameter 2!!\n|a block|"
+        @step = CucumberAnalytics::Step.new(source)
+      end
+
+
+      it 'returns the step\'s entire text by default' do
+        source = "Given a test step with -parameter 1- ^and@ *parameter 2!!\n|a block|"
+        step_with_block = CucumberAnalytics::Step.new(source)
+
+        expected_output = ['Given a test step with -parameter 1- ^and@ *parameter 2!!',
+                           '|a block|']
+
+        step_with_block.step_text.should == expected_output
+
+        source = 'Given a test step with -parameter 1- ^and@ *parameter 2!!'
+        step_without_block = CucumberAnalytics::Step.new(source)
+
+        expected_output = ['Given a test step with -parameter 1- ^and@ *parameter 2!!']
+
+        step_without_block.step_text.should == expected_output
+      end
+
+      it 'can provide the step\'s text without the keyword' do
+        expected_output = ['a test step with -parameter 1- ^and@ *parameter 2!!',
+                           '|a block|']
+
+        @step.step_text(with_keywords: false).should == expected_output
+      end
+
+  end
+
+end