reek 4.6.0 → 5.0.0

data/lib/reek/smell_detectors/uncommunicative_variable_name.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -20,11 +21,10 @@ module Reek
     #
     # See {file:docs/Uncommunicative-Variable-Name.md} for details.
     #
-    # :reek:DataClump: { max_copies: 4 }
     class UncommunicativeVariableName < BaseDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
-      REJECT_KEY = 'reject'.freeze
+      REJECT_KEY = 'reject'
       DEFAULT_REJECT_SET = [
         /^.$/, # single-character names
         /[0-9]$/,  # any name ending with a number
@@ -34,7 +34,7 @@ module Reek
       # The name of the config field that lists the specific names that are
       # to be treated as exceptions; these names will not be reported as
       # uncommunicative.
-      ACCEPT_KEY = 'accept'.freeze
+      ACCEPT_KEY = 'accept'
       DEFAULT_ACCEPT_SET = [/^_$/].freeze
 
       def self.default_config
@@ -52,14 +52,11 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        self.reject_names = value(REJECT_KEY, ctx)
-        self.accept_names = value(ACCEPT_KEY, ctx)
-        variable_names(ctx.exp).select do |name, _lines|
+      def sniff
+        variable_names.select do |name, _lines|
           uncommunicative_variable_name?(name)
         end.map do |name, lines|
           smell_warning(
-            context: ctx,
             lines: lines,
             message: "has the variable name '#{name}'",
             parameters: { name: name.to_s })
@@ -68,6 +65,14 @@ module Reek
 
       private
 
+      def reject_names
+        @reject_names ||= value(REJECT_KEY, context)
+      end
+
+      def accept_names
+        @accept_names ||= value(ACCEPT_KEY, context)
+      end
+
       def uncommunicative_variable_name?(name)
         sanitized_name = name.to_s.gsub(/^[@\*\&]*/, '')
         !acceptable_name?(sanitized_name)
@@ -78,34 +83,31 @@ module Reek
           Array(reject_names).none? { |reject_pattern| name.match reject_pattern }
       end
 
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def variable_names(exp)
+      def variable_names
         result = Hash.new { |hash, key| hash[key] = [] }
-        find_assignment_variable_names(exp, result)
-        find_block_argument_variable_names(exp, result)
-        result.to_a.sort_by { |name, _| name.to_s }
+        find_assignment_variable_names(result)
+        find_block_argument_variable_names(result)
+        result
       end
 
-      # :reek:UtilityFunction
-      def find_assignment_variable_names(exp, accumulator)
-        assignment_nodes = exp.each_node(:lvasgn, [:class, :module, :defs, :def])
+      def find_assignment_variable_names(accumulator)
+        assignment_nodes = expression.each_node(:lvasgn, [:class, :module, :defs, :def]).to_a
 
-        case exp.type
+        case expression.type
         when :class, :module
-          assignment_nodes += exp.each_node(:ivasgn, [:class, :module])
+          assignment_nodes += expression.each_node(:ivasgn, [:class, :module]).to_a
         end
 
         assignment_nodes.each { |asgn| accumulator[asgn.children.first].push(asgn.line) }
       end
 
-      # :reek:FeatureEnvy
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def find_block_argument_variable_names(exp, accumulator)
-        arg_search_exp = case exp.type
+      # @quality :reek:TooManyStatements { max_statements: 6 }
+      def find_block_argument_variable_names(accumulator)
+        arg_search_exp = case expression.type
                          when :class, :module
-                           exp
+                           expression
                          when :defs, :def
-                           exp.body
+                           expression.body
                          end
 
         return unless arg_search_exp
@@ -127,15 +129,13 @@ module Reek
         end
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def record_variable_name(exp, symbol, accumulator)
         varname = symbol.to_s.sub(/^\*/, '')
         return if varname == ''
         var = varname.to_sym
         accumulator[var].push(exp.line)
       end
-
-      attr_accessor :accept_names, :reject_names
     end
   end
 end

data/lib/reek/smell_detectors/unused_parameters.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -13,14 +14,12 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        return [] if ctx.uses_super_with_implicit_arguments?
-        ctx.unused_params.map do |param|
+      def sniff
+        return [] if context.uses_super_with_implicit_arguments?
+        context.unused_params.map do |param|
           name = param.name.to_s
           smell_warning(
-            context: ctx,
-            lines: [ctx.exp.line],
+            lines: [source_line],
             message: "has unused parameter '#{name}'",
             parameters: { name: name })
         end

data/lib/reek/smell_detectors/unused_private_method.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -31,15 +32,12 @@ module Reek
       end
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        hits(ctx).map do |hit|
+      def sniff
+        hits.map do |hit|
           name = hit.name
           smell_warning(
-            context: ctx,
             lines: [hit.line],
             message: "has the unused private instance method '#{name}'",
             parameters: { name: name.to_s })
@@ -49,37 +47,33 @@ module Reek
       private
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<Hit>]
       #
-      def hits(ctx)
-        unused_private_methods(ctx).map do |defined_method|
-          Hit.new(defined_method) unless ignore_method?(ctx, defined_method)
+      def hits
+        unused_private_methods.map do |defined_method|
+          Hit.new(defined_method) unless ignore_method?(defined_method)
         end.compact
       end
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<Context::MethodContext]
       #
-      # :reek:UtilityFunction
-      def unused_private_methods(ctx)
-        defined_private_methods = ctx.defined_instance_methods(visibility: :private)
-        called_method_names     = ctx.instance_method_calls.map(&:name)
+      def unused_private_methods
+        defined_private_methods = context.defined_instance_methods(visibility: :private)
+        called_method_names     = context.instance_method_calls.map(&:name)
 
-        defined_private_methods.select do |defined_method|
-          !called_method_names.include?(defined_method.name)
+        defined_private_methods.reject do |defined_method|
+          called_method_names.include?(defined_method.name)
         end
       end
 
       #
-      # @param ctx [Context::ClassContext]
+      # @param method [Context::MethodContext]
       # @return [Boolean]
       #
-      # :reek:FeatureEnvy
-      def ignore_method?(ctx, method)
+      def ignore_method?(method)
         # ignore_contexts will be e.g. ["Foo::Smelly#my_method", "..."]
-        ignore_contexts = value(EXCLUDE_KEY, ctx)
+        ignore_contexts = value(EXCLUDE_KEY, context)
         ignore_contexts.any? do |ignore_context|
           full_name = "#{method.parent.full_name}##{method.name}"
           full_name[ignore_context]

data/lib/reek/smell_detectors/utility_function.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../ast/reference_collector'
 require_relative 'base_detector'
 
@@ -37,7 +38,7 @@ module Reek
     #
     # See {file:docs/Utility-Function.md} for details.
     class UtilityFunction < BaseDetector
-      PUBLIC_METHODS_ONLY_KEY     = 'public_methods_only'.freeze
+      PUBLIC_METHODS_ONLY_KEY     = 'public_methods_only'
       PUBLIC_METHODS_ONLY_DEFAULT = false
 
       def self.default_config
@@ -55,30 +56,26 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def sniff(ctx)
-        return [] if ctx.singleton_method? || ctx.module_function?
-        return [] if ctx.references_self?
-        return [] if num_helper_methods(ctx).zero?
-        return [] if ignore_method?(ctx)
+      def sniff
+        return [] if context.singleton_method? || context.module_function?
+        return [] if context.references_self?
+        return [] if num_helper_methods.zero?
+        return [] if ignore_method?
 
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: "doesn't depend on instance state (maybe move it to another class?)")]
       end
 
       private
 
-      # :reek:UtilityFunction
-      def num_helper_methods(method_ctx)
-        method_ctx.local_nodes(:send).length
+      def num_helper_methods
+        context.local_nodes(:send).to_a.length
       end
 
-      def ignore_method?(method_ctx)
-        method_ctx.non_public_visibility? &&
-          value(PUBLIC_METHODS_ONLY_KEY, method_ctx)
+      def ignore_method?
+        context.non_public_visibility? &&
+          value(PUBLIC_METHODS_ONLY_KEY, context)
       end
     end
   end

data/lib/reek/smell_detectors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'smell_detectors/attribute'
 require_relative 'smell_detectors/boolean_parameter'
 require_relative 'smell_detectors/class_variable'
@@ -14,7 +15,7 @@ require_relative 'smell_detectors/manual_dispatch'
 require_relative 'smell_detectors/module_initialize'
 require_relative 'smell_detectors/nested_iterators'
 require_relative 'smell_detectors/nil_check'
-require_relative 'smell_detectors/prima_donna_method'
+require_relative 'smell_detectors/missing_safe_method'
 require_relative 'smell_detectors/repeated_conditional'
 require_relative 'smell_detectors/subclassed_from_core_class'
 require_relative 'smell_detectors/too_many_instance_variables'

data/lib/reek/smell_warning.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
+
 require 'forwardable'
+require_relative 'documentation_link'
 
 module Reek
   #
@@ -7,7 +9,7 @@ module Reek
   #
   # @public
   #
-  # :reek:TooManyInstanceVariables: { max_instance_variables: 6 }
+  # @quality :reek:TooManyInstanceVariables { max_instance_variables: 6 }
   class SmellWarning
     include Comparable
     extend Forwardable
@@ -20,7 +22,7 @@ module Reek
     #   objects yourself. This is why the initializer is not part of the
     #   public API.
     #
-    # :reek:LongParameterList: { max_params: 6 }
+    # @quality :reek:LongParameterList { max_params: 6 }
     def initialize(smell_detector, context: '', lines:, message:,
                    source:, parameters: {})
       @smell_detector = smell_detector
@@ -54,7 +56,9 @@ module Reek
       base_hash.merge(stringified_params)
     end
 
-    alias yaml_hash to_hash
+    def yaml_hash
+      to_hash.merge('documentation_link' => explanatory_link)
+    end
 
     def base_message
       "#{smell_type}: #{context} #{message}"
@@ -64,6 +68,10 @@ module Reek
       smell_detector.class
     end
 
+    def explanatory_link
+      DocumentationLink.build(smell_type)
+    end
+
     protected
 
     def identifying_values
@@ -74,11 +82,11 @@ module Reek
 
     def base_hash
       {
-        'context'        => context,
-        'lines'          => lines,
-        'message'        => message,
-        'smell_type'     => smell_type,
-        'source'         => source
+        'context'    => context,
+        'lines'      => lines,
+        'message'    => message,
+        'smell_type' => smell_type,
+        'source'     => source
       }
     end
   end

data/lib/reek/source/source_code.rb

@@ -1,65 +1,94 @@
 # frozen_string_literal: true
+
 require_relative '../cli/silencer'
-Reek::CLI::Silencer.silently do
-  require 'parser/ruby23'
-end
+Reek::CLI::Silencer.without_warnings { require 'parser/ruby25' }
 require_relative '../tree_dresser'
 require_relative '../ast/node'
-require_relative '../errors/parse_error'
+require_relative '../ast/builder'
 
 # Opt in to new way of representing lambdas
-Parser::Builders::Default.emit_lambda = true
+Reek::AST::Builder.emit_lambda = true
 
 module Reek
   module Source
     #
-    # A +Source+ object represents a chunk of Ruby source code.
+    # A +SourceCode+ object represents a chunk of Ruby source code.
     #
     class SourceCode
-      IO_IDENTIFIER     = 'STDIN'.freeze
-      STRING_IDENTIFIER = 'string'.freeze
-
-      attr_reader :origin
+      IO_IDENTIFIER     = 'STDIN'
+      STRING_IDENTIFIER = 'string'
 
       # Initializer.
       #
-      # code   - Ruby code as String
-      # origin - 'STDIN', 'string' or a filepath as String
-      # parser - the parser to use for generating AST's out of the given source
-      def initialize(code:, origin:, parser: Parser::Ruby23)
-        @source = code
+      # @param source [File|Pathname|IO|String] Ruby source code
+      # @param origin [String] Origin of the source code. Will be determined
+      #   automatically if left blank.
+      # @param parser the parser to use for generating AST's out of the given code
+      def initialize(source:, origin: nil, parser: self.class.default_parser)
         @origin = origin
         @parser = parser
+        @source = source
       end
 
       # Initializes an instance of SourceCode given a source.
-      # This source can come via 4 different ways:
+      # This source can come via several 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`
+      # - from an existing SourceCode object. This is passed through unchanged
       #
-      # @param source [File|IO|String] - the given source
+      # @param source [SourceCode|File|Pathname|IO|String] the given source
+      # @param origin [String|nil]
       #
       # @return an instance of SourceCode
-      # :reek:DuplicateMethodCall: { max_calls: 2 }
-      def self.from(source)
+      def self.from(source, origin: nil)
         case source
-        when File     then new(code: source.read,           origin: source.path)
-        when IO       then new(code: source.readlines.join, origin: IO_IDENTIFIER)
-        when Pathname then new(code: source.read,           origin: source.to_s)
-        when String   then new(code: source,                origin: STRING_IDENTIFIER)
+        when self then source
+        else new(source: source, origin: origin)
         end
       end
 
-      # Parses the given source into an AST and associates the source code comments with it.
+      def syntax_tree
+        @syntax_tree ||= parse
+      end
+
+      def self.default_parser
+        Parser::Ruby25.new(AST::Builder.new).tap do |parser|
+          diagnostics = parser.diagnostics
+          diagnostics.all_errors_are_fatal = true
+          diagnostics.ignore_warnings      = true
+        end
+      end
+
+      def origin
+        @origin ||=
+          case source
+          when File     then source.path
+          when IO       then IO_IDENTIFIER
+          when Pathname then source.to_s
+          when String   then STRING_IDENTIFIER
+          end
+      end
+
+      private
+
+      def code
+        @code ||=
+          case source
+          when File, Pathname then source.read
+          when IO             then source.readlines.join
+          when String         then source
+          end.force_encoding(Encoding::UTF_8)
+      end
+
+      attr_reader :parser, :source
+
+      # Parses the given code into an AST and associates the source code comments with it.
       # This AST is then traversed by a TreeDresser which adorns the nodes in the AST
       # with our SexpExtensions.
       # Finally this AST is returned where each node is an anonymous subclass of Reek::AST::Node
       #
-      # Important to note is that Reek will not fail on unparseable files but rather print out
-      # a warning and then just continue.
-      #
-      # Given this @source:
+      # Given this @code:
       #
       #   # comment about C
       #   class C
@@ -80,26 +109,16 @@ module Reek
       # where each node is possibly adorned with our SexpExtensions (see ast/ast_node_class_map
       # and ast/sexp_extensions for details).
       #
-      #  @return [Anonymous subclass of Reek::AST::Node] the AST presentation
-      #          for the given source
-      def syntax_tree
-        @syntax_tree ||=
-          begin
-            begin
-              ast, comments = parser.parse_with_comments(source, origin)
-            rescue Racc::ParseError, Parser::SyntaxError => error
-              raise Errors::ParseError, origin: origin, original_exception: error
-            end
+      # @return Reek::AST::Node the AST presentation for the given code
+      def parse
+        buffer = Parser::Source::Buffer.new(origin, 1)
+        buffer.source = code
+        ast, comments = parser.parse_with_comments(buffer)
 
-            # See https://whitequark.github.io/parser/Parser/Source/Comment/Associator.html
-            comment_map = Parser::Source::Comment.associate(ast, comments) if ast
-            TreeDresser.new.dress(ast, comment_map)
-          end
+        # See https://whitequark.github.io/parser/Parser/Source/Comment/Associator.html
+        comment_map = Parser::Source::Comment.associate(ast, comments)
+        TreeDresser.new.dress(ast, comment_map) || AST::Node.new(:empty)
       end
-
-      private
-
-      attr_reader :parser, :source
     end
   end
 end

data/lib/reek/source/source_locator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'find'
 require 'pathname'
 
@@ -23,7 +24,7 @@ module Reek
       # Traverses all paths we initialized the SourceLocator with, finds
       # all relevant Ruby files and returns them as a list.
       #
-      # @return [Array<Pathname>] - Ruby paths found
+      # @return [Array<Pathname>] Ruby paths found
       def sources
         source_paths
       end
@@ -32,8 +33,8 @@ module Reek
 
       attr_reader :configuration, :paths, :options
 
-      # :reek:TooManyStatements: { max_statements: 7 }
-      # :reek:NestedIterators: { max_allowed_nesting: 2 }
+      # @quality :reek:TooManyStatements { max_statements: 7 }
+      # @quality :reek:NestedIterators { max_allowed_nesting: 2 }
       def source_paths
         paths.each_with_object([]) do |given_path, relevant_paths|
           unless given_path.exist?
@@ -66,12 +67,12 @@ module Reek
         configuration.path_excluded?(path)
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def print_no_such_file_error(path)
-        $stderr.puts "Error: No such file - #{path}"
+        warn "Error: No such file - #{path}"
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def hidden_directory?(path)
         path.basename.to_s.start_with? '.'
       end
@@ -80,12 +81,12 @@ module Reek
         path_excluded?(path) || hidden_directory?(path)
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def ruby_file?(path)
         path.extname == '.rb'
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def current_directory?(path)
         [Pathname.new('.'), Pathname.new('./')].include?(path)
       end

data/lib/reek/spec/should_reek.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 require_relative '../examiner'
-require_relative '../report/formatter'
+require_relative '../report/simple_warning_formatter'
 
 module Reek
   module Spec
@@ -22,7 +23,7 @@ module Reek
       end
 
       def failure_message_when_negated
-        rpt = Report::Formatter.format_list(examiner.smells)
+        rpt = Report::SimpleWarningFormatter.new.format_list(examiner.smells)
         "Expected no smells, but got:\n#{rpt}"
       end
 

data/lib/reek/spec/should_reek_of.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 require_relative '../examiner'
 require_relative 'smell_matcher'
+require_relative '../configuration/app_configuration'
 
 module Reek
   module Spec
@@ -11,36 +13,31 @@ module Reek
     class ShouldReekOf
       include RSpec::Matchers::Composable
 
-      # Variant of Examiner that doesn't swallow exceptions
-      class UnsafeExaminer < Examiner
-        def run
-          examine_tree
-        end
-      end
-
       attr_reader :failure_message, :failure_message_when_negated
 
-      def initialize(smell_type_or_class,
+      def initialize(smell_type,
                      smell_details = {},
                      configuration = Configuration::AppConfiguration.default)
-        @smell_type = normalize smell_type_or_class
+        @smell_type = smell_type.to_s
         @smell_details = smell_details
-        configuration.load_values(smell_type => { SmellConfiguration::ENABLED_KEY => true })
+        configuration.load_values(Configuration::AppConfiguration::DETECTORS_KEY =>
+                                    { smell_type => { SmellConfiguration::ENABLED_KEY => true } })
         @configuration = configuration
       end
 
       def matches?(source)
         @matching_smell_types = nil
-        self.examiner = UnsafeExaminer.new(source,
-                                           filter_by_smells: [smell_type],
-                                           configuration: configuration)
+        self.examiner = Examiner.new(source,
+                                     filter_by_smells: [smell_type],
+                                     configuration: configuration)
         set_failure_messages
         matching_smell_details?
       end
 
       def with_config(config_hash)
         new_configuration = Configuration::AppConfiguration.default
-        new_configuration.load_values(smell_type => config_hash)
+        new_configuration.load_values(Configuration::AppConfiguration::DETECTORS_KEY =>
+                                        { smell_type => config_hash })
         self.class.new(smell_type, smell_details, new_configuration)
       end
 
@@ -88,7 +85,7 @@ module Reek
           "#{smell_type} with smell details #{smell_details}, but it did"
       end
 
-      # :reek:FeatureEnvy
+      # @quality :reek:FeatureEnvy
       def all_relevant_smell_details_formatted
         matching_smell_types.each_with_object([]).with_index do |(smell, accumulator), index|
           accumulator << "#{index + 1}.)\n"
@@ -99,17 +96,7 @@ module Reek
       end
 
       def origin
-        examiner.description
-      end
-
-      # :reek:UtilityFunction
-      def normalize(smell_type_or_class)
-        case smell_type_or_class
-        when Class
-          smell_type_or_class.smell_type
-        else
-          smell_type_or_class.to_s
-        end
+        examiner.origin
       end
     end
   end