sabat-rubocop 0.9.0

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for unreachable code.
+      # The check are based on the presence of flow of control
+      # statement in non-final position in *begin*(implicit) blocks.
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'
+
+        NODE_TYPES = [:return, :next, :break, :retry, :redo]
+        FLOW_COMMANDS = [:throw, :raise, :fail]
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions.each_cons(2) do |e1, e2|
+            if NODE_TYPES.include?(e1.type) || flow_command?(e1)
+              add_offence(:warning, e2.loc.expression, MSG)
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def flow_command?(node)
+          FLOW_COMMANDS.any? { |c| command?(c, node) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop looks for unused local variables in each scope.
+      # Actually this is a mimic of the warning
+      # "assigned but unused variable - foo" from `ruby -cw`.
+      class UnusedLocalVariable < Cop
+        include VariableInspector
+
+        MSG = 'Assigned but unused variable - %s'
+        TYPES_TO_ACCEPT_UNUSED =
+          (ARGUMENT_DECLARATION_TYPES - [:shadowarg]).freeze
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          inspect_variables(ast)
+        end
+
+        def after_leaving_scope(scope)
+          scope.variable_entries.each_value do |entry|
+            next if entry.used?
+            next if TYPES_TO_ACCEPT_UNUSED.include?(entry.node.type)
+            next if entry.name.to_s.start_with?('_')
+            message = sprintf(MSG, entry.name)
+            add_offence(:warning, entry.node.loc.expression, message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables and literals used
+      # in void context.
+      class Void < Cop
+        OP_MSG = 'Operator %s used in void context.'
+        VAR_MSG = 'Variable %s used in void context.'
+        LIT_MSG = 'Literal %s used in void context'
+
+        OPS = %w(* / % + - == === != < > <= >= <=>)
+        VARS = [:ivar, :lvar, :cvar, :const]
+        LITERALS = [:str, :dstr, :int, :float, :array,
+                    :hash, :regexp, :nil, :true, :false]
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions[0...-1].each do |expr|
+            check_for_void_op(expr)
+            check_for_literal(expr)
+            check_for_var(expr)
+          end
+
+          super
+        end
+
+        private
+
+        def check_for_void_op(node)
+          return unless node.type == :send
+
+          op = node.loc.selector.source
+
+          if OPS.include?(op)
+            add_offence(:warning, node.loc.selector, sprintf(OP_MSG, op))
+          end
+        end
+
+        def check_for_var(node)
+          if VARS.include?(node.type)
+            add_offence(:warning, node.loc.name,
+                        sprintf(VAR_MSG, node.loc.name.source))
+          end
+        end
+
+        def check_for_literal(node)
+          if LITERALS.include?(node.type)
+            add_offence(:warning, node.loc.expression,
+                        sprintf(LIT_MSG, node.loc.expression.source))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offence.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # An Offence represents a style violation detected by RuboCop.
+    class Offence
+      include Comparable
+
+      # @api private
+      SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
+
+      # @api public
+      #
+      # @!attribute [r] severity
+      #
+      # @return [Symbol]
+      #   severity.
+      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      attr_reader :severity
+
+      # @api public
+      #
+      # @!attribute [r] location
+      #
+      # @return [Parser::Source::Range]
+      #   the location where the violation is detected.
+      #
+      # @see http://rubydoc.info/github/whitequark/parser/Parser/Source/Range
+      #   Parser::Source::Range
+      attr_reader :location
+
+      # @api public
+      #
+      # @!attribute [r] message
+      #
+      # @return [String]
+      #   human-readable message
+      #
+      # @example
+      #   'Line is too long. [90/79]'
+      attr_reader :message
+
+      # @api public
+      #
+      # @!attribute [r] cop_name
+      #
+      # @return [String]
+      #   a cop class name without namespace.
+      #   i.e. type of the violation.
+      #
+      # @example
+      #   'LineLength'
+      attr_reader :cop_name
+
+      # @api private
+      attr_reader :line
+
+      # @api private
+      attr_reader :column
+
+      # @api private
+      def initialize(severity, location, message, cop_name)
+        unless SEVERITIES.include?(severity)
+          fail ArgumentError, "Unknown severity: #{severity}"
+        end
+        @severity = severity.freeze
+        @location = location.freeze
+        @line = location.line.freeze
+        @column = location.column.freeze
+        @message = message.freeze
+        @cop_name = cop_name.freeze
+        freeze
+      end
+
+      # @api private
+      def to_s
+        sprintf("#{encode_severity}:%3d:%3d: %s",
+                line, real_column, message)
+      end
+
+      # @api private
+      def encode_severity
+        @severity.to_s[0].upcase
+      end
+
+      # @api private
+      def clang_severity
+        case @severity
+        when :fatal then 'F'.color(:red)
+        when :error then 'E'.color(:red)
+        when :warning then 'W'.color(:magenta)
+        when :convention then 'C'.color(:yellow)
+        end
+      end
+
+      # @api private
+      def severity_level
+        SEVERITIES.index(severity) + 1
+      end
+
+      # @api private
+      #
+      # Internally we use column number that start at 0, but when
+      # outputting column numbers, we want them to start at 1. One
+      # reason is that editors, such as Emacs, expect this.
+      def real_column
+        column + 1
+      end
+
+      # @api public
+      #
+      # @return [Boolean]
+      #   returns `true` if two offences contain same attributes
+      def ==(other)
+        severity == other.severity && line == other.line &&
+          column == other.column && message == other.message &&
+          cop_name == other.cop_name
+      end
+
+      # @api public
+      #
+      # Returns `-1`, `0` or `+1`
+      # if this offence is less than, equal to, or greater than `other`.
+      #
+      # @return [Integer]
+      #   comparison result
+      def <=>(other)
+        [:line, :column, :cop_name, :message].each do |attribute|
+          result = send(attribute) <=> other.send(attribute)
+          return result unless result == 0
+        end
+        0
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/validation.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for the use of old-style attribute validation macros.
+      class Validation < Cop
+        MSG = 'Use the new "sexy" validations (validates ...).'
+
+        BLACKLIST = [:validates_acceptance_of,
+                     :validates_confirmation_of,
+                     :validates_exclusion_of,
+                     :validates_format_of,
+                     :validates_inclusion_of,
+                     :validates_length_of,
+                     :validates_numericality_of,
+                     :validates_presence_of,
+                     :validates_size_of]
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          if receiver.nil? && BLACKLIST.include?(method_name)
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # A couple of checks related to the use method visibility modifiers.
+      # Modifiers should be indented as deeps are method definitions and
+      # surrounded by blank lines.
+      class AccessControl < Cop
+        INDENT_MSG = 'Indent %s as deep as method definitions.'
+        BLANK_MSG = 'Keep a blank line before and after %s.'
+
+        PRIVATE_NODE = s(:send, nil, :private)
+        PROTECTED_NODE = s(:send, nil, :protected)
+        PUBLIC_NODE = s(:send, nil, :public)
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          on_node([:class, :module, :sclass], ast) do |class_node|
+            class_start_col = class_node.loc.expression.column
+
+            # we'll have to walk all class children nodes
+            # except other class/module nodes
+            class_node.children.compact.each do |node|
+              on_node(:send, node, [:class, :module, :sclass]) do |send_node|
+                if modifier_node?(send_node)
+                  send_start_col = send_node.loc.expression.column
+                  selector = send_node.loc.selector.source
+
+                  if send_start_col - 2 != class_start_col
+                    add_offence(:convention,
+                                send_node.loc.expression,
+                                format(INDENT_MSG, selector))
+                  end
+
+                  send_line = send_node.loc.line
+
+                  unless source[send_line].chomp.empty? &&
+                      source[send_line - 2].chomp.empty?
+                    add_offence(:convention,
+                                send_node.loc.expression,
+                                format(BLANK_MSG, selector))
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def modifier_node?(node)
+          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # The purpose of the this cop is advise the use of
+      # alias_method over the alias keyword whenever possible.
+      class Alias < Cop
+        MSG = 'Use alias_method instead of alias.'
+
+        # TODO make this check context aware - alias_method is not
+        # available outside of classes/modules.
+        def on_alias(node)
+          # alias_method can't be used with global variables
+          new, old = *node
+
+          return if new.type == :gvar && old.type == :gvar
+
+          add_offence(:convention,
+                      node.loc.keyword,
+                      MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Here we check if the parameters on a multi-line method call are
+      # aligned.
+      class AlignParameters < Cop
+        MSG = 'Align the parameters of a method call if they span ' +
+          'more than one line.'
+
+        def on_send(node)
+          _receiver, method, *args = *node
+
+          if method != :[]= && args.size > 1
+            first_arg_col = args.first.loc.expression.column
+            prev_arg_line = args.first.loc.expression.line
+            prev_arg_col = first_arg_col
+
+            args.each do |arg|
+              cur_arg_line = arg.loc.expression.line
+              cur_arg_col = arg.loc.expression.column
+
+              if cur_arg_line != prev_arg_line &&
+                  cur_arg_col != first_arg_col
+                add_offence(:convention, arg.loc.expression, MSG)
+              end
+
+              prev_arg_col = cur_arg_col
+              prev_arg_line = cur_arg_line
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of *and* and *or*.
+      class AndOr < Cop
+        MSG = 'Use %s instead of %s.'
+
+        OPS = { 'and' => '&&', 'or' => '||' }
+
+        def on_and(node)
+          process_logical_op(node)
+
+          super
+        end
+
+        def on_or(node)
+          process_logical_op(node)
+
+          super
+        end
+
+        private
+
+        def process_logical_op(node)
+          op = node.loc.operator.source
+          op_type = node.type.to_s
+
+          if op == op_type
+            add_offence(:convention,
+                        node.loc.operator,
+                        sprintf(MSG, OPS[op], op))
+            do_autocorrect(node)
+          end
+        end
+
+        def autocorrect_action(node)
+          replacement = (node.type == :and ? '&&' : '||')
+          replace(node.loc.operator, replacement)
+        end
+      end
+    end
+  end
+end