sabat-rubocop 0.9.0

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for uses of Proc.new where Kernel#proc
+      # would be more appropriate.
+      class Proc < Cop
+        MSG = 'Use proc instead of Proc.new.'
+
+        TARGET = s(:send, s(:const, nil, :Proc), :new)
+
+        def on_block(node)
+          # We're looking for
+          # (block
+          #   (send
+          #     (const nil :Proc) :new)
+          #   ...)
+          block_method, = *node
+
+          if block_method == TARGET
+            add_offence(:convention, block_method.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the block arguments of a single-line
+      # reduce(inject) call are named *a*(for accumulator) and *e*
+      # (for element)
+      class ReduceArguments < Cop
+        MSG = 'Name reduce arguments |a, e| (accumulator, element).'
+
+        ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
+
+        def on_block(node)
+          # we care only for single line blocks
+          return unless Util.block_length(node) == 0
+
+          method_node, args_node, _body_node = *node
+          receiver, method_name, _method_args = *method_node
+
+          # discard other scenarios
+          return unless receiver
+          return unless [:reduce, :inject].include?(method_name)
+
+          unless args_node == ARGS_NODE
+            add_offence(:convention, node.loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for regexp literals and reports offences based
+      # on how many escaped slashes there are in the regexp and on the
+      # value of the configuration parameter MaxSlashes.
+      class RegexpLiteral < Cop
+        def on_regexp(node)
+          slashes = node.loc.expression.source[1...-1].scan(/\//).size
+          max = RegexpLiteral.max_slashes
+          msg = if node.loc.begin.is?('/')
+                  error_message('') if slashes > max
+                else
+                  error_message('only ') if slashes <= max
+                end
+          add_offence(:convention, node.loc.expression, msg) if msg
+
+          super
+        end
+
+        def self.max_slashes
+          RegexpLiteral.config['MaxSlashes']
+        end
+
+        private
+
+        def error_message(word)
+          sprintf('Use %%r %sfor regular expressions matching more ' +
+                  "than %d '/' character%s.",
+                  word,
+                  RegexpLiteral.max_slashes,
+                  RegexpLiteral.max_slashes == 1 ? '' : 's')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of rescue in its modifier form.
+      class RescueModifier < Cop
+        MSG = 'Avoid using rescue in its modifier form.'
+
+        def on_kwbegin(node)
+          body, *_ = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def on_def(node)
+          _method_name, _args, body = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def on_defs(node)
+          _receiver, _method_name, _args, body = *node
+          return if normal_rescue?(body)
+          super
+        end
+
+        def normal_rescue?(node)
+          return false unless node
+
+          case node.type
+          when :rescue
+            # Skip only the rescue node and continue processing its children.
+            process_regular_node(node)
+            true
+          when :ensure
+            first_child = node.children.first
+            if first_child && first_child.type == :rescue
+              process_regular_node(first_child)
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+
+        def on_rescue(node)
+          add_offence(:convention, node.loc.expression, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for multiple expressions placed on the same line.
+      # It also checks for lines terminated with a semicolon.
+      class Semicolon < Cop
+        MSG = 'Do not use semicolons to terminate expressions.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+
+          on_node(:begin, ast) do |node|
+            exprs = node.children
+
+            next if exprs.size < 2
+
+            # create a map matching lines to the number of expressions on them
+            exprs_lines = exprs.map { |e| e.loc.expression.line }
+            lines = exprs_lines.group_by { |i| i }
+
+            # every line with more than 1 expression on it is an offence
+            lines.each do |line, expr_on_line|
+              if expr_on_line.size > 1
+                # TODO: Find the correct position of the semicolon. We don't
+                # know if the first semicolon on the line is a separator of
+                # expressions. It's just a guess.
+                column = source[line - 1].index(';')
+                add_offence(:convention,
+                            source_range(source_buffer, source[0...(line - 1)],
+                                         column, 1),
+                            MSG)
+              end
+            end
+          end
+
+          tokens.group_by { |t| t.pos.line }.each do |line, line_tokens|
+            if line_tokens.last.type == :tSEMI # rubocop:disable SymbolName
+              column = line_tokens.last.pos.column
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...(line - 1)],
+                                       column, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for single-line method definitions.
+      # It can optionally accept single-line methods with no body.
+      class SingleLineMethods < Cop
+        MSG = 'Avoid single-line method definitions.'
+
+        def allow_empty?
+          SingleLineMethods.config['AllowIfMethodIsEmpty']
+        end
+
+        def on_def(node)
+          check(node)
+
+          super
+        end
+
+        def on_defs(node)
+          check(node)
+
+          super
+        end
+
+        private
+
+        def check(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          if node.type == :def
+            empty_body = node.children[2].nil?
+          else
+            empty_body = node.children[3].nil?
+          end
+
+          if start_line == end_line && !(allow_empty? && empty_body)
+            add_offence(:convention,
+                        node.loc.expression,
+                        MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for cops checking for missing space after
+      # punctuation.
+      module SpaceAfterCommaEtc
+        MSG = 'Space missing after %s.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          tokens.each_cons(2) do |t1, t2|
+            if kind(t1) && t1.pos.line == t2.pos.line &&
+                t2.pos.column == t1.pos.column + offset(t1)
+              add_offence(:convention, t1.pos, sprintf(MSG, kind(t1)))
+            end
+          end
+        end
+
+        # The normal offset, i.e., the distance from the punctuation
+        # token where a space should be, is 1.
+        def offset(token)
+          1
+        end
+      end
+
+      # Checks for comma (,) not follwed by some kind of space.
+      class SpaceAfterComma < Cop
+        include SpaceAfterCommaEtc
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+
+      # Checks for semicolon (;) not follwed by some kind of space.
+      class SpaceAfterSemicolon < Cop
+        include SpaceAfterCommaEtc
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+
+      # Checks for colon (:) not follwed by some kind of space.
+      class SpaceAfterColon < Cop
+        include SpaceAfterCommaEtc
+
+        # The colon following a label will not appear in the token
+        # array. Instad we get a tLABEL token, whose length we use to
+        # calculate where we expect a space.
+        def offset(token)
+          case token.type
+          when :tLABEL then token.text.length + 1
+          when :tCOLON then 1
+          end
+        end
+
+        def kind(token)
+          case token.type
+          when :tLABEL, :tCOLON then 'colon'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for various control keywords missing a space after them.
+      class SpaceAfterControlKeyword < Cop
+        MSG = 'Use space after control keywords.'
+        # elsif and unless are handled by on_if.
+        KEYWORDS = %w(if case when while until)
+
+        def on_keyword(node)
+          return if node.loc.is_a?(Parser::Source::Map::Ternary)
+
+          exp = node.loc.expression
+          kw = node.loc.keyword
+          kw_offset = kw.begin_pos - exp.begin_pos
+          if exp.source[kw_offset..-1].start_with?(kw.source + '(')
+            add_offence(:convention, kw, MSG)
+          end
+        end
+
+        KEYWORDS.each do |keyword|
+          define_method(:"on_#{keyword}") do |node|
+            on_keyword(node)
+            super(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of double quotes where single quotes would do.
+      class StringLiterals < Cop
+        MSG = "Prefer single-quoted strings when you don't need " +
+          'string interpolation or special symbols.'
+
+        def on_str(node)
+          # Constants like __FILE__ are handled as strings,
+          # but don't respond to begin.
+          return unless node.loc.respond_to?(:begin)
+
+          # regex matches IF there is a ' or there is a \\ in the string that
+          # is not preceeded/followed by another \\ (e.g. "\\x34") but not
+          # "\\\\"
+          if node.loc.expression.source !~ /('|([^\\]|\A)\\([^\\]|\Z))/ &&
+              node.loc.begin.is?('"')
+            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)
+          replace(node.loc.begin, "'")
+          replace(node.loc.end, "'")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,314 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for checking surrounding space.
+      module SurroundingSpace
+        def space_between?(t1, t2)
+          char_preceding_2nd_token =
+            @source[t2.pos.line - 1][t2.pos.column - 1]
+          if char_preceding_2nd_token == '+' && t1.type != :tPLUS
+            # Special case. A unary plus is not present in the tokens.
+            char_preceding_2nd_token =
+              @source[t2.pos.line - 1][t2.pos.column - 2]
+          end
+          t2.pos.line > t1.pos.line || char_preceding_2nd_token == ' '
+        end
+
+        def index_of_first_token(node, tokens)
+          @token_table ||= build_token_table(tokens)
+          b = node.loc.expression.begin
+          @token_table[[b.line, b.column]]
+        end
+
+        def index_of_last_token(node, tokens)
+          @token_table ||= build_token_table(tokens)
+          e = node.loc.expression.end
+          (0...e.column).to_a.reverse.find do |c|
+            ix = @token_table[[e.line, c]]
+            return ix if ix
+          end
+        end
+
+        def build_token_table(tokens)
+          table = {}
+          tokens.each_with_index do |t, ix|
+            table[[t.pos.line, t.pos.column]] = ix
+          end
+          table
+        end
+      end
+
+      # Checks that operators have space around them, except for **
+      # which should not have surrounding space.
+      class SpaceAroundOperators < Cop
+        include SurroundingSpace
+        MSG_MISSING = "Surrounding space missing for operator '%s'."
+        MSG_DETECTED = 'Space around operator ** detected.'
+
+        BINARY_OPERATORS =
+          [:tEQL,    :tAMPER2,  :tPIPE,  :tCARET, :tPLUS,  :tMINUS, :tSTAR2,
+           :tDIVIDE, :tPERCENT, :tEH,    :tCOLON, :tANDOP, :tOROP,  :tMATCH,
+           :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
+           :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
+
+        def inspect(source_buffer, source, tokens, sexp, comments)
+          return unless sexp
+
+          @source = source
+          positions_not_to_check = get_positions_not_to_check(tokens, sexp)
+
+          tokens.each_cons(3) do |token_before, token, token_after|
+            next if token_before.type == :kDEF # TODO: remove?
+            next if token_before.type == :tDOT # Called as method.
+            next if positions_not_to_check.include?(token.pos)
+
+            case token.type
+            when :tPOW
+              if has_space?(token_before, token, token_after)
+                add_offence(:convention, token.pos, MSG_DETECTED)
+              end
+            when *BINARY_OPERATORS
+              check_missing_space(token_before, token, token_after)
+            end
+          end
+        end
+
+        # Returns an array of positions marking the tokens that this cop
+        # should not check, either because the token is not an operator
+        # or because another cop does the check.
+        def get_positions_not_to_check(tokens, sexp)
+          positions_not_to_check = []
+          do_not_check_block_arg_pipes(sexp, positions_not_to_check)
+          do_not_check_param_default(tokens, sexp, positions_not_to_check)
+          do_not_check_class_lshift_self(tokens, sexp, positions_not_to_check)
+          do_not_check_def_things(tokens, sexp, positions_not_to_check)
+          do_not_check_singleton_operator_defs(tokens, sexp,
+                                               positions_not_to_check)
+          positions_not_to_check
+        end
+
+        def do_not_check_block_arg_pipes(sexp, positions_not_to_check)
+          # each { |a| }
+          #        ^ ^
+          on_node(:block, sexp) do |b|
+            on_node(:args, b) do |a|
+              positions_not_to_check << a.loc.begin << a.loc.end if a.loc.begin
+            end
+          end
+        end
+
+        def do_not_check_param_default(tokens, sexp, positions_not_to_check)
+          # func(a, b=nil)
+          #          ^
+          on_node(:optarg, sexp) do |optarg|
+            _arg, equals, _value = tokens[index_of_first_token(optarg, tokens),
+                                          3]
+            positions_not_to_check << equals.pos
+          end
+        end
+
+        def do_not_check_class_lshift_self(tokens,
+                                           sexp,
+                                           positions_not_to_check)
+          # class <<self
+          #       ^
+          on_node(:sclass, sexp) do |sclass|
+            ix = index_of_first_token(sclass, tokens)
+            if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
+              positions_not_to_check << tokens[ix + 1].pos
+            end
+          end
+        end
+
+        def do_not_check_def_things(tokens, sexp, positions_not_to_check)
+          # def +(other)
+          #     ^
+          on_node(:def, sexp) do |def_node|
+            # def each &block
+            #          ^
+            # def each *args
+            #          ^
+            on_node([:blockarg, :restarg], def_node) do |arg_node|
+              positions_not_to_check <<
+                tokens[index_of_first_token(arg_node, tokens)].pos
+            end
+            positions_not_to_check <<
+              tokens[index_of_first_token(def_node, tokens) + 1].pos
+          end
+        end
+
+        def do_not_check_singleton_operator_defs(tokens, sexp,
+                                                 positions_not_to_check)
+          # def self.===(other)
+          #          ^
+          on_node(:defs, sexp) do |defs_node|
+            _receiver, name, _args = *defs_node
+            ix = index_of_first_token(defs_node, tokens)
+            name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
+            positions_not_to_check << name_token.pos
+          end
+        end
+
+        def check_missing_space(token_before, token, token_after)
+          unless has_space?(token_before, token, token_after)
+            text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
+            add_offence(:convention, token.pos, MSG_MISSING % text)
+          end
+        end
+
+        def has_space?(token_before, token, token_after)
+          space_between?(token_before, token) && space_between?(token,
+                                                                token_after)
+        end
+      end
+
+      # Checks that block braces have surrounding space.
+      class SpaceAroundBraces < Cop
+        include SurroundingSpace
+        MSG_LEFT = "Surrounding space missing for '{'."
+        MSG_RIGHT = "Space missing to the left of '}'."
+
+        def inspect(source_buffer, source, tokens, sexp, comments)
+          return unless sexp
+          @source = source
+          positions_not_to_check = get_positions_not_to_check(tokens, sexp)
+          tokens.each_cons(2) do |t1, t2|
+            next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
+
+            type1, type2 = t1.type, t2.type
+            # :tLBRACE in hash literals, :tLCURLY otherwise.
+            next if [:tLCURLY, :tLBRACE].include?(type1) && type2 == :tRCURLY
+            check(t1, t2, MSG_LEFT) if type1 == :tLCURLY || type2 == :tLCURLY
+            check(t1, t2, MSG_RIGHT) if type2 == :tRCURLY
+          end
+        end
+
+        def get_positions_not_to_check(tokens, sexp)
+          positions_not_to_check = []
+
+          on_node(:hash, sexp) do |hash|
+            b_ix = index_of_first_token(hash, tokens)
+            e_ix = index_of_last_token(hash, tokens)
+            positions_not_to_check << tokens[b_ix].pos << tokens[e_ix].pos
+          end
+
+          # TODO: Check braces inside string/symbol/regexp/xstr interpolation.
+          on_node([:dstr, :dsym, :regexp, :xstr], sexp) do |s|
+            b_ix = index_of_first_token(s, tokens)
+            e_ix = index_of_last_token(s, tokens)
+            tokens[b_ix..e_ix].each do |t|
+              positions_not_to_check << t.pos if t.type == :tRCURLY
+            end
+          end
+
+          positions_not_to_check
+        end
+
+        def check(t1, t2, msg)
+          unless space_between?(t1, t2)
+            brace_token = msg == MSG_LEFT ? t1 : t2
+            add_offence(:convention, brace_token.pos, msg)
+          end
+        end
+      end
+
+      # Common functionality for checking for spaces inside various
+      # kinds of parentheses.
+      module SpaceInside
+        include SurroundingSpace
+        MSG = 'Space inside %s detected.'
+
+        def inspect(source_buffer, source, tokens, sexp, comments)
+          @source = source
+          left, right, kind = specifics
+          tokens.each_cons(2) do |t1, t2|
+            if t1.type == left || t2.type == right
+              if t2.pos.line == t1.pos.line && space_between?(t1, t2)
+                space_range = Parser::Source::Range.new(source_buffer,
+                                                        t1.pos.end_pos,
+                                                        t2.pos.begin_pos)
+                add_offence(:convention, space_range, format(MSG, kind))
+              end
+            end
+          end
+        end
+      end
+
+      # Checks for spaces inside ordinary round parentheses.
+      class SpaceInsideParens < Cop
+        include SpaceInside
+
+        def specifics
+          [:tLPAREN2, :tRPAREN, 'parentheses']
+        end
+      end
+
+      # Checks for spaces inside square brackets.
+      class SpaceInsideBrackets < Cop
+        include SpaceInside
+
+        def specifics
+          [:tLBRACK, :tRBRACK, 'square brackets']
+        end
+      end
+
+      # Checks that braces used for hash literals have or don't have
+      # surrounding space depending on configuration.
+      class SpaceInsideHashLiteralBraces < Cop
+        include SurroundingSpace
+        MSG = 'Space inside hash literal braces %s.'
+
+        def inspect(source_buffer, source, tokens, sexp, comments)
+          return unless sexp
+          @source = source
+          on_node(:hash, sexp) do |hash|
+            b_ix = index_of_first_token(hash, tokens)
+            e_ix = index_of_last_token(hash, tokens)
+            if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
+              check(tokens[b_ix], tokens[b_ix + 1])
+              check(tokens[e_ix - 1], tokens[e_ix])
+            end
+          end
+        end
+
+        def check(t1, t2)
+          types = [t1, t2].map(&:type)
+          braces = [:tLBRACE, :tRCURLY]
+          return if types == braces || (braces - types).size == 2
+          # No offence if line break inside.
+          return if t1.pos.line < t2.pos.line
+          has_space = space_between?(t1, t2)
+          is_offence, word = if self.class.config['EnforcedStyleIsWithSpaces']
+                               [!has_space, 'missing']
+                             else
+                               [has_space, 'detected']
+                             end
+          add_offence(:convention, t1.pos, sprintf(MSG, word)) if is_offence
+        end
+      end
+
+      # Checks that the equals signs in parameter default assignments
+      # have surrounding space.
+      class SpaceAroundEqualsInParameterDefault < Cop
+        include SurroundingSpace
+        MSG = 'Surrounding space missing in default value assignment.'
+
+        def inspect(source_buffer, source, tokens, sexp, comments)
+          return unless sexp
+          @source = source
+          on_node(:optarg, sexp) do |optarg|
+            index = index_of_first_token(optarg, tokens)
+            arg, equals, value = tokens[index, 3]
+            unless space_between?(arg, equals) && space_between?(equals, value)
+              add_offence(:convention, equals.pos, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end