rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the . position in multi-line method calls.
+      class DotPosition < Cop
+        MSG = 'Place the . on the next line, together with the method name.'
+
+        def on_send(node)
+          return unless node.loc.dot
+
+          dot_line = node.loc.dot.line
+          selector_line = node.loc.selector.line
+
+          if dot_line != selector_line
+            add_offence(:convention, node.loc.dot, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether method definitions are
+      # separated by empty lines.
+      class EmptyLineBetweenDefs < Cop
+        MSG = 'Use empty lines between defs.'
+
+        def on_def(node)
+          def_start = node.loc.keyword.line
+          def_end = node.loc.end.line
+
+          if @prev_def_end && (def_start - @prev_def_end) < 2
+            add_offence(:convention, node.loc.keyword, MSG)
+          end
+
+          @prev_def_end = def_end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for two or more consecutive blank lines.
+      class EmptyLines < Cop
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return if tokens.empty?
+
+          prev_line = 1
+
+          tokens.each do |token|
+            cur_line = token.pos.line
+            line_diff = cur_line - prev_line
+
+            if line_diff > LINE_OFFSET
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                # we check if the prev and current lines are empty
+                if source[line - 2].empty? && source[line - 1].empty?
+                  add_offence(:convention,
+                              source_range(source_buffer,
+                                           source[0...(line - 1)], 0, 1),
+                              MSG)
+                end
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash or string.
+      class EmptyLiteral < Cop
+        ARR_MSG = 'Use array literal [] instead of Array.new.'
+        HASH_MSG = 'Use hash literal {} instead of Hash.new.'
+        STR_MSG = "Use string literal '' instead of String.new."
+
+        # Empty array node
+        #
+        # (send
+        #   (const nil :Array) :new)
+        ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
+
+        # Empty hash node
+        #
+        # (send
+        #   (const nil :Hash) :new)
+        HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
+
+        # Empty string node
+        #
+        # (send
+        #   (const nil :String) :new)
+        STR_NODE = s(:send, s(:const, nil, :String), :new)
+
+        def on_send(node)
+          case node
+          when ARRAY_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        ARR_MSG)
+          when HASH_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        HASH_MSG)
+          when STR_NODE
+            add_offence(:convention,
+                        node.loc.expression,
+                        STR_MSG)
+          end
+        end
+
+        # TODO Check block contents as well
+        alias_method :on_block, :ignore_node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks whether the source file has a
+      # utf-8 encoding comment. This check makes sense only
+      # in Ruby 1.9, since in 2.0+ utf-8 is the default source file
+      # encoding.
+      class Encoding < Cop
+        MSG = 'Missing utf-8 encoding comment.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          unless RUBY_VERSION >= '2.0.0'
+            expected_line = 0
+            expected_line += 1 if source[expected_line] =~ /^#!/
+            unless source[expected_line] =~ /#.*coding: (UTF|utf)-8/
+              add_offence(:convention,
+                          source_range(source_buffer,
+                                       source[0...expected_line],
+                                       0, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      class EndBlock < Cop
+        MSG = 'Avoid the use of END blocks. Use `Kernel#at_exit` instead.'
+
+        def on_postexe(node)
+          add_offence(:convention, node.loc.keyword, MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for Windows-style line endings in the source code.
+      class EndOfLine < Cop
+        MSG = 'Carriage return character detected.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            if line =~ /\r$/
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index],
+                                       line.length - 1, 1),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of "*" as a substitute for *join*.
+      #
+      # Not all cases can reliably checked, due to Ruby's dynamic
+      # types, so we consider only cases when the first argument is an
+      # array literal or the second is a string literal.
+      class FavorJoin < Cop
+        MSG = 'Favor Array#join over Array#*.'
+
+        def on_send(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          if receiver_node && receiver_node.type == :array &&
+              method_name == :* && arg_nodes[0].type == :str
+            add_offence(:convention,
+                        node.loc.selector,
+                        MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for modifier cops.
+      module FavorModifier
+        # TODO extremely ugly solution that needs lots of polish
+        def check(sexp, comments)
+          case sexp.loc.keyword.source
+          when 'if'     then cond, body, _else = *sexp
+          when 'unless' then cond, _else, body = *sexp
+          else               cond, body = *sexp
+          end
+
+          if length(sexp) > 3
+            false
+          else
+            body_length = body_length(body)
+
+            if body_length == 0
+              false
+            else
+              indentation = sexp.loc.keyword.column
+              kw_length = sexp.loc.keyword.size
+              cond_length = cond.loc.expression.size
+              space = 1
+              total = indentation + body_length + space + kw_length + space +
+                cond_length
+              total <= LineLength.max && !body_has_comment?(body, comments)
+            end
+          end
+        end
+
+        def length(sexp)
+          sexp.loc.expression.source.lines.to_a.size
+        end
+
+        def body_length(body)
+          if body && body.loc.expression
+            body.loc.expression.size
+          else
+            0
+          end
+        end
+
+        def body_has_comment?(body, comments)
+          comment_lines = comments.map(&:location).map(&:line)
+          body_line = body.loc.expression.line
+          comment_lines.include?(body_line)
+        end
+      end
+
+      # Checks for if and unless statements that would fit on one line
+      # if written as a modifier if/unless.
+      class IfUnlessModifier < Cop
+        include FavorModifier
+
+        def error_message
+          'Favor modifier if/unless usage when you have a single-line body. ' +
+            'Another good alternative is the usage of control flow &&/||.'
+        end
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          on_node(:if, ast) do |node|
+            # discard ternary ops, if/else and modifier if/unless nodes
+            return if ternary_op?(node)
+            return if modifier_if?(node)
+            return if elsif?(node)
+            return if if_else?(node)
+
+            if check(node, comments)
+              add_offence(:convention, node.loc.expression, error_message)
+            end
+          end
+        end
+
+        def ternary_op?(node)
+          node.loc.respond_to?(:question)
+        end
+
+        def modifier_if?(node)
+          node.loc.end.nil?
+        end
+
+        def elsif?(node)
+          node.loc.keyword.is?('elsif')
+        end
+
+        def if_else?(node)
+          node.loc.respond_to?(:else) && node.loc.else
+        end
+      end
+
+      # Checks for while and until statements that would fit on one line
+      # if written as a modifier while/until.
+      class WhileUntilModifier < Cop
+        include FavorModifier
+
+        MSG =
+          'Favor modifier while/until usage when you have a single-line body.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          on_node([:while, :until], ast) do |node|
+            # discard modifier while/until
+            next unless node.loc.end
+
+            if check(node, comments)
+              add_offence(:convention, node.loc.expression, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of String#%.
+      #
+      # It cannot be implemented in a reliable manner for all cases, so
+      # only two scenarios are considered - if the first argument is a string
+      # literal and if the second argument is an array literal.
+      class FavorSprintf < Cop
+        MSG = 'Favor sprintf over String#%.'
+
+        def on_send(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          if method_name == :% &&
+              ([:str, :dstr].include?(receiver_node.type) ||
+               arg_nodes[0].type == :array)
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Some common code shared between the two cops.
+      module FavorOtherKeywordOverNegation
+        def check(node)
+          condition, _body, _rest = *node
+
+          # Look at last expression of contents if there's a parenthesis
+          # around condition.
+          condition = condition.children.last while condition.type == :begin
+
+          if condition.type == :send
+            _object, method = *condition
+            if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
+              add_offence(:convention, node.loc.expression, error_message)
+            end
+          end
+        end
+      end
+
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered.
+      class FavorUnlessOverNegatedIf < Cop
+        include FavorOtherKeywordOverNegation
+
+        def on_if(node)
+          check(node)
+          super
+        end
+
+        def error_message
+          'Favor unless (or control flow or) over if for negative conditions.'
+        end
+      end
+
+      # Checks for uses of while with a negated condition.
+      class FavorUntilOverNegatedWhile < Cop
+        include FavorOtherKeywordOverNegation
+
+        def on_while(node)
+          check(node)
+          super
+        end
+
+        def error_message
+          'Favor until over while for negative conditions.'
+        end
+      end
+    end
+  end
+end