yard-cucumber2 2.3.3

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

@@ -0,0 +1,21 @@
+module YARD
+  module Handlers
+    module Cucumber
+
+      class Base < Handlers::Base
+        class << self
+          include Parser::Cucumber
+          def handles?(node)
+            handlers.any? do |a_handler|
+              #log.debug "YARD::Handlers::Cucumber::Base#handles?(#{node.class})"
+              node.class == a_handler
+            end
+          end
+          include Parser::Cucumber
+        end
+      end
+
+      Processor.register_handler_namespace :feature, Cucumber
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+module YARD
+  module Handlers
+    module Cucumber
+      class FeatureHandler < Base
+
+        handles CodeObjects::Cucumber::Feature
+
+        def process
+          #
+          # Features have already been created when they were parsed. So there
+          # is no need to process the feature further. 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
+
+          @@step_definitions = nil
+          @@step_transforms = nil
+
+          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
+
+            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
+              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
+
+          #
+          # 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
+
+          # process a scenario
+          def process_scenario(scenario)
+            scenario.steps.each {|step| process_step(step) }
+          end
+
+          # process a step
+          def process_step(step)
+            match_step_to_step_definition_and_transforms(step)
+          end
+
+          #
+          # 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
+
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+class YARD::Handlers::Ruby::Legacy::StepDefinitionHandler < YARD::Handlers::Ruby::Legacy::Base
+  STEP_DEFINITION_MATCH = /^((When|Given|And|Then)\s*(\/.+\/)\s+do(?:\s*\|.+\|)?\s*)$/ unless defined?(STEP_DEFINITION_MATCH)
+  handles STEP_DEFINITION_MATCH
+
+  @@unique_name = 0
+
+  def process
+    keyword = statement.tokens.to_s[STEP_DEFINITION_MATCH,2]
+    step_definition = statement.tokens.to_s[STEP_DEFINITION_MATCH,3]
+
+    @@unique_name = @@unique_name + 1
+
+    stepdef_instance = StepDefinitionObject.new(YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE, "definition_#{@@unique_name}") do |o|
+      o.source = "#{keyword} #{step_definition} do #{statement.block.to_s =~ /^\s*\|.+/ ? '' : "\n  "}#{statement.block.to_s}\nend"
+      o.value = step_definition
+      o.keyword = keyword
+    end
+
+    obj = register stepdef_instance
+    parse_block :owner => obj
+
+  rescue YARD::Handlers::NamespaceMissingError
+  end
+
+  #
+  # Step Definitions can contain defined steps within them.  While it is likely that they could not
+  # very easily be parsed because of variables that are only calculated at runtime, it would be nice
+  # to at least list those in use within a step definition and if you can find a match, go ahead and
+  # make it
+  #
+  def find_steps_defined_in_block(block)
+    #log.debug "#{block} #{block.class}"
+    block.each_with_index do |token,index|
+      #log.debug "Token #{token.class} #{token.text}"
+        if token.is_a?(YARD::Parser::Ruby::Legacy::RubyToken::TkCONSTANT)  &&
+          token.text =~ /^(given|when|then|and)$/i &&
+          block[index + 2].is_a?(YARD::Parser::Ruby::Legacy::RubyToken::TkSTRING)
+          log.debug "Step found in Step Definition: #{block[index + 2].text} "
+        end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+class YARD::Handlers::Ruby::Legacy::StepTransformHandler < YARD::Handlers::Ruby::Legacy::Base
+  STEP_TRANSFORM_MATCH = /^(Transform\s*(\/.+\/)\s+do(?:\s*\|.+\|)?\s*)$/ unless defined?(STEP_TRANSFORM_MATCH)
+  handles STEP_TRANSFORM_MATCH
+
+  @@unique_name = 0
+
+  def process
+    transform = statement.tokens.to_s[STEP_TRANSFORM_MATCH,2]
+    @@unique_name = @@unique_name + 1
+
+    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
+
+    obj = register instance
+    parse_block :owner => obj
+
+  rescue YARD::Handlers::NamespaceMissingError
+  end
+
+end
+

data/lib/yard/handlers/step_definition_handler.rb

@@ -0,0 +1,86 @@
+#
+# 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
+
+  def self.default_step_definitions
+    [ "When", "Given", "And", "Then" ]
+  end
+
+  def self.custom_step_definitions
+    YARD::Config.options["yard-cucumber"]["language"]["step_definitions"]
+  end
+
+  def self.custom_step_definitions_defined?
+    YARD::Config.options["yard-cucumber"] and
+    YARD::Config.options["yard-cucumber"]["language"] and
+    YARD::Config.options["yard-cucumber"]["language"]["step_definitions"]
+  end
+
+  def self.step_definitions
+    if custom_step_definitions_defined?
+      custom_step_definitions
+    else
+      default_step_definitions
+    end
+  end
+
+  step_definitions.each { |step_def| handles method_call(step_def) }
+
+  process do
+
+    instance = YARD::CodeObjects::StepDefinitionObject.new(step_transform_namespace,step_definition_name) do |o|
+      o.source = statement.source
+      o.comments = statement.comments
+      o.keyword = statement.method_name.source
+      o.value = statement.parameters.source
+      o.pending = pending_keyword_used?(statement.block)
+    end
+
+    obj = register instance
+    parse_block(statement[2],:owner => obj)
+
+  end
+
+  def pending_keyword
+    "pending"
+  end
+
+  def pending_command_statement?(line)
+    (line.type == :command || line.type == :vcall) && line.first.source == pending_keyword
+  end
+
+  def pending_keyword_used?(block)
+    code_in_block = block.last
+    code_in_block.find { |line| pending_command_statement?(line) }
+  end
+
+  def step_transform_namespace
+    YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE
+  end
+
+  def step_definition_name
+    "step_definition#{self.class.generate_unique_id}"
+  end
+
+  def self.generate_unique_id
+    @step_definition_count = @step_definition_count.to_i + 1
+  end
+
+end

data/lib/yard/handlers/step_transform_handler.rb

@@ -0,0 +1,31 @@
+
+class YARD::Handlers::Ruby::StepTransformHandler < YARD::Handlers::Ruby::Base
+  handles method_call(:Transform)
+
+  process do
+
+    instance = YARD::CodeObjects::StepTransformObject.new(step_transform_namespace,step_transformer_name) do |o|
+      o.source = statement.source
+      o.comments = statement.comments
+      o.keyword = statement[0].source
+      o.value = statement[1].source
+    end
+
+    obj = register instance
+    parse_block(statement[2],:owner => obj)
+
+  end
+
+  def step_transform_namespace
+    YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE
+  end
+
+  def step_transformer_name
+    "step_transform#{self.class.generate_unique_id}"
+  end
+
+  def self.generate_unique_id
+    @step_transformer_count = @step_transformer_count.to_i + 1
+  end
+
+end

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

@@ -0,0 +1,73 @@
+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)
+      @tag_counts = {}
+      @tag_formatter = Gherkin::Formatter::TagCountFormatter.new(@builder, @tag_counts)
+      @parser = Gherkin::Parser::Parser.new(@tag_formatter, true, "root", false)
+
+      @source = source
+      @file = file
+
+      @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)
+        @feature = @builder.ast
+        return nil if @feature.nil? # Nothing matched
+        
+        # The parser used the following keywords when parsing the feature
+        # @feature.language = @parser.i18n_language.get_code_keywords.map {|word| word }
+        
+      rescue Gherkin::Lexer::LexingError, Gherkin::Parser::ParseError => e
+        e.message.insert(0, "#{@file}: ")
+        raise e
+      end
+      
+      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

data/lib/yard/server/adapter.rb

@@ -0,0 +1,43 @@
+module YARD
+  module Server
+    
+    class Adapter
+      
+      class << self
+      
+        alias_method :yard_setup, :setup
+      
+        #
+        # To provide the templates necessary for `yard-cucumber` to integrate
+        # with YARD the adapter has to around-alias the setup method to place
+        # the `yard-cucumber` server templates as the last template in the list.
+        #
+        # When they are normally loaded with the plugin they cause an error with 
+        # the `yardoc` command. They are also not used because the YARD server
+        # templates are placed after all plugin templates. 
+        #
+        def setup
+          yard_setup
+          YARD::Templates::Engine.template_paths += 
+          [File.dirname(__FILE__) + '/../../templates',File.dirname(__FILE__) + '/../../docserver']
+        end
+        
+        alias_method :yard_shutdown, :shutdown
+
+        #
+        # Similar to the addition, it is good business to tear down the templates
+        # that were added by again around-aliasing the shutdown method.
+        #
+        def shutdown
+          yard_shutdown
+          YARD::Templates::Engine.template_paths -= 
+          [File.dirname(__FILE__) + '/../../templates',File.dirname(__FILE__) + '/../../docserver']
+        end  
+        
+      end
+      
+
+    end
+    
+  end
+end