rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for excessive nesting of conditional and looping
+      # constructs. Despite the cop's name, blocks are not considered as a
+      # extra level of nesting.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Cop
+        NESTING_BLOCKS = [:case, :if, :while, :while_post, :until, :until_post,
+                          :for, :resbody]
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          max = BlockNesting.config['Max']
+          check_nesting_level(ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if NESTING_BLOCKS.include?(node.type)
+            unless node.loc.respond_to?(:keyword) &&
+                node.loc.keyword.is?('elsif')
+              current_level += 1
+            end
+            if current_level == max + 1
+              add_offence(:convention, node.location.expression, message(max))
+              return
+            end
+          end
+          node.children.each do |child|
+            if child.is_a?(Parser::AST::Node)
+              check_nesting_level(child, max, current_level)
+            end
+          end
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Check for uses of braces or do/end around single line or
+      # multi-line blocks.
+      class Blocks < Cop
+        MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
+        SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
+
+        def on_block(node)
+          block_length = Util.block_length(node)
+          block_begin = node.loc.begin.source
+
+          if block_length > 0 && block_begin == '{'
+            add_offence(:convention, node.loc.begin, MULTI_LINE_MSG)
+          elsif block_length == 0 && block_begin != '{'
+            add_offence(:convention, node.loc.begin, SINGLE_LINE_MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the case equality operator(===).
+      class CaseEquality < Cop
+        MSG = 'Avoid the use of the case equality operator(===).'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+
+          if method_name == :===
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the *when*s of a *case* expression
+      # are indented as deep as its *case* keyword.
+      #
+      # It will register a separate offence for each misaligned *when*.
+      class CaseIndentation < Cop
+        MSG = 'Indent when as deep as case.'
+
+        def on_case(case_node)
+          _condition, *whens, _else = *case_node
+
+          case_column = case_node.location.keyword.column
+
+          whens.each do |when_node|
+            pos = when_node.loc.keyword
+            add_offence(:convention, pos, MSG) if pos.column != case_column
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      class CharacterLiteral < Cop
+        MSG = 'Do not use the character literal - use string literal instead.'
+
+        def on_str(node)
+          # Constants like __FILE__ are handled as strings,
+          # but don't respond to begin.
+          return unless node.loc.respond_to?(:begin)
+
+          # we don't register an offence for things like ?\C-\M-d
+          if node.loc.begin.is?('?') && node.loc.expression.source.size < 4
+            add_offence(:convention, node.loc.expression, MSG)
+            do_autocorrect(node)
+          end
+        end
+
+        alias_method :on_dstr, :ignore_node
+        alias_method :on_regexp, :ignore_node
+
+        def autocorrect_action(node)
+          string = node.loc.expression.source[1..-1]
+
+          if string.length == 1 # normal character
+            replace(node.loc.expression, "'#{string}'")
+          elsif string.length == 2 # special character like \n
+            replace(node.loc.expression, %Q("#{string}"))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for class and module names with
+      # an underscore in them.
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'
+
+        def on_class(node)
+          check_name(node)
+
+          super
+        end
+
+        def on_module(node)
+          check_name(node)
+
+          super
+        end
+
+        private
+
+        def check_name(node)
+          name = node.loc.name.source
+
+          add_offence(:convention, node.loc.name, MSG) if name =~ /_/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the class/module name instead of
+      # self, when defining class/module methods.
+      class ClassMethods < Cop
+        MSG = 'Prefer self over class/module for class/module methods.'
+
+        # TODO - check if we're in a class/module
+        def on_defs(node)
+          definee, _name, _args, _body = *node
+
+          if definee.type == :const
+            add_offence(:convention, definee.loc.name, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of unidiomatic method names
+      # from the Enumerable module.
+      #
+      # The current definition of the check is flawed and should be
+      # enhanced by check for by blocks & procs as arguments of the
+      # methods.
+      class CollectionMethods < Cop
+        MSG = 'Prefer %s over %s.'
+
+        PREFERRED_METHODS = {
+          collect: 'map',
+          inject: 'reduce',
+          detect: 'find',
+          find_all: 'select'
+        }
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          # a simple(but flawed way) to reduce false positives
+          if receiver && PREFERRED_METHODS[method_name]
+            add_offence(
+              :convention,
+              node.loc.selector,
+              sprintf(MSG, PREFERRED_METHODS[method_name], method_name)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for methods invoked via the :: operator instead
+      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      class ColonMethodCall < Cop
+        MSG = 'Do not use :: for method calls.'
+
+        def on_send(node)
+          receiver, _method_name, *_args = *node
+
+          # discard methods with nil receivers and op methods(like [])
+          if receiver && node.loc.dot && node.loc.dot.is?('::')
+            add_offence(:convention, node.loc.dot, MSG)
+            do_autocorrect(node)
+          end
+
+          super
+        end
+
+        def autocorrect_action(node)
+          replace(node.loc.dot, '.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # To avoid false positives, it ignores cases in which we cannot know
+      # for certain the type of value that would be assigned to a constant.
+      class ConstantName < Cop
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
+        SNAKE_CASE = /^[\dA-Z_]+$/
+
+        def on_casgn(node)
+          _scope, const_name, value = *node
+
+          # We cannot know the result of method calls line
+          # NewClass = something_that_returns_a_class
+          unless value && value.type == :send
+            if const_name !~ SNAKE_CASE
+              add_offence(:convention, node.loc.name, MSG)
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for parentheses in the definition of a method,
+      # that does not take any arguments. Both instance and
+      # class/singleton methods are checked.
+      class DefWithParentheses < Cop
+        MSG = "Omit the parentheses in defs when the method doesn't accept " +
+            'any arguments.'
+
+        def on_def(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          _, args = *node
+          if args.children == [] && args.loc.begin
+            add_offence(:convention, args.loc.begin, MSG)
+          end
+
+          super
+        end
+
+        def on_defs(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          _, _, args = *node
+          if args.children == [] && args.loc.begin
+            add_offence(:convention, args.loc.begin, MSG)
+          end
+
+          super
+        end
+      end
+
+      # This cop checks for missing parentheses in the definition of a
+      # method, that takes arguments. Both instance and
+      # class/singleton methods are checked.
+      class DefWithoutParentheses < Cop
+        MSG = 'Use def with parentheses when there are arguments.'
+
+        def on_def(node)
+          _, args = *node
+
+          if args.children.size > 0 && args.loc.begin.nil?
+            add_offence(:convention, args.loc.expression, MSG)
+          end
+
+          super
+        end
+
+        def on_defs(node)
+          _, _, args = *node
+
+          if args.children.size > 0 && args.loc.begin.nil?
+            add_offence(:convention, args.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for missing top-level documentation of
+      # classes and modules. Classes with no body are exempt from the
+      # check and so are namespace modules - modules that have nothing in
+      # their bodies except classes or other other modules.
+      class Documentation < Cop
+        MSG = 'Missing top-level %s documentation comment.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+
+          ast_with_comments = Parser::Source::Comment.associate(ast, comments)
+
+          check_classes(ast, ast_with_comments)
+          check_modules(ast, ast_with_comments)
+        end
+
+        private
+
+        def check_classes(ast, ast_with_comments)
+          on_node(:class, ast) do |node|
+            _name, _superclass, body = *node
+
+            if body != nil && ast_with_comments[node].empty?
+              add_offence(:convention, node.loc.keyword, format(MSG, 'class'))
+            end
+          end
+        end
+
+        def check_modules(ast, ast_with_comments)
+          on_node(:module, ast) do |node|
+            _name, body = *node
+
+            if body.nil?
+              namespace = false
+            elsif body.type == :begin
+              namespace = body.children.all? do |n|
+                [:class, :module].include?(n.type)
+              end
+            elsif body.type == :class || body.type == :module
+              namespace = true
+            else
+              namespace = false
+            end
+
+            if !namespace && ast_with_comments[node].empty?
+              add_offence(:convention, node.loc.keyword, format(MSG, 'module'))
+            end
+          end
+        end
+      end
+    end
+  end
+end