reek 3.0.4 → 3.1

data/lib/reek/cli/application.rb

@@ -14,6 +14,7 @@ module Reek
       STATUS_SUCCESS = 0
       STATUS_ERROR   = 1
       STATUS_SMELLS  = 2
+      attr_reader :configuration
 
       def initialize(argv)
         @status = STATUS_SUCCESS
@@ -21,7 +22,7 @@ module Reek
         begin
           @options = options_parser.parse
           @command = ReekCommand.new(OptionInterpreter.new(@options))
-          initialize_configuration
+          @configuration = Configuration::AppConfiguration.new @options
         rescue OptionParser::InvalidOption, Reek::Configuration::ConfigFileException => error
           $stderr.puts "Error: #{error}"
           @status = STATUS_ERROR
@@ -34,10 +35,6 @@ module Reek
         @status
       end
 
-      def initialize_configuration
-        Configuration::AppConfiguration.initialize_with @options
-      end
-
       def output(text)
         print text
       end

data/lib/reek/cli/reek_command.rb

@@ -11,7 +11,7 @@ module Reek
     class ReekCommand < Command
       def execute(app)
         @options.sources.each do |source|
-          reporter.add_examiner Examiner.new(source, smell_names)
+          reporter.add_examiner Examiner.new(source, smell_names, configuration: app.configuration)
         end
         reporter.smells? ? app.report_smells : app.report_success
         reporter.show

data/lib/reek/configuration/app_configuration.rb

@@ -1,90 +1,144 @@
+require 'pathname'
 require_relative './configuration_file_finder'
 
 module Reek
   # @api private
   module Configuration
     # @api private
-    class ConfigFileException < StandardError; end
     #
     # Reek's singleton configuration instance.
     #
     # @api private
-    module AppConfiguration
-      NON_SMELL_TYPE_KEYS   = %w(exclude_paths)
-      EXCLUDE_PATHS_KEY     = 'exclude_paths'
-      @configuration        = {}
-      @has_been_initialized = false
-
-      class << self
-        attr_reader :configuration
-
-        def initialize_with(options)
-          @has_been_initialized = true
-          configuration_file_path = ConfigurationFileFinder.find(options: options)
-          return unless configuration_file_path
-          load_from_file configuration_file_path
-        end
+    class AppConfiguration
+      EXCLUDE_PATHS_KEY = 'exclude_paths'
+      attr_reader :exclude_paths, :default_directive, :directory_directives
 
-        def configure_smell_repository(smell_repository)
-          # Let users call this method directly without having initialized AppConfiguration before
-          # and if they do, initialize it without application context
-          initialize_with(nil) unless @has_been_initialized
-          for_smell_types.each do |klass_name, config|
-            klass = load_smell_type(klass_name)
-            smell_repository.configure(klass, config) if klass
-          end
-        end
+      # Given this configuration file:
+      #
+      # ---
+      # IrresponsibleModule:
+      #   enabled: false
+      # "app/helpers":
+      #   UtilityFunction:
+      #     enabled: false
+      # exclude_paths:
+      #   - "app/controllers"
+      #
+      # this would result in the following configuration:
+      #
+      # exclude_paths = [ Pathname('spec/samples/two_smelly_files') ]
+      # default_directive = { Reek::Smells::IrresponsibleModule => { "enabled" => false } }
+      # directory_directives = { Pathname("spec/samples/three_clean_files/") =>
+      #                          { Reek::Smells::UtilityFunction => { "enabled" => false } } }
+      #
+      #
+      # @param options [OpenStruct]
+      #   e.g.: #<OpenStruct report_format =: text,
+      #                      location_format =: numbers,
+      #                      colored = true,
+      #                      smells_to_detect = [],
+      #                      config_file = #<Pathname:config/defaults.reek>,
+      #                      argv = [ "lib/reek/spec" ]>
+      def initialize(options = nil)
+        self.directory_directives = {}
+        self.default_directive    = {}
+        self.exclude_paths        = []
 
-        def load_from_file(path)
-          if File.size(path) == 0
-            report_problem('Empty file', path)
-            return
-          end
+        load options
+      end
 
-          begin
-            @configuration = YAML.load_file(path) || {}
-          rescue => error
-            raise_error(error.to_s, path)
-          end
+      # @param source_via [String] - the source of the code inspected
+      # @return [Hash] the directory directive for the source or, if there is
+      # none, the default directive
+      def directive_for(source_via)
+        directory_directive_for_source(source_via) || default_directive
+      end
 
-          raise_error('Not a hash', path) unless @configuration.is_a? Hash
-        end
+      private
 
-        def reset
-          @configuration.clear
-        end
+      attr_writer :exclude_paths, :default_directive, :directory_directives
 
-        def exclude_paths
-          @exclude_paths ||= @configuration.
-            fetch(EXCLUDE_PATHS_KEY, []).
-            map { |path| path.chomp('/') }
-        end
+      # @param source_via [String] - the source of the code inspected
+      # Might be a string, STDIN or Filename / Pathname. We're only interested in the source
+      # when it's coming from file since a directory_directive doesn't make sense
+      # for anything else.
+      # @return [Hash | nil] the configuration for the source or nil
+      def directory_directive_for_source(source_via)
+        return unless source_via
+        source_base_dir = Pathname.new(source_via).dirname
+        hit = best_directory_match_for source_base_dir
+        directory_directives[hit]
+      end
 
-        private
+      def load(options)
+        configuration_file = ConfigurationFileFinder.find_and_load(options: options)
 
-        def for_smell_types
-          @configuration.reject { |key, _value| NON_SMELL_TYPE_KEYS.include?(key) }
+        configuration_file.each do |key, value|
+          case
+          when key == EXCLUDE_PATHS_KEY
+            handle_exclude_paths(value)
+          when smell_type?(key)
+            handle_default_directive(key, value)
+          else
+            handle_directory_directive(key, value)
+          end
         end
+      end
 
-        def load_smell_type(name)
-          Reek::Smells.const_get(name)
-        rescue NameError
-          report_problem("\"#{name}\" is not a code smell")
-          nil
+      def handle_exclude_paths(paths)
+        self.exclude_paths = paths.map do |path|
+          pathname = Pathname.new path.chomp('/')
+          raise ArgumentError, "Excluded directory #{path} does not exists" unless pathname.exist?
+          pathname
         end
+      end
 
-        def report_problem(reason, path)
-          $stderr.puts "Warning: #{message(reason, path)}"
-        end
+      def handle_default_directive(key, config)
+        klass = Reek::Smells.const_get(key)
+        default_directive[klass] = config
+      end
 
-        def raise_error(reason, path)
-          raise ConfigFileException, message(reason, path)
-        end
+      def handle_directory_directive(path, config)
+        pathname = Pathname.new path.chomp('/')
+        validate_directive pathname
 
-        def message(reason, path)
-          "Invalid configuration file \"#{File.basename(path)}\" -- #{reason}"
+        directory_directives[pathname] = config.each_with_object({}) do |(key, value), hash|
+          abort(error_message_for_invalid_smell_type(key)) unless smell_type?(key)
+          hash[Reek::Smells.const_get(key)] = value
         end
       end
+
+      def best_directory_match_for(source_base_dir)
+        directory_directives.
+          keys.
+          select { |pathname| source_base_dir.to_s =~ /#{pathname}/ }.
+          max_by { |pathname| pathname.to_s.length }
+      end
+
+      def smell_type?(key)
+        Reek::Smells.const_get key
+      rescue NameError
+        false
+      end
+
+      def error_message_for_invalid_smell_type(klass)
+        "You are trying to configure smell type #{klass} but we can't find one with that name.\n" \
+          "Please make sure you spelled it right (see 'config/defaults.reek' in the reek\n" \
+          'repository for a list of all available smell types.'
+      end
+
+      def error_message_for_missing_directory(pathname)
+        "Configuration error: Directory `#{pathname}` does not exist"
+      end
+
+      def error_message_for_file_given(pathname)
+        "Configuration error: `#{pathname}` is supposed to be a directory but is a file"
+      end
+
+      def validate_directive(pathname)
+        abort(error_message_for_missing_directory(pathname)) unless pathname.exist?
+        abort(error_message_for_file_given(pathname)) unless pathname.directory?
+      end
     end
   end
 end

data/lib/reek/configuration/configuration_file_finder.rb

@@ -2,6 +2,7 @@ require 'pathname'
 
 module Reek
   module Configuration
+    class ConfigFileException < StandardError; end
     #
     # ConfigurationFileFinder is responsible for finding reek's configuration.
     #
@@ -17,6 +18,10 @@ module Reek
     module ConfigurationFileFinder
       module_function
 
+      def find_and_load(params = {})
+        load_from_file(find(params))
+      end
+
       # FIXME: switch to kwargs on upgrade to Ruby 2 and drop `params.fetch` calls:
       # def find(options: nil, current: Pathname.pwd, home: Pathname.new(Dir.home))
       def find(params = {})
@@ -37,6 +42,20 @@ module Reek
           return found if found
         end
       end
+
+      def load_from_file(path)
+        return {} unless path
+        begin
+          configuration = YAML.load_file(path) || {}
+        rescue => error
+          raise ConfigFileException, "Invalid configuration file #{path}, error is #{error}"
+        end
+
+        unless configuration.is_a? Hash
+          raise ConfigFileException, "Invalid configuration file \"#{path}\" -- Not a hash"
+        end
+        configuration
+      end
     end
   end
 end

data/lib/reek/context/code_context.rb

@@ -1,6 +1,8 @@
 require_relative '../code_comment'
+require_relative '../ast/object_refs'
 
 module Reek
+  # @api private
   module Context
     #
     # Superclass for all types of source code context. Each instance represents
@@ -11,23 +13,27 @@ module Reek
     # @api private
     class CodeContext
       attr_reader :exp
+      attr_reader :num_statements
+      attr_reader :children
+      attr_reader :visibility
 
       # Initializes a new CodeContext.
       #
-      # context - *_context from the `core` namespace
-      # exp - Reek::Source::ASTNode
+      # @param context [CodeContext, nil] The parent context
+      # @param exp [Reek::AST::Node] The code described by this context
       #
-      # Examples:
+      # For example, given the following code:
       #
-      # Given something like:
+      #   class Omg
+      #     def foo(x)
+      #       puts x
+      #     end
+      #   end
       #
-      #   class Omg; def foo(x); puts x; end; end
+      # The {TreeWalker} object first instantiates a {RootContext}, which has no parent.
       #
-      # the first time this is instantianted from TreeWalker `context` is a RootContext:
-      #
-      #   #<Reek::Context::RootContext:0x00000002231098 @name="">
-      #
-      # and `exp` looks like this:
+      # Next, it instantiates a {ModuleContext}, with +context+ being the
+      # {RootContext} just created, and +exp+ looking like this:
       #
       #  (class
       #    (const nil :Omg) nil
@@ -37,20 +43,55 @@ module Reek
       #      (send nil :puts
       #        (lvar :x))))
       #
-      # The next time we instantiate a CodeContext via TreeWalker `context` would be:
+      # Finally, {TreeWalker} will instantiate a {MethodContext}. This time,
+      # +context+ is the {ModuleContext} created above, and +exp+ is:
       #
-      #   Reek::Context::ModuleContext
+      #   (def :foo
+      #     (args
+      #       (arg :x))
+      #     (send nil :puts
+      #       (lvar :x)))
+      def initialize(context, exp)
+        @context    = context
+        @exp        = exp
+        @visibility = :public
+        @children   = []
+
+        @num_statements = 0
+        @refs = AST::ObjectRefs.new
+      end
+
+      # Register a child context. The child's parent context should be equal to
+      # the current context.
       #
-      # and `exp` is:
+      # This makes the current context responsible for setting the child's
+      # visibility.
       #
-      # (def :foo
-      #   (args
-      #     (arg :x))
-      #   (send nil :puts
-      #     (lvar :x)))
-      def initialize(context, exp)
-        @context = context
-        @exp     = exp
+      # @param child [CodeContext] the child context to register
+      def append_child_context(child)
+        child.visibility = tracked_visibility
+        @children << child
+      end
+
+      def count_statements(num)
+        @num_statements += num
+      end
+
+      def record_call_to(exp)
+        receiver = exp.receiver
+        type = receiver ? receiver.type : :self
+        case type
+        when :lvar, :lvasgn
+          unless exp.object_creation_call?
+            @refs.record_reference_to(receiver.name, line: exp.line)
+          end
+        when :self
+          @refs.record_reference_to(:self, line: exp.line)
+        end
+      end
+
+      def record_use_of_self
+        @refs.record_reference_to(:self)
       end
 
       def name
@@ -73,14 +114,6 @@ module Reek
         end
       end
 
-      #
-      # Bounces messages up the context tree to the first enclosing context
-      # that knows how to deal with the request.
-      #
-      def method_missing(method, *args)
-        @context.send(method, *args)
-      end
-
       def num_methods
         0
       end
@@ -95,8 +128,48 @@ module Reek
           config[detector_class.smell_type] || {})
       end
 
+      # Handle the effects of a visibility modifier.
+      #
+      # @example Setting the current visibility
+      #   track_visibility :public
+      #
+      # @example Modifying the visibility of existing children
+      #   track_visibility :private, [:hide_me, :implementation_detail]
+      #
+      # @param visibility [Symbol]
+      # @param names [Array<Symbol>]
+      def track_visibility(visibility, names = [])
+        if names.any?
+          @children.each do |child|
+            child.visibility = visibility if names.include? child.name
+          end
+        else
+          @tracked_visibility = visibility
+        end
+      end
+
+      def type
+        @exp.type
+      end
+
+      # Iterate over +self+ and child contexts.
+      def each(&block)
+        yield self
+        @children.each do |child|
+          child.each(&block)
+        end
+      end
+
+      protected
+
+      attr_writer :visibility
+
       private
 
+      def tracked_visibility
+        @tracked_visibility ||= :public
+      end
+
       def config
         @config ||= if @exp
                       CodeComment.new(@exp.full_comment || '').config