rubocop 0.42.0 → 0.52.1

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

@@ -1,166 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that block braces have or don't have surrounding space inside
-      # them on configuration. For blocks taking parameters, it checks that the
-      # left brace has or doesn't have trailing space depending on
-      # configuration.
-      class SpaceInsideBlockBraces < Cop
-        include ConfigurableEnforcedStyle
-        include SurroundingSpace
-
-        def on_block(node)
-          return if node.loc.begin.is?('do') # No braces.
-
-          # If braces are on separate lines, and the BlockDelimiters cop is
-          # enabled, those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             block_length(node) > 0
-            return
-          end
-
-          left_brace = node.loc.begin
-          right_brace = node.loc.end
-
-          check_inside(node, left_brace, right_brace)
-        end
-
-        private
-
-        def check_inside(node, left_brace, right_brace)
-          sb = node.source_range.source_buffer
-
-          if left_brace.end_pos == right_brace.begin_pos
-            adjacent_braces(sb, left_brace, right_brace)
-          else
-            range = Parser::Source::Range.new(sb, left_brace.end_pos,
-                                              right_brace.begin_pos)
-            inner = range.source
-
-            if inner =~ /\S/
-              braces_with_contents_inside(node, inner, sb)
-            elsif style_for_empty_braces == :no_space
-              offense(sb, range.begin_pos, range.end_pos,
-                      'Space inside empty braces detected.')
-            end
-          end
-        end
-
-        def adjacent_braces(sb, left_brace, right_brace)
-          return if style_for_empty_braces != :space
-
-          offense(sb, left_brace.begin_pos, right_brace.end_pos,
-                  'Space missing inside empty braces.')
-        end
-
-        def braces_with_contents_inside(node, inner, sb)
-          _method, args, _body = *node
-          left_brace = node.loc.begin
-          right_brace = node.loc.end
-          args_delimiter = args.loc.begin # Can be ( | or nil.
-
-          if inner =~ /^\S/
-            no_space_inside_left_brace(left_brace, args_delimiter, sb)
-          else
-            space_inside_left_brace(left_brace, args_delimiter, sb)
-          end
-
-          if inner =~ /\S$/ && block_length(node).zero?
-            no_space(sb, right_brace.begin_pos, right_brace.end_pos,
-                     'Space missing inside }.')
-          else
-            space_inside_right_brace(right_brace, sb)
-          end
-        end
-
-        def no_space_inside_left_brace(left_brace, args_delimiter, sb)
-          if pipe?(args_delimiter)
-            if left_brace.end_pos == args_delimiter.begin_pos &&
-               cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.') do
-                opposite_style_detected
-              end
-            end
-          else
-            # We indicate the position after the left brace. Otherwise it's
-            # difficult to distinguish between space missing to the left and to
-            # the right of the brace in autocorrect.
-            no_space(sb, left_brace.end_pos, left_brace.end_pos + 1,
-                     'Space missing inside {.')
-          end
-        end
-
-        def space_inside_left_brace(left_brace, args_delimiter, sb)
-          if pipe?(args_delimiter)
-            unless cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.') do
-                opposite_style_detected
-              end
-            end
-          else
-            brace_with_space = range_with_surrounding_space(left_brace, :right)
-            space(sb, brace_with_space.begin_pos + 1, brace_with_space.end_pos,
-                  'Space inside { detected.')
-          end
-        end
-
-        def pipe?(args_delimiter)
-          args_delimiter && args_delimiter.is?('|')
-        end
-
-        def space_inside_right_brace(right_brace, sb)
-          brace_with_space = range_with_surrounding_space(right_brace, :left)
-          space(sb, brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                'Space inside } detected.')
-        end
-
-        def no_space(sb, begin_pos, end_pos, msg)
-          if style == :space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
-          else
-            correct_style_detected
-          end
-        end
-
-        def space(sb, begin_pos, end_pos, msg)
-          if style == :no_space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
-          else
-            correct_style_detected
-          end
-        end
-
-        def offense(sb, begin_pos, end_pos, msg)
-          range = Parser::Source::Range.new(sb, begin_pos, end_pos)
-          add_offense(range, range, msg) { yield if block_given? }
-        end
-
-        def style_for_empty_braces
-          case cop_config['EnforcedStyleForEmptyBraces']
-          when 'space'    then :space
-          when 'no_space' then :no_space
-          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{}' then corrector.replace(range, '{ }')
-            when '{|' then corrector.replace(range, '{ |')
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [
-            [:tLBRACK, :tLBRACK2],
-            :tRBRACK,
-            'square brackets'
-          ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for spaces inside ordinary round parentheses.
-      class SpaceInsideParens < Cop
-        include SpaceInside
-
-        def specifics
-          [[:tLPAREN, :tLPAREN2], :tRPAREN, 'parentheses']
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for whitespace within string interpolations.
-      #
-      # @example
-      #   # Good if EnforcedStyle is no_space, bad if space.
-      #      var = "This is the #{no_space} example"
-      #
-      #   # Good if EnforceStyle is space, bad if no_space.
-      #      var = "This is the #{ space } example"
-      class SpaceInsideStringInterpolation < Cop
-        include ConfigurableEnforcedStyle
-
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'.freeze
-        SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
-
-        def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-
-            interp = final_node.source_range
-            interp_with_surrounding_space = range_with_surrounding_space(interp)
-            if style == :no_space
-              if interp_with_surrounding_space != interp
-                add_offense(final_node, :expression, NO_SPACE_MSG)
-              end
-            elsif style == :space
-              if interp_with_surrounding_space.source != " #{interp.source} "
-                add_offense(final_node, :expression, SPACE_MSG)
-              end
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(range_with_surrounding_space(node.source_range),
-                              new_source)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
-      class VariableName < Cop
-        include ConfigurableNaming
-
-        def on_lvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_ivasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_cvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_arg(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        private
-
-        def message(style)
-          format('Use %s for variable names.', style)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -1,197 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This module provides a way to locate the conditional branch the node is
-      # in. This is intended to be used as mix-in.
-      module Locatable
-        BRANCH_TYPES = [:if, :case].freeze
-        CONDITION_INDEX_OF_BRANCH_NODE = 0
-
-        LOGICAL_OPERATOR_TYPES = [:and, :or].freeze
-        LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE = 0
-
-        ENSURE_TYPE = :ensure
-        ENSURE_INDEX_OF_ENSURE_NODE = 1
-
-        FOR_LOOP_TYPE = :for
-        FOR_LOOP_CHILD_INDEX = 2
-
-        NON_FOR_LOOP_TYPES = LOOP_TYPES - [FOR_LOOP_TYPE]
-        NON_FOR_LOOP_TYPES_CHILD_INDEX = 1
-
-        def node
-          raise '#node must be declared!'
-        end
-
-        def scope
-          raise '#scope must be declared!'
-        end
-
-        def inside_of_branch?
-          branch_point_node
-        end
-
-        def run_exclusively_with?(other)
-          return false unless branch_point_node.equal?(other.branch_point_node)
-          return false if branch_body_node.equal?(other.branch_body_node)
-
-          # Main body of rescue is always run:
-          #
-          #   begin
-          #     # main
-          #   rescue
-          #     # resbody
-          #   end
-          if branch_point_node.type == :rescue &&
-             (branch_body_name == 'main' || other.branch_body_name == 'main')
-            return false
-          end
-
-          true
-        end
-
-        def branch_id
-          return nil unless inside_of_branch?
-          @branch_id ||= [branch_point_node.object_id, branch_type].join('_')
-        end
-
-        def branch_type
-          return nil unless inside_of_branch?
-          @branch_type ||= [branch_point_node.type, branch_body_name].join('_')
-        end
-
-        # Inner if, case, rescue, or ensure node.
-        def branch_point_node
-          if instance_variable_defined?(:@branch_point_node)
-            return @branch_point_node
-          end
-
-          set_branch_point_and_body_nodes!
-          @branch_point_node
-        end
-
-        # A child node of #branch_point_node this assignment belongs.
-        def branch_body_node
-          if instance_variable_defined?(:@branch_body_node)
-            return @branch_body_node
-          end
-
-          set_branch_point_and_body_nodes!
-          @branch_body_node
-        end
-
-        def branch_body_name
-          case branch_point_node.type
-          when :if                     then if_body_name
-          when :case                   then case_body_name
-          when RESCUE_TYPE             then rescue_body_name
-          when ENSURE_TYPE             then ensure_body_name
-          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
-          when *LOOP_TYPES             then loop_body_name
-          else raise InvalidBranchBodyError
-          end
-        rescue InvalidBranchBodyError
-          raise InvalidBranchBodyError,
-                "Invalid body index #{body_index} of #{branch_point_node.type}"
-        end
-
-        private
-
-        def if_body_name
-          case body_index
-          when 1 then 'true'
-          when 2 then 'false'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def case_body_name
-          if branch_body_node.type == :when
-            "when#{body_index - 1}"
-          else
-            'else'
-          end
-        end
-
-        def logical_operator_body_name
-          case body_index
-          when 1 then 'right'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def rescue_body_name
-          if body_index.zero?
-            'main'
-          elsif branch_body_node.type == :resbody
-            "rescue#{body_index - 1}"
-          else
-            'else'
-          end
-        end
-
-        def ensure_body_name
-          case body_index
-          when 0 then 'main'
-          else raise InvalidBranchBodyError
-          end
-        end
-
-        def loop_body_name
-          loop_indices = [FOR_LOOP_CHILD_INDEX, NON_FOR_LOOP_TYPES_CHILD_INDEX]
-
-          raise InvalidBranchBodyError unless loop_indices.include?(body_index)
-
-          'main'
-        end
-
-        def body_index
-          branch_point_node.children.index { |n| n.equal?(branch_body_node) }
-        end
-
-        def set_branch_point_and_body_nodes!
-          self_and_ancestor_nodes = [node] + ancestor_nodes_in_scope
-
-          self_and_ancestor_nodes.each_cons(2) do |child, parent|
-            next unless branch?(parent, child)
-            @branch_point_node = parent
-            @branch_body_node = child
-            break
-          end
-        end
-
-        def ancestor_nodes_in_scope
-          node.each_ancestor.take_while do |ancestor_node|
-            !ancestor_node.equal?(scope.node)
-          end
-        end
-
-        def branch?(parent_node, child_node)
-          child_index = parent_node.children.index(child_node)
-
-          case parent_node.type
-          when RESCUE_TYPE
-            true
-          when ENSURE_TYPE
-            child_index != ENSURE_INDEX_OF_ENSURE_NODE
-          when FOR_LOOP_TYPE
-            child_index == FOR_LOOP_CHILD_INDEX
-          when *BRANCH_TYPES
-            child_index != CONDITION_INDEX_OF_BRANCH_NODE
-          when *LOGICAL_OPERATOR_TYPES
-            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
-          when *NON_FOR_LOOP_TYPES
-            child_index == NON_FOR_LOOP_TYPES_CHILD_INDEX
-          else
-            false
-          end
-        end
-
-        class InvalidBranchBodyError < StandardError; end
-      end
-    end
-  end
-end