rubocop 0.2.1 → 0.3.0

data/lib/rubocop/cop/encoding.rb

@@ -4,12 +4,12 @@ module Rubocop
   module Cop
     class Encoding < Cop
       ERROR_MESSAGE = 'Missing encoding comment.'
-      MAX_LINE_LENGTH = 80
 
       def inspect(file, source, tokens, sexp)
-        unless source[0] =~ /#.*coding: (UTF|utf)-8/
-          message = sprintf(ERROR_MESSAGE)
-          add_offence(:convention, 1, message)
+        expected_line = 0
+        expected_line += 1 if source[expected_line] =~ /^#!/
+        unless source[expected_line] =~ /#.*coding: (UTF|utf)-8/
+          add_offence(:convention, 1, ERROR_MESSAGE)
         end
       end
     end

data/lib/rubocop/cop/if_then_else.rb

@@ -2,21 +2,13 @@
 
 module Rubocop
   module Cop
-    class IfThenElse < Cop
-      ERROR_MESSAGE = {
-        multiline_if_then:
-        'Never use then for multi-line if/unless.',
-        one_liner:
-        'Favor the ternary operator (?:) over if/then/else/end constructs.',
-        semicolon:
-        'Never use if x; Use the ternary operator instead.'
-      }
-
+    module IfThenElse
       def inspect(file, source, tokens, sexp)
         tokens.each_with_index do |t, ix|
           if t.type == :on_kw && ['if', 'unless'].include?(t.text)
-            error = ERROR_MESSAGE[kind_of_if(tokens, ix + 1)]
-            add_offence(:convention, t.pos.lineno, error) if error
+            if kind_of_if(tokens, ix + 1) == self.class
+              add_offence(:convention, t.pos.lineno, error_message)
+            end
           end
         end
       end
@@ -28,12 +20,12 @@ module Rubocop
           when :on_kw
             case t.text
             when 'then' then then_found = true
-            when 'end'  then return :one_liner
+            when 'end'  then return OneLineConditional
             end
           when :on_ignored_nl, :on_nl
             break
           when :on_semicolon
-            return :semicolon
+            return IfWithSemicolon
           when :on_comment
             break if t.text =~ /\n/
           when :on_sp
@@ -42,7 +34,28 @@ module Rubocop
             then_found = false
           end
         end
-        then_found ? :multiline_if_then : nil
+        then_found ? MultilineIfThen : nil
+      end
+    end
+
+    class IfWithSemicolon < Cop
+      include IfThenElse
+      def error_message
+        'Never use if x; Use the ternary operator instead.'
+      end
+    end
+
+    class MultilineIfThen < Cop
+      include IfThenElse
+      def error_message
+        'Never use then for multi-line if/unless.'
+      end
+    end
+
+    class OneLineConditional < Cop
+      include IfThenElse
+      def error_message
+        'Favor the ternary operator (?:) over if/then/else/end constructs.'
       end
     end
   end

data/lib/rubocop/cop/offence.rb

@@ -14,7 +14,7 @@ module Rubocop
       end
 
       def to_s
-        "#{encode_severity}:#{sprintf("%3d", line_number)}: #{message}"
+        "#{encode_severity}:%3d: #{message}" % [line_number]
       end
 
       def encode_severity

data/lib/rubocop/cop/space_after_comma_etc.rb

@@ -2,24 +2,41 @@
 
 module Rubocop
   module Cop
-    class SpaceAfterCommaEtc < Cop
+    module SpaceAfterCommaEtc
       ERROR_MESSAGE = 'Space missing after %s.'
 
       def inspect(file, source, tokens, sexp)
         tokens.each_index do |ix|
           t = tokens[ix]
-          kind = case t.type
-                 when :on_comma     then 'comma'
-                 when :on_label     then 'colon'
-                 when :on_op        then 'colon' if t.text == ':'
-                 when :on_semicolon then 'semicolon'
-                 end
-          if kind and not [:on_sp,
-                           :on_ignored_nl].include?(tokens[ix + 1].type)
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE % kind)
+          if kind(t) && !whitespace?(tokens[ix + 1])
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE % kind(t))
           end
         end
       end
     end
+
+    class SpaceAfterComma < Cop
+      include SpaceAfterCommaEtc
+      def kind(token)
+        'comma' if token.type == :on_comma
+      end
+    end
+
+    class SpaceAfterSemicolon < Cop
+      include SpaceAfterCommaEtc
+      def kind(token)
+        'semicolon' if token.type == :on_semicolon
+      end
+    end
+
+    class SpaceAfterColon < Cop
+      include SpaceAfterCommaEtc
+      def kind(token)
+        case token.type
+        when :on_label then 'colon'
+        when :on_op    then 'colon' if token.text == ':'
+        end
+      end
+    end
   end
 end

data/lib/rubocop/cop/surrounding_space.rb

@@ -4,62 +4,12 @@ require_relative 'grammar'
 
 module Rubocop
   module Cop
-    class SurroundingSpace < Cop
-      ERROR_MESSAGE = 'Surrounding space missing for '
-
+    module SurroundingSpace
       def inspect(file, source, tokens, sexp)
         @correlations.sort.each do |ix, grammar_path|
-          t = tokens[ix]
-          case t.type
-          when :on_op
-            unless surrounded_by_whitespace?(tokens[ix - 1, 3])
-              unless ok_without_spaces?(grammar_path)
-                add_offence(:convention, t.pos.lineno,
-                            ERROR_MESSAGE + "operator '#{t.text}'.")
-              end
-            end
-          when :on_lbrace
-            unless surrounded_by_whitespace?(tokens[ix - 1, 3])
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE + "'{'.")
-            end
-          when :on_rbrace
-            unless whitespace?(tokens[ix - 1])
-              add_offence(:convention, t.pos.lineno,
-                          "Space missing to the left of '}'.")
-            end
-          end
-        end
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          prev, nxt = tokens.values_at(ix - 1, ix + 1)
-          offence_detected = case t.type
-                             when :on_lbracket, :on_lparen
-                               nxt.type == :on_sp
-                             when :on_rbracket, :on_rparen
-                               if prev.type == :on_sp
-                                 prev_ns = previous_non_space(tokens, ix)
-                                 prev_ns && tokens_on_same_row?(prev_ns,
-                                                                tokens[ix]) &&
-                                   # Avoid double repoting of [ ] and ( )
-                                   prev_ns.type != :on_lbracket &&
-                                   prev_ns.type != :on_lparen
-                               end
-                             when :on_op
-                               t.text == '**' &&
-                                 (whitespace?(prev) || whitespace?(nxt))
-                             end
-          if offence_detected
-            kind = case t.type
-                   when :on_lparen, :on_rparen
-                     'inside parentheses'
-                   when :on_lbracket, :on_rbracket
-                     'inside square brackets'
-                   when :on_op
-                     "around operator #{t.text}"
-                   end
-            add_offence(:convention, t.pos.lineno, "Space #{kind} detected.")
-          end
+          check_missing(tokens, ix, grammar_path)
         end
+        tokens.each_index { |ix| check_extra(tokens, ix) }
       end
 
       private
@@ -88,6 +38,105 @@ module Rubocop
         left, _, right = nearby_tokens
         whitespace?(left) && whitespace?(right)
       end
+
+      # Default implementation for classes that don't need it.
+      def check_missing(tokens, ix, grammar_path)
+      end
+    end
+
+    class SpaceAroundOperators < Cop
+      include SurroundingSpace
+      ERROR_MESSAGE = 'Surrounding space missing for operator '
+
+      def check_missing(tokens, ix, grammar_path)
+        t = tokens[ix]
+        if t.type == :on_op
+          unless surrounded_by_whitespace?(tokens[ix - 1, 3])
+            unless ok_without_spaces?(grammar_path)
+              add_offence(:convention, t.pos.lineno,
+                          ERROR_MESSAGE + "'#{t.text}'.")
+            end
+          end
+        end
+      end
+
+      def check_extra(tokens, ix)
+        prev, t, nxt = tokens.values_at(ix - 1, ix, ix + 1)
+        if t.type == :on_op && t.text == '**' &&
+            (whitespace?(prev) || whitespace?(nxt))
+          add_offence(:convention, t.pos.lineno,
+                      "Space around operator #{t.text} detected.")
+        end
+      end
+    end
+
+    class SpaceAroundBraces < Cop
+      include SurroundingSpace
+
+      def check_extra(tokens, ix)
+      end
+
+      def check_missing(tokens, ix, grammar_path)
+        t = tokens[ix]
+        case t.type
+        when :on_lbrace
+          unless surrounded_by_whitespace?(tokens[ix - 1, 3])
+            add_offence(:convention, t.pos.lineno,
+                        "Surrounding space missing for '{'.")
+          end
+        when :on_rbrace
+          unless whitespace?(tokens[ix - 1])
+            add_offence(:convention, t.pos.lineno,
+                        "Space missing to the left of '}'.")
+          end
+        end
+      end
+    end
+
+    class SpaceInsideParens < Cop
+      include SurroundingSpace
+      def check_extra(tokens, ix)
+        prev, t, nxt = tokens.values_at(ix - 1, ix, ix + 1)
+        offence_detected = case t.type
+                           when :on_lparen
+                             nxt.type == :on_sp
+                           when :on_rparen
+                             if prev.type == :on_sp
+                               prev_ns = previous_non_space(tokens, ix)
+                               prev_ns && tokens_on_same_row?(prev_ns,
+                                                              tokens[ix]) &&
+                                 # Avoid double repoting of ( )
+                                 prev_ns.type != :on_lparen
+                             end
+                           end
+        if offence_detected
+          add_offence(:convention, t.pos.lineno,
+                      'Space inside parentheses detected.')
+        end
+      end
+    end
+
+    class SpaceInsideBrackets < Cop
+      include SurroundingSpace
+      def check_extra(tokens, ix)
+        prev, t, nxt = tokens.values_at(ix - 1, ix, ix + 1)
+        offence_detected = case t.type
+                           when :on_lbracket
+                             nxt.type == :on_sp
+                           when :on_rbracket
+                             if prev.type == :on_sp
+                               prev_ns = previous_non_space(tokens, ix)
+                               prev_ns && tokens_on_same_row?(prev_ns,
+                                                              tokens[ix]) &&
+                                 # Avoid double repoting of [ ] and ( )
+                                 prev_ns.type != :on_lbracket
+                             end
+                           end
+        if offence_detected
+          add_offence(:convention, t.pos.lineno,
+                      'Space inside square brackets detected.')
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/ternary_operator.rb

@@ -2,22 +2,39 @@
 
 module Rubocop
   module Cop
-    class TernaryOperator < Cop
-      ERROR_MESSAGE = 'Avoid multi-line ?: (the ternary operator); use ' +
-        'if/unless instead.'
-
+    module TernaryOperator
       def inspect(file, source, tokens, sexp)
         each(:ifop, sexp) do |ifop|
-          line_numbers = all_positions(ifop).map(&:lineno)
-          if line_numbers.uniq.size > 1
-            add_offence(:convention, line_numbers[0], ERROR_MESSAGE)
+          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
+        'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
+      end
+
+      def offends?(ifop)
+        all_positions(ifop).map(&:lineno).uniq.size > 1
+      end
+    end
+
+    class NestedTernaryOperator < Cop
+      include TernaryOperator
+
+      def error_message
+        'Ternary operators must not be nested. Prefer if/else constructs ' +
+          'instead.'
+      end
 
-      def all_positions(sexp)
-        return [sexp[2]] if sexp[0] =~ /^@/
-        sexp.grep(Array).inject([]) { |memo, s| memo + all_positions(s) }
+      def offends?(ifop)
+        ifop.flatten[1..-1].include?(:ifop)
       end
     end
   end

data/lib/rubocop/cop/unless_else.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class UnlessElse < Cop
+      ERROR_MESSAGE = '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.find { |s| s[0] == :else }
+            add_offence(:convention, all_positions(unless_sexp).first.lineno,
+                        ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/when_then.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class WhenThen < Cop
+      ERROR_MESSAGE = '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]
+          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
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/report/emacs_style.rb

@@ -7,7 +7,8 @@ module Rubocop
       # Generates a string representation of the report
       def generate
         report = entries.map do |e|
-          "#@filename:#{e.line_number}: #{e.encode_severity}: #{e.message}"
+          '%s:%d: %s: %s' % [@filename, e.line_number, e.encode_severity,
+                             e.message]
         end
         report.join("\n")
       end

data/rubocop.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "rubocop"
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bozhidar Batsov"]
-  s.date = "2013-01-12"
+  s.date = "2013-02-11"
   s.description = "Automatic Ruby code style checking tool. Aims to enforce the community-driven Ruby Style Guide."
   s.email = "bozhidar@batsov.com"
   s.executables = ["rubocop"]
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
     ".document",
     ".rbenv-version",
     ".rspec",
+    ".rubocop.yml",
     ".rvmrc",
     ".travis.yml",
     "CONTRIBUTING.md",
@@ -37,6 +38,7 @@ Gem::Specification.new do |s|
     "lib/rubocop.rb",
     "lib/rubocop/cli.rb",
     "lib/rubocop/cop/align_parameters.rb",
+    "lib/rubocop/cop/ampersands_pipes_vs_and_or.rb",
     "lib/rubocop/cop/blocks.rb",
     "lib/rubocop/cop/cop.rb",
     "lib/rubocop/cop/def_parentheses.rb",
@@ -57,6 +59,8 @@ Gem::Specification.new do |s|
     "lib/rubocop/cop/tab.rb",
     "lib/rubocop/cop/ternary_operator.rb",
     "lib/rubocop/cop/trailing_whitespace.rb",
+    "lib/rubocop/cop/unless_else.rb",
+    "lib/rubocop/cop/when_then.rb",
     "lib/rubocop/report/emacs_style.rb",
     "lib/rubocop/report/plain_text.rb",
     "lib/rubocop/report/report.rb",
@@ -64,25 +68,38 @@ Gem::Specification.new do |s|
     "rubocop.gemspec",
     "spec/rubocop/cli_spec.rb",
     "spec/rubocop/cops/align_parameters_spec.rb",
-    "spec/rubocop/cops/blocks_spec.rb",
+    "spec/rubocop/cops/ampersands_pipes_vs_and_or_spec.rb",
     "spec/rubocop/cops/cop_spec.rb",
-    "spec/rubocop/cops/def_parentheses_spec.rb",
+    "spec/rubocop/cops/def_with_parentheses_spec.rb",
+    "spec/rubocop/cops/def_without_parentheses_spec.rb",
     "spec/rubocop/cops/empty_lines_spec.rb",
+    "spec/rubocop/cops/encoding_spec.rb",
     "spec/rubocop/cops/end_of_line_spec.rb",
     "spec/rubocop/cops/grammar_spec.rb",
     "spec/rubocop/cops/hash_syntax_spec.rb",
-    "spec/rubocop/cops/if_then_else_spec.rb",
+    "spec/rubocop/cops/if_with_semicolon_spec.rb",
     "spec/rubocop/cops/indentation_spec.rb",
     "spec/rubocop/cops/line_length_spec.rb",
+    "spec/rubocop/cops/multiline_blocks_spec.rb",
+    "spec/rubocop/cops/multiline_if_then_spec.rb",
     "spec/rubocop/cops/numeric_literals_spec.rb",
     "spec/rubocop/cops/offence_spec.rb",
+    "spec/rubocop/cops/one_line_conditional_spec.rb",
     "spec/rubocop/cops/parameter_lists_spec.rb",
-    "spec/rubocop/cops/space_after_comma_etc_spec.rb",
+    "spec/rubocop/cops/single_line_blocks_spec.rb",
+    "spec/rubocop/cops/space_after_colon_spec.rb",
+    "spec/rubocop/cops/space_after_comma_spec.rb",
+    "spec/rubocop/cops/space_after_semicolon_spec.rb",
+    "spec/rubocop/cops/space_around_braces_spec.rb",
+    "spec/rubocop/cops/space_around_operators_spec.rb",
+    "spec/rubocop/cops/space_inside_brackets_spec.rb",
+    "spec/rubocop/cops/space_inside_parens_spec.rb",
     "spec/rubocop/cops/string_literals_spec.rb",
-    "spec/rubocop/cops/surrounding_space_spec.rb",
     "spec/rubocop/cops/tab_spec.rb",
     "spec/rubocop/cops/ternary_operator_spec.rb",
     "spec/rubocop/cops/trailing_whitespace_spec.rb",
+    "spec/rubocop/cops/unless_else_spec.rb",
+    "spec/rubocop/cops/when_then_spec.rb",
     "spec/rubocop/reports/emacs_style_spec.rb",
     "spec/rubocop/reports/report_spec.rb",
     "spec/spec_helper.rb"