yard-cucumber 2.0.0

data/lib/templates/default/steptransformers/html/transformers.erb

@@ -0,0 +1,74 @@
+<% @items.each do |item| %>
+
+<div class="transformer <%= @item_type.gsub(/\s/,'') %> <%= "nodefinitions" if item.steps.nil? || item.steps.empty? %>">
+  <a name="<%= anchor_for item %>"></a>
+  <div class="title">
+    <span class="pre"><%= h item.keyword %></span>
+    <span class="name"><%= link_constants item %></span>
+    <a style="float: right;" href="http://rubular.com/?regex=<%= urlencode item.value %>" target="_blank">Rubular</a>
+    <div style="clear: both;"></div>
+  </div>
+
+  <div class="details">
+    
+    <div class="meta" style="clear: right;">
+      <div class="file"><%= h item.location %></div>
+    </div>
+
+    
+    <!-- Comments -->
+    <div>
+      <%= display_comments_for item %>
+    </div>
+    
+
+    <!-- Source Code -->
+    <div class="method_details_list">
+      <table class="source_code">
+        <tr>
+          <td>
+            <pre class="lines"><%= "" %><%= h format_lines(item) %></pre>
+          </td>
+          <td>
+            <pre class="code"><%= "" %><%= html_syntax_highlight item.source %></pre>
+          </td>
+        </tr>
+      </table>
+    </div>
+
+    <!-- Matching Step Instances -->
+    <% if item.steps.length > 0 %>
+      <div class='showSteps'>
+        [<a href='#' class='toggleSteps' alt="<%= item.steps.length %> steps">Hide <%= item.steps.length %> steps</a>]
+      </div>
+    <% end %>
+    <div class="steps">
+      <% if item.steps && !item.steps.empty? %>
+      <% unique_steps(item.steps).each_with_index do |uniq_step,step_index| %>
+      <div class="step <%= (step_index + 1) % 2 == 0 ? 'even' : 'odd' %>">
+        <div>
+          <span class="predicate">
+            <%= h uniq_step.last.first.keyword %>
+          </span>
+          <span class="defined">
+            <%= link_transformed_step(uniq_step.last.first) %>
+          </span>
+        </div>
+        <% uniq_step.last.each do |step| %>
+        <a class="definition" style="clear: right;" href="<%= url_for step.scenario.feature %>"><%= h step.location %></a>
+        <% end %>
+        <div style="clear: both;"></div>
+      </div>
+      <% end %>
+      <% else %>
+      <div class="undefined">No steps were found to match this <%= @item_type %>.</div>
+      <% end%>
+    </div>
+    
+  </div>
+
+  <div style="margin: 30px 20px; border-top: 1px dotted #AAA;"></div>
+
+</div>
+
+<% end %>

data/lib/templates/default/steptransformers/html/undefinedsteps.erb

@@ -0,0 +1,26 @@
+<div class="transformer">
+  <div class="steps">
+  <% if @undefined_steps && !@undefined_steps.empty? %>
+    <% @undefined_steps.each_with_index do |uniq_step,step_index| %>
+    <div class="step <%= (step_index + 1) % 2 == 0 ? 'even' : 'odd' %>">
+      <div>
+        <span class="predicate"><%= uniq_step.last.first.keyword %></span>
+        <span class="undefined">
+          <%= h uniq_step.last.first.value %>
+        </span>
+      </div>
+      <% uniq_step.last.each do |step| %>
+        <a class="definition" style="clear: right;" href="<%= url_for step.scenario.feature %>">
+          <%= h step.location %>
+        </a>
+      <% end%>
+      <div style="clear: both;"></div>
+    </div>
+    <% end %>
+    <% else %>
+    <div class="steps">
+      <div class="undefined">No undefined steps</div>
+    </div>
+    <% end%>
+  </div>
+</div>

data/lib/templates/default/tag/html/alpha_table.erb

@@ -0,0 +1,32 @@
+<% if @elements && !@elements.empty? %>
+  <% i = (@elements.length % 2 == 0 ? 1 : 0) %>
+  <table style="margin-left: 10px; width: 100%;">
+    <tr>
+      <td valign='top' width="50%">
+        <% @elements.each do |letter, objects| %>
+          <% if (i += 1) > (@elements.length / 2 + 1) %>
+          </td><td valign='top' width="50%">
+            <% i = 0 %>
+          <% end %>
+          <ul id="alpha_<%= letter %>" class="alpha">
+            <li class="letter"><%= letter %></li>
+            <ul>
+              <% objects.each do |obj| %>
+                <li>
+                  <% if obj.is_a?(YARD::CodeObjects::Cucumber::Scenario) || obj.is_a?(YARD::CodeObjects::Cucumber::ScenarioOutline) %>
+                    <a href="<%= url_for(obj.feature,"scenario_#{obj.path[(/.+_(\d+)$/),1]}") %>">
+                 		  <%= h obj.value %>
+                 		</a>
+                  <% else %>
+                    <%= linkify obj, obj.value %>
+                  <% end %>
+                  <small>(<%= obj.file %>)</small>
+                </li>
+              <% end %>
+            </ul>
+          </ul>
+        <% end %>
+      </td>
+    </tr>
+  </table>
+<% end %>

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

@@ -0,0 +1,27 @@
+def init
+  super
+  @tag = object
+
+  sections.push :tag
+end
+
+def features
+  @tag.features
+end
+
+def scenarios
+  @tag.scenarios
+end
+
+
+def alpha_table(objects)
+  @elements = Hash.new
+
+  objects = run_verifier(objects)
+  objects.each {|o| (@elements[o.value.to_s[0,1].upcase] ||= []) << o }
+  @elements.values.each {|v| v.sort! {|a,b| b.value.to_s <=> a.value.to_s } }
+  @elements = @elements.sort_by {|l,o| l.to_s }
+
+  @elements.each {|letter,objects| objects.sort! {|a,b| b.value.to_s <=> a.value.to_s }}
+  erb(:alpha_table)
+end

data/lib/templates/default/tag/html/tag.erb

@@ -0,0 +1,35 @@
+<div class="tag">
+  <div class="title">
+    <span class="pre">Tag:</span>
+    <span class="name"><%= @tag.value %></span>
+
+  </div>
+
+  <div class="meta">
+    <div class="file">
+      <%= @tag.features.size > 0 ? "#{@tag.features.size} feature#{@tag.features.size > 1 ? 's' : ''} (with #{@tag.indirect_scenarios.size} scenario#{@tag.indirect_scenarios.size > 1 ? 's' : ''})" : "" %>
+      <%= " and " if @tag.features.size > 0 && @tag.scenarios.size > 0 %>
+      <%= @tag.scenarios.size > 0 ? "#{@tag.scenarios.size} scenario#{@tag.scenarios.size > 1 ? 's' : ''}" : "" %>
+    </div>		
+  </div>
+
+  <div style="margin-top: 20px;">&nbsp;</div>
+
+  <% if features && !features.empty? %>
+  <div id="features" style="margin-left: 40px;">
+    <div class="title"><span class="name">Features</span></div>
+  </div>
+  <%= alpha_table(features) %>
+
+  <% end %>
+
+  <% if scenarios && !scenarios.empty? %>
+  <div id="features" style="margin-left: 40px;">
+    <div class="title"><span class="name">Scenarios</span></div>
+  </div>
+  <%= alpha_table(scenarios) %>
+
+  <% end %>
+
+
+</div>

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

@@ -0,0 +1,32 @@
+
+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,18 @@
+
+
+module YARD::CodeObjects::Cucumber
+
+  class Feature < NamespaceObject
+    
+    attr_accessor :background, :comments, :description, :keyword, :scenarios, :tags, :value
+
+    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,45 @@
+
+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 StepTransformersObject < 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 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 = StepTransformersObject.new(CUCUMBER_NAMESPACE, "step_transformers") unless defined?(CUCUMBER_STEPTRANSFORM_NAMESPACE)
+  
+end

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

@@ -0,0 +1,26 @@
+
+
+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,66 @@
+
+
+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[:rows].nil?
+    end
+
+    def example_keyword
+      @examples[:keyword]
+    end
+    
+    def example_headers
+      @examples[:rows].first
+    end
+    
+    def example_data
+      return "" unless @examples[:rows]
+      @examples[:rows][1..-1]
+    end
+
+    def example_values_for_row(row)
+      hash = {}
+
+      example_headers.each_with_index do |header,index|
+        hash[header] = example_data[row][index]
+      end
+
+      hash
+    end
+    
+    def example_hash
+      hash = {}
+      
+      @examples[:rows].each_with_index do |header,index|
+        hash[header] = @examples[:rows].collect {|row| row[index] }
+      end
+      
+      hash
+    end
+    
+  end
+
+end

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

@@ -0,0 +1,35 @@
+
+
+module YARD::CodeObjects::Cucumber
+
+  class Step < Base
+    
+    attr_accessor :comments, :definition, :examples, :keyword, :scenario, :table, :text, :transforms, :value
+    
+    def initialize(namespace,name)
+      super(namespace,name.to_s.strip)
+      @comments = @definition = @description = @keyword = @table = @text = @value = nil
+      @examples = {}
+      @transforms = []
+    end
+    
+    def has_table?
+      !@table.nil?
+    end
+
+    def has_text?
+      !@text.nil?
+    end
+    
+    def definition=(stepdef)
+      @definition = stepdef
+      stepdef.steps << self
+    end
+    
+    def transformed?
+      !@transforms.empty?
+    end
+
+  end
+
+end

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

@@ -0,0 +1,27 @@
+
+
+module YARD::CodeObjects::Cucumber
+
+  class Tag < NamespaceObject
+
+    attr_accessor :value, :owners
+    
+    def features
+      @owners.find_all{|owner| owner.is_a?(Feature) }
+    end
+    
+    def scenarios
+      @owners.find_all{|owner| owner.is_a?(Scenario) || owner.is_a?(ScenarioOutline) }
+    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/step_definition.rb

@@ -0,0 +1,7 @@
+
+
+module YARD::CodeObjects
+
+  class StepDefinitionObject < StepTransformerObject ; end
+
+end

data/lib/yard/code_objects/step_transform.rb

@@ -0,0 +1,7 @@
+
+
+module YARD::CodeObjects
+
+  class StepTransformObject < StepTransformerObject ; end
+  
+end

data/lib/yard/code_objects/step_transformer.rb

@@ -0,0 +1,51 @@
+
+module YARD::CodeObjects
+
+  class StepTransformerObject < Base
+
+    include Cucumber::LocationHelper
+
+    attr_reader :constants, :keyword, :source, :value, :literal_value
+    attr_accessor :steps
+
+    ESCAPE_PATTERN = /#\{\s*(\w+)\s*\}/ unless defined?(ESCAPE_PATTERN)
+
+    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 = []
+    end
+
+    def regex
+      @regex ||= /#{strip_regex_from(@value)}/
+    end
+
+    def constants_from_value(data=@value)
+      data.scan(ESCAPE_PATTERN).flatten.collect { |value| value.strip }
+    end
+
+    protected
+
+    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
+  
+    def value_regex(value)
+      /#\{\s*#{value}\s*\}/
+    end
+
+    def strip_regex_from(value)
+      value.gsub(/^\/|\/$/,'')
+    end
+
+
+  end
+
+end

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

@@ -0,0 +1,22 @@
+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,93 @@
+module YARD
+  module Handlers
+    module Cucumber
+      class FeatureHandler < Base
+
+        handles CodeObjects::Cucumber::Feature
+
+        @@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
+            # 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
+
+
+        def process_scenario(scenario)
+          scenario.steps.each {|step| process_step(step) }
+        end
+
+        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
+                  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

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

@@ -0,0 +1,46 @@
+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
+
+  @@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