yard-cucumber 2.0.0

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

@@ -0,0 +1,314 @@
+function cucumberSearchFrameLinks() {
+    $('#features_list_link').click(function() {
+        toggleSearchFrame(this, relpath + 'feature_list.html');
+    });
+    $('#tags_list_link').click(function() {
+        toggleSearchFrame(this, relpath + 'tag_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;
+    switch (evt.charCode) {
+      case 82: case 114: $('#features_list_link').click(); break; // 'r'
+      case 84: case 116: $('#tags_list_link').click(); break;  // 't'
+    }
+  });
+}
+
+$(cucumberSearchFrameLinks);
+$(cucumberKeyboardShortcuts);
+
+
+$(function() {
+
+    //
+    //  Feature Page - Scenarios 
+    //
+    $('.scenario div.title').click(function(eventObject) {
+        if (typeof eventObject.currentTarget !== "undefined")  {
+            toggleScenario( $($(eventObject.currentTarget).parent()) );
+        }
+    });
+
+    //
+    // Developer View
+    // Click + Developer View = toggle the expansion of all tags, location, and comments
+    //
+    $('#view').click(function(eventObject) {
+		
+        if (typeof eventObject.currentTarget !== "undefined")  {
+            var view = eventObject.currentTarget;
+			
+            if (view.innerHTML === '[More Detail]') {
+                $('.developer').show(500);
+                view.innerHTML = '[Less Detail]';
+            } else {
+                $('.developer').hide(500);
+                // Already hidden elements with .developer sub-elements were not getting message
+                $('.developer').each(function() {
+                    $(this).css('display','none');
+                });
+                view.innerHTML = '[More Detail]';
+            }
+        }
+    });
+
+    //
+    // Expand/Collapse All
+    //
+    $('#expand').click(function(eventObject) {
+	    
+        if (typeof eventObject.currentTarget !== "undefined")  {
+            if (eventObject.currentTarget.innerHTML === '[Expand All]') {
+                eventObject.currentTarget.innerHTML = '[Collapse All]';
+                $('div.scenario > div.details:hidden').each(function() {
+                    toggleScenario( $($(this).parent()) );
+                });
+            } else {
+                eventObject.currentTarget.innerHTML = '[Expand All]';
+                $('div.scenario > div.details:visible').each(function() {
+                    toggleScenario( $($(this).parent()) );
+                });
+            }
+        }
+    });
+
+    //
+    // Expand/Collapse All
+    //
+    $('#stepdefinition,#steptransform').click(function(eventObject) {
+
+        if (typeof eventObject.currentTarget !== "undefined")  {
+            if (eventObject.currentTarget.innerHTML === '[Expand All]') {
+                eventObject.currentTarget.innerHTML = '[Collapse All]';
+                $('div.' + eventObject.currentTarget.id + ' > div.details:hidden').each(function() {
+                    $(this).show(200);
+                });
+            } else {
+                eventObject.currentTarget.innerHTML = '[Expand All]';
+                $('div.' + eventObject.currentTarget.id + ' > div.details:visible').each(function() {
+                    $(this).hide(200);
+                });
+            }
+        }
+    });
+
+
+    //
+    // Scenario Outlines - Toggle Examples
+    //
+    $('.outline table tr').click(function(eventObject) {
+		
+        if (typeof eventObject.currentTarget !== "undefined")  {
+            var exampleRow = $(eventObject.currentTarget);
+            
+            if (eventObject.currentTarget.className.match(/example\d+/) == null) {
+                return false;
+            }
+            
+            var exampleClass = eventObject.currentTarget.className.match(/example\d+/)[0];
+            var example = exampleRow.closest('div.details').find('.' + exampleClass);
+			
+            var currentExample = null;
+			
+            $('.outline table tr').each(function() {
+                $(this).removeClass('selected');
+            });
+			
+            if ( example[0].style.display == 'none' ) {
+                currentExample = example[0];
+                exampleRow.addClass('selected');
+            } else {
+                currentExample = exampleRow.closest('div.details').find('.steps')[0];
+            }
+
+            // hide everything
+            exampleRow.closest('div.details').find('.steps').each(function() {
+                $(this).hide();
+            });
+			
+            // show the selected
+            $(currentExample).show();
+        }
+    });
+
+
+});
+ 
+
+function toggleScenario(scenario) {
+	
+    var state = scenario.find(".attributes input[name='collapsed']")[0];
+	
+    if (state.value === 'true') {
+        scenario.find("div.details").each(function() {
+            $(this).show(500);
+        });
+        state.value = "false";
+        scenario.find('a.toggle').each(function() {
+            this.innerHTML = ' - ';
+        });
+		
+    } else {
+        scenario.find("div.details").each(function() {
+            $(this).hide(500);
+        });
+        state.value = "true";
+        scenario.find('a.toggle').each(function() {
+            this.innerHTML = ' + ';
+        });
+    }
+}
+
+
+function updateTagFiltering(tagString) {
+    var formulaTags = determineTagsUsedInFormula(tagString);
+    displayExampleCommandLine(formulaTags);
+    displayQualifyingFeaturesAndScenarios(formulaTags);
+    fixSectionRowAlternations();
+}
+
+function clearTagFiltering() {
+    updateTagFiltering("");
+}
+
+function determineTagsUsedInFormula(tagString)  {
+
+    tagString = tagString.replace(/^(\s+)|(\s+)$/,'').replace(/\s{2,}/,' ');
+
+    var tagGroup = tagString.match(/(?:~)?@\w+(,(?:~)?@\w+)*/g);
+
+    var returnTags = [];
+
+    if (tagGroup) {
+        tagGroup.forEach(function(tag, index, array) {
+            console.log("Tag Group: " + tag);
+            var validTags = removeInvalidTags(tag)
+            if (validTags != "") {
+                returnTags.push(validTags);
+            }
+        });
+    }
+
+    return returnTags;
+}
+
+function removeInvalidTags(tagGroup) {
+    tagGroup.split(",").forEach(function(tag, index, array) {
+        
+        baseTag = tag.match(/^~(.+)/) ? tag.match(/^~(.+)/)[1] : tag;
+        
+        //console.log("Validating Tag: " + tag)
+        if (tag_list.indexOf(baseTag) === -1) {
+            //console.log("Removing Tag: " + tag);
+            tagGroup = tagGroup.replace(new RegExp(',?' + tag + ',?'),"")
+        }
+    });
+
+    return tagGroup;
+}
+
+
+function displayExampleCommandLine(tags) {
+    $("#command_example")[0].innerHTML = "cucumber ";
+
+    if (tags.length > 0)  {
+        $("#command_example")[0].innerHTML += "--tags " + tags.join(" --tags ");
+    }
+}
+
+function fixSectionRowAlternations() {
+    $(".feature:visible,.scenario:visible").each(function(index){
+        $(this).removeClass("odd even").addClass( ((index + 1) % 2 == 0 ? "even" : "odd") );
+    });
+}
+
+function displayQualifyingFeaturesAndScenarios(tags) {
+
+    if (tags.length > 0) {
+
+        $(".feature,.scenario").each(function(feature){
+            $(this).hide();
+        });
+
+        var tagSelectors = generateCssSelectorFromTags(tags);
+
+        tagSelectors.forEach(function(selector,selectorIndex,selectorArray) {
+            var tags = selector;
+            
+            $(".feature." + tags).each(function(index) {
+                $(this).show();
+            });
+            $(".scenario." + tags).each(function(index) {
+                $(this).show();
+                $(this).parent().prev().show();
+            });
+            
+        });
+        
+        if ( $(".feature:visible,.scenario:visible").length == 0 ) {
+            $("#features div.undefined").show();
+        }  else {
+            $("#features div.undefined").hide();
+        }
+        
+
+    } else {
+        $(".feature:hidden,.scenario:hidden").each(function(feature){
+            $(this).show();
+        });
+    }
+
+}
+
+function generateCssSelectorFromTags(tagGroups) {
+
+    var tagSelectors = [ "" ];
+
+    tagGroups.forEach(function(tagGroup,index,array) {
+        var newTagSelectors = [];
+
+        tagSelectors.forEach(function(selector,selectorIndex,selectorArray) {
+            tagGroup.split(",").forEach(function(tag,tagIndex,tagArray) {
+                
+                if ( tag.match(/^~@.+$/) ) {
+                    tag = tag.match(/^~(@.+)$/)[1]
+                    //console.log("selector: " + (selector + " :not(" + tag + ")").trim());
+                    newTagSelectors.push((selector + ":not(." + tag.replace(/@/g,"\\@") +")").trim());
+                } else { 
+                    //console.log("selector: " + (selector + " " + tag).trim());
+                    newTagSelectors.push((selector + "." + tag.replace(/@/g,"\\@")).trim());
+                }
+            });
+
+        });
+
+        tagSelectors = newTagSelectors;
+
+    });
+
+
+    return tagSelectors;
+}
+
+
+function createStepDefinitionLinks() {
+    // $('.step_instances_list').
+    //         before("<span class='showSteps'>[<a href='#' class='toggleSteps'>View steps</a>]</span>");
+    $('.toggleSteps').toggle(function() {
+        $(this).parent().next().slideUp(100);
+        $(this).text("View " + $(this).attr('alt'));
+    },
+    function() {
+        $(this).parent().next().slideDown(100);
+        $(this).text("Hide " + $(this).attr('alt'));
+    });
+}
+
+$(createStepDefinitionLinks);

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

@@ -0,0 +1,72 @@
+include YARD::Templates::Helpers::HtmlHelper
+
+def init
+  super
+  asset("js/cucumber.js",file("js/cucumber.js",true))
+
+  @features = Registry.all(:feature)
+
+  if @features
+    @features.each {|feature| serialize(feature) } 
+    generate_full_list @features.sort {|x,y| x.value.to_s <=> y.value.to_s }
+  end
+  
+  @tags = Registry.all(:tag)
+
+  if @tags
+    @tags.each {|tag| serialize(tag) }
+    generate_full_list @tags.sort {|x,y| y.all_scenarios.size <=> x.all_scenarios.size }
+  end
+
+  feature_directories = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory) }
+
+
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE)
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE)
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_TAG_NAMESPACE)
+  serialize_feature_directories(feature_directories)
+
+end
+
+
+def generate_full_list(objects,friendly_name=nil)
+  if !objects.empty?
+    @items = objects
+    @list_type = "#{objects.first.type.to_s}s"
+    @list_title = "#{friendly_name || objects.first.type.to_s.capitalize} List"
+    @list_class = "class"
+    asset("#{objects.first.type}_list.html",erb(:full_list))
+  else
+    log.warn "Full List: Failed to create a list because the objects array is empty."
+  end
+end
+
+#
+# Remove CUCUMBER namespace from the class list
+#
+def class_list(root = Registry.root)
+  root.instance_eval { children.delete YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE } if root == Registry.root
+  out = super(root)
+  root.instance_eval { children << YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE } if root == Registry.root
+  out
+end
+
+def serialize_feature_directories(namespaces)
+  namespaces.each do |namespace|
+    Templates::Engine.with_serializer(namespace, options[:serializer]) do
+      options[:object] = namespace
+      T('layout').run(options)
+    end
+    serialize_feature_directories(namespace.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory)})
+  end
+end
+
+def all_features_link
+  root_feature_directories = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory)}
+
+  if root_feature_directories.length > 1
+    linkify YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE, "All Features"
+  else
+    linkify root_feature_directories.first, "All Features"
+  end
+end

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

@@ -0,0 +1,14 @@
+<meta name="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>
+<script type="text/javascript" charset="utf-8" src="<%= url_for("js/jquery.js") %>"></script>
+<script type="text/javascript" charset="utf-8" src="<%= url_for("js/app.js") %>"></script>
+<script type="text/javascript" charset="utf-8" src="<%= url_for("js/cucumber.js") %>"></script>

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

@@ -0,0 +1,7 @@
+<div id="search">
+  <a id="features_list_link" href="#">Features</a>
+  <a id="tags_list_link" href="#">Tags</a>
+  <a id="class_list_link" href="#">Class List</a>
+  <a id="method_list_link" href="#">Method List</a>
+  <a id ="file_list_link" href="#">File List</a>
+</div>

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

@@ -0,0 +1,26 @@
+<% 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>
+                  <%= linkify obj, obj.value %>
+                  <small>(<%= obj.file %>)</small>
+                </li>
+              <% end %>
+            </ul>
+          </ul>
+        <% end %>
+      </td>
+    </tr>
+  </table>
+<% end %>

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

@@ -0,0 +1,50 @@
+<% if @namespace %>
+  <div id="cukes_logo">&nbsp;</div>
+  <div id="cukes_links">
+    <a href="http://cukes.info/">Cucumber</a> |
+    <a href="http://github.com/aslakhellesoy/cucumber/wiki/Gherkin">Gherkin</a> |
+    <a href="http://yardoc.org/">YARD</a> |
+    <a href="http://github.com/burtlo/Cucumber-In-The-Yard">Cucumber-In-The-YARD</a>
+  </div>
+
+  <div class="requirements">
+
+    <% if features && !features.empty? %>
+      <%= alpha_table(features) %>
+    <% else %>
+      <!-- No Features Defined -->
+      <div class="none">No Features Defined</div>
+    <% end %>
+
+    <div id="directory" style="margin-left: 40px;">
+      <div class="title"><span class="name">Tags</span></div>
+    </div>
+    <div class="tags">
+      <%= tags.collect {|tag| linkify(tag,tag.value) }.join(",\n") %>
+    </div>
+
+    <% if feature_subdirectories && !feature_subdirectories.empty? %>
+      <div id="directory" style="margin-left: 40px;">
+        <div class="title"><span class="name">Subdirectories</span></div>
+      </div>
+      <%= alpha_table(feature_subdirectories) %>
+    <% else %>
+      <!-- No Feature Directories -->
+    <% end %>
+    
+    <div id="directory" style="margin-left: 40px;">
+      <div class="title"><span class="name">Step Definitions &amp; Transforms</span></div>
+    </div>
+    <div class="steptransformers">
+      <%= step_definitions.length %> 
+      <a href="<%= url_for step_transformers, "step_definitions" %>">Step Definitions</a>
+      <%= transformers.length %>
+      <a href="<%= url_for step_transformers, "step_transforms" %>">Transforms</a>
+      and <%= undefined_steps.length %>
+      <a href="<%= url_for step_transformers, "undefined_steps" %>">Undefined Steps</a>
+    </div>
+    
+  </div>
+<% end %>
+
+

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

@@ -0,0 +1,51 @@
+def init
+  super
+  sections.push :requirements
+  @namespace = object
+
+end
+
+def features
+  @features ||= Registry.all(:feature)
+end
+
+def tags
+  @tags ||= Registry.all(:tag).sort_by {|l,o| l.value.to_s }
+end
+
+def feature_directories
+  @feature_directories ||= YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory)}
+end
+
+def feature_subdirectories
+  @feature_subdirectories ||= Registry.all(:featuredirectory) - feature_directories
+end
+
+def step_transformers
+  YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE
+end
+
+def step_definitions
+  @step_definitions ||= YARD::Registry.all(:stepdefinition)
+end
+
+def transformers
+  @transformers ||= YARD::Registry.all(:steptransform)
+end
+
+def undefined_steps
+  @undefined_steps ||= Registry.all(:step).reject {|s| s.definition || s.scenario.outline? }
+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/steptransformers/html/header.erb

@@ -0,0 +1,12 @@
+<div class="title">
+  <% if @item_type %>
+     <a class="control" id="<%= @item_type.gsub(/\s/,'') %>">[Collapse All]</a>
+     <div style="clear: right;"></div>
+   <% end %>
+ 
+  <% if @item_anchor_name %>
+    <a name="<%= @item_anchor_name %>">
+  <% end %>
+  <div class="name"><%= @item_title %></div>
+</div>
+

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

@@ -0,0 +1,10 @@
+<div class="requirements">
+  <div class="title">Step Definitions &amp; Transforms</div>
+
+  <div class="summary">
+    <div><%= step_definitions.length %><a href="#step_definitions">Step Definitions</a></div>
+    <div><%= step_transforms.length %><a href="#step_transforms">Step Transforms</a></div>
+    <div><%= undefined_steps.length %><a href="#undefined_steps">Undefined Steps</a></div>
+  </div>
+
+</div>

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

@@ -0,0 +1,94 @@
+def init
+  super
+  sections.push :index, :stepdefinitions, :steptransforms, :undefinedsteps
+end
+
+def step_definitions
+  @step_definitions ||= begin
+    YARD::Registry.all(:stepdefinition).sort_by {|definition| definition.steps.length * -1 }
+  end
+end
+
+def step_transforms
+  @step_transforms ||= begin
+    YARD::Registry.all(:steptransform).sort_by {|definition| definition.steps.length * -1 }
+  end
+end
+
+def undefined_steps
+  @undefined_steps ||= begin
+    unique_steps(Registry.all(:step).reject {|s| s.definition || s.scenario.outline? }).sort_by{|steps| steps.last.length * -1 }
+  end
+end
+
+def stepdefinitions
+  @item_title = "Step Definitions"  
+  @item_anchor_name = "step_definitions"
+  @item_type = "step definition"
+  @items = step_definitions
+  erb(:header) + erb(:transformers)
+end
+
+def steptransforms
+  @item_title = "Step Transforms"
+  @item_anchor_name = "step_transforms"
+  @item_type = "step transform"
+  @items = step_transforms
+  erb(:header) + erb(:transformers)
+end
+
+def undefinedsteps
+  @item_title = "Undefined Steps"  
+  @item_anchor_name = "undefined_steps"
+  @item_type = nil
+  @items = undefined_steps
+  erb(:header) + erb(:undefinedsteps)
+end
+
+
+def unique_steps(steps)
+  uniq_steps = {}
+  steps.each {|s| (uniq_steps[s.value.to_s] ||= []) << s }
+  uniq_steps
+end
+
+def display_comments_for(item)
+  begin
+    T('docstring').run(options.dup.merge({:object => item}))
+  rescue
+    log.warn %{An error occurred while attempting to render the comments for: #{item.location} }
+    return ""
+  end
+  
+end
+
+def link_constants(definition)
+  value = definition.literal_value.dup
+
+  definition.constants_from_value(value).each do |name|
+    constant = YARD::Registry.all(:constant).find{|c| c.name == name.to_sym }
+    value.gsub!(/\b#{name}\b/,"<a href='#{url_for(constant)}'>#{name}</a>") if constant
+  end
+
+  value
+end
+
+
+def link_transformed_step(step)
+  value = step.value.dup
+  
+  if step.definition
+    matches = step.value.match(step.definition.regex)
+    
+    if matches
+      matches[1..-1].reverse.each_with_index do |match,index|
+        next if match == nil
+        transform = step.transforms.find {|transform| transform.regex.match(match) }
+        
+        value[matches.begin((matches.size - 1) - index)..(matches.end((matches.size - 1) - index) - 1)] = transform ? "<a href='#{url_for(transform)}'>#{h(match)}</a>" : "<span class='match'>#{match}</span>"
+      end
+    end
+  end
+  
+  value
+end