rubocop 0.7.2 → 0.8.0

data/lib/rubocop/cop/symbol_array.rb

@@ -3,23 +3,25 @@
 module Rubocop
   module Cop
     class SymbolArray < Cop
-      ERROR_MESSAGE = 'Use %i or %I for array of symbols.'
+      MSG = 'Use %i or %I for array of symbols.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         # %i and %I were introduced in Ruby 2.0
         unless RUBY_VERSION < '2.0.0'
-          each(:array, sexp) do |s|
-            array_elems = s[1]
+          on_node(:array, ast) do |s|
+            next unless s.loc.begin && s.loc.begin.source == '['
+
+            array_elems = s.children
 
             # no need to check empty arrays
             next unless array_elems && array_elems.size > 1
 
-            symbol_array = array_elems.all? { |e| e[0] == :symbol_literal }
+            symbol_array = array_elems.all? { |e| e.type == :sym }
 
             if symbol_array
               add_offence(:convention,
-                          all_positions(s).first.lineno,
-                          ERROR_MESSAGE)
+                          s.loc.line,
+                          MSG)
             end
           end
         end

data/lib/rubocop/cop/symbol_name.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    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.line, MSG)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/syntax.rb

@@ -5,26 +5,33 @@ require 'open3'
 module Rubocop
   module Cop
     class Syntax < Cop
-      def inspect(file, source, tokens, sexp)
+      def inspect_file(file)
+        # Starting JRuby processes would be extremely slow
+        # We need to check if rbx returns nice warning messages
+        return unless RUBY_ENGINE == 'ruby'
+
         stderr = nil
 
         # it's extremely important to run the syntax check in a
         # clean environment - otherwise it will be extremely slow
         if defined? Bundler
           Bundler.with_clean_env do
-            _, stderr, _ =
-              Open3.capture3('ruby -wc', stdin_data: source.join("\n"))
+            _, stderr, _ = Open3.capture3("ruby -wc #{file}")
           end
         else
-          _, stderr, _ =
-            Open3.capture3('ruby -wc', stdin_data: source.join("\n"))
+          _, stderr, _ = Open3.capture3("ruby -wc #{file}")
         end
 
         stderr.each_line do |line|
           # discard lines that are not containing relevant info
           if line =~ /.+:(\d+): (.+)/
-            line_no, severity, message = process_line(line)
-            add_offence(severity, line_no, message)
+            # Assignment to unused variables beginning with underscore
+            # is reported by Ruby 1.9, but not 2.0. Make 1.9 behave
+            # like 2.0.
+            unless line =~ /assigned but unused variable - _\w+/
+              line_no, severity, message = process_line(line)
+              add_offence(severity, line_no, message)
+            end
           end
         end
       end

data/lib/rubocop/cop/tab.rb

@@ -3,11 +3,11 @@
 module Rubocop
   module Cop
     class Tab < Cop
-      ERROR_MESSAGE = 'Tab detected.'
+      MSG = 'Tab detected.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
-          add_offence(:convention, index + 1, ERROR_MESSAGE) if line =~ /^ *\t/
+          add_offence(:convention, index + 1, MSG) if line =~ /^ *\t/
         end
       end
     end

data/lib/rubocop/cop/ternary_operator.rb

@@ -2,39 +2,41 @@
 
 module Rubocop
   module Cop
-    module TernaryOperator
-      def inspect(file, source, tokens, sexp)
-        each(:ifop, sexp) do |ifop|
-          if offends?(ifop)
-            add_offence(:convention, all_positions(ifop).first.lineno,
-                        error_message)
-          end
-        end
-      end
-    end
-
     class MultilineTernaryOperator < Cop
-      include TernaryOperator
-
-      def error_message
+      MSG =
         'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
-      end
 
-      def offends?(ifop)
-        all_positions(ifop).map(&:lineno).uniq.size > 1
+      def on_if(node)
+        loc = node.loc
+
+        # discard non-ternary ops
+        return unless loc.respond_to?(:question)
+
+        add_offence(:convention, loc.line, MSG) if loc.line != loc.colon.line
+
+        super
       end
     end
 
     class NestedTernaryOperator < Cop
-      include TernaryOperator
+      MSG = 'Ternary operators must not be nested. Prefer if/else ' +
+          'constructs instead.'
 
-      def error_message
-        'Ternary operators must not be nested. Prefer if/else constructs ' +
-          'instead.'
-      end
+      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.line, MSG)
+            end
+          end
+        end
 
-      def offends?(ifop)
-        ifop.flatten[1..-1].include?(:ifop)
+        super
       end
     end
   end

data/lib/rubocop/cop/trailing_whitespace.rb

@@ -3,13 +3,11 @@
 module Rubocop
   module Cop
     class TrailingWhitespace < Cop
-      ERROR_MESSAGE = 'Trailing whitespace detected.'
+      MSG = 'Trailing whitespace detected.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
-          if line =~ /.*[ \t]+$/
-            add_offence(:convention, index + 1, ERROR_MESSAGE)
-          end
+          add_offence(:convention, index + 1, MSG) if line =~ /.*[ \t]+$/
         end
       end
     end

data/lib/rubocop/cop/trivial_accessors.rb

@@ -3,101 +3,24 @@
 module Rubocop
   module Cop
     class TrivialAccessors < Cop
-      READER_MESSAGE = 'Use attr_reader to define trivial reader methods.'
-      WRITER_MESSAGE = 'Use attr_writer to define trivial writer methods.'
-
-      def inspect(file, source, token, sexp)
-        each(:def, sexp) do |def_block|
-          find_trivial_accessors def_block
-        end
-      end
-
-      private
-
-      # Parse the sexp given, corresponding to a def method.
-      # Looking for a trivial reader/writer pattern
-      def find_trivial_accessors(sexp)
-        lineno = sexp[1][2].lineno
-        accessor_var = sexp[1][1]
-        if trivial_reader?(sexp, accessor_var)
-          add_offence(:convention, lineno, READER_MESSAGE)
-        elsif trivial_writer?(sexp, accessor_var)
-          add_offence(:convention, lineno, WRITER_MESSAGE)
-        end
-      end
-
-      # body statements that exclude a trivial accessor
-      NON_TRIVIAL_BODYSTMT = [:void_stmt, :unary, :binary,
-                              :@float, :@int, :hash, :begin,
-                              :yield0, :zsuper, :array]
-
-      # looking for a trivial reader method
-      def trivial_reader?(sexp, accessor_var)
-        if reader_shape?(sexp)
-          accessor_body = sexp[3][1][0][1][1]
-          accessor_body.slice!(0) if accessor_body[0] == '@'
-          accessor_var == accessor_body
-        end
-      end
-
-      # looking for a trivial writer method
-      def trivial_writer?(sexp, accessor_var)
-        if accessor_var[-1] == '=' &&
-           writer_shape?(sexp) &&
-           has_only_one_assignment?(sexp)
-          accessor_var.chop!
-          accessor_body = sexp[3][1][0][1][1][1]
-          accessor_body.slice!(0) if accessor_body[0] == '@'
-          unless sexp[3][1][0][0] == :vcall
-            body_purpose = sexp[3][1][0][2][0]
-            accessor_var == accessor_body && body_purpose == :var_ref
-          end
+      MSG = 'Use attr_%s to define trivial %s methods.'
+
+      def on_def(node)
+        _, args, body = *node
+
+        kind = if body.type == :ivar
+                 'reader'
+               elsif args.children.size == 1 && body.type == :ivasgn &&
+                   body.children[1].type == :lvar
+                 'writer'
+               end
+        if kind
+          add_offence(:convention, node.loc.keyword.line,
+                      sprintf(MSG, kind, kind))
         end
-      end
-
-      # return true if the sexp is a reader accessor, without params
-      # or with empty braces
-      def reader_shape?(sexp)
-        accessor_shape?(sexp) &&
-          (sexp[2][0] == :params || empty_params?(sexp[2]))
-      end
-
-      # return true if the sexp is a writer accessor, with a param
-      # and with or without braces
-      def writer_shape?(sexp)
-        accessor_shape?(sexp) && with_braces?(sexp[2])
-      end
-
-      # return true if the sexp has the common shape of an accessor
-      def accessor_shape?(sexp)
-        [:@ident, :@const].include?(sexp[1][0]) &&
-        sexp[3][0] == :bodystmt &&
-        !NON_TRIVIAL_BODYSTMT.include?(sexp[3][1][0][0])
-      end
-
-      # detect "def foo() ..." or
-      # "[:paren, [:params, nil, nil, nil, nil, nil, nil, nil]]"
-      def empty_params?(sexp)
-        sexp[0] == :paren &&
-        sexp[1][0] == :params &&
-        sexp[1][1..-1].reject { |x| !x }.empty?
-      end
 
-      # detect "def name= name" or "def name=(name)
-      def with_braces?(sexp)
-        (sexp[0] == :paren && sexp[1][0] == :params) ||
-          sexp[0] == :params
+        super
       end
-
-      # return true if the sexp has only one assignment in the body
-      # false otherwise (maybe one or more function calls).
-      # why [3..-1]? because:
-      # [:bodystmt, [[:assign, [:var_field, [:var_ref ...] and no :vcall
-      # thus [:bodystmt, :assign, :var_ref, nil, nil, nil ...]
-      def has_only_one_assignment?(sexp)
-        sexp[3][1][1] == nil
-      end
-
-    end # TrivialAccessors
-  end # Cop
-end # Rubocop
+    end
+  end
+end

data/lib/rubocop/cop/unless_else.rb

@@ -3,16 +3,20 @@
 module Rubocop
   module Cop
     class UnlessElse < Cop
-      ERROR_MESSAGE = 'Never use unless with else. Rewrite these with the ' +
+      MSG = 'Never use unless with else. Rewrite these with the ' +
         'positive case first.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:unless, sexp) do |unless_sexp|
-          if unless_sexp.compact.any? { |s| s[0] == :else }
-            add_offence(:convention, all_positions(unless_sexp).first.lineno,
-                        ERROR_MESSAGE)
-          end
+      def on_if(node)
+        loc = node.loc
+
+        # discard ternary ops and modifier if/unless nodes
+        return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
+
+        if loc.keyword.source == 'unless' && loc.else
+          add_offence(:convention, loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/util.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Util
+      module_function
+
+      def strip_quotes(str)
+        if str[0] == '"' || str[0] == "'"
+          str[0] = ''
+          str[-1] = ''
+        else
+          # we're dealing with %q or %Q
+          str[0, 3] = ''
+          str[-1] = ''
+        end
+
+        str
+      end
+
+      def block_length(block_node)
+        block_node.loc.end.line - block_node.loc.begin.line
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_interpolation.rb

@@ -3,18 +3,26 @@
 module Rubocop
   module Cop
     class VariableInterpolation < Cop
-      def inspect(file, source, tokens, sexp)
-        each(:string_dvar, sexp) do |s|
-          interpolation = s[1][0] == :@backref ? s[1] : s[1][1]
-          var = interpolation[1]
-          lineno = interpolation[2].lineno
+      MSG = 'Replace interpolated var %s with expression #{%s}.'
 
-          add_offence(
-            :convention,
-            lineno,
-            "Replace interpolated var #{var} with expression \#{#{var}}."
-          )
+      def on_dstr(node)
+        var_nodes(node.children).each do |v|
+          var = (v.type == :nth_ref ? '$' : '') + v.to_a[0].to_s
+
+          if node.loc.expression.source.include?("##{var}")
+            add_offence(:convention,
+                        v.loc.line,
+                        sprintf(MSG, var, var))
+          end
         end
+
+        super
+      end
+
+      private
+
+      def var_nodes(nodes)
+        nodes.select { |n| [:ivar, :cvar, :gvar, :nth_ref].include?(n.type) }
       end
     end
   end

data/lib/rubocop/cop/when_then.rb

@@ -3,25 +3,14 @@
 module Rubocop
   module Cop
     class WhenThen < Cop
-      ERROR_MESSAGE = 'Never use "when x;". Use "when x then" instead.'
+      MSG = 'Never use "when x;". Use "when x then" instead.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:when, sexp) do |s|
-          # The grammar is:
-          # when <value> <divider> <body>
-          # where divider is either semicolon, then, or line break.
-          last_pos_in_value = all_positions(s[1])[-1]
-
-          next unless last_pos_in_value # Give up if no positions found.
-
-          start_index = tokens.index { |t| t.pos == last_pos_in_value }
-          tokens[start_index..-1].each do |t|
-            break if ['then', "\n"].include?(t.text)
-            if t.type == :on_semicolon
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-            end
-          end
+      def on_when(node)
+        if node.loc.begin && node.loc.begin.source == ';'
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/word_array.rb

@@ -3,35 +3,34 @@
 module Rubocop
   module Cop
     class WordArray < Cop
-      ERROR_MESSAGE = 'Use %w or %W for array of words.'
+      MSG = 'Use %w or %W for array of words.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:array, sexp) do |s|
-          array_elems = s[1]
+      def on_array(node)
+        return unless node.loc.begin && node.loc.begin.source == '['
 
-          # no need to check empty arrays
-          next unless array_elems && array_elems.size > 1
+        array_elems = node.children
 
-          string_array = array_elems.all? { |e| e[0] == :string_literal }
+        # no need to check empty arrays
+        return unless array_elems && array_elems.size > 1
 
-          if string_array && !complex_content?(array_elems)
-            add_offence(:convention,
-                        all_positions(s).first.lineno,
-                        ERROR_MESSAGE)
-          end
+        string_array = array_elems.all? { |e| e.type == :str }
+
+        if string_array && !complex_content?(array_elems)
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
 
-      def complex_content?(arr_sexp)
-        non_empty_strings = 0
+      private
 
-        each(:@tstring_content, arr_sexp) do |content|
-          non_empty_strings += 1
-          return true unless content[1] =~ /\A[\w-]+\z/
+      def complex_content?(arr_sexp)
+        arr_sexp.each do |s|
+          str_content = Util.strip_quotes(s.loc.expression.source)
+          return true unless str_content =~ /\A[\w-]+\z/
         end
 
-        # check for '' strings in the array
-        non_empty_strings == arr_sexp.size ? false : true
+        false
       end
     end
   end