rubbycop 0.49.0

data/lib/rubbycop/cop/layout/space_before_comma.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for comma (,) preceded by space.
+      class SpaceBeforeComma < Cop
+        include SpaceBeforePunctuation
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_before_comment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for missing space between a token and a comment on the
+      # same line.
+      class SpaceBeforeComment < Cop
+        MSG = 'Put a space before an end-of-line comment.'.freeze
+
+        def investigate(processed_source)
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            next unless t2.type == :tCOMMENT
+            next unless t1.pos.line == t2.pos.line
+            add_offense(t2.pos, t2.pos) if t1.pos.end == t2.pos.begin
+          end
+        end
+
+        private
+
+        def autocorrect(range)
+          ->(corrector) { corrector.insert_before(range, ' ') }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_before_first_arg.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks that exactly one space is used between a method name and the
+      # first argument for method calls without parentheses.
+      #
+      # Alternatively, extra spaces can be added to align the argument with
+      # something on a preceding or following line, if the AllowForAlignment
+      # config parameter is true.
+      #
+      # @example
+      #   @bad
+      #   something  x
+      #   something   y, z
+      #   something'hello'
+      #
+      #   @good
+      #   something x
+      #   something y, z
+      #   something 'hello'
+      #
+      class SpaceBeforeFirstArg < Cop
+        include PrecedingFollowingAlignment
+
+        MSG = 'Put one space between the method name and ' \
+              'the first argument.'.freeze
+
+        def on_send(node)
+          return unless regular_method_call_with_arguments?(node)
+          return unless expect_params_after_method_name?(node)
+
+          first_arg = node.first_argument.source_range
+          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
+          space = range_between(first_arg_with_space.begin_pos,
+                                first_arg.begin_pos)
+
+          add_offense(space, space) if space.length != 1
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.replace(range, ' ') }
+        end
+
+        private
+
+        def regular_method_call_with_arguments?(node)
+          node.arguments? && !node.operator_method? && !node.setter_method?
+        end
+
+        def expect_params_after_method_name?(node)
+          return false if node.parenthesized?
+
+          first_arg = node.first_argument
+
+          same_line?(first_arg, node) &&
+            !(allow_for_alignment? &&
+              aligned_with_something?(first_arg.source_range))
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_before_semicolon.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for semicolon (;) preceded by space.
+      class SpaceBeforeSemicolon < Cop
+        include SpaceBeforePunctuation
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_in_lambda_literal.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks for spaces between -> and opening parameter
+      # brace in lambda literals.
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_no_space (default)
+      #
+      #     @bad
+      #     a = -> (x, y) { x + y }
+      #
+      #     @good
+      #     a = ->(x, y) { x + y }
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_space
+      #
+      #     @bad
+      #     a = ->(x, y) { x + y }
+      #
+      #     @good
+      #     a = -> (x, y) { x + y }
+      class SpaceInLambdaLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        ARROW = '->'.freeze
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and opening brace ' \
+                            'in lambda literals'.freeze
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and opening ' \
+                               'brace in lambda literals'.freeze
+
+        def on_send(node)
+          return unless arrow_lambda_with_args?(node)
+          if style == :require_space && !space_after_arrow?(node)
+            add_offense(node, node.parent.loc.expression, MSG_REQUIRE_SPACE)
+          elsif style == :require_no_space && space_after_arrow?(node)
+            add_offense(node, node.parent.loc.expression, MSG_REQUIRE_NO_SPACE)
+          end
+        end
+
+        def autocorrect(lambda_node)
+          children = lambda_node.parent.children
+          lambda do |corrector|
+            if style == :require_space
+              corrector.insert_before(children[1].source_range, ' ')
+            else
+              space_range = range_between(children[0].source_range.end_pos,
+                                          children[1].source_range.begin_pos)
+              corrector.remove(space_range)
+            end
+          end
+        end
+
+        private
+
+        def arrow_lambda_with_args?(node)
+          lambda_node?(node) && arrow_form?(node) && args?(node)
+        end
+
+        def lambda_node?(node)
+          receiver, call = *node
+          receiver.nil? && call == :lambda
+        end
+
+        def arrow_form?(lambda_node)
+          lambda_node.loc.selector.source == ARROW
+        end
+
+        def args?(lambda_node)
+          _call, args, _body = *lambda_node.parent
+          !args.children.empty?
+        end
+
+        def space_after_arrow?(lambda_node)
+          arrow = lambda_node.parent.children[0]
+          parentheses = lambda_node.parent.children[1]
+          parentheses.source_range.begin_pos - arrow.source_range.end_pos > 0
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_inside_array_percent_literal.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for unnecessary additional spaces inside array percent literals
+      # (i.e. %i/%w).
+      #
+      # @example
+      #   @good
+      #   %i(foo bar baz)
+      #
+      #   @bad
+      #   %w(foo  bar  baz)
+      class SpaceInsideArrayPercentLiteral < Cop
+        include MatchRange
+        include PercentLiteral
+
+        MSG = 'Use only a single space inside array percent literal.'.freeze
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
+          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/
+
+        def on_array(node)
+          process(node, '%i', '%I', '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          each_unnecessary_space_match(node) do |range|
+            add_offense(node, range, MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_unnecessary_space_match(node) do |range|
+              corrector.replace(range, ' ')
+            end
+          end
+        end
+
+        private
+
+        def each_unnecessary_space_match(node, &blk)
+          each_match_range(
+            contents_range(node),
+            MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX,
+            &blk
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/space_inside_block_braces.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # 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.
+
+          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)
+          if left_brace.end_pos == right_brace.begin_pos
+            adjacent_braces(left_brace, right_brace)
+          else
+            range = range_between(left_brace.end_pos, right_brace.begin_pos)
+            inner = range.source
+
+            if inner =~ /\S/
+              braces_with_contents_inside(node, inner)
+            elsif style_for_empty_braces == :no_space
+              offense(range.begin_pos, range.end_pos,
+                      'Space inside empty braces detected.')
+            end
+          end
+        end
+
+        def adjacent_braces(left_brace, right_brace)
+          return if style_for_empty_braces != :space
+
+          offense(left_brace.begin_pos, right_brace.end_pos,
+                  'Space missing inside empty braces.')
+        end
+
+        def braces_with_contents_inside(node, inner)
+          _method, args, _body = *node
+          args_delimiter = args.loc.begin # Can be ( | or nil.
+
+          check_left_brace(inner, node.loc.begin, args_delimiter)
+          check_right_brace(inner, node.loc.end, block_length(node))
+        end
+
+        def check_left_brace(inner, left_brace, args_delimiter)
+          if inner =~ /\A\S/
+            no_space_inside_left_brace(left_brace, args_delimiter)
+          else
+            space_inside_left_brace(left_brace, args_delimiter)
+          end
+        end
+
+        def check_right_brace(inner, right_brace, block_length)
+          if inner =~ /\S$/ && block_length.zero?
+            no_space(right_brace.begin_pos, right_brace.end_pos,
+                     'Space missing inside }.')
+          else
+            space_inside_right_brace(right_brace)
+          end
+        end
+
+        def no_space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            if left_brace.end_pos == args_delimiter.begin_pos &&
+               cop_config['SpaceBeforeBlockParameters']
+              offense(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(left_brace.end_pos, left_brace.end_pos + 1,
+                     'Space missing inside {.')
+          end
+        end
+
+        def space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            unless cop_config['SpaceBeforeBlockParameters']
+              offense(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(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)
+          brace_with_space = range_with_surrounding_space(right_brace, :left)
+          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
+                'Space inside } detected.')
+        end
+
+        def no_space(begin_pos, end_pos, msg)
+          if style == :space
+            offense(begin_pos, end_pos, msg) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        def space(begin_pos, end_pos, msg)
+          if style == :no_space
+            offense(begin_pos, end_pos, msg) { opposite_style_detected }
+          else
+            correct_style_detected
+          end
+        end
+
+        def offense(begin_pos, end_pos, msg)
+          range = range_between(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/rubbycop/cop/layout/space_inside_brackets.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks for spaces inside square brackets.
+      class SpaceInsideBrackets < Cop
+        include SpaceInside
+
+        def specifics
+          [
+            %i[tLBRACK tLBRACK2],
+            :tRBRACK,
+            'square brackets'
+          ]
+        end
+      end
+    end
+  end
+end