rubocop 0.16.0 → 0.17.0

data/lib/rubocop/cop/check_assignment.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    # Common functionality for checking assignment nodes.
-    module CheckAssignment
-      def on_lvasgn(node)
-        _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_ivasgn(node)
-        _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_gvasgn(node)
-        _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_or_asgn(node)
-        _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_and_asgn(node)
-        _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_casgn(node)
-        _scope, _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_op_asgn(node)
-        _lhs, _op, rhs = *node
-        check_assignment(node, rhs)
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Common code for ordinary arrays with [] that can be written with %
-      # syntax.
-      module ArraySyntax
-        def array_of?(element_type, node)
-          return false unless node.loc.begin && node.loc.begin.is?('[')
-
-          array_elems = node.children
-
-          # no need to check empty arrays
-          return false unless array_elems && array_elems.size > 1
-
-          array_elems.all? { |e| e.type == element_type }
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # This module does auto-correction of nodes that should just be moved to
-      # the left or to the right, amount being determined by the instance
-      # variable @column_delta.
-      module AutocorrectAlignment
-        def check_alignment(items)
-          items.each_cons(2) do |prev, current|
-            if current.loc.line > prev.loc.line && start_of_line?(current.loc)
-              @column_delta = items.first.loc.column - current.loc.column
-              add_offence(current, :expression) if @column_delta != 0
-            end
-          end
-        end
-
-        def start_of_line?(loc)
-          loc.expression.source_line[0...loc.column] =~ /^\s*$/
-        end
-
-        def autocorrect(node)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get
-          # the last value of @column_delta. A local variable fixes the
-          # problem.
-          column_delta = @column_delta
-
-          @corrections << lambda do |corrector|
-            expr = node.loc.expression
-            each_line(expr) do |line_begin_pos, line|
-              range = calculate_range(expr, line_begin_pos, column_delta)
-              if column_delta > 0
-                corrector.insert_before(range, ' ' * column_delta)
-              else
-                remove(range, corrector)
-              end
-            end
-          end
-        end
-
-        def calculate_range(expr, line_begin_pos, column_delta)
-          starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
-          pos_to_remove = if column_delta > 0 || starts_with_space
-                            line_begin_pos
-                          else
-                            line_begin_pos - column_delta.abs
-                          end
-          Parser::Source::Range.new(expr.source_buffer, pos_to_remove,
-                                    pos_to_remove + column_delta.abs)
-        end
-
-        def remove(range, corrector)
-          original_stderr = $stderr
-          $stderr = StringIO.new # Avoid error messages on console
-          corrector.remove(range)
-        rescue RuntimeError
-          range = Parser::Source::Range.new(range.source_buffer,
-                                            range.begin_pos + 1,
-                                            range.end_pos + 1)
-          retry if range.source =~ /^ +$/
-        ensure
-          $stderr = original_stderr
-        end
-
-        def each_line(expr)
-          offset = 0
-          expr.source.each_line do |line|
-            line_begin_pos = expr.begin_pos + offset
-            yield line_begin_pos, line
-            offset += line.length
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Common functionality for checking length of code segments.
-      module CodeLength
-        include ConfigurableMax
-
-        def max_length
-          cop_config['Max']
-        end
-
-        def count_comments?
-          cop_config['CountComments']
-        end
-
-        def check(node, *_)
-          length = code_length(node)
-          if length > max_length
-            add_offence(node, :keyword, sprintf(message, length,
-                                                max_length)) do
-              self.max = length
-            end
-          end
-        end
-
-        # Returns true for lines that shall not be included in the count.
-        def irrelevant_line(source_line)
-          source_line.blank? || !count_comments? && comment_line?(source_line)
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Handles `EnforcedStyle` configuration parameters.
-      module ConfigurableEnforcedStyle
-        def opposite_style_detected
-          self.config_to_allow_offences ||=
-            { 'EnforcedStyle' => alternative_style.to_s }
-          both_styles_detected if config_to_allow_offences['Enabled']
-        end
-
-        def correct_style_detected
-          # Enabled:true indicates, later when the opposite style is detected,
-          # that the correct style is used somewhere.
-          self.config_to_allow_offences ||= { 'Enabled' => true }
-          both_styles_detected if config_to_allow_offences['EnforcedStyle']
-        end
-
-        def both_styles_detected
-          # Both correct and opposite styles exist.
-          self.config_to_allow_offences = { 'Enabled' => false }
-        end
-
-        def unrecognized_style_detected
-          # All we can do is to disable.
-          self.config_to_allow_offences = { 'Enabled' => false }
-        end
-
-        def style
-          s = cop_config['EnforcedStyle']
-          if cop_config['SupportedStyles'].include?(s)
-            s.to_sym
-          else
-            fail "Unknown style #{s} selected!"
-          end
-        end
-
-        def alternative_style
-          a = cop_config['SupportedStyles'].map(&:to_sym)
-          if a.size != 2
-            fail 'alternative_style can only be used when there are exactly ' +
-              '2 SupportedStyles'
-          end
-          style == a.first ? a.last : a.first
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Handles `Max` configuration parameters, especially setting them to an
-      # appropriate value with --auto-gen-config.
-      module ConfigurableMax
-        def max=(value)
-          cfg = self.config_to_allow_offences ||= {}
-          value = [cfg['Max'], value].max if cfg['Max']
-          cfg['Max'] = value
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # This module provides functionality for checking if names match the
-      # configured EnforcedStyle.
-      module ConfigurableNaming
-        include ConfigurableEnforcedStyle
-
-        SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
-        CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
-
-        def check(node, range)
-          return unless range
-
-          name = range.source.to_sym
-          unless matches_config?(name) || Cop::OPERATOR_METHODS.include?(name)
-            add_offence(node, range, message(style))
-          end
-        end
-
-        def matches_config?(name)
-          name =~ (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-        end
-
-        # Returns a range containing the method name after the given regexp and
-        # a dot.
-        def after_dot(node, method_name_length, regexp)
-          expr = node.loc.expression
-          match = /\A#{regexp}\s*\.\s*/.match(expr.source)
-          return unless match
-          offset = match[0].length
-          begin_pos = expr.begin_pos + offset
-          Parser::Source::Range.new(expr.source_buffer, begin_pos,
-                                    begin_pos + method_name_length)
-        end
-      end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Common functionality for modifier cops.
-      module FavorModifier
-        include IfNode
-
-        # 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
-
-          return false if length(sexp) > 3
-
-          body_length = body_length(body)
-
-          return false if body_length == 0
-
-          on_node(:lvasgn, cond) do
-            return false
-          end
-
-          indentation = sexp.loc.keyword.column
-          kw_length = sexp.loc.keyword.size
-          cond_length = conditional_length(cond)
-          space = 1
-          total = indentation + body_length + space + kw_length + space +
-            cond_length
-          total <= max_line_length && !body_has_comment?(body, comments)
-        end
-
-        def max_line_length
-          config.for_cop('LineLength')['Max']
-        end
-
-        def length(sexp)
-          sexp.loc.expression.source.lines.to_a.size
-        end
-
-        def conditional_length(conditional_node)
-          node = if conditional_node.type == :match_current_line
-                   conditional_node.children.first
-                 else
-                   conditional_node
-                 end
-
-          node.loc.expression.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 investigate(processed_source)
-          return unless processed_source.ast
-          on_node(:if, processed_source.ast) do |node|
-            # discard ternary ops, if/else and modifier if/unless nodes
-            next if ternary_op?(node)
-            next if modifier_if?(node)
-            next if elsif?(node)
-            next if if_else?(node)
-
-            if check(node, processed_source.comments)
-              add_offence(node, :keyword, error_message)
-            end
-          end
-        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 investigate(processed_source)
-          return unless processed_source.ast
-          on_node([:while, :until], processed_source.ast) do |node|
-            # discard modifier while/until
-            next unless node.loc.end
-
-            if check(node, processed_source.comments)
-              add_offence(node, :keyword)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# 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)
-        end
-
-        def on_unless(node)
-          check(node)
-        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(node, :expression, error_message)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    module Style
-      # Common functionality for cops checking for missing space after
-      # punctuation.
-      module SpaceAfterCommaEtc
-        MSG = 'Space missing after %s.'
-
-        def investigate(processed_source)
-          processed_source.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(t1, t1.pos, 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
-
-        def autocorrect(token)
-          @corrections << lambda do |corrector|
-            corrector.insert_after(token.pos, ' ')
-          end
-        end
-      end
-
-      # Checks for comma (,) not follwed by some kind of space.
-      class SpaceAfterComma < Cop
-        include SpaceAfterCommaEtc
-
-        def kind(token)
-          'comma' if token.type == :tCOMMA
-        end
-      end
-
-      # Checks for semicolon (;) not follwed by some kind of space.
-      class SpaceAfterSemicolon < Cop
-        include SpaceAfterCommaEtc
-
-        def kind(token)
-          'semicolon' if token.type == :tSEMI
-        end
-      end
-
-      # Checks for colon (:) not follwed by some kind of space.
-      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
-end