rubocop 0.8.3 → 0.9.0

data/lib/rubocop/cop/not.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Not < Cop
-      MSG = 'Use ! instead of not.'
-
-      def on_send(node)
-        _receiver, method_name, *args = *node
-
-        # not does not take any arguments
-        if args.empty? && method_name == :! &&
-            node.loc.selector.source == 'not'
-          add_offence(:convention, node.loc.line, MSG)
-        end
-
-        super
-      end
-    end
-  end
-end

data/lib/rubocop/cop/numeric_literals.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class NumericLiterals < Cop
-      MSG = 'Add underscores to large numeric literals to ' +
-        'improve their readability.'
-
-      def on_int(node)
-        value, = *node
-
-        if value > 10000 &&
-            node.loc.expression.source.split('.').grep(/\d{6}/).any?
-          add_offence(:convention, node.loc.expression.line, MSG)
-        end
-      end
-
-      alias_method :on_float, :on_int
-    end
-  end
-end

data/lib/rubocop/cop/parameter_lists.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class ParameterLists < Cop
-      MSG = 'Avoid parameter lists longer than %d parameters.'
-
-      def on_args(node)
-        args_count = node.children.size
-
-        if args_count > max_params
-          add_offence(:convention, node.loc.line, sprintf(MSG, max_params))
-        end
-
-        super
-      end
-
-      def max_params
-        ParameterLists.config['Max']
-      end
-    end
-  end
-end

data/lib/rubocop/cop/parentheses_around_condition.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class ParenthesesAroundCondition < Cop
-      MSG = "Don't use parentheses around the condition of an " +
-        'if/unless/while/until'
-
-      def on_if(node)
-        process_control_op(node)
-
-        super
-      end
-
-      def on_while(node)
-        process_control_op(node)
-
-        super
-      end
-
-      def on_until(node)
-        process_control_op(node)
-
-        super
-      end
-
-      private
-
-      def process_control_op(node)
-        cond, _body = *node
-
-        cond_source = cond.loc.expression.source
-
-        if cond_source.start_with?('(') && cond_source.end_with?(')')
-          add_offence(:convetion, cond.loc.line, MSG)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/percent_r.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class PercentR < Cop
-      MSG = 'Use %r only 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/proc.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Proc < Cop
-      MSG = 'Use proc instead of Proc.new.'
-
-      TARGET = s(:send, s(:const, nil, :Proc), :new)
-
-      def on_block(node)
-        # We're looking for
-        # (block
-        #   (send
-        #     (const nil :Proc) :new)
-        #   ...)
-        block_method, = *node
-
-        if block_method == TARGET
-          add_offence(:convention, block_method.loc.line, MSG)
-        end
-
-        super
-      end
-    end
-  end
-end

data/lib/rubocop/cop/reduce_arguments.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class ReduceArguments < Cop
-      MSG = 'Name reduce arguments |a, e| (accumulator, element)'
-
-      ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
-
-      def on_block(node)
-        # we care only for single line blocks
-        return unless Util.block_length(node) == 0
-
-        method_node, args_node, _body_node = *node
-        receiver, method_name, _method_args = *method_node
-
-        # discard other scenarios
-        return unless receiver
-        return unless [:reduce, :inject].include?(method_name)
-
-        unless args_node == ARGS_NODE
-          add_offence(:convention, node.loc.line, MSG)
-        end
-
-        super
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rescue_exception.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class RescueException < Cop
-      MSG = 'Avoid rescuing the Exception class.'
-
-      def on_resbody(node)
-        return unless node.children.first
-        rescue_args = node.children.first.children
-        if rescue_args.any? { |a| targets_exception?(a) }
-          add_offence(:warning, node.location.line, MSG)
-        end
-
-        super
-      end
-
-      def targets_exception?(rescue_arg_node)
-        return false unless rescue_arg_node.type == :const
-        namespace, klass_name = *rescue_arg_node
-        return false unless namespace.nil? || namespace.type == :cbase
-        klass_name == :Exception
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rescue_modifier.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class RescueModifier < Cop
-      MSG = 'Avoid using rescue in its modifier form.'
-
-      def on_rescue(node)
-        add_offence(:convention, node.loc.line, MSG)
-      end
-
-      alias_method :on_begin, :ignore_node
-    end
-  end
-end

data/lib/rubocop/cop/semicolon.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Semicolon < Cop
-      MSG = 'Do not use semicolons to terminate expressions.'
-
-      def inspect(source, tokens, ast, comments)
-        on_node(:begin, ast) do |node|
-          exprs = node.children
-
-          next if exprs.size < 2
-
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.loc.expression.line }
-          lines = exprs_lines.group_by { |i| i }
-
-          # every line with more than 1 expression on it is an offence
-          lines.each do |line, expr_on_line|
-            add_offence(:convention, line, MSG) if expr_on_line.size > 1
-          end
-        end
-
-        # not pretty reliable, but the best we can do for now
-        source.each_with_index do |line, index|
-          add_offence(:convention, index, MSG) if line =~ /;\s*\z/
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/single_line_methods.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class SingleLineMethods < Cop
-      MSG = 'Avoid single-line method definitions.'
-
-      def allow_empty?
-        SingleLineMethods.config['AllowIfMethodIsEmpty']
-      end
-
-      def on_def(node)
-        check(node)
-
-        super
-      end
-
-      def on_defs(node)
-        check(node)
-
-        super
-      end
-
-      private
-
-      def check(node)
-        start_line = node.loc.keyword.line
-        end_line = node.loc.end.line
-
-        if node.type == :def
-          empty_body = node.children[2].type == :nil
-        else
-          empty_body = node.children[3].type == :nil
-        end
-
-        if start_line == end_line && !(allow_empty? && empty_body)
-          add_offence(:convention,
-                      start_line,
-                      MSG)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/space_after_comma_etc.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-# rubocop:disable SymbolName
-
-module Rubocop
-  module Cop
-    module SpaceAfterCommaEtc
-      MSG = 'Space missing after %s.'
-
-      def inspect(source, tokens, ast, comments)
-        tokens.each_cons(2) do |t1, t2|
-          if kind(t1) && t1.pos.line == t2.pos.line &&
-              t2.pos.column == t1.pos.column + offset(t1)
-            add_offence(:convention, t1.pos.line, sprintf(MSG, kind(t1)))
-          end
-        end
-      end
-
-      # The normal offset, i.e., the distance from the punctuation
-      # token where a space should be, is 1.
-      def offset(token)
-        1
-      end
-    end
-
-    class SpaceAfterComma < Cop
-      include SpaceAfterCommaEtc
-
-      def kind(token)
-        'comma' if token.type == :tCOMMA
-      end
-    end
-
-    class SpaceAfterSemicolon < Cop
-      include SpaceAfterCommaEtc
-
-      def kind(token)
-        'semicolon' if token.type == :tSEMI
-      end
-    end
-
-    class SpaceAfterColon < Cop
-      include SpaceAfterCommaEtc
-
-      # The colon following a label will not appear in the token
-      # array. Instad we get a tLABEL token, whose length we use to
-      # calculate where we expect a space.
-      def offset(token)
-        case token.type
-        when :tLABEL then token.text.length + 1
-        when :tCOLON then 1
-        end
-      end
-
-      def kind(token)
-        case token.type
-        when :tLABEL, :tCOLON then 'colon'
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/space_after_control_keyword.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class SpaceAfterControlKeyword < Cop
-      MSG = 'Use space after control keywords.'
-      # elsif and unless are handled by on_if.
-      KEYWORDS = %w(if case when while until)
-
-      def on_keyword(node)
-        return if node.loc.is_a?(Parser::Source::Map::Ternary)
-
-        exp = node.loc.expression
-        kw = node.loc.keyword
-        kw_offset = kw.begin_pos - exp.begin_pos
-        if exp.source[kw_offset..-1].start_with?(kw.source + '(')
-          add_offence(:convention, kw.line, MSG)
-        end
-      end
-
-      KEYWORDS.each do |keyword|
-        define_method(:"on_#{keyword}") do |node|
-          on_keyword(node)
-          super(node)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/string_literals.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class StringLiterals < Cop
-      MSG = "Prefer single-quoted strings when you don't need " +
-        'string interpolation or special symbols.'
-
-      def on_str(node)
-        text, = *node
-
-        # Constants like __FILE__ and __DIR__ are created as strings,
-        # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin)
-
-        if text !~ /['\n\t\r]/ && node.loc.begin.source == '"'
-          add_offence(:convention, node.loc.line, MSG)
-        end
-      end
-
-      alias_method :on_dstr, :ignore_node
-      alias_method :on_regexp, :ignore_node
-    end
-  end
-end

data/lib/rubocop/cop/surrounding_space.rb

@@ -1,285 +0,0 @@
-# encoding: utf-8
-
-# rubocop:disable SymbolName
-
-module Rubocop
-  module Cop
-    module SurroundingSpace
-      def space_between?(t1, t2)
-        char_preceding_2nd_token =
-          @source[t2.pos.line - 1][t2.pos.column - 1]
-        if char_preceding_2nd_token == '+' && t1.type != :tPLUS
-          # Special case. A unary plus is not present in the tokens.
-          char_preceding_2nd_token =
-            @source[t2.pos.line - 1][t2.pos.column - 2]
-        end
-        t2.pos.line > t1.pos.line || char_preceding_2nd_token == ' '
-      end
-
-      def index_of_first_token(node, tokens)
-        @token_table ||= build_token_table(tokens)
-        b = node.loc.expression.begin
-        @token_table[[b.line, b.column]]
-      end
-
-      def index_of_last_token(node, tokens)
-        @token_table ||= build_token_table(tokens)
-        e = node.loc.expression.end
-        (0...e.column).to_a.reverse.find do |c|
-          ix = @token_table[[e.line, c]]
-          return ix if ix
-        end
-      end
-
-      def build_token_table(tokens)
-        table = {}
-        tokens.each_with_index do |t, ix|
-          table[[t.pos.line, t.pos.column]] = ix
-        end
-        table
-      end
-    end
-
-    class SpaceAroundOperators < Cop
-      include SurroundingSpace
-      MSG_MISSING = "Surrounding space missing for operator '%s'."
-      MSG_DETECTED = 'Space around operator ** detected.'
-
-      BINARY_OPERATORS =
-        [:tEQL,    :tAMPER2,  :tPIPE,  :tCARET, :tPLUS,  :tMINUS, :tSTAR2,
-         :tDIVIDE, :tPERCENT, :tEH,    :tCOLON, :tANDOP, :tOROP,  :tMATCH,
-         :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
-         :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
-
-      def inspect(source, tokens, sexp, comments)
-        @source = source
-        positions_not_to_check = get_positions_not_to_check(tokens, sexp)
-
-        tokens.each_cons(3) do |token_before, token, token_after|
-          next if token_before.type == :kDEF # TODO: remove?
-          next if positions_not_to_check.include?(token.pos)
-
-          case token.type
-          when :tPOW
-            if has_space?(token_before, token, token_after)
-              add_offence(:convention, token.pos.line, MSG_DETECTED)
-            end
-          when *BINARY_OPERATORS
-            check_missing_space(token_before, token, token_after)
-          end
-        end
-      end
-
-      # Returns an array of positions marking the tokens that this cop
-      # should not check, either because the token is not an operator
-      # or because another cop does the check.
-      def get_positions_not_to_check(tokens, sexp)
-        positions_not_to_check = []
-        do_not_check_block_arg_pipes(sexp, positions_not_to_check)
-        do_not_check_param_default(tokens, sexp, positions_not_to_check)
-        do_not_check_class_lshift_self(tokens, sexp, positions_not_to_check)
-        do_not_check_def_things(tokens, sexp, positions_not_to_check)
-        do_not_check_singleton_operator_defs(tokens, sexp,
-                                             positions_not_to_check)
-        positions_not_to_check
-      end
-
-      def do_not_check_block_arg_pipes(sexp, positions_not_to_check)
-        # each { |a| }
-        #        ^ ^
-        on_node(:block, sexp) do |b|
-          on_node(:args, b) do |a|
-            positions_not_to_check << a.loc.begin << a.loc.end if a.loc.begin
-          end
-        end
-      end
-
-      def do_not_check_param_default(tokens, sexp, positions_not_to_check)
-        # func(a, b=nil)
-        #          ^
-        on_node(:optarg, sexp) do |optarg|
-          _arg, equals, _value = tokens[index_of_first_token(optarg, tokens),
-                                        3]
-          positions_not_to_check << equals.pos
-        end
-      end
-
-      def do_not_check_class_lshift_self(tokens, sexp, positions_not_to_check)
-        # class <<self
-        #       ^
-        on_node(:sclass, sexp) do |sclass|
-          ix = index_of_first_token(sclass, tokens)
-          if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
-            positions_not_to_check << tokens[ix + 1].pos
-          end
-        end
-      end
-
-      def do_not_check_def_things(tokens, sexp, positions_not_to_check)
-        # def +(other)
-        #     ^
-        on_node(:def, sexp) do |def_node|
-          # def each &block
-          #          ^
-          # def each *args
-          #          ^
-          on_node([:blockarg, :restarg], def_node) do |arg_node|
-            positions_not_to_check << tokens[index_of_first_token(arg_node,
-                                                                  tokens)].pos
-          end
-          positions_not_to_check <<
-            tokens[index_of_first_token(def_node, tokens) + 1].pos
-        end
-      end
-
-      def do_not_check_singleton_operator_defs(tokens, sexp,
-                                               positions_not_to_check)
-        # def self.===(other)
-        #          ^
-        on_node(:defs, sexp) do |defs_node|
-          _receiver, name, _args = *defs_node
-          ix = index_of_first_token(defs_node, tokens)
-          name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
-          positions_not_to_check << name_token.pos
-        end
-      end
-
-      def check_missing_space(token_before, token, token_after)
-        unless has_space?(token_before, token, token_after)
-          text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
-          add_offence(:convention, token.pos.line, MSG_MISSING % text)
-        end
-      end
-
-      def has_space?(token_before, token, token_after)
-        space_between?(token_before, token) && space_between?(token,
-                                                              token_after)
-      end
-    end
-
-    class SpaceAroundBraces < Cop
-      include SurroundingSpace
-      MSG_LEFT = "Surrounding space missing for '{'."
-      MSG_RIGHT = "Space missing to the left of '}'."
-
-      def inspect(source, tokens, sexp, comments)
-        @source = source
-        positions_not_to_check = get_positions_not_to_check(tokens, sexp)
-        tokens.each_cons(2) do |t1, t2|
-          next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
-
-          type1, type2 = t1.type, t2.type
-          # :tLBRACE in hash literals, :tLCURLY otherwise.
-          next if [:tLCURLY, :tLBRACE].include?(type1) && type2 == :tRCURLY
-          check(t1, t2, MSG_LEFT) if type1 == :tLCURLY || type2 == :tLCURLY
-          check(t1, t2, MSG_RIGHT) if type2 == :tRCURLY
-        end
-      end
-
-      def get_positions_not_to_check(tokens, sexp)
-        positions_not_to_check = []
-
-        on_node(:hash, sexp) do |hash|
-          b_ix = index_of_first_token(hash, tokens)
-          e_ix = index_of_last_token(hash, tokens)
-          positions_not_to_check << tokens[b_ix].pos << tokens[e_ix].pos
-        end
-
-        # TODO: Check braces inside string/symbol/regexp/xstr interpolation.
-        on_node([:dstr, :dsym, :regexp, :xstr], sexp) do |s|
-          b_ix = index_of_first_token(s, tokens)
-          e_ix = index_of_last_token(s, tokens)
-          tokens[b_ix..e_ix].each do |t|
-            positions_not_to_check << t.pos if t.type == :tRCURLY
-          end
-        end
-
-        positions_not_to_check
-      end
-
-      def check(t1, t2, msg)
-        unless space_between?(t1, t2)
-          add_offence(:convention, t1.pos.line, msg)
-        end
-      end
-    end
-
-    module SpaceInside
-      include SurroundingSpace
-      MSG = 'Space inside %s detected.'
-
-      def inspect(source, tokens, sexp, comments)
-        @source = source
-        left, right, kind = specifics
-        tokens.each_cons(2) do |t1, t2|
-          if t1.type == left || t2.type == right
-            if t2.pos.line == t1.pos.line && space_between?(t1, t2)
-              add_offence(:convention, t1.pos.line, MSG % kind)
-            end
-          end
-        end
-      end
-    end
-
-    class SpaceInsideParens < Cop
-      include SpaceInside
-
-      def specifics
-        [:tLPAREN2, :tRPAREN, 'parentheses']
-      end
-    end
-
-    class SpaceInsideBrackets < Cop
-      include SpaceInside
-
-      def specifics
-        [:tLBRACK, :tRBRACK, 'square brackets']
-      end
-    end
-
-    class SpaceInsideHashLiteralBraces < Cop
-      include SurroundingSpace
-      MSG = 'Space inside hash literal braces %s.'
-
-      def inspect(source, tokens, sexp, comments)
-        @source = source
-        on_node(:hash, sexp) do |hash|
-          b_ix = index_of_first_token(hash, tokens)
-          e_ix = index_of_last_token(hash, tokens)
-          if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
-            check(tokens[b_ix], tokens[b_ix + 1])
-            check(tokens[e_ix - 1], tokens[e_ix])
-          end
-        end
-      end
-
-      def check(t1, t2)
-        types = [t1, t2].map(&:type)
-        braces = [:tLBRACE, :tRCURLY]
-        return if types == braces || (braces - types).size == 2
-        has_space = space_between?(t1, t2)
-        is_offence, word = if self.class.config['EnforcedStyleIsWithSpaces']
-                             [!has_space, 'missing']
-                           else
-                             [has_space, 'detected']
-                           end
-        add_offence(:convention, t1.pos.line, MSG % word) if is_offence
-      end
-    end
-
-    class SpaceAroundEqualsInParameterDefault < Cop
-      include SurroundingSpace
-      MSG = 'Surrounding space missing in default value assignment.'
-
-      def inspect(source, tokens, sexp, comments)
-        @source = source
-        on_node(:optarg, sexp) do |optarg|
-          arg, equals, value = tokens[index_of_first_token(optarg, tokens), 3]
-          unless space_between?(arg, equals) && space_between?(equals, value)
-            add_offence(:convention, equals.pos.line, MSG)
-          end
-        end
-      end
-    end
-  end
-end