rubocop 0.8.3 → 0.9.0

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

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for array literals made up of symbols
+      # that are not using the %i() syntax.
+      #
+      # This check makes sense only on Ruby 2.0+.
+      class SymbolArray < Cop
+        MSG = 'Use %i or %I for array of symbols.'
+
+        def on_array(node)
+          # %i and %I were introduced in Ruby 2.0
+          unless RUBY_VERSION < '2.0.0'
+            return unless node.loc.begin && node.loc.begin.is?('[')
+
+            array_elems = node.children
+
+            # no need to check empty arrays
+            return unless array_elems && array_elems.size > 1
+
+            symbol_array = array_elems.all? { |e| e.type == :sym }
+
+            add_offence(:convention, node.loc.expression, MSG) if symbol_array
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether symbol names are snake_case.
+      # There's also an option to accept CamelCase symbol names as well.
+      class SymbolName < Cop
+        MSG = 'Use snake_case for symbols.'
+        SNAKE_CASE = /^[\da-z_]+[!?=]?$/
+        CAMEL_CASE = /^[A-Z][A-Za-z\d]*$/
+
+        def allow_camel_case?
+          self.class.config['AllowCamelCase']
+        end
+
+        def on_sym(node)
+          sym_name = node.to_a[0]
+          return unless sym_name =~ /^[a-zA-Z]/
+          return if sym_name =~ SNAKE_CASE
+          return if allow_camel_case? && sym_name =~ CAMEL_CASE
+          add_offence(:convention, node.loc.expression, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for tabs inside the source code.
+      class Tab < Cop
+        MSG = 'Tab detected.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            match = line.match(/^( *)\t/)
+            if match
+              spaces = match.captures[0]
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index],
+                                       spaces.length, 8),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for multi-line ternary op expressions.
+      class MultilineTernaryOperator < Cop
+        MSG =
+          'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard non-ternary ops
+          return unless loc.respond_to?(:question)
+
+          if loc.line != loc.colon.line
+            add_offence(:convention, loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+
+      # This cop checks for nested ternary op expressions.
+      class NestedTernaryOperator < Cop
+        MSG = 'Ternary operators must not be nested. Prefer if/else ' +
+            'constructs instead.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard non-ternary ops
+          return unless loc.respond_to?(:question)
+
+          node.children.each do |child|
+            on_node(:if, child) do |c|
+              if c.loc.respond_to?(:question)
+                add_offence(:convention, c.loc.expression, MSG)
+              end
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end