rubocop 0.16.0 → 0.17.0

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      #
+      # @example
+      #   begin
+      #     do_something
+      #   else
+      #     handle_errors # This will never be run.
+      #   end
+      class UselessElseWithoutRescue < Cop
+        include ParserDiagnostic
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :useless_else
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common code for ordinary arrays with [] that can be written with %
+    # syntax.
+    module ArraySyntax
+      def array_of?(element_type, node)
+        return false unless node.loc.begin && node.loc.begin.is?('[')
+
+        array_elems = node.children
+
+        # no need to check empty arrays
+        return false unless array_elems && array_elems.size > 1
+
+        array_elems.all? { |e| e.type == element_type }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # This module does auto-correction of nodes that should just be moved to
+    # the left or to the right, amount being determined by the instance
+    # variable @column_delta.
+    module AutocorrectAlignment
+      def check_alignment(items)
+        items.each_cons(2) do |prev, current|
+          if current.loc.line > prev.loc.line && start_of_line?(current.loc)
+            @column_delta = items.first.loc.column - current.loc.column
+            add_offence(current, :expression) if @column_delta != 0
+          end
+        end
+      end
+
+      def start_of_line?(loc)
+        loc.expression.source_line[0...loc.column] =~ /^\s*$/
+      end
+
+      def autocorrect(node)
+        # We can't use the instance variable inside the lambda. That would
+        # just give each lambda the same reference and they would all get
+        # the last value of @column_delta. A local variable fixes the
+        # problem.
+        column_delta = @column_delta
+
+        @corrections << lambda do |corrector|
+          expr = node.loc.expression
+          each_line(expr) do |line_begin_pos, line|
+            range = calculate_range(expr, line_begin_pos, column_delta)
+            if column_delta > 0
+              corrector.insert_before(range, ' ' * column_delta)
+            else
+              remove(range, corrector)
+            end
+          end
+        end
+      end
+
+      def calculate_range(expr, line_begin_pos, column_delta)
+        starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
+        pos_to_remove = if column_delta > 0 || starts_with_space
+                          line_begin_pos
+                        else
+                          line_begin_pos - column_delta.abs
+                        end
+        Parser::Source::Range.new(expr.source_buffer, pos_to_remove,
+                                  pos_to_remove + column_delta.abs)
+      end
+
+      def remove(range, corrector)
+        original_stderr = $stderr
+        $stderr = StringIO.new # Avoid error messages on console
+        corrector.remove(range)
+      rescue RuntimeError
+        range = Parser::Source::Range.new(range.source_buffer,
+                                          range.begin_pos + 1,
+                                          range.end_pos + 1)
+        retry if range.source =~ /^ +$/
+      ensure
+        $stderr = original_stderr
+      end
+
+      def each_line(expr)
+        offset = 0
+        expr.source.each_line do |line|
+          line_begin_pos = expr.begin_pos + offset
+          yield line_begin_pos, line
+          offset += line.length
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for checking assignment nodes.
+    module CheckAssignment
+      TYPES = Util::ASGN_NODES - [:casgn, :op_asgn]
+      TYPES.each do |type|
+        define_method("on_#{type}") do |node|
+          _lhs, rhs = *node
+          check_assignment(node, rhs)
+        end
+      end
+
+      def on_casgn(node)
+        _scope, _lhs, rhs = *node
+        check_assignment(node, rhs)
+      end
+
+      def on_op_asgn(node)
+        _lhs, _op, rhs = *node
+        check_assignment(node, rhs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for checking length of code segments.
+    module CodeLength
+      include ConfigurableMax
+
+      def max_length
+        cop_config['Max']
+      end
+
+      def count_comments?
+        cop_config['CountComments']
+      end
+
+      def check(node, *_)
+        length = code_length(node)
+        if length > max_length
+          add_offence(node, :keyword, sprintf(message, length,
+                                              max_length)) do
+            self.max = length
+          end
+        end
+      end
+
+      # Returns true for lines that shall not be included in the count.
+      def irrelevant_line(source_line)
+        source_line.blank? || !count_comments? && comment_line?(source_line)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Handles `EnforcedStyle` configuration parameters.
+    module ConfigurableEnforcedStyle
+      def opposite_style_detected
+        self.config_to_allow_offences ||=
+          { parameter_name => alternative_style.to_s }
+        both_styles_detected if config_to_allow_offences['Enabled']
+      end
+
+      def correct_style_detected
+        # Enabled:true indicates, later when the opposite style is detected,
+        # that the correct style is used somewhere.
+        self.config_to_allow_offences ||= { 'Enabled' => true }
+        both_styles_detected if config_to_allow_offences[parameter_name]
+      end
+
+      def both_styles_detected
+        # Both correct and opposite styles exist.
+        self.config_to_allow_offences = { 'Enabled' => false }
+      end
+
+      def unrecognized_style_detected
+        # All we can do is to disable.
+        self.config_to_allow_offences = { 'Enabled' => false }
+      end
+
+      def style
+        s = cop_config[parameter_name]
+        if cop_config['SupportedStyles'].include?(s)
+          s.to_sym
+        else
+          fail "Unknown style #{s} selected!"
+        end
+      end
+
+      def alternative_style
+        a = cop_config['SupportedStyles'].map(&:to_sym)
+        if a.size != 2
+          fail 'alternative_style can only be used when there are exactly ' +
+            '2 SupportedStyles'
+        end
+        style == a.first ? a.last : a.first
+      end
+
+      def parameter_name
+        'EnforcedStyle'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Handles `Max` configuration parameters, especially setting them to an
+    # appropriate value with --auto-gen-config.
+    module ConfigurableMax
+      def max=(value)
+        cfg = self.config_to_allow_offences ||= {}
+        value = [cfg[parameter_name], value].max if cfg[parameter_name]
+        cfg[parameter_name] = value
+      end
+
+      def parameter_name
+        'Max'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # This module provides functionality for checking if names match the
+    # configured EnforcedStyle.
+    module ConfigurableNaming
+      include ConfigurableEnforcedStyle
+
+      SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
+      CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
+
+      def check(node, range)
+        return unless range
+
+        name = range.source.to_sym
+        return if operator?(name)
+
+        if matches_config?(name)
+          correct_style_detected
+        else
+          add_offence(node, range, message(style)) do
+            opposite_style_detected
+          end
+        end
+      end
+
+      def matches_config?(name)
+        name =~ (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
+      end
+
+      # Returns a range containing the method name after the given regexp and
+      # a dot.
+      def after_dot(node, method_name_length, regexp)
+        expr = node.loc.expression
+        match = /\A#{regexp}\s*\.\s*/.match(expr.source)
+        return unless match
+        offset = match[0].length
+        begin_pos = expr.begin_pos + offset
+        Parser::Source::Range.new(expr.source_buffer, begin_pos,
+                                  begin_pos + method_name_length)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for cops checking if and unless statements.
+    module IfThenElse
+      def on_if(node)
+        check(node)
+      end
+
+      def on_unless(node)
+        check(node)
+      end
+
+      def check(node)
+        # We won't check modifier or ternary conditionals.
+        return unless node.loc.expression.source =~ /\A(if|unless)\b/
+        return unless offending_line(node)
+        add_offence(node, :expression, error_message(node))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Some common code shared between FavorUnlessOverNegatedIf and
+    # FavorUntilOverNegatedWhile.
+    module NegativeConditional
+      def check(node)
+        condition, _body, _rest = *node
+
+        # Look at last expression of contents if there's a parenthesis
+        # around condition.
+        condition = condition.children.last while condition.type == :begin
+
+        if condition.type == :send
+          _object, method = *condition
+          if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
+            add_offence(node, :expression, error_message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for cops which processes Parser's diagnostics.
+    # This mixin requires its user class to define `#relevant_diagnostic?`.
+    #
+    #     def relevant_diagnostic?(diagnostic)
+    #       diagnostic.reason == :my_interested_diagnostic_type
+    #     end
+    #
+    # If you want to use an alternative offence message rather than the one in
+    # Parser's diagnostic, define `#alternative_message`.
+    #
+    #     def alternative_message(diagnostic)
+    #       'My custom message'
+    #     end
+    module ParserDiagnostic
+      def investigate(processed_source)
+        processed_source.diagnostics.each do |d|
+          next unless relevant_diagnostic?(d)
+
+          message = if respond_to?(:alternative_message, true)
+                      alternative_message(d)
+                    else
+                      d.message.capitalize
+                    end
+
+          add_offence(nil, d.location, message, d.level)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    module SafeAssignment
+      def safe_assignment?(node)
+        node.type == :begin && node.children.size == 1 &&
+          Util::EQUALS_ASGN_NODES.include?(node.children[0].type)
+      end
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for cops checking for missing space after
+    # punctuation.
+    module SpaceAfterPunctuation
+      MSG = 'Space missing after %s.'
+
+      def investigate(processed_source)
+        processed_source.tokens.each_cons(2) do |t1, t2|
+          if kind(t1) && t1.pos.line == t2.pos.line &&
+              t2.pos.column == t1.pos.column + offset(t1)
+            add_offence(t1, t1.pos, sprintf(MSG, kind(t1)))
+          end
+        end
+      end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset(token)
+        1
+      end
+
+      def autocorrect(token)
+        @corrections << lambda do |corrector|
+          corrector.insert_after(token.pos, ' ')
+        end
+      end
+    end
+  end
+end