yard-lucid 0.1.0

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

@@ -0,0 +1,27 @@
+<% @row = @row == 'even' ? 'odd' : 'even' %>
+<% if @directory.children %>
+<ul>
+  <% @directory.children.sort { |x,y| x.value.to_s <=> y.value.to_s }.each_with_index do |child, index| %>
+    <% if child.is_a?(YARD::CodeObjects::Lucid::Feature) %>
+      <li class="<%= @row %>">
+        <div class="item" style="padding-left: <%= @padding %>px">
+          <%= linkify child, child.value %>
+          <small><%= child.location %></small>
+        </div>
+      </li>
+      <% @row = @row == 'even' ? 'odd' : 'even' %>
+    <% end %>
+
+    <% if child.is_a?(YARD::CodeObjects::Lucid::FeatureDirectory) %>
+      <li class="<%= @row %>">
+        <div class="item" style="padding-left: <%= @padding %>px">
+          <%= "<a class='toggle'></a>" unless child.features.empty? && child.subdirectories.empty? %>
+          <%= linkify child, child.value.to_s.capitalize  %>
+          <small><%= child.location %></small>
+        </div>
+        <%= directory_node child, @padding + 15, @row %>
+      </li>
+    <% end %>
+  <% end %>
+</ul>
+<% end %>

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

@@ -0,0 +1,11 @@
+<% n = 'odd' %>
+<% @items.each do |directory| %>
+<li class="<%= n %>">
+  <div class="item" style="padding-left: 30px">
+    <%= "<a class='toggle'></a>" unless directory.features.empty? && directory.subdirectories.empty? %>
+    <%= linkify directory, directory.value %>
+    <small><%= directory.location %></small>
+  </div>
+  <%= directory_node directory, 45, n %>
+</li>
+<% end %>

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

@@ -0,0 +1,36 @@
+<% n = 'odd' %>
+<li class="<%= n %>">
+  <div class="item" style="padding-left: 30px">
+    <%= all_features_link %>
+  </div>
+</li>
+<% n = n == 'odd' ? 'even' : 'odd' %>
+<% @items.each do |feature| %>
+<li class="<%= n %>">
+  <div class="item" style="padding-left: 30px">
+    <%= "<a class='toggle'></a>" unless feature.scenarios.empty? %>
+    <%= linkify feature, feature.value %>
+    <small><%= feature.location %></small>
+  </div>
+
+  <% n = n == 'odd' ? 'even' : 'odd' %>
+  <% if feature.scenarios %>
+  <ul>
+    <% feature.scenarios.each_with_index do |scenario,index| %>
+    <li class="<%= n %>">
+      <div class="item" style="padding-left: 45px">
+        <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>
+       </div>
+    </li>
+    <% n = n == 'odd' ? 'even' : 'odd' %>
+    <% end %>
+  </ul>
+  <% end %>
+</li>
+<% end %>

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

@@ -0,0 +1,20 @@
+<li>
+  <div class="item" style="padding-left: 30px">
+    <%= linkify YARD::CodeObjects::Lucid::LUCID_STEPTRANSFORM_NAMESPACE, "All Step Definitions" %>
+  </div>
+</li>
+<% n = 'odd' %>
+<% @items.each do |stepdef| %>
+  <li class="<%= n %>">
+    <div class="item" style="padding-left: 30px">
+      <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>
+    </div>
+  </li>
+  <% n = n == 'even' ? 'odd' : 'even' %>
+<% end %>

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

@@ -0,0 +1,20 @@
+<li class='odd'>
+  <div class="item" style="padding-left: 30px">
+    <%= linkify YARD::CodeObjects::Lucid::LUCID_STEPTRANSFORM_NAMESPACE, "All Defined Steps" %>
+  </div>
+</li>
+<% n = 'even' %>
+<% @items.each do |step| %>
+  <li class="<%= n %>">
+    <div class="item" style="padding-left: 30px">
+      <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>
+    </div>
+  </li>
+  <% n = n == 'even' ? 'odd' : 'even' %>
+<% end %>

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

@@ -0,0 +1,16 @@
+<li>
+  <div class="item" style="padding-left: 30px;">
+    <%= linkify YARD::CodeObjects::Lucid::LUCID_TAG_NAMESPACE, "All Tags" %>
+  </div
+</li>
+
+<% n = 'odd' %>
+<% @items.each do |tag| %>
+  <li class="<%= n %>">
+    <div class="item" style="padding-left: 30px;">
+      <%= linkify tag, tag.value %>
+      <small style="display: inline;"><%= tag.all_scenarios.size %></small>
+    </div>
+  </li>
+  <% n = n == 'odd' ? 'even' : 'odd' %>
+<% end %>

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

@@ -0,0 +1,284 @@
+function lucidKeyboardShortcuts() {
+  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'
+    }
+  });
+}
+
+$(lucidKeyboardShortcuts);
+
+$(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);
+                });
+                $('div.' + eventObject.currentTarget.id + ' a.stepdef').text("[Collapse]")
+            } else {
+                eventObject.currentTarget.innerHTML = '[Expand All]';
+                $('div.' + eventObject.currentTarget.id + ' > div.details:visible').each(function() {
+                    $(this).hide(200);
+                });
+                console.log(eventObject.currentTarget.id);
+                $('div.' + eventObject.currentTarget.id + ' a.stepdef').text('[Expand]');
+            }
+        }
+    });
+
+    $('.stepdef').click(function(eventObject) {
+        if (typeof eventObject.currentTarget !== "undefined") {
+            if (eventObject.currentTarget.innerHTML === '[Expand]') {
+                eventObject.currentTarget.innerHTML = '[Collapse]';
+                $(eventObject.target).parent().parent().parent().find("div.details:hidden").each(function() {
+                    $(this).show(200);
+                });
+            } else {
+                eventObject.currentTarget.innerHTML = '[Expand]';
+                $(eventObject.target).parent().parent().parent().find("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;
+
+        if (tag_list.indexOf(baseTag) === -1) {
+            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]
+                    newTagSelectors.push((selector + ":not(." + tag.replace(/@/g,"\\@") +")").trim());
+                } else {
+                    newTagSelectors.push((selector + "." + tag.replace(/@/g,"\\@")).trim());
+                }
+            });
+        });
+        tagSelectors = newTagSelectors;
+    });
+    return tagSelectors;
+}
+
+
+function createStepDefinitionLinks() {
+    $('.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,199 @@
+include YARD::Templates::Helpers::HtmlHelper
+
+def init
+  super
+
+  # Additional javascript that power the additional menus, collapsing, etc.
+  asset "js/lucid.js", file("js/lucid.js",true)
+
+  serialize_object_type :feature
+
+  serialize_object_type :tag
+
+  # Generates the specifications splash page with the 'specifications' template
+  serialize(YARD::CodeObjects::Lucid::LUCID_NAMESPACE)
+
+  # Generates a page for step definitions and step transforms with the 'steptransformers' template
+  serialize(YARD::CodeObjects::Lucid::LUCID_STEPTRANSFORM_NAMESPACE)
+
+  # Generates the tags page with the 'featuretags' template
+  serialize(YARD::CodeObjects::Lucid::LUCID_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 'features/**/*' 'specs/**/*'`
+def root_feature_directories
+  @root_feature_directories ||= YARD::CodeObjects::Lucid::LUCID_NAMESPACE.children.find_all { |child| child.is_a?(YARD::CodeObjects::Lucid::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::Lucid::FeatureDirectory) })
+  end
+end
+
+# Generate feature list. 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. 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. This menu is not automatically added until
+# yard configuration has this menu added.
+def generate_stepdefinition_list
+  generate_full_list YARD::Registry.all(:stepdefinition), :stepdefinitions,
+    :list_title => "Step Definitions List"
+end
+
+# Generate a step list. This menu is not automatically added until yard
+# configuration has this menu added.
+def generate_step_list
+  generate_full_list YARD::Registry.all(:step), :steps
+end
+
+# Generate feature list. This menu is not automatically added until yard
+# configuration has this menu added.
+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
+
+# This class provides the tree context needed by the server.
+class TreeContext
+  def initialize
+    @depth = 0
+    @even_odd = Alternator.new(:even, :odd)
+  end
+
+  def nest
+    @depth += 1
+    yield
+    @depth -= 1
+  end
+
+  def indent
+    "#{(@depth + 2) * 15}px"
+  end
+
+  def classes
+    classes = []
+    classes << 'collapsed' if @depth > 0
+    classes << @even_odd.next if @depth < 2
+    classes
+  end
+
+  class Alternator
+    def initialize(first, second)
+      @next = first
+      @after = second
+    end
+
+    def next
+      @next, @after = @after, @next
+      @after
+    end
+  end
+end
+
+# This method overrides YARD's default template class_list method.
+#
+# The existing YARD 'Class List' search field contains all the YARD namespace
+# objects. In the context of this parsing, the Lucid Namespace YARD Object is
+# a meta-object, so that should not be considered.
+#
+# 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, tree = TreeContext.new)
+  return super unless root == Registry.root
+
+  lucid_namespace = YARD::CodeObjects::Lucid::LUCID_NAMESPACE
+  root.instance_eval { children.delete lucid_namespace }
+  out = super(root)
+  root.instance_eval { children.push lucid_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 link to the 'Requirements' page.
+#
+# When there are is just one feature directory then link to that directory.
+def all_features_link
+  if root_feature_directories.length == 0 || root_feature_directories.length > 1
+    linkify YARD::CodeObjects::Lucid::LUCID_NAMESPACE, "All Features"
+  else
+    linkify root_feature_directories.first, "All Features"
+  end
+end
+
+# This method is used to generate a feature directory. This template may call
+# this method as well to generate any child feature directories as well.
+def directory_node(directory,padding,row)
+  @directory = directory
+  @padding = padding
+  @row = row
+  erb(:directories)
+end