rubbycop 0.49.0

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks that the equals signs in parameter default assignments
+      # have or don't have surrounding space depending on configuration.
+      class SpaceAroundEqualsInParameterDefault < Cop
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
+        def on_optarg(node)
+          index = index_of_first_token(node)
+          arg, equals, value = processed_source.tokens[index, 3]
+          check_optarg(arg, equals, value)
+        end
+
+        private
+
+        def check_optarg(arg, equals, value)
+          space_on_both_sides = space_on_both_sides?(arg, equals, value)
+          no_surrounding_space = no_surrounding_space?(arg, equals, value)
+
+          if style == :space && space_on_both_sides ||
+             style == :no_space && no_surrounding_space
+            correct_style_detected
+          else
+            incorrect_style_detected(arg, value, space_on_both_sides,
+                                     no_surrounding_space)
+          end
+        end
+
+        def incorrect_style_detected(arg, value, space_on_both_sides,
+                                     no_surrounding_space)
+          range = range_between(arg.pos.end_pos, value.pos.begin_pos)
+          add_offense(range, range) do
+            if style == :space && no_surrounding_space ||
+               style == :no_space && space_on_both_sides
+              opposite_style_detected
+            else
+              unrecognized_style_detected
+            end
+          end
+        end
+
+        def space_on_both_sides?(arg, equals, value)
+          space_between?(arg, equals) && space_between?(equals, value)
+        end
+
+        def no_surrounding_space?(arg, equals, value)
+          !space_between?(arg, equals) && !space_between?(equals, value)
+        end
+
+        def message(_)
+          format('Surrounding space %s in default value assignment.',
+                 style == :space ? 'missing' : 'detected')
+        end
+
+        def autocorrect(range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
+          replacement = style == :space ? ' = ' : '='
+          ->(corrector) { corrector.replace(range, replacement + rest) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks the spacing around the keywords.
+      #
+      # @example
+      #
+      #   # bad
+      #   something 'test'do|x|
+      #   end
+      #
+      #   while(something)
+      #   end
+      #
+      #   something = 123if test
+      #
+      #   # good
+      #   something 'test' do |x|
+      #   end
+      #
+      #   while (something)
+      #   end
+      #
+      #   something = 123 if test
+      class SpaceAroundKeyword < Cop
+        MSG_BEFORE = 'Space before keyword `%s` is missing.'.freeze
+        MSG_AFTER = 'Space after keyword `%s` is missing.'.freeze
+
+        DO = 'do'.freeze
+        SAFE_NAVIGATION = '&.'.freeze
+        ACCEPT_LEFT_PAREN =
+          %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_SQUARE_BRACKET =
+          %w[super yield].freeze
+
+        def on_and(node)
+          check(node, [:operator].freeze) if node.keyword?
+        end
+
+        def on_block(node)
+          check(node, %i[begin end].freeze)
+        end
+
+        def on_break(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_case(node)
+          check(node, %i[keyword else].freeze)
+        end
+
+        def on_ensure(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_for(node)
+          check(node, %i[begin end].freeze)
+        end
+
+        def on_if(node)
+          check(node, %i[keyword else begin end].freeze, 'then'.freeze)
+        end
+
+        def on_kwbegin(node)
+          check(node, %i[begin end].freeze, nil)
+        end
+
+        def on_next(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_or(node)
+          check(node, [:operator].freeze) if node.keyword?
+        end
+
+        def on_postexe(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_preexe(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_resbody(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_rescue(node)
+          check(node, [:else].freeze)
+        end
+
+        def on_return(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_send(node)
+          check(node, [:selector].freeze) if node.keyword_not?
+        end
+
+        def on_super(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_zsuper(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_until(node)
+          check(node, %i[begin end keyword].freeze)
+        end
+
+        def on_when(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_while(node)
+          check(node, %i[begin end keyword].freeze)
+        end
+
+        def on_yield(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_defined?(node)
+          check(node, [:keyword].freeze)
+        end
+
+        private
+
+        def check(node, locations, begin_keyword = DO)
+          locations.each do |loc|
+            next unless node.loc.respond_to?(loc)
+            range = node.loc.public_send(loc)
+            next unless range
+
+            case loc
+            when :begin then check_begin(node, range, begin_keyword)
+            when :end then check_end(node, range, begin_keyword)
+            else check_keyword(node, range)
+            end
+          end
+        end
+
+        def check_begin(node, range, begin_keyword)
+          return if begin_keyword && !range.is?(begin_keyword)
+
+          check_keyword(node, range)
+        end
+
+        def check_end(node, range, begin_keyword)
+          return if begin_keyword == DO && !do?(node)
+
+          offense(range, MSG_BEFORE) if space_before_missing?(range)
+        end
+
+        def do?(node)
+          node.loc.begin && node.loc.begin.is?(DO)
+        end
+
+        def check_keyword(node, range)
+          offense(range, MSG_BEFORE) if space_before_missing?(range) &&
+                                        !preceded_by_operator?(node, range)
+          offense(range, MSG_AFTER) if space_after_missing?(range)
+        end
+
+        def offense(range, msg)
+          add_offense(range, range, msg % range.source)
+        end
+
+        def space_before_missing?(range)
+          pos = range.begin_pos - 1
+          return false if pos < 0
+          range.source_buffer.source[pos] !~ /[\s\(\|\{\[;,\*\=]/
+        end
+
+        def space_after_missing?(range)
+          pos = range.end_pos
+          char = range.source_buffer.source[pos]
+          return false unless char
+          return false if accept_left_parenthesis?(range) &&
+                          char == '('.freeze
+          return false if accept_left_square_bracket?(range) &&
+                          char == '['.freeze
+          return false if safe_navigation_call?(range, pos)
+
+          char !~ /[\s;,#\\\)\}\]\.]/
+        end
+
+        def accept_left_parenthesis?(range)
+          ACCEPT_LEFT_PAREN.include?(range.source)
+        end
+
+        def accept_left_square_bracket?(range)
+          ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
+        end
+
+        def safe_navigation_call?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
+        end
+
+        def preceded_by_operator?(node, _range)
+          # regular dotted method calls bind more tightly than operators
+          # so we need to climb up the AST past them
+          node.each_ancestor do |ancestor|
+            return true if ancestor.and_type? || ancestor.or_type?
+            return false unless ancestor.send_type?
+            return true if operator?(ancestor.method_name)
+          end
+          false
+        end
+
+        def autocorrect(range)
+          if space_before_missing?(range)
+            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
+          else
+            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks that operators have space around them, except for **
+      # which should not have surrounding space.
+      class SpaceAroundOperators < Cop
+        include PrecedingFollowingAlignment
+
+        IRREGULAR_METHODS = %i[[] ! []=].freeze
+
+        def on_pair(node)
+          return unless node.hash_rocket?
+
+          return if hash_table_style? && !node.parent.pairs_on_same_line?
+
+          check_operator(node.loc.operator, node.source_range)
+        end
+
+        def on_if(node)
+          return unless node.ternary?
+
+          check_operator(node.loc.question, node.if_branch.source_range)
+          check_operator(node.loc.colon, node.else_branch.source_range)
+        end
+
+        def on_resbody(node)
+          return unless node.loc.assoc
+
+          _, variable, = *node
+
+          check_operator(node.loc.assoc, variable.source_range)
+        end
+
+        def on_send(node)
+          if node.setter_method?
+            on_special_asgn(node)
+          elsif regular_operator?(node)
+            check_operator(node.loc.selector, node.first_argument.source_range)
+          end
+        end
+
+        def on_binary(node)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(node.loc.operator, rhs.source_range)
+        end
+
+        def on_special_asgn(node)
+          _, _, right, = *node
+
+          return unless right
+          check_operator(node.loc.operator, right.source_range)
+        end
+
+        alias on_or       on_binary
+        alias on_and      on_binary
+        alias on_lvasgn   on_binary
+        alias on_masgn    on_binary
+        alias on_casgn    on_special_asgn
+        alias on_ivasgn   on_binary
+        alias on_cvasgn   on_binary
+        alias on_gvasgn   on_binary
+        alias on_class    on_binary
+        alias on_or_asgn  on_binary
+        alias on_and_asgn on_binary
+        alias on_op_asgn  on_special_asgn
+
+        private
+
+        def regular_operator?(send_node)
+          !send_node.unary_operation? && !send_node.dot? &&
+            operator_with_regular_syntax?(send_node)
+        end
+
+        def operator_with_regular_syntax?(send_node)
+          send_node.operator_method? &&
+            !IRREGULAR_METHODS.include?(send_node.method_name)
+        end
+
+        def check_operator(op, right_operand)
+          with_space = range_with_surrounding_space(op)
+          return if with_space.source.start_with?("\n")
+
+          offense(op, with_space, right_operand) do |msg|
+            add_offense(with_space, op, msg)
+          end
+        end
+
+        def offense(op, with_space, right_operand)
+          msg = offense_message(op, with_space, right_operand)
+          yield msg if msg
+        end
+
+        def offense_message(op, with_space, right_operand)
+          if op.is?('**')
+            'Space around operator `**` detected.' unless with_space.is?('**')
+          elsif with_space.source !~ /^\s.*\s$/
+            "Surrounding space missing for operator `#{op.source}`."
+          elsif excess_leading_space?(op, with_space) ||
+                excess_trailing_space?(right_operand, with_space)
+            "Operator `#{op.source}` should be surrounded by a single space."
+          end
+        end
+
+        def excess_leading_space?(op, with_space)
+          with_space.source =~ /^  / &&
+            (!allow_for_alignment? || !aligned_with_operator?(op))
+        end
+
+        def excess_trailing_space?(right_operand, with_space)
+          with_space.source =~ /  $/ &&
+            (!allow_for_alignment? || !aligned_with_something?(right_operand))
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            if range.source =~ /\*\*/
+              corrector.replace(range, '**')
+            elsif range.source.end_with?("\n")
+              corrector.replace(range, " #{range.source.strip}\n")
+            else
+              corrector.replace(range, " #{range.source.strip} ")
+            end
+          end
+        end
+
+        def align_hash_cop_config
+          config.for_cop('Layout/AlignHash')
+        end
+
+        def hash_table_style?
+          align_hash_cop_config &&
+            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Checks that block braces have or don't have a space before the opening
+      # brace depending on configuration.
+      class SpaceBeforeBlockBraces < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_block(node)
+          return if node.loc.begin.is?('do') # No braces.
+
+          left_brace = node.loc.begin
+          space_plus_brace = range_with_surrounding_space(left_brace)
+          used_style =
+            space_plus_brace.source.start_with?('{') ? :no_space : :space
+
+          case used_style
+          when style  then correct_style_detected
+          when :space then space_detected(left_brace, space_plus_brace)
+          else             space_missing(left_brace)
+          end
+        end
+
+        private
+
+        def space_missing(left_brace)
+          add_offense(left_brace, left_brace,
+                      'Space missing to the left of {.') do
+            opposite_style_detected
+          end
+        end
+
+        def space_detected(left_brace, space_plus_brace)
+          space = range_between(space_plus_brace.begin_pos,
+                                left_brace.begin_pos)
+          add_offense(space, space, 'Space detected to the left of {.') do
+            opposite_style_detected
+          end
+        end
+
+        def autocorrect(range)
+          lambda do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            else           corrector.insert_before(range, ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end