cuke_sniffer 0.0.5 → 0.0.6

data/lib/cuke_sniffer/formatter.rb

@@ -0,0 +1,142 @@
+require 'erb'
+
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants
+  # Static class used to generate output for the CukeSniffer::CLI object.
+  class Formatter
+    include CukeSniffer::Constants
+
+    # Prints out a summary of the results and the list of improvements to be made
+    def self.output_console(cuke_sniffer)
+      summary = cuke_sniffer.summary
+      output = "Suite Summary" +
+                "  Total Score: #{summary[:total_score]}\n" +
+                get_output_summary_nodes(cuke_sniffer) +
+                console_improvement_list(summary[:improvement_list])
+
+      puts output
+    end
+
+    # Returns a string of formatted output for all the object sections of summary
+    def self.get_output_summary_nodes(cuke_sniffer)
+      output = ""
+      [:features, :scenarios, :step_definitions, :hooks].each do |summary_section|
+        output += console_summary(summary_section.to_s.gsub("_", " ").capitalize, cuke_sniffer.summary[summary_section])
+      end
+      output
+    end
+
+    # Formats the section data for a summary object
+    def self.console_summary(name, summary)
+      "  #{name}\n" +
+      "    Min: #{summary[:min]} (#{summary[:min_file]})\n" +
+      "    Max: #{summary[:max]} (#{summary[:max_file]})\n" +
+      "    Average: #{summary[:average]}\n"
+    end
+
+    # Formats the improvement list data for summary
+    def self.console_improvement_list(improvement_list)
+      output = "  Improvements to make:\n"
+      improvement_list.each do |improvement, count|
+        output << "    (#{count}) #{improvement}\n"
+      end
+      output
+    end
+
+    # Creates a html file with the collected project details
+    # file_name defaults to "cuke_sniffer_results.html" unless specified
+    # Second parameter used for passing into the markup.
+    #  cuke_sniffer.output_html
+    # Or
+    #  cuke_sniffer.output_html("results01-01-0001.html")
+    def self.output_html(cuke_sniffer, file_name = DEFAULT_OUTPUT_FILE_NAME, template_name = "standard_template")
+      cuke_sniffer = sort_cuke_sniffer_lists(cuke_sniffer)
+      output = ERB.new(extract_markup("#{template_name}.html.erb")).result(binding)
+      File.open(format_html_file_name(file_name), 'w') do |f| f.write(output) end
+    end
+
+    # Returns an ERB page built up for the passed file name
+    def self.build_page(cuke_sniffer, erb_file)
+      ERB.new(extract_markup(erb_file)).result(binding)
+    end
+
+    # Assigns an html extension if one is not provided for the passed file name
+    def self.format_html_file_name(file_name)
+      if file_name =~ /\.html$/
+        file_name
+      else
+        file_name + ".html"
+      end
+    end
+
+    # Creates a html file with minimum information: Summary, Rules, Improvement List.
+    # file_name defaults to "cuke_sniffer_results.html" unless specified
+    # Second parameter used for passing into the markup.
+    #  cuke_sniffer.output_min_html
+    # Or
+    #  cuke_sniffer.output_min_html("results01-01-0001.html")
+    def self.output_min_html(cuke_sniffer, file_name = DEFAULT_OUTPUT_FILE_NAME)
+      output_html(cuke_sniffer, file_name, "min_template")
+    end
+
+    # Returns the Rules erb page that utilizes sub page sections of enabled and disabled rules
+    def self.rules_template(cuke_sniffer)
+      enabled_rules = sub_rules_template(cuke_sniffer, true, "Enabled Rules")
+      disabled_rules = sub_rules_template(cuke_sniffer, false, "Disabled Rules")
+      ERB.new(extract_markup("rules.html.erb")).result(binding)
+    end
+
+    # Returns the sub rules erb page for enabled status of a rule
+    def self.sub_rules_template(cuke_sniffer, state, heading)
+      ERB.new(extract_markup("sub_rules.html.erb")).result(binding)
+    end
+
+    # Creates a xml file with the collected project details
+    # file_name defaults to "cuke_sniffer.xml" unless specified
+    #  cuke_sniffer.output_xml
+    # Or
+    #  cuke_sniffer.output_xml("cuke_sniffer01-01-0001.xml")
+    def self.output_xml(cuke_sniffer, file_name = DEFAULT_OUTPUT_FILE_NAME)
+      file_name = file_name + ".xml" unless file_name =~ /\.xml$/
+
+      doc = Nokogiri::XML::Document.new
+      doc.root = cuke_sniffer.to_xml
+      open(file_name, "w") do |file|
+        file << doc.serialize
+      end
+    end
+
+    # Formats a list of rule conditions into a compact string of 5 or less elements per row.
+    def self.convert_array_condition_into_list_of_strings(condition_list)
+      result = []
+      while condition_list.size > 0
+        five_words = condition_list.slice!(0, 5)
+        result << five_words.join(", ")
+      end
+      result
+    end
+
+    # Sorts all of the lists on a cuke_sniffer object to be in descending order for each objects score.
+    def self.sort_cuke_sniffer_lists(cuke_sniffer)
+      cuke_sniffer.features = cuke_sniffer.features.sort_by { |feature| feature.total_score }.reverse
+      cuke_sniffer.step_definitions = cuke_sniffer.step_definitions.sort_by { |step_definition| step_definition.score }.reverse
+      cuke_sniffer.hooks = cuke_sniffer.hooks.sort_by { |hook| hook.score }.reverse
+      cuke_sniffer.rules = cuke_sniffer.rules.sort_by { |rule| rule.score }.reverse
+      cuke_sniffer
+    end
+
+    # Returns the markup for a desired erb file.
+    def self.extract_markup(template_name = "markup.html.erb", markup_source = MARKUP_SOURCE)
+      markup_location = "#{markup_source}/#{template_name}"
+      markup = ""
+      File.open(markup_location).lines.each do |line|
+        markup << line
+      end
+      markup
+    end
+
+  end
+end

data/lib/cuke_sniffer/hook.rb

@@ -1,160 +1,77 @@
-require 'roxml'
-module CukeSniffer
-
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Cucumber Hook class used for evaluating rules
-  # Extends CukeSniffer::RulesEvaluator
-  class Hook < RulesEvaluator
-
-    xml_accessor :start_line
-    xml_accessor :type
-    xml_accessor :tags, :as => [], :in => "tags"
-    xml_accessor :parameters, :as => [], :in => "parameters"
-    xml_accessor :code, :as => [], :in => "code"
-
-    # The type of the hook: AfterConfiguration, After, AfterStep, Around, Before, at_exit
-    attr_accessor :type
-
-    # The list of tags used as a filter for the hook
-    attr_accessor :tags
-
-    # The parameters that are declared on the hook
-    attr_accessor :parameters
-
-    # Integer of the line in which the hook was found
-    attr_accessor :start_line
-
-    # Array of strings that contain the code kept in the hook
-    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 hook declaration line and the pairing end
-    def initialize(location, raw_code)
-      super(location)
-
-      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
-      @type = nil
-      @tags = []
-      @parameters = []
-
-      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 =~ HOOK_REGEX
-          matches = HOOK_REGEX.match(line)
-          @type = matches[:type]
-          hook_tag_regexp = /["']([^"']*)["']/
-          matches[:tags].scan(hook_tag_regexp).each { |tag| @tags << tag[0] } if matches[:tags]
-          @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
-        end
-      end
-      evaluate_score
-    end
-
-    def ==(comparison_object) # :nodoc:
-      super(comparison_object) &&
-          comparison_object.type == type &&
-          comparison_object.tags == tags &&
-          comparison_object.parameters == parameters &&
-          comparison_object.code == code
-    end
-
-    private
-
-    def evaluate_score
-      rule_empty_hook
-      rule_hook_not_in_hooks_file
-      rule_no_debugging
-      rule_all_comments
-      rule_conflicting_tags
-      rule_duplicate_tags
-      if @type == "Around"
-        rule_around_hook_without_2_parameters
-        rule_around_hook_no_block_call
-      end
-    end
-
-    def rule_empty_hook
-      rule = RULES[:empty_hook]
-      store_rule(rule) if @code == []
-    end
-
-    def rule_hook_not_in_hooks_file
-      rule = RULES[:hook_not_in_hooks_file]
-      store_rule(rule) unless @location.include?(rule[:file])
-    end
-
-    def rule_around_hook_without_2_parameters
-      rule = RULES[:around_hook_without_2_parameters]
-      store_rule(rule) unless @parameters.count == 2
-    end
-
-    def rule_around_hook_no_block_call
-      return if rule_stored?(:around_hook_without_2_parameters)
-      rule = RULES[:around_hook_no_block_call]
-      block_call = "#{@parameters[1]}.call"
-      @code.each do |line|
-        return if line.include?(block_call)
-      end
-      store_rule(rule)
-    end
-
-    def rule_stored?(rule_symbol)
-      @rules_hash.keys.include?(RULES[rule_symbol][:phrase])
-    end
-
-    def rule_no_debugging
-      return if rule_stored?(:empty_hook)
-      rule = RULES[:hook_no_debugging]
-      begin_found = false
-      rescue_found = false
-      @code.each do |line|
-        begin_found = true if line.include?("begin")
-        rescue_found = true if line.include?("rescue")
-        break if begin_found and rescue_found
-      end
-      store_rule(rule) unless begin_found and rescue_found
-    end
-
-    def rule_all_comments
-      rule = RULES[:hook_all_comments]
-      @code.each do |line|
-        return unless is_comment?(line)
-      end
-      store_rule(rule)
-    end
-
-    def rule_conflicting_tags
-      rule = RULES[:hook_conflicting_tags]
-      all_tags = flatten_tags
-
-      all_tags.each do |single_tag|
-        tag = single_tag.gsub("~", "")
-        if all_tags.include?(tag) and all_tags.include?("~#{tag}")
-          store_rule(rule)
-          return
-        end
-      end
-    end
-
-    def flatten_tags
-      all_tags = []
-      @tags.each { |single_tag| all_tags << single_tag.split(',') }
-      all_tags.flatten
-    end
-
-    def rule_duplicate_tags
-      rule = RULES[:hook_duplicate_tags]
-      all_tags = flatten_tags
-      unique_tags = all_tags.uniq
-
-      store_rule(rule) unless all_tags == unique_tags
-    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
+  # Cucumber Hook class used for evaluating rules
+  # Extends CukeSniffer::RulesEvaluator
+  class Hook < RuleTarget
+
+    xml_accessor :start_line
+    xml_accessor :type
+    xml_accessor :tags, :as => [], :in => "tags"
+    xml_accessor :parameters, :as => [], :in => "parameters"
+    xml_accessor :code, :as => [], :in => "code"
+
+    # The type of the hook: AfterConfiguration, After, AfterStep, Around, Before, at_exit
+    attr_accessor :type
+
+    # The list of tags used as a filter for the hook
+    attr_accessor :tags
+
+    # The parameters that are declared on the hook
+    attr_accessor :parameters
+
+    # Integer of the line in which the hook was found
+    attr_accessor :start_line
+
+    # Array of strings that contain the code kept in the hook
+    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 hook declaration line and the pairing end
+    def initialize(location, hook_block)
+      super(location)
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+      end_match_index = (hook_block.size - 1) - hook_block.reverse.index("end")
+      @code = hook_block[1...end_match_index]
+      initialize_hook_signature(hook_block)
+    end
+
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+          comparison_object.type == type &&
+          comparison_object.tags == tags &&
+          comparison_object.parameters == parameters &&
+          comparison_object.code == code
+    end
+
+    private
+
+    def initialize_hook_signature(hook_block)
+      @type = nil
+      @tags = []
+      @parameters = []
+
+      hook_signature = extract_hook_signature(hook_block)
+      matches = HOOK_REGEX.match(hook_signature)
+      @type = matches[:type]
+      initialize_tags(matches[:tags]) if matches[:tags]
+      @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
+    end
+
+    def extract_hook_signature(hook_block)
+      hook_block.each do |line|
+        return line if line =~ HOOK_REGEX
+      end
+    end
+
+    def initialize_tags(tag_list)
+      hook_tag_regexp = /["']([^"']*)["']/
+      tag_list.scan(hook_tag_regexp).each { |tag| @tags << tag[0] }
+    end
+  end
+end

data/lib/cuke_sniffer/report/dead_steps.html.erb

@@ -0,0 +1,36 @@
+<div class="title" onclick="toggleById('dead_steps_data', this)">
+  Dead Steps +
+</div>
+<div class="shrink_section" id="dead_steps_data">
+  <% dead_steps = cuke_sniffer.get_dead_steps %>
+  <% dead_steps.delete(:total) %>
+  <% dead_step_count = dead_steps.values.flatten.count %>
+  <% if dead_step_count == 0 %>
+      <div class="empty_set_message">No dead steps found!</div>
+  <% elsif dead_step_count == 1 %>
+      <div class="empty_set_message" style="color: red"><%= dead_step_count %> Dead Step found.</div>
+  <% else %>
+      <div class="empty_set_message" style="color: red"><%= dead_step_count %> Dead Steps found.</div>
+  <% end %>
+
+  <table style="width: 100%">
+    <% dead_steps.each_key do |file_name| %>
+        <tr>
+          <td>
+            <div style="text-indent: 2%;font-weight: bold;"><%= file_name.gsub(cuke_sniffer.step_definitions_location, "") %>
+              .rb
+            </div>
+            <table style="width: 100%; padding-left: 3%;">
+              <% dead_steps[file_name].each do |regex| %>
+                  <tr>
+                    <td style="width: 3%"><%= regex.match(/(?<line>\d+):/)[:line] %></td>
+                    <td><%= regex.match(/:(?<regex>.*)/)[:regex] %></td>
+                  </tr>
+              <% end %>
+            </table>
+          </td>
+        </tr>
+    <% end %>
+  </table>
+</div>
+<br style="clear:both">

data/lib/cuke_sniffer/report/features.html.erb

@@ -0,0 +1,60 @@
+<div class="title" onclick="toggleById('features_data', this)">
+  Features +
+</div>
+<div class="shrink_section" id="features_data">
+  <% if cuke_sniffer.features.count == 0 %>
+      <div class="empty_set_message">There were no Features to sniff in '<%= cuke_sniffer.features_location %>'!</div>
+  <% elsif cuke_sniffer.features.count >= 1 && cuke_sniffer.scenarios.count >=1 && cuke_sniffer.summary[:features][:total_score] ==0 && cuke_sniffer.summary[:scenarios][:total_score] ==0 %>
+      <div class="empty_set_message">Excellent! No smells found for Features and Scenarios!</div>
+  <% end %>
+  <% index = 0 %>
+  <% cuke_sniffer.features.each do |feature| %>
+      <% next if feature.total_score <= 0 %>
+      <div style="cursor: pointer; padding-top: 3px" onclick="updateDisplayStatus(document.getElementById('feature_<%=index%>'))">
+        <div class="red_number" style="float:left"><%= feature.total_score + feature.scenarios_score %></div>
+        <div class="notes"><%= feature.name %></div>
+      </div>
+      <div id="feature_<%= index %>" class="sub_section">
+        <div style="text-indent: 4%; float: left; width: 45%; border-right: 2px solid #add8e6; padding-bottom: 4px">
+          <% if feature.rules_hash.empty? %>
+              <pre style="margin: 0;">      </pre>
+          <% end %>
+          <% feature.rules_hash.each_key do |rule| %>
+              <pre style="margin: 0;"><%= rule %></pre>
+          <% end %>
+        </div>
+        <div style="text-indent: 1%; padding-bottom: 4px">
+          <%= feature.location.gsub(cuke_sniffer.features_location, "") %>
+        </div>
+        <br style="clear:both">
+
+        <div>
+          <% unless feature.background.nil? or feature.background.score > 0 %>
+              <div class="red_number" style="float:left; padding-left: 1%"><%= feature.background.score %></div>
+              <div style="float: left; width: 45%;"><%= feature.background.type + ": " + feature.background.name %></div>
+              <div style="margin-left:1%;float: left; border-left: 2px solid #90ee90; border-top: 2px solid #90ee90;text-indent: 1%;">
+                <% feature.background.rules_hash.each_key do |rule| %>
+                    <pre style="margin: 0; text_indent: 3%;"><%= rule %></pre>
+                <% end %>
+              </div>
+              <br style="clear:both">
+          <% end %>
+        </div>
+        <div>
+          <% feature.scenarios.each do |scenario| %>
+              <% next if scenario.score <= 0 %>
+              <div class="red_number" style="float:left; padding-left: 1%"><%= scenario.score %></div>
+              <div style="float: left; width: 45%;"><%= scenario.type + ": " + scenario.name %></div>
+              <div style="margin-left:1%;float: left; border-left: 2px solid #90ee90; border-top: 2px solid #90ee90; text-indent: 1%">
+                <% scenario.rules_hash.each_key do |rule| %>
+                    <pre style="margin: 0; text_indent: 3%;"><%= rule %></pre>
+                <% end %>
+              </div>
+              <br style="clear:both">
+          <% end %>
+        </div>
+      </div>
+      <% index += 1 %>
+  <% end %>
+</div>
+<br style="clear:both">