go-merge 7.1.1 → 7.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b0b435b61118c6713db06822163d8580bb16efa4d6b0c062607bbabdfc9072d
-  data.tar.gz: 598971a08e823d4766f33fe24fd6b57adefc71c60667e98acb2456177e722c7c
+  metadata.gz: fc2818e672c1921f963df9cb173320cfe7a180ecd33a6c0a3b4d855fa76044a8
+  data.tar.gz: 239be77b2d5ff59d3d00d5e729f55361f13aa5c7e7d4cb0c9ff5c6c0efbeaa48
 SHA512:
-  metadata.gz: bf5053390f52d5f671a1a1c936c46f711aef088a7f1596dc9c7ca909468d997f838008c71f0f422428ba50b7fea754b2caed65ce88862bd0912095a9e0057883
-  data.tar.gz: 70d589fb1ad395149a1e0968b6af7b835f95f1bf59c89190e2aef27c701a17a87dee356a166f47bad9eb4cfb4ec8b512be18406e6ce7b66cc34e2e576f73d472
+  metadata.gz: 933ef214c37510ad01f07b2a305b06a23d7d0b8061e8d7ebb656eab06415eefe08064a5ce8d9257f72540caa3eceec8c81a052a871989eb6779dc2fb671650b9
+  data.tar.gz: add66ed0b4da849c4723780e316a256bc9cfcc7a9ac5bcd965ffc7f0b71f1f8cacd34a3951bdab12b4ce63d4571dc6803c1554badc03c479f88e64f05f830f04

data/README.md

@@ -46,7 +46,7 @@ I've summarized my thoughts in [this blog post](https://dev.to/galtzo/hostile-ta
 
 ### Compatibility
 
-Compatible with MRI Ruby 4.0.0+, and concordant releases of JRuby, and TruffleRuby.
+Compatible with MRI Ruby 4.0.0+, JRuby, and TruffleRuby.
 CI workflows and Appraisals are generated for MRI Ruby 4.0.0+.
 This test floor is configured by `ruby.test_minimum` in `.kettle-jem.yml` and
 may be higher than the gem's runtime compatibility floor when legacy Rubies are
@@ -120,20 +120,12 @@ See [SECURITY.md][🔐security].
 ## 🤝 Contributing
 
 If you need some ideas of where to help, you could work on adding more code coverage,
-or if it is already 💯 (see [below](#code-coverage)) check [issues][🤝gh-issues] or [PRs][🤝gh-pulls],
-or use the gem and think about how it could be better.
+check [issues][🤝gh-issues] or [PRs][🤝gh-pulls], or use the gem and think about how it could be better.
 
 We [![Keep A Changelog][📗keep-changelog-img]][📗keep-changelog] so if you make changes, remember to update it.
 
 See [CONTRIBUTING.md][🤝contributing] for more detailed instructions.
 
-### Code Coverage
-
-<details markdown="1">
-<summary>Coverage service badges</summary>
-
-</details>
-
 ## 📌 Versioning
 
 This library follows [![Semantic Versioning 2.0.0][📌semver-img]][📌semver] for its public API where practical.

data/lib/go/merge/file_analysis.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Go
+  module Merge
+    # Native TreeHaver analysis of safely attributable top-level Go source.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- one AST pass establishes ordered ownership and comment attachment
+    class FileAnalysis
+      attr_reader :source, :root_node, :declarations, :errors, :backend
+
+      def initialize(source, require_package: true)
+        @source = source
+        @require_package = require_package
+        @backend = TREE_SITTER_BACKEND.id.to_sym
+        @errors = []
+        parse!
+      rescue StandardError => e
+        @root_node = nil
+        @declarations = [].freeze
+        @errors = [e].freeze
+      end
+
+      private
+
+      def parse!
+        parser = TreeHaver.parser_for(:go, backend_type: :tree_sitter)
+        @root_node = parser.parse(source).root_node
+        raise TreeHaver::NotAvailable, 'Go parse returned no root node' unless root_node
+        raise TreeHaver::NotAvailable, 'Go parse contains syntax errors' if root_node.has_error?
+
+        wrappers = []
+        pending_comments = []
+        root_node.children.each do |node|
+          if node.type == 'comment'
+            if trailing_comment?(wrappers.last, node)
+              wrappers.last.attach_trailing_comment!(node)
+            else
+              pending_comments << node
+            end
+            next
+          end
+          unless NodeWrapper::DECLARATION_TYPES.include?(node.type)
+            pending_comments.clear
+            next
+          end
+
+          comments = attached_comments(pending_comments, node)
+          wrappers << NodeWrapper.new(node, source: source, leading_comments: comments)
+          pending_comments.clear
+        end
+        validate_package!(wrappers) if @require_package
+        @declarations = wrappers.freeze
+      end
+
+      def trailing_comment?(owner, comment)
+        return false unless owner
+
+        gap = source.byteslice(owner.end_byte...comment.start_byte).to_s
+        whitespace_only?(gap) && gap.count("\n").zero?
+      end
+
+      def attached_comments(comments, owner)
+        return [] if comments.empty?
+
+        attached = []
+        cursor = owner.start_byte
+        comments.reverse_each do |comment|
+          gap = source.byteslice(comment.end_byte...cursor).to_s
+          break unless whitespace_only?(gap) && gap.count("\n") <= 1
+
+          attached.unshift(comment)
+          cursor = comment.start_byte
+        end
+        attached.freeze
+      end
+
+      def validate_package!(wrappers)
+        packages = wrappers.select { |wrapper| wrapper.node.type == 'package_clause' }
+        raise TreeHaver::NotAvailable, 'Go source must contain exactly one package clause' unless packages.length == 1
+        return if wrappers.first.equal?(packages.first)
+
+        raise TreeHaver::NotAvailable, 'Go package clause must be the first owned top-level construct'
+      end
+
+      def whitespace_only?(value)
+        value.each_byte.all? { |byte| [9, 10, 13, 32].include?(byte) }
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/go/merge/node_wrapper.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Go
+  module Merge
+    # Structural identity and source-range adapter for a top-level Go AST node.
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength -- Go declaration forms share one structural identity boundary
+    class NodeWrapper
+      DECLARATION_TYPES = %w[
+        const_declaration
+        function_declaration
+        import_declaration
+        method_declaration
+        package_clause
+        type_declaration
+        var_declaration
+      ].freeze
+      GROUP_SPEC_TYPES = %w[const_spec import_spec type_spec var_spec].freeze
+
+      attr_reader :node, :source, :leading_comments, :trailing_comments
+
+      def initialize(node, source:, leading_comments: [])
+        @node = node
+        @source = source
+        @leading_comments = leading_comments.freeze
+        @trailing_comments = []
+      end
+
+      def signature
+        case node.type
+        when 'package_clause'
+          [:package, required_descendant_text(node, 'package_identifier')]
+        when 'import_declaration'
+          import_signature
+        when 'function_declaration'
+          [:function, required_direct_child_text(node, 'identifier')]
+        when 'method_declaration'
+          [:method, receiver_type_name, required_direct_child_text(node, 'field_identifier')]
+        when 'type_declaration'
+          declaration_signature(:type, 'type_spec', 'type_identifier')
+        when 'const_declaration'
+          declaration_signature(:const, 'const_spec', 'identifier')
+        when 'var_declaration'
+          declaration_signature(:var, 'var_spec', 'identifier')
+        else
+          raise ArgumentError, "Unsupported top-level Go node #{node.type.inspect}"
+        end.freeze
+      end
+
+      def grouped?
+        case node.type
+        when 'import_declaration'
+          !find_descendant(node, ['import_spec_list']).nil?
+        when 'type_declaration', 'const_declaration'
+          node.children.any? { |child| child.type == '(' }
+        when 'var_declaration'
+          !find_descendant(node, ['var_spec_list']).nil?
+        else
+          false
+        end
+      end
+
+      def start_byte
+        leading_comments.first&.start_byte || node.start_byte
+      end
+
+      def attach_trailing_comment!(comment)
+        trailing_comments << comment
+      end
+
+      def end_byte = trailing_comments.last&.end_byte || node.end_byte
+      def start_line = line_for_byte(start_byte)
+      def end_line = line_for_byte(end_byte.zero? ? 0 : end_byte - 1)
+      def source_text = source.byteslice(start_byte...end_byte).to_s
+
+      def semantic_tree
+        semantic_node(node)
+      end
+
+      private
+
+      def import_signature
+        specs = descendants(node, 'import_spec')
+        values = specs.map do |spec|
+          literal = required_descendant(spec, 'interpreted_string_literal', 'raw_string_literal')
+          alias_node = spec.children.find do |child|
+            %w[package_identifier dot blank_identifier].include?(child.type)
+          end
+          [alias_node ? text(alias_node) : nil, import_path(literal)]
+        end
+        return [:import_group, values.sort_by { |value| value.map(&:to_s) }.freeze] if grouped?
+
+        [:import, values.fetch(0)]
+      end
+
+      def import_path(literal)
+        content = literal.children.find do |child|
+          %w[interpreted_string_literal_content raw_string_literal_content].include?(child.type)
+        end
+        return text(content) if content
+
+        literal_text = text(literal)
+        literal_text.byteslice(1...-1).to_s
+      end
+
+      def receiver_type_name
+        receiver = node.children.find { |child| child.type == 'parameter_list' }
+        parameter = required_descendant(receiver, 'parameter_declaration')
+        required_descendant_text(parameter, 'type_identifier')
+      end
+
+      def declaration_signature(kind, spec_type, identifier_type)
+        specs = descendants(node, spec_type)
+        member_names = specs.map do |spec|
+          spec.children.select { |child| child.type == identifier_type }.map { |child| text(child) }
+        end
+        raise ArgumentError, "#{node.type} has no declared name" if member_names.flatten.empty?
+        return [:"#{kind}_group", member_names.map(&:freeze).freeze] if grouped?
+
+        names = member_names.flatten
+        [kind, names.length == 1 ? names.first : names.freeze]
+      end
+
+      def required_direct_child_text(parent, type)
+        child = parent.children.find { |candidate| candidate.type == type }
+        raise ArgumentError, "#{parent.type} has no #{type}" unless child
+
+        text(child)
+      end
+
+      def required_descendant_text(parent, *types)
+        text(required_descendant(parent, *types))
+      end
+
+      def required_descendant(parent, *types)
+        found = find_descendant(parent, types)
+        raise ArgumentError, "#{parent.type} has no #{types.join(' or ')}" unless found
+
+        found
+      end
+
+      def find_descendant(parent, types)
+        return parent if types.include?(parent.type)
+
+        parent.children.each do |child|
+          found = find_descendant(child, types)
+          return found if found
+        end
+        nil
+      end
+
+      def descendants(parent, type, found = [])
+        found << parent if parent.type == type
+        parent.children.each { |child| descendants(child, type, found) }
+        found
+      end
+
+      def semantic_node(value)
+        children = value.children
+        return [value.type, text(value)] if children.empty?
+
+        [value.type, children.select(&:named?).map { |child| semantic_node(child) }]
+      end
+
+      def text(value)
+        source.byteslice(value.start_byte...value.end_byte).to_s
+      end
+
+      def line_for_byte(byte)
+        source.byteslice(0...byte).to_s.count("\n") + 1
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  end
+end