stepdown 0.5.0 → 0.6.0

data/Gemfile

@@ -5,6 +5,6 @@ gem 'gherkin', '~> 2.3'
 
 group :development,:test do
   gem 'rake'
-  gem 'rspec', '~> 2.5'
+  gem 'rspec', '~> 2.5.0'
   gem 'rcov', '~> 0.9.9'
 end

data/Gemfile.lock

@@ -8,14 +8,14 @@ GEM
     json (1.4.6)
     rake (0.8.7)
     rcov (0.9.9)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.0)
-    rspec-expectations (2.6.0)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+    rspec-mocks (2.5.0)
 
 PLATFORMS
   ruby
@@ -25,4 +25,4 @@ DEPENDENCIES
   haml (> 2.0.0)
   rake
   rcov (~> 0.9.9)
-  rspec (~> 2.5)
+  rspec (~> 2.5.0)

data/History.txt

@@ -1,4 +1,7 @@
-== 0.50 2011-5-17
+== 0.6.0 2011-6
+* Graph for overall statistics
+
+== 0.5.0 2011-5-17
 * Use gherkin gem to parse features
 * Added empty step detection
 * Added unused step count to summary

data/README.rdoc

@@ -1,11 +1,12 @@
-= Step down
+= Stepdown
 Stepdown allows you to see where your most used Cucumber steps are, your unused steps and how they are clustered
 
 == Statistics available
 * Total number of scenarios
 * Total number of steps
+* Number of empty scenarios (scenarios without any steps)
 * Number of steps per scenario
-* Number of unique scenario
+* Number of unique steps per scenario
 * Per step
   * Total usage
   * Number of scenarios
@@ -13,9 +14,15 @@ Stepdown allows you to see where your most used Cucumber steps are, your unused
   * Scenario grouping (number of times used with another step)
 
 == Installation
-Stepdown is available as a ruby gem
+Stepdown is available as a Ruby gem
    gem install stepdown
 
+Or, add the following to your Gemfile
+   gem 'stepdown'
+
 == Usage
+From the root folder of your project. This assumes step definitions are in PROJECT_ROOT/features/step_definitions and feature files are in PROJECT_ROOT/features
+  stepdown
+Or, set the the directory parameters manually
   stepdown --steps <step definition directory> --features <feature file directory>
   e.g. stepdown --steps features/step_definitions --features features

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.fail_on_error = false

data/bin/stepdown

@@ -12,6 +12,7 @@ begin
   options.validate
 
   Stepdown.quiet = options.quiet
+  Stepdown.output_directory = options.output_directory
 
   Stepdown::Analyzer.new(options.steps_dir, options.features_dir, options.reporter).analyse
 

data/lib/stepdown.rb

@@ -2,6 +2,9 @@ require 'stepdown/feature_parser'
 require 'stepdown/step_instance'
 require 'stepdown/html_reporter'
 require 'stepdown/text_reporter'
+require 'stepdown/statistics'
+require 'stepdown/yaml_writer'
+require 'stepdown/graph'
 require 'stepdown/analyzer'
 
 require 'rubygems'
@@ -9,6 +12,6 @@ require 'bundler/setup'
 
 module Stepdown
   class << self
-    attr_accessor :quiet
+    attr_accessor :quiet, :output_directory
   end
 end

data/lib/stepdown/analyzer.rb

@@ -14,9 +14,14 @@ module Stepdown
 
       puts "Performing analysis..." unless Stepdown.quiet
 
-      reporter = reporter(@reporter, scenarios, instance.step_collection)
+      stats = Statistics.new(scenarios, instance.step_collection)
+
+      reporter = reporter(@reporter, stats)
       reporter.output_overview
 
+      Stepdown::YamlWriter.write(stats)
+      Stepdown::Graph.create_graph
+
     end
 
     def process_feature_files(feature_files)
@@ -30,20 +35,17 @@ module Stepdown
       listener.scenarios
     end
 
-    def reporter(type, scenarios, step_collection)
+    def reporter(type, stats)
       case type
         when "html"
-          Stepdown::HTMLReporter.new(scenarios, step_collection)
+          Stepdown::HTMLReporter.new(stats)
         when "text"
-          Stepdown::TextReporter.new(scenarios, step_collection)
+          Stepdown::TextReporter.new(stats)
         when "quiet"
-          Stepdown::Reporter.new(scenarios, step_collection)
+          Stepdown::Reporter.new(stats)
       end
     end
 
-    def step(id)
-      instance.steps.detect{|step| step.id == id}
-    end
 
     def instance
       @instance ||= begin

data/lib/stepdown/graph.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'date'
+module Stepdown
+  class Graph
+    BLUFF_GRAPH_SIZE = "890x400"
+    BLUFF_DEFAULT_OPTIONS = <<-EOS
+      var g = new Bluff.Line('graph', "#{BLUFF_GRAPH_SIZE}");
+      g.theme_37signals();
+      g.tooltips = true;
+      g.title_font_size = "24px"
+      g.legend_font_size = "12px"
+      g.marker_font_size = "10px"
+    EOS
+
+    def self.create_graph
+      stats, labels = collect_stats
+      label_set = {}
+      labels.each_with_index do |label, i|
+        label_set.update({i => label})
+      end
+
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Stepdown';
+        g.data('Total scenarios', [#{stats[:number_scenarios].join(',')}]);
+        g.data('Total steps', [#{stats[:total_steps].join(',')}]);
+        g.data('Total steps per scenario', [#{stats[:steps_per_scenario].join(',')}]);
+        g.data('Total unused steps', [#{stats[:unused_steps].join(',')}]);
+        g.labels = #{label_set.to_json};
+        g.draw();
+      EOS
+
+      File.open(File.join(Stepdown.output_directory, 'stepdown.js'), 'w') do 
+        |f| f << content 
+      end
+    end
+
+    def self.collect_stats
+      stats = Hash.new {|hsh, key| hsh[key] = [] }
+      labels = []
+
+      load_stats.each do |stat_set|
+        stat_set.each{|key, val| stats[key].push val }
+        labels.push(stat_set[:label])
+      end
+
+      [stats, labels]
+    end
+
+    def self.load_stats
+      stat_collection = []
+      Dir.glob("#{Stepdown.output_directory}/*.yml").sort.each do |file_name|
+        stats = Hash.new {|hsh, key| hsh[key] = [] }
+        file = File.open(file_name)
+        stat_set = YAML::load(file)
+
+        stat_set.each do |key, val|
+          stats[key].push(val)
+        end
+        stats[:label] = date_from_file_name(file_name)
+        stat_collection << stats
+
+        file.close
+      end
+
+      stat_collection
+    end
+
+    def self.date_from_file_name(file_name)
+      label_date = Date.strptime(file_name.match(/(\d+)/)[1], "%Y%m%d")
+      "#{label_date.day} / #{label_date.month}"
+    end
+
+  end
+end

data/lib/stepdown/html_reporter.rb

@@ -8,33 +8,33 @@ module Stepdown
 
     def output_overview()
       puts "Generating report..." unless Stepdown.quiet
-      FileUtils.mkdir_p(Reporter::OUTPUT_DIR)
+      FileUtils.mkdir_p(Stepdown.output_directory)
       copy_files
 
       template = File.open(File.expand_path(File.dirname(__FILE__)) + '/../../templates/main.html.haml').read()
       engine = Haml::Engine.new(template)
 
-      out = File.new(Reporter::OUTPUT_DIR + '/analysis.html','w+')
+      out = File.new(Stepdown.output_directory + '/analysis.html','w+')
       out.puts engine.render(self)
       out.close
 
       template = File.open(File.expand_path(File.dirname(__FILE__))  + '/../../templates/style.sass').read
       sass_engine = Sass::Engine.new(template)
 
-      out = File.new(Reporter::OUTPUT_DIR + '/style.css', 'w+')
+      out = File.new(Stepdown.output_directory + '/style.css', 'w+')
       out.puts sass_engine.render
 
       out.close
 
-      puts "\nReport output to #{Reporter::OUTPUT_DIR}/analysis.html" unless Stepdown.quiet
+      puts "\nReport output to #{Stepdown.output_directory}/analysis.html" unless Stepdown.quiet
     end
 
     protected
 
     def copy_files
-      ['step_down.js', 'jquery-1.4.3.min.js'].each do |file|
+      ['step_down.js', 'jquery-1.4.3.min.js', 'bluff-min.js', 'excanvas.js', 'js-class.js'].each do |file|
         src = File.expand_path("#{File.dirname(__FILE__)}/../../public/#{file}")
-        FileUtils.cp(src, File.join(OUTPUT_DIR, "#{file}"))
+        FileUtils.cp(src, File.join(Stepdown.output_directory, "#{file}"))
       end
     end
   end

data/lib/stepdown/options.rb

@@ -2,7 +2,7 @@ require 'optparse'
 
 module Stepdown
   class Options
-    attr_reader :steps_dir, :features_dir, :reporter, :quiet
+    attr_reader :steps_dir, :features_dir, :reporter, :quiet, :output_directory
 
     OUTPUT_FORMATS = ["html", "text", "quiet"]
 
@@ -11,8 +11,12 @@ module Stepdown
       @features_dir = "features"
       @reporter = "html"
       @quiet = false
+      @output_directory = "./stepdown"
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: stepdown step_definition_dir feature_file_directory"
+        opts.banner = <<-USE 
+        Usage: stepdown
+               stepdown --steps <STEP_DEFINITION_DIRECTORY> --features <FEATURE_FILE_DIRECTORY>
+        USE
 
         opts.separator("")
 

data/lib/stepdown/reporter.rb

@@ -2,114 +2,15 @@ require 'stepdown/step_group'
 require 'stepdown/step_usage'
 
 module Stepdown
-  class Reporter
-    OUTPUT_DIR = "./stepdown"
-
-    attr_reader :scenarios, :usages, :step_collection, :grouping
-
-    def initialize(scenarios, step_collection)
-      @scenarios = scenarios
-      @step_collection = step_collection
-    end
-
-    def groupings
-      @groupings ||= grouping(@scenarios)
-    end
-
-    def total_scenarios
-      @scenarios.length
-    end
-
-    def total_steps
-      @step_collection.length
-    end
-
-    def steps_per_scenario
-      steps_scenario(@scenarios)
-    end
-
-    def unique_steps
-      uniq_steps_per_scenario(@scenarios)
-    end
-
-    def grouping(scenarios)
-      step_groups = @step_collection.collect{|step| Stepdown::StepGroup.new(step) }
-
-      step_groups.each do |step_group|
-        scenarios.each do |scenario|
-
-          if scenario.steps.any?{|step| step.id == step_group.id}
-            step_group.add_steps(scenario.steps)
-            step_group.update_use_count(scenario.step_count)
-          end
-        end
-
-      end
-      step_groups.sort{|a,b| b.use_count <=> a.use_count}
-    end
-
-    def step_usage(scenarios)
-      usages = @step_collection.collect{|step| Stepdown::StepUsage.new(step) }
-      scenarios.each do |scenario|
-
-        scenario.steps.each do |step|
-          usage = usages.detect{|use| use.step.id == step.id}
-          if usage
-            usage.total_usage += step.count
-            usage.number_scenarios += 1
-          end
-        end
-      end
-
-      usages.each do |usage|
-        if usage.number_scenarios > 0
-          use = sprintf "%.2f", (usage.total_usage / Float(usage.number_scenarios))
-          usage.use_scenario = use
-        end
-      end
-
-      usages.sort{|a,b| b.total_usage <=> a.total_usage}
-    end
-
-    def step_usages
-      @step_usages ||= step_usage(@scenarios)
-    end
-
-    def usages
-      step_usages.select{|use| use.total_usage > 0 }
-    end
-
-    def unused_steps
-      step_usages.select{|use| use.total_usage == 0}
-    end
-
-    def unused_step_count
-      unused_steps.length
-    end
-
-    def uniq_steps_per_scenario(scenarios)
-      total_steps = 0.0
-      uniq_steps = 0.0
-      scenarios.each do |scen|
-        total_steps += scen.step_count
-        uniq_steps += scen.unique_step_count
-      end
-      sprintf "%.2f", (total_steps / uniq_steps)
-    end
-
-    def steps_scenario(scenarios)
-      scen_count = scenarios.length
-      step_count = 0.0
-      scenarios.each do |scenario|
-        step_count += scenario.step_count
-      end
-      sprintf "%.2f", (step_count / scen_count)
+  class Reporter < Delegator
+    
+    def initialize(statistics)
+      @statistics = statistics
+      super @statistics
     end
 
-    def empty_scenarios
-      @scenarios.select do |scen|
-        scen.steps.empty?
-      end
+    def __getobj__
+      @statistics  
     end
 
   end

data/lib/stepdown/statistics.rb

@@ -0,0 +1,120 @@
+
+module Stepdown
+  class Statistics
+    attr_reader :scenarios, :usages, :step_collection, :grouping
+
+    def initialize(scenarios, step_collection)
+      @scenarios = scenarios
+      @step_collection = step_collection
+    end
+
+    def to_h
+      stats = {}
+      stats[:number_scenarios] = total_scenarios
+      stats[:total_steps] = total_steps
+      stats[:steps_per_scenario] = steps_per_scenario
+      stats[:unused_steps] = unused_step_count
+      stats
+    end
+
+    def groupings
+      @groupings ||= grouping(@scenarios)
+    end
+
+    def total_scenarios
+      @scenarios.length
+    end
+
+    def total_steps
+      @step_collection.length
+    end
+
+    def steps_per_scenario
+      steps_scenario(@scenarios)
+    end
+
+    def unique_steps
+      uniq_steps_per_scenario(@scenarios)
+    end
+
+    def grouping(scenarios)
+      step_groups = @step_collection.collect{|step| Stepdown::StepGroup.new(step) }
+
+      step_groups.each do |step_group|
+        scenarios.each do |scenario|
+
+          if scenario.steps.any?{|step| step.id == step_group.id}
+            step_group.add_steps(scenario.steps)
+            step_group.update_use_count(scenario.step_count)
+          end
+        end
+
+      end
+      step_groups.sort{|a,b| b.use_count <=> a.use_count}
+    end
+
+    def step_usage(scenarios)
+      usages = @step_collection.collect{|step| Stepdown::StepUsage.new(step) }
+      scenarios.each do |scenario|
+
+        scenario.steps.each do |step|
+          usage = usages.detect{|use| use.step.id == step.id}
+          if usage
+            usage.total_usage += step.count
+            usage.number_scenarios += 1
+          end
+        end
+      end
+
+      usages.each do |usage|
+        if usage.number_scenarios > 0
+          use = sprintf "%.2f", (usage.total_usage / Float(usage.number_scenarios))
+          usage.use_scenario = use
+        end
+      end
+
+      usages.sort{|a,b| b.total_usage <=> a.total_usage}
+    end
+
+    def step_usages
+      @step_usages ||= step_usage(@scenarios)
+    end
+
+    def usages
+      step_usages.select{|use| use.total_usage > 0 }
+    end
+
+    def unused_steps
+      step_usages.select{|use| use.total_usage == 0}
+    end
+
+    def unused_step_count
+      unused_steps.length
+    end
+
+    def uniq_steps_per_scenario(scenarios)
+      total_steps = 0.0
+      uniq_steps = 0.0
+      scenarios.each do |scen|
+        total_steps += scen.step_count
+        uniq_steps += scen.unique_step_count
+      end
+      sprintf "%.2f", (total_steps / uniq_steps)
+    end
+
+    def steps_scenario(scenarios)
+      scen_count = scenarios.length
+      step_count = 0.0
+      scenarios.each do |scenario|
+        step_count += scenario.step_count
+      end
+      sprintf "%.2f", (step_count / scen_count)
+    end
+
+    def empty_scenarios
+      @scenarios.select do |scen|
+        scen.steps.empty?
+      end
+    end
+  end
+end