sabat-rubocop 0.9.0

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

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly.
+      #
+      # For keywords (if, def, etc.) the end is aligned with the start
+      # of the keyword.
+      # For blocks - with the start of the expression where the block
+      # is defined.
+      #
+      # @example
+      #
+      #   variable = if true
+      #              end
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      class EndAlignment < Cop
+        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
+
+        def initialize
+          super
+          @inspected_blocks = []
+        end
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          @inspected_blocks = []
+          super
+        end
+
+        def on_def(node)
+          check(node)
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+          super
+        end
+
+        def on_class(node)
+          check(node)
+          super
+        end
+
+        def on_module(node)
+          check(node)
+          super
+        end
+
+        def on_if(node)
+          check(node) if node.loc.respond_to?(:end)
+          super
+        end
+
+        def on_while(node)
+          check(node)
+          super
+        end
+
+        def on_until(node)
+          check(node)
+          super
+        end
+
+        # Block related alignments
+
+        def on_block(node)
+          return if already_processed_node?(node)
+          check_block_alignment(node.loc.expression, node.loc)
+          super
+        end
+
+        def on_and(node)
+          return if already_processed_node?(node)
+
+          _left, right = *node
+          if right.type == :block
+            check_block_alignment(node.loc.expression, right.loc)
+            @inspected_blocks << right
+          end
+          super
+        end
+
+        alias_method :on_or, :on_and
+
+        def on_lvasgn(node)
+          _, children = *node
+          process_block_assignment(node, children)
+          super
+        end
+
+        alias_method :on_ivasgn,   :on_lvasgn
+        alias_method :on_cvasgn,   :on_lvasgn
+        alias_method :on_gvasgn,   :on_lvasgn
+        alias_method :on_and_asgn, :on_lvasgn
+        alias_method :on_or_asgn,  :on_lvasgn
+
+        def on_casgn(node)
+          _, _, children = *node
+          process_block_assignment(node, children)
+          super
+        end
+
+        def on_op_asgn(node)
+          variable, _op, args = *node
+          process_block_assignment(variable, args)
+          super
+        end
+
+        def on_send(node)
+          _receiver, _method, *args = *node
+          process_block_assignment(node, args.last)
+          super
+        end
+
+        def on_masgn(node)
+          variables, args = *node
+          process_block_assignment(variables, args)
+          super
+        end
+
+        private
+
+        def process_block_assignment(begin_node, block_node)
+          return unless block_node
+          return if already_processed_node?(block_node)
+
+          while block_node.type == :send
+            receiver, _method, args = *block_node
+            if receiver && [:block, :send].include?(receiver.type)
+              block_node = receiver
+            elsif args && [:block, :send].include?(args.type)
+              block_node = args
+            else
+              break
+            end
+          end
+          if block_node.type == :block
+            # Align with the expression that is on the same line
+            # where the block is defined
+            return if block_is_on_next_line?(begin_node, block_node)
+
+            @inspected_blocks << block_node
+            check_block_alignment(begin_node.loc.expression, block_node.loc)
+          end
+        end
+
+        def check_block_alignment(start_loc, block_loc)
+          end_loc = block_loc.end
+          if block_loc.begin.line != end_loc.line &&
+               start_loc.column != end_loc.column
+            add_offence(:warning,
+                        end_loc,
+                        sprintf(MSG, end_loc.line, end_loc.column,
+                                start_loc.source.lines.to_a.first.chomp,
+                                start_loc.line, start_loc.column))
+          end
+        end
+
+        def check(node)
+          # discard modifier forms of if/while/until
+          return unless node.loc.end
+
+          kw_loc = node.loc.keyword
+          end_loc = node.loc.end
+
+          if kw_loc.line != end_loc.line && kw_loc.column != end_loc.column
+            add_offence(:warning,
+                        end_loc,
+                        sprintf(MSG, end_loc.line, end_loc.column,
+                                kw_loc.source, kw_loc.line, kw_loc.column))
+          end
+        end
+
+        def already_processed_node?(node)
+          @inspected_blocks.include?(node)
+        end
+
+        def block_is_on_next_line?(begin_node, block_node)
+          begin_node.loc.line != block_node.loc.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for END blocks in method definitions.
+      class EndInMethod < Cop
+        MSG = 'END found in method definition. Use `at_exit` instead.'
+
+        def on_def(node)
+          check(node)
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+          super
+        end
+
+        private
+
+        def check(node)
+          on_node(:postexe, node) do |end_node|
+            add_offence(:warning, end_node.loc.keyword, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *return* from an *ensure* block.
+      class EnsureReturn < Cop
+        MSG = 'Never return from an ensure block.'
+
+        def on_ensure(node)
+          _body, ensure_body = *node
+
+          on_node(:return, ensure_body) do |e|
+            add_offence(:warning, e.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for the use of *Kernel#eval*.
+      class Eval < Cop
+        MSG = 'The use of eval is a serious security risk.'
+
+        def on_send(node)
+          receiver, method_name, = *node
+
+          if receiver.nil? && method_name == :eval
+            add_offence(:warning, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks with no body.
+      class HandleExceptions < Cop
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          _exc_list_node, _exc_var_node, body_node = *node
+
+          add_offence(:warning, node.loc.expression, MSG) unless body_node
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for literals used as the conditions or as
+      # operands in and/or expressions serving as the conditions of
+      # if/while/until.
+      #
+      # @example
+      #
+      #   if 20
+      #     do_something
+      #   end
+      #
+      #   if some_var && true
+      #     do_something
+      #   end
+      #
+      class LiteralInCondition < Cop
+        MSG = 'Literal %s appeared in a condition.'
+
+        LITERALS = [:str, :dstr, :int, :float, :array,
+                    :hash, :regexp, :nil, :true, :false]
+
+        def on_if(node)
+          check_for_literal(node)
+
+          super
+        end
+
+        def on_while(node)
+          check_for_literal(node)
+
+          super
+        end
+
+        def on_while_post(node)
+          check_for_literal(node)
+
+          super
+        end
+
+        def on_until(node)
+          check_for_literal(node)
+
+          super
+        end
+
+        def on_until_post(node)
+          check_for_literal(node)
+
+          super
+        end
+
+        private
+
+        def check_for_literal(node)
+          cond, = *node
+
+          # if the code node is literal we obviously have a problem
+          if LITERALS.include?(cond.type)
+            add_offence(:warning, cond.loc.expression,
+                        format(MSG, cond.loc.expression.source))
+          elsif [:and, :or].include?(cond.type)
+            # alternatively we have to consider a logical node with a
+            # literal argument
+            *operands = *cond
+            operands.each do |op|
+              if LITERALS.include?(op.type)
+                add_offence(:warning, op.loc.expression,
+                            format(MSG, op.loc.expression.source))
+
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for uses of *begin...end while/until something*.
+      class Loop < Cop
+        MSG = 'Use Kernel#loop with break rather than ' +
+              'begin/end/until(or while).'
+
+        def on_while_post(node)
+          register_offence(node)
+          super
+        end
+
+        def on_until_post(node)
+          register_offence(node)
+          super
+        end
+
+        private
+
+        def register_offence(node)
+          add_offence(:warning, node.loc.keyword, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks targeting the Exception class.
+      class RescueException < Cop
+        MSG = 'Avoid rescuing the Exception class.'
+
+        def on_resbody(node)
+          return unless node.children.first
+          rescue_args = node.children.first.children
+          if rescue_args.any? { |a| targets_exception?(a) }
+            add_offence(:warning, node.location.expression, MSG)
+          end
+
+          super
+        end
+
+        def targets_exception?(rescue_arg_node)
+          return false unless rescue_arg_node.type == :const
+          namespace, klass_name = *rescue_arg_node
+          return false unless namespace.nil? || namespace.type == :cbase
+          klass_name == :Exception
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop looks for use of the same name as outer local variables
+      # for block arguments or block local variables.
+      # This is a mimic of the warning
+      # "shadowing outer local variable - foo" from `ruby -cw`.
+      class ShadowingOuterLocalVariable < Cop
+        include VariableInspector
+
+        MSG = 'Shadowing outer local variable - %s'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          inspect_variables(ast)
+        end
+
+        def before_declaring_variable(entry)
+          # Only block scope can reference outer local variables.
+          return unless variable_table.current_scope.node.type == :block
+          return unless ARGUMENT_DECLARATION_TYPES.include?(entry.node.type)
+          return if entry.name.to_s.start_with?('_')
+
+          outer_local_variable = variable_table.find_variable_entry(entry.name)
+          return unless outer_local_variable
+
+          message = sprintf(MSG, entry.name)
+          add_offence(:warning, entry.node.loc.expression, message)
+        end
+      end
+    end
+  end
+end