reek 3.0.4 → 3.1

data/lib/reek/context/method_context.rb

@@ -1,63 +1,17 @@
 require_relative 'code_context'
-require_relative '../ast/object_refs'
 
 module Reek
   module Context
-    #
-    # The parameters in a method's definition.
-    #
-    # @api private
-    module MethodParameters
-      def default_assignments
-        result = []
-        each do |exp|
-          result << exp[1..2] if exp.optional_argument?
-        end
-        result
-      end
-    end
-
     #
     # A context wrapper for any method definition found in a syntax tree.
     #
     # @api private
     class MethodContext < CodeContext
-      attr_reader :parameters
       attr_reader :refs
-      attr_reader :num_statements
-
-      def initialize(outer, exp)
-        super
-        @parameters = exp.parameters.dup
-        @parameters.extend MethodParameters
-        @num_statements = 0
-        @refs = AST::ObjectRefs.new
-      end
-
-      def count_statements(num)
-        @num_statements += num
-      end
-
-      def record_call_to(exp)
-        receiver, meth = exp[1..2]
-        receiver ||= [:self]
-        case receiver[0]
-        when :lvasgn
-          @refs.record_reference_to(receiver.name, line: exp.line)
-        when :lvar
-          @refs.record_reference_to(receiver.name, line: exp.line) unless meth == :new
-        when :self
-          @refs.record_reference_to(:self, line: exp.line)
-        end
-      end
-
-      def record_use_of_self
-        @refs.record_reference_to(:self)
-      end
 
       def envious_receivers
-        return {} if @refs.self_is_max?
-        @refs.most_popular
+        return {} if refs.self_is_max?
+        refs.most_popular
       end
 
       def references_self?
@@ -79,6 +33,15 @@ module Reek
       def uses_super_with_implicit_arguments?
         (body = exp.body) && body.contains_nested_node?(:zsuper)
       end
+
+      def default_assignments
+        @default_assignments ||=
+          exp.parameters.select(&:optional_argument?).map(&:children)
+      end
+
+      def singleton_method?
+        exp.singleton_method? || visibility == :module_function
+      end
     end
   end
 end

data/lib/reek/context/module_context.rb

@@ -8,11 +8,6 @@ module Reek
     #
     # @api private
     class ModuleContext < CodeContext
-      def initialize(outer, exp)
-        super(outer, exp)
-        @name = AST::SexpFormatter.format(exp.children.first)
-      end
-
       def node_instance_methods
         local_nodes(:def)
       end
@@ -28,8 +23,9 @@ module Reek
       #
       # @return true if the module is a namespace module
       def namespace_module?
+        return false if exp.type == :casgn
         contents = exp.children.last
-        contents && contents.find_nodes([:def, :defs], [:class, :module]).empty?
+        contents && contents.find_nodes([:def, :defs], [:casgn, :class, :module]).empty?
       end
     end
   end

data/lib/reek/context/root_context.rb

@@ -1,25 +1,18 @@
+require_relative 'code_context'
+
 module Reek
-  # @api private
   module Context
     #
     # A context wrapper representing the root of an abstract syntax tree.
     #
     # @api private
-    class RootContext
-      def initialize
-        @name = ''
-      end
-
-      def method_missing(_method, *_args)
-        nil
-      end
-
-      def config_for(_)
-        {}
+    class RootContext < CodeContext
+      def initialize(exp)
+        super(nil, exp)
       end
 
-      def count_statements(_num)
-        0
+      def type
+        :root
       end
 
       def full_name

data/lib/reek/examiner.rb

@@ -21,13 +21,16 @@ module Reek
     #   If +source+ is a String it is assumed to be Ruby source code;
     #   if it is a File or IO, it is opened and Ruby source code is read from it;
     #
-    # @param smell_types_to_filter_by [Array<String>]
+    # @param filter_by_smells [Array<String>]
     #   List of smell types to filter by.
     #
-    def initialize(source, smell_types_to_filter_by = [])
-      @source       = Source::SourceCode.from(source)
-      @collector    = CLI::WarningCollector.new
-      @smell_types  = eligible_smell_types(smell_types_to_filter_by)
+    def initialize(source,
+                   filter_by_smells = [],
+                   configuration: Configuration::AppConfiguration.new)
+      @source        = Source::SourceCode.from(source)
+      @configuration = configuration
+      @collector     = CLI::WarningCollector.new
+      @smell_types   = eligible_smell_types(filter_by_smells)
 
       run
     end
@@ -63,16 +66,18 @@ module Reek
     private
 
     def run
-      smell_repository = Smells::SmellRepository.new(description, @smell_types)
+      smell_repository = Smells::SmellRepository.new(source_description: description,
+                                                     smell_types: @smell_types,
+                                                     configuration: @configuration)
       syntax_tree = @source.syntax_tree
-      TreeWalker.new(smell_repository).process(syntax_tree) if syntax_tree
+      TreeWalker.new(smell_repository, syntax_tree).walk if syntax_tree
       smell_repository.report_on(@collector)
     end
 
-    def eligible_smell_types(smell_types_to_filter_by = [])
-      if smell_types_to_filter_by.any?
+    def eligible_smell_types(filter_by_smells = [])
+      if filter_by_smells.any?
         Smells::SmellRepository.smell_types.select do |klass|
-          smell_types_to_filter_by.include? klass.smell_type
+          filter_by_smells.include? klass.smell_type
         end
       else
         Smells::SmellRepository.smell_types

data/lib/reek/report/report.rb

@@ -1,5 +1,6 @@
-require 'rainbow'
 require 'json'
+require 'pathname'
+require 'rainbow'
 require_relative 'formatter'
 require_relative 'heading_formatter'
 
@@ -129,9 +130,9 @@ module Reek
     class HTMLReport < Base
       require 'erb'
 
-      def show(target_path = 'reek.html')
-        template_path = File.expand_path('../html_report.html.erb', __FILE__)
-        File.write target_path, ERB.new(File.read(template_path)).result(binding)
+      def show(target_path = Pathname.new('reek.html'))
+        template_path = Pathname.new("#{__dir__}/html_report.html.erb")
+        File.write target_path, ERB.new(template_path.read).result(binding)
         puts 'HTML file saved'
       end
     end

data/lib/reek/smells/boolean_parameter.rb

@@ -24,7 +24,7 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        method_ctx.parameters.default_assignments.select do |_param, value|
+        method_ctx.default_assignments.select do |_param, value|
           [:true, :false].include?(value[0])
         end.map do |parameter, _value|
           SmellWarning.new self,

data/lib/reek/smells/duplicate_method_call.rb

@@ -108,7 +108,7 @@ module Reek
 
         def collect_calls(result)
           context.each_node(:send, [:mlhs]) do |call_node|
-            next if initializer_call? call_node
+            next if call_node.object_creation_call?
             next if simple_method_call? call_node
             result[call_node].record(call_node)
           end
@@ -125,10 +125,6 @@ module Reek
           !call_node.receiver && call_node.args.empty?
         end
 
-        def initializer_call?(call_node)
-          call_node.method_name == :new
-        end
-
         def allow_calls?(method)
           @allow_calls.any? { |allow| /#{allow}/ =~ method }
         end

data/lib/reek/smells/irresponsible_module.rb

@@ -11,7 +11,7 @@ module Reek
     # @api private
     class IrresponsibleModule < SmellDetector
       def self.contexts
-        [:class, :module]
+        [:casgn, :class, :module]
       end
 
       #
@@ -26,7 +26,7 @@ module Reek
                           context: ctx.full_name,
                           lines: [expression.line],
                           message: 'has no descriptive comment',
-                          parameters: { name: expression.text_name })]
+                          parameters: { name: expression.name })]
       end
 
       private

data/lib/reek/smells/smell_repository.rb

@@ -9,45 +9,59 @@ module Reek
     #
     # @api private
     class SmellRepository
-      attr_reader :detectors
-
       def self.smell_types
         Reek::Smells::SmellDetector.descendants.sort_by(&:name)
       end
 
-      def initialize(source_description = nil, smell_types = self.class.smell_types)
-        @typed_detectors = nil
-        @detectors = {}
-        smell_types.each do |klass|
-          @detectors[klass] = klass.new(source_description)
+      def initialize(source_description: nil,
+                     smell_types: self.class.smell_types,
+                     configuration: Configuration::AppConfiguration.new)
+        self.source_via         = source_description
+        self.typed_detectors    = nil
+        self.configuration      = configuration
+        self.smell_types        = smell_types
+
+        configuration.directive_for(source_via).each do |klass, config|
+          configure klass, config
         end
-        Configuration::AppConfiguration.configure_smell_repository self
       end
 
       def configure(klass, config)
-        detector = @detectors[klass]
+        detector = detectors[klass]
         raise ArgumentError, "Unknown smell type #{klass} found in configuration" unless detector
         detector.configure_with(config)
       end
 
       def report_on(listener)
-        @detectors.each_value { |detector| detector.report_on(listener) }
+        detectors.each_value { |detector| detector.report_on(listener) }
       end
 
-      def examine(scope, node_type)
-        smell_listeners[node_type].each do |detector|
+      def examine(scope)
+        smell_listeners[scope.type].each do |detector|
           detector.examine(scope)
         end
       end
 
+      def detectors
+        @initialized_detectors ||= begin
+          @detectors = {}
+          smell_types.each do |klass|
+            @detectors[klass] = klass.new(source_via)
+          end
+          @detectors
+        end
+      end
+
       private
 
+      attr_accessor :typed_detectors, :configuration, :source_via, :smell_types
+
       def smell_listeners
-        unless @typed_detectors
-          @typed_detectors = Hash.new { |hash, key| hash[key] = [] }
-          @detectors.each_value { |detector| detector.register(@typed_detectors) }
+        unless typed_detectors
+          self.typed_detectors = Hash.new { |hash, key| hash[key] = [] }
+          detectors.each_value { |detector| detector.register(typed_detectors) }
         end
-        @typed_detectors
+        typed_detectors
       end
     end
   end

data/lib/reek/smells/utility_function.rb

@@ -54,7 +54,7 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        return [] if method_ctx.exp.singleton_method?
+        return [] if method_ctx.singleton_method?
         return [] if method_ctx.num_statements == 0
         return [] if method_ctx.references_self?
         return [] if num_helper_methods(method_ctx).zero?

data/lib/reek/source/source_code.rb

@@ -13,12 +13,15 @@ module Reek
     #
     # @api private
     class SourceCode
+      IO_IDENTIFIER     = 'STDIN'
+      STRING_IDENTIFIER = 'string'
+
       attr_reader :description
 
       # Initializer.
       #
       # code        - ruby code as String
-      # description - in case of STDIN this is "STDIN" otherwise it's a filepath as String
+      # description - 'STDIN', 'string' or a filepath as String
       # parser      - the parser to use for generating AST's out of the given source
       def initialize(code, description, parser = Parser::Ruby22)
         @source      = code
@@ -27,8 +30,8 @@ module Reek
       end
 
       # Initializes an instance of SourceCode given a source.
-      # This source can come via 3 different ways:
-      # - from files a la `reek lib/reek/`
+      # This source can come via 4 different ways:
+      # - from Files or Pathnames a la `reek lib/reek/`
       # - from IO (STDIN) a la `echo "class Foo; end" | reek`
       # - from String via our rspec matchers a la `expect("class Foo; end").to reek`
       #
@@ -37,9 +40,10 @@ module Reek
       # @return an instance of SourceCode
       def self.from(source)
         case source
-        when File   then new(source.read, source.path)
-        when IO     then new(source.readlines.join, 'STDIN')
-        when String then new(source, 'string')
+        when File     then new(source.read, source.path)
+        when IO       then new(source.readlines.join, IO_IDENTIFIER)
+        when Pathname then new(source.read, source.to_s)
+        when String   then new(source, STRING_IDENTIFIER)
         end
       end
 

data/lib/reek/source/source_locator.rb

@@ -1,4 +1,5 @@
 require 'find'
+require 'pathname'
 
 module Reek
   module Source
@@ -10,61 +11,61 @@ module Reek
       # Initialize with the paths we want to search.
       #
       # paths - a list of paths as Strings
-      def initialize(paths)
-        @pathnames = paths.
-          map { |path| Pathname.new(path.chomp('/')) }.
-          flat_map { |pathname| current_directory?(pathname) ? pathname.entries : pathname }
+      def initialize(paths, configuration: Configuration::AppConfiguration.new)
+        self.paths = paths.flat_map do |string|
+          path = Pathname.new(string)
+          current_directory?(path) ? path.entries : path
+        end
+        self.configuration = configuration
       end
 
       # Traverses all paths we initialized the SourceLocator with, finds
       # all relevant ruby files and returns them as a list.
       #
-      # @return [Array<File>] - Ruby files found
+      # @return [Array<Pathname>] - Ruby paths found
       def sources
-        source_paths.map { |pathname| File.new(pathname) }
+        source_paths
       end
 
       private
 
+      attr_accessor :paths, :configuration
+
       def source_paths
-        @pathnames.each_with_object([]) do |given_pathname, relevant_paths|
-          print_no_such_file_error(given_pathname) && next unless path_exists?(given_pathname)
-          given_pathname.find do |pathname|
-            if pathname.directory?
-              ignore_path?(pathname) ? Find.prune : next
+        paths.each_with_object([]) do |given_path, relevant_paths|
+          print_no_such_file_error(given_path) && next unless given_path.exist?
+          given_path.find do |path|
+            if path.directory?
+              ignore_path?(path) ? Find.prune : next
             else
-              relevant_paths << pathname if ruby_file?(pathname)
+              relevant_paths << path if ruby_file?(path)
             end
           end
         end
       end
 
-      def path_excluded?(pathname)
-        Configuration::AppConfiguration.exclude_paths.include? pathname.to_s
-      end
-
-      def path_exists?(path)
-        Pathname.new(path).exist?
+      def path_excluded?(path)
+        configuration.exclude_paths.include?(path)
       end
 
       def print_no_such_file_error(path)
         $stderr.puts "Error: No such file - #{path}"
       end
 
-      def hidden_directory?(pathname)
-        pathname.basename.to_s.start_with? '.'
+      def hidden_directory?(path)
+        path.basename.to_s.start_with? '.'
       end
 
-      def ignore_path?(pathname)
-        path_excluded?(pathname) || hidden_directory?(pathname)
+      def ignore_path?(path)
+        path_excluded?(path) || hidden_directory?(path)
       end
 
-      def ruby_file?(pathname)
-        pathname.extname == '.rb'
+      def ruby_file?(path)
+        path.extname == '.rb'
       end
 
-      def current_directory?(pathname)
-        ['.', './'].include? pathname.to_s
+      def current_directory?(path)
+        [Pathname.new('.'), Pathname.new('./')].include?(path)
       end
     end
   end