rubocop 0.8.3 → 0.9.0

data/lib/rubocop/cop/{op_method.rb → style/op_method.rb}

@@ -2,8 +2,10 @@
 
 module Rubocop
   module Cop
+    # This cop makes sure that certain operator methods have their sole
+    # parameter named *other*.
     class OpMethod < Cop
-      MSG = 'When defining the %s operator, name its argument other.'
+      MSG = 'When defining the %s operator, name its argument *other*.'
 
       BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
 
@@ -14,8 +16,7 @@ module Rubocop
 
         if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
             args.children.size == 1 && args != TARGET_ARGS
-          add_offence(:convention,
-                      node.loc.line,
+          add_offence(:convention, args.children[0].loc.expression,
                       sprintf(MSG, name))
         end
 

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for methods with too many parameters.
+      # The maximum number of parameters in configurable.
+      # On Ruby 2.0+ keyword arguments can optionally
+      # be excluded from the total count.
+      class ParameterLists < Cop
+        MSG = 'Avoid parameter lists longer than %d parameters.'
+
+        def on_args(node)
+          if args_count(node) > max_params
+            add_offence(:convention, node.loc.expression,
+                        sprintf(MSG, max_params))
+          end
+
+          super
+        end
+
+        private
+
+        def args_count(node)
+          if count_keyword_args?
+            node.children.size
+          else
+            node.children.reject { |a| a.type == :kwoptarg }.size
+          end
+        end
+
+        def max_params
+          ParameterLists.config['Max']
+        end
+
+        def count_keyword_args?
+          ParameterLists.config['CountKeywordArgs']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous parentheses around the
+      # condition of if/while/until.
+      class ParenthesesAroundCondition < Cop
+        MSG = "Don't use parentheses around the condition of an " +
+          'if/unless/while/until'
+
+        def on_if(node)
+          process_control_op(node)
+
+          super
+        end
+
+        def on_while(node)
+          process_control_op(node)
+
+          super
+        end
+
+        def on_until(node)
+          process_control_op(node)
+
+          super
+        end
+
+        private
+
+        def process_control_op(node)
+          cond, _body = *node
+
+          if cond.type == :begin
+            add_offence(:convention, cond.loc.expression, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for uses of Proc.new where Kernel#proc
+      # would be more appropriate.
+      class Proc < Cop
+        MSG = 'Use proc instead of Proc.new.'
+
+        TARGET = s(:send, s(:const, nil, :Proc), :new)
+
+        def on_block(node)
+          # We're looking for
+          # (block
+          #   (send
+          #     (const nil :Proc) :new)
+          #   ...)
+          block_method, = *node
+
+          if block_method == TARGET
+            add_offence(:convention, block_method.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the block arguments of a single-line
+      # reduce(inject) call are named *a*(for accumulator) and *e*
+      # (for element)
+      class ReduceArguments < Cop
+        MSG = 'Name reduce arguments |a, e| (accumulator, element).'
+
+        ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
+
+        def on_block(node)
+          # we care only for single line blocks
+          return unless Util.block_length(node) == 0
+
+          method_node, args_node, _body_node = *node
+          receiver, method_name, _method_args = *method_node
+
+          # discard other scenarios
+          return unless receiver
+          return unless [:reduce, :inject].include?(method_name)
+
+          unless args_node == ARGS_NODE
+            add_offence(:convention, node.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for regexp literals and reports offences based
+      # on how many escaped slashes there are in the regexp and on the
+      # value of the configuration parameter MaxSlashes.
+      class RegexpLiteral < Cop
+        def on_regexp(node)
+          slashes = node.loc.expression.source[1...-1].scan(/\//).size
+          max = RegexpLiteral.max_slashes
+          msg = if node.loc.begin.is?('/')
+                  error_message('') if slashes > max
+                else
+                  error_message('only ') if slashes <= max
+                end
+          add_offence(:convention, node.loc.expression, msg) if msg
+
+          super
+        end
+
+        def self.max_slashes
+          RegexpLiteral.config['MaxSlashes']
+        end
+
+        private
+
+        def error_message(word)
+          sprintf('Use %%r %sfor regular expressions matching more ' +
+                  "than %d '/' character%s.",
+                  word,
+                  RegexpLiteral.max_slashes,
+                  RegexpLiteral.max_slashes == 1 ? '' : 's')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of rescue in its modifier form.
+      class RescueModifier < Cop
+        MSG = 'Avoid using rescue in its modifier form.'
+
+        def on_kwbegin(node)
+          body, *_ = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def on_def(node)
+          _method_name, _args, body = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def on_defs(node)
+          _receiver, _method_name, _args, body = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def normal_rescue?(node)
+          return false unless node
+
+          case node.type
+          when :rescue
+            # Skip only the rescue node and continue processing its children.
+            process_regular_node(node)
+            true
+          when :ensure
+            first_child = node.children.first
+            if first_child && first_child.type == :rescue
+              process_regular_node(first_child)
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+
+        def on_rescue(node)
+          add_offence(:convention, node.loc.expression, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for multiple expressions placed on the same line.
+      # It also checks for lines terminated with a semicolon.
+      class Semicolon < Cop
+        MSG = 'Do not use semicolons to terminate expressions.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+
+          on_node(:begin, ast) do |node|
+            exprs = node.children
+
+            next if exprs.size < 2
+
+            # create a map matching lines to the number of expressions on them
+            exprs_lines = exprs.map { |e| e.loc.expression.line }
+            lines = exprs_lines.group_by { |i| i }
+
+            # every line with more than 1 expression on it is an offence
+            lines.each do |line, expr_on_line|
+              if expr_on_line.size > 1
+                # TODO: Find the correct position of the semicolon. We don't
+                # know if the first semicolon on the line is a separator of
+                # expressions. It's just a guess.
+                column = source[line - 1].index(';')
+                add_offence(:convention,
+                            source_range(source_buffer, source[0...(line - 1)],
+                                         column, 1),
+                            MSG)
+              end
+            end
+          end
+
+          tokens.group_by { |t| t.pos.line }.each do |line, line_tokens|
+            if line_tokens.last.type == :tSEMI # rubocop:disable SymbolName
+              column = line_tokens.last.pos.column
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...(line - 1)],
+                                       column, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for single-line method definitions.
+      # It can optionally accept single-line methods with no body.
+      class SingleLineMethods < Cop
+        MSG = 'Avoid single-line method definitions.'
+
+        def allow_empty?
+          SingleLineMethods.config['AllowIfMethodIsEmpty']
+        end
+
+        def on_def(node)
+          check(node)
+
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+
+          super
+        end
+
+        private
+
+        def check(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          if node.type == :def
+            empty_body = node.children[2].nil?
+          else
+            empty_body = node.children[3].nil?
+          end
+
+          if start_line == end_line && !(allow_empty? && empty_body)
+            add_offence(:convention,
+                        node.loc.expression,
+                        MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for cops checking for missing space after
+      # punctuation.
+      module SpaceAfterCommaEtc
+        MSG = 'Space missing after %s.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          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(:convention, 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
+      end
+
+      # Checks for comma (,) not follwed by some kind of space.
+      class SpaceAfterComma < Cop
+        include SpaceAfterCommaEtc
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+
+      # Checks for semicolon (;) not follwed by some kind of space.
+      class SpaceAfterSemicolon < Cop
+        include SpaceAfterCommaEtc
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+
+      # Checks for colon (:) not follwed by some kind of space.
+      class SpaceAfterColon < Cop
+        include SpaceAfterCommaEtc
+
+        # The colon following a label will not appear in the token
+        # array. Instad we get a tLABEL token, whose length we use to
+        # calculate where we expect a space.
+        def offset(token)
+          case token.type
+          when :tLABEL then token.text.length + 1
+          when :tCOLON then 1
+          end
+        end
+
+        def kind(token)
+          case token.type
+          when :tLABEL, :tCOLON then 'colon'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for various control keywords missing a space after them.
+      class SpaceAfterControlKeyword < Cop
+        MSG = 'Use space after control keywords.'
+        # elsif and unless are handled by on_if.
+        KEYWORDS = %w(if case when while until)
+
+        def on_keyword(node)
+          return if node.loc.is_a?(Parser::Source::Map::Ternary)
+
+          exp = node.loc.expression
+          kw = node.loc.keyword
+          kw_offset = kw.begin_pos - exp.begin_pos
+          if exp.source[kw_offset..-1].start_with?(kw.source + '(')
+            add_offence(:convention, kw, MSG)
+          end
+        end
+
+        KEYWORDS.each do |keyword|
+          define_method(:"on_#{keyword}") do |node|
+            on_keyword(node)
+            super(node)
+          end
+        end
+      end
+    end
+  end
+end