typescript-merge 7.1.1 → 7.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ec9f6ce57ba276ee2cd6713ce86001d78c65b8c4aabade24693ef11bbf4f03
-  data.tar.gz: 48a163ba332882e39cf8e67190d29ef4a01c1ede53a68c3126f0466b32f8ff4a
+  metadata.gz: 92374fc2c22a8142c444657938d8f099d4b8f6fd141ee84bb9a59817d5ff573c
+  data.tar.gz: 9caa1d69534ee9c62820e3c6c93244e5068667403bddfbead6cfefe23915f7ed
 SHA512:
-  metadata.gz: d49657661f31655f72f27836e503529209465c037be78d323fb4606e78612a2b35061013ccf67d74589cba1f3c41b915e83d86e0963bc9a5ebb1d9e61675c869
-  data.tar.gz: 8584890377190ece90ac9f04ce895c039b4062da51a1f08699b3c7d24e305d463e7d6dfa381be195664526cacecf384bdecb368a1a55adb416cf5d975769b581
+  metadata.gz: cf3322b809657af80cbe142168bf5e12dcbd253d7e98c671adf20a5eba537c172b68e1d43b16bfafa576ce268211279fb3507989cdd927a32406a9bc705c0841
+  data.tar.gz: 7ca821538482d3163f7aa3bbb6874116df64fbdb47d9b36584f62b479831b8ec5e3857a8d8c7bbecc0dc26d696d146eaec58084e1ec080be0381dd091ada611f

checksums.yaml.gz.sig

@@ -1,3 +1 @@
-�`��5�A.L����sQ�ڣ����~�d����z	Z~]�h�����ֆ��ߠ�F~g�FX;���
-Ml-�$h��L*�֎��b�D��3a��Pؑ��4��“xOdݖ�׃�D3[�zȝ��X�r��
-��O˻�=��Էi)�S8�6���1vb�B3(�6�&ޙ���ߤ(�a4�XY�$�l`�Z��VE8�@(�/xӜ�w'��.�+��q�Cz"@?RI^�8OKC�6D����p?Z��3�N��Q�+�##9f��2����q`
+|o�jH���BtH]��۠��6���F���A�g}[c�7������LL�M�Q�>B�8��.4��'�+!AU���l���Ǖ6������{�~�^�~C=PKm�V'��5 ^�1�]V�#4h^K&\���+3��J���,fc��H7/\���:@BU�E���ɀ �aN�������j�Un)G:4��U��cT���
S��Z@<+Y�V�I�i�w���`TG�[�F

data/README.md

@@ -45,7 +45,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
@@ -119,20 +119,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/typescript/merge/file_analysis.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module TypeScript
+  module Merge
+    # Native TreeHaver analysis of safely attributable top-level TypeScript 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, :dialect
+
+      def initialize(source, dialect: :typescript)
+        @source = source
+        @dialect = dialect.to_sym
+        @backend = TREE_SITTER_BACKEND.id.to_sym
+        @errors = []
+        parse!
+      rescue StandardError => e
+        @root_node = nil
+        @declarations = [].freeze
+        @errors = [e].freeze
+      end
+
+      private
+
+      def parse!
+        language = dialect == :tsx ? :tsx : :typescript
+        @root_node = TreeHaver.parser_for(language, backend_type: :tree_sitter).parse(source).root_node
+        raise TreeHaver::NotAvailable, 'TypeScript parse returned no root node' unless root_node
+        raise TreeHaver::NotAvailable, 'TypeScript 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)
+            raise TreeHaver::NotAvailable, "Unmanaged top-level TypeScript node #{node.type.inspect}" if node.named?
+
+            pending_comments.clear
+            next
+          end
+
+          wrappers << NodeWrapper.new(node, source: source, leading_comments: attached_comments(pending_comments, node))
+          pending_comments.clear
+        end
+        @declarations = wrappers.freeze
+      end
+
+      def trailing_comment?(owner, comment)
+        owner && whitespace_only?(source.byteslice(owner.end_byte...comment.start_byte).to_s) &&
+          source.byteslice(owner.end_byte...comment.start_byte).to_s.count("\n").zero?
+      end
+
+      def attached_comments(comments, owner)
+        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 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/typescript/merge/node_wrapper.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module TypeScript
+  module Merge
+    # Structural identity and source-range adapter for one top-level TypeScript owner.
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- TypeScript declaration forms share one structural identity boundary
+    class NodeWrapper
+      DECLARATION_TYPES = %w[
+        ambient_declaration
+        class_declaration
+        enum_declaration
+        expression_statement
+        export_statement
+        function_declaration
+        function_signature
+        import_statement
+        interface_declaration
+        internal_module
+        lexical_declaration
+        type_alias_declaration
+        variable_declaration
+      ].freeze
+      NAMED_DECLARATIONS = {
+        'class_declaration' => [:class, %w[type_identifier identifier]],
+        'enum_declaration' => [:enum, %w[identifier type_identifier]],
+        'interface_declaration' => [:interface, %w[type_identifier identifier]],
+        'type_alias_declaration' => [:type, %w[type_identifier identifier]],
+        'internal_module' => [:namespace, %w[identifier string nested_identifier]],
+        'function_declaration' => [:function, %w[identifier]],
+        'function_signature' => [:function, %w[identifier]]
+      }.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
+        return expression_statement_signature if node.type == 'expression_statement'
+        return import_signature if node.type == 'import_statement'
+        return export_signature if node.type == 'export_statement'
+        return variable_signature(node) if variable_declaration?(node)
+        return ambient_signature if node.type == 'ambient_declaration'
+
+        named_signature(node)
+      end
+
+      def membership_signature
+        signature
+      end
+
+      def grouped? = variable_declaration?(node)
+
+      def start_byte = leading_comments.first&.start_byte || node.start_byte
+      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 attach_trailing_comment!(comment) = trailing_comments << comment
+      def semantic_tree = semantic_node(node)
+
+      private
+
+      def expression_statement_signature
+        declaration = node.children.find { |child| NAMED_DECLARATIONS.key?(child.type) }
+        return named_signature(declaration) if declaration
+
+        call = direct_child(node, 'call_expression')
+        raise ArgumentError, 'expression statement is not a supported top-level call' unless call
+
+        callee = call.children.find(&:named?)
+        unless callee && callee.type == 'identifier'
+          raise ArgumentError, 'top-level call has no safely attributable named callee'
+        end
+
+        arguments = direct_child(call, 'arguments')
+        identity = arguments&.children&.find(&:named?)
+        unless identity && identity.type == 'string'
+          raise ArgumentError, 'top-level call has no literal string identity'
+        end
+
+        [:call, text(callee), text(identity)]
+      end
+
+      def import_signature
+        source_node = direct_child(node, 'string') || find_descendant(node, %w[string])
+        raise ArgumentError, 'import_statement has no structural module source' unless source_node
+
+        return [:import, text(source_node), :import_equals] if direct_child(node, 'import_require_clause')
+
+        clause = direct_child(node, 'import_clause')
+        type_only = !direct_child(node, 'type').nil?
+        [:import, text(source_node), type_only ? :type : :value, import_form(clause)]
+      end
+
+      def export_signature
+        default = node.children.any? { |child| child.type == 'default' }
+        return [:default_export] if default
+
+        declaration = node.children.find { |child| DECLARATION_TYPES.include?(child.type) }
+        return [:export_declaration, declaration_signature(declaration)] if declaration
+
+        source_node = direct_child(node, 'string')
+        type_only = !direct_child(node, 'type').nil?
+        if source_node
+          return [:export_from, text(source_node), type_only ? :type : :value, export_form]
+        end
+        return [:export_local, type_only ? :type : :value, :named] if direct_child(node, 'export_clause')
+        return [:export_assignment] if node.children.any? { |child| child.type == '=' }
+        return [:export_as_namespace] if node.children.any? { |child| child.type == 'namespace' }
+
+        [:export, semantic_node(node)]
+      end
+
+      def import_form(clause)
+        return :side_effect unless clause
+
+        child_types = clause.children.select(&:named?).map(&:type)
+        default = child_types.include?('identifier')
+        named = child_types.include?('named_imports')
+        namespace = child_types.include?('namespace_import')
+        return :default_named if default && named
+        return :default_namespace if default && namespace
+        return :default if default
+        return :named if named
+        return :namespace if namespace
+
+        raise ArgumentError, "unsupported structural import clause #{child_types.inspect}"
+      end
+
+      def export_form
+        return :named if direct_child(node, 'export_clause')
+        return :namespace if direct_child(node, 'namespace_export')
+        return :all if node.children.any? { |child| child.type == '*' }
+
+        raise ArgumentError, 'unsupported structural export-from form'
+      end
+
+      def declaration_signature(declaration)
+        return variable_signature(declaration) if variable_declaration?(declaration)
+        return ambient_signature(declaration) if declaration.type == 'ambient_declaration'
+
+        named_signature(declaration)
+      end
+
+      def named_signature(value)
+        kind, name_types = NAMED_DECLARATIONS.fetch(value.type) do
+          raise ArgumentError, "Unsupported top-level TypeScript node #{value.type.inspect}"
+        end
+        name = direct_named_child_text(value, name_types)
+        raise ArgumentError, "#{value.type} has no structurally attributable name" unless name
+
+        [kind, name]
+      end
+
+      def variable_signature(value)
+        declarators = value.children.select { |child| child.type == 'variable_declarator' }
+        names = declarators.map do |declarator|
+          name = declarator.children.find(&:named?)
+          raise ArgumentError, 'variable_declarator has no binding' unless name
+          raise ArgumentError, "unsupported variable binding #{name.type}" unless %w[identifier].include?(name.type)
+
+          text(name)
+        end
+        raise ArgumentError, "#{value.type} has no variable declarators" if names.empty?
+
+        keyword = value.children.find { |child| %w[const let var].include?(child.type) }
+        [:variables, keyword&.type, names.freeze]
+      end
+
+      def ambient_signature(value = node)
+        declaration = value.children.find { |child| child.named? && child.type != 'declare' }
+        raise ArgumentError, 'ambient_declaration has no declaration' unless declaration
+
+        if declaration.type == 'module'
+          name = declaration.children.find { |child| %w[string identifier nested_identifier].include?(child.type) }
+          raise ArgumentError, 'module augmentation has no structural name' unless name
+
+          return [:module_augmentation, text(name)]
+        end
+
+        [:ambient, named_signature(declaration)]
+      end
+
+      def variable_declaration?(value)
+        %w[lexical_declaration variable_declaration].include?(value.type)
+      end
+
+      def direct_child(parent, type)
+        parent.children.find { |child| child.type == type }
+      end
+
+      def direct_named_child_text(parent, types)
+        child = parent.children.find { |candidate| types.include?(candidate.type) }
+        child && text(child)
+      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 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
+      def line_for_byte(byte) = source.byteslice(0...byte).to_s.count("\n") + 1
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end