cuke_sniffer 0.0.8 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08622ee3780b51802880b03e082b31e87276a0ae
+  data.tar.gz: face498e4e3bcfe632b1f7fc1fdc15c71514ee6f
+SHA512:
+  metadata.gz: 8b3f1802e042beefe36c066c01699c3bcc1fc3cfa75818749a3c070a52e84dee5e166e211e6a33ee0bed3aaed33aa7ddac8bd43855aa573e61440b4ebdb9d5db
+  data.tar.gz: 9693a75b3eb0321b14212cde4b3179b69b51096f8ce1b0bbfcf999aedb825f6256a8f1304dab9507625ede083799b9539d00c04eb263ec3c12d2b5e64df4382a

data/bin/cuke_sniffer

@@ -6,7 +6,7 @@ require 'cuke_sniffer'
 help_cmd_txt = "Welcome to CukeSniffer!
 Calling CukeSniffer with no arguments will run it against the current directory.
 Other Options for Running include:
-  -o, --out <type> (name)                   : Where <type> is 'html', 'min_html' or 'xml'.
+  -o, --out <type> (name)                   : Where <type> is 'html', 'min_html', 'junit_xml' or 'xml'.
                                               Runs CukeSniffer then outputs an
                                               html/xml file in the current
                                               directory (with optional name).
@@ -50,6 +50,7 @@ def handle_output(argv)
         :html => "html",
         :min_html => "min_html",
         :xml => "xml",
+        :junit_xml => "junit_xml",
     }
     output_type_hash.each_value do |value|
       index_of_key = argv.index(value)
@@ -72,6 +73,8 @@ def call_output(file_type, file_name)
       file_name.nil? ? @cuke_sniffer.output_html : @cuke_sniffer.output_html(file_name)
     when "min_html"
       file_name.nil? ? @cuke_sniffer.output_min_html : @cuke_sniffer.output_min_html(file_name)
+    when "junit_xml"
+      file_name.nil? ? @cuke_sniffer.output_junit_xml : @cuke_sniffer.output_junit_xml(file_name)
     else
       puts "#{file_type} is not a supported version of cuke_sniffer output."
   end

data/lib/cuke_sniffer/cli.rb

@@ -149,6 +149,15 @@ module CukeSniffer
       CukeSniffer::Formatter.output_xml(self, file_name)
     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 output_junit_xml(file_name = DEFAULT_OUTPUT_FILE_NAME + ".xml")
+      CukeSniffer::Formatter.output_junit_xml(self, file_name)
+    end
+
     # Gathers all StepDefinitions that have no calls
     # Returns a hash that has two different types of records
     # 1: String of the file with a dead step with an array of the line and regex of each dead step
@@ -205,9 +214,11 @@ module CukeSniffer
     end
 
     def initialize_locations(parameters)
-      @features_location = parameters[:features_location] ? parameters[:features_location] : Dir.getwd
-      @step_definitions_location = parameters[:step_definitions_location] ? parameters[:step_definitions_location] : Dir.getwd
-      @hooks_location = parameters[:hooks_location] ? parameters[:hooks_location] : Dir.getwd
+      default_location = parameters[:project_location] || Dir.getwd
+
+      @features_location = parameters[:features_location] || default_location
+      @step_definitions_location = parameters[:step_definitions_location] || default_location
+      @hooks_location = parameters[:hooks_location] || default_location
     end
 
     def initialize_feature_objects
@@ -260,7 +271,7 @@ module CukeSniffer
         if File.file?(pattern_location)
           [pattern_location]
         else
-          Dir["#{pattern_location}/**/*.#{extension}"]
+          Dir["#{pattern_location}/**/*.#{extension}"].select { |f| File.file? f }
         end
       end
     end

data/lib/cuke_sniffer/cuke_sniffer_helper.rb

@@ -86,14 +86,15 @@ module CukeSniffer
     # Builds a list of rule objects out of a hash. See CukeSniffer::RulesConfig for hash example.
     def self.build_rules(rules)
       return [] if rules.nil?
-      rules.collect do |key, value|
-        CukeSniffer::CukeSnifferHelper.build_rule(value)
+      rules.collect do |symbol, value|
+        CukeSniffer::CukeSnifferHelper.build_rule(symbol, value)
       end
     end
 
     # Builds rule object out of a hash. See CukeSniffer::RulesConfig for hash example.
-    def self.build_rule(rule_hash)
+    def self.build_rule(symbol, rule_hash)
       rule = CukeSniffer::Rule.new
+      rule.symbol = symbol
       rule.phrase = rule_hash[:phrase]
       rule.score = rule_hash[:score]
       rule.enabled = rule_hash[:enabled]

data/lib/cuke_sniffer/dead_steps_helper.rb

@@ -1,54 +1,54 @@
-module CukeSniffer
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2014 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Mixins: CukeSniffer::Constants
-  # A static class to aid in the identification of dead steps.
-  class DeadStepsHelper
-    include CukeSniffer::Constants
-
-    # Returns a hash of dead steps for displaying in the html.
-    def self.build_dead_steps_hash(step_definitions)
-      dead_steps_hash = gather_all_dead_steps_by_file(step_definitions)
-      sort_dead_steps_in_file!(dead_steps_hash)
-      dead_steps_hash[:total] = count_dead_steps(dead_steps_hash)
-      dead_steps_hash
-    end
-
-    # Returns all dead step definitions in a file
-    def self.gather_all_dead_steps_by_file(step_definitions)
-      dead_steps_hash = {}
-      step_definitions.each do |step_definition|
-        location_match = step_definition.location.match(/(?<file>.*).rb:(?<line>\d+)/)
-        file_name = location_match[:file]
-        regex = format_step_definition_regex(step_definition.regex)
-        if step_definition.calls.empty?
-          dead_steps_hash[file_name] ||= []
-          dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/"
-        end
-      end
-      dead_steps_hash
-    end
-
-    # Formats the regex of a step definition to remove the (?-mix) part of the to_s
-    def self.format_step_definition_regex(regex)
-      regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
-    end
-
-    # Sorts the dead steps found in a hash by the line number in the file
-    def self.sort_dead_steps_in_file!(dead_steps_hash)
-      dead_steps_hash.each_key do |file|
-        dead_steps_hash[file].sort_by! { |row| row[/^\d+/].to_i }
-      end
-    end
-
-    # Returns the count of all possible dead steps in each file
-    def self.count_dead_steps(dead_steps_hash)
-      count = 0
-      dead_steps_hash.each_value do |dead_steps_in_file_list|
-        count += dead_steps_in_file_list.size
-      end
-      count
-    end
-  end
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2014 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants
+  # A static class to aid in the identification of dead steps.
+  class DeadStepsHelper
+    include CukeSniffer::Constants
+
+    # Returns a hash of dead steps for displaying in the html.
+    def self.build_dead_steps_hash(step_definitions)
+      dead_steps_hash = gather_all_dead_steps_by_file(step_definitions)
+      sort_dead_steps_in_file!(dead_steps_hash)
+      dead_steps_hash[:total] = count_dead_steps(dead_steps_hash)
+      dead_steps_hash
+    end
+
+    # Returns all dead step definitions in a file
+    def self.gather_all_dead_steps_by_file(step_definitions)
+      dead_steps_hash = {}
+      step_definitions.each do |step_definition|
+        location_match = step_definition.location.match(/(?<file>.*).rb:(?<line>\d+)/)
+        file_name = location_match[:file]
+        regex = format_step_definition_regex(step_definition.regex)
+        if step_definition.calls.empty?
+          dead_steps_hash[file_name] ||= []
+          dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/"
+        end
+      end
+      dead_steps_hash
+    end
+
+    # Formats the regex of a step definition to remove the (?-mix) part of the to_s
+    def self.format_step_definition_regex(regex)
+      regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
+    end
+
+    # Sorts the dead steps found in a hash by the line number in the file
+    def self.sort_dead_steps_in_file!(dead_steps_hash)
+      dead_steps_hash.each_key do |file|
+        dead_steps_hash[file].sort_by! { |row| row[/^\d+/].to_i }
+      end
+    end
+
+    # Returns the count of all possible dead steps in each file
+    def self.count_dead_steps(dead_steps_hash)
+      count = 0
+      dead_steps_hash.each_value do |dead_steps_in_file_list|
+        count += dead_steps_in_file_list.size
+      end
+      count
+    end
+  end
 end

data/lib/cuke_sniffer/formatter.rb

@@ -1,125 +1,166 @@
-require 'erb'
-
-module CukeSniffer
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2014 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]}\n" +
-      "    Max: #{summary[:max]}\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)
-      ERB.new(extract_markup("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
-
-    # 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
+require 'erb'
+
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2014 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]}\n" +
+      "    Max: #{summary[:max]}\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)
+      ERB.new(extract_markup("rules.html.erb")).result(binding)
+    end
+
+    # Creates a xml file with the collected project details
+    # file_name defaults to "cuke_sniffer_result.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
+
+    # Creates an xml file in the junit with issues organized by file.
+    # file_name defaults to "cuke_sniffer_result.xml" unless specified
+    #  cuke_sniffer.output_xml
+    # Or
+    #  cuke_sniffer.output_xml("cuke_sniffer01-01-0001.xml")
+    def self.output_junit_xml(cuke_sniffer, file_name = DEFAULT_OUTPUT_FILE_NAME)
+      file_name = file_name + ".xml" unless file_name =~ /\.xml$/
+      results = {}
+      failures = 0
+      current = cuke_sniffer.features
+      current.concat cuke_sniffer.scenarios
+      current.concat cuke_sniffer.step_definitions
+      current.concat cuke_sniffer.hooks
+      current.each do |test|
+        location = test.location.gsub("#{Dir.pwd}/", '')
+        location_no_line = location.gsub(/:[0-9]*/,'')
+        line_num = location.include?(":") ? location.gsub(/.*:(.*)/, "\\1") : "full_file"
+        errors = test.rules_hash.keys.map {|f| {:line => line_num,
+                                                :severity => test.rules_hash,
+                                                :error => f,
+                                                :formatted => "Severity: #{test.rules_hash[f]}\nLocation: #{location}\nError: #{f}"}}
+        results[location_no_line] = results[location_no_line].nil? ? errors : results[location_no_line].concat(errors)
+        failures += test.rules_hash.size
+      end
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.testsuites(:tests => results.size, :failures => failures) do
+          results.each do |location, failures|
+            failures.each do |failure|
+              xml.testcase(:classname => location, :name => failure[:line], :time => 0) do
+                xml.failure(failure[:formatted], :type => 'failure', :message => failure[:error])
+              end
+            end
+          end
+        end
+      end
+      output = builder.to_xml
+      File.open(file_name, 'w') do |f| f.write(output) end
+      # Return here to aid testing.
+      output
+    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).each_line do |line|
+        markup << line
+      end
+      markup
+    end
+
+  end
+end