rubocop 0.14.1 → 0.15.0

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

@@ -13,26 +13,15 @@ module Rubocop
         MSG = '(...) interpreted as grouped expression.'
 
         def on_send(node)
-          receiver, method_name, args = *node
+          _receiver, method_name, args = *node
           if OPERATOR_METHODS.include?(method_name) ||
               method_name.to_s.end_with?('=')
             return
           end
           if args && args.loc.expression.source.start_with?('(')
-            receiver_length = if receiver
-                                receiver.loc.expression.source.length
-                              else
-                                0
-                              end
-            without_receiver = node.loc.expression.source[receiver_length..-1]
-
-            # Escape question mark if any.
-            method_regexp = Regexp.escape(method_name)
-
-            if (match =
-                without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/))
+            space_length = spaces_before_left_parenthesis(node)
+            if space_length > 0
               expr = args.loc.expression
-              space_length = match.captures[0].length
               space_range =
                 Parser::Source::Range.new(expr.source_buffer,
                                           expr.begin_pos - space_length,
@@ -41,6 +30,24 @@ module Rubocop
             end
           end
         end
+
+        private
+
+        def spaces_before_left_parenthesis(node)
+          receiver, method_name, _args = *node
+          receiver_length = if receiver
+                              receiver.loc.expression.source.length
+                            else
+                              0
+                            end
+          without_receiver = node.loc.expression.source[receiver_length..-1]
+
+          # Escape question mark if any.
+          method_regexp = Regexp.escape(method_name)
+
+          match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
+          match ? match.captures[0].length : 0
+        end
       end
     end
   end

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

@@ -119,7 +119,7 @@ module Rubocop
               if mrhs_node.type == :array && rhs_node
                 process_assignment(lhs_variable_name, rhs_node)
               else
-                table[lhs_variable_name] = false
+                @table[lhs_variable_name] = false
               end
             end
 

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for the use of output calls like puts and print
+      class Output < Cop
+        MSG = 'Do not write to stdout. Use Rails\' logger if you want to log.'
+
+        BLACKLIST = [:puts,
+                     :print,
+                     :p,
+                     :pp,
+                     :pretty_print]
+
+        def on_send(node)
+          return if matches_blacklist?(processed_source)
+          receiver, method_name, *_args = *node
+
+          if receiver.nil? && BLACKLIST.include?(method_name)
+            convention(node, :selector)
+          end
+        end
+
+        def matches_blacklist?(source)
+          ignore_paths.any? { |regex| source.buffer.name =~ /#{regex}/ }
+        end
+
+        def ignore_paths
+          cop_config['Ignore']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{access_control.rb → access_modifier_indentation.rb}

@@ -6,9 +6,8 @@ module Rubocop
       # A couple of checks related to the use method visibility modifiers.
       # Modifiers should be indented as deeps are method definitions and
       # surrounded by blank lines.
-      class AccessControl < Cop
-        INDENT_MSG = 'Indent %s as deep as method definitions.'
-        BLANK_MSG = 'Keep a blank line before and after %s.'
+      class AccessModifierIndentation < Cop
+        MSG = '%s access modifiers like %s.'
 
         PRIVATE_NODE = s(:send, nil, :private)
         PROTECTED_NODE = s(:send, nil, :protected)
@@ -30,19 +29,9 @@ module Rubocop
               on_node(:send, node, [:class, :module, :sclass]) do |send_node|
                 if modifier_node?(send_node)
                   send_start_col = send_node.loc.expression.column
-                  selector = send_node.loc.selector.source
 
-                  if send_start_col - 2 != class_start_col
-                    convention(send_node, :expression,
-                               format(INDENT_MSG, selector))
-                  end
-
-                  send_line = send_node.loc.line
-
-                  unless processed_source[send_line].chomp.empty? &&
-                      processed_source[send_line - 2].chomp.empty?
-                    convention(send_node, :expression,
-                               format(BLANK_MSG, selector))
+                  if send_start_col != class_start_col + expected_indent_offset
+                    convention(send_node, :expression)
                   end
                 end
               end
@@ -52,6 +41,12 @@ module Rubocop
 
         private
 
+        def message(node)
+          format(MSG,
+                 cop_config['EnforcedStyle'].capitalize,
+                 node.loc.selector.source)
+        end
+
         def class_constructor?(block_node)
           send_node = block_node.children.first
           receiver_node, method_name, *_ = *send_node
@@ -59,6 +54,14 @@ module Rubocop
           %w(Class Module).include?(Util.const_name(receiver_node))
         end
 
+        def expected_indent_offset
+          case cop_config['EnforcedStyle'].downcase
+          when 'outdent' then 0
+          when 'indent' then 2
+          else fail 'Unknown EnforcedStyle specified'
+          end
+        end
+
         def modifier_node?(node)
           [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
         end

data/lib/rubocop/cop/style/alias.rb

@@ -8,9 +8,21 @@ module Rubocop
       class Alias < Cop
         MSG = 'Use alias_method instead of alias.'
 
-        # TODO: Make this check context aware - alias_method is not
-        #   available outside of classes/modules.
+        def on_block(node)
+          method, _args, body = *node
+
+          _receiver, method_name = *method
+
+          # using alias is the only option in certain scenarios
+          # in such scenarios we don't want to report an offence
+          if method_name == :instance_exec
+            on_node(:alias, body) { |n| ignore_node(n) }
+          end
+        end
+
         def on_alias(node)
+          return if ignored_node?(node)
+
           # alias_method can't be used with global variables
           new, old = *node
 

data/lib/rubocop/cop/style/align_hash.rb

@@ -6,154 +6,219 @@ module Rubocop
       # Here we check if the keys, separators, and values of a multi-line hash
       # literal are aligned.
       class AlignHash < Cop
-        MSG = 'Align the elements of a hash literal if they span more than ' +
-          'one line.'
+        # Handles calculation of deltas (deviations from correct alignment)
+        # when the enforced style is 'key'.
+        class KeyAlignment
+          def checkable_layout(_node)
+            true
+          end
 
-        def on_hash(node)
-          first_pair = node.children.first
+          def deltas_for_first_pair(*_)
+            {} # The first pair is always considered correct.
+          end
+
+          def deltas(first_pair, prev_pair, current_pair)
+            if current_pair.loc.line == prev_pair.loc.line
+              {}
+            else
+              { key: first_pair.loc.column - current_pair.loc.column }
+            end
+          end
+        end
 
-          styles = [cop_config['EnforcedHashRocketStyle'],
-                    cop_config['EnforcedColonStyle']]
+        # Common functionality for the styles where not only keys, but also
+        # values are aligned.
+        class AlignmentOfValues
+          def checkable_layout(node)
+            !any_pairs_on_the_same_line?(node) && all_have_same_sparator?(node)
+          end
+
+          def deltas(first_pair, prev_pair, current_pair)
+            key_delta = key_delta(first_pair, current_pair)
+            current_separator = current_pair.loc.operator
+            separator_delta = separator_delta(first_pair, current_separator,
+                                              key_delta)
+            value_delta = value_delta(first_pair, current_pair) -
+              key_delta - separator_delta
+
+            { key: key_delta, separator: separator_delta, value: value_delta }
+          end
+
+          private
 
-          if styles.include?('table') || styles.include?('separator')
-            return if any_pairs_on_the_same_line?(node)
+          def any_pairs_on_the_same_line?(node)
+            lines_of_the_children = node.children.map do |pair|
+              key, _value = *pair
+              key.loc.line
+            end
+            lines_of_the_children.uniq.size < lines_of_the_children.size
+          end
+
+          def all_have_same_sparator?(node)
+            first_separator = node.children.first.loc.operator.source
+            node.children[1..-1].all? do |pair|
+              pair.loc.operator.is?(first_separator)
+            end
           end
+        end
 
-          if styles.include?('table')
+        # Handles calculation of deltas when the enforced style is 'table'.
+        class TableAlignment < AlignmentOfValues
+          # The table style is the only one where the first key-value pair can
+          # be considered to have bad alignment.
+          def deltas_for_first_pair(first_pair, node)
             key_widths = node.children.map do |pair|
               key, _value = *pair
               key.loc.expression.source.length
             end
             @max_key_width = key_widths.max
-            if first_pair && value_delta(nil, first_pair, @max_key_width) != 0
-              @column_deltas = {}
-              convention(first_pair, :expression)
+
+            separator_delta = separator_delta(first_pair,
+                                              first_pair.loc.operator, 0)
+            {
+              separator: separator_delta,
+              value:     value_delta(first_pair, first_pair) - separator_delta
+            }
+          end
+
+          private
+
+          def key_delta(first_pair, current_pair)
+            first_pair.loc.column - current_pair.loc.column
+          end
+
+          def separator_delta(first_pair, current_separator, key_delta)
+            if current_separator.is?(':')
+              0 # Colon follows directly after key
+            else
+              first_pair.loc.column + @max_key_width + 1 -
+                current_separator.column - key_delta
             end
           end
 
-          node.children.each_cons(2) do |prev, current|
-            @column_deltas = deltas(first_pair, prev, current, @max_key_width)
-            convention(current, :expression) unless good_alignment?
+          def value_delta(first_pair, current_pair)
+            first_key, _ = *first_pair
+            _, current_value = *current_pair
+            correct_value_column = first_key.loc.column +
+              spaced_separator(current_pair).length + @max_key_width
+            correct_value_column - current_value.loc.column
           end
-        end
 
-        def any_pairs_on_the_same_line?(node)
-          lines_of_the_children = node.children.map do |pair|
-            key, _value = *pair
-            key.loc.line
+          def spaced_separator(node)
+            node.loc.operator.is?('=>') ? ' => ' : ': '
           end
-          lines_of_the_children.uniq.size < lines_of_the_children.size
         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 each. Some local variables fix the problem.
-          max_key_width = @max_key_width
-          key_delta = @column_deltas[:key] || 0
+        # Handles calculation of deltas when the enforced style is 'separator'.
+        class SeparatorAlignment < AlignmentOfValues
+          def deltas_for_first_pair(first_pair, node)
+            {} # The first pair is always considered correct.
+          end
 
-          key, value = *node
+          private
 
-          @corrections << lambda do |corrector|
-            expr = node.loc.expression
-            b = expr.begin_pos
-            b -= key_delta.abs if key_delta < 0
-            range = Parser::Source::Range.new(expr.source_buffer, b,
-                                              expr.end_pos)
-            source = ' ' * [key_delta, 0].max +
-              if enforced_style(node) == 'key'
-                expr.source
-              else
-                key_source = key.loc.expression.source
-                padded_separator = case enforced_style(node)
-                                   when 'separator'
-                                     spaced_separator(node)
-                                   when 'table'
-                                     space = ' ' * (max_key_width -
-                                                    key_source.length)
-                                     if node.loc.operator.is?('=>')
-                                       space + spaced_separator(node)
-                                     else
-                                       spaced_separator(node) + space
-                                     end
-                                   end
-                key_source + padded_separator + value.loc.expression.source
-              end
-            corrector.replace(range, source)
+          def key_delta(first_pair, current_pair)
+            key_end_column(first_pair) - key_end_column(current_pair)
           end
-        end
 
-        private
+          def key_end_column(pair)
+            key, _value = *pair
+            key.loc.column + key.loc.expression.source.length
+          end
 
-        def good_alignment?
-          @column_deltas.values.compact.none? { |v| v != 0 }
+          def separator_delta(first_pair, current_separator, key_delta)
+            if current_separator.is?(':')
+              0 # Colon follows directly after key
+            else
+              first_pair.loc.operator.column - current_separator.column -
+                key_delta
+            end
+          end
+
+          def value_delta(first_pair, current_pair)
+            _, first_value = *first_pair
+            _, current_value = *current_pair
+            first_value.loc.column - current_value.loc.column
+          end
         end
 
-        def deltas(first_pair, prev_pair, current_pair, max_key_width)
-          enforced_style = enforced_style(current_pair)
-          unless %w(key separator table).include?(enforced_style)
-            fail "Unknown #{config_parameter(current_pair)}: #{enforced_style}"
+        MSG = 'Align the elements of a hash literal if they span more than ' +
+          'one line.'
+
+        def on_hash(node)
+          return if node.children.empty?
+
+          @alignment_for_hash_rockets ||=
+            new_alignment('EnforcedHashRocketStyle')
+          @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
+
+          first_pair = node.children.first
+
+          unless @alignment_for_hash_rockets.checkable_layout(node) &&
+              @alignment_for_colons.checkable_layout(node)
+            return
           end
 
-          return {} if current_pair.loc.line == prev_pair.loc.line
+          @column_deltas = alignment_for(first_pair)
+            .deltas_for_first_pair(first_pair, node)
+          convention(first_pair, :expression) unless good_alignment?
 
-          key_left_alignment_delta = (first_pair.loc.column -
-                                      current_pair.loc.column)
-          if enforced_style == 'key'
-            { key: key_left_alignment_delta }
-          else
-            {
-              key: if enforced_style == 'table'
-                     key_left_alignment_delta
-                   else
-                     key_end_column(first_pair) - key_end_column(current_pair)
-                   end,
-              separator: if current_pair.loc.operator.is?(':') &&
-                             enforced_style == 'table'
-                           # Colon follows directly after key
-                           (key_end_column(current_pair) -
-                            current_pair.loc.operator.column)
-                         else
-                           # Aligned separator
-                           (first_pair.loc.operator.column -
-                            current_pair.loc.operator.column)
-                         end,
-              value: value_delta(first_pair, current_pair, max_key_width)
-            }
+          node.children.each_cons(2) do |prev, current|
+            @column_deltas = alignment_for(current).deltas(first_pair, prev,
+                                                           current)
+            convention(current, :expression) unless good_alignment?
           end
         end
 
-        def key_end_column(pair)
-          key, _value = *pair
-          key.loc.column + key.loc.expression.source.length
+        private
+
+        def alignment_for(pair)
+          if pair.loc.operator.is?('=>')
+            @alignment_for_hash_rockets
+          else
+            @alignment_for_colons
+          end
         end
 
-        def value_delta(first_pair, current_pair, max_key_width)
-          key, value = *current_pair
-          correct_value_column = if enforced_style(current_pair) == 'table'
-                                   key.loc.column +
-                                     spaced_separator(current_pair).length +
-                                     max_key_width
-                                 elsif first_pair.nil? # Only one pair?
-                                   value.loc.column
-                                 else
-                                   _key1, value1 = *first_pair
-                                   value1.loc.column
-                                 end
-          correct_value_column - value.loc.column
+        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 each. Some local variables fix the problem.
+          key_delta       = @column_deltas[:key] || 0
+          separator_delta = @column_deltas[:separator] || 0
+          value_delta     = @column_deltas[:value] || 0
+
+          key, value = *node
+
+          @corrections << lambda do |corrector|
+            adjust(corrector, key_delta, key.loc.expression)
+            adjust(corrector, separator_delta, node.loc.operator)
+            adjust(corrector, value_delta, value.loc.expression)
+          end
         end
 
-        def spaced_separator(node)
-          node.loc.operator.is?('=>') ? ' => ' : ': '
+        def new_alignment(key)
+          case cop_config[key]
+          when 'key'       then KeyAlignment.new
+          when 'table'     then TableAlignment.new
+          when 'separator' then SeparatorAlignment.new
+          else fail "Unknown #{key}: #{cop_config[key]}"
+          end
         end
 
-        def enforced_style(node)
-          cop_config[config_parameter(node)]
+        def adjust(corrector, delta, range)
+          if delta > 0
+            corrector.insert_before(range, ' ' * delta)
+          elsif delta < 0
+            range = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos - delta.abs,
+                                              range.begin_pos)
+            corrector.remove(range)
+          end
         end
 
-        def config_parameter(node)
-          separator = node.loc.operator.is?('=>') ? 'HashRocket' : 'Colon'
-          "Enforced#{separator}Style"
+        def good_alignment?
+          @column_deltas.values.compact.none? { |v| v != 0 }
         end
       end
     end