cucumber_characteristics 0.0.4 → 0.0.5

data/features/characteristics/cucumber_step_characteristics.json

@@ -1 +1 @@
-[["features/step_definitions/wait_steps.rb:1",{"total_count":8,"passed":{"count":8,"feature_location":{"features/scenario_outline.feature:4":[0.102381726,0.300628711],"features/scenario_outline.feature:5":[0.202134351,0.202134351],"features/scenario_outline.feature:6":[0.300628711,0.102381726],"features/scenario_outline.feature:7":[0.202134351,0.202134351]}},"failed":{"count":0,"feature_location":{}},"skipped":{"count":0,"feature_location":{}},"undefined":{"count":0,"feature_location":{}},"regexp":"/^I wait ([\\d\\.]+) seconds$/","fastest":0.102381726,"slowest":0.300628711,"average":0.20181978475,"total_duration":1.614558278,"standard_deviation":0.07009159960098225,"variation":0.198246985,"variance":0.0049128323346244165}]]
+[["features/step_definitions/wait_steps.rb:1",{"total_count":33,"passed":{"count":31,"feature_location":{"features/failure.feature:4":[1.002],"features/pending.feature:4":[1.002],"features/scenario.feature:4":[0.501],"features/scenario.feature:5":[0.501],"features/scenario.feature:6":[0.501],"features/scenario_outline.feature:4":[0.101,0.305],"features/scenario_outline.feature:5":[0.2,0.2],"features/scenario_outline.feature:6":[0.305,0.101],"features/scenario_outline.feature:7":[0.2,0.2],"features/scenario_outline_with_background.feature:4":[0.402,0.402],"features/scenario_outline_with_background.feature:7":[0.101,0.501],"features/scenario_outline_with_background.feature:8":[0.2,0.601],"features/scenario_outline_with_background.feature:9":[0.305,0.701],"features/scenario_outline_with_background.feature:10":[0.2,0.2],"features/scenario_with_background.feature:4":[0.402,0.402],"features/scenario_with_background.feature:7":[0.101],"features/scenario_with_background.feature:8":[0.2],"features/scenario_with_background.feature:9":[0.305],"features/scenario_with_background.feature:12":[0.501],"features/scenario_with_background.feature:13":[0.601],"features/scenario_with_background.feature:14":[0.701]}},"failed":{"count":0,"feature_location":{}},"skipped":{"count":2,"feature_location":{"features/failure.feature:6":[],"features/pending.feature:6":[]}},"undefined":{"count":0,"feature_location":{}},"regexp":"/^I wait ([\\d\\.]+) seconds$/","fastest":0.101,"slowest":1.002,"average":0.3853225806451612,"total_duration":11.944999999999997,"standard_deviation":0.2372462157958885,"variation":0.901,"variance":0.0562857669094693}],["I call a pending step",{"total_count":1,"passed":{"count":0,"feature_location":{}},"failed":{"count":0,"feature_location":{}},"skipped":{"count":0,"feature_location":{}},"undefined":{"count":1,"feature_location":{"features/pending.feature:5":[]}},"fastest":null,"slowest":null,"average":null,"total_duration":null,"standard_deviation":null,"variation":null}],["features/step_definitions/fail_steps.rb:1",{"total_count":1,"passed":{"count":0,"feature_location":{}},"failed":{"count":1,"feature_location":{"features/failure.feature:5":[]}},"skipped":{"count":0,"feature_location":{}},"undefined":{"count":0,"feature_location":{}},"regexp":"/^I fail$/","fastest":null,"slowest":null,"average":null,"total_duration":null,"standard_deviation":null,"variation":null}]]

data/features/step_definitions/fail_steps.rb

@@ -1,3 +1,3 @@
 Given(/^I fail$/) do
-  fail "Expected step failure"
+  raise 'Expected step failure'
 end

data/features/step_definitions/unused_steps.rb

@@ -0,0 +1,2 @@
+Given(/^I am unused/) do
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'cucumber'
+require 'cucumber_characteristics/autoload'

data/lib/cucumber_characteristics.rb

@@ -1,8 +1,13 @@
-require "cucumber_characteristics/configuration"
-require "cucumber_characteristics/cucumber_step_patch"
-require "cucumber_characteristics/exporter"
-require "cucumber_characteristics/formatter"
-require "cucumber_characteristics/profile_data"
+require 'cucumber_characteristics/configuration'
+require 'cucumber_characteristics/cucumber_common_step_patch'
+if Cucumber::VERSION < '2.0.0'
+  require 'cucumber_characteristics/cucumber_1x_step_patch'
+else
+  require 'cucumber_characteristics/cucumber_2x_step_patch'
+end
+require 'cucumber_characteristics/exporter'
+require 'cucumber_characteristics/formatter'
+require 'cucumber_characteristics/profile_data'
 
 module CucumberCharacteristics
   class << self

data/lib/cucumber_characteristics/autoload.rb

@@ -1,3 +1,5 @@
+require 'cucumber_characteristics'
+
 AfterConfiguration do |configuration|
-  configuration.options[:formats] << ['CucumberCharacteristics::Formatter', nil]
+  configuration.formats << ['CucumberCharacteristics::Formatter', nil]
 end

data/lib/cucumber_characteristics/configuration.rb

@@ -1,15 +1,13 @@
 module CucumberCharacteristics
-
   class Configuration
-
     attr_accessor :export_json, :export_html, :target_filename, :relative_path, :precision
 
     def initialize
       @export_json = true
       @export_html = true
       @precision = 4
-      @target_filename =  'cucumber_step_characteristics'
-      @relative_path =  'features/characteristics'
+      @target_filename = 'cucumber_step_characteristics'
+      @relative_path = 'features/characteristics'
     end
 
     def full_target_filename
@@ -18,7 +16,7 @@ module CucumberCharacteristics
 
     def full_dir
       dir = resolve_path_from_root @relative_path
-      FileUtils.mkdir_p dir unless File.exists? dir
+      FileUtils.mkdir_p dir unless File.exist? dir
       dir
     end
 
@@ -31,6 +29,5 @@ module CucumberCharacteristics
         File.expand_path(rel_path, Dir.pwd)
       end
     end
-
   end
 end

data/lib/cucumber_characteristics/cucumber_1x_step_patch.rb

@@ -0,0 +1,38 @@
+module Cucumber
+  class Runtime
+    def scenario_profiles
+      return @scenario_profiles if @scenario_profiles
+      feature_profiles = {}
+      scenarios.each do |f|
+        if f.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)
+          feature_id = f.scenario_outline.file_colon_line
+          feature_profiles[feature_id] ||= { name: f.scenario_outline.name, total_duration: 0, step_count: 0, example_count: 0, examples: {} }
+          example_id = f.name
+          feature_profiles[feature_id][:examples][example_id] = scenario_outline_example_profile(f)
+        else
+          feature_id = f.file_colon_line
+          feature_profiles[feature_id] = scenario_profile(f)
+        end
+      end
+      @scenario_profiles = feature_profiles
+    end
+
+    private
+
+    def scenario_profile(scenario)
+      scenario_profile = { name: scenario.name, total_duration: 0, step_count: 0 }
+      scenario_profile[:total_duration] = scenario.steps.select { |s| s.status == :passed }.map { |s| s.step_match.duration }.inject(&:+)
+      scenario_profile[:step_count] = scenario.steps.count
+      scenario_profile[:status] = scenario.status
+      scenario_profile
+    end
+
+    def scenario_outline_example_profile(scenario)
+      example_profile = { total_duration: 0, step_count: 0 }
+      example_profile[:total_duration] = scenario.instance_variable_get(:@step_invocations).select { |s| s.status == :passed }.map { |s| s.step_match.duration }.inject(&:+)
+      example_profile[:step_count] = scenario.instance_variable_get(:@step_invocations).count
+      example_profile[:status] = scenario.status
+      example_profile
+    end
+  end
+end

data/lib/cucumber_characteristics/cucumber_2x_step_patch.rb

@@ -0,0 +1,163 @@
+module Cucumber
+  class StepDefinitionLight
+    unless method_defined?(:file_colon_line)
+      def file_colon_line
+        location.file_colon_line
+      end
+    end
+  end
+
+  module Core
+    module Ast
+      module Location
+        #  Cucumber::Core::Ast::Location::Precise
+        class Precise
+          unless method_defined?(:file_colon_line)
+            def file_colon_line
+              to_s
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module Formatter
+    module LegacyApi
+      module Ast
+        class Scenario
+          attr_accessor :steps, :background_steps
+        end
+      end
+
+      class RuntimeFacade
+        def scenario_profiles
+          return @scenario_profiles if @scenario_profiles
+          feature_profiles = {}
+
+          assign_steps_to_scenarios!
+          results.scenarios.each do |scenario|
+            # Feature id outline is the top level feature defintion
+            # aggregating up multiple examples
+            feature_id = feature_id(scenario)
+            if outline_feature?(scenario)
+              feature_profiles[feature_id] ||= { name: scenario.name, total_duration: 0, step_count: 0, examples: {} }
+              agg_steps = aggregate_steps(scenario.steps)
+              feature_profiles[feature_id][:total_duration] += agg_steps[:total_duration]
+              feature_profiles[feature_id][:step_count] += agg_steps[:step_count]
+
+              # First order step associations to scenario examples
+              example_id = scenario_from(scenario.steps.first).name.match(/(Examples.*\))/).captures.first
+              feature_profiles[feature_id][:examples][example_id] = { total_duration: 0, step_count: 0 }
+              feature_profiles[feature_id][:examples][example_id] = aggregate_steps(scenario.steps)
+              feature_profiles[feature_id][:examples][example_id][:status] = scenario.status.to_sym
+            else
+              feature_profiles[feature_id] = { name: scenario.name, total_duration: 0, step_count: 0 }
+              feature_profiles[feature_id][:status] = scenario.status.to_sym
+              feature_profiles[feature_id].merge!(aggregate_steps(scenario.steps))
+            end
+          end
+          # Collect up background tasks not directly attributable to
+          # specific scenarios
+          feature_files.each do |file|
+            steps = background_steps_for(file)
+            next if steps.empty?
+            feature_id = "#{file}:0 (Background)"
+            feature_profiles[feature_id] = { name: 'Background', total_duration: 0, step_count: 0 }
+            feature_profiles[feature_id].merge!(aggregate_steps(steps))
+            feature_profiles[feature_id][:status] =
+              steps.map(&:status).uniq.join(',')
+          end
+
+          @scenario_profiles = feature_profiles
+        end
+
+        private
+
+        def feature_id(scenario)
+          if outline_feature?(scenario)
+            scenario_outline_to_feature_id(scenario)
+          else
+            scenario.location.to_s
+          end
+        end
+
+        def outline_feature?(scenario)
+          scenario.name =~ /Examples \(#\d+\)$/
+        end
+
+        def outline_step?(step)
+          step.step.class == Cucumber::Core::Ast::ExpandedOutlineStep
+        end
+
+        def background_step?(step)
+          !step.background.nil?
+        end
+
+        def scenario_from(step)
+          if outline_step?(step)
+            # Match directly to scenario by line number
+            scenarios.select do |s|
+              s.location.file == step.location.file && s.location.line == step.location.line
+            end.first
+          else
+            # Match indirectly to preceeding scenario by line number
+            # (explicit sort needed for ruby 2.x)
+            scenarios.select { |s| s.location.file == step.location.file && s.location.line < step.location.line }.sort { |a, b| a.location.line <=> b.location.line }.last
+          end
+        end
+
+        def background_steps_for(scenario_file)
+          steps.select do |s|
+            s.location.file == scenario_file &&
+              background_step?(s)
+          end
+        end
+
+        def assign_steps_to_scenarios!
+          steps.each do |step|
+            scenario = scenario_from(step)
+            if scenario
+              scenario.steps ||= []
+              scenario.steps << step
+            end
+          end
+        end
+
+        Feature = Struct.new(:name, :line) #=> Customer
+        def scenario_outlines_from_file(file)
+          count = 1
+          results = []
+          File.open(file).each_line do |li|
+            results << Feature.new(li, count) if li[/^\s*Scenario Outline:/]
+            count += 1
+          end
+          results
+        end
+
+        # List of scenario name and lines from file
+        def scenario_outlines(file)
+          @feature_outlines ||= {}
+          return @feature_outlines[file] if @feature_outlines[file]
+          @feature_outlines[file] = scenario_outlines_from_file(file)
+        end
+
+        def scenario_outline_to_feature_id(scenario)
+          scenarios = scenario_outlines(scenario.location.file)
+          scenario_outline = scenarios.select { |s| s.line < scenario.location.line }
+          scenario_outline = scenario_outline.sort { |a, b| a.line <=> b.line }.last
+          "#{scenario.location.file}:#{scenario_outline.line}"
+        end
+
+        def feature_files
+          scenarios.map { |s| s.location.file }.uniq
+        end
+
+        def aggregate_steps(steps)
+          { total_duration: steps.reject { |s| [:skipped, :undefined].include?(s.status) }.map { |s| s.duration.nanoseconds.to_f / 1_000_000_000 }.inject(&:+),
+            step_count: steps.count }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber_characteristics/{cucumber_step_patch.rb → cucumber_common_step_patch.rb}

@@ -1,14 +1,14 @@
-#http://stackoverflow.com/questions/4470108/when-monkey-patching-a-method-can-you-call-the-overridden-method-from-the-new-i
+# http://stackoverflow.com/questions/4470108/when-monkey-patching-a-method-can-you-call-the-overridden-method-from-the-new-i
 
 module Cucumber
   class StepMatch
-    if self.method_defined?(:invoke)
+    if method_defined?(:invoke)
       old_invoke = instance_method(:invoke)
       attr_reader :duration
 
-      define_method(:invoke) do | multiline_arg |
+      define_method(:invoke) do |multiline_arg|
         start_time = Time.now
-        ret = old_invoke.bind(self).(multiline_arg)
+        ret = old_invoke.bind(self).call(multiline_arg)
         @duration = Time.now - start_time
         ret
       end
@@ -16,7 +16,6 @@ module Cucumber
   end
 end
 
-
 module Cucumber
   module Ast
     class StepInvocation

data/lib/cucumber_characteristics/exporter.rb

@@ -2,9 +2,7 @@ require 'haml'
 require 'digest/md5'
 
 module CucumberCharacteristics
-
   class Exporter
-
     attr_reader :profile
     def initialize(profile)
       @profile = profile
@@ -14,11 +12,11 @@ module CucumberCharacteristics
     def export
       filename = @config.full_target_filename
       if @config.export_html
-        File.open(filename+'.html', 'w') { |file| file.write(to_html) }
+        File.open(filename + '.html', 'w') { |file| file.write(to_html) }
         puts "Step characteristics report written to #{filename}.html"
       end
       if @config.export_json
-        File.open(filename+'.json', 'w') { |file| file.write(to_json) }
+        File.open(filename + '.json', 'w') { |file| file.write(to_json) }
         puts "Step characteristics report written to #{filename}.json"
       end
     end
@@ -36,20 +34,18 @@ module CucumberCharacteristics
     # HELPERS
 
     def format_ts(t)
-      t ? sprintf("%0.#{@config.precision}f", t) : '-'
+      t ? format("%0.#{@config.precision}f", t) : '-'
     end
 
     def format_step_usage(step_feature_data)
       step_feature_data[:feature_location].map do |location, timings|
-        "#{location}" + (timings.count > 1 ? " (x#{timings.count})" : '')
+        location.to_s + (timings.count > 1 ? " (x#{timings.count})" : '')
       end.join("\n")
     end
 
     def step_status_summary(profile)
       status = profile.step_count_by_status
-      status.keys.sort.map{|s| status[s]> 0 ? "#{s.capitalize}: #{status[s]}" : nil}.compact.join(', ')
+      status.keys.sort.map { |s| status[s] > 0 ? "#{s.capitalize}: #{status[s]}" : nil }.compact.join(', ')
     end
-
-   end
-
+  end
 end

data/lib/cucumber_characteristics/formatter.rb

@@ -1,7 +1,5 @@
 module CucumberCharacteristics
-
   class Formatter
-
     def initialize(runtime, io, options)
       @runtime = runtime
       @io = io
@@ -9,30 +7,9 @@ module CucumberCharacteristics
       @features = {}
     end
 
-    # def before_feature(scenario)
-    #   pp scenario.class.name
-    #   if scenario.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)
-    #     feature_location = scenario.scenario_outline.file_colon_line
-    #     feature_name     = scenario.scenario_outline.name.chomp
-    #     feature_example  = scenario.name
-    #     @features[feature_location] ||= {}
-    #     @features[feature_location][feature_example] ||= {start_time: Time.now}
-    #   else
-    #     feature_location = scenario.file_colon_line
-    #     feature_name     = scenario.name.chomp
-    #     @features[feature_location] ||= {start_time: Time.now}
-    #   end
-    # end
-
-    # def after_feature(scenario)
-    # end
-
     def after_features(features)
       profile = ProfileData.new(@runtime, features)
       Exporter.new(profile).export
     end
-
   end
-
-
 end

data/lib/cucumber_characteristics/profile_data.rb

@@ -1,13 +1,15 @@
-module CucumberCharacteristics
+require 'pp'
 
+module CucumberCharacteristics
   class ProfileData
+    CUCUMBER_VERSION = Gem::Version.new(Cucumber::VERSION)
 
     extend Forwardable
 
     def_delegators :@runtime, :scenarios, :steps
     attr_reader :duration
 
-    STATUS_ORDER = {passed: 0, failed: 2000, skipped: 1000, undefined: 500}
+    STATUS_ORDER = { passed: 0, failed: 2000, skipped: 1000, undefined: 500 }.freeze
 
     STATUS = STATUS_ORDER.keys
 
@@ -18,82 +20,64 @@ module CucumberCharacteristics
     end
 
     def ambiguous_count
-      @runtime.steps.count{|s| ambiguous?(s)}
+      @runtime.steps.count { |s| ambiguous?(s) }
     end
 
     def unmatched_steps
       unmatched = {}
       @runtime.unmatched_step_definitions.each do |u|
-        unmatched[u.file_colon_line] = u.regexp_source
+        location = u.file_colon_line
+        unmatched[location] = u.regexp_source
       end
       unmatched.sort
     end
 
-    def has_unmatched_steps?
+    def unmatched_steps?
       unmatched_steps.count > 0
     end
 
     def feature_profiles
-      feature_profiles = { }
-      @runtime.scenarios.each do |f|
-        if f.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)
-          feature_id = f.scenario_outline.file_colon_line
-          feature_profiles[feature_id] ||= {name: f.scenario_outline.name, total_duration: 0, step_count: 0, example_count: 0, examples: {} }
-          example_id = f.name
-          feature_profiles[feature_id][:examples][example_id] ||= {total_duration: 0, step_count: 0}
-          feature_profiles[feature_id][:examples][example_id][:total_duration] = f.instance_variable_get(:@step_invocations).select{|s| s.status == :passed}.map{|s| s.step_match.duration}.inject(&:+)
-          feature_profiles[feature_id][:examples][example_id][:step_count] = f.instance_variable_get(:@step_invocations).count
-          feature_profiles[feature_id][:examples][example_id][:status] = f.status
-        else
-          feature_id = f.file_colon_line
-          feature_profiles[feature_id] = {name: f.name, total_duration: 0, step_count: 0}
-          feature_profiles[feature_id][:total_duration] = f.steps.select{|s| s.status == :passed}.map{|s| s.step_match.duration}.inject(&:+)
-          feature_profiles[feature_id][:step_count] = f.steps.count
-          feature_profiles[feature_id][:status] = f.status
-        end
-      end
-      with_feature_calculations(feature_profiles)
+      return @feature_profiles if @feature_profiles
+      feature_profiles = @runtime.scenario_profiles
+      @feature_profiles = with_feature_calculations(feature_profiles)
     end
 
     def with_feature_calculations(feature_profiles)
       feature_profiles.each do |feature, meta|
-        if meta[:examples]
-          feature_profiles[feature][:example_count] = meta[:examples].keys.count
-          feature_profiles[feature][:total_duration] = meta[:examples].map{|e,m| m[:total_duration]}.inject(&:+)
-          feature_profiles[feature][:step_count] = meta[:examples].map{|e,m| m[:step_count]}.inject(&:+)
-          feature_profiles[feature][:examples] = feature_profiles[feature][:examples].sort_by{|k, v| v[:total_duration]}.reverse
-          feature_profiles[feature][:status] = if meta[:examples].all?{|e,m| m[:status] == :passed}
-                                                 :passed
-                                               elsif meta[:examples].any?{|e,m| m[:status] == :failed}
-                                                 :failed
-                                               elsif meta[:examples].any?{|e,m| m[:status] == :skipped}
-                                                 :skipped
-                                               else
-                                                 :unknown
-                                               end
-        end
+        next unless meta[:examples]
+        feature_profiles[feature][:example_count] = meta[:examples].keys.count
+        feature_profiles[feature][:total_duration] = meta[:examples].map { |_e, m| m[:total_duration] || 0 }.inject(&:+)
+        feature_profiles[feature][:step_count] = meta[:examples].map { |_e, m| m[:step_count] }.inject(&:+)
+        feature_profiles[feature][:examples] = feature_profiles[feature][:examples].sort_by { |_k, v| v[:total_duration] }.reverse
+        feature_profiles[feature][:status] = if meta[:examples].all? { |_e, m| m[:status] == :passed }
+                                               :passed
+                                             elsif meta[:examples].any? { |_e, m| m[:status] == :failed }
+                                               :failed
+                                             elsif meta[:examples].any? { |_e, m| m[:status] == :skipped }
+                                               :skipped
+                                             else
+                                               :unknown
+                                             end
       end
-      feature_profiles.sort_by{|k, v| (STATUS_ORDER[v[:status]]||0)+(v[:total_duration] || 0)}.reverse
+      feature_profiles.sort_by { |_k, v| (STATUS_ORDER[v[:status]] || 0) + (v[:total_duration] || 0) }.reverse
     end
 
     def step_profiles
       step_profiles = {}
       @runtime.steps.each do |s|
-        unless ambiguous?(s)
-          step_name = s.status == :undefined ? s.name : s.step_match.step_definition.file_colon_line
-          # Initialize data structure
-          step_profiles[step_name] ||= { :total_count => 0}
-          STATUS.each {|status| step_profiles[step_name][status] ||= {:count => 0, :feature_location => {} }}
-          feature_location = s.file_colon_line
-          step_profiles[step_name][s.status][:count] += 1
-          step_profiles[step_name][:total_count] += 1
-          step_profiles[step_name][s.status][:feature_location][feature_location] ||= []
-          if s.status != :undefined
-            step_profiles[step_name][:regexp] = s.step_match.step_definition.regexp_source
-            if s.status == :passed
-              step_profiles[step_name][s.status][:feature_location][feature_location] << s.step_match.duration
-            end
-          end
+        next if ambiguous?(s)
+        step_name = s.status == :undefined ? s.name : s.step_match.step_definition.file_colon_line
+        # Initialize data structure
+        step_profiles[step_name] ||= { total_count: 0 }
+        STATUS.each { |status| step_profiles[step_name][status] ||= { count: 0, feature_location: {} } }
+        feature_location = s.file_colon_line
+        step_profiles[step_name][s.status][:count] += 1
+        step_profiles[step_name][:total_count] += 1
+        step_profiles[step_name][s.status][:feature_location][feature_location] ||= []
+        next unless s.status != :undefined
+        step_profiles[step_name][:regexp] = s.step_match.step_definition.regexp_source
+        if s.status == :passed
+          step_profiles[step_name][s.status][:feature_location][feature_location] << s.step_match.duration
         end
       end
       with_step_calculations(step_profiles)
@@ -118,18 +102,18 @@ module CucumberCharacteristics
         step_profiles[step][:variation] = step_profiles[step][:slowest] - step_profiles[step][:fastest]
         step_profiles[step][:total_duration] = timings.inject(:+)
         step_profiles[step][:average] = step_profiles[step][:total_duration] / meta[:passed][:count]
-        sum = timings.inject(0){|accum, i| accum +(i-step_profiles[step][:average])**2 }
-        step_profiles[step][:variance] = sum/(timings.length ).to_f
-        step_profiles[step][:standard_deviation] = Math.sqrt( step_profiles[step][:variance])
+        sum = timings.inject(0) { |accum, i| accum + (i - step_profiles[step][:average])**2 }
+        step_profiles[step][:variance] = sum / timings.length.to_f
+        step_profiles[step][:standard_deviation] = Math.sqrt(step_profiles[step][:variance])
       end
-      step_profiles.sort_by{|k, v| v[:total_duration]||0}.reverse
+      step_profiles.sort_by { |_k, v| v[:total_duration] || 0 }.reverse
     end
 
     def step_duration
       step_duration = []
-      step_profiles.each do | step, meta |
+      step_profiles.each do |_step, meta|
         STATUS.each do |status|
-          meta[status][:feature_location].each do | location, timings |
+          meta[status][:feature_location].each do |_location, timings|
             step_duration << timings
           end
         end
@@ -162,7 +146,5 @@ module CucumberCharacteristics
       end
       status
     end
-
   end
-
 end