rubocop 0.28.0 → 0.29.0

data/lib/rubocop/cli.rb

@@ -24,7 +24,7 @@ module RuboCop
       all_passed = runner.run(paths)
       display_error_summary(runner.errors)
 
-      all_passed && !runner.aborting? ? 0 : 1
+      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
     rescue Cop::AmbiguousCopName => e
       $stderr.puts "Ambiguous cop name #{e.message} needs namespace " \
                    'qualifier.'

data/lib/rubocop/config.rb

@@ -25,13 +25,15 @@ module RuboCop
     end
 
     def make_excludes_absolute
-      return unless self['AllCops'] && self['AllCops']['Exclude']
-
-      self['AllCops']['Exclude'].map! do |exclude_elem|
-        if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
-          File.join(base_dir_for_path_parameters, exclude_elem)
-        else
-          exclude_elem
+      keys.each do |key|
+        next unless self[key]['Exclude']
+
+        self[key]['Exclude'].map! do |exclude_elem|
+          if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
+            File.join(base_dir_for_path_parameters, exclude_elem)
+          else
+            exclude_elem
+          end
         end
       end
     end
@@ -109,9 +111,11 @@ module RuboCop
     end
 
     def file_to_include?(file)
+      absolute_file_path = File.expand_path(file)
       relative_file_path = path_relative_to_config(file)
       patterns_to_include.any? do |pattern|
-        match_path?(pattern, relative_file_path, loaded_path)
+        match_path?(pattern, relative_file_path, loaded_path) ||
+          match_path?(pattern, absolute_file_path, loaded_path)
       end
     end
 

data/lib/rubocop/config_loader.rb

@@ -24,15 +24,7 @@ module RuboCop
 
       def load_file(path)
         path = File.absolute_path(path)
-        yaml_code = IO.read(path)
-        # At one time, there was a problem with the psych YAML engine under
-        # Ruby 1.9.3. YAML.load_file would crash when reading empty .yml files
-        # or files that only contained comments and blank lines. This problem
-        # is not possible to reproduce now, but we want to avoid it in case
-        # it's still there. So we only load the YAML code if we find some real
-        # code in there.
-        hash = yaml_code =~ /^[A-Z]/i ? YAML.load(yaml_code) : {}
-        puts "configuration from #{path}" if debug?
+        hash = load_yaml_configuration(path)
 
         resolve_inheritance(path, hash)
 
@@ -66,7 +58,7 @@ module RuboCop
 
       def base_configs(path, inherit_from)
         configs = Array(inherit_from).map do |f|
-          f = File.join(File.dirname(path), f) unless f.start_with?('/')
+          f = File.expand_path(f, File.dirname(path))
 
           if auto_gen_config?
             next if f.include?(AUTO_GENERATED_FILE)
@@ -114,6 +106,24 @@ module RuboCop
 
       private
 
+      def load_yaml_configuration(absolute_path)
+        yaml_code = IO.read(absolute_path)
+        # At one time, there was a problem with the psych YAML engine under
+        # Ruby 1.9.3. YAML.load_file would crash when reading empty .yml files
+        # or files that only contained comments and blank lines. This problem
+        # is not possible to reproduce now, but we want to avoid it in case
+        # it's still there. So we only load the YAML code if we find some real
+        # code in there.
+        hash = yaml_code =~ /^[A-Z]/i ? YAML.load(yaml_code) : {}
+        puts "configuration from #{absolute_path}" if debug?
+
+        unless hash.is_a?(Hash)
+          fail(TypeError, "Malformed configuration in #{absolute_path}")
+        end
+
+        hash
+      end
+
       def resolve_inheritance(path, hash)
         base_configs(path, hash['inherit_from']).reverse_each do |base_config|
           base_config.each do |k, v|

data/lib/rubocop/cop/cop.rb

@@ -15,12 +15,12 @@ module RuboCop
 
       # @return [Array<Cop>] Cops for that specific type.
       def with_type(type)
-        select { |c| c.cop_type == type }
+        CopStore.new(select { |c| c.cop_type == type })
       end
 
       # @return [Array<Cop>] Cops not for a specific type.
       def without_type(type)
-        reject { |c| c.cop_type == type }
+        CopStore.new(reject { |c| c.cop_type == type })
       end
     end
 
@@ -54,11 +54,11 @@ module RuboCop
       @all = CopStore.new
 
       def self.all
-        @all.clone
+        @all.without_type(:test)
       end
 
       def self.qualified_cop_name(name, origin)
-        @cop_names ||= Set.new(@all.map(&:cop_name))
+        @cop_names ||= Set.new(all.map(&:cop_name))
         basename = File.basename(name)
         found_ns = @all.types.map(&:capitalize).select do |ns|
           @cop_names.include?("#{ns}/#{basename}")
@@ -80,7 +80,7 @@ module RuboCop
       end
 
       def self.non_rails
-        @all.without_type(:rails)
+        all.without_type(:rails)
       end
 
       def self.inherited(subclass)
@@ -128,7 +128,8 @@ module RuboCop
       end
 
       def display_cop_names?
-        debug? || @options[:display_cop_names]
+        debug? || @options[:display_cop_names] ||
+          config['AllCops'] && config['AllCops']['DisplayCopNames']
       end
 
       def message(_node = nil)
@@ -187,8 +188,13 @@ module RuboCop
       def file_name_matches_any?(file, parameter, default_result)
         patterns = cop_config && cop_config[parameter]
         return default_result unless patterns
-        path = config.path_relative_to_config(file)
+        path = nil
         patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file, config.loaded_path)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
           match_path?(pattern, path, config.loaded_path)
         end
       end

data/lib/rubocop/cop/corrector.rb

@@ -17,19 +17,19 @@ module RuboCop
       #
       # @example
       #
-      # class AndOrCorrector
-      #   def initialize(node)
-      #     @node = node
-      #   end
+      #   class AndOrCorrector
+      #     def initialize(node)
+      #       @node = node
+      #     end
       #
-      #   def call(corrector)
-      #     replacement = (@node.type == :and ? '&&' : '||')
-      #     corrector.replace(@node.loc.operator, replacement)
+      #     def call(corrector)
+      #       replacement = (@node.type == :and ? '&&' : '||')
+      #       corrector.replace(@node.loc.operator, replacement)
+      #     end
       #   end
-      # end
       #
-      # corrections = [AndOrCorrector.new(node)]
-      # corrector = Corrector.new(source_buffer, corrections)
+      #   corrections = [AndOrCorrector.new(node)]
+      #   corrector = Corrector.new(source_buffer, corrections)
       def initialize(source_buffer, corrections)
         @source_buffer = source_buffer
         @corrections = corrections

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -30,7 +30,12 @@ module RuboCop
           # assignments inside blocks are not what we're looking for
           return if condition.type == :block
 
-          condition.each_node(:begin, *EQUALS_ASGN_NODES) do |asgn_node|
+          condition.each_node(:begin, *EQUALS_ASGN_NODES, :send) do |asgn_node|
+            if asgn_node.type == :send
+              _receiver, method_name, *_args = *asgn_node
+              return if method_name != :[]=
+            end
+
             # skip safe assignment nodes if safe assignment is allowed
             return if safe_assignment_allowed? && safe_assignment?(asgn_node)
 

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -149,11 +149,11 @@ module RuboCop
         end
 
         def autocorrect(node)
-          key = node.children.first
+          ancestor_node = ancestor_on_same_line(node)
           source = node.loc.expression.source_buffer
 
           @corrections << lambda do |corrector|
-            start_col = key.loc.expression.column
+            start_col = (ancestor_node || node).loc.expression.column
             starting_position_of_block_end = node.loc.end.begin_pos
             end_col = node.loc.end.column
 
@@ -168,6 +168,13 @@ module RuboCop
             end
           end
         end
+
+        def ancestor_on_same_line(node)
+          node.ancestors.reverse.find do |ancestor|
+            next unless ancestor.loc.respond_to?(:line)
+            ancestor.loc.line == node.loc.line
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/debugger.rb

@@ -35,12 +35,24 @@ module RuboCop
         #   (send nil :binding) :pry_remote)
         PRY_REMOTE_NODE = s(:send, s(:send, nil, :binding), :pry_remote)
 
+        # save_and_open_page
+        #
+        # (send nil :save_and_open_page)
+        CAPYBARA_SAVE_PAGE = s(:send, nil, :save_and_open_page)
+
+        # save_and_open_screenshot
+        #
+        # (send nil :save_and_open_screenshot)
+        CAPYBARA_SAVE_SCREENSHOT = s(:send, nil, :save_and_open_screenshot)
+
         DEBUGGER_NODES = [
           DEBUGGER_NODE,
           BYEBUG_NODE,
           PRY_NODE,
           REMOTE_PRY_NODE,
-          PRY_REMOTE_NODE
+          PRY_REMOTE_NODE,
+          CAPYBARA_SAVE_PAGE,
+          CAPYBARA_SAVE_SCREENSHOT
         ]
 
         def on_send(node)

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate methods in classes and modules.
+      #
+      # @example Duplicate methods in class
+      #
+      #   class SomeClass
+      #     def some_method
+      #     end
+      #
+      #     def some_method
+      #     end
+      #   end
+      #
+      # @example Duplicate methods in module
+      #
+      #   module SomeClass
+      #     def some_method
+      #     end
+      #
+      #     def some_method
+      #     end
+      #   end
+      #
+      # @example Duplicate class methods in class
+      #
+      #   class SomeClass
+      #     def self.some_method
+      #     end
+      #
+      #     def self.some_method
+      #     end
+      #   end
+      #
+      # @example Duplicate private and public methods in class
+      #
+      #   class SomeClass
+      #     def some_method
+      #     end
+      #
+      #     private def some_method
+      #     end
+      #   end
+      class DuplicateMethods < Cop
+        MSG = 'Duplicate methods `%s` at lines `%s` detected.'
+
+        def on_class(node)
+          _klass_name, _parent, body = *node
+          return unless body
+          names = method_names(body)
+          check_duplicate_methods(names)
+        end
+
+        def on_module(node)
+          _klass_name, body = *node
+          return unless body
+          names = method_names(body)
+          check_duplicate_methods(names)
+        end
+
+        private
+
+        def method_names(body)
+          body.child_nodes.map do |node|
+            _receiver, node, body  = *node if node.send_type?
+
+            if node.is_a? Symbol
+              next if body.nil?
+              node = body
+            end
+
+            if node.def_type?
+              method, _args, _body = *node
+            elsif node.defs_type?
+              _receiver, method = *node
+              method = "self.#{ method }"
+            end
+
+            method ? [method, node] : nil
+          end.compact
+        end
+
+        def check_duplicate_methods(names)
+          dups = names.each_with_object({}) do |item, accum|
+            accum[item[0]] ||= []
+            accum[item[0]] << item[1]
+          end
+
+          dups.each do |method, nodes|
+            next if nodes.size < 2
+            lines = nodes.map { |node| node.loc.line }
+
+            add_offense(nodes.last,
+                        :keyword,
+                        format(MSG, method, lines.join(', ')))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -8,7 +8,7 @@ module RuboCop
       #
       # @example
       #
-      # puts (x + y)
+      #   puts (x + y)
       class ParenthesesAsGroupedExpression < Cop
         MSG = '`(...)` interpreted as grouped expression.'
 

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -14,9 +14,9 @@ module RuboCop
       #
       # @example
       #
-      # if day.is? :tuesday && month == :jan
-      #   ...
-      # end
+      #   if day.is? :tuesday && month == :jan
+      #     ...
+      #   end
       class RequireParentheses < Cop
         include IfNode
 

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -11,12 +11,39 @@ module RuboCop
       PUBLIC_NODE = s(:send, nil, :public)
       MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
 
+      # Returns true when the node is an access modifier.
       def modifier_node?(node)
+        modifier_structure?(node) && class_or_module_parent?(node)
+      end
+
+      # Returns true when the node looks like an access modifier.
+      def modifier_structure?(node)
         [PRIVATE_NODE,
          PROTECTED_NODE,
          PUBLIC_NODE,
          MODULE_FUNCTION_NODE].include?(node)
       end
+
+      # Returns true when the parent of what looks like an access modifier
+      # is a Class or Module. Filters out simple method calls to similarly
+      # named private, protected or public.
+      def class_or_module_parent?(node)
+        node.each_ancestor do |a|
+          if a.type == :block
+            return true if class_constructor?(a)
+          elsif a.type != :begin
+            return [:casgn, :sclass, :class, :module].include?(a.type)
+          end
+        end
+      end
+
+      # Returns true when the block node looks like Class or Module.new do ... .
+      def class_constructor?(block_node)
+        send_node = block_node.children.first
+        receiver_node, method_name, *_ = *send_node
+        return false unless method_name == :new
+        %w(Class Module).include?(Util.const_name(receiver_node))
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -10,10 +10,6 @@ module RuboCop
         invoke_hook_for_normal_if_unless(node)
       end
 
-      def on_unless(node)
-        invoke_hook_for_normal_if_unless(node)
-      end
-
       def invoke_hook_for_normal_if_unless(node)
         # We won't check modifier or ternary conditionals.
         return if modifier_if?(node) || ternary_op?(node)

data/lib/rubocop/cop/rails/delegate.rb

@@ -29,18 +29,17 @@ module RuboCop
       #     foo.bar
       #   end
       class Delegate < Cop
-        include OnMethodDef
-
         MSG = 'Use `delegate` to define delegations.'
 
-        private
-
-        def on_method_def(node, method_name, args, body)
+        def on_def(node)
+          method_name, args, body = *node
           return unless trivial_delegate?(method_name, args, body)
           return if private_or_protected_delegation(node)
           add_offense(node, :keyword, MSG)
         end
 
+        private
+
         def autocorrect(node)
           method_name, args, body = *node
           return unless trivial_delegate?(method_name, args, body)