stepdown-patched 0.6.3.1patched

data/lib/stepdown/reporter.rb

@@ -0,0 +1,23 @@
+require 'stepdown/step_group'
+require 'stepdown/step_usage'
+require 'delegate'
+
+module Stepdown
+  class Reporter < Delegator
+    
+    def initialize(statistics)
+      @statistics = statistics
+      super @statistics
+    end
+
+    def __getobj__
+      @statistics  
+    end
+
+    def __setobj__(statistics)
+      @statistics = statistics
+    end
+
+  end
+end
+

data/lib/stepdown/scenario.rb

@@ -0,0 +1,26 @@
+require 'stepdown/step_collection'
+
+module Stepdown
+  class Scenario
+    attr_reader :step_count, :name
+    def initialize(name)
+      @step_collection = Stepdown::StepCollection.new
+      @step_count = 0
+      @name = name
+    end
+
+    def add_step(step)
+      @step_count += 1
+      @step_collection.add_step(step.id, step.regex)
+    end
+
+    def steps
+      @step_collection.steps
+    end
+
+    def unique_step_count
+      @step_collection.length
+    end
+
+  end
+end

data/lib/stepdown/statistics.rb

@@ -0,0 +1,162 @@
+
+module Stepdown
+  class Statistics
+    attr_reader :scenarios, :usages, :step_collection, :grouping
+
+    def initialize(scenarios, step_collection)
+      @scenarios = scenarios
+      @step_collection = step_collection
+    end
+
+    def generate
+      puts "Performing analysis..." unless Stepdown.quiet
+      groupings
+      step_usages
+      empty
+      steps_per_scenario
+      unique_steps
+    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_rest
+      groupings[10..groupings.length]
+    end
+
+    def groupings_top(limit = 10)
+      groupings[0...limit]
+    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_per_scenario ||= steps_scenario(@scenarios)
+    end
+
+    def unique_steps
+      @uniq_steps_per_scenario ||= 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 usages_top(limit = 10)
+      usages[0...limit]
+    end
+
+    def usages_rest
+      usages[10..usages.length]
+    end
+
+    def step_usages
+      @step_usages ||= step_usage(@scenarios)
+    end
+
+    def usages
+      step_usages.select{|use| use.total_usage > 0 }
+    end
+
+    def unused_rest
+      unused[10..unused.length]
+    end
+
+    def unused_top(limit = 10)
+      unused[0...limit]
+    end
+
+    def unused
+      step_usages.select{|use| use.total_usage == 0}
+    end
+
+    def unused_step_count
+      unused.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_rest
+      empty[10..empty.length] || []
+    end
+
+    def empty_top(limit = 10)
+      empty[0...limit]
+    end
+
+    def empty
+      @empty_scenarios ||= @scenarios.select do |scen|
+        scen.steps.empty?
+      end
+      @empty_scenarios
+    end
+  end
+end

data/lib/stepdown/step.rb

@@ -0,0 +1,22 @@
+module Stepdown
+  class Step
+
+    attr_accessor :count
+    attr_reader :id, :regex
+
+    def initialize(id, regex)
+      @id = id
+      @regex = regex
+      @count = 0
+    end
+
+    def <=>(other)
+      other.count <=> self.count
+    end
+
+    def ==(other)
+      self.id == other.id
+    end
+
+  end
+end

data/lib/stepdown/step_collection.rb

@@ -0,0 +1,36 @@
+require 'stepdown/step'
+
+module Stepdown
+  class StepCollection
+    include Enumerable
+
+    def initialize
+      @steps = {}
+    end
+
+    def add_step(id, regex)
+      if @steps[id]
+        @steps[id].count += 1
+      else
+        @steps[id] = Stepdown::Step.new(id, regex)
+        @steps[id].count = 1
+      end
+    end
+
+    def steps
+      @steps.collect{|id,step| step }
+    end
+
+    def each
+      @steps.each{|id, step| yield step }
+    end
+
+    def [](id)
+      @steps[id]
+    end
+
+    def length
+      @steps.length
+    end
+  end
+end

data/lib/stepdown/step_group.rb

@@ -0,0 +1,45 @@
+require 'cgi'
+require 'stepdown/step_collection'
+
+module Stepdown
+  class StepGroup
+    attr_reader :id, :regex, :use_count
+
+    def initialize(step)
+      @id = step.id
+      @regex = step.regex
+      @use_count = 0
+      @step_collection = Stepdown::StepCollection.new
+    end
+
+    def step_collection
+      @step_collection.sort
+    end
+
+    def add_step(step)
+      @step_collection.add_step(step.id, step.regex)
+    end
+
+    def add_steps(step_set)
+      step_set.each{|step| add_step(step)}
+    end
+
+    def update_use_count(num_steps)
+      @use_count += num_steps
+    end
+
+    def group_graph
+      base = "https://chart.googleapis.com/chart?cht=gv:dot&chl=graph{"
+      base += "a [label=\"#{CGI.escape(CGI.escapeHTML(@regex.inspect.to_s))}\"];"
+
+      step_collection[0..10].each do |step|
+
+        next if step.regex.nil?
+        base += "a--\"#{CGI.escape(CGI.escapeHTML(step.regex.inspect.to_s))}\" [weight=#{step.count}];"
+        #a [label=\"#{grouping.in_steps[0][:step].regex.inspect}\"]; a--b [penwidth=3,weight=2];b--d}"
+      end
+      base += "}"
+      base
+    end
+  end
+end

data/lib/stepdown/step_instance.rb

@@ -0,0 +1,63 @@
+require 'stepdown/step_collection'
+
+module Stepdown
+  class StepInstance
+    def initialize
+      @steps = []
+    end
+
+    def Given(regex,&block)
+      define_step(regex,&block)
+    end
+
+    def When(regex,&block)
+      define_step(regex,&block)
+    end
+
+    def Then(regex,&block)
+      define_step(regex,&block)
+    end
+
+    def define_step(regex,&block)
+      @steps << regex
+    end
+
+    def self.method_missing(*args)
+      #nothing
+    end
+
+    def method_missing(*args)
+      #nothing
+    end
+
+    def self.const_missing(*args)
+      self
+    end
+
+    def require(*args)
+      # do nothing
+    end
+
+    def line_matches(line)
+      #stripped_line = line.strip.gsub(/^(And|Given|When|Then) (.*)$/,'\2')
+
+      @steps.each_with_index do |regex,i|
+        match = regex.match(line)
+        if match
+          return step_collection.detect{|step| i == step.id}
+        end
+      end
+
+      return nil
+    end
+
+    def step_collection
+      return @step_collection if @step_collection
+      @step_collection = StepCollection.new
+      @steps.each_with_index do |regex, i|
+        @step_collection.add_step(i, regex)
+      end
+      @step_collection
+    end
+  end
+end

data/lib/stepdown/step_usage.rb

@@ -0,0 +1,15 @@
+
+module Stepdown
+  class StepUsage
+
+    attr_accessor :total_usage, :number_scenarios, :use_scenario
+    attr_reader :step
+
+    def initialize(step)
+      @step = step
+      @total_usage = 0
+      @number_scenarios = 0
+      @use_scenario = 0.0
+    end
+  end
+end

data/lib/stepdown/text_reporter.rb

@@ -0,0 +1,39 @@
+require 'stepdown/reporter'
+
+module Stepdown
+  class TextReporter < Reporter
+
+    def output_overview
+      puts "Generating report..." unless Stepdown.quiet
+      output = File.new(Stepdown.output_directory + '/analysis.txt', "w+")
+
+      output.puts "Total number of scenarios: #{total_scenarios}"
+      output.puts "Total numer of steps: #{total_steps}"
+      output.puts "Unused steps: #{unused_step_count}"
+      output.puts "Steps per scenario: #{steps_per_scenario}"
+      output.puts "Unique steps per scenario: #{unique_steps}"
+
+      output.puts "Step usages"
+      output.puts "Step|Total usage|Scenarios|Use per scenario"
+      usages.each{|use| output.puts used_step_line(use) }
+
+      output.puts "Unused steps"
+      unused_steps.each{|use| output.puts unused_step_line(use) }
+
+      output.close
+
+      puts "Report output to #{Stepdown.output_directory}/analysis.txt" unless Stepdown.quiet
+
+    end
+
+    def used_step_line(use)
+      line = [use.step.regex.inspect, use.total_usage, use.number_scenarios, use.use_scenario]
+      line.join("|")
+    end
+
+    def unused_step_line(use)
+      use.step.regex.inspect
+    end
+
+  end
+end

data/lib/stepdown/version.rb

@@ -0,0 +1,3 @@
+module Stepdown
+  VERSION = "0.6.3.1patched"
+end