sabat-rubocop 0.9.0

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

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the Ruby 1.8 hash literal syntax,
+      # when the 1.9 syntax is applicable as well.
+      #
+      # A separate offence is registered for each problematic pair.
+      class HashSyntax < Cop
+        MSG = 'Ruby 1.8 hash syntax detected'
+
+        def on_hash(node)
+          pairs = *node
+
+          sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
+
+          if sym_indices
+            pairs.each do |pair|
+              if pair.loc.operator && pair.loc.operator.is?('=>')
+                add_offence(:convention,
+                            pair.loc.expression.begin.join(pair.loc.operator),
+                            MSG)
+              end
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def word_symbol_pair?(pair)
+          key, _value = *pair
+
+          if key.type == :sym
+            sym_name = key.to_a[0]
+
+            sym_name =~ /\A\w+\z/
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for cops checking if and unless statements.
+      module IfThenElse
+        def on_if(node)
+          check(node)
+          super
+        end
+
+        def on_unless(node)
+          check(node)
+          super
+        end
+
+        def check(node)
+          # We won't check modifier or ternary conditionals.
+          if node.loc.expression.source =~ /\A(if|unless)\b/
+            if offending_line(node)
+              add_offence(:convention, node.loc.expression, error_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
+        end
+
+        def error_message
+          'Never use if x; Use the ternary operator instead.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of the pre 1.9 lambda syntax for one-line
+      # anonymous functions and uses of the 1.9 lambda syntax for multi-line
+      # anonymous functions.
+      class Lambda < Cop
+        SINGLE_MSG = 'Use the new lambda literal syntax ->(params) {...}.'
+        MULTI_MSG = 'Use the lambda method for multi-line lambdas.'
+
+        TARGET = s(:send, nil, :lambda)
+
+        def on_block(node)
+          # We're looking for
+          # (block
+          #   (send nil :lambda)
+          #   ...)
+          block_method, = *node
+
+          if block_method == TARGET
+            selector = block_method.loc.selector.source
+            lambda_length = lambda_length(node)
+
+            if selector != '->' && lambda_length == 0
+              add_offence(:convention, block_method.loc.expression, SINGLE_MSG)
+            elsif selector == '->' && lambda_length > 0
+              add_offence(:convention, block_method.loc.expression, MULTI_MSG)
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def lambda_length(block_node)
+          start_line = block_node.loc.begin.line
+          end_line = block_node.loc.end.line
+
+          end_line - start_line
+        end
+      end
+    end
+  end
+end