yard-gherkin-turnip 1.0.0

data/lib/yard-gherkin-turnip/version.rb

@@ -0,0 +1,3 @@
+module YardTurnip
+  VERSION = '1.0.0'
+end

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

@@ -0,0 +1,24 @@
+module YARD::CodeObjects::Cucumber
+  module LocationHelper
+
+    def line_number
+      files.first.last
+    end
+
+    def file
+      files.first.first if files && !files.empty?
+    end
+
+    def location
+      "#{file}:#{line_number}"
+    end
+  end
+
+  class Base < YARD::CodeObjects::Base
+    include LocationHelper
+
+    def path
+      @value || super
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module YARD::CodeObjects::Cucumber
+  class Feature < NamespaceObject
+    attr_accessor :background, :comments, :description, :keyword, :scenarios, :tags, :value
+
+    def total_scenarios
+      scenarios.count
+    end
+
+    def initialize(namespace, name)
+      @comments = ""
+      @scenarios = []
+      @tags = []
+      super(namespace, name.to_s.strip)
+    end
+  end
+end

data/lib/yard/code_objects/cucumber/namespace_object.rb

@@ -0,0 +1,55 @@
+module YARD::CodeObjects::Cucumber
+  class NamespaceObject < YARD::CodeObjects::NamespaceObject
+    include LocationHelper
+
+    def value;
+      nil;
+    end
+  end
+
+  class Requirements < NamespaceObject;
+  end
+  class FeatureTags < NamespaceObject;
+  end
+  class StepTransformers < NamespaceObject;
+  end
+
+  class FeatureDirectory < YARD::CodeObjects::NamespaceObject
+
+    attr_accessor :description
+
+    def initialize(namespace, name)
+      super(namespace, name)
+      @description = ""
+    end
+
+    def location
+      files.first.first if files && !files.empty?
+    end
+
+    def expanded_path
+      to_s.split('::')[1..-1].join('/')
+    end
+
+    def value;
+      name;
+    end
+
+    def features
+      children.find_all { |d| d.is_a?(Feature) }
+    end
+
+    def subdirectories
+      subdirectories = children.find_all { |d| d.is_a?(FeatureDirectory) }
+      subdirectories + subdirectories.collect { |s| s.subdirectories }.flatten
+    end
+
+  end
+
+  CUCUMBER_NAMESPACE = Requirements.new(:root, "requirements") unless defined?(CUCUMBER_NAMESPACE)
+
+  CUCUMBER_TAG_NAMESPACE = FeatureTags.new(CUCUMBER_NAMESPACE, "tags") unless defined?(CUCUMBER_TAG_NAMESPACE)
+
+  CUCUMBER_STEPTRANSFORM_NAMESPACE = StepTransformers.new(CUCUMBER_NAMESPACE, "step_transformers") unless defined?(CUCUMBER_STEPTRANSFORM_NAMESPACE)
+
+end

data/lib/yard/code_objects/cucumber/scenario.rb

@@ -0,0 +1,22 @@
+module YARD::CodeObjects::Cucumber
+
+  class Scenario < NamespaceObject
+
+    attr_accessor :value, :comments, :keyword, :description, :steps, :tags, :feature
+
+    def initialize(namespace, name)
+      super(namespace, name.to_s.strip)
+      @comments = @description = @keyword = @value = @feature = nil
+      @steps = []
+      @tags = []
+    end
+
+    def background?
+      @keyword == "Background"
+    end
+
+    def outline?
+      false
+    end
+  end
+end

data/lib/yard/code_objects/cucumber/scenario_outline.rb

@@ -0,0 +1,68 @@
+module YARD::CodeObjects::Cucumber
+  class ScenarioOutline < NamespaceObject
+
+    attr_accessor :value, :comments, :keyword, :description, :steps, :tags, :feature
+    attr_accessor :scenarios, :examples
+
+    def initialize(namespace, name)
+      super(namespace, name.to_s.strip)
+      @comments = @description = @value = @feature = nil
+      @steps = []
+      @tags = []
+      @scenarios = []
+      @examples = []
+    end
+
+    def background?
+      false
+    end
+
+    def outline?
+      true
+    end
+
+    def examples?
+      @examples.find { |example| example.rows }
+    end
+
+    class Examples
+
+      attr_accessor :name, :line, :keyword, :comments, :rows, :tags, :scenario
+
+      # The first row of the rows contains the headers for the table
+      def headers
+        rows.first
+      end
+
+      # The data of the table starts at the second row. When there is no data then
+      # return a empty string.
+      def data
+        rows ? rows[1..-1] : ""
+      end
+
+      def values_for_row(row)
+        hash = {}
+
+        headers.each_with_index do |header, index|
+          hash[header] = data[row][index]
+        end
+
+        hash
+      end
+
+      def to_hash
+        hash = {}
+
+        rows.each_with_index do |header, index|
+          hash[header] = rows.collect { |row| row[index] }
+        end
+
+        hash
+      end
+
+      def initialize(parameters = {})
+        parameters.each { |key, value| send("#{key.to_sym}=", value) if respond_to? "#{key.to_sym}=" }
+      end
+    end
+  end
+end

data/lib/yard/code_objects/cucumber/step.rb

@@ -0,0 +1,46 @@
+module YARD::CodeObjects::Cucumber
+  class Step < Base
+
+    attr_accessor :comments,
+                  :definition,
+                  :examples,
+                  :keyword,
+                  :scenario,
+                  :table,
+                  :text,
+                  :placeholders,
+                  :value
+
+    def initialize(namespace, name)
+      super(namespace, name.to_s.strip)
+      @comments = @definition = @description = @keyword = @table = @text = @value = nil
+      @examples = {}
+      @placeholders = []
+    end
+
+    def has_table?
+      !@table.nil?
+    end
+
+    def has_text?
+      !@text.nil?
+    end
+
+    def definition=(stepdef)
+      @definition = stepdef
+
+      unless stepdef.steps.map(&:files).include?(files)
+        stepdef.steps << self
+
+        stepdef.placeholders.each do |placeholder|
+          placeholders << placeholder
+          placeholder.steps << self
+        end
+      end
+    end
+
+    def transformed?
+      !@placeholders.empty?
+    end
+  end
+end

data/lib/yard/code_objects/cucumber/tag.rb

@@ -0,0 +1,31 @@
+module YARD::CodeObjects::Cucumber
+  class Tag < NamespaceObject
+
+    attr_accessor :value, :owners, :total_scenarios
+
+    def features
+      @owners.find_all { |owner| owner.is_a?(Feature) }
+    end
+
+    def scenarios
+      all = @owners.find_all do |owner|
+        owner.is_a?(Scenario) || owner.is_a?(ScenarioOutline) || ()
+      end
+
+      @owners.each do |owner|
+        if owner.is_a?(ScenarioOutline::Examples) && !all.include?(owner.scenario)
+          all << owner.scenario
+        end
+      end
+      all
+    end
+
+    def indirect_scenarios
+      @owners.find_all { |owner| owner.is_a?(Feature) }.collect { |feature| feature.scenarios }.flatten
+    end
+
+    def all_scenarios
+      scenarios + indirect_scenarios
+    end
+  end
+end

data/lib/yard/code_objects/placeholder.rb

@@ -0,0 +1,45 @@
+module YARD::CodeObjects
+  class Placeholder < StepTransformer
+
+    CONSTANT_PATTERN = /#\{\s*([^}]+)\s*\}/
+
+    DEFAULT_PLACE_HOLDER_REGEXP_STRING = "['\"]?((?:(?<=\")[^\"]*)(?=\")|(?:(?<=')[^']*(?='))|(?<!['\"])[[:alnum:]_-]+(?!['\"]))['\"]?"
+
+    def value
+      return if @value.nil?
+      unless @processed
+        @processed = true
+        loop do
+          break if substitute_constants.nil?
+        end
+      end
+      @value
+    end
+
+    private
+
+    def substitute_constants
+      @value.gsub!(CONSTANT_PATTERN) do |_|
+        find_value_for_constant($1)
+      end
+    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(CONSTANT_PATTERN).flatten.collect { |value| value.strip }
+    end
+
+    #
+    # 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 == constant.to_sym }
+      log.warn "StepTransformer#find_value_for_constant : Could not find the CONSTANT [#{name}] using the string value." unless constant
+      constant ? constant.value : DEFAULT_PLACE_HOLDER_REGEXP_STRING
+    end
+  end
+end

data/lib/yard/code_objects/step_definition.rb

@@ -0,0 +1,46 @@
+module YARD::CodeObjects
+  class StepDefinition < StepTransformer
+
+    attr_accessor :placeholders
+
+    OPTIONAL_WORD_REGEXP = %r{(\\\s)?\\\((?!:)([^)]+)\\\)(\\s)?}
+    PLACEHOLDER_REGEXP = /(:[\w]+)/
+    ALTERNATIVE_WORD_REGEXP = /([[:alpha:]]+)((\/[[:alpha:]]+)+)/
+
+    def value
+      unless @processed
+        @placeholders = []
+        @processed = true
+        @value = Regexp.escape(@value)
+        @value.gsub!(PLACEHOLDER_REGEXP) do |_|
+          find_value_for_placeholder($1)
+        end
+        @value.gsub!(OPTIONAL_WORD_REGEXP) do |_|
+          [$1, $2, $3].compact.map { |m| "(?:#{m})?" }.join
+        end
+        @value.gsub!(ALTERNATIVE_WORD_REGEXP) do |_|
+          "(?:#{$1}#{$2.tr('/', '|')})"
+        end
+      end
+      @value
+    end
+
+
+    private
+
+    #
+    # 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_placeholder(name)
+      placeholder_matches = YARD::Registry.all(:placeholder).select{ |p|  p.literal_value == name }
+      regex = if placeholder_matches.empty?
+        YARD::CodeObjects::Placeholder::DEFAULT_PLACE_HOLDER_REGEXP_STRING
+      else
+        placeholders.push(*placeholder_matches)
+        placeholder_matches.map(&:regex).join('|')
+      end
+      "(?<placeholder_#{name[1..-1]}>#{regex})"
+    end
+  end
+end

data/lib/yard/code_objects/step_transformer.rb

@@ -0,0 +1,32 @@
+module YARD::CodeObjects
+  class StepTransformer < Base
+
+    include Cucumber::LocationHelper
+
+    attr_reader :constants, :keyword, :source, :value
+    attr_accessor :steps, :pending, :substeps, :literal_value
+
+
+
+    #
+    # 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)
+
+      @steps = []
+    end
+
+    # Generate a regex with the step transformers value
+    def regex
+      @regex ||= Regexp.new(value)
+    end
+  end
+end

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,96 @@
+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 placeholders. 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 placeholders.
+        #
+        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 placeholders"
+            FeatureHandler.match_steps_to_step_definitions(feature)
+          end
+        end
+
+        class << self
+          def match_steps_to_step_definitions(statement)
+            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.error "\n#{exception}\n#{exception.backtrace.join("\n")}\n"
+          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_placeholders(step)
+          end
+
+          #
+          # Given a step object, attempt to match that step to a step
+          # transformation
+          #
+          def match_step_to_step_definition_and_placeholders(step)
+            YARD::Registry.all(:stepdefinition).each do |stepdef|
+              stepdef_matches = stepdef.regex.match(step.value)
+
+              if stepdef_matches
+                step.definition = stepdef
+                # Step has been matched to step definition and step placeholders
+                # 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