sabat-rubocop 0.9.0

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,56 @@
+# 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_block(node)
+          method, _args, _body = *node
+
+          check_method_node(method)
+
+          super
+        end
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+
+          if args.size == 1 && args.first.type == :block_pass
+            check_method_node(node)
+          end
+
+          super
+        end
+
+        private
+
+        def check_method_node(node)
+          _receiver, method_name, *_args = *node
+
+          if 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

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the . position in multi-line method calls.
+      class DotPosition < Cop
+        MSG = 'Place the . on the next line, together with the method name.'
+
+        def on_send(node)
+          return unless node.loc.dot
+
+          dot_line = node.loc.dot.line
+          selector_line = node.loc.selector.line
+
+          if dot_line != selector_line
+            add_offence(:convention, node.loc.dot, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether method definitions are
+      # separated by empty lines.
+      class EmptyLineBetweenDefs < Cop
+        MSG = 'Use empty lines between defs.'
+
+        def on_def(node)
+          def_start = node.loc.keyword.line
+          def_end = node.loc.end.line
+
+          if @prev_def_end && (def_start - @prev_def_end) < 2
+            add_offence(:convention, node.loc.keyword, MSG)
+          end
+
+          @prev_def_end = def_end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for two or more consecutive blank lines.
+      class EmptyLines < Cop
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return if tokens.empty?
+
+          prev_line = 1
+
+          tokens.each do |token|
+            cur_line = token.pos.line
+            line_diff = cur_line - prev_line
+
+            if line_diff > LINE_OFFSET
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                # we check if the prev and current lines are empty
+                if source[line - 2].empty? && source[line - 1].empty?
+                  add_offence(:convention,
+                              source_range(source_buffer,
+                                           source[0...(line - 1)], 0, 1),
+                              MSG)
+                end
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash or string.
+      class EmptyLiteral < Cop
+        ARR_MSG = 'Use array literal [] instead of Array.new.'
+        HASH_MSG = 'Use hash literal {} instead of Hash.new.'
+        STR_MSG = "Use string literal '' instead of String.new."
+
+        # Empty array node
+        #
+        # (send
+        #   (const nil :Array) :new)
+        ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
+
+        # Empty hash node
+        #
+        # (send
+        #   (const nil :Hash) :new)
+        HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
+
+        # Empty string node
+        #
+        # (send
+        #   (const nil :String) :new)
+        STR_NODE = s(:send, s(:const, nil, :String), :new)
+
+        def on_send(node)
+          case node
+          when ARRAY_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        ARR_MSG)
+          when HASH_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        HASH_MSG)
+          when STR_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        STR_MSG)
+          end
+        end
+
+        # TODO Check block contents as well
+        alias_method :on_block, :ignore_node
+      end
+    end
+  end
+end