reek 1.6.6 → 2.0.0

data/lib/reek/cli/report/formatter.rb

@@ -1,8 +1,14 @@
+require 'reek/cli/report/location_formatter'
+
 module Reek
   module Cli
     module Report
+      #
+      # Formatter handling the formatting of the report at large. Formatting
+      # the individual warnings is handled by the warning formatter passed in.
+      #
       module Formatter
-        def self.format_list(warnings, formatter = SimpleWarningFormatter)
+        def self.format_list(warnings, formatter = SimpleWarningFormatter.new)
           warnings.map do |warning|
             "  #{formatter.format warning}"
           end.join("\n")
@@ -17,41 +23,44 @@ module Reek
         end
       end
 
-      module UltraVerboseWarningFormattter
-        BASE_URL_FOR_HELP_LINK = 'https://github.com/troessner/reek/wiki/'
-
-        module_function
+      #
+      # Basic formatter that just shows a simple message for each warning,
+      # pre-pended with the result of the passed-in location formatter.
+      #
+      class SimpleWarningFormatter
+        def initialize(location_formatter = BlankLocationFormatter)
+          @location_formatter = location_formatter
+        end
 
         def format(warning)
-          "#{WarningFormatterWithLineNumbers.format(warning)} " \
-          "[#{explanatory_link(warning)}]"
+          "#{@location_formatter.format(warning)}#{base_format(warning)}"
         end
 
-        def explanatory_link(warning)
-          "#{BASE_URL_FOR_HELP_LINK}#{class_name_to_param(warning.smell_type)}"
-        end
+        private
 
-        def class_name_to_param(name)
-          name.split(/(?=[A-Z])/).join('-')
+        def base_format(warning)
+          "#{warning.context} #{warning.message} (#{warning.smell_type})"
         end
       end
 
-      module SimpleWarningFormatter
-        def self.format(warning)
-          "#{warning.context} #{warning.message} (#{warning.smell_type})"
+      #
+      # Formatter that adds a link to the Wiki to the basic message from
+      # SimpleWarningFormatter.
+      #
+      class WikiLinkWarningFormatter < SimpleWarningFormatter
+        BASE_URL_FOR_HELP_LINK = 'https://github.com/troessner/reek/wiki/'
+
+        def format(warning)
+          "#{super} " \
+          "[#{explanatory_link(warning)}]"
         end
-      end
 
-      module WarningFormatterWithLineNumbers
-        def self.format(warning)
-          "#{warning.lines.inspect}:#{SimpleWarningFormatter.format(warning)}"
+        def explanatory_link(warning)
+          "#{BASE_URL_FOR_HELP_LINK}#{class_name_to_param(warning.smell_type)}"
         end
-      end
 
-      module SingleLineWarningFormatter
-        def self.format(warning)
-          "#{warning.source}:#{warning.lines.first}: " \
-          "#{SimpleWarningFormatter.format(warning)}"
+        def class_name_to_param(name)
+          name.split(/(?=[A-Z])/).join('-')
         end
       end
     end

data/lib/reek/cli/report/heading_formatter.rb

@@ -0,0 +1,45 @@
+module Reek
+  module Cli
+    module Report
+      module HeadingFormatter
+        #
+        # Base class for heading formatters.
+        # Is responsible for formatting the heading emitted for each examiner
+        #
+        class Base
+          attr_reader :report_formatter
+
+          def initialize(report_formatter)
+            @report_formatter = report_formatter
+          end
+
+          def header(examiner)
+            if show_header?(examiner)
+              report_formatter.header examiner
+            else
+              ''
+            end
+          end
+        end
+
+        #
+        # Lists out each examiner, even if it has no smell
+        #
+        class Verbose < Base
+          def show_header?(_examiner)
+            true
+          end
+        end
+
+        #
+        # Lists only smelly examiners
+        #
+        class Quiet < Base
+          def show_header?(examiner)
+            examiner.smelly?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reek/cli/report/location_formatter.rb

@@ -0,0 +1,23 @@
+module Reek
+  module Cli
+    module Report
+      module BlankLocationFormatter
+        def self.format(_warning)
+          ''
+        end
+      end
+
+      module DefaultLocationFormatter
+        def self.format(warning)
+          "#{warning.lines.inspect}:"
+        end
+      end
+
+      module SingleLineLocationFormatter
+        def self.format(warning)
+          "#{warning.source}:#{warning.lines.first}: "
+        end
+      end
+    end
+  end
+end

data/lib/reek/cli/report/report.rb

@@ -11,13 +11,9 @@ module Reek
         NO_WARNINGS_COLOR = :green
         WARNINGS_COLOR = :red
 
-        def initialize(options = {})
-          @warning_formatter   = options.fetch :warning_formatter, SimpleWarningFormatter
-          @report_formatter    = options.fetch :report_formatter, Formatter
+        def initialize(_options = {})
           @examiners           = []
           @total_smell_count   = 0
-          @sort_by_issue_count = options.fetch :sort_by_issue_count, false
-          @strategy = options.fetch(:strategy, Strategy::Quiet)
         end
 
         def add_examiner(examiner)
@@ -31,7 +27,7 @@ module Reek
         end
 
         def smells
-          @strategy.new(@report_formatter, @warning_formatter, @examiners).gather_results
+          @examiners.map(&:smells).flatten
         end
       end
 
@@ -39,12 +35,26 @@ module Reek
       # Generates a sorted, text summary of smells in examiners
       #
       class TextReport < Base
+        def initialize(options = {})
+          super options
+          @options = options
+          @warning_formatter   = options.fetch :warning_formatter, SimpleWarningFormatter.new
+          @report_formatter    = options.fetch :report_formatter, Formatter
+          @sort_by_issue_count = options.fetch :sort_by_issue_count, false
+        end
+
         def show
           sort_examiners if smells?
           display_summary
           display_total_smell_count
         end
 
+        def smells
+          @examiners.each_with_object([]) do |examiner, result|
+            result << summarize_single_examiner(examiner)
+          end
+        end
+
         private
 
         def display_summary
@@ -57,6 +67,16 @@ module Reek
           print total_smell_count_message
         end
 
+        def summarize_single_examiner(examiner)
+          result = heading_formatter.header(examiner)
+          if examiner.smelly?
+            formatted_list = @report_formatter.format_list(examiner.smells,
+                                                           @warning_formatter)
+            result += ":\n#{formatted_list}"
+          end
+          result
+        end
+
         def sort_examiners
           @examiners.sort_by!(&:smells_count).reverse! if @sort_by_issue_count
         end
@@ -66,19 +86,19 @@ module Reek
           s = @total_smell_count == 1 ? '' : 's'
           Rainbow("#{@total_smell_count} total warning#{s}\n").color(colour)
         end
+
+        def heading_formatter
+          @heading_formatter ||=
+            @options.fetch(:heading_formatter, HeadingFormatter::Quiet).new(@report_formatter)
+        end
       end
 
       #
       # Displays a list of smells in YAML format
       # YAML with empty array for 0 smells
       class YamlReport < Base
-        def initialize(options = {})
-          @options = options
-          super options.merge!(strategy: Strategy::Normal)
-        end
-
         def show
-          print(smells.to_yaml)
+          print smells.map(&:yaml_hash).to_yaml
         end
       end
 
@@ -86,11 +106,6 @@ module Reek
       # Saves the report as a HTML file
       #
       class HtmlReport < Base
-        def initialize(options = {})
-          @options = options
-          super @options.merge!(strategy: Strategy::Normal)
-        end
-
         require 'erb'
 
         def show

data/lib/reek/configuration/app_configuration.rb

@@ -13,9 +13,9 @@ module Reek
       class << self
         attr_reader :configuration
 
-        def initialize_with(application)
+        def initialize_with(options)
           @has_been_initialized = true
-          configuration_file_path = ConfigurationFileFinder.find(application)
+          configuration_file_path = ConfigurationFileFinder.find(options)
           return unless configuration_file_path
           load_from_file configuration_file_path
         end

data/lib/reek/configuration/configuration_file_finder.rb

@@ -6,26 +6,26 @@ module Reek
     # ConfigurationFileFinder is responsible for finding reeks configuration.
     #
     # There are 3 ways of passing `reek` a configuration file:
-    # 1. Using the cli "-c" switch (see "Command line interface" above)
-    # 2. Having a file ending with .reek either in your current working directory or in a parent
-    #    directory
+    # 1. Using the cli "-c" switch
+    # 2. Having a file ending with .reek either in your current working
+    #    directory or in a parent directory
     # 3. Having a file ending with .reek in your HOME directory
     #
-    # The order in which ConfigurationFileFinder tries to find such a configuration file is exactly
-    # like above.
+    # The order in which ConfigurationFileFinder tries to find such a
+    # configuration file is exactly like above.
     module ConfigurationFileFinder
       class << self
-        def find(application)
-          configuration_by_cli(application) ||
+        def find(options)
+          configuration_by_cli(options) ||
             configuration_in_file_system    ||
             configuration_in_home_directory
         end
 
         private
 
-        def configuration_by_cli(application)
-          return unless application # Return gracefully allowing calls without app context
-          config_file_option = application.options.config_file
+        def configuration_by_cli(options)
+          return unless options # Return gracefully allowing calls without app context
+          config_file_option = options.config_file
           return unless config_file_option
           path_name = Pathname.new config_file_option
           raise ArgumentError, "Config file #{path_name} doesn't exist" unless path_name.exist?

data/lib/reek/core/smell_repository.rb

@@ -1,4 +1,5 @@
 require 'reek/smells'
+require 'reek/smells/smell_detector'
 
 module Reek
   module Core
@@ -9,36 +10,10 @@ module Reek
       attr_reader :detectors
 
       def self.smell_types
-        # SMELL: Duplication -- these should be loaded by listing the files
-        [
-          Smells::Attribute,
-          Smells::BooleanParameter,
-          Smells::ClassVariable,
-          Smells::ControlParameter,
-          Smells::DataClump,
-          Smells::DuplicateMethodCall,
-          Smells::FeatureEnvy,
-          Smells::IrresponsibleModule,
-          Smells::LongParameterList,
-          Smells::LongYieldList,
-          Smells::ModuleInitialize,
-          Smells::NestedIterators,
-          Smells::NilCheck,
-          Smells::PrimaDonnaMethod,
-          Smells::RepeatedConditional,
-          Smells::TooManyInstanceVariables,
-          Smells::TooManyMethods,
-          Smells::TooManyStatements,
-          Smells::UncommunicativeMethodName,
-          Smells::UncommunicativeModuleName,
-          Smells::UncommunicativeParameterName,
-          Smells::UncommunicativeVariableName,
-          Smells::UnusedParameters,
-          Smells::UtilityFunction
-        ]
+        Reek::Smells::SmellDetector.descendants
       end
 
-      def initialize(source_description, smell_types = SmellRepository.smell_types)
+      def initialize(source_description, smell_types = self.class.smell_types)
         @typed_detectors = nil
         @detectors = {}
         smell_types.each do |klass|

data/lib/reek/rake/task.rb

@@ -3,6 +3,7 @@
 require 'rake'
 require 'rake/tasklib'
 require 'pathname'
+require 'English'
 
 module Reek
   #
@@ -32,126 +33,84 @@ module Reek
     #   rake reek REEK_OPTS=-s                   # sorts the report by smell
     #
     class Task < ::Rake::TaskLib
-      # Name of reek task.
-      # Defaults to :reek.
-      attr_accessor :name
+      # Name of reek task. Defaults to :reek.
+      attr_writer :name
 
-      # Array of directories to be added to $LOAD_PATH before running reek.
-      # Defaults to ['<the absolute path to reek's lib directory>']
-      attr_accessor :libs
-
-      # Glob pattern to match config files.
+      # Path to reeks config file.
       # Setting the REEK_CFG environment variable overrides this.
-      # Defaults to 'config/**/*.reek'.
-      attr_accessor :config_file
-
-      def config_files=(value)
-        @config_file = value
-      end
-
-      def config_files
-        @config_file
-      end
+      attr_writer :config_file
 
       # Glob pattern to match source files.
       # Setting the REEK_SRC environment variable overrides this.
       # Defaults to 'lib/**/*.rb'.
-      attr_accessor :source_files
+      attr_writer :source_files
 
       # String containing commandline options to be passed to Reek.
       # Setting the REEK_OPTS environment variable overrides this value.
       # Defaults to ''.
-      attr_accessor :reek_opts
-
-      # Array of commandline options to pass to ruby. Defaults to [].
-      attr_accessor :ruby_opts
+      attr_writer :reek_opts
 
       # Whether or not to fail Rake when an error occurs (typically when smells are found).
       # Defaults to true.
-      attr_accessor :fail_on_error
+      attr_writer :fail_on_error
 
       # Use verbose output. If this is set to true, the task will print
       # the reek command to stdout. Defaults to false.
-      attr_accessor :verbose
+      attr_writer :verbose
 
-      # Defines a new task, using the name +name+.
       def initialize(name = :reek)
-        @name = name
-        @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
-        @config_file = nil
-        @source_files = nil
-        @ruby_opts = []
-        @reek_opts = ''
+        @name          = name
+        @reek_opts     = ''
         @fail_on_error = true
-        @sort = nil
+        @source_files  = 'lib/**/*.rb'
+        @verbose       = false
 
         yield self if block_given?
-        @config_file ||= Pathname.glob('config/**/*.reek').detect(&:file?)
-        @source_files ||= 'lib/**/*.rb'
-        define
+        define_task
       end
 
       private
 
-      def define # :nodoc:
-        desc 'Check for code smells' unless ::Rake.application.last_comment
-        task(name) { run_task }
-        self
+      def define_task
+        desc 'Check for code smells'
+        task(@name) { run_task }
       end
 
       def run_task
-        return if source_file_list.empty?
-        cmd = cmd_words.join(' ')
-        puts cmd if @verbose
-        raise('Smells found!') if !system(cmd) && fail_on_error
+        puts "\n\n!!! Running 'reek' rake command: #{command}\n\n" if @verbose
+        system(*command)
+        abort("\n\n!!! `reek` has found smells - exiting!") if sys_call_failed? && @fail_on_error
       end
 
-      def self.ruby_exe
-        File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+      def command
+        ['reek', *config_file_as_argument, *reek_opts_as_arguments, *source_files].
+          compact.
+          reject(&:empty?)
       end
 
-      def cmd_words
-        [Task.ruby_exe] +
-          ruby_options +
-          [%(reek)] +
-          [sort_option] +
-          config_option +
-          source_file_list.map { |fn| %("#{fn}") }
+      def source_files
+        FileList[ENV['REEK_SRC'] || @source_files]
       end
 
-      def config_option
-        if config_file
-          ['-c', config_file]
-        else
-          []
-        end
+      def reek_opts
+        ENV['REEK_OPTS'] || @reek_opts
       end
 
       def config_file
         ENV['REEK_CFG'] || @config_file
       end
 
-      def ruby_options
-        if bundler?
-          %w(-S bundle exec)
-        else
-          lib_path = @libs.join(File::PATH_SEPARATOR)
-          @ruby_opts.clone << "-I\"#{lib_path}\""
-        end
+      def sys_call_failed?
+        !$CHILD_STATUS.success?
       end
 
-      def bundler?
-        File.exist?('./Gemfile')
-      end
-
-      def sort_option
-        ENV['REEK_OPTS'] || @reek_opts
+      def config_file_as_argument
+        return [] unless @config_file
+        ['-c', @config_file]
       end
 
-      def source_file_list # :nodoc:
-        files = ENV['REEK_SRC'] || @source_files
-        return [] unless files
-        FileList[files]
+      def reek_opts_as_arguments
+        reek_opts.split(/\s+/)
       end
     end
   end