rubocop 0.8.3 → 0.9.0

data/lib/rubocop/cop/favor_percent_r.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class FavorPercentR < Cop
-      MSG = 'Use %r for regular expressions matching more ' +
-        "than one '/' character."
-
-      def on_regexp(node)
-        if node.loc.begin.source == '/' &&
-            node.loc.expression.source[1...-1].scan(/\//).size > 1
-          add_offence(:convention, node.loc.line, MSG)
-        end
-
-        super
-      end
-    end
-  end
-end

data/lib/rubocop/cop/favor_sprintf.rb

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

data/lib/rubocop/cop/favor_unless_over_negated_if.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module FavorOtherKeywordOverNegation
-      def check(node)
-        condition, _body, _rest = *node
-
-        # Look at last expression of contents if there's a parenthesis
-        # around condition.
-        *_, condition = *condition 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.line,
-                        error_message)
-          end
-        end
-      end
-    end
-
-    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
-
-    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

data/lib/rubocop/cop/handle_exceptions.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class HandleExceptions < Cop
-      MSG = 'Do not suppress exceptions.'
-
-      def on_resbody(node)
-        _exc_list_node, _exc_var_node, body_node = *node
-
-        add_offence(:warning, node.loc.line, MSG) if body_node.type == :nil
-
-        super
-      end
-    end
-  end
-end

data/lib/rubocop/cop/hash_syntax.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    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.source == '=>'
-              add_offence(:convention,
-                          pair.loc.line,
-                          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

data/lib/rubocop/cop/if_then_else.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    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/
-          line = offending_line(node)
-          add_offence(:convention, line, error_message) if line
-        end
-      end
-    end
-
-    class IfWithSemicolon < Cop
-      include IfThenElse
-
-      def offending_line(node)
-        if node.loc.begin && node.loc.begin.source == ';'
-          node.loc.begin.line
-        end
-      end
-
-      def error_message
-        'Never use if x; Use the ternary operator instead.'
-      end
-    end
-
-    class MultilineIfThen < Cop
-      include IfThenElse
-
-      def offending_line(node)
-        condition, body = *node
-        next_thing = if body && body.loc.expression
-                       body.loc.expression.begin
-                     else
-                       node.loc.end # No body, use "end".
-                     end
-        right_after_cond =
-          Parser::Source::Range.new(next_thing.source_buffer,
-                                    condition.loc.expression.end.end_pos,
-                                    next_thing.begin_pos)
-        if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
-          node.loc.expression.begin.line
-        end
-      end
-
-      def error_message
-        'Never use then for multi-line if/unless.'
-      end
-    end
-
-    class OneLineConditional < Cop
-      include IfThenElse
-
-      def offending_line(node)
-        node.loc.expression.line unless node.loc.expression.source =~ /\n/
-      end
-
-      def error_message
-        'Favor the ternary operator (?:) over if/then/else/end constructs.'
-      end
-    end
-  end
-end

data/lib/rubocop/cop/lambda.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    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.line, SINGLE_MSG)
-          elsif selector == '->' && lambda_length > 0
-            add_offence(:convention, block_method.loc.line, 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

data/lib/rubocop/cop/leading_comment_space.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class LeadingCommentSpace < Cop
-      MSG = 'Missing space after #.'
-
-      def inspect(source, tokens, ast, comments)
-        comments.each do |comment|
-          if comment.text =~ /^#+[^#\s]/
-            unless comment.text.start_with?('#!') && comment.loc.line == 1
-              add_offence(:convention, comment.loc.line, MSG)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/line_continuation.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class LineContinuation < Cop
-      MSG = 'Avoid the use of the line continuation character(\).'
-
-      def inspect(source, tokens, ast, comments)
-        source.each_with_index do |line, index|
-          add_offence(:convention, index + 1, MSG) if line =~ /.*\\\z/
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/line_length.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class LineLength < Cop
-      MSG = 'Line is too long. [%d/%d]'
-
-      def inspect(source, tokens, ast, comments)
-        source.each_with_index do |line, index|
-          max = LineLength.max
-          if line.length > max
-            message = sprintf(MSG, line.length, max)
-            add_offence(:convention, index + 1, message)
-          end
-        end
-      end
-
-      def self.max
-        LineLength.config['Max']
-      end
-    end
-  end
-end

data/lib/rubocop/cop/loop.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Loop < Cop
-      MSG = 'Use Kernel#loop with break rather than begin/end/until(or while).'
-
-      def on_while(node)
-        check(node)
-
-        super
-      end
-
-      def on_until(node)
-        check(node)
-
-        super
-      end
-
-      private
-
-      def check(node)
-        _cond, body = *node
-        type = node.type.to_s
-
-        if body.type == :begin &&
-            !node.loc.expression.source.start_with?(type)
-          add_offence(:warning, node.loc.keyword.line, MSG)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/method_and_variable_snake_case.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class MethodAndVariableSnakeCase < Cop
-      MSG = 'Use snake_case for methods and variables.'
-      SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
-
-      # http://phrogz.net/programmingruby/language.html#table_18.4
-      OPERATOR_METHODS = %w(
-        | ^ & <=> == === =~ > >= < <= << >>
-        + - * / % ** ~ +@ -@ [] []= ` ! != !~
-      ).map(&:to_sym)
-
-      def inspect(source, tokens, node, comments)
-        on_node([:def, :defs, :lvasgn, :ivasgn, :send], node) do |n|
-          name = case n.type
-                 when :def
-                   name_of_instance_method(n)
-                 when :defs
-                   name_of_singleton_method(n)
-                 when :lvasgn, :ivasgn
-                   name_of_variable(n)
-                 when :send
-                   name_of_setter(n)
-                 end
-
-          next unless name
-          next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
-
-          add_offence(:convention, n.location.line, MSG)
-        end
-      end
-
-      def name_of_instance_method(def_node)
-        def_node.children.first
-      end
-
-      def name_of_singleton_method(defs_node)
-        defs_node.children[1]
-      end
-
-      def name_of_variable(vasgn_node)
-        vasgn_node.children.first
-      end
-
-      def name_of_setter(send_node)
-        receiver, method_name = *send_node
-        return nil unless receiver && receiver.type == :self
-        return nil unless method_name.to_s.end_with?('=')
-        method_name
-      end
-    end
-  end
-end

data/lib/rubocop/cop/method_length.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class MethodLength < Cop
-      MSG = 'Method has too many lines. [%d/%d]'
-
-      def on_def(node)
-        check(node)
-
-        super
-      end
-
-      def on_defs(node)
-        check(node)
-
-        super
-      end
-
-      def max_length
-        MethodLength.config['Max']
-      end
-
-      def count_comments?
-        MethodLength.config['CountComments']
-      end
-
-      private
-
-      def check(node)
-        method_length = calculate_length(node.loc.expression.source)
-
-        if method_length > max_length
-          message = sprintf(MSG, method_length, max_length)
-          add_offence(:convention, node.loc.keyword.line, message)
-        end
-      end
-
-      def calculate_length(source)
-        lines = source.lines.to_a[1...-1]
-
-        return 0 unless lines
-
-        lines.map!(&:strip).reject!(&:empty?)
-
-        lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
-
-        lines.size
-      end
-    end
-  end
-end