yard-cucumber 2.0.3 → 2.1.0

data/History.txt

@@ -1,3 +1,9 @@
+=== 2.1.0 / 2011-05-22
+
+* YARD 0.7.0 compatibility (removed some monkey-patching)
+* Add more menus (Steps and Step Definitions)
+* Define step definitions in your language Internalization (Ruby 1.9.2)
+
 === 2.0.3 / 2011-05-22
 
 * Updated Cucumber links to the new github organization

data/README.md

@@ -40,19 +40,23 @@ The implemented example has been deployed at [http://recursivegames.com/cukes/](
 
 **9. Feature directories with a README.md will be parsed into the description** [example](http://recursivegames.com/cukes/requirements/example/child_feature.html)
 
+**10. Configurable Menus - want a searchable steps menu and remove the tags menu**
+
+**11. Step definitions in your language (Ruby 1.9.2 - Internationalization)**
+
 Installation
 ------------
 
-Cucumber-In-The-Yard (CITY) requires the following gems installed:
+YARD-Cucumber requires the following gems installed:
 
-    Gherkin - http://cukes.info
-    Cucumber - http://cukes.info
-    YARD - http://yardoc.org
+Gherkin 2.3.5 - http://cukes.info
+Cucumber 0.7.5 - http://cukes.info
+YARD 0.7.0 - http://yardoc.org
 
-To install CITY use the following command:
+To install `yard-cucumber` use the following command:
+
+$ gem install yard-cucumber
 
-    $ gem install yard-cucumber
-    
 (Add `sudo` if you're installing under a POSIX system as root)
 
 Usage
@@ -61,25 +65,61 @@ Usage
 YARD supports for automatically including gems with the prefix `yard-` 
 as a plugin. To enable automatic loading yard-cucumber. 
 
-1. Edit `~/.yard/config` and insert the following line:
+$ yard config load_plugins true
+$ yardoc 'example/**/*.rb' 'example/**/*.feature'
 
-    load_plugins: true
+Now you can run YARD as you [normally](https://github.com/lsegal/yard) would and 
+have your features, step definitions and transforms captured.
 
-2. Run `yardoc`, use the rake task, or run `yard server`, as would [normally](https://github.com/lsegal/yard).
+An example with the rake task:
 
-Be sure to update any file patterns so that they do not exclude `feature` 
-files. yard-cucumber will even process your step definitions and transforms.
+require 'yard'
 
-    $ yardoc 'example/**/*.rb' 'example/**/*.feature'
+YARD::Rake::YardocTask.new do |t|
+t.files   = ['features/**/*.feature', 'features/**/*.rb']
+t.options = ['--any', '--extra', '--opts'] # optional
+end
 
-An example with the rake task:
 
-    require 'yard'
+Configuration
+-------------
+
+* Adding or Removing search fields (yardoc)
+
+Be default the yardoc output will generate a search field for features and tags.
+This can be configured through the yard configuration file `~./yard/config` to
+add or remove these search fields.
+  
+    --- !map:SymbolHash 
+    :load_plugins: true
+    :ignored_plugins: []
+
+    :autoload_plugins: []
+
+    :safe_mode: false
+    
+    :"yard-cucumber": 
+      menus: [ 'features', 'tags', 'steps', 'stepdefinitions' ]
+
+
+By default the configuration, yaml format, that is generate by the `yard config` 
+command will save a `SymbolHash`. You can still edit this file add the entry for 
+`:"yard-cucumber":` and the sub-entry `menus:` which can contain all of the above
+mentioned menus or simply an empty array `[]` if you want no additional menus.
+
+* Step definitions in your language (Ruby 1.9.2)
+
+Again the yard configuration file you can define additional step definitions that
+can be matched.
+
+    :"yard-cucumber": 
+      language: 
+        step_definitions: [ 'Given', 'When', 'Then', 'And', 'Soit', 'Etantdonné', 'Lorsque', 'Lorsqu', 'Alors', 'Et' ]
 
-    YARD::Rake::YardocTask.new do |t|
-      t.files   = ['features/**/*.feature', 'features/**/*.rb']
-      t.options = ['--any', '--extra', '--opts'] # optional
-    end
+In this example, I have included the French step definition words alongside the
+English step definitions. Even without specifying this feature files in other
+languages are found, this provides the ability for the step definitions to match
+correctly to step definitions.
 
 Details
 --------

data/city.gemspec

@@ -56,7 +56,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'gherkin', '>= 2.2.9'
   s.add_dependency 'cucumber', '>= 0.7.5'
-  s.add_dependency 'yard', '>= 0.6.3'
+  s.add_dependency 'yard', '>= 0.7.0'
   
   s.rubygems_version   = "1.3.7"
   s.files            = `git ls-files`.split("\n")

data/example/french.feature

@@ -0,0 +1,18 @@
+# language: fr
+Fonctionnalité: Addition
+  Afin de gagner du temps lors du calcul de la facture
+  En tant que commerçant
+  Je souhaite pouvoir faire une addition
+
+  Plan du Scénario: Addition de deux nombres
+    Soit une calculatrice
+    Et que j'entre <a> pour le premier nombre
+    Et que je tape sur la touche "+"
+    Et que j'entre <b> pour le second nombre
+    Lorsque je tape sur la touche "="
+    Alors le résultat affiché doit être <somme>
+
+    Exemples:
+      | a | b | somme |
+      | 2 | 2 | 4     |
+      | 2 | 3 | 5     |

data/example/step_definitions/french_steps.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+Soit /^une calculatrice$/ do
+  @calc = Calculatrice.new
+end
+
+Etantdonné /^qu'on tape (.*)$/ do |n|
+  @calc.push n.to_i
+end
+
+Etantdonné /^que j'entre (\d+) pour le (.*) nombre/ do |n, x|
+  @calc.push n.to_i
+end
+
+Lorsque /^je tape sur la touche "="$/ do
+  @expected_result = @calc.additionner
+end
+
+Lorsqu /on tape additionner/ do
+  @expected_result = @calc.additionner
+end
+
+Alors /le résultat affiché doit être (\d*)/ do |result|
+  result.to_i.should == @expected_result
+end
+
+Alors /le résultat doit être (\d*)/ do |result|
+  result.to_i.should == @expected_result
+end
+
+Soit /^que je tape sur la touche "\+"$/ do
+  # noop
+end

data/lib/cucumber/city_builder.rb

@@ -3,17 +3,48 @@ module Cucumber
   module Parser
     class CityBuilder
       include Gherkin::Rubify
-
+      
+      #
+      # The Gherkin Parser is going to call the various methods within this
+      # class as it finds items. This is similar to how Cucumber generates
+      # it's Abstract Syntax Tree (AST). Here instead this generates the
+      # various YARD::CodeObjects defined within this template.
+      # 
+      # A namespace is specified and that is the place in the YARD namespacing
+      # where all cucumber features generated will reside. The namespace specified
+      # is the root namespaces.
+      # 
+      # @param [String] file the name of the file which the content belongs
+      # 
       def initialize(file)
         @namespace = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE
         find_or_create_namespace(file)
         @file = file
       end
 
+      # Return the feature that has been defined. This method is the final
+      # method that is called when all the work is done. It is called by
+      # the feature parser to return the complete Feature object that was created
+      # 
+      # @return [YARD::CodeObject::Cucumber::Feature] the completed feature
+      # 
+      # @see YARD::Parser::Cucumber::FeatureParser
       def ast
-        @feature || @multiline_arg
+        @feature
       end
-
+      
+      #
+      # Feature that are found in sub-directories are considered, in the way
+      # that I chose to implement it, in another namespace. This is because
+      # when you execute a cucumber test run on a directory any sub-directories
+      # of features will be executed with that directory so the file is split
+      # and then namespaces are generated if they have not already have been.
+      # 
+      # The other duty that this does is look for a README.md file within the
+      # specified directory of the file and loads it as the description for the
+      # namespace. This is useful if you want to give a particular directory
+      # some flavor or text to describe what is going on.
+      # 
       def find_or_create_namespace(file)
         @namespace = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE
         
@@ -26,7 +57,20 @@ module Cucumber
           @namespace.description = File.read("#{File.dirname(file)}/README.md")
         end
       end
-
+      
+      #
+      # Find the tag if it exists within the YARD Registry, if it doesn' t then
+      # create it. 
+      # 
+      # We note that the tag was used in this file at the current line.
+      # 
+      # Then we add the tag to the current scenario or feature. We also add the
+      # feature or scenario to the tag.
+      # 
+      # @param [String] tag_name the name of the tag
+      # @param [parent] parent the scenario or feature that is going to adopt
+      #     this tag.
+      # 
       def find_or_create_tag(tag_name,parent)
         #log.debug "Processing tag #{tag_name}"
         tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.value == tag_name } ||
@@ -37,7 +81,12 @@ module Cucumber
         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
-
+      
+      #
+      # Each feature found will call this method, generating the feature object.
+      # This is once, as the gherking parser does not like multiple feature per
+      # file.
+      # 
       def feature(feature)
         #log.debug "FEATURE"
         
@@ -52,7 +101,11 @@ module Cucumber
           feature.tags.each {|feature_tag| find_or_create_tag(feature_tag.name,f) }
         end
       end
-
+      
+      #
+      # Called when a background has been found
+      # 
+      # @see #scenario
       def background(background)
         #log.debug "BACKGROUND"
         
@@ -68,7 +121,20 @@ module Cucumber
         @background.feature = @feature
         @step_container = @background
       end
-
+      
+      #
+      # Called when a scenario has been found
+      #   - create a scenario
+      #   - assign the scenario to the feature
+      #   - assign the feature to the scenario
+      #   - find or create tags associated with the scenario
+      # 
+      # The scenario is set as the @step_container, which means that any steps
+      # found before another scenario is defined belong to this scenario
+      # 
+      # @param [Scenario] statement is a scenario object returned from Gherkin
+      # @see #find_or_create_tag
+      # 
       def scenario(statement)
         #log.debug "SCENARIO"
 
@@ -86,7 +152,14 @@ module Cucumber
         @feature.scenarios << scenario
         @step_container = scenario
       end
-
+      
+      #
+      # Called when a scenario outline is found. Very similar to a scenario,
+      # the ScenarioOutline is still a distinct object as it can contain
+      # multiple different example groups that can contain different values.
+      # 
+      # @see #scenario
+      # 
       def scenario_outline(statement)
         #log.debug "SCENARIO OUTLINE"
         
@@ -105,6 +178,13 @@ module Cucumber
         @step_container = outline
       end
 
+      #
+      # Examples for a scenario outline are called here. This section differs
+      # from the Cucumber parser because here each of the examples are exploded
+      # out here as individual scenarios and step definitions. This is so that
+      # later we can ensure that we have all the variations of the scenario
+      # outline defined to be displayed. 
+      # 
       def examples(examples)
         #log.debug "EXAMPLES"
 
@@ -157,6 +237,14 @@ module Cucumber
         
       end
 
+      # 
+      # Called when a step is found. The step is refered to a table owner, though
+      # not all steps have a table or multliline arguments associated with them.
+      # 
+      # If a multiline string is present with the step it is included as the text
+      # of the step. If the step has a table it is added to the step using the
+      # same method used by the Cucumber Gherkin model.
+      # 
       def step(step)
         #log.debug "STEP"
 
@@ -182,9 +270,11 @@ module Cucumber
         @step_container.steps << @table_owner
       end
 
+      # Defined in the cucumber version so left here. No events for the end-of-file
       def eof
       end
 
+      # When a syntax error were to occurr. This parser is not interested in errors
       def syntax_error(state, event, legal_events, line)
         # raise "SYNTAX ERROR"
       end

data/lib/templates/default/fulldoc/html/js/cucumber.js

@@ -1,22 +1,30 @@
 function cucumberSearchFrameLinks() {
-    $('#features_list_link').click(function() {
+    $('#feature_list_link').click(function() {
         toggleSearchFrame(this, relpath + 'feature_list.html');
     });
-    $('#tags_list_link').click(function() {
+    $('#tag_list_link').click(function() {
         toggleSearchFrame(this, relpath + 'tag_list.html');
     });
+    $('#step_list_link').click(function() {
+        toggleSearchFrame(this, relpath + 'step_list.html');
+    });
+    $('#stepdefinition_list_link').click(function() {
+        toggleSearchFrame(this, relpath + 'stepdefinition_list.html');
+    });
 }
 
 function cucumberKeyboardShortcuts() {
   if (window.top.frames.main) return;
   $(document).keypress(function(evt) {
     if (evt.altKey || evt.ctrlKey || evt.metaKey || evt.shiftKey) return;
-    if (typeof evt.orignalTarget !== "undefined" &&  
-        (evt.originalTarget.nodeName == "INPUT" || 
-        evt.originalTarget.nodeName == "TEXTAREA")) return;
+    if (typeof evt.target !== "undefined" &&
+        (evt.target.nodeName == "INPUT" ||
+        evt.target.nodeName == "TEXTAREA")) return;
     switch (evt.charCode) {
-      case 82: case 114: $('#features_list_link').click(); break; // 'r'
-      case 84: case 116: $('#tags_list_link').click(); break;  // 't'
+      case 68: case 100: $('#stepdefinition_list_link').click(); break;  // 'd'
+      case 82: case 114: $('#feature_list_link').click(); break; // 'r'
+      case 83: case 115: $('#step_list_link').click(); break; // 's'
+      case 84: case 116: $('#tag_list_link').click(); break;  // 't'
     }
   });
 }

data/lib/templates/default/fulldoc/html/setup.rb

@@ -15,7 +15,7 @@ def init
 
   if @features
     @features.each {|feature| serialize(feature) } 
-    generate_full_list @features.sort {|x,y| x.value.to_s <=> y.value.to_s }, :feature
+    #generate_full_list @features.sort {|x,y| x.value.to_s <=> y.value.to_s }, :feature
   end
   
   #
@@ -28,7 +28,7 @@ def init
 
   if @tags
     @tags.each {|tag| serialize(tag) }
-    generate_full_list @tags.sort {|x,y| y.all_scenarios.size <=> x.all_scenarios.size }, :tag
+    #generate_full_list @tags.sort {|x,y| y.all_scenarios.size <=> x.all_scenarios.size }, :tag
   end
 
   # Generates the requirements splash page with the 'requirements' template
@@ -46,15 +46,43 @@ def init
 
 end
 
-#
-# Generate a full_list page of the specified objects with the specified type.
-#
+
+# Generate feature list
+# @note this method is called automically by YARD based on the menus defined in the layout
+def generate_feature_list
+  @features = Registry.all(:feature)
+  generate_full_list @features.sort {|x,y| x.value.to_s <=> y.value.to_s }, :feature
+end
+
+# Generate tag list
+# @note this method is called automically by YARD based on the menus defined in the layout
+def generate_tag_list
+  @tags = Registry.all(:tag)
+  generate_full_list @tags.sort {|x,y| y.all_scenarios.size <=> x.all_scenarios.size }, :tag
+end
+
+# Generate a step definition list
+# @note this menu is not automatically added until yard configuration has this menu added
+# See the layout template method that loads the menus
+def generate_stepdefinition_list
+  generate_full_list YARD::Registry.all(:stepdefinition), :stepdefinition
+end
+
+# Generate a step list
+# @note this menu is not automatically added until yard configuration has this menu added
+# See the layout template method that loads the menus
+def generate_step_list
+  generate_full_list YARD::Registry.all(:step), :step
+end
+
+# Helpler method to generate a full_list page of the specified objects with the 
+# specified type.
 def generate_full_list(objects,list_type,friendly_name=nil)
-    @items = objects
-    @list_type = "#{list_type}s"
-    @list_title = "#{friendly_name || list_type.to_s.capitalize} List"
-    @list_class = "class"
-    asset("#{list_type}_list.html",erb(:full_list))
+  @items = objects
+  @list_type = "#{list_type}s"
+  @list_title = "#{friendly_name || list_type.to_s.capitalize} List"
+  @list_class = "class"
+  asset("#{list_type}_list.html",erb(:full_list))
 end
 
 #

data/lib/templates/default/layout/html/setup.rb

@@ -2,12 +2,54 @@ def init
   super
 end
 
-def javascript_files
-  existing_js = super rescue [ 'js/jquery.js','js/app.js' ]
-  existing_js + [ 'js/cucumber.js' ]
+#
+# Append yard-cucumber stylesheet to yard core stylesheets
+# 
+def stylesheets
+  super + %w(css/cucumber.css)
 end
 
-def search_fields
-  existing_fields = super rescue [ [ 'class_list_link', 'Class List' ],[ 'method_list_link', 'Method List' ],[ 'file_list_link', 'File List' ] ] 
-  existing_fields + [ [ 'features_list_link', 'Features' ],[ 'tags_list_link', 'Tags' ] ]
-end
+#
+# Append yard-cucumber javascript to yard core javascripts
+# 
+def javascripts
+  super + %w(js/cucumber.js)
+end
+
+#
+# Append yard-cucumber specific menus 'features' and 'tags'
+# 
+# 'features' and 'tags' are enabled by default.
+# 
+# 'step definitions' and 'steps' may be enabled by setting up a value in
+# yard configuration file '~/.yard/config'
+# 
+# @example `~/.yard.config`
+# 
+#     yard-cucumber:
+#       menus: [ 'features', 'tags', 'step definitions', 'steps' ]
+# 
+def menu_lists
+  
+  menus = [ "features", "tags" ]
+
+  # load the yard-cucumber menus defined in the configuration file
+  if YARD::Config.options["yard-cucumber"] and YARD::Config.options["yard-cucumber"]["menus"]
+    menus = YARD::Config.options["yard-cucumber"]["menus"]
+  end
+
+  menus.map {|menu_name| yard_cucumber_menus[menu_name] }.compact + super
+end
+
+#
+# When a menu is specified in the yard configuration file, this hash contains
+# the details about the menu necessary for it to be displayed.
+# 
+# @see #menu_lists
+# 
+def yard_cucumber_menus
+  { "features" => { :type => 'feature', :title => 'Features', :search_title => 'Features' },
+    "tags" => { :type => 'tag', :title => 'Tags', :search_title => 'Tags' },
+    "step definitions" => { :type => 'stepdefinition', :title => 'Step Definitions', :search_title => 'Step Defs' },
+    "steps" => { :type => 'step', :title => 'Steps', :search_title => 'Steps' } }
+end

data/lib/yard-cucumber.rb

@@ -4,7 +4,7 @@ require 'gherkin/formatter/tag_count_formatter'
 
 
 module CucumberInTheYARD
-  VERSION = '2.0.3'
+  VERSION = '2.1.0'
 end
 
 require File.dirname(__FILE__) + "/yard/code_objects/cucumber/base.rb"
@@ -34,7 +34,7 @@ end
 require File.dirname(__FILE__) + "/yard/handlers/legacy/step_definition_handler.rb"
 require File.dirname(__FILE__) + "/yard/handlers/legacy/step_transform_handler.rb"
 
-require File.dirname(__FILE__) + "/yard/parser/source_parser.rb"
+#require File.dirname(__FILE__) + "/yard/parser/source_parser.rb"
 require File.dirname(__FILE__) + "/yard/templates/helpers/base_helper.rb"
 
 require File.dirname(__FILE__) + "/yard/server/adapter.rb"

data/lib/yard/code_objects/step_transformer.rb

@@ -7,45 +7,89 @@ module YARD::CodeObjects
 
     attr_reader :constants, :keyword, :source, :value, :literal_value
     attr_accessor :steps
-
+    
+    # This defines an escape pattern within a string or regex:
+    #     /^the first #{CONSTANT} step$/
+    # 
+    # This is used below in the value to process it if there happen to be
+    # constants defined here.
+    # 
+    # @note this does not handle the result of method calls
+    # @note this does not handle multiple constants within the same escaped area
+    # 
     ESCAPE_PATTERN = /#\{\s*(\w+)\s*\}/ unless defined?(ESCAPE_PATTERN)
 
+    #
+    # When requesting a step tranformer object value, process it, it it hasn't
+    # alredy been processed, replacing any constants that may be lurking within
+    # the value.
+    # 
+    # Processing it means looking for any escaped characters that happen to be
+    # CONSTANTS that could be matched and then replaced. This is done recursively
+    # as CONSTANTS can be defined with more CONSTANTS.
+    # 
+    def value
+      unless @processed
+        @processed = true
+        until (nested = constants_from_value).empty?
+          nested.each {|n| @value.gsub!(value_regex(n),find_value_for_constant(n)) }
+        end
+      end
+      
+      @value
+    end
+
+    #
+    # Set the literal value and the value of the step definition.
+    # 
+    # The literal value is as it appears in the step definition file with any
+    # constants. The value, when retrieved will attempt to replace those 
+    # constants with their regex or string equivalents to hopefully match more
+    # steps and step definitions.
+    # 
+    # 
     def value=(value)
       @literal_value = format_source(value)
       @value = format_source(value)
       
-      until (nested = constants_from_value).empty?
-        nested.each {|n| @value.gsub!(value_regex(n),find_value_for_constant(n)) }
-      end
-      
       @steps = []
+      value
     end
 
+    # Generate a regex with the step transformers value
     def regex
-      @regex ||= /#{strip_regex_from(@value)}/
+      @regex ||= /#{strip_regex_from(value)}/
     end
-
+    
+    # Look through the specified data for the escape pattern and return an array
+    # of those constants found. This defaults to the @value within step transformer
+    # as it is used internally, however, it can be called externally if it's
+    # needed somewhere.
     def constants_from_value(data=@value)
       data.scan(ESCAPE_PATTERN).flatten.collect { |value| value.strip }
     end
 
     protected
 
+    #
+    # Looking through all the constants in the registry and returning the value
+    # with the regex items replaced from the constnat if present
+    # 
     def find_value_for_constant(name)
       constant = YARD::Registry.all(:constant).find{|c| c.name == name.to_sym }
       log.warn "StepTransformer#find_value_for_constant : Could not find the CONSTANT [#{name}] using the string value." unless constant
       constant ? strip_regex_from(constant.value) : name
     end
   
+    # Return a regex of the value
     def value_regex(value)
       /#\{\s*#{value}\s*\}/
     end
 
+    # Step the regex starting / and ending / from the value
     def strip_regex_from(value)
       value.gsub(/^\/|\/$/,'')
     end
-
-
   end
 
 end

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

@@ -13,9 +13,8 @@ module YARD
           end
           include Parser::Cucumber
         end
-
       end
-
+      
       Processor.register_handler_namespace :feature, Cucumber
     end 
   end

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

@@ -5,87 +5,125 @@ module YARD
 
         handles CodeObjects::Cucumber::Feature
 
-        @@step_definitions = nil
-        @@step_transforms = nil
-        
         def process
+          #
+          # Features have already been created when they were parsed. So there
+          # is no need to process the feature furhter. Previously this is where
+          # feature steps were matched to step definitions and step definitions
+          # were matched to step transforms. This only worked if the feature
+          # files were were assured to be processed last which was accomplished
+          # by overriding YARD::SourceParser to make it load file in a similar
+          # order as Cucumber.
+          # 
+          # As of YARD 0.7.0 this is no longer necessary as there are callbacks
+          # that can be registered after all the files have been loaded. That
+          # callback _after_parse_list_ is defined below and performs the
+          # functionality described above.
+          # 
+        end
+        
+        #
+        # Register, once, when that when all files are finished to perform
+        # the final matching of feature steps to step definitions and step
+        # definitions to step transforms.
+        # 
+        YARD::Parser::SourceParser.after_parse_list do |files,globals|
+          # For every feature found in the Registry, find their steps and step
+          # definitions...
+          YARD::Registry.all(:feature).each do |feature|
+            log.debug "Finding #{feature.file} - steps, step definitions, and step transforms"
+            FeatureHandler.match_steps_to_step_definitions(feature)
+          end
+          
+        end
+
+        class << self
 
-          # 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
+          @@step_definitions = nil
+          @@step_transforms = nil
 
-          if statement
-            # For the background and the scenario, find the steps that have definitions
-            process_scenario(statement.background) if statement.background
+          def match_steps_to_step_definitions(statement)
+            # 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
 
-            statement.scenarios.each do |scenario|
-              if scenario.outline?
-                #log.info "Scenario Outline: #{scenario.value}"
-                scenario.scenarios.each_with_index do |example,index|
-                  #log.info " * Processing Example #{index + 1}"
-                  process_scenario(example)
+            if statement
+              # 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}"
+                  scenario.scenarios.each_with_index do |example,index|
+                    #log.info " * Processing Example #{index + 1}"
+                    process_scenario(example)
+                  end
+                else
+                  process_scenario(scenario)
                 end
-              else
-                process_scenario(scenario)
               end
-            end
 
 
-          else
-            log.warn "Empty feature file.  A feature failed to process correctly or contains no feature"
-          end
-
-        rescue YARD::Handlers::NamespaceMissingError
-        rescue Exception => exception
-          log.error "Skipping feature because an error has occurred."
-          log.debug "\n#{exception}\n#{exception.backtrace.join("\n")}\n"
-        end
+            else
+              log.warn "Empty feature file.  A feature failed to process correctly or contains no feature"
+            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[item.regex] = item if item.regex
-            hash
+          rescue YARD::Handlers::NamespaceMissingError
+          rescue Exception => exception
+            log.error "Skipping feature because an error has occurred."
+            log.debug "\n#{exception}\n#{exception.backtrace.join("\n")}\n"
           end
-        end
-
 
-        def process_scenario(scenario)
-          scenario.steps.each {|step| process_step(step) }
-        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[item.regex] = item if item.regex
+              hash
+            end
+          end
 
-        def process_step(step)
-          match_step_to_step_definition_and_transforms(step)
+          # process a scenario
+          def process_scenario(scenario)
+            scenario.steps.each {|step| process_step(step) }
+          end
 
-        end
+          # process a step
+          def process_step(step)
+            match_step_to_step_definition_and_transforms(step)
+          end
 
-        def match_step_to_step_definition_and_transforms(step)
-          @@step_definitions.each_pair do |stepdef,stepdef_object|
-            stepdef_matches = step.value.match(stepdef)
-
-            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
+          #
+          # Given a step object, attempt to match that step to a step 
+          # transformation
+          # 
+          def match_step_to_step_definition_and_transforms(step)
+            @@step_definitions.each_pair do |stepdef,stepdef_object|
+              stepdef_matches = step.value.match(stepdef)
+
+              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
+                # TODO: If the step were to match again then we would be able to display ambigous step definitions
+                break
+
               end
-              
-              # Step has been matched to step definition and step transforms
-              # TODO: If the step were to match again then we would be able to display ambigous step definitions
-              break
-              
+
             end
 
           end
 
-
         end
       end
     end

data/lib/yard/handlers/legacy/step_definition_handler.rb

@@ -1,5 +1,4 @@
 class YARD::Handlers::Ruby::Legacy::StepDefinitionHandler < YARD::Handlers::Ruby::Legacy::Base
-  #TODO: This needs to become language independent.
   STEP_DEFINITION_MATCH = /^((When|Given|And|Then)\s*(\/.+\/)\s+do(?:\s*\|.+\|)?\s*)$/ unless defined?(STEP_DEFINITION_MATCH)
   handles STEP_DEFINITION_MATCH
 

data/lib/yard/handlers/step_definition_handler.rb

@@ -1,6 +1,42 @@
-
+#
+# Finds and processes all the step definitions defined in the ruby source
+# code. By default the english gherkin language will be parsed.
+# 
+# To override the language you can define the step definitions in the YARD 
+# configuration file `~./yard/config`:
+# 
+# @example `~/.yard/config` with LOLCatz step definitions
+# 
+#     :"yard-cucumber": 
+#       language: 
+#         step_definitions: [ 'WEN', 'I CAN HAZ', 'AN', 'DEN' ]
+# 
+# @example `~/.yard/config` with French step definitions
+# 
+#     :"yard-cucumber": 
+#       language: 
+#         step_definitions: [ 'Soit', 'Etantdonné', 'Lorsque', 'Lorsqu', 'Alors', 'Et' ]
+# 
 class YARD::Handlers::Ruby::StepDefinitionHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:When),method_call(:Given),method_call(:And),method_call(:Then)
+  
+  #
+  # By default the english gherkin language will be parsed, however, if the
+  # YARD configuration file `~./yard/config` defines different step definition
+  # handlers those are used.
+  # 
+  # 
+  if YARD::Config.options["yard-cucumber"] and 
+    YARD::Config.options["yard-cucumber"]["language"] and
+    YARD::Config.options["yard-cucumber"]["language"]["step_definitions"]
+    
+    YARD::Config.options["yard-cucumber"]["language"]["step_definitions"].each do |step_word|
+      handles method_call(step_word.to_sym)
+    end
+    
+  else
+    handles method_call(:When),method_call(:Given),method_call(:And),method_call(:Then)
+  end
+  
   
   @@unique_name = 0
   

data/lib/yard/parser/cucumber/feature.rb

@@ -1,7 +1,18 @@
 module YARD::Parser::Cucumber
 
   class FeatureParser < YARD::Parser::Base
-
+    
+    #
+    # Each found feature found is creates a new FeatureParser
+    # 
+    # This logic was copied from the logic found in Cucumber to create the builder
+    # and then set up the formatter and parser. The difference is really the
+    # custom Cucumber::Parser::CityBuilder that is being used to parse the elements
+    # of the feature into YARD::CodeObjects.
+    # 
+    # @param [<String>] source containing the string conents of the feauture file
+    # @param [<String>] file the filename that contains the source
+    # 
     def initialize(source, file = '(stdin)')
 
       @builder = Cucumber::Parser::CityBuilder.new(file)
@@ -15,6 +26,13 @@ module YARD::Parser::Cucumber
       @feature = nil
     end
 
+    #
+    # When parse is called, the gherkin parser is executed and all the feature
+    # elements that are found are sent to the various methods in the 
+    # Cucumber::Parser::CityBuilder. The result of which is the feature element
+    # that contains all the scenarios, steps, etc. associated with that feature.
+    # 
+    # @see Cucumber::Parser::CityBuilder
     def parse
       begin
         @parser.parse(@source, @file, 0)
@@ -29,18 +47,24 @@ module YARD::Parser::Cucumber
       self
     end
 
+    #
+    # This is not used as all the work is done in the parse method
+    # 
     def tokenize
       
     end
 
-
+    # 
+    # The only enumeration that can be done here is returning the feature itself
+    # 
     def enumerator
       [@feature]
     end
 
   end
 
-
+  # 
+  # Register all feature files (.feature) to be processed with the above FeatureParser
   YARD::Parser::SourceParser.register_parser_type :feature, FeatureParser, 'feature'
 
 end

metadata

@@ -2,7 +2,7 @@
 name: yard-cucumber
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.0.3
+  version: 2.1.0
 platform: ruby
 authors: 
 - Franklin Webber
@@ -43,7 +43,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.6.3
+        version: 0.7.0
   type: :runtime
   version_requirements: *id003
 description: " \n    YARD-Cucumber is a YARD extension that processes Cucumber Features, Scenarios, Steps,\n    Step Definitions, Transforms, and Tags and provides a documentation interface that allows you\n    easily view and investigate the test suite.  This tools hopes to bridge the gap of being able\n    to provide your feature descriptions to your Product Owners and Stakeholders.  "
@@ -66,10 +66,12 @@ files:
 - example/child_feature/child.feature
 - example/child_feature/grandchild_feature/grandchild.feature
 - example/empty.feature
+- example/french.feature
 - example/scenario.feature
 - example/scenario_outline.feature
 - example/step_definitions/example.step.rb
 - example/step_definitions/first.step.rb
+- example/step_definitions/french_steps.rb
 - example/step_definitions/support/env.rb
 - example/step_definitions/support/env_support.rb
 - example/step_definitions/support/support.rb
@@ -93,17 +95,13 @@ files:
 - lib/templates/default/featuredirectory/html/setup.rb
 - lib/templates/default/featuretags/html/namespace.erb
 - lib/templates/default/featuretags/html/setup.rb
-- lib/templates/default/fulldoc/html/css/common.css
-- lib/templates/default/fulldoc/html/full_list.erb
+- lib/templates/default/fulldoc/html/css/cucumber.css
 - lib/templates/default/fulldoc/html/full_list_features.erb
 - lib/templates/default/fulldoc/html/full_list_stepdefinitions.erb
 - lib/templates/default/fulldoc/html/full_list_steps.erb
 - lib/templates/default/fulldoc/html/full_list_tags.erb
-- lib/templates/default/fulldoc/html/index.erb
 - lib/templates/default/fulldoc/html/js/cucumber.js
 - lib/templates/default/fulldoc/html/setup.rb
-- lib/templates/default/layout/html/headers.erb
-- lib/templates/default/layout/html/search.erb
 - lib/templates/default/layout/html/setup.rb
 - lib/templates/default/requirements/html/alpha_table.erb
 - lib/templates/default/requirements/html/requirements.erb
@@ -134,7 +132,6 @@ files:
 - lib/yard/handlers/step_definition_handler.rb
 - lib/yard/handlers/step_transform_handler.rb
 - lib/yard/parser/cucumber/feature.rb
-- lib/yard/parser/source_parser.rb
 - lib/yard/server/adapter.rb
 - lib/yard/server/commands/list_command.rb
 - lib/yard/server/router.rb
@@ -144,7 +141,7 @@ homepage: http://github.com/burtlo/yard-cucumber
 licenses: []
 
 post_install_message: "\n\
-  (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)\n\n  Thank you for installing yard-cucumber 2.0.3 / 2011-05-22.\n  \n  Changes:\n    \n  * Updated Cucumber links to the new github organization\n  \n\n\
+  (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)\n\n  Thank you for installing yard-cucumber 2.1.0 / 2011-05-22.\n  \n  Changes:\n    \n  * YARD 0.7.0 compatibility (removed some monkey-patching)\n  * Add more menus (Steps and Step Definitions)\n  * Define step definitions in your language Internalization (Ruby 1.9.2)\n  \n\n\
   (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)\n\n"
 rdoc_options: 
 - --charset=UTF-8

data/lib/templates/default/fulldoc/html/full_list.erb

@@ -1,36 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-  <head>
-    <meta name="Content-Type" content="text/html; charset=<%= charset %>" />
-    <link rel="stylesheet" href="css/full_list.css" type="text/css" media="screen" charset="utf-8" />
-    <link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
-    <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
-    <script type="text/javascript" charset="utf-8" src="js/full_list.js"></script>
-    <base id="base_target" target="_parent" />
-  </head>
-  <body>
-    <script type="text/javascript" charset="utf-8">
-      if (window.top.frames.main) {
-        document.getElementById('base_target').target = 'main';
-        document.body.className = 'frames';
-      }
-    </script>
-    <div id="content">
-      <h1 id="full_list_header"><%= @list_title %></h1>
-      <div id="nav">
-        <a target="_self" href="feature_list.html">Features</a> | 
-        <a target="_self" href="tag_list.html">Tags</a> | 
-        <a target="_self" href="class_list.html">Classes</a> | 
-        <a target="_self" href="method_list.html">Methods</a> |
-        <a target="_self" href="file_list.html">Files</a>
-      </div>
-      <div id="search">Search: <input type="text" /></div>
-
-      <ul id="full_list" class="<%= @list_class || @list_type %>">
-        <%= erb "full_list_#{@list_type}" %>
-      </ul>
-    </div>
-  </body>
-</html>
-

data/lib/templates/default/fulldoc/html/index.erb

@@ -1,24 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <%= T('layout/headers') %>
-  </head>
-  <body>
-    <script type="text/javascript" charset="utf-8">
-      if (window.top.frames.main) document.body.className = 'frames';
-    </script>
-    
-    <div id="header">
-      <%= T('layout/breadcrumb') %>
-      <%= T('layout/search') %>
-      <div class="clear"></div>
-    </div>
-    
-    <iframe id="search_frame"></iframe>
-    
-    <div id="content"><%= yieldall %></div>
-    
-    <%= T('layout/footer') %>
-  </body>
-</html>

data/lib/templates/default/layout/html/headers.erb

@@ -1,14 +0,0 @@
-<meta http-equiv="Content-Type" content="text/html; charset=<%= charset %>" />
-<title><%= @page_title %></title>
-<link rel="stylesheet" href="<%= url_for("css/style.css") %>" type="text/css" media="screen" charset="utf-8" />
-<link rel="stylesheet" href="<%= url_for("css/common.css") %>" type="text/css" media="screen" charset="utf-8" />
-<% if @extra_css %>
-  <link rel="stylesheet" href="<%= url_for @extra_css %>" type="text/css" media="screen" charset="utf-8" />
-<% end %>
-<script type="text/javascript" charset="utf-8">
-  relpath = '<%= url_for('') %>';
-  if (relpath != '') relpath += '/';
-</script>
-<% javascript_files.each do |js_file| %>
-  <script type="text/javascript" charset="utf-8" src="<%= url_for(js_file) %>"></script>
-<% end %>

data/lib/templates/default/layout/html/search.erb

@@ -1,5 +0,0 @@
-<div id="search">
-  <% search_fields.each do |id,name| %>
-  <a id="<%= id %>" href="#"><%= name %></a>
-  <% end %>
-</div>

data/lib/yard/parser/source_parser.rb

@@ -1,58 +0,0 @@
-module YARD::Parser
-
-  class SourceParser
-    class << self
-
-      #
-      # Following the conventions of ordering as Cucumber performs it
-      #  
-      #  environment files - 'directory/support/env.rb,env_*.rb'
-      #  support files     - 'directory/support/*.rb' (but not env prefixed)
-      #  directory files   - 'directory/*.rb'
-      #  
-      #  feature files     - 'directory/*.feature'
-      #
-      def order_by_cucumber_standards(*files)
-        
-        non_feature_files = files.reject {|x| x =~ /^.+\.feature$/}
-        feature_files = files.find_all {|x| x =~ /^.+\.feature$/ }
-        
-        support_files = non_feature_files.find_all {|file| file =~ /support\/.+\.rb$/ }
-        other_files = non_feature_files - support_files
-        
-        environment_files = support_files.find_all {|file| file =~ /support\/env.*\.rb$/ }
-        environment_files.sort_by {|x| x.length if x }
-        
-        support_files = support_files - environment_files
-        
-        environment_files + support_files + other_files + feature_files
-      end
-
-      #
-      # Overriding the parse_in_order method was necessary so that step definitions
-      # match to steps utilizing the load ordering that is used by Cucumber.
-      #
-      def parse_in_order(*files)
-        
-        files = order_by_cucumber_standards(*files)
-        
-        while file = files.shift
-          begin
-            if file.is_a?(Array) && file.last.is_a?(Continuation)
-              log.debug("Re-processing #{file.first}")
-              file.last.call
-            elsif file.is_a?(String)
-              log.debug("Processing #{file}...")
-              new(parser_type, true).parse(file)
-            end
-          rescue LoadOrderError => e
-            # Out of order file. Push the context to the end and we'll call it
-            files.push([file, e.message])
-          end
-        end
-      end
-      
-    end
-  end
-  
-end