rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the Ruby 1.8 hash literal syntax,
+      # when the 1.9 syntax is applicable as well.
+      #
+      # A separate offence is registered for each problematic pair.
+      class HashSyntax < Cop
+        MSG = 'Ruby 1.8 hash syntax detected'
+
+        def on_hash(node)
+          pairs = *node
+
+          sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
+
+          if sym_indices
+            pairs.each do |pair|
+              if pair.loc.operator && pair.loc.operator.is?('=>')
+                add_offence(:convention,
+                            pair.loc.expression.begin.join(pair.loc.operator),
+                            MSG)
+              end
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def word_symbol_pair?(pair)
+          key, _value = *pair
+
+          if key.type == :sym
+            sym_name = key.to_a[0]
+
+            sym_name =~ /\A\w+\z/
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for cops checking if and unless statements.
+      module IfThenElse
+        def on_if(node)
+          check(node)
+          super
+        end
+
+        def on_unless(node)
+          check(node)
+          super
+        end
+
+        def check(node)
+          # We won't check modifier or ternary conditionals.
+          if node.loc.expression.source =~ /\A(if|unless)\b/
+            if offending_line(node)
+              add_offence(:convention, node.loc.expression, error_message)
+            end
+          end
+        end
+      end
+
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
+        end
+
+        def error_message
+          'Never use if x; Use the ternary operator instead.'
+        end
+      end
+
+      # Checks for uses of then multi-line if statements.
+      class MultilineIfThen < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          condition, body = *node
+          next_thing = if body && body.loc.expression
+                         body.loc.expression.begin
+                       else
+                         node.loc.end # No body, use "end".
+                       end
+          right_after_cond =
+            Parser::Source::Range.new(next_thing.source_buffer,
+                                      condition.loc.expression.end.end_pos,
+                                      next_thing.begin_pos)
+          if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
+            node.loc.expression.begin.line
+          end
+        end
+
+        def error_message
+          'Never use then for multi-line if/unless.'
+        end
+      end
+
+      # Checks for uses of if/then/else/end on a single line.
+      class OneLineConditional < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.expression.line unless node.loc.expression.source =~ /\n/
+        end
+
+        def error_message
+          'Favor the ternary operator (?:) over if/then/else/end constructs.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the pre 1.9 lambda syntax for one-line
+      # anonymous functions and uses of the 1.9 lambda syntax for multi-line
+      # anonymous functions.
+      class Lambda < Cop
+        SINGLE_MSG = 'Use the new lambda literal syntax ->(params) {...}.'
+        MULTI_MSG = 'Use the lambda method for multi-line lambdas.'
+
+        TARGET = s(:send, nil, :lambda)
+
+        def on_block(node)
+          # We're looking for
+          # (block
+          #   (send nil :lambda)
+          #   ...)
+          block_method, = *node
+
+          if block_method == TARGET
+            selector = block_method.loc.selector.source
+            lambda_length = lambda_length(node)
+
+            if selector != '->' && lambda_length == 0
+              add_offence(:convention, block_method.loc.expression, SINGLE_MSG)
+            elsif selector == '->' && lambda_length > 0
+              add_offence(:convention, block_method.loc.expression, MULTI_MSG)
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def lambda_length(block_node)
+          start_line = block_node.loc.begin.line
+          end_line = block_node.loc.end.line
+
+          end_line - start_line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether comments have a leading space
+      # after the # denoting the start of the comment. The
+      # leading space is not required for some RDoc special syntax,
+      # like #++, #--, #:nodoc, etc.
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after #.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text =~ /^#+[^#\s:+-]/
+              unless comment.text.start_with?('#!') && comment.loc.line == 1
+                add_offence(:convention, comment.loc, MSG)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the line continuation character.
+      #
+      # This check has to be refined or retired, since it doesn't make a lot
+      # of sense without inspection of its context.
+      class LineContinuation < Cop
+        MSG = 'Avoid the use of the line continuation character(\).'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            if line =~ /.*\\\z/
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index],
+                                       line.length - 1, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the length of lines in the source code.
+      # The maximum length is configurable.
+      class LineLength < Cop
+        MSG = 'Line is too long. [%d/%d]'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            max = LineLength.max
+            if line.length > max
+              message = sprintf(MSG, line.length, max)
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index], max,
+                                       line.length - max),
+                          message)
+            end
+          end
+        end
+
+        def self.max
+          LineLength.config['Max']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that all methods and variables use
+      # snake_case for their names. Some special arrangements have to be
+      # made for operator methods.
+      class MethodAndVariableSnakeCase < Cop
+        MSG = 'Use snake_case for methods and variables.'
+        SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
+
+        # http://phrogz.net/programmingruby/language.html#table_18.4
+        OPERATOR_METHODS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).map(&:to_sym)
+
+        def inspect(source_buffer, source, tokens, node, comments)
+          return unless node
+          on_node([:def, :defs, :lvasgn, :ivasgn, :send], node) do |n|
+            name = case n.type
+                   when :def
+                     name_of_instance_method(n)
+                   when :defs
+                     name_of_singleton_method(n)
+                   when :lvasgn, :ivasgn
+                     name_of_variable(n)
+                   when :send
+                     name_of_setter(n)
+                   end
+
+            next unless name
+            next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
+
+            add_offence(:convention, n.location.expression, MSG)
+          end
+        end
+
+        def name_of_instance_method(def_node)
+          def_node.children.first
+        end
+
+        def name_of_singleton_method(defs_node)
+          defs_node.children[1]
+        end
+
+        def name_of_variable(vasgn_node)
+          vasgn_node.children.first
+        end
+
+        def name_of_setter(send_node)
+          receiver, method_name = *send_node
+          return nil unless receiver && receiver.type == :self
+          return nil unless method_name.to_s.end_with?('=')
+          method_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for unwanted parentheses in parameterless method calls.
+      class MethodCallParentheses < Cop
+        MSG = 'Do not use parentheses for method calls with no arguments.'
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+
+          if args.empty? && node.loc.begin
+            add_offence(:convention, node.loc.begin, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks if the length a method exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class MethodLength < Cop
+        MSG = 'Method has too many lines. [%d/%d]'
+
+        def on_def(node)
+          check(node)
+
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+
+          super
+        end
+
+        def max_length
+          MethodLength.config['Max']
+        end
+
+        def count_comments?
+          MethodLength.config['CountComments']
+        end
+
+        private
+
+        def check(node)
+          method_length = calculate_length(node.loc.expression.source)
+
+          if method_length > max_length
+            message = sprintf(MSG, method_length, max_length)
+            add_offence(:convention, node.loc.keyword, message)
+          end
+        end
+
+        def calculate_length(source)
+          lines = source.lines.to_a[1...-1]
+
+          return 0 unless lines
+
+          lines.map!(&:strip).reject!(&:empty?)
+
+          lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
+
+          lines.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses if the keyword *not* instead of !.
+      class Not < Cop
+        MSG = 'Use ! instead of not.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          # not does not take any arguments
+          if args.empty? && method_name == :! &&
+              node.loc.selector.is?('not')
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for big numeric literals without _ between groups
+      # of digits in them.
+      class NumericLiterals < Cop
+        MSG = 'Add underscores to large numeric literals to ' +
+          'improve their readability.'
+
+        def on_int(node)
+          value, = *node
+
+          if value > 10000 &&
+              node.loc.expression.source.split('.').grep(/\d{6}/).any?
+            add_offence(:convention, node.loc.expression, MSG)
+          end
+        end
+
+        alias_method :on_float, :on_int
+      end
+    end
+  end
+end