cuke_sniffer 0.0.5 → 0.0.6

data/bin/cuke_sniffer

@@ -1,63 +1,85 @@
-#!/usr/bin/env ruby
-$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
-
-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:
-  <feature_file_path>, <step_def_file_path> : Runs CukeSniffer against the
-                                              specified paths.
-  -o, --out <type> (name)                   : Where <type> is 'html' or 'xml'.
-                                              Runs CukeSniffer then outputs an
-                                              html/xml file in the current
-                                              directory (with optional name).
-  -h, --help                                : You get this lovely document."
-
-
-if ARGV.include? "-h" or ARGV.include? "--help"
-  puts help_cmd_txt
-  exit
-end
-
-cuke_sniffer = nil
-if (ARGV[0] != nil and File.directory?(ARGV[0])) and (ARGV[1] != nil and File.directory?
-(ARGV[1]))
-  cuke_sniffer = CukeSniffer::CLI.new(ARGV[0], ARGV[1])
-else
-  cuke_sniffer = CukeSniffer::CLI.new
-end
-
-def print_results(cuke_sniffer)
-  puts cuke_sniffer.output_results
-end
-
-if ARGV.include? "--out" or ARGV.include? "-o"
-  index = ARGV.index("--out")
-  index ||= ARGV.index("-o")
-  out_type = ARGV[index + 1]
-  case out_type
-    when "html"
-      file_name = ARGV[index + 2]
-      if file_name.nil?
-        cuke_sniffer.output_html
-      else
-        file_name = file_name + ".html" unless file_name =~ /\.html$/
-        cuke_sniffer.output_html(file_name)
-      end
-    when "xml"
-      file_name = ARGV[index + 2]
-      if file_name.nil?
-        cuke_sniffer.output_xml
-      else
-        file_name = file_name + ".xml" unless file_name =~ /\.xml$/
-        cuke_sniffer.output_xml(file_name)
-      end
-    else
-      print_results(cuke_sniffer)
-  end
-else
-  print_results(cuke_sniffer)
-end
-
-puts "Completed Sniffing."
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+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'.
+                                              Runs CukeSniffer then outputs an
+                                              html/xml file in the current
+                                              directory (with optional name).
+  -h,  --help                               : You get this lovely document.
+  -p,  --project <project_root>             : Root directory of project.
+  -f,  --features <feature_path>            : Path to features directory.
+  -s,  --step_definitions <step_def_path>   : Path to step definitions directory.
+  -hk, --hooks <hooks_path>                 : Path to support directory.            "
+
+def find_index_by_regex_match(list, regex)
+  list.each do |item|
+    return list.index(item) if item =~ regex
+  end
+  nil
+end
+
+def build_cli_hash(argv)
+  cucumber_hash ={
+      :hooks_location => /-hk|--hooks/,
+      :features_location => /-f|--features/,
+      :step_definitions_location => /-s|--step_definitions/,
+      :project_location => /-p|--project/}
+  cli_hash = {}
+  cucumber_hash.each do |symbol, regex|
+    index_of_key = find_index_by_regex_match(argv, regex)
+    if !index_of_key.nil?
+      cli_hash[symbol] = argv[index_of_key + 1]
+    end
+  end
+  cli_hash
+end
+
+def handle_output(argv)
+  if find_index_by_regex_match(argv, /-o|--out/)
+    output_type_hash = {
+        :html => "html",
+        :min_html => "min_html",
+        :xml => "xml",
+    }
+    output_type_hash.each_value do |value|
+      index_of_key = argv.index(value)
+      if !index_of_key.nil?
+        file_type = argv[index_of_key]
+        file_name = argv[index_of_key+1]
+        call_output(file_type, file_name)
+      end
+    end
+  else
+    puts @cuke_sniffer.output_results
+  end
+end
+
+def call_output(file_type, file_name)
+  case file_type
+    when "xml"
+      file_name.nil? ? @cuke_sniffer.output_xml  : @cuke_sniffer.output_xml(file_name)
+    when "html"
+      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)
+    else
+      puts "#{file_type} is not a supported version of cuke_sniffer output."
+  end
+end
+
+if ARGV.include? "-h" or ARGV.include? "--help"
+  puts help_cmd_txt
+  exit
+end
+
+arguments_hash = build_cli_hash(ARGV)
+@cuke_sniffer = CukeSniffer::CLI.new(arguments_hash)
+handle_output(ARGV)
+
+
+puts "Completed Sniffing."

data/lib/cuke_sniffer.rb

@@ -1,16 +1,23 @@
-require 'nokogiri'
-require 'roxml'
-
-require 'cuke_sniffer/constants'
-require 'cuke_sniffer/rule_config'
-require 'cuke_sniffer/rules_evaluator'
-require 'cuke_sniffer/feature_rules_evaluator'
-require 'cuke_sniffer/feature'
-require 'cuke_sniffer/scenario'
-require 'cuke_sniffer/step_definition'
-require 'cuke_sniffer/hook'
-require 'cuke_sniffer/cli'
-
-module CukeSniffer
-
-end
+require 'nokogiri'
+require 'roxml'
+
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/rule_target'
+require 'cuke_sniffer/feature_rules_evaluator'
+require 'cuke_sniffer/feature'
+require 'cuke_sniffer/scenario'
+require 'cuke_sniffer/step_definition'
+require 'cuke_sniffer/hook'
+require 'cuke_sniffer/rule'
+require 'cuke_sniffer/summary_node'
+require 'cuke_sniffer/rules_evaluator'
+require 'cuke_sniffer/cuke_sniffer_helper'
+require 'cuke_sniffer/summary_helper'
+require 'cuke_sniffer/dead_steps_helper'
+require 'cuke_sniffer/cli'
+require 'cuke_sniffer/formatter'
+
+module CukeSniffer
+
+end

data/lib/cuke_sniffer/cli.rb

@@ -1,523 +1,269 @@
-require 'erb'
-require 'roxml'
-
-module CukeSniffer
-
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Mixins: CukeSniffer::Constants, ROXML
-  class CLI
-    include CukeSniffer::Constants
-    include ROXML
-
-    class SummaryNode
-      include ROXML
-      xml_accessor :score
-      xml_accessor :count
-      xml_accessor :average
-      xml_accessor :good
-      xml_accessor :bad
-      xml_accessor :threshold
-    end # :nodoc:
-
-    xml_name "cuke_sniffer"
-    xml_accessor :features_summary, :as => SummaryNode
-    xml_accessor :scenarios_summary, :as => SummaryNode
-    xml_accessor :step_definitions_summary, :as => SummaryNode
-    xml_accessor :hooks_summary, :as => SummaryNode
-    xml_accessor :improvement_list, :as => {:key => "rule", :value => "total"}, :in => "improvement_list", :from => "improvement"
-    xml_accessor :features, :as => [CukeSniffer::Feature], :in => "features"
-    xml_accessor :step_definitions, :as => [CukeSniffer::StepDefinition], :in => "step_definitions"
-    xml_accessor :hooks, :as => [CukeSniffer::Hook], :in => "hooks"
-
-
-    # Feature array: All Features gathered from the specified folder
-    attr_accessor :features
-
-    # StepDefinition Array: All StepDefinitions objects gathered from the specified folder
-    attr_accessor :step_definitions
-
-    # Hash: Summary objects and improvement lists
-    # * Key: symbol, :total_score, :features, :step_definitions, :improvement_list
-    # * Value: hash or array
-    attr_accessor :summary
-
-    # string: Location of the feature file or root folder that was searched in
-    attr_accessor :features_location
-
-    # string: Location of the step definition file or root folder that was searched in
-    attr_accessor :step_definitions_location
-
-    # string: Location of the hook file or root folder that was searched in
-    attr_accessor :hooks_location
-
-    # Scenario array: All Scenarios found in the features from the specified folder
-    attr_accessor :scenarios
-
-    # Hook array: All Hooks found in the current directory
-    attr_accessor :hooks
-
-
-    # Does analysis against the passed features and step definition locations
-    #
-    # Can be called in several ways.
-    #
-    #
-    # No argument(assumes current directory is the project)
-    #  cuke_sniffer = CukeSniffer::CLI.new
-    #
-    # Against single files
-    #  cuke_sniffer = CukeSniffer::CLI.new("my_feature.feature", nil)
-    # Or
-    #  cuke_sniffer = CukeSniffer::CLI.new(nil, "my_steps.rb")
-    #
-    #
-    # Against folders
-    #  cuke_sniffer = CukeSniffer::CLI.new("my_features_directory\", "my_steps_directory\")
-    #
-    # You can mix and match all of the above examples
-    #
-    # Displays the sequence and a . indicator for each new loop in that process.
-    # Handles creation of all Feature and StepDefinition objects
-    # Then catalogs all step definition calls to be used for rules and identification
-    # of dead steps.
-    def initialize(features_location = Dir.getwd, step_definitions_location = Dir.getwd, hooks_location = Dir.getwd)
-      @features_location = features_location
-      @step_definitions_location = step_definitions_location
-      @hooks_location = hooks_location
-      @features = []
-      @scenarios = []
-      @step_definitions = []
-      @hooks = []
-
-      puts "\nFeatures:"
-      #extract this to a method that accepts a block and yields for the build pattern
-      unless features_location.nil?
-        if File.file?(features_location)
-          @features = [CukeSniffer::Feature.new(features_location)]
-        else
-          build_file_list_from_folder(features_location, ".feature").each { |location|
-            @features << CukeSniffer::Feature.new(location)
-            print '.'
-          }
-        end
-      end
-
-      @scenarios = get_all_scenarios(@features)
-
-      puts("\nStep Definitions:")
-      unless step_definitions_location.nil?
-        if File.file?(step_definitions_location)
-          @step_definitions = [build_step_definitions(step_definitions_location)]
-        else
-          build_file_list_from_folder(step_definitions_location, ".rb").each { |location|
-            @step_definitions << build_step_definitions(location)
-            print '.'
-          }
-        end
-      end
-      @step_definitions.flatten!
-
-      puts("\nHooks:")
-      unless hooks_location.nil?
-        if File.file?(hooks_location)
-          @hooks = [build_hooks(hooks_location)]
-        else
-          build_file_list_from_folder(hooks_location, ".rb").each { |location|
-            @hooks << build_hooks(location)
-            print '.'
-          }
-        end
-      end
-      @hooks.flatten!
-
-      @summary = {
-          :total_score => 0,
-          :features => {},
-          :step_definitions => {},
-          :hooks => {},
-          :improvement_list => {}
-      }
-      puts "\nCataloging Step Calls: "
-      catalog_step_calls
-      puts "\nAssessing Score: "
-      assess_score
-      @improvement_list = @summary[:improvement_list]
-      @features_summary = load_summary_data(@summary[:features])
-      @scenarios_summary = load_summary_data(@summary[:scenarios])
-      @step_definitions_summary = load_summary_data(@summary[:step_definitions])
-      @hooks_summary = load_summary_data(@summary[:hooks])
-    end
-
-    # Returns the status of the overall project based on a comparison of the score to the threshold score
-    def good?
-      @summary[:total_score] <= Constants::THRESHOLDS["Project"]
-    end
-
-    # Calculates the score to threshold percentage of an object
-    # Return: Float
-    def problem_percentage
-      @summary[:total_score].to_f / Constants::THRESHOLDS["Project"].to_f
-    end
-
-    # Prints out a summary of the results and the list of improvements to be made
-    def output_results
-      feature_results = @summary[:features]
-      step_definition_results = @summary[:step_definitions]
-      hooks_results = @summary[:hooks]
-      output = "Suite Summary
-  Total Score: #{@summary[:total_score]}
-    Features (#@features_location)
-      Min: #{feature_results[:min]} (#{feature_results[:min_file]})
-      Max: #{feature_results[:max]} (#{feature_results[:max_file]})
-      Average: #{feature_results[:average]}
-    Step Definitions (#@step_definitions_location)
-      Min: #{step_definition_results[:min]} (#{step_definition_results[:min_file]})
-      Max: #{step_definition_results[:max]} (#{step_definition_results[:max_file]})
-      Average: #{step_definition_results[:average]}
-    Hooks (#@hooks_location)
-      Min: #{hooks_results[:min]} (#{hooks_results[:min_file]})
-      Max: #{hooks_results[:max]} (#{hooks_results[:max_file]})
-      Average: #{hooks_results[:average]}
-  Improvements to make:"
-      create_improvement_list.each { |item| output << "\n    #{item}" }
-      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 output_html(file_name = "cuke_sniffer_results.html", cuke_sniffer = self)
-      @features = @features.sort_by { |feature| feature.total_score }.reverse
-      @step_definitions = @step_definitions.sort_by { |step_definition| step_definition.score }.reverse
-      @hooks = @hooks.sort_by { |hook| hook.score }.reverse
-
-      markup_erb = ERB.new extract_markup
-      output = markup_erb.result(binding)
-      File.open(file_name, 'w') do |f|
-        f.write(output)
-      end
-    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_xml(file_name = "cuke_sniffer.xml")
-      doc = Nokogiri::XML::Document.new
-      doc.root = self.to_xml
-      open(file_name, "w") do |file|
-        file << doc.serialize
-      end
-    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
-    # 2: Symbol of :total with an integer that is the total number of dead steps
-    def get_dead_steps
-      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 = step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
-        dead_steps_hash[file_name] ||= []
-        dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/" if step_definition.calls.empty?
-      end
-      total = 0
-      dead_steps_hash.each_key do |key|
-        unless dead_steps_hash[key] == []
-          total += dead_steps_hash[key].size
-          dead_steps_hash[key].sort_by! { |row| row[/^\d+/].to_i }
-        else
-          dead_steps_hash.delete(key)
-        end
-      end
-      dead_steps_hash[:total] = total
-      dead_steps_hash
-    end
-
-    # Determines all normal and nested step calls and assigns them to the corresponding step definition.
-    # Does direct and fuzzy matching
-    def catalog_step_calls
-      steps = get_all_steps
-      @step_definitions.each do |step_definition|
-        print '.'
-        calls = steps.find_all { |location, step| step.gsub(STEP_STYLES, "") =~ step_definition.regex }
-        calls.each { |call| step_definition.add_call(call[0], call[1].gsub(STEP_STYLES, "")) }
-      end
-
-      converted_steps = convert_steps_with_expressions(get_steps_with_expressions(steps))
-      catalog_possible_dead_steps(converted_steps)
-    end
-
-    private
-
-    def extract_variables_from_example(example)
-      example = example[example.index('|')..example.length]
-      example.split(/\s*\|\s*/) - [""]
-    end
-
-    def assess_score
-      @summary[:features] = assess_array(@features, "Feature")
-      @summary[:scenarios] = assess_array(@scenarios, "Scenario")
-      @summary[:step_definitions] = assess_array(@step_definitions, "StepDefinition")
-      @summary[:hooks] = assess_array(@hooks, "Hook")
-      sort_improvement_list
-    end
-
-    def get_all_steps
-      feature_steps = extract_steps_from_features
-      step_definition_steps = extract_steps_from_step_definitions
-      feature_steps.merge step_definition_steps
-    end
-
-    def get_steps_with_expressions(steps)
-      steps_with_expressions = {}
-      steps.each do |step_location, step_value|
-        if step_value =~ /\#{.*}/
-          steps_with_expressions[step_location] = step_value
-        end
-      end
-      steps_with_expressions
-    end
-
-    def catalog_possible_dead_steps(steps_with_expressions)
-      @step_definitions.each do |step_definition|
-        next unless step_definition.calls.empty?
-        regex_as_string = step_definition.regex.to_s.gsub(/\(\?-mix:\^?/, "").gsub(/\$\)$/, "")
-        steps_with_expressions.each do |step_location, step_value|
-          if regex_as_string =~ step_value
-            step_definition.add_call(step_location, step_value)
-          end
-        end
-      end
-    end
-
-    def convert_steps_with_expressions(steps_with_expressions)
-      step_regexs = {}
-      steps_with_expressions.each do |step_location, step_value|
-        modified_step = step_value.gsub(/\#{[^}]*}/, '.*')
-        step_regexs[step_location] = Regexp.new('^' + modified_step + '$')
-      end
-      step_regexs
-    end
-
-    def 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
-
-    def build_file_list_from_folder(folder_name, extension)
-      list = []
-      Dir.entries(folder_name).each_entry do |file_name|
-        unless FILE_IGNORE_LIST.include?(file_name)
-          file_name = "#{folder_name}/#{file_name}"
-          if File.directory?(file_name)
-            list << build_file_list_from_folder(file_name, extension)
-          elsif file_name.downcase.include?(extension)
-            list << file_name
-          end
-        end
-      end
-      list.flatten
-    end
-
-    def build_step_definitions(file_name)
-      step_file_lines = []
-      step_file = File.open(file_name)
-      step_file.each_line { |line| step_file_lines << line }
-      step_file.close
-
-      counter = 0
-      step_code = []
-      step_definitions = []
-      found_first_step = false
-      until counter >= step_file_lines.length
-        if step_file_lines[counter] =~ STEP_DEFINITION_REGEX and !step_code.empty? and found_first_step
-          step_definitions << CukeSniffer::StepDefinition.new("#{file_name}:#{counter+1 - step_code.count}", step_code)
-          step_code = []
-        end
-        found_first_step = true if step_file_lines[counter] =~ STEP_DEFINITION_REGEX
-        step_code << step_file_lines[counter].strip
-        counter+=1
-      end
-      step_definitions << CukeSniffer::StepDefinition.new("#{file_name}:#{counter+1 -step_code.count}", step_code) unless step_code.empty? or !found_first_step
-      step_definitions
-    end
-
-    def assess_array(array, type)
-      min, max, min_file, max_file = nil
-      total = 0
-      good = 0
-      bad = 0
-      total_score = 0
-      unless array.empty?
-        array.each do |node|
-          score = node.score
-          @summary[:total_score] += score
-          total_score += score
-          node.rules_hash.each_key do |key|
-            @summary[:improvement_list][key] ||= 0
-            @summary[:improvement_list][key] += node.rules_hash[key]
-          end
-          min, min_file = score, node.location if (min.nil? or score < min)
-          max, max_file = score, node.location if (max.nil? or score > max)
-          if node.good?
-            good += 1
-          else
-            bad += 1
-          end
-          total += score
-        end
-      end
-      {
-          :total => array.count,
-          :total_score => total_score,
-          :min => min,
-          :min_file => min_file,
-          :max => max,
-          :max_file => max_file,
-          :average => (total.to_f/array.count.to_f).round(2),
-          :threshold => THRESHOLDS[type],
-          :good => good,
-          :bad => bad,
-      }
-    end
-
-    def get_all_scenarios(features)
-      scenarios = []
-      features.each do |feature|
-        scenarios << feature.background unless feature.background.nil?
-        scenarios << feature.scenarios
-      end
-      scenarios.flatten
-    end
-
-    def sort_improvement_list
-      sorted_array = @summary[:improvement_list].sort_by { |improvement, occurrence| occurrence }
-      @summary[:improvement_list] = {}
-      sorted_array.reverse.each { |node|
-        @summary[:improvement_list][node[0]] = node[1]
-      }
-    end
-
-    def create_improvement_list
-      output = []
-      @summary[:improvement_list].each_key { |improvement| output << "(#{summary[:improvement_list][improvement]})#{improvement}" }
-      output
-    end
-
-    def extract_steps_from_features
-      steps = {}
-      @features.each do |feature|
-        steps.merge! extract_scenario_steps(feature.background) unless feature.background.nil?
-        feature.scenarios.each do |scenario|
-          if scenario.type == "Scenario Outline"
-            steps.merge! extract_scenario_outline_steps(scenario)
-          else
-            steps.merge! extract_scenario_steps(scenario)
-          end
-        end
-      end
-      steps
-    end
-
-    def extract_scenario_steps(scenario)
-      steps_hash = {}
-      counter = 1
-      scenario.steps.each do |step|
-        location = scenario.location.gsub(/:\d*$/, ":#{scenario.start_line + counter}")
-        steps_hash[location] = step
-        counter += 1
-      end
-      steps_hash
-    end
-
-    def extract_scenario_outline_steps(scenario)
-      steps = {}
-      examples = scenario.examples_table
-      return {} if examples.empty?
-      variable_list = extract_variables_from_example(examples.first)
-      (1...examples.size).each do |example_counter|
-        #TODO Abstraction needed for this regex matcher (constants?)
-        next if examples[example_counter] =~ /^\#.*$/
-        row_variables = extract_variables_from_example(examples[example_counter])
-        step_counter = 1
-        scenario.steps.each do |step|
-          step_line = scenario.start_line + step_counter
-          location = "#{scenario.location.gsub(/\d+$/, step_line.to_s)}(Example #{example_counter})"
-          steps[location] = build_updated_step_from_example(step, variable_list, row_variables)
-          step_counter += 1
-        end
-      end
-      steps
-    end
-
-    def build_updated_step_from_example(step, variable_list, row_variables)
-      new_step = step.dup
-      variable_list.each do |variable|
-        if step.include? variable
-          table_variable_to_insert = row_variables[variable_list.index(variable)]
-          table_variable_to_insert ||= ""
-          new_step.gsub!("<#{variable}>", table_variable_to_insert)
-        end
-      end
-      new_step
-    end
-
-    def extract_steps_from_step_definitions
-      steps = {}
-      @step_definitions.each do |definition|
-        definition.nested_steps.each_key do |key|
-          steps[key] = definition.nested_steps[key]
-        end
-      end
-      steps
-    end
-
-    def extract_markup
-      markup_location = File.join(File.dirname(__FILE__), 'report', 'markup.rhtml')
-      markup = ""
-      File.open(markup_location).lines.each do |line|
-        markup << line
-      end
-      markup
-    end
-
-    def build_hooks(file_name)
-      hooks_file_lines = []
-      hooks_file = File.open(file_name)
-      hooks_file.each_line { |line| hooks_file_lines << line }
-      hooks_file.close
-
-      counter = 0
-      hooks_code = []
-      hooks = []
-      found_first_hook = false
-      until counter >= hooks_file_lines.length
-        if hooks_file_lines[counter] =~ HOOK_REGEX and !hooks_code.empty? and found_first_hook
-          hooks << CukeSniffer::Hook.new("#{file_name}:#{counter+1 - hooks_code.count}", hooks_code)
-          hooks_code = []
-        end
-        found_first_hook = true if hooks_file_lines[counter] =~ HOOK_REGEX
-        hooks_code << hooks_file_lines[counter].strip
-        counter+=1
-      end
-      hooks << CukeSniffer::Hook.new("#{file_name}:#{counter+1 -hooks_code.count}", hooks_code) unless hooks_code.empty? or !found_first_hook
-      hooks
-    end
-
-  end
-end
+require 'erb'
+require 'roxml'
+
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants, ROXML
+  class CLI
+    include CukeSniffer::Constants
+    include CukeSniffer::RuleConfig
+    include ROXML
+
+    xml_name "cuke_sniffer"
+    xml_accessor :rules, :as => [Rule], :in => "rules"
+    xml_accessor :features_summary, :as => CukeSniffer::SummaryNode
+    xml_accessor :scenarios_summary, :as => CukeSniffer::SummaryNode
+    xml_accessor :step_definitions_summary, :as => CukeSniffer::SummaryNode
+    xml_accessor :hooks_summary, :as => CukeSniffer::SummaryNode
+    xml_accessor :improvement_list, :as => {:key => "rule", :value => "total"}, :in => "improvement_list", :from => "improvement"
+    xml_accessor :features, :as => [CukeSniffer::Feature], :in => "features"
+    xml_accessor :step_definitions, :as => [CukeSniffer::StepDefinition], :in => "step_definitions"
+    xml_accessor :hooks, :as => [CukeSniffer::Hook], :in => "hooks"
+
+
+    # Feature array: All Features gathered from the specified folder
+    attr_accessor :features
+
+    # StepDefinition Array: All StepDefinitions objects gathered from the specified folder
+    attr_accessor :step_definitions
+
+    # Hash: Summary objects and improvement lists
+    # * Key: symbol, :total_score, :features, :step_definitions, :improvement_list
+    # * Value: hash or array
+    attr_accessor :summary
+
+    # string: Location of the feature file or root folder that was searched in
+    attr_accessor :features_location
+
+    # string: Location of the step definition file or root folder that was searched in
+    attr_accessor :step_definitions_location
+
+    # string: Location of the hook file or root folder that was searched in
+    attr_accessor :hooks_location
+
+    # Scenario array: All Scenarios found in the features from the specified folder
+    attr_accessor :scenarios
+
+    # Hook array: All Hooks found in the current directory
+    attr_accessor :hooks
+
+    # Rules hash: All the rules that exist at runtime and their corresponding data
+    attr_accessor :rules
+
+
+    # Does analysis against the passed features and step definition locations
+    #
+    # Can be called in several ways.
+    #
+    #
+    # No argument(assumes current directory is the project)
+    #  cuke_sniffer = CukeSniffer::CLI.new
+    #
+    # Against single files
+    #  cuke_sniffer = CukeSniffer::CLI.new({:features_location =>"my_feature.feature"})
+    # Or
+    #  cuke_sniffer = CukeSniffer::CLI.new({:step_definitions_location =>"my_steps.rb"})
+    # Or
+    #  cuke_sniffer = CukeSniffer::CLI.new({:hooks_location =>"my_hooks.rb"})
+    #
+    #
+    # Against folders
+    #  cuke_sniffer = CukeSniffer::CLI.new({:features_location =>"my_features_directory\", :step_definitions_location =>"my_steps_directory\"})
+    #
+    # You can mix and match all of the above examples
+    #
+    # Displays the sequence and a . indicator for each new loop in that process.
+    # Handles creation of all Feature and StepDefinition objects
+    # Then catalogs all step definition calls to be used for rules and identification
+    # of dead steps.
+    def initialize(parameters = {})
+      initialize_rule_targets(parameters)
+      evaluate_rules
+      catalog_step_calls
+      assess_score
+    end
+
+    # Returns the status of the overall project based on a comparison of the score to the threshold score
+    def good?
+      @summary[:total_score] <= Constants::THRESHOLDS["Project"]
+    end
+
+    # Calculates the score to threshold percentage of an object
+    # Return: Float
+    def problem_percentage
+      @summary[:total_score].to_f / Constants::THRESHOLDS["Project"].to_f
+    end
+
+    # Prints out a summary of the results and the list of improvements to be made
+    def output_results
+      CukeSniffer::Formatter.output_console(self)
+    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 output_html(file_name = DEFAULT_OUTPUT_FILE_NAME + ".html")
+      CukeSniffer::Formatter.output_html(self, file_name)
+    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 output_min_html(file_name = DEFAULT_OUTPUT_FILE_NAME + ".html")
+      CukeSniffer::Formatter.output_min_html(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_xml(file_name = DEFAULT_OUTPUT_FILE_NAME + ".xml")
+      CukeSniffer::Formatter.output_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
+    # 2: Symbol of :total with an integer that is the total number of dead steps
+    def get_dead_steps
+      CukeSniffer::DeadStepsHelper::build_dead_steps_hash(@step_definitions)
+    end
+
+    # Determines all normal and nested step calls and assigns them to the corresponding step definition.
+    # Does direct and fuzzy matching
+    def catalog_step_calls
+      puts "\nCataloging Step Calls: "
+      steps = CukeSniffer::CukeSnifferHelper.get_all_steps(@features, @step_definitions)
+      @step_definitions.each do |step_definition|
+        print '.'
+        calls = steps.find_all { |location, step| step.gsub(STEP_STYLES, "") =~ step_definition.regex }
+        calls.each { |call| step_definition.add_call(call[0], call[1].gsub(STEP_STYLES, "")) }
+      end
+
+      steps_with_expressions = CukeSniffer::CukeSnifferHelper.get_steps_with_expressions(steps)
+      converted_steps = CukeSniffer::CukeSnifferHelper.convert_steps_with_expressions(steps_with_expressions)
+      CukeSniffer::CukeSnifferHelper.catalog_possible_dead_steps(@step_definitions, converted_steps)
+    end
+
+    private
+
+    def initialize_rule_targets(parameters)
+      initialize_locations(parameters)
+      initialize_feature_objects
+
+      puts("\nStep Definitions: ")
+      @step_definitions = build_objects_for_extension_from_location(@step_definitions_location, "rb") { |location| build_step_definitions(location) }
+
+      puts("\nHooks:")
+      @hooks = build_objects_for_extension_from_location(@hooks_location, "rb") { |location| build_hooks(location) }
+    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
+    end
+
+    def initialize_feature_objects
+      puts "\nFeatures:"
+      @features = build_objects_for_extension_from_location(features_location, "feature") { |location| CukeSniffer::Feature.new(location) }
+      @scenarios = CukeSniffer::CukeSnifferHelper.get_all_scenarios(@features)
+    end
+
+    def evaluate_rules
+      @rules = CukeSniffer::CukeSnifferHelper.build_rules(RULES)
+      CukeSniffer::RulesEvaluator.new(self, @rules)
+    end
+
+    def initialize_summary
+      @summary = {
+          :total_score => 0,
+          :improvement_list => {}
+      }
+    end
+
+    def assess_score
+      puts "\nAssessing Score: "
+      initialize_summary
+      summarize(:features, @features, "Feature", @features_summary)
+      summarize(:scenarios, @scenarios, "Scenario", @scenarios_summary)
+      summarize(:step_definitions, @step_definitions, "StepDefinition", @step_definitions_summary)
+      summarize(:hooks, @hooks, "Hook", @hooks_summary)
+      @summary[:improvement_list] = CukeSniffer::SummaryHelper.sort_improvement_list(@summary[:improvement_list])
+      @improvement_list = @summary[:improvement_list]
+    end
+
+    def summarize(symbol, list, name, summary_object)
+      @summary[symbol] = CukeSniffer::SummaryHelper.assess_rule_target_list(list, name)
+      @summary[:total_score] = @summary[symbol][:total_score]
+      @summary[symbol][:improvement_list].each do |phrase, count|
+        @summary[:improvement_list][phrase] ||= 0
+        @summary[:improvement_list][phrase] += @summary[symbol][:improvement_list][phrase]
+      end
+      summary_object = CukeSniffer::SummaryHelper::load_summary_data(@summary[symbol])
+    end
+
+    def build_step_definitions(file_name)
+      build_object_for_extension_from_file(file_name, STEP_DEFINITION_REGEX, CukeSniffer::StepDefinition)
+    end
+
+    def build_hooks(file_name)
+      build_object_for_extension_from_file(file_name, HOOK_REGEX, CukeSniffer::Hook)
+    end
+
+    def build_file_list_for_extension_from_location(pattern_location, extension)
+      list = []
+      unless pattern_location.nil?
+        if File.file?(pattern_location)
+          [pattern_location]
+        else
+          Dir["#{pattern_location}/**/*.#{extension}"]
+        end
+      end
+    end
+
+    def build_objects_for_extension_from_location(pattern_location, extension, &block)
+      file_list = build_file_list_for_extension_from_location(pattern_location, extension)
+      list = []
+      file_list.each {|file_name|
+        print '.'
+        list << block.call(file_name)
+      }
+      list.flatten
+    end
+
+
+    def build_object_for_extension_from_file(file_name, regex, cuke_sniffer_class)
+      file_lines = IO.readlines(file_name)
+
+      counter = 0
+      code = []
+      object_list = []
+      found_first_object = false
+      until counter >= file_lines.length
+        if file_lines[counter] =~ regex and !code.empty? and found_first_object
+          location = "#{file_name}:#{counter+1 - code.count}"
+          object_list << cuke_sniffer_class.new(location, code)
+          code = []
+        end
+        found_first_object = true if file_lines[counter] =~ regex
+        code << file_lines[counter].strip
+        counter+=1
+      end
+      location = "#{file_name}:#{counter+1 -code.count}"
+      object_list << cuke_sniffer_class.new(location, code) unless code.empty? or !found_first_object
+      object_list
+    end
+
+  end
+end