yard-cucumber2 2.3.3

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

@@ -0,0 +1,29 @@
+<% n = 1 %>
+<li class="r<%= n %>">
+  <%= all_features_link %>
+</li>
+<% n = n == 2 ? 1 : 2 %>
+<% @items.each do |feature| %>
+<li class="r<%= n %>">
+  <%= "<a class='toggle'></a>" unless feature.scenarios.empty? %>
+  <%= linkify feature, feature.value %>
+  <small><%= feature.location %></small>
+</li>
+<% n = n == 2 ? 1 : 2 %>
+<% if feature.scenarios %>
+<ul>
+  <% feature.scenarios.each_with_index do |scenario,index| %>
+  <li class="r<%= n %>">
+    <span class='object_link'>
+       <a href="<%= url_for(scenario.feature,"scenario_#{index}") %>"
+           title="<%= h scenario.value %>">
+         <%= h scenario.value %>
+       </a>
+     </span>
+     <small><%= scenario.location %></small>
+  </li>
+        <% n = n == 2 ? 1 : 2 %>
+  <% end %>
+</ul>
+<% end %>
+<% end %>

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

@@ -0,0 +1,16 @@
+<li>
+  <%= linkify YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE, "All Step Definitions" %>
+</li>
+<% n = 1 %>
+<% @items.each do |stepdef| %>
+  <li class="r<%= n %>">
+  <span class='object_link'>
+    <span class="pre"><%= stepdef.keyword %></span>
+      <a href="<%= url_for stepdef %>" title="<%= h stepdef.value %>">
+        <span class="name"><%= h stepdef.literal_value %></span>
+      </a>&nbsp;&nbsp;
+  </span>
+  <small><%= h(stepdef.location) %></small>
+  </li>
+  <% n = n == 2 ? 1 : 2 %>
+<% end %>

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

@@ -0,0 +1,17 @@
+<li>
+  <%= linkify YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE, "All Defined Steps" %>
+</li>
+<% n = 1 %>
+
+<% @items.each do |step| %>
+  <li class="r<%= n %>">
+	<span class='object_link'>
+		<a href="<%= url_for step.scenario.feature %>" title="<%= h step.value %>">
+			<span class="pre"><%= step.keyword %></span>
+			<span class="name"><%= h(step.value) %></span>
+		</a>
+	</span>
+	<span class="">(<%= h(step.file) %>)<span>
+  </li>
+  <% n = n == 2 ? 1 : 2 %>
+<% end %>

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

@@ -0,0 +1,12 @@
+<li>
+  <%= linkify YARD::CodeObjects::Cucumber::CUCUMBER_TAG_NAMESPACE, "All Tags" %>
+</li>
+<% n = 1 %>
+
+<% @items.each do |tag| %>
+  <li class="r<%= n %>">
+	<%= linkify tag, tag.value %>
+	<small><%= tag.all_scenarios.size %></small>
+  </li>
+  <% n = n == 2 ? 1 : 2 %>
+<% end %>

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

@@ -0,0 +1,305 @@
+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.target !== "undefined" &&
+        (evt.target.nodeName == "INPUT" ||
+        evt.target.nodeName == "TEXTAREA")) return;
+    switch (evt.charCode) {
+      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'
+    }
+  });
+}
+
+$(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+-\d+/) == null) {
+                return false;
+            }
+            
+            var exampleClass = eventObject.currentTarget.className.match(/example\d+-\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,175 @@
+include YARD::Templates::Helpers::HtmlHelper
+
+def init
+  super
+
+  # Additional javascript that power the additional menus, collapsing, etc.
+  asset "js/cucumber.js", file("js/cucumber.js",true)
+
+  serialize_object_type :feature
+
+  serialize_object_type :tag
+
+  # Generates the requirements splash page with the 'requirements' template
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE)
+
+  # Generates a page for step definitions and step transforms with the 'steptransformers' template
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_STEPTRANSFORM_NAMESPACE)
+
+  # Generates the tags page with the 'featuretags' template
+  serialize(YARD::CodeObjects::Cucumber::CUCUMBER_TAG_NAMESPACE)
+
+  serialize_feature_directories
+end
+
+#
+# The top-level feature directories. This is affected by the directories that YARD is told to parse.
+# All other features in sub-directories are contained under each of these top-level directories.
+#
+# @example Generating one feature directory
+#
+#     `yardoc 'example/**/*'`
+#
+# @example Generating two feature directories
+#
+#     `yardoc 'example/**/*' 'example2/**/*'`
+#
+# @return the feature directories at the root of the Cucumber Namespace.
+#
+def root_feature_directories
+  @root_feature_directories ||= YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory)}
+end
+
+#
+# Generate pages for the objects if there are objects of this type contained
+# within the Registry.
+#
+def serialize_object_type(type)
+  objects = Registry.all(type.to_sym)
+  Array(objects).each {|object| serialize(object) }
+end
+
+#
+# Generates pages for the feature directories found. Starting with all root-level feature
+# directories and then recursively finding all child feature directories.
+#
+def serialize_feature_directories
+  serialize_feature_directories_recursively(root_feature_directories)
+  root_feature_directories.each {|directory| serialize(directory) }
+end
+
+#
+# Generate a page for each Feature Directory. This is called recursively to
+# ensure that all feature directories contained as children are rendered to
+# pages.
+#
+def serialize_feature_directories_recursively(namespaces)
+  namespaces.each do |namespace|
+    Templates::Engine.with_serializer(namespace, options[:serializer]) do
+      options[:object] = namespace
+      T('layout').run(options)
+    end
+    serialize_feature_directories_recursively(namespace.children.find_all {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory)})
+  end
+end
+
+
+# Generate feature list
+# @note this method is called automatically by YARD based on the menus defined in the layout
+def generate_feature_list
+  features = Registry.all(:feature)
+  features_ordered_by_name = features.sort {|x,y| x.value.to_s <=> y.value.to_s }
+  generate_full_list features_ordered_by_name, :features
+end
+
+# Generate tag list
+# @note this method is called automatically by YARD based on the menus defined in the layout
+def generate_tag_list
+  tags = Registry.all(:tag)
+  tags_ordered_by_use = Array(tags).sort {|x,y| y.all_scenarios.size <=> x.all_scenarios.size }
+
+  generate_full_list tags_ordered_by_use, :tags
+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), :stepdefinitions,
+    :list_title => "Step Definitions List"
+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), :steps
+end
+
+# Generate feature 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_featuredirectories_list
+  directories_ordered_by_name = root_feature_directories.sort {|x,y| x.value.to_s <=> y.value.to_s }
+  generate_full_list directories_ordered_by_name, :featuredirectories, 
+    :list_title => "Features by Directory",
+    :list_filename => "featuredirectories_list.html"
+end
+
+
+# Helpler method to generate a full_list page of the specified objects with the
+# specified type.
+def generate_full_list(objects,type,options = {})
+  defaults = { :list_title => "#{type.to_s.capitalize} List",
+    :css_class => "class",
+    :list_filename => "#{type.to_s.gsub(/s$/,'')}_list.html" }
+
+  options = defaults.merge(options)
+
+  @items = objects
+  @list_type = type
+  @list_title = options[:list_title]
+  @list_class = options[:css_class]
+  asset options[:list_filename], erb(:full_list)
+end
+
+#
+# @note This method overrides YARD's default template class_list method.
+#
+# The existing YARD 'Class List' search field contains all the YARD namespace objects.
+# We, however, do not want the Cucumber Namespace YARD Object (which holds the features,
+# tags, etc.) as it is a meta-object.
+#
+# This method removes the namespace from the root node, generates the class list,
+# and then adds it back into the root node.
+#
+def class_list(root = Registry.root)
+  return super unless root == Registry.root
+
+  cucumber_namespace = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE
+  root.instance_eval { children.delete cucumber_namespace }
+  out = super(root)
+  root.instance_eval { children.push cucumber_namespace }
+  out
+end
+
+#
+# Generate a link to the 'All Features' in the features_list.html
+#
+# When there are no feature directories or multiple top-level feature directories
+# then we want to link to the 'Requirements' page
+#
+# When there are is just one feature directory then we want to link to that directory
+#
+def all_features_link
+  if root_feature_directories.length == 0 || root_feature_directories.length > 1
+    linkify YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE, "All Features"
+  else
+    linkify root_feature_directories.first, "All Features"
+  end
+end
+
+def directory_node(directory)
+  @directory = directory
+  erb(:directories)
+end