glib-web 5.1.5 → 6.3.1

data/lib/glib/rubocop/cops/multiline_method_call_style.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Glib
-      # Enforces parentheses style for multi-line method calls with arguments.
-      #
-      # @example
-      #   # bad
-      #   page.footer padding: glib_json_padding_body, backgroundColor: '#b3bac2', childViews: ->(footer) do
-      #     footer.h1 text: 'Footer'
-      #   end
-      #
-      #   # bad
-      #   page.footer \
-      #     padding: glib_json_padding_body,
-      #     backgroundColor: '#b3bac2',
-      #     childViews: ->(footer) do
-      #       footer.h1 text: 'Footer'
-      #     end
-      #
-      #   # good
-      #   page.footer(
-      #     padding: glib_json_padding_body,
-      #     backgroundColor: '#b3bac2',
-      #     childViews: ->(footer) do
-      #       footer.h1 text: 'Footer'
-      #     end
-      #   )
-      class MultilineMethodCallStyle < Base
-        extend AutoCorrector
-
-        MSG = 'Use parentheses style for multi-line method calls: ' \
-              'wrap arguments in parentheses and place each argument on its own line.'
-
-        def on_send(node)
-          return unless multi_line_call_with_args?(node)
-          return if proper_parentheses_style?(node)
-          return if proper_backslash_style?(node) && allow_backslash?
-          return if inside_correctable_parent?(node)
-
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        alias on_csend on_send
-
-        private
-
-        def multi_line_call_with_args?(node)
-          node.multiline? && node.arguments.any?
-        end
-
-        def allow_backslash?
-          # Allow backslash style without warnings when configured
-          # Set to true to allow both styles (but auto-correct will still convert to parentheses)
-          # Set to false to enforce parentheses style always
-          cop_config.fetch('AllowBackslashStyle', true)
-        end
-
-        def proper_backslash_style?(node)
-          source = processed_source.buffer.source
-          method_end_pos = node.loc.selector.end_pos
-
-          # Check if there's a backslash right after the method name
-          next_char_pos = method_end_pos
-          while next_char_pos < source.length && source[next_char_pos] == ' '
-            next_char_pos += 1
-          end
-
-          return false unless source[next_char_pos] == '\\'
-
-          # Check that each argument is on its own line
-          args = collect_arguments(node)
-          return false if args.empty?
-
-          args.each_cons(2) do |arg1, arg2|
-            return false if arg1.loc.line == arg2.loc.line
-          end
-
-          true
-        end
-
-        def proper_parentheses_style?(node)
-          return false unless node.parenthesized?
-
-          # Check that first argument is on a new line after opening paren
-          first_arg = node.first_argument
-          return false if first_arg.loc.line == node.loc.selector.line
-
-          # Check that each argument is on its own line
-          args = collect_arguments(node)
-          return false if args.empty?
-
-          args.each_cons(2) do |arg1, arg2|
-            return false if arg1.loc.line == arg2.loc.line
-          end
-
-          # Check that closing paren is on its own line
-          source = processed_source.buffer.source
-          close_paren_pos = node.loc.end.begin_pos
-          line_start = source.rindex("\n", close_paren_pos) || 0
-          line_content = source[line_start...close_paren_pos].strip
-
-          return false unless line_content.empty?
-
-          true
-        end
-
-        def collect_arguments(node)
-          args = []
-
-          node.arguments.each do |arg|
-            if arg.hash_type?
-              # For hash arguments, treat each pair as a separate argument
-              arg.pairs.each { |pair| args << pair }
-            else
-              args << arg
-            end
-          end
-
-          args
-        end
-
-        def inside_correctable_parent?(node)
-          # Check if this node is inside a block that belongs to a multi-line call
-          # that will also be corrected. If so, skip this node to avoid conflicts.
-          current = node.parent
-
-          while current
-            if current.send_type? || current.csend_type?
-              if multi_line_call_with_args?(current) && !proper_parentheses_style?(current)
-                return true
-              end
-            end
-            current = current.parent
-          end
-
-          false
-        end
-
-        def autocorrect(corrector, node)
-          method_end_pos = node.loc.selector.end_pos
-
-          # Calculate indentation based on the node's actual column position
-          base_indent = node.loc.column
-          arg_indent = ' ' * (base_indent + 2)
-
-          # Build the new argument list
-          arg_parts = []
-          node.arguments.each do |arg|
-            next if arg.block_pass_type? # Skip block arguments like &block
-
-            if arg.hash_type?
-              arg.pairs.each do |pair|
-                # Re-indent pair if it contains a block
-                pair_source = reindent_pair_with_block(pair, arg_indent)
-                arg_parts << pair_source
-              end
-            else
-              arg_parts << arg.source
-            end
-          end
-
-          # Build the replacement with parentheses style
-          if arg_parts.any?
-            # Opening paren on same line as method, arguments on separate lines
-            replacement = "(\n#{arg_indent}" + arg_parts.join(",\n#{arg_indent}")
-
-            # If there's a block, add it on the last argument line
-            if node.block_literal?
-              block_source = reindent_block(node.block_literal, arg_indent)
-              replacement += " #{block_source}"
-            end
-
-            # Closing paren on its own line at base indentation
-            replacement += "\n#{' ' * base_indent})"
-          else
-            # No arguments, just the block (shouldn't happen for multi-line, but handle it)
-            replacement = if node.block_literal?
-                           " #{node.block_literal.source}"
-                         else
-                           '()'
-                         end
-          end
-
-          # Remove everything from method name to end of node
-          range = Parser::Source::Range.new(
-            processed_source.buffer,
-            method_end_pos,
-            node.source_range.end_pos
-          )
-
-          corrector.replace(range, replacement)
-        end
-
-        def reindent_pair_with_block(pair, base_indent)
-          # Check if the pair's value is a block
-          return pair.source unless pair.value.block_type?
-
-          # Format: "key: ->(param) do ... end"
-          key_source = pair.key.source
-          block_source = reindent_block(pair.value, base_indent)
-
-          "#{key_source}: #{block_source}"
-        end
-
-        def reindent_block(block_node, base_indent)
-          # Get block source lines
-          source = block_node.source
-          lines = source.lines
-
-          return source if lines.length == 1 # Single line block, no reindent needed
-
-          # Find the current indentation of the block's first line
-          # (this is usually where "do" appears)
-          first_line = lines[0]
-
-          # Process the block:
-          # Line 0: "->(param) do" - keep as is
-          # Lines 1..-2: block body - re-indent to base_indent + 2
-          # Last line: "end" - indent to base_indent
-
-          result_lines = []
-          block_body_indent = base_indent + ' ' * 2
-
-          lines.each_with_index do |line, index|
-            if index == 0
-              # First line: "->(param) do"
-              result_lines << line.rstrip
-            elsif index == lines.length - 1
-              # Last line: "end"
-              result_lines << "#{base_indent}#{line.strip}"
-            else
-              # Body lines: re-indent
-              # Remove existing indentation and add new indentation
-              stripped = line.lstrip
-              next if stripped.empty? # Skip blank lines
-
-              result_lines << "#{block_body_indent}#{stripped.rstrip}"
-            end
-          end
-
-          result_lines.join("\n")
-        end
-      end
-    end
-  end
-end