cuke_sniffer 0.0.5 → 0.0.6

data/lib/cuke_sniffer/step_definition.rb

@@ -1,239 +1,163 @@
-require 'roxml'
-module CukeSniffer
-
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Translates and evaluates Cucumber step definitions
-  # Extends CukeSniffer::RulesEvaluator
-  class StepDefinition < RulesEvaluator
-
-    xml_accessor :start_line
-    xml_accessor :regex
-    xml_accessor :parameters, :as => [], :in => "parameters"
-    xml_accessor :nested_steps, :as => {:key => 'location', :value => 'call'}, :in => "nested_steps"
-    xml_accessor :calls, :as => {:key => 'location', :value => 'call'}, :in => "calls"
-    xml_accessor :code, :as => [], :in => "code"
-
-    # int: Line on which a step definition starts
-    attr_accessor :start_line
-
-    # Regex: Regex that cucumber uses to match step calls
-    attr_accessor :regex
-
-    # string array: List of the parameters a step definition has
-    attr_accessor :parameters
-
-    # hash: Contains each nested step call a step definition has
-    # * Key: location:line of the nested step
-    # * Value: The step call that appears on the line
-    attr_accessor :nested_steps
-
-    # hash: Contains each call that is made to a step definition
-    # * Key: Location in which the step definition is called from
-    # * Value: The step string that matched the regex
-    # In the case of a fuzzy match it will be a regex of the
-    # step call that was the inverse match of the regex translated
-    # into a string.
-    attr_accessor :calls
-
-    # string array: List of all of the content between the regex and the end of the step definition.
-    attr_accessor :code
-
-    # location must be in the format of "file_path\file_name.rb:line_number"
-    # raw_code is an array of strings that represents the step definition
-    # must contain the regex line and its pairing end
-    def initialize(location, raw_code)
-      super(location)
-
-      @parameters = []
-      @calls = {}
-      @nested_steps = {}
-      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
-
-      end_match_index = (raw_code.size - 1) - raw_code.reverse.index("end")
-      @code = raw_code[1...end_match_index]
-
-      raw_code.each do |line|
-        if line =~ STEP_DEFINITION_REGEX
-          matches = STEP_DEFINITION_REGEX.match(line)
-          @regex = Regexp.new(matches[:step])
-          @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
-        end
-      end
-
-      detect_nested_steps
-      evaluate_score
-    end
-
-    # Adds new location => step_string pairs to the calls hash
-    def add_call(location, step_string)
-      @calls[location] = step_string
-    end
-
-    def ==(comparison_object) # :nodoc:
-      super(comparison_object) &&
-      comparison_object.regex == regex &&
-      comparison_object.code == code &&
-      comparison_object.parameters == parameters &&
-      comparison_object.calls == calls &&
-      comparison_object.nested_steps == nested_steps
-    end
-
-    def condensed_call_list
-      condensed_list = {}
-      @calls.each do |call, step_string|
-        condensed_list[step_string] ||= []
-        condensed_list[step_string] << call
-      end
-      condensed_list
-    end
-
-    private
-
-    SIMPLE_NESTED_STEP_REGEX = /steps?\s"#{STEP_STYLES}(?<step_string>.*)"$/ # :nodoc:
-    START_COMPLEX_STEP_REGEX = /^steps?\s%(q|Q)?\{\s*/ # :nodoc:
-    SAME_LINE_COMPLEX_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
-    END_COMPLEX_STEP_REGEX = /}$/ # :nodoc:
-    START_COMPLEX_WITH_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)$/ # :nodoc:
-    END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
-
-    def detect_nested_steps
-      multi_line_step_flag = false
-      counter = 1
-      @code.each do |line|
-        regex = nil
-        case line
-          when SIMPLE_NESTED_STEP_REGEX
-            regex = SIMPLE_NESTED_STEP_REGEX
-          when SAME_LINE_COMPLEX_STEP_REGEX
-            regex = SAME_LINE_COMPLEX_STEP_REGEX
-          when START_COMPLEX_WITH_STEP_REGEX
-            if line =~ /\}$/
-              if line.include?('#{')
-                reversed_line = line.reverse
-                last_capture = reversed_line[0..reversed_line.index('#')].reverse
-                if last_capture =~ /{.*}$/
-                  multi_line_step_flag = true
-                  regex = START_COMPLEX_WITH_STEP_REGEX
-                else
-                  regex = SAME_LINE_COMPLEX_STEP_REGEX
-                end
-              else
-                regex = SAME_LINE_COMPLEX_STEP_REGEX
-              end
-            else
-              multi_line_step_flag = true
-              regex = START_COMPLEX_WITH_STEP_REGEX
-            end
-          when END_COMPLEX_WITH_STEP_REGEX
-            if line =~ /[#]{.*}$/ && multi_line_step_flag
-              regex = STEP_REGEX
-            else
-              regex = END_COMPLEX_WITH_STEP_REGEX
-              multi_line_step_flag = false
-            end
-          when START_COMPLEX_STEP_REGEX
-            multi_line_step_flag = true
-          when STEP_REGEX
-            regex = STEP_REGEX if multi_line_step_flag
-          when END_COMPLEX_STEP_REGEX
-            multi_line_step_flag = false
-          else
-        end
-
-        if regex and !is_comment?(line)
-          match = regex.match(line)
-          nested_step_line = (@start_line + counter)
-          @nested_steps[location.gsub(/:\d*$/, ":" + nested_step_line.to_s)] = match[:step_string].gsub("\\", "")
-        end
-        counter += 1
-      end
-    end
-
-    def evaluate_score
-      rule_no_code
-      rule_too_many_parameters
-      rule_nested_steps
-      rule_recursive_nested_step
-      rule_commented_code
-      rule_lazy_debugging
-      rule_pending
-      rule_todo
-      sleep_rules
-    end
-
-    def rule_todo
-      code.each do |line|
-        rule = RULES[:todo]
-        store_rule(rule) if line =~ /\#(TODO|todo)/
-      end
-    end
-
-    def sleep_rules
-      code.each do |line|
-        match_data = line.match /^\s*sleep(\s|\()(?<sleep_time>.*)\)?/
-        if match_data
-          sleep_value = match_data[:sleep_time].to_f
-          rule_small_sleep(sleep_value)
-          rule_large_sleep(sleep_value)
-        end
-      end
-    end
-
-    def rule_large_sleep(sleep_value)
-      rule = RULES[:large_sleep]
-      store_rule(rule) if sleep_value > rule[:min]
-    end
-
-    def rule_small_sleep(sleep_value)
-      rule = RULES[:small_sleep]
-      store_rule(rule) if sleep_value <= rule[:max]
-    end
-
-    def rule_pending
-      rule = RULES[:pending]
-      code.each do |line|
-        store_rule(rule) if line =~ /^\s*pending\s*$/
-        return
-      end
-    end
-
-    def rule_lazy_debugging
-      rule = RULES[:lazy_debugging]
-      code.each do |line|
-        next if is_comment?(line)
-        store_rule(rule) if line.strip =~ /^(p|puts)( |\()('|"|%(q|Q)?\{)/
-      end
-    end
-
-    def rule_no_code
-      rule = RULES[:no_code]
-      store_rule(rule) if code.empty?
-    end
-
-    def rule_too_many_parameters
-      rule = RULES[:too_many_parameters]
-      store_rule(rule) if parameters.size >= rule[:max]
-    end
-
-    def rule_nested_steps
-      rule = RULES[:nested_step]
-      store_rule(rule) unless nested_steps.empty?
-    end
-
-    def rule_recursive_nested_step
-      rule = RULES[:recursive_nested_step]
-      nested_steps.each_value do |nested_step|
-        store_rule(rule) if nested_step =~ regex
-      end
-    end
-
-    def rule_commented_code
-      rule = RULES[:commented_code]
-      code.each do |line|
-        store_rule(rule) if is_comment?(line)
-      end
-    end
-  end
-end
+require 'roxml'
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Translates and evaluates Cucumber step definitions
+  # Extends CukeSniffer::RulesEvaluator
+  class StepDefinition < RuleTarget
+
+    xml_accessor :start_line
+    xml_accessor :regex
+    xml_accessor :parameters, :as => [], :in => "parameters"
+    xml_accessor :nested_steps, :as => {:key => 'location', :value => 'call'}, :in => "nested_steps"
+    xml_accessor :calls, :as => {:key => 'location', :value => 'call'}, :in => "calls"
+    xml_accessor :code, :as => [], :in => "code"
+
+    # int: Line on which a step definition starts
+    attr_accessor :start_line
+
+    # Regex: Regex that cucumber uses to match step calls
+    attr_accessor :regex
+
+    # string array: List of the parameters a step definition has
+    attr_accessor :parameters
+
+    # hash: Contains each nested step call a step definition has
+    # * Key: location:line of the nested step
+    # * Value: The step call that appears on the line
+    attr_accessor :nested_steps
+
+    # hash: Contains each call that is made to a step definition
+    # * Key: Location in which the step definition is called from
+    # * Value: The step string that matched the regex
+    # In the case of a fuzzy match it will be a regex of the
+    # step call that was the inverse match of the regex translated
+    # into a string.
+    attr_accessor :calls
+
+    # string array: List of all of the content between the regex and the end of the step definition.
+    attr_accessor :code
+
+    # location must be in the format of "file_path\file_name.rb:line_number"
+    # step_definition_block is an array of strings that represents the step definition
+    # must contain the regex line and its pairing end
+    def initialize(location, step_definition_block)
+      @parameters = []
+      @calls = {}
+      @nested_steps = {}
+      super(location)
+      extract_start_line(location)
+      extract_code(step_definition_block)
+      extract_step_definition_signature(step_definition_block)
+
+      detect_nested_steps
+    end
+
+    # Adds new location => step_string pairs to the calls hash
+    def add_call(location, step_string)
+      @calls[location] = step_string
+    end
+
+    def ==(comparison_object) # :nodoc:
+      comparison_object.regex == regex && comparison_object.parameters == parameters
+    end
+
+    def condensed_call_list
+      condensed_list = {}
+      @calls.each do |call, step_string|
+        condensed_list[step_string] ||= []
+        condensed_list[step_string] << call
+      end
+      condensed_list
+    end
+
+    private
+
+    SIMPLE_NESTED_STEP_REGEX = /steps?\s"#{STEP_STYLES}(?<step_string>.*)"$/ # :nodoc:
+    START_COMPLEX_STEP_REGEX = /^steps?\s%(q|Q)?\{\s*/ # :nodoc:
+    SAME_LINE_COMPLEX_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
+    END_COMPLEX_STEP_REGEX = /}$/ # :nodoc:
+    START_COMPLEX_WITH_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)$/ # :nodoc:
+    END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
+
+    def detect_nested_steps
+      multi_line_step_flag = false
+      counter = 1
+      @code.each do |line|
+        regex = nil
+        case line
+          when SIMPLE_NESTED_STEP_REGEX
+            regex = SIMPLE_NESTED_STEP_REGEX
+          when SAME_LINE_COMPLEX_STEP_REGEX
+            regex = SAME_LINE_COMPLEX_STEP_REGEX
+          when START_COMPLEX_WITH_STEP_REGEX
+            if line =~ /\}$/
+              if line.include?('#{')
+                reversed_line = line.reverse
+                last_capture = reversed_line[0..reversed_line.index('#')].reverse
+                if last_capture =~ /{.*}$/
+                  multi_line_step_flag = true
+                  regex = START_COMPLEX_WITH_STEP_REGEX
+                else
+                  regex = SAME_LINE_COMPLEX_STEP_REGEX
+                end
+              else
+                regex = SAME_LINE_COMPLEX_STEP_REGEX
+              end
+            else
+              multi_line_step_flag = true
+              regex = START_COMPLEX_WITH_STEP_REGEX
+            end
+          when END_COMPLEX_WITH_STEP_REGEX
+            if line =~ /[#]{.*}$/ && multi_line_step_flag
+              regex = STEP_REGEX
+            else
+              regex = END_COMPLEX_WITH_STEP_REGEX
+              multi_line_step_flag = false
+            end
+          when START_COMPLEX_STEP_REGEX
+            multi_line_step_flag = true
+          when STEP_REGEX
+            regex = STEP_REGEX if multi_line_step_flag
+          when END_COMPLEX_STEP_REGEX
+            multi_line_step_flag = false
+          else
+        end
+
+        if regex and !is_comment?(line)
+          match = regex.match(line)
+          nested_step_line = (@start_line + counter)
+          @nested_steps[location.gsub(/:\d*$/, ":" + nested_step_line.to_s)] = match[:step_string].gsub("\\", "")
+        end
+        counter += 1
+      end
+    end
+
+    def extract_step_definition_signature(step_definition_block)
+      regex_line = find_regex_line(step_definition_block)
+      unless regex_line.nil?
+        matches = STEP_DEFINITION_REGEX.match(regex_line)
+        @regex = Regexp.new(matches[:step])
+        @parameters = matches[:parameters].split(/,\s*/).collect { |param| param.strip } if matches[:parameters]
+      end
+    end
+
+    def extract_start_line(location)
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+    end
+
+    def extract_code(step_definition_block)
+      end_match_index = (step_definition_block.size - 1) - step_definition_block.reverse.index("end")
+      @code = step_definition_block[1...end_match_index]
+    end
+
+    def find_regex_line(step_definition_block)
+      step_definition_block.each do |line|
+        return line if line =~ STEP_DEFINITION_REGEX
+      end
+      nil
+    end
+  end
+end

data/lib/cuke_sniffer/summary_helper.rb

@@ -0,0 +1,91 @@
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants
+  # A static class used to help with handling summary data for CukeSniffer::CLI
+  class SummaryHelper
+    include CukeSniffer::Constants
+
+    # Sorts the list of improvements in descending order of times found.
+    def self.sort_improvement_list(improvement_list)
+      sorted_array = improvement_list.sort_by { |improvement, occurrence| occurrence }.reverse
+      sorted_improvement_list = {}
+      sorted_array.each { |node|
+        sorted_improvement_list[node[0]] = node[1]
+      }
+      sorted_improvement_list
+    end
+
+    # Builds a default assessment hash.
+    def self.make_assessment_hash
+      {
+          :total => 0,
+          :total_score => 0,
+          :min => nil,
+          :min_file => nil,
+          :max => nil,
+          :max_file => nil,
+          :average => 0,
+          :threshold => nil,
+          :good => 0,
+          :bad => 0,
+          :improvement_list => {}
+      }
+    end
+
+    # Initializes an assessment hash for the rule target list
+    def self.initialize_assessment_hash(rule_target_list, type)
+      assessment_hash = make_assessment_hash
+      assessment_hash[:total] = rule_target_list.count
+      assessment_hash[:threshold] = THRESHOLDS[type]
+
+      unless rule_target_list.empty?
+        score = rule_target_list.first.score
+        location = rule_target_list.first.location
+        assessment_hash[:min] = score
+        assessment_hash[:min_file] = location
+        assessment_hash[:max] = score
+        assessment_hash[:max_file] = location
+      end
+      assessment_hash
+    end
+
+    # Returns a summary hash for the rule_target_list
+    def self.assess_rule_target_list(rule_target_list, type)
+      assessment_hash = initialize_assessment_hash(rule_target_list, type)
+      rule_target_list.each do |rule_target|
+        score = rule_target.score
+        assessment_hash[:total_score] += score
+        assessment_hash[rule_target.good? ? :good : :bad] += 1
+        if score < assessment_hash[:min]
+          assessment_hash[:min] = score
+          assessment_hash[:min_file] = rule_target.location
+        end
+        if score > assessment_hash[:max]
+          assessment_hash[:max] = score
+          assessment_hash[:max_file] = rule_target.location
+        end
+        rule_target.rules_hash.each_key do |key|
+          assessment_hash[:improvement_list][key] ||= 0
+          assessment_hash[:improvement_list][key] += rule_target.rules_hash[key]
+        end
+      end
+      assessment_hash[:average] = (assessment_hash[:total_score].to_f/rule_target_list.count.to_f).round(2)
+      assessment_hash
+    end
+
+    # Returns a CukeSniffer::SummaryNode object for the passed hash
+    def self.load_summary_data(summary_hash)
+      summary_node = SummaryNode.new
+      summary_node.count = summary_hash[:total]
+      summary_node.score = summary_hash[:total_score]
+      summary_node.average = summary_hash[:average]
+      summary_node.threshold = summary_hash[:threshold]
+      summary_node.good = summary_hash[:good]
+      summary_node.bad = summary_hash[:bad]
+      summary_node
+    end
+
+  end
+end