cucumber-in-the-yard 1.5.3 → 1.5.4

data/.autotest

@@ -0,0 +1,15 @@
+require 'autotest/growl'
+
+Autotest.add_hook :initialize do |at|
+  #%w{ features definitions common browser jmx }.each {|exception| at.add_exception(exception)}
+end
+
+# Overrides to include the required folders to make this project autotestable
+# This is because requires cannot exist within the options file
+class Autotest::Rspec < Autotest
+  def make_test_cmd(files_to_test)
+    files_to_test.empty? ? '' :
+      "#{ruby} #{SPEC_PROGRAM} -r lib/city.rb --color --autospec #{normalize(files_to_test).keys.flatten.join(' ')} #{add_options_if_present}"
+  end
+end
+

data/.rspec

@@ -0,0 +1,3 @@
+# /.rspec
+--format d
+--color

data/History.txt

@@ -1,3 +1,14 @@
+=== 1.5.4 / 2010-10-28
+
+* Optimization - Found that for a large test suite that the processing time was
+  approaching 2 hours (oh boy!).  Reduced that time to a few minutes by optimizing
+  the feature handler to cache all step definitions and step transforms.
+
+* Step Transforms will now attempt to unpack any constants found within them.
+* FIX - Step Transforms were not being parsed because the regex incorrectly included
+  the block.
+* FIX - Features and Scenarios with multiple tags were not being displayed
+
 === 1.5.3 / 2010-10-26
 
 * FIX - Step Definition YARD handler regex was poorly formed and raised exceptions

data/Rakefile

@@ -1,22 +1,9 @@
 require 'rake'
-require 'echoe'
 
 task :default => :gendoc
 
 task :gendoc do
   `rm -rf doc`
-  `yardoc -e lib/city.rb -p lib/templates 'example/**/*' --debug`
-end
-
-Echoe.new('cucumber-in-the-yard', '1.5.3') do |g|
-  g.author = "Franklin Webber"
-  g.email = "franklin.webber@gmail.com"
-  g.url = "http://github.com/burtlo/Cucumber-In-The-Yard"
-  g.description = %{ 
-    Cucumber-In-The-Yard is a YARD extension that processes Cucumber Features, Scenarios, Steps,
-    Step Definitions, Transforms, and Tags and provides a documentation interface that allows you
-    easily view and investigate the test suite.  This tools hopes to bridge the gap of being able
-    to provide your feature descriptions to your Product Owners and Stakeholders.  }
-  g.ignore_pattern = FileList["{doc,pkg,spec,features,nbproject,autotest}/**/*"].to_a
-  g.runtime_dependencies = [ "cucumber >=0.7.5", "yard >=0.6.1" ]
-end
+  `rm -rf .yardoc`
+  `yardoc -e lib/city.rb -p lib/templates 'example/**/*.*' --debug`
+end

data/autotest/discover.rb

@@ -0,0 +1,3 @@
+#./autotest/discover.rb
+
+Autotest.add_discovery { "rspec2" }

data/city.gemspec

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/lib/city"
+
+module CucumberInTheYARD
+
+def self.show_version_changes(version)
+  date = ""
+  changes = []  
+  grab_changes = false
+
+  File.open("#{File.dirname(__FILE__)}/History.txt",'r') do |file|
+    while (line = file.gets) do
+    
+      if line =~ /^===\s*#{version.gsub('.','\.')}\s*\/\s*(.+)\s*$/
+        grab_changes = true
+        date = $1.strip
+      elsif line =~ /^===\s*.+$/
+        grab_changes = false
+      elsif grab_changes
+        changes = changes << line
+      end
+      
+    end
+  end
+  
+  { :date => date, :changes => changes }
+end
+end
+
+Gem::Specification.new do |s|
+  s.name        = 'cucumber-in-the-yard'
+  s.version     = ::CucumberInTheYARD::VERSION
+  s.authors     = ["Franklin Webber"]
+  s.description = %{ 
+    Cucumber-In-The-Yard is a YARD extension that processes Cucumber Features, Scenarios, Steps,
+    Step Definitions, Transforms, and Tags and provides a documentation interface that allows you
+    easily view and investigate the test suite.  This tools hopes to bridge the gap of being able
+    to provide your feature descriptions to your Product Owners and Stakeholders.  }
+  s.summary     = "Cucumber Features in YARD"
+  s.email       = 'franklin.webber@gmail.com'
+  s.homepage    = "http://github.com/burtlo/Cucumber-In-The-Yard"
+
+  s.platform    = Gem::Platform::RUBY
+  
+  changes = CucumberInTheYARD.show_version_changes(::CucumberInTheYARD::VERSION)
+  
+  s.post_install_message = %{
+(::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)
+
+  Thank you for installing Cucumber-In-The-YARD #{::CucumberInTheYARD::VERSION} / #{changes[:date]}.
+  
+  Changes:
+  #{changes[:changes].collect{|change| "  #{change}"}.join("")}
+(::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)
+
+}
+
+  s.add_dependency 'gherkin', '>= 2.2.9'
+  s.add_dependency 'cucumber', '>= 0.7.5'
+  s.add_dependency 'yard', '>= 0.6.1'
+  
+  s.rubygems_version   = "1.3.7"
+  s.files            = `git ls-files`.split("\n")
+  s.extra_rdoc_files = ["README.md", "History.txt"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+end

data/example/first_example.feature

@@ -0,0 +1,19 @@
+@feature @bvt
+Feature: Feature File
+  As a product owner it is important for me to be able to view a feature file through
+  an interface which is easily accessible.  A feature's description appears along side
+  the comments for the feature.
+
+  Background:
+    Given this first background step
+
+  @bvt
+  Scenario: First Scenario
+    Given this first scenario step
+    When this is parsed with Cucumber-In-The-YARD
+    Then I expect that each step is highlighted and matched to a step definition 
+
+  Scenario: Second Scenario
+    Given this first scenario step
+    When this is parsed with Cucumber-In-The-YARD
+    Then I expect that this scenario is present

data/example/second_example.feature

@@ -5,7 +5,7 @@ Feature: Customer Logout Feature
   Background:
     Given this undefined step definition
 
-  @bvt
+  @bvt @param2 @param3
   Scenario: Customer that is logged in is able to log out
     Given that a customer is a valid customer
     And a customer logs in as username 'frank' with password 'default'

data/example/step_definitions/example.step.rb

@@ -10,6 +10,11 @@ Transform /^the customer$/ do |customer|
   "the transformed customer"
 end
 
+Transform /^#{TEDDY_BEAR}$/ do |teddy|
+  "the tranformed teddy bear"
+end
+
+
 Transform /^((?:\d{1,2}[\/-]){2}(?:\d\d){1,2})?\s*(\w{3})?\s*(\d{1,2}:\d{2}\s*(?:AM|PM)?)$/ do |date,day,time|
   "#{date} #{day} #{time}"
 end

data/lib/city.rb

@@ -5,6 +5,11 @@ require 'gherkin/formatter/tag_count_formatter'
 
 require 'yard'
 
+module CucumberInTheYARD
+  VERSION = '1.5.4' unless defined?(CucumberInTheYARD::VERSION)
+end
+
+
 require File.dirname(__FILE__) + "/yard/code_objects/cucumber/base.rb"
 require File.dirname(__FILE__) + "/yard/code_objects/cucumber/namespace_object.rb"
 require File.dirname(__FILE__) + "/yard/code_objects/cucumber/feature.rb"

data/lib/cucumber/city_builder.rb

@@ -27,7 +27,7 @@ module Cucumber
 
         tag_code_object.add_file(@file,parent.line)
 
-        parent.tags << tag_code_object unless parent.tags.find {|tag| tag_code_object }
+        parent.tags << tag_code_object unless parent.tags.find {|tag| tag == tag_code_object }
         tag_code_object.owners << parent unless tag_code_object.owners.find {|owner| owner == parent}
       end
 

data/lib/templates/default/steptransformers/setup.rb

@@ -12,8 +12,8 @@ def stepdefinitions
 end
 
 def steptransforms
-  @item_title = "Step Transformers"
-  @item_type = "step transformer"
+  @item_title = "Step Transforms"
+  @item_type = "step transform"
   @items = YARD::Registry.all(:steptransform)
   erb(:transformers)
 end

data/lib/yard/code_objects/step_definition.rb

@@ -5,8 +5,8 @@ module YARD::CodeObjects
   class StepDefinitionObject < Base
     include Cucumber::LocationHelper
     
-    attr_reader :keyword, :value, :compare_value, :source 
-    attr_accessor :constants, :steps
+    attr_reader :constants, :keyword, :source, :value  
+    attr_accessor :steps
     
     def value=(value)
       @value = format_source(value)

data/lib/yard/code_objects/step_transform.rb

@@ -1,18 +1,38 @@
 
+
 module YARD::CodeObjects
 
   class StepTransformObject < Base
     include Cucumber::LocationHelper
     
-    attr_reader :value
+    attr_reader :constants, :source, :value
+    attr_accessor :steps
 
     def value=(value)
       @value = format_source(value)
+      @constants = {}
       @steps = []
+      @compare_value = nil
     end
     
     def compare_value
-      value.gsub(/^\/|\/$/,'')
+      unless @compare_value
+        @compare_value = value.gsub(/^\/|\/$/,'')
+        @constants.each do |name,value|
+          @compare_value.gsub!(/\#\{\s*#{name.to_s}\s*\}/,value.gsub(/^\/|\/$/,''))
+        end
+      end
+      @compare_value
+    end
+        
+    def _value_constants(data=@value)
+      data.scan(/\#\{([^\}]+)\}/).flatten.collect { |value| value.strip }
+    end
+    
+    def constants=(value)
+      value.each do |val| 
+        @constants[val.name.to_s] = val if val.respond_to?(:name) && val.respond_to?(:value)
+      end
     end
     
   end

data/lib/yard/handlers/cucumber/feature_handler.rb

@@ -1,32 +1,38 @@
 module YARD
   module Handlers
     module Cucumber
-
       class FeatureHandler < Base
 
         handles CodeObjects::Cucumber::Feature
 
-        def process 
+        @@step_definitions = nil
+        @@step_transforms = nil
+        
+        def process
+
+          # Create a cache of all of the step definitions and the step transforms
+          @@step_definitions = cache(:stepdefinition) unless @@step_definitions
+          @@step_transforms = cache(:steptransform) unless @@step_transforms
+
 
           if statement
-            log.info "Processing Feature: #{statement.value}"
             # For the background and the scenario, find the steps that have definitions
             process_scenario(statement.background) if statement.background
 
-
             statement.scenarios.each do |scenario|
               if scenario.outline?
-                log.info "Scenario Outline: #{scenario.value}"
+                #log.info "Scenario Outline: #{scenario.value}"
                 scenario.scenarios.each_with_index do |example,index|
-                  log.info " * Processing Example #{index + 1}"
+                  #log.info " * Processing Example #{index + 1}"
                   process_scenario(example)
                 end
               else
-                log.info "Processing Scenario: #{scenario.value}"
+                #log.info "Processing Scenario: #{scenario.value}"
                 process_scenario(scenario)
               end
             end
-            
+
+
           else
             log.warn "Empty feature file.  A feature failed to process correctly or contains no feature"
           end
@@ -37,64 +43,53 @@ module YARD
           log.debug "\n#{exception}\n#{exception.backtrace.join("\n")}\n"
         end
 
+        #
+        # Store all comparable items with their compare_value as the key and the item as the value
+        # - Reject any compare values that contain escapes #{} as that means they have unpacked constants
+        # 
+        def cache(type)
+          YARD::Registry.all(type).inject({}) do |hash,item| 
+            hash[%r{#{item.compare_value}}] = item unless item.compare_value =~ /.+\#\{[^\}]+\}.+/
+            hash
+          end
+        end
 
 
         def process_scenario(scenario)
-          scenario.steps.each do |step|
-            process_step(step)
-          end
+          scenario.steps.each {|step| process_step(step) }
         end
 
-
         def process_step(step)
-          step_definition = match_step_to_step_definition(step.value)
-          
-          if step_definition
-            step.definition = step_definition
-            find_transforms_for_step(step)
-          end
-        end
+          match_step_to_step_definition_and_transforms(step)
 
+        end
 
-        def match_step_to_step_definition(step_value)
-          YARD::Registry.all(:stepdefinition).each do |stepdef|
-            #log.debug "Looking at step #{step_value} against #{stepdef}"
+        def match_step_to_step_definition_and_transforms(step)
+          @@step_definitions.each do |stepdef,stepdef_object|
 
-            if stepdef.compare_value =~ /.+\#\{[^\}]+\}.+/
-              log.warn "Step definition still has a unpacked constant #{stepdef.compare_value}"
-            else
-              return stepdef if %r{#{stepdef.compare_value}}.match(step_value)
-            end
-          end
+            stepdef_matches = step.value.match(stepdef)
 
-          nil
-        end
-        
-        def find_transforms_for_step(step)
-          #log.debug "Looking at step #{step} for transforms"
-          
-          if step.definition
-            
-            step.value.match(%r{#{step.definition.compare_value}}).to_a.each do |match|
-              YARD::Registry.all(:steptransform).each do |steptrans|
-                #log.debug "Looking at transform #{steptrans.value}"
-                if %r{#{steptrans.compare_value}}.match(match)
-                  #log.debug "Step #{step} is affected by the transform #{steptrans}"
-                  step.transforms << steptrans
-                  steptrans.steps << step
+            if stepdef_matches
+              step.definition = stepdef_object
+              stepdef_matches[-1..1].each do |match|
+                @@step_transforms.each do |steptrans,steptransform_object|
+                  if steptrans.match(match)
+                    step.transforms << steptransform_object
+                    steptransform_object.steps << step
+                  end
                 end
               end
               
+              # Step has been matched to step definition and step transforms
+              break
+              
             end
-            
-          end
-          
-        end
 
+          end
 
 
+        end
       end
-
     end
   end
 end

data/lib/yard/handlers/step_definition_handler.rb

@@ -2,14 +2,14 @@
 
 class StepDefinitionHandler < YARD::Handlers::Ruby::Legacy::Base
   #TODO: This needs to become language independent.
-  MATCH = /^((When|Given|And|Then)\s*(\/.+\/)\s+do(?:\s\|.+\|)?\s*)$/
-  handles MATCH
+  STEP_DEFINITION_MATCH = /^((When|Given|And|Then)\s*(\/.+\/)\s+do(?:\s*\|.+\|)?\s*)$/
+  handles STEP_DEFINITION_MATCH
 
   @@unique_name = 0
 
   def process
-    keyword = statement.tokens.to_s[MATCH,2]
-    step_definition = statement.tokens.to_s[MATCH,3]
+    keyword = statement.tokens.to_s[STEP_DEFINITION_MATCH,2]
+    step_definition = statement.tokens.to_s[STEP_DEFINITION_MATCH,3]
 
     @@unique_name = @@unique_name + 1
 
@@ -19,12 +19,15 @@ class StepDefinitionHandler < YARD::Handlers::Ruby::Legacy::Base
       o.keyword = keyword
     end
     
-    find_steps_defined_in_block(statement.block)
+    # TODO: Currently I have not devised a good way to declare them or show them
+    #find_steps_defined_in_block(statement.block)
 
     begin
+      @constants = YARD::Registry.all(:constant)
+      
       # Look for all constants within the step definitions
       stepdef_instance._value_constants.each do |stepdef_constant| 
-        YARD::Registry.all(:constant).each do |constant|
+        @constants.each do |constant|
           if stepdef_constant.to_sym == constant.name
             #log.debug "Constant #{constant.name} was found in the step definition #{stepdef_instance.value}, attempting to replace that value"
             returned_constant = unpack_constants(constant.value)
@@ -39,17 +42,16 @@ class StepDefinitionHandler < YARD::Handlers::Ruby::Legacy::Base
     end
     
 
-    obj = register stepdef_instance 
-
-
+    obj = register stepdef_instance
     parse_block :owner => obj
+    
   rescue YARD::Handlers::NamespaceMissingError
   end
   
   
   def unpack_constants(constant_value)
     constant_value.scan(/\#\{([^\}]+)\}/).flatten.collect { |value| value.strip }.each do |inner_constant|
-      inner_constant_match = owner.constants.find {|constant| constant.name.to_s == inner_constant }
+      inner_constant_match = @constants.find {|constant| constant.name.to_s == inner_constant }
       if inner_constant_match
         constant_value.gsub!(/\#\{#{inner_constant}\}/,unpack_constants(inner_constant_match.value))
       end

data/lib/yard/handlers/step_transform_handler.rb

@@ -1,23 +1,58 @@
 
+
 class StepTransformHandler < YARD::Handlers::Ruby::Legacy::Base
-  MATCH = /^Transform\s*(\/.+\/)\s+do\s+\|.+\|\s*$/
-  handles MATCH
+  STEP_TRANSFORM_MATCH = /^(Transform\s*(\/.+\/)\s+do(?:\s*\|.+\|)?\s*)$/
+  handles STEP_TRANSFORM_MATCH
 
   @@unique_name = 0
   
   def process
-    transform = statement.tokens.to_s[MATCH,1]
-    
+    transform = statement.tokens.to_s[STEP_TRANSFORM_MATCH,2]
     @@unique_name = @@unique_name + 1
     
-    obj = register StepTransformObject.new(YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE, "transform_#{@@unique_name}") do |o| 
+    instance = StepTransformObject.new(YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE, "transform_#{@@unique_name}") do |o| 
       o.source = "Transform #{transform} do #{statement.block.to_s}\nend"
       o.value = transform
       o.keyword = "Transform"
     end
+    
+    log.debug "Step Tranform: #{instance}"
 
-    parse_block :owner => obj
+    begin
+      @constants = YARD::Registry.all(:constant)
+      
+      # Look for all constants within the step transforms
+      instance._value_constants.each do |instance_constants| 
+        @constants.each do |constant|
+          if instance_constants.to_sym == constant.name
+            returned_constant = unpack_constants(constant.value)
+            instance.constants[constant.name] = unpack_constants(constant.value)
+          end
+        end
+      end
 
+    rescue Exception => e
+      log.error "Failed to link step transform to constants. This will make step transform to step linking impossible if constants are present.  #{e}"
+    end
+
+    obj = register instance
+    parse_block :owner => obj
+    
   rescue YARD::Handlers::NamespaceMissingError
   end
-end
+  
+  
+  def unpack_constants(constant_value)
+    constant_value.scan(/\#\{([^\}]+)\}/).flatten.collect { |value| value.strip }.each do |inner_constant|
+      inner_constant_match = @constants.find {|constant| constant.name.to_s == inner_constant }
+      if inner_constant_match
+        constant_value.gsub!(/\#\{#{inner_constant}\}/,unpack_constants(inner_constant_match.value))
+      end
+    end
+
+    constant_value.gsub!(/^('|"|\/)|('|"|\/)$/,'')
+    constant_value
+  end
+  
+end
+