rubocop 0.6.1 → 0.7.0

data/lib/rubocop/cop/method_length.rb

@@ -10,30 +10,19 @@ module Rubocop
           def_lineno, end_lineno = def_and_end_lines(tokens, t_ix)
           length = calculate_length(def_lineno, end_lineno, source)
 
-          if length > MethodLength.max
-            message = sprintf(ERROR_MESSAGE, length, MethodLength.max)
+          max = MethodLength.config['Max']
+          if length > max
+            message = sprintf(ERROR_MESSAGE, length, max)
             add_offence(:convention, def_lineno, message)
           end
         end
       end
 
-      def self.max
-        MethodLength.config ? MethodLength.config['Max'] || 10 : 10
-      end
-
-      def self.count_comments?
-        if MethodLength.config
-          MethodLength.config['CountComments'] || false
-        else
-          false
-        end
-      end
-
       private
 
       def calculate_length(def_lineno, end_lineno, source)
         lines = source[def_lineno..(end_lineno - 2)].reject(&:empty?)
-        unless MethodLength.count_comments?
+        unless MethodLength.config['CountComments']
           lines = lines.reject { |line| line =~ /^\s*#/ }
         end
         lines.size

data/lib/rubocop/cop/not.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Not < Cop
+      ERROR_MESSAGE = 'Use ! instead of not.'
+
+      def inspect(file, source, tokens, sexp)
+        each_keyword('not', tokens) do |t|
+          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offence.rb

@@ -22,6 +22,15 @@ module Rubocop
       def encode_severity
         @severity.to_s[0].upcase
       end
+
+      def ==(other)
+        severity == other.severity and line_number == other.line_number and
+          message == other.message
+      end
+
+      def explode
+        [severity, line_number, message]
+      end
     end
   end
 end

data/lib/rubocop/cop/semicolon.rb

@@ -6,13 +6,84 @@ module Rubocop
       ERROR_MESSAGE = 'Do not use semicolons to terminate expressions.'
 
       def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
+        @tokens = tokens
+        already_checked_line = nil
+        tokens.each_with_index do |t, ix|
           if t.type == :on_semicolon
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+            next if t.pos.lineno == already_checked_line # fast-forward
+            token_1_ix = index_of_first_token_on_line(ix, t.pos.lineno)
+            if %w(def class module).include?(tokens[token_1_ix].text)
+              handle_exceptions_to_the_rule(token_1_ix)
+              if source[t.pos.lineno - 1] =~ /;\s*(#.*)?$/
+                # Semicolons at end of a lines are always reported.
+                add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+              end
+              # When dealing with these one line definitions, we check
+              # the whole line at once. That's why we use the variable
+              # already_checked_line to know when to fast-forward past
+              # the current line.
+              already_checked_line = t.pos.lineno
+            else
+              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+            end
           end
         end
       end
+
+      def index_of_first_token_on_line(ix, lineno)
+        # Index of last token on the previous line
+        prev_line_ix =
+          @tokens[0...ix].rindex { |t| t.pos.lineno < lineno } || 0
+        # Index of first non-whitespace token on the current line.
+        prev_line_ix + @tokens[prev_line_ix..ix].index { |t| !whitespace?(t) }
+      end
+
+      def handle_exceptions_to_the_rule(token_1_ix)
+        # We only do further checking of the def case, which means
+        # that there are some cases of semicolon usage within
+        # non-empty one-line class or method definitions that we don't
+        # catch, but these should be rare.
+        if @tokens[token_1_ix].text == 'def'
+          state = :initial
+          @tokens[token_1_ix..-1].each do |t|
+            state = next_state(state, t) || state
+            break if t.text == 'end'
+          end
+        end
+      end
+
+      def next_state(state, token)
+        return nil if whitespace?(token) # no state change for whitespace
+
+        case state
+        when :initial
+          :def_kw if token.type == :on_kw
+        when :def_kw
+          :method_name if token.type == :on_ident
+        when :method_name
+          case token.type
+          when :on_lparen then :inside_param_list
+          when :on_semicolon then :method_body
+          end
+        when :inside_param_list
+          :right_after_param_list if token.type == :on_rparen
+        when :right_after_param_list
+          if token.type == :on_semicolon
+            unless Semicolon.config['AllowAfterParameterListInOneLineMethods']
+              add_offence(:convention, token.pos.lineno, ERROR_MESSAGE)
+            end
+          end
+          :method_body
+        when :method_body
+          :semicolon_used if token.type == :on_semicolon
+        when :semicolon_used
+          if token.text != 'end' ||
+              !Semicolon.config['AllowBeforeEndInOneLineMethods']
+            add_offence(:convention, token.pos.lineno, ERROR_MESSAGE)
+          end
+          :method_body
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/single_line_methods.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SingleLineMethods < Cop
+      ERROR_MESSAGE = 'Avoid single-line methods.'
+
+      def inspect(file, source, tokens, sexp)
+        if SingleLineMethods.config['AllowIfMethodIsEmpty']
+          is_empty = empty_methods(sexp)
+        end
+
+        lineno_of_def = nil
+        possible_offence = false
+
+        tokens.each_with_index do |token, ix|
+          if possible_offence
+            if token.pos.lineno > lineno_of_def
+              possible_offence = false
+            elsif [token.type, token.text] == [:on_kw, 'end']
+              add_offence(:convention, lineno_of_def, ERROR_MESSAGE)
+            end
+          end
+
+          if [token.type, token.text] == [:on_kw, 'def']
+            lineno_of_def = token.pos.lineno
+            name_token = tokens[ix..-1].find do |t|
+              [:on_ident, :on_const].include?(t.type)
+            end
+            possible_offence =
+              if SingleLineMethods.config['AllowIfMethodIsEmpty']
+                !is_empty[name_token.pos]
+              else
+                true
+              end
+          end
+        end
+      end
+
+      private
+
+      # Returns a hash mapping positions of method names to booleans
+      # saying whether or not the method is empty.
+      def empty_methods(sexp)
+        is_empty = {}
+        # Since def is a keyword, def: can confuse the editor. Hence
+        # Ruby 1.8 hash syntax is used here.
+        # rubocop:disable HashSyntax
+        { :def => [1, 3], :defs => [3, 5] }.each do |key, offsets|
+          each(key, sexp) do |d|
+            method_name_pos = d[offsets.first][-1]
+            is_empty[method_name_pos] =
+              (d[offsets.last] == [:bodystmt, [[:void_stmt]], nil, nil, nil])
+          end
+        end
+        is_empty
+      end
+    end
+  end
+end

data/lib/rubocop/cop/space_after_control_keyword.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SpaceAfterControlKeyword < Cop
+      ERROR_MESSAGE = 'Use space after control keywords.'
+
+      KEYWORDS = %w(if elsif case when while until unless)
+
+      def inspect(file, source, tokens, sexp)
+        # we need to keep track of the previous token to
+        # avoid confusing symbols like :if with real keywords
+        prev = Token.new(0, :init, '')
+
+        tokens.each_cons(2) do |t1, t2|
+          if prev.type != :on_symbeg && t1.type == :on_kw &&
+              KEYWORDS.include?(t1.text) && t2.type != :on_sp
+            add_offence(:convention,
+                        t1.pos.lineno,
+                        ERROR_MESSAGE)
+          end
+
+          prev = t1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/surrounding_space.rb

@@ -13,7 +13,7 @@ module Rubocop
       private
 
       def previous_non_space(tokens, ix)
-        tokens[0...ix].reverse.find { |t| not whitespace?(t) }
+        tokens[0...ix].reverse.find { |t| !whitespace?(t) }
       end
 
       def ok_without_spaces?(grammar_path)
@@ -66,6 +66,9 @@ module Rubocop
       end
 
       def check_missing_space(tokens, ix, grammar_path)
+        # Checked by SpaceInsideHashLiteralBraces and not here.
+        return if grammar_path.last == :hash
+
         t = tokens[ix]
         case t.type
         when :on_lbrace
@@ -123,17 +126,53 @@ module Rubocop
       end
     end
 
+    class SpaceInsideHashLiteralBraces < Cop
+      include SurroundingSpace
+
+      def check_missing_space(tokens, ix, grammar_path)
+        if self.class.config['EnforcedStyleIsWithSpaces']
+          check_space(tokens, ix, grammar_path, 'missing') do |t|
+            !(whitespace?(t) || [:on_lbrace, :on_rbrace].include?(t.type))
+          end
+        end
+      end
+
+      def check_unwanted_space(tokens, ix)
+        unless self.class.config['EnforcedStyleIsWithSpaces']
+          grammar_path = @correlations[ix] or return
+          check_space(tokens, ix, grammar_path, 'detected') do |t|
+            whitespace?(t)
+          end
+        end
+      end
+
+      private
+
+      def check_space(tokens, ix, grammar_path, word)
+        if grammar_path[-1] == :hash
+          is_offence = case tokens[ix].type
+                       when :on_lbrace then yield tokens[ix + 1]
+                       when :on_rbrace then yield tokens[ix - 1]
+                       else false
+                       end
+          if is_offence
+            add_offence(:convention, tokens[ix].pos.lineno,
+                        "Space inside hash literal braces #{word}.")
+          end
+        end
+      end
+    end
+
     class SpaceAroundEqualsInParameterDefault < Cop
       def inspect(file, source, tokens, sexp)
         each(:params, sexp) do |s|
-          (s[2] || []).each do |param, value|
-            value_pos = all_positions(value).first or next
-            if param[-1].lineno == value_pos.lineno
-              if value_pos.column - (param[-1].column + param[1].length) <= 2
-                add_offence(:convention, param[-1].lineno,
-                            'Surrounding space missing in default value ' +
-                            'assignment.')
-              end
+          (s[2] || []).each do |param, _|
+            param_pos = param.last
+            ix = tokens.index { |t| t.pos == param_pos }
+            unless whitespace?(tokens[ix + 1]) && whitespace?(tokens[ix + 3])
+              add_offence(:convention, param[-1].lineno,
+                          'Surrounding space missing in default value ' +
+                          'assignment.')
             end
           end
         end

data/lib/rubocop/cop/symbol_array.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SymbolArray < Cop
+      ERROR_MESSAGE = 'Use %i or %I for array of symbols.'
+
+      def inspect(file, source, tokens, sexp)
+        # %i and %I were introduced in Ruby 2.0
+        unless RUBY_VERSION < '2.0.0'
+          each(:array, sexp) do |s|
+            array_elems = s[1]
+
+            # no need to check empty arrays
+            return unless array_elems && array_elems.size > 1
+
+            symbol_array = array_elems.all? { |e| e[0] == :symbol_literal }
+
+            if symbol_array
+              add_offence(:convention,
+                          all_positions(s).first.lineno,
+                          ERROR_MESSAGE)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/trivial_accessors.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+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
+        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
+      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