cuporter 0.1.1 → 0.2.0

data/README.textile

@@ -1,44 +1,47 @@
 h1. Cuporter
 
-Scrapes your feature files and shows scenarios per tag, with their context.  Formats Pretty Text, HTML and CSV.
+Scrapes your feature files and shows scenarios per tag, with their context.  Formats HTML, CSV, and Pretty Text.
 
 Consider this a stop-gap until we get this functionality in a proper cucumber formatter.
 
+In version 0.2.0 and later you can number the Scenarios and Example rows with the @-n@ or @--numbers@ option.
+
 ---------
-h3. Example Output
+h3. Example Output: numbered pretty text
 
 <pre>
 @failing
-  Feature: Abominable Aardvark
-    Scenario: An Aardvark eats ants
-    Scenario: Zee Zebra eats zee aardvark
-  Feature: Wired
-    Scenario: Everybody's Wired
-    Scenario Outline: Why is everybody so wired?
-      Examples: loosely wired
-        | arg1 | arg2 |
-        | foo  | bar  |
-        | shif | fish |
-      Examples: tightly wired
-        | name  | value |
-        | foo   | bar   |
-        | frotz | knurl |
+   Feature: Abominable Aardvark
+   1. Scenario: An Aardvark eats ants
+   2. Scenario: Zee Zebra eats zee aardvark
+   Feature: Wired
+   3. Scenario: Everybody's Wired
+      Scenario Outline: Why is everybody so wired?
+         Examples: loosely wired
+            | arg1 | arg2 |
+   4.       | foo  | bar  |
+   5.       | shif | fish |
+         Examples: tightly wired
+            | arg1  | arg2  |
+   6.       | foo   | bar   |
+   7.       | frotz | knurl |
+   8. Scenario: Yellow lines
 @ignore
-  Feature: Wired
-    Scenario Outline: Why is everybody so wired?
-      Examples: tightly wired
-        | name  | value |
-        | foo   | bar   |
-        | frotz | knurl |
+   Feature: Wired
+      Scenario Outline: Why is everybody so wired?
+         Examples: tightly wired
+            | arg1  | arg2  |
+   1.       | foo   | bar   |
+   2.       | frotz | knurl |
 @wip
-  Feature: HTML formatter
-    Scenario: Everything in fixtures/self_test
-  Feature: not everyone is involved
-    Scenario: Failure is not an option, people
-  Feature: sample
-    Scenario: And yet another Example
-  Feature: search examples
-    Scenario: Generate PDF with pdf formatter
+   Feature: HTML formatter
+   1. Scenario: Everything in fixtures/self_test
+   Feature: not everyone is involved
+   2. Scenario: Failure is not an option, people
+   Feature: sample
+   3. Scenario: And yet another Example
+   Feature: search examples
+   4. Scenario: Generate PDF with pdf formatter
 
 </pre>
 
@@ -70,14 +73,18 @@ h4. help
   
       -f, --format [pretty|html|csv]   Output format
   					Default: pretty text
+
+      -n, --numbers                    number scenarios and examples
 </pre>
 
 h4. run script directly
 
 <pre>
-  $ ./bin/cuporter.rb -i fixtures/self_text               # pretty-print demo report to stdout
+  $ ./bin/cuporter.rb -i fixtures/self_text                         # pretty-print demo report to stdout
+
+  $ ./bin/cuporter.rb -f html -o feature_tag_report.html            # default input features/**/*.feature to named output file
 
-  $ ./bin/cuporter.rb -f html -o feature_tag_report.html  # default input features/**/*.feature to named output file
+  $ ./bin/cuporter.rb -f html --numbers -o feature_tag_report.html  # same, but number the scenarios and example rows
 </pre>
 
 h4. run via rake

data/Rakefile

@@ -56,7 +56,7 @@ namespace :cuporter do
 
   spec = Gem::Specification.new do |s|
     s.name = 'cuporter'
-    s.version = '0.1.1'
+    s.version = '0.2.0'
     s.rubyforge_project = s.name
 
     s.platform = Gem::Platform::RUBY

data/bin/cuporter

@@ -6,4 +6,6 @@ require 'cuporter'
 tag_report = Cuporter::TagReport.new(Cuporter::Options[:input_file] || Cuporter::Options[:input_dir])
 
 formatter = Cuporter::Formatters.const_get(Cuporter::Options[:format])
-formatter.new(tag_report.scenarios_per_tag, Cuporter::Options[:output]).write
+formatter.new(tag_report.scenarios_per_tag,
+              Cuporter::Options[:output],
+              Cuporter::Options[:numbers]).write

data/lib/cuporter/cli/options.rb

@@ -38,6 +38,9 @@ module Cuporter
         end
         @options[:format] ||= :Text
         
+        opts.on("-n", "--numbers", "number scenarios and examples") do |n|
+          @options[:numbers] = n
+        end
       end.parse!
 
 

data/lib/cuporter/example_set_node.rb

@@ -0,0 +1,19 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  class ExampleSetNode < TagListNode
+
+    def initialize(name, tags)
+      super(name, tags)
+    end
+
+    def sort!
+      # no op
+    end
+
+    def add_child(node)
+      node.numerable = false unless has_children? #first row ( arg list header)
+      super(node)
+    end
+
+  end
+end

data/lib/cuporter/feature_parser.rb

@@ -45,7 +45,7 @@ module Cuporter
         when EXAMPLE_SET_LINE, SCENARIO_SET_LINE
           @scenario_outline.add_to_tag_nodes(@example_set) if @example_set
 
-          @example_set = NonSortingNode.new($1, @feature.tags | @current_tags)
+          @example_set = ExampleSetNode.new($1, @feature.tags | @current_tags)
           @current_tags = []
         when EXAMPLE_LINE
           @example_set.add_child(Node.new($1))

data/lib/cuporter/formatters/csv.rb

@@ -4,7 +4,14 @@ module Cuporter
     class Csv < Writer
       include TextMethods
       
-      TAB = ","
+      def tab
+        ","
+      end
+
+      def line(number, line)
+        line.sub!(/^#{tab}/, "#{number}#{tab}") if number
+        line
+      end
 
     end
   end

data/lib/cuporter/formatters/html.rb

@@ -7,10 +7,11 @@ module Cuporter
   module Formatters
     class Html < Writer
 
-      NODE_CLASS = [:tag, :feature, :scenario, :example_set]
+      NODE_CLASS = [:tag, :feature, :scenario, :example_set, :example]
 
       def write_nodes
-        @report.sort.children.each do |tag_node|
+        @report.children.each do |tag_node|
+          tag_node.number_all_descendants if @number_scenarios
           write_node(tag_node, 0)
         end
         builder
@@ -22,14 +23,19 @@ module Cuporter
 
       def write_node(node, indent_level)
         builder.li(:class => NODE_CLASS[indent_level]) do |list_item|
-          list_item.span(node.name, :class => "#{NODE_CLASS[indent_level]}_name")
+          list_item.span("#{node.number}.", :class => :number) if node.number
+          list_item.span(node.name, :class => "#{NODE_CLASS[indent_level]}_name" )
+
           if node.has_children?
             list_item.ul(:class => "#{NODE_CLASS[indent_level]}_children") do |list|
-              node.sort.children.each do |child|
+              node.children.each do |child|
                 if child.has_children?
                   write_node(child, indent_level + 1)
                 else
-                  list.li(child.name, :class => "#{NODE_CLASS[indent_level + 1]}_name")
+                  list.li() do |item|
+                    item.span("#{child.number}.", :class => :number) if child.number
+                    item.span(child.name, :class => "#{NODE_CLASS[indent_level + 1]}_name")
+                  end
                 end
               end
             end

data/lib/cuporter/formatters/text.rb

@@ -4,7 +4,19 @@ module Cuporter
     class Text < Writer
       include TextMethods
 
-      TAB = "  "
+      def tab
+        @tab ||= @number_scenarios ? "   " : "  "
+      end
+
+      COL_WIDTH = 5
+      def line(number, line)
+        if @number_scenarios
+          number_string = number ? "#{number}." : ""
+          number_field = number_string.rjust(COL_WIDTH, " ")
+          line.sub!(/^\s{#{COL_WIDTH}}/, number_field)
+        end
+        line
+      end
 
     end
   end

data/lib/cuporter/formatters/text_methods.rb

@@ -4,25 +4,23 @@ module Cuporter
     module TextMethods
     
       def write
-        @report.sort.children.each do |tag_node|
+        @report.children.each do |tag_node|
+          tag_node.number_all_descendants if @number_scenarios
           write_node(tag_node, 0)
         end
       end
 
       def write_node(node, tab_stops)
-        @output.puts "#{self.class::TAB * tab_stops}#{node.name}"
-        node.sort.children.each do |child|
-          @output.puts "#{self.class::TAB + (self.class::TAB * tab_stops)}#{child.name}"
-          child.sort.children.each do |grand_child|
-            if grand_child.has_children?
-              write_node(grand_child, tab_stops + 2)
-            else
-              @output.puts "#{self.class::TAB * tab_stops}#{self.class::TAB * 2}#{grand_child.name}"
-            end
+        @output.puts line(node.number, "#{tab * tab_stops}#{node.name}")
+        node.children.each do |child|
+          if child.has_children?
+            write_node(child, tab_stops + 1)
+          else
+            @output.puts line(child.number, "#{tab * tab_stops}#{tab }#{child.name}")
           end
         end
       end
-    
+
     end
   end
 end

data/lib/cuporter/formatters/writer.rb

@@ -4,13 +4,10 @@ module Cuporter
   module Formatters
     class Writer
 
-      def initialize(report, output)
+      def initialize(report, output, number_scenarios)
         @report = report
-        if output
-          @output = File.open(output, "w")
-        else
-          @output = STDOUT
-        end
+        @output = output ? File.open(output, "w") : STDOUT
+        @number_scenarios = number_scenarios
       end
     end
   end

data/lib/cuporter/node.rb

@@ -4,9 +4,10 @@ module Cuporter
     include Comparable
 
     attr_reader :name, :children
+    attr_accessor :number
 
     def initialize(name)
-      @name = name.strip
+      @name = name.to_s.strip
       @children = []
     end
 
@@ -19,6 +20,10 @@ module Cuporter
       @children << node unless has_child?(node)
     end
 
+    def names
+      children.collect {|c| c.name }
+    end
+
     def find_or_create_child(name)
       child_node = self[name]
       unless child_node
@@ -42,9 +47,13 @@ module Cuporter
       @name_without_title ||= name.split(/:\s+/).last
     end
 
-    def sort
+    def sort_all_descendants!
+      sort!
+      children.each {|child| child.sort_all_descendants! }
+    end
+
+    def sort!
       children.sort!
-      self
     end
 
     # sort on name or substring of name after any ':'
@@ -73,5 +82,20 @@ module Cuporter
       end
     end
 
+    def total
+      number_all_descendants unless @numberer
+      @numberer.total
+    end
+
+    def number_all_descendants
+      @numberer = NodeNumberer.new
+      @numberer.number(self)
+    end
+
+    def numerable?
+      @numerable.nil? ? !has_children? : @numerable
+    end
+    attr_writer :numerable
+
   end
 end

data/lib/cuporter/node_numberer.rb

@@ -0,0 +1,18 @@
+module Cuporter
+  class NodeNumberer
+    
+    attr_reader :total
+
+    def initialize
+      @total = 0
+    end
+
+    def number(node)
+      node.children.each do |child|
+        child.number = @total += 1 if child.numerable?
+        number(child)
+      end
+    end
+
+  end
+end

data/lib/cuporter/tag_report.rb

@@ -16,6 +16,7 @@ module Cuporter
         content = File.read(file)
         tags.merge(FeatureParser.parse(content)) unless content.empty?
       end
+      tags.sort_all_descendants!
       tags
     end
 

data/lib/cuporter.rb

@@ -1,7 +1,8 @@
 # Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
 require 'cuporter/node'
 require 'cuporter/tag_list_node'
-require 'cuporter/non_sorting_node'
+require 'cuporter/example_set_node'
+require 'cuporter/node_numberer'
 require 'cuporter/feature_parser'
 require 'cuporter/extensions/string'
 require 'cuporter/cli/options'

data/spec/cuporter/example_set_node_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cuporter
+  describe ExampleSetNode do
+    context 'empty' do
+      it 'raises no error when numbering' do
+        node = ExampleSetNode.new("Scenarios: stuff", [])
+        expect do
+          node.number_all_descendants
+        end.to_not raise_error
+        node.total.should == 0
+      end
+    end
+
+    context 'with children' do
+      it 'does not count first or "header" row' do
+        node = ExampleSetNode.new("Scenarios: stuff", [])
+        node.add_child(Node.new("|col1|col2|"))
+        node.add_child(Node.new("|val1|val2|"))
+
+        node.number_all_descendants
+        node.children.first.number.should be_nil
+        node.children.last.number.should == 1
+      end
+    end
+  end
+end

data/spec/cuporter/node_numberer_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Cuporter
+  describe NodeNumberer do
+    context '#number' do
+      let(:root) {Node.new("root")} 
+      let(:numberer) { NodeNumberer.new}
+
+      before(:each) do
+        root.add_child(Node.new("child_1"))
+        root.add_child(Node.new("child_2"))
+      end
+
+      it 'does not add number to root node' do
+        numberer.number(root)
+
+        root.number.should be_nil
+      end
+
+      it 'adds a number to both children' do
+       numberer.number(root)
+
+        root[:child_1].number.should == 1
+        root[:child_2].number.should == 2
+      end
+
+      it 'does not add a number to children with children' do
+        root[:child_1].add_child(Node.new("grandbaby"))
+
+        numberer.number(root)
+
+        root[:child_1].number.should be_nil
+        root[:child_2].number.should == 2
+      end
+
+      it 'numbers child and grandchild in same sequence' do
+        root[:child_1].add_child(Node.new("grandbaby"))
+
+        numberer.number(root)
+
+        root[:child_1][:grandbaby].number.should == 1
+        root[:child_2].number.should             == 2
+      end
+
+      context '2 children, 1 grandchild, and 2 great-grandchildren' do
+        before(:each) do
+          root[:child_2].add_child(Node.new("grandbaby"))
+          root.add_child(Node.new(:child_3))
+          child_4 = Node.new(:child_4)
+          child_4.add_child(Node.new(:grandchild))
+          child_4[:grandchild].add_child(Node.new(:great_grandchild_1))
+          child_4[:grandchild].add_child(Node.new(:great_grandchild_2))
+          root.add_child(child_4)
+        end
+
+        it 'numbers the leaf nodes' do
+          numberer.number(root)
+
+          root.number.should be_nil
+          root[:child_1].number.should == 1
+          root[:child_2].number.should be_nil
+          root[:child_3].number.should == 3
+          root[:child_4].number.should be_nil
+
+          root[:child_2][:grandbaby].number.should == 2
+          root[:child_4][:grandchild].number.should be_nil
+          root[:child_4][:grandchild][:great_grandchild_1].number.should == 4
+          root[:child_4][:grandchild][:great_grandchild_2].number.should == 5
+        end
+
+        it 'keeps total' do
+          numberer.total.should == 0
+          numberer.number(root)
+          numberer.total.should == 5
+        end
+      end
+    end
+
+  end
+end

data/spec/cuporter/node_spec.rb

@@ -51,5 +51,31 @@ module Cuporter
         n1.should == n2
       end
     end
+
+    context 'numbering' do
+      let(:node) {Node.new(:node)}
+      it 'can number itself' do
+        expect do
+          node.number_all_descendants
+        end.to_not raise_error()
+      end
+
+      it 'gets a leaf count' do
+        node.number_all_descendants
+        node.total.should == 0
+      end
+
+      it 'can number itself with a child' do
+        node.add_child(Node.new(:child))
+        node.number_all_descendants
+        node.total.should == 1
+        node[:child].number.should == 1
+      end
+
+      it 'can get count from child' do
+        node.add_child(Node.new(:child))
+        node[:child].total.should == 0
+      end
+    end
   end
 end

data/spec/cuporter/sort_node_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+module Cuporter
+  describe Node do
+    context 'sorting' do
+      it 'defaults to order of addition' do
+        root = Node.new('root')
+        root.add_child(Node.new('zebra'))
+        root.add_child(Node.new('aardvark'))
+
+        root.names.should == %w[zebra aardvark]
+      end
+
+      it 'sorts direct descendants' do
+        root = Node.new('root')
+        root.add_child(Node.new('zebra'))
+        root.add_child(Node.new('aardvark'))
+
+        root.sort_all_descendants!
+        root.names.should == %w[aardvark zebra]
+      end
+
+      it 'sorts all descendants to an arbitrary depth, such as 6' do
+        root = Node.new('root')
+        zebra  = Node.new("zebra")
+        apple  = Node.new("apple")
+        zebra1 = Node.new("zebra1")
+        apple1 = Node.new("apple1")
+        zebra2 = Node.new("zebra2")
+        apple2 = Node.new("apple2")
+        zebra3 = Node.new("zebra3")
+        apple3 = Node.new("apple3")
+        zebra4 = Node.new("zebra4")
+        apple4 = Node.new("apple4")
+        zebra5 = Node.new("zebra5")
+        apple5 = Node.new("apple5")
+        
+        zebra4.add_child(zebra5)
+        zebra4.add_child(apple5)
+        apple4.add_child(zebra5)
+        apple4.add_child(apple5)
+
+        zebra3.add_child(zebra4)
+        zebra3.add_child(apple4)
+        apple3.add_child(zebra4)
+        apple3.add_child(apple4)
+
+        zebra2.add_child(zebra3)
+        zebra2.add_child(apple3)
+        apple2.add_child(zebra3)
+        apple2.add_child(apple3)
+
+        zebra1.add_child(zebra2)
+        zebra1.add_child(apple2)
+        apple1.add_child(zebra2)
+        apple1.add_child(apple2)
+
+        zebra.add_child(zebra1)
+        zebra.add_child(apple1)
+        apple.add_child(zebra1)
+        apple.add_child(apple1)
+
+        root.add_child(zebra)
+        root.add_child(apple)
+
+        root.sort_all_descendants!
+        root.names.should == %w[apple zebra]
+        gen_1 = %w[apple1 zebra1]
+        root[:apple].names.should == gen_1
+        root[:zebra].names.should == gen_1
+
+        gen_2 = %w[apple2 zebra2]
+        root[:apple][:apple1].names.should == gen_2
+        root[:apple][:zebra1].names.should == gen_2
+        root[:zebra][:apple1].names.should == gen_2
+        root[:zebra][:zebra1].names.should == gen_2
+
+        gen_3 = %w[apple3 zebra3]
+        root[:apple][:apple1][:apple2].names.should == gen_3
+        root[:apple][:apple1][:zebra2].names.should == gen_3
+        root[:apple][:zebra1][:apple2].names.should == gen_3
+        root[:apple][:zebra1][:zebra2].names.should == gen_3
+        root[:zebra][:apple1][:apple2].names.should == gen_3
+        root[:zebra][:apple1][:zebra2].names.should == gen_3
+        root[:zebra][:zebra1][:apple2].names.should == gen_3
+        root[:zebra][:zebra1][:zebra2].names.should == gen_3
+
+        gen_4 = %w[apple4 zebra4]
+        root[:apple][:apple1][:apple2][:apple3].names.should == gen_4
+        root[:apple][:apple1][:apple2][:zebra3].names.should == gen_4
+        root[:apple][:apple1][:zebra2][:apple3].names.should == gen_4
+        root[:apple][:apple1][:zebra2][:zebra3].names.should == gen_4
+
+        root[:apple][:zebra1][:apple2][:apple3].names.should == gen_4
+        root[:apple][:zebra1][:apple2][:zebra3].names.should == gen_4
+        root[:apple][:zebra1][:zebra2][:apple3].names.should == gen_4
+        root[:apple][:zebra1][:zebra2][:zebra3].names.should == gen_4
+
+        root[:zebra][:apple1][:apple2][:apple3].names.should == gen_4
+        root[:zebra][:apple1][:apple2][:zebra3].names.should == gen_4
+        root[:zebra][:apple1][:zebra2][:apple3].names.should == gen_4
+        root[:zebra][:apple1][:zebra2][:zebra3].names.should == gen_4
+
+        root[:zebra][:zebra1][:apple2][:apple3].names.should == gen_4
+        root[:zebra][:zebra1][:apple2][:zebra3].names.should == gen_4
+        root[:zebra][:zebra1][:zebra2][:apple3].names.should == gen_4
+        root[:zebra][:zebra1][:zebra2][:zebra3].names.should == gen_4
+
+        gen_5 = %w[apple5 zebra5]
+        root[:apple][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:apple][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:apple][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:apple][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:apple][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+
+
+        root[:zebra][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:apple2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:zebra][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:apple1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:zebra][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:apple2][:zebra3][:zebra4].names.should == gen_5
+
+        root[:zebra][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:apple3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:apple3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:zebra3][:apple4].names.should == gen_5
+        root[:zebra][:zebra1][:zebra2][:zebra3][:zebra4].names.should == gen_5
+
+      end
+
+    end
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Tim Camper
@@ -31,7 +31,7 @@ files:
 - LICENSE
 - README.textile
 - Rakefile
-- lib/cuporter/non_sorting_node.rb
+- lib/cuporter/example_set_node.rb
 - lib/cuporter/formatters/csv.rb
 - lib/cuporter/formatters/text.rb
 - lib/cuporter/formatters/html.rb
@@ -42,11 +42,15 @@ files:
 - lib/cuporter/extensions/string.rb
 - lib/cuporter/feature_parser.rb
 - lib/cuporter/node.rb
+- lib/cuporter/node_numberer.rb
 - lib/cuporter/tag_report.rb
 - lib/cuporter.rb
 - spec/cuporter/node_spec.rb
+- spec/cuporter/sort_node_spec.rb
 - spec/cuporter/feature_parser_spec.rb
 - spec/cuporter/support/functional/cli.rb
+- spec/cuporter/node_numberer_spec.rb
+- spec/cuporter/example_set_node_spec.rb
 - spec/cuporter/functional/scenario_outlines_spec.rb
 - spec/cuporter/functional/single_feature_spec.rb
 - spec/cuporter/tag_list_node_spec.rb

data/lib/cuporter/non_sorting_node.rb

@@ -1,16 +0,0 @@
-# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
-module Cuporter
-  class NonSortingNode < Node
-    attr_reader :tags
-
-    def initialize(name, tags)
-      super(name)
-      @tags = tags
-    end
-
-    def sort
-      self
-    end
-
-  end
-end