cucumber_analytics 0.0.2 → 0.0.3

data/History.rdoc

@@ -0,0 +1,16 @@
+=== Version 0.0.3 / 2012-11-10
+
+* 'But' has been added to the list of recognized step keywords (formerly Given,
+When,Then, And, and *)
+* Bug fix: the number of test cases a feature is considered to contain now
+properly takes into account an outline's example rows.
+
+
+=== Version 0.0.2 / 2012-11-1
+
+* Bug fix: descriptions are no longer cut short due to the presence of keywords
+
+
+=== Version 0.0.1 / 2012-10-28
+
+* Initial release

data/cucumber_analytics.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("cucumber")
   gem.add_development_dependency("wrong")
   gem.add_development_dependency("simplecov")
+  gem.add_development_dependency("log4r")
 end

data/features/modeling/background_modeling.feature

@@ -26,13 +26,14 @@ Feature: Background elements can be modeled.
           # Basically, if it's not a step keyword or tag then I will accept
           # it as description here. Cucumber might not but but that's between
           # you and its lexxer/parser. ;)
-        * this *parameterized* step takes a table:
+        Given this *parameterized* step takes a table:
           | data      |
           | more data |
-        * some setup step
+        When some setup step
+        But some setup step
 #
-        * a step with a *parameter*
-        * some big setup step:
+        Then a step with a *parameter*
+        And some big setup step:
         #random comment
         \"\"\"
       some text
@@ -47,6 +48,8 @@ Feature: Background elements can be modeled.
         Given
         When
         Then
+        And
+        But
         *
             some more text
         \"\"\"
@@ -78,40 +81,45 @@ Feature: Background elements can be modeled.
 
   Scenario: The background steps are modeled.
     Then the background's steps are as follows:
-      | * this *parameterized* step takes a table: |
-      | \| data      \|                            |
-      | \| more data \|                            |
-      | * some setup step                          |
-      | * a step with a *parameter*                |
-      | * some big setup step:                     |
-      | """                                        |
-      | 'some text'                                |
-      | ''                                         |
-      | '#some comments'                           |
-      | 'Scenario:'                                |
-      | 'Scenario Outline:'                        |
-      | 'Examples:'                                |
-      | '@'                                        |
-      | 'Feature:'                                 |
-      | '\|'                                       |
-      | 'Given'                                    |
-      | 'When'                                     |
-      | 'Then'                                     |
-      | '*'                                        |
-      | '    some more text'                       |
-      | """                                        |
-      | * *lots* *of* *parameters*                 |
+      | Given this *parameterized* step takes a table: |
+      | \| data      \|                                |
+      | \| more data \|                                |
+      | When some setup step                           |
+      | But some setup step                            |
+      | Then a step with a *parameter*                 |
+      | And some big setup step:                       |
+      | """                                            |
+      | 'some text'                                    |
+      | ''                                             |
+      | '#some comments'                               |
+      | 'Scenario:'                                    |
+      | 'Scenario Outline:'                            |
+      | 'Examples:'                                    |
+      | '@'                                            |
+      | 'Feature:'                                     |
+      | '\|'                                           |
+      | 'Given'                                        |
+      | 'When'                                         |
+      | 'Then'                                         |
+      | 'And'                                          |
+      | 'But'                                          |
+      | '*'                                            |
+      | '    some more text'                           |
+      | """                                            |
+      | * *lots* *of* *parameters*                     |
     And the background's steps "without" arguments are as follows:
-      | * this ** step takes a table: |
-      | * some setup step             |
-      | * a step with a **            |
-      | * some big setup step:        |
-      | * ** ** **                    |
+      | Given this ** step takes a table: |
+      | When some setup step              |
+      | But some setup step               |
+      | Then a step with a **             |
+      | And some big setup step:          |
+      | * ** ** **                        |
     And the background's steps "without" keywords are as follows:
       | this *parameterized* step takes a table: |
       | \| data      \|                          |
       | \| more data \|                          |
       | some setup step                          |
+      | some setup step                          |
       | a step with a *parameter*                |
       | some big setup step:                     |
       | """                                      |
@@ -127,6 +135,8 @@ Feature: Background elements can be modeled.
       | 'Given'                                  |
       | 'When'                                   |
       | 'Then'                                   |
+      | 'And'                                    |
+      | 'But'                                    |
       | '*'                                      |
       | '    some more text'                     |
       | """                                      |
@@ -134,13 +144,14 @@ Feature: Background elements can be modeled.
     And the background's steps "without" arguments "without" keywords are as follows:
       | this ** step takes a table: |
       | some setup step             |
+      | some setup step             |
       | a step with a **            |
       | some big setup step:        |
       | ** ** **                    |
     And step "1" of the background has the following block:
       | \| data      \| |
       | \| more data \| |
-    And step "4" of the background has the following block:
+    And step "5" of the background has the following block:
       | """                  |
       | 'some text'          |
       | ''                   |
@@ -154,6 +165,8 @@ Feature: Background elements can be modeled.
       | 'Given'              |
       | 'When'               |
       | 'Then'               |
+      | 'And'                |
+      | 'But'                |
       | '*'                  |
       | '    some more text' |
       | """                  |

data/features/modeling/feature_modeling.feature

@@ -30,6 +30,7 @@ Feature: Features can be modeled.
         Given some description that uses keywords
         And more of it
         When I chuck the kitchen sink at it:
+        But
         *
         |
 
@@ -79,6 +80,7 @@ Feature: Features can be modeled.
       Examples: some examples with different significance and a tag
         | param1 | param2 |
         | a      | b      |
+        | c      | d      |
 
 
       Scenario: The second scenario's name.
@@ -113,7 +115,7 @@ Feature: Features can be modeled.
     Then feature "1" is found to have the following properties:
       | name            | The test feature name. |
       | test_count      | 3                      |
-      | test_case_count | 4                      |
+      | test_case_count | 5                      |
     And feature "2" is found to have the following properties:
       | name            |   |
       | test_count      | 2 |
@@ -132,6 +134,7 @@ Feature: Features can be modeled.
       | Given some description that uses keywords                           |
       | And more of it                                                      |
       | When I chuck the kitchen sink at it:                                |
+      | But                                                                 |
       | *                                                                   |
       | \|                                                                  |
       | Scenario Outline                                                    |

data/features/modeling/outline_modeling.feature

@@ -36,9 +36,10 @@ Feature: Scenario Outline elements can be modeled.
           | <param1> |
           | <param2> |
         And some setup step
+        * some setup step
 #
         When a step with a *parameter*
-        And a big step:
+        But a big step:
         #random comment
         \"\"\"
       some text
@@ -53,6 +54,8 @@ Feature: Scenario Outline elements can be modeled.
         Given
         When
         Then
+        And
+        But
         *
             some more text
         \"\"\"
@@ -103,8 +106,9 @@ Feature: Scenario Outline elements can be modeled.
       | \| <param1> \|                                 |
       | \| <param2> \|                                 |
       | And some setup step                            |
+      | * some setup step                              |
       | When a step with a *parameter*                 |
-      | And a big step:                                |
+      | But a big step:                                |
       | """                                            |
       | 'some text'                                    |
       | ''                                             |
@@ -118,6 +122,8 @@ Feature: Scenario Outline elements can be modeled.
       | 'Given'                                        |
       | 'When'                                         |
       | 'Then'                                         |
+      | 'And'                                          |
+      | 'But'                                          |
       | '*'                                            |
       | '    some more text'                           |
       | """                                            |
@@ -125,14 +131,16 @@ Feature: Scenario Outline elements can be modeled.
     And the test steps "without" arguments are as follows:
       | Given this ** step takes a table: |
       | And some setup step               |
+      | * some setup step                 |
       | When a step with a **             |
-      | And a big step:                   |
+      | But a big step:                   |
       | Then ** ** **                     |
     And the test steps "without" keywords are as follows:
       | this *parameterized* step takes a table: |
       | \| <param1> \|                           |
       | \| <param2> \|                           |
       | some setup step                          |
+      | some setup step                          |
       | a step with a *parameter*                |
       | a big step:                              |
       | """                                      |
@@ -148,6 +156,8 @@ Feature: Scenario Outline elements can be modeled.
       | 'Given'                                  |
       | 'When'                                   |
       | 'Then'                                   |
+      | 'And'                                    |
+      | 'But'                                    |
       | '*'                                      |
       | '    some more text'                     |
       | """                                      |
@@ -155,13 +165,14 @@ Feature: Scenario Outline elements can be modeled.
     And the test steps "without" arguments "without" keywords are as follows:
       | this ** step takes a table: |
       | some setup step             |
+      | some setup step             |
       | a step with a **            |
       | a big step:                 |
       | ** ** **                    |
     And the test step "1" has the following block:
       | \| <param1> \| |
       | \| <param2> \| |
-    And the test step "4" has the following block:
+    And the test step "5" has the following block:
       | """                  |
       | 'some text'          |
       | ''                   |
@@ -175,6 +186,8 @@ Feature: Scenario Outline elements can be modeled.
       | 'Given'              |
       | 'When'               |
       | 'Then'               |
+      | 'And'                |
+      | 'But'                |
       | '*'                  |
       | '    some more text' |
       | """                  |

data/features/modeling/scenario_modeling.feature

@@ -36,9 +36,10 @@ Feature: Scenario elements can be modeled.
           | data      |
           | more data |
         And some setup step
+        * some setup step
 #
         When a step with a *parameter*
-        And a big step:
+        But a big step:
         #random comment
         \"\"\"
       some text
@@ -53,6 +54,8 @@ Feature: Scenario elements can be modeled.
         Given
         When
         Then
+        And
+        But
         *
             some more text
         \"\"\"
@@ -69,13 +72,13 @@ Feature: Scenario elements can be modeled.
 
   Scenario: The scenario description is modeled.
     Then the test descriptive lines are as follows:
-      | My big hunk of perfectly valid description:                       |
-      | \|                                                                |
-      | Scenario Outline                                                  |
-      | Examples                                                          |
-      | """                                                               |
-      | Background                                                        |
-      | this is still one big valid description                           |
+      | My big hunk of perfectly valid description: |
+      | \|                                          |
+      | Scenario Outline                            |
+      | Examples                                    |
+      | """                                         |
+      | Background                                  |
+      | this is still one big valid description     |
 
   Scenario: The scenario steps are modeled.
     Then the test steps are as follows:
@@ -83,8 +86,9 @@ Feature: Scenario elements can be modeled.
       | \| data      \|                                |
       | \| more data \|                                |
       | And some setup step                            |
+      | * some setup step                              |
       | When a step with a *parameter*                 |
-      | And a big step:                                |
+      | But a big step:                                |
       | """                                            |
       | 'some text'                                    |
       | ''                                             |
@@ -98,6 +102,8 @@ Feature: Scenario elements can be modeled.
       | 'Given'                                        |
       | 'When'                                         |
       | 'Then'                                         |
+      | 'And'                                          |
+      | 'But'                                          |
       | '*'                                            |
       | '    some more text'                           |
       | """                                            |
@@ -105,14 +111,16 @@ Feature: Scenario elements can be modeled.
     And the test steps "without" arguments are as follows:
       | Given this ** step takes a table: |
       | And some setup step               |
+      | * some setup step                 |
       | When a step with a **             |
-      | And a big step:                   |
+      | But a big step:                   |
       | Then ** ** **                     |
     And the test steps "without" keywords are as follows:
       | this *parameterized* step takes a table: |
       | \| data      \|                          |
       | \| more data \|                          |
       | some setup step                          |
+      | some setup step                          |
       | a step with a *parameter*                |
       | a big step:                              |
       | """                                      |
@@ -128,6 +136,8 @@ Feature: Scenario elements can be modeled.
       | 'Given'                                  |
       | 'When'                                   |
       | 'Then'                                   |
+      | 'And'                                    |
+      | 'But'                                    |
       | '*'                                      |
       | '    some more text'                     |
       | """                                      |
@@ -135,13 +145,14 @@ Feature: Scenario elements can be modeled.
     And the test steps "without" arguments "without" keywords are as follows:
       | this ** step takes a table: |
       | some setup step             |
+      | some setup step             |
       | a step with a **            |
       | a big step:                 |
       | ** ** **                    |
     And the test step "1" has the following block:
       | \| data      \| |
       | \| more data \| |
-    And the test step "4" has the following block:
+    And the test step "5" has the following block:
       | """                  |
       | 'some text'          |
       | ''                   |
@@ -155,6 +166,8 @@ Feature: Scenario elements can be modeled.
       | 'Given'              |
       | 'When'               |
       | 'Then'               |
+      | 'And'                |
+      | 'But'                |
       | '*'                  |
       | '    some more text' |
       | """                  |

data/features/support/env.rb

@@ -6,6 +6,15 @@ include Wrong
 
 require File.dirname(__FILE__) + '/../../lib/cucumber_analytics'
 
+Log4r::Logger.root.level = Log4r::OFF
+
+Log4r::FileOutputter.new('logfile',
+                         :filename=>'test_log.txt',
+                         :trunc=>true,
+                         :level=>Log4r::DEBUG)
+
+CucumberAnalytics::Logging.logger.add('logfile')
+
 
 DEFAULT_FEATURE_FILE_NAME = 'test_feature.feature'
 DEFAULT_STEP_FILE_NAME = 'test_steps.rb'

data/lib/cucumber_analytics.rb

@@ -1,4 +1,7 @@
+require "log4r"
+
 require 'cucumber_analytics/version'
+require 'cucumber_analytics/logging'
 require 'cucumber_analytics/parsed_file'
 require 'cucumber_analytics/parsed_directory'
 require 'cucumber_analytics/feature_element.rb'

data/lib/cucumber_analytics/feature_element.rb

@@ -8,6 +8,8 @@ module CucumberAnalytics
 
     # Creates a new FeatureElement object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('FeatureElement#initialize')
+
       @name = ''
       @description =[]
     end
@@ -17,25 +19,41 @@ module CucumberAnalytics
 
 
     def parse_feature_element(source_lines)
+      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element')
+
       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|
+      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element_tags')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
+      source_lines.take_while { |line| line !~ /^\s*(?:[A-Z a-z])+:/ }.tap do |tag_lines|
+        tag_lines.delete_if { |line| World.ignored_line?(line)}
+
         tag_lines.join(' ').delete(' ').split('@').each do |tag|
           @tags << "@#{tag.strip}"
         end
       end
       @tags.shift
 
-      while source_lines.first =~ /^\s*@/
+      while source_lines.first !~  /^\s*(?:[A-Z a-z])+:/
         source_lines.shift
       end
     end
 
     def parse_feature_element_name(source_lines)
+      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element_name')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       @name.replace source_lines.first.match(/^\s*(?:[A-Z a-z])+:(.*)/)[1].strip
       source_lines.shift
     end

data/lib/cucumber_analytics/logging.rb

@@ -0,0 +1,9 @@
+module CucumberAnalytics
+  module Logging
+
+    def self.logger
+      @logger ||= Log4r::Logger.new('ca_logger')
+    end
+
+  end
+end

data/lib/cucumber_analytics/outline_example.rb

@@ -9,6 +9,12 @@ module CucumberAnalytics
     # Creates a new OutlineExample object and, if *source_lines* is provided,
     # populates the object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('OutlineExample#initialize')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       super
 
       @tags = []
@@ -22,16 +28,29 @@ module CucumberAnalytics
 
 
     def parse_example(source_lines)
+      CucumberAnalytics::Logging.logger.info('OutlineExample#parse_example')
+
       parse_feature_element_tags(source_lines)
       parse_feature_element(source_lines)
+
+      source_lines.delete_if { |line| World.ignored_line?(line)}
       rows.concat source_lines.collect { |line| line.strip }
     end
 
     def parse_feature_element_description(source_lines)
+      CucumberAnalytics::Logging.logger.info('OutlineExample#parse_feature_element_description')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       until source_lines.first =~ /^\s*\|/ or
           source_lines.empty?
 
-        @description << source_lines.first.strip
+        unless World.ignored_line?(source_lines.first)
+          @description << source_lines.first.strip
+        end
+
         source_lines.shift
       end
     end

data/lib/cucumber_analytics/parsed_background.rb

@@ -5,6 +5,8 @@ module CucumberAnalytics
     # Creates a new ParsedBackground object and, if *source_lines* is provided,
     # populates the object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedBackground#initialize')
+
       super
 
       parse_background(source_lines) if source_lines
@@ -15,15 +17,26 @@ module CucumberAnalytics
 
 
     def parse_background(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedBackground#parse_background')
+
       parse_feature_element(source_lines)
       parse_test_element_steps(source_lines)
     end
 
     def parse_feature_element_description(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedBackground#parse_feature_element_description')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* ))/ or
           source_lines.empty?
 
-        @description << source_lines.first.strip
+        unless World.ignored_line?(source_lines.first)
+          @description << source_lines.first.strip
+        end
+
         source_lines.shift
       end
     end

data/lib/cucumber_analytics/parsed_directory.rb

@@ -9,6 +9,8 @@ module CucumberAnalytics
     # Creates a new ParsedDirectory object and, if *directory_parsed* is
     # provided, populates the object.
     def initialize(directory_parsed = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedDirectory#initialize')
+
       @directory = directory_parsed
 
       @feature_files = []

data/lib/cucumber_analytics/parsed_feature.rb

@@ -10,6 +10,8 @@ module CucumberAnalytics
     # Creates a new ParsedFeature object and, if *source_lines* is provided,
     # populates the object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedFeature#initialize')
+
       super
 
       @tags = []
@@ -50,7 +52,11 @@ module CucumberAnalytics
 
     # 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 }
+      scenario_count + outlines.reduce(0) { |outline_sum, outline|
+        outline_sum += outline.examples.reduce(0) { |example_sum, example|
+          example_sum += example.rows.count - 1
+        }
+      }
     end
 
     def contains
@@ -62,11 +68,21 @@ module CucumberAnalytics
 
 
     def parse_feature(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedFeature#parse_feature')
+
       parse_feature_element_tags(source_lines)
       parse_feature_element(source_lines)
     end
 
     def parse_feature_element_description(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedFeature#parse_feature_element_description')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
+      source_lines.delete_if { |line| World.ignored_line?(line)}
+
       until source_lines.first =~ /^\s*(?:(?:Scenario: )|(?:Scenario Outline: )|(?:Background: )|(?:@ ))/ or
           source_lines.empty?
 

data/lib/cucumber_analytics/parsed_file.rb

@@ -8,6 +8,8 @@ module CucumberAnalytics
     # Creates a new ParsedFile object and, if *file_parsed* is provided,
     # populates the object.
     def initialize(file_parsed = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedFile#initialize')
+
       parse_file(file_parsed) if file_parsed
     end
 
@@ -30,6 +32,8 @@ module CucumberAnalytics
 
 
     def parse_file(file_parsed)
+      CucumberAnalytics::Logging.logger.info('ParsedFile#parse_file')
+
       @file = file_parsed
 
       file_lines = []
@@ -40,47 +44,44 @@ module CucumberAnalytics
 
       # collect feature tag lines
       until file_lines.first =~ /^s*Feature:/
-        unless ignored_line?(file_lines.first)
-          feature_lines << file_lines.first
-        end
+        feature_lines << file_lines.first
         file_lines.shift
       end
 
       # collect everything else until the end of the feature section
-      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
+      until file_lines.first =~ /^\s*(?:@|Background:|Scenario:|(?:Scenario Outline:))/ or
+          file_lines.empty?
+
+        feature_lines << file_lines.first
         file_lines.shift
       end
 
+      # create a new feature bases on the collected lines
+      @feature = ParsedFeature.new(feature_lines)
+
       if file_lines.first =~ /^\s*Background:/
 
         # collect the background description lines
-        until (file_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|@|Scenario:|(?:Scenario Outline:))/) or file_lines.empty?
-          unless ignored_line?(file_lines.first)
-            background_lines << file_lines.first
-          end
+        until (file_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|@|Scenario:|(?:Scenario Outline:))/) or
+            file_lines.empty?
+
+          background_lines << file_lines.first
           file_lines.shift
         end
 
         # collect everything else up to the first test
-        until file_lines.first =~ /^\s*(?:@|Scenario:|(?:Scenario Outline:))/ or file_lines.empty?
+        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
+            background_lines << file_lines.first
             file_lines.shift
           end
         end
 
-      end
-
-      @feature = ParsedFeature.new(feature_lines)
-
-      unless background_lines.empty?
+        # create a new background based on the collected lines
         @feature.background = ParsedBackground.new(background_lines)
       end
 
@@ -88,18 +89,22 @@ module CucumberAnalytics
     end
 
     def parse_tests(lines)
-      test_lines = []
+      CucumberAnalytics::Logging.logger.info('ParsedFile#parse_tests')
+      CucumberAnalytics::Logging.logger.debug('lines')
+      lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
 
       until lines.empty?
         # we'll need this in order to figure out whether we are dealing with a
         # scenario or an outline
         current_test_line = lines.index { |line| line =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/ }
 
+        test_lines = []
+
         # collect the tag lines
         until lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/
-          unless ignored_line?(lines.first)
-            test_lines << lines.first
-          end
+          test_lines << lines.first
           lines.shift
         end
 
@@ -107,28 +112,28 @@ module CucumberAnalytics
         lines.shift
 
         # collect the description lines
-        until (lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|Scenario:|(?:Scenario Outline:))/) or lines.empty?
-          unless ignored_line?(lines.first)
-            test_lines << lines.first
-          end
+        until (lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|Scenario:|(?:Scenario Outline:))/) or
+            lines.empty?
+
+          test_lines << lines.first
           lines.shift
         end
 
         # collect everything else up to the next test
-        until (lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/) or lines.empty?
+        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
+            test_lines << lines.first
             lines.shift
           end
         end
 
         # backtrack in order to not end up stealing the next test's tag lines
         unless lines.empty?
-          while  (test_lines.last =~ /^\s*@/)
+          while (test_lines.last =~ /^\s*@/) or World.ignored_line?(test_lines.last)
             lines = [test_lines.pop].concat(lines)
           end
         end
@@ -145,6 +150,12 @@ module CucumberAnalytics
     end
 
     def extract_doc_string!(lines)
+      CucumberAnalytics::Logging.logger.info('ParsedFile#extract_doc_string!')
+      CucumberAnalytics::Logging.logger.debug('lines')
+      lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       doc_block = []
 
       doc_block << lines.first
@@ -161,9 +172,5 @@ module CucumberAnalytics
       doc_block
     end
 
-    def ignored_line?(line)
-      line =~ /^\s*#/ or !(line =~ /\S/)
-    end
-
   end
 end

data/lib/cucumber_analytics/parsed_scenario.rb

@@ -8,6 +8,12 @@ module CucumberAnalytics
     # Creates a new ParsedScenario object and, if *source_lines* is provided,
     # populates the object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedScenario#initialize')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+      CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       super
 
       @tags = []
@@ -20,16 +26,27 @@ module CucumberAnalytics
 
 
     def parse_scenario(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedScenario#parse_scenario')
+
       parse_feature_element_tags(source_lines)
       parse_feature_element(source_lines)
       parse_test_element_steps(source_lines)
     end
 
     def parse_feature_element_description(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedScenario#parse_feature_element_description')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* ))/ or
           source_lines.empty?
 
-        @description << source_lines.first.strip
+        unless World.ignored_line?(source_lines.first)
+          @description << source_lines.first.strip
+        end
+
         source_lines.shift
       end
     end

data/lib/cucumber_analytics/parsed_scenario_outline.rb

@@ -8,6 +8,12 @@ module CucumberAnalytics
     # Creates a new ParsedScenarioOutline object and, if *source_lines* is
     # provided, populates the object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#initialize')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       super
 
       @tags = []
@@ -25,6 +31,8 @@ module CucumberAnalytics
 
 
     def parse_outline(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_outline')
+
       parse_feature_element_tags(source_lines)
       parse_feature_element(source_lines)
       parse_test_element_steps(source_lines)
@@ -32,32 +40,63 @@ module CucumberAnalytics
     end
 
     def parse_feature_element_description(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_feature_element_description')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
       until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )| (?:Examples: ))/ or
           source_lines.empty?
 
-        @description << source_lines.first.strip
+        unless World.ignored_line?(source_lines.first)
+          @description << source_lines.first.strip
+        end
+
         source_lines.shift
       end
     end
 
     def parse_outline_examples(source_lines)
+      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_outline_examples')
+      CucumberAnalytics::Logging.logger.debug('source lines')
+      source_lines.each do |line|
+        CucumberAnalytics::Logging.logger.debug(line.chomp)
+      end
+
+
       until source_lines.empty?
-        current_example_line = source_lines.index { |line| line =~ /^\s*Examples/ }
+        example_lines = []
 
-        example_lines = source_lines.slice!(0..current_example_line)
+        # collect the tag lines
+        until source_lines.first =~ /^\s*Examples:/
+          example_lines << source_lines.first
+          source_lines.shift
+        end
 
-        next_example_line = source_lines.index { |line| line =~ /^\s*Examples:/ }
+        example_lines << source_lines.first
+        source_lines.shift
 
-        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
+        # collect the description lines
+        until (source_lines.first =~ /^\s*\|/) or source_lines.empty?
+          example_lines << source_lines.first
+          source_lines.shift
+        end
+
+        # collect everything else up to the next example
+        until (source_lines.first =~ /^\s*Examples:/) or source_lines.empty?
+          example_lines << source_lines.first
+          source_lines.shift
+        end
 
-          example_lines.concat(source_lines.slice!(0...next_example_line))
+        # backtrack in order to not end up stealing the next test's tag lines
+        unless source_lines.empty?
+          while  (example_lines.last =~ /^\s*@/) or World.ignored_line?(example_lines.last)
+            source_lines = [example_lines.pop].concat(source_lines)
+          end
         end
 
+        # use the collected lines to create an example
         @examples << OutlineExample.new(example_lines)
       end
     end

data/lib/cucumber_analytics/step.rb

@@ -10,11 +10,23 @@ module CucumberAnalytics
     # 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}")
+
       @base = step.sub(/#{World::STEP_KEYWORD_PATTERN}/, '')
       @block = block
       @keyword = step.slice(/#{World::STEP_KEYWORD_PATTERN}/).strip
     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
+
     # 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.

data/lib/cucumber_analytics/test_element.rb

@@ -7,18 +7,17 @@ module CucumberAnalytics
 
     # Creates a new TestElement object.
     def initialize(source_lines = nil)
+      CucumberAnalytics::Logging.logger.info('TestElement#initialize')
+
       super
 
       @steps = []
     end
 
-    # Return true if the two elements have the same steps, minus any keywords
+    # Returns 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
+      steps == other_element.steps
     end
 
 
@@ -26,6 +25,12 @@ module CucumberAnalytics
 
 
     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
@@ -38,13 +43,22 @@ module CucumberAnalytics
             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)
+            unless World.ignored_line?(line)
+              @steps << Step.new(line.strip)
+            end
+
             source_lines.shift
         end
       end
     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
@@ -72,6 +86,12 @@ module CucumberAnalytics
     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
+
       step_block = []
 
       line = source_lines.first

data/lib/cucumber_analytics/version.rb

@@ -1,3 +1,3 @@
-module CucumberAnalytics
-  VERSION = "0.0.2"
-end
+module CucumberAnalytics
+  VERSION = "0.0.3"
+end

data/lib/cucumber_analytics/world.rb

@@ -3,7 +3,7 @@ module CucumberAnalytics
 
 
     SANITARY_STRING = '___!!!___'
-    STEP_KEYWORD_PATTERN = '\s*(?:Given|When|Then|And|\*)\s*'
+    STEP_KEYWORD_PATTERN = '\s*(?:Given|When|Then|And|But|\*)\s*'
 
 
     # Returns the left delimiter, which is used to mark the beginning of a step
@@ -178,5 +178,11 @@ module CucumberAnalytics
       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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber_analytics
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2012-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -75,6 +75,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Static analysis of Cucumber tests made easy.
 email:
 - morrow748@gmail.com
@@ -84,6 +100,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- History.rdoc
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -112,6 +129,7 @@ files:
 - features/support/transforms.rb
 - lib/cucumber_analytics.rb
 - lib/cucumber_analytics/feature_element.rb
+- lib/cucumber_analytics/logging.rb
 - lib/cucumber_analytics/outline_example.rb
 - lib/cucumber_analytics/parsed_background.rb
 - lib/cucumber_analytics/parsed_directory.rb