reek 5.0.2 → 5.1.0

data/lib/reek/smell_detectors/control_parameter_helpers/control_parameter_finder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative './call_in_condition_finder'
+require_relative '../../ast/node'
+
+module Reek
+  module SmellDetectors
+    module ControlParameterHelpers
+      # Finds cases of ControlParameter in a particular node for a particular parameter
+      class ControlParameterFinder
+        CONDITIONAL_NODE_TYPES = [:if, :case, :and, :or].freeze
+        #
+        # @param node [Reek::AST::Node] the node in our current scope,
+        #   e.g. s(:def, :alfa,
+        #          s(:args,
+        #            s(:arg, :bravo),
+        # @param parameter [Symbol] the parameter name in question
+        #   e.g. in the example above this would be :bravo
+        #
+        def initialize(node, parameter)
+          @node = node
+          @parameter = parameter
+        end
+
+        #
+        # @return [Array<Reek::AST::Node>] all nodes where the parameter is used for control flow
+        #
+        def find_matches
+          return [] if legitimate_uses?
+
+          nested_finders.flat_map(&:find_matches) + uses_of_param_in_condition
+        end
+
+        #
+        # @return [Boolean] true if the parameter is not used for control flow
+        #
+        def legitimate_uses?
+          return true if CallInConditionFinder.new(node, parameter).uses_param_in_call_in_condition?
+          return true if parameter_used_in_body?
+          return true if nested_finders.any?(&:legitimate_uses?)
+
+          false
+        end
+
+        private
+
+        attr_reader :node, :parameter
+
+        #
+        # @return [Boolean] if the parameter is used in the body of the method
+        #   e.g. this
+        #
+        #   def alfa(bravo)
+        #     puts bravo
+        #     if bravo then charlie end
+        #   end
+        #
+        #   would cause this method to return true because of the "puts bravo"
+        #
+        def parameter_used_in_body?
+          nodes = node.body_nodes([:lvar], CONDITIONAL_NODE_TYPES)
+          nodes.any? { |lvar_node| lvar_node.var_name == parameter }
+        end
+
+        #
+        # @return [Array<ControlParameterFinder>]
+        #
+        def nested_finders
+          @nested_finders ||= conditional_nodes.flat_map do |node|
+            self.class.new(node, parameter)
+          end
+        end
+
+        #
+        # @return [Array<Reek::AST::Node>] all nodes where the parameter is part of a condition,
+        #   e.g. [s(:lvar, :charlie)]
+        #
+        def uses_of_param_in_condition
+          condition = node.condition
+          return [] unless condition
+
+          condition.each_node(:lvar).select { |inner| inner.var_name == parameter }
+        end
+
+        #
+        # @return [Array<Reek::AST::Node>] the conditional nodes scoped below the current node
+        #
+        def conditional_nodes
+          node.body_nodes(CONDITIONAL_NODE_TYPES)
+        end
+      end
+    end
+  end
+end

data/lib/reek/smell_detectors/duplicate_method_call.rb

@@ -123,6 +123,7 @@ module Reek
           context.local_nodes(:send, [:mlhs]) do |call_node|
             next if call_node.object_creation_call?
             next if simple_method_call? call_node
+
             result[call_node].record(call_node)
           end
           context.local_nodes(:block) do |call_node|

data/lib/reek/smell_detectors/feature_envy.rb

@@ -45,6 +45,7 @@ module Reek
       def sniff
         return [] if context.singleton_method? || context.module_function?
         return [] unless context.references_self?
+
         envious_receivers.map do |name, lines|
           smell_warning(
             lines: lines,
@@ -61,6 +62,7 @@ module Reek
 
       def envious_receivers
         return {} if refs.self_is_max?
+
         refs.most_popular
       end
     end

data/lib/reek/smell_detectors/irresponsible_module.rb

@@ -21,6 +21,7 @@ module Reek
       #
       def sniff
         return [] if descriptive_context? || context.namespace_module?
+
         [smell_warning(
           lines: [source_line],
           message: 'has no descriptive comment')]

data/lib/reek/smell_detectors/long_parameter_list.rb

@@ -35,6 +35,7 @@ module Reek
       def sniff
         count = expression.arg_names.length
         return [] if count <= max_allowed_params
+
         [smell_warning(
           lines: [source_line],
           message: "has #{count} parameters",

data/lib/reek/smell_detectors/manual_dispatch.rb

@@ -22,6 +22,7 @@ module Reek
       def sniff
         smelly_nodes = context.local_nodes(:send).select { |node| node.name == :respond_to? }
         return [] if smelly_nodes.empty?
+
         lines = smelly_nodes.map(&:line)
         [smell_warning(lines: lines, message: MESSAGE)]
       end

data/lib/reek/smell_detectors/missing_safe_method.rb

@@ -64,6 +64,7 @@ module Reek
         return false unless method_sexp.ends_with_bang?
         return false if ignore_method? method_sexp
         return false if version_without_bang_exists? method_sexp
+
         true
       end
 

data/lib/reek/smell_detectors/nested_iterators.rb

@@ -96,6 +96,7 @@ module Reek
       # @quality :reek:TooManyStatements { max_statements: 6 }
       def scout(exp:, depth:)
         return [] unless exp
+
         # Find all non-nested blocks in this expression
         exp.each_node([:block], [:block]).flat_map do |iterator|
           new_depth = increment_depth(iterator, depth)

data/lib/reek/smell_detectors/repeated_conditional.rb

@@ -77,6 +77,7 @@ module Reek
         collector = proc do |node|
           next unless (condition = node.condition)
           next if condition == BLOCK_GIVEN_CONDITION
+
           result[condition].push(condition.line)
         end
         [:if, :case].each { |stmt| context.local_nodes(stmt, &collector) }

data/lib/reek/smell_detectors/too_many_instance_variables.rb

@@ -37,6 +37,7 @@ module Reek
         variables = context.local_nodes(:ivasgn, [:or_asgn]).map(&:name)
         count = variables.uniq.size
         return [] if count <= max_allowed_ivars
+
         [smell_warning(
           lines: [source_line],
           message: "has at least #{count} instance variables",

data/lib/reek/smell_detectors/too_many_methods.rb

@@ -39,6 +39,7 @@ module Reek
         # TODO: Only checks instance methods!
         actual = context.node_instance_methods.length
         return [] if actual <= max_allowed_methods
+
         [smell_warning(
           lines: [source_line],
           message: "has at least #{actual} methods",

data/lib/reek/smell_detectors/too_many_statements.rb

@@ -30,6 +30,7 @@ module Reek
       def sniff
         count = context.number_of_statements
         return [] if count <= max_allowed_statements
+
         [smell_warning(
           lines: [source_line],
           message: "has approx #{count} statements",

data/lib/reek/smell_detectors/uncommunicative_variable_name.rb

@@ -111,6 +111,7 @@ module Reek
                          end
 
         return unless arg_search_exp
+
         args_nodes = arg_search_exp.each_node(:args, [:class, :module, :defs, :def])
 
         args_nodes.each do |args_node|
@@ -133,6 +134,7 @@ module Reek
       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

data/lib/reek/smell_detectors/unused_parameters.rb

@@ -16,6 +16,7 @@ module Reek
       #
       def sniff
         return [] if context.uses_super_with_implicit_arguments?
+
         context.unused_params.map do |param|
           name = param.name.to_s
           smell_warning(

data/lib/reek/source/source_locator.rb

@@ -56,6 +56,7 @@ module Reek
         if options.force_exclusion?
           path.ascend do |ascendant|
             break true if path_excluded?(ascendant)
+
             false
           end
         else

data/lib/reek/spec/should_reek_of.rb

@@ -20,7 +20,7 @@ module Reek
                      configuration = Configuration::AppConfiguration.default)
         @smell_type = smell_type.to_s
         @smell_details = smell_details
-        configuration.load_values(Configuration::AppConfiguration::DETECTORS_KEY =>
+        configuration.load_values(DETECTORS_KEY =>
                                     { smell_type => { SmellConfiguration::ENABLED_KEY => true } })
         @configuration = configuration
       end
@@ -36,7 +36,7 @@ module Reek
 
       def with_config(config_hash)
         new_configuration = Configuration::AppConfiguration.default
-        new_configuration.load_values(Configuration::AppConfiguration::DETECTORS_KEY =>
+        new_configuration.load_values(DETECTORS_KEY =>
                                         { smell_type => config_hash })
         self.class.new(smell_type, smell_details, new_configuration)
       end

data/lib/reek/spec/should_reek_only_of.rb

@@ -20,6 +20,7 @@ module Reek
         self.examiner = examiner
         self.warnings = examiner.smells
         return false if warnings.empty?
+
         warnings.all? { |warning| SmellMatcher.new(warning).matches?(smell_type) }
       end
 

data/lib/reek/spec/smell_matcher.rb

@@ -39,6 +39,7 @@ module Reek
         parameter_keys = other_attributes.keys - COMPARABLE_ATTRIBUTES
         extra_keys = parameter_keys - smell_warning.parameters.keys
         return if extra_keys.empty?
+
         raise ArgumentError, "The attribute '#{extra_keys.first}' is not available for comparison"
       end
 

data/lib/reek/tree_dresser.rb

@@ -41,6 +41,7 @@ module Reek
     # @quality :reek:TooManyStatements { max_statements: 6 }
     def dress(sexp, comment_map)
       return sexp unless sexp.is_a? ::Parser::AST::Node
+
       type = sexp.type
       children = sexp.children.map { |child| dress(child, comment_map) }
       comments = comment_map[sexp]

data/lib/reek/version.rb

@@ -8,6 +8,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '5.0.2'
+    STRING = '5.1.0'
   end
 end

data/samples/smelly_source/ruby.rb

@@ -0,0 +1,368 @@
+module CodeRay
+module Scanners
+
+  # This scanner is really complex, since Ruby _is_ a complex language!
+  #
+  # It tries to highlight 100% of all common code,
+  # and 90% of strange codes.
+  #
+  # It is optimized for HTML highlighting, and is not very useful for
+  # parsing or pretty printing.
+  #
+  # For now, I think it's better than the scanners in VIM or Syntax, or
+  # any highlighter I was able to find, except Caleb's RubyLexer.
+  #
+  # I hope it's also better than the rdoc/irb lexer.
+  class Ruby < Scanner
+
+    include Streamable
+
+    register_for :ruby
+    file_extension 'rb'
+
+    helper :patterns
+
+  private
+    def scan_tokens tokens, options
+      last_token_dot = false
+      value_expected = true
+      heredocs = nil
+      last_state = nil
+      state = :initial
+      depth = nil
+      inline_block_stack = []
+
+      patterns = Patterns  # avoid constant lookup
+
+      until eos?
+        match = nil
+        kind = nil
+
+        if state.instance_of? patterns::StringState
+# {{{
+          match = scan_until(state.pattern) || scan_until(/\z/)
+          tokens << [match, :content] unless match.empty?
+          break if eos?
+
+          if state.heredoc and self[1]  # end of heredoc
+            match = getch.to_s
+            match << scan_until(/$/) unless eos?
+            tokens << [match, :delimiter]
+            tokens << [:close, state.type]
+            state = state.next_state
+            next
+          end
+
+          case match = getch
+
+          when state.delim
+            if state.paren
+              state.paren_depth -= 1
+              if state.paren_depth > 0
+                tokens << [match, :nesting_delimiter]
+                next
+              end
+            end
+            tokens << [match, :delimiter]
+            if state.type == :regexp and not eos?
+              modifiers = scan(/#{patterns::REGEXP_MODIFIERS}/ox)
+              tokens << [modifiers, :modifier] unless modifiers.empty?
+            end
+            tokens << [:close, state.type]
+            value_expected = false
+            state = state.next_state
+
+          when '\\'
+            if state.interpreted
+              if esc = scan(/ #{patterns::ESCAPE} /ox)
+                tokens << [match + esc, :char]
+              else
+                tokens << [match, :error]
+              end
+            else
+              case m = getch
+              when state.delim, '\\'
+                tokens << [match + m, :char]
+              when nil
+                tokens << [match, :error]
+              else
+                tokens << [match + m, :content]
+              end
+            end
+
+          when '#'
+            case peek(1)
+            when '{'
+              inline_block_stack << [state, depth, heredocs]
+              value_expected = true
+              state = :initial
+              depth = 1
+              tokens << [:open, :inline]
+              tokens << [match + getch, :inline_delimiter]
+            when '$', '@'
+              tokens << [match, :escape]
+              last_state = state  # scan one token as normal code, then return here
+              state = :initial
+            else
+              raise_inspect 'else-case # reached; #%p not handled' % peek(1), tokens
+            end
+
+          when state.paren
+            state.paren_depth += 1
+            tokens << [match, :nesting_delimiter]
+
+          when /#{patterns::REGEXP_SYMBOLS}/ox
+            tokens << [match, :function]
+
+          else
+            raise_inspect 'else-case " reached; %p not handled, state = %p' % [match, state], tokens
+
+          end
+          next
+# }}}
+        else
+# {{{
+          if match = scan(/[ \t\f]+/)
+            kind = :space
+            match << scan(/\s*/) unless eos? or heredocs
+            tokens << [match, kind]
+            next
+            
+          elsif match = scan(/\\?\n/)
+            kind = :space
+            if match == "\n"
+              value_expected = true  # FIXME not quite true
+              state = :initial if state == :undef_comma_expected
+            end
+            if heredocs
+              unscan  # heredoc scanning needs \n at start
+              state = heredocs.shift
+              tokens << [:open, state.type]
+              heredocs = nil if heredocs.empty?
+              next
+            else
+              match << scan(/\s*/) unless eos?
+            end
+            tokens << [match, kind]
+            next
+          
+          elsif match = scan(/\#.*/) or
+            ( bol? and match = scan(/#{patterns::RUBYDOC_OR_DATA}/o) )
+              kind = :comment
+              value_expected = true
+              tokens << [match, kind]
+              next
+
+          elsif state == :initial
+
+            # IDENTS #
+            if match = scan(/#{patterns::METHOD_NAME}/o)
+              if last_token_dot
+                kind = if match[/^[A-Z]/] and not match?(/\(/) then :constant else :ident end
+              else
+                kind = patterns::IDENT_KIND[match]
+                if kind == :ident and match[/^[A-Z]/] and not match[/[!?]$/] and not match?(/\(/)
+                  kind = :constant
+                elsif kind == :reserved
+                  state = patterns::DEF_NEW_STATE[match]
+                end
+              end
+              ## experimental!
+              value_expected = :set if
+                patterns::REGEXP_ALLOWED[match] or check(/#{patterns::VALUE_FOLLOWS}/o)
+            
+            elsif last_token_dot and match = scan(/#{patterns::METHOD_NAME_OPERATOR}/o)
+              kind = :ident
+              value_expected = :set if check(/#{patterns::VALUE_FOLLOWS}/o)
+
+            # OPERATORS #
+            elsif not last_token_dot and match = scan(/ \.\.\.? | (?:\.|::)() | [,\(\)\[\]\{\}] | ==?=? /x)
+              if match !~ / [.\)\]\}] /x or match =~ /\.\.\.?/
+                value_expected = :set
+              end
+              last_token_dot = :set if self[1]
+              kind = :operator
+              unless inline_block_stack.empty?
+                case match
+                when '{'
+                  depth += 1
+                when '}'
+                  depth -= 1
+                  if depth == 0  # closing brace of inline block reached
+                    state, depth, heredocs = inline_block_stack.pop
+                    tokens << [match, :inline_delimiter]
+                    kind = :inline
+                    match = :close
+                  end
+                end
+              end
+
+            elsif match = scan(/ ['"] /mx)
+              tokens << [:open, :string]
+              kind = :delimiter
+              state = patterns::StringState.new :string, match == '"', match  # important for streaming
+
+            elsif match = scan(/#{patterns::INSTANCE_VARIABLE}/o)
+              kind = :instance_variable
+
+            elsif value_expected and match = scan(/\//)
+              tokens << [:open, :regexp]
+              kind = :delimiter
+              interpreted = true
+              state = patterns::StringState.new :regexp, interpreted, match
+
+            elsif match = scan(/#{patterns::NUMERIC}/o)
+              kind = if self[1] then :float else :integer end
+
+            elsif match = scan(/#{patterns::SYMBOL}/o)
+              case delim = match[1]
+              when ?', ?"
+                tokens << [:open, :symbol]
+                tokens << [':', :symbol]
+                match = delim.chr
+                kind = :delimiter
+                state = patterns::StringState.new :symbol, delim == ?", match
+              else
+                kind = :symbol
+              end
+
+            elsif match = scan(/ [-+!~^]=? | [*|&]{1,2}=? | >>? /x)
+              value_expected = :set
+              kind = :operator
+
+            elsif value_expected and match = scan(/#{patterns::HEREDOC_OPEN}/o)
+              indented = self[1] == '-'
+              quote = self[3]
+              delim = self[quote ? 4 : 2]
+              kind = patterns::QUOTE_TO_TYPE[quote]
+              tokens << [:open, kind]
+              tokens << [match, :delimiter]
+              match = :close
+              heredoc = patterns::StringState.new kind, quote != '\'', delim, (indented ? :indented : :linestart )
+              heredocs ||= []  # create heredocs if empty
+              heredocs << heredoc
+
+            elsif value_expected and match = scan(/#{patterns::FANCY_START_CORRECT}/o)
+              kind, interpreted = *patterns::FancyStringType.fetch(self[1]) do
+                raise_inspect 'Unknown fancy string: %%%p' % k, tokens
+              end
+              tokens << [:open, kind]
+              state = patterns::StringState.new kind, interpreted, self[2]
+              kind = :delimiter
+
+            elsif value_expected and match = scan(/#{patterns::CHARACTER}/o)
+              kind = :integer
+
+            elsif match = scan(/ [\/%]=? | <(?:<|=>?)? | [?:;] /x)
+              value_expected = :set
+              kind = :operator
+
+            elsif match = scan(/`/)
+              if last_token_dot
+                kind = :operator
+              else
+                tokens << [:open, :shell]
+                kind = :delimiter
+                state = patterns::StringState.new :shell, true, match
+              end
+
+            elsif match = scan(/#{patterns::GLOBAL_VARIABLE}/o)
+              kind = :global_variable
+
+            elsif match = scan(/#{patterns::CLASS_VARIABLE}/o)
+              kind = :class_variable
+
+            else
+              kind = :error
+              match = getch
+
+            end
+
+          elsif state == :def_expected
+            state = :initial
+            if match = scan(/(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
+              kind = :method
+            else
+              next
+            end
+
+          elsif state == :undef_expected
+            state = :undef_comma_expected
+            if match = scan(/#{patterns::METHOD_NAME_EX}/o)
+              kind = :method
+            elsif match = scan(/#{patterns::SYMBOL}/o)
+              case delim = match[1]
+              when ?', ?"
+                tokens << [:open, :symbol]
+                tokens << [':', :symbol]
+                match = delim.chr
+                kind = :delimiter
+                state = patterns::StringState.new :symbol, delim == ?", match
+                state.next_state = :undef_comma_expected
+              else
+                kind = :symbol
+              end
+            else
+              state = :initial
+              next
+            end
+
+          elsif state == :undef_comma_expected
+            if match = scan(/,/)
+              kind = :operator
+              state = :undef_expected
+            else
+              state = :initial
+              next
+            end
+
+          elsif state == :module_expected
+            if match = scan(/<</)
+              kind = :operator
+            else
+              state = :initial
+              if match = scan(/ (?:#{patterns::IDENT}::)* #{patterns::IDENT} /ox)
+                kind = :class
+              else
+                next
+              end
+            end
+
+          end
+# }}}
+
+          value_expected = value_expected == :set
+          last_token_dot = last_token_dot == :set
+
+          if $DEBUG and not kind
+            raise_inspect 'Error token %p in line %d' %
+              [[match, kind], line], tokens, state
+          end
+          raise_inspect 'Empty token', tokens unless match
+
+          tokens << [match, kind]
+
+          if last_state
+            state = last_state
+            last_state = nil
+          end
+        end
+      end
+
+      inline_block_stack << [state] if state.is_a? patterns::StringState
+      until inline_block_stack.empty?
+        this_block = inline_block_stack.pop
+        tokens << [:close, :inline] if this_block.size > 1
+        state = this_block.first
+        tokens << [:close, state.type]
+      end
+
+      tokens
+    end
+
+  end
+
+end
+end
+
+# vim:fdm=marker