typescript-merge 7.0.0 → 7.1.3

data/lib/typescript/merge/version.rb

@@ -2,10 +2,12 @@
 
 module TypeScript
   module Merge
+    # Version namespace for this gem.
     module Version
-      VERSION = "7.0.0"
+      # Current gem version.
+      VERSION = '7.1.3'
     end
-
-    VERSION = Version::VERSION
+    # Current gem version exposed at the traditional constant location.
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/typescript/merge.rb

@@ -1,27 +1,58 @@
 # frozen_string_literal: true
 
-require "tree_haver"
-require "ast/merge"
+require 'tree_haver'
+require 'ast/merge'
+require_relative 'merge/version'
 
 module TypeScript
   module Merge
-    extend self
+    module_function
 
-    PACKAGE_NAME = "typescript-merge"
+    PACKAGE_NAME = 'typescript-merge'
     TREE_SITTER_BACKEND = TreeHaver::KREUZBERG_LANGUAGE_PACK_BACKEND
-    DESTINATION_WINS_ARRAY_POLICY = { surface: "array", name: "destination_wins_array" }.freeze
+    DESTINATION_WINS_ARRAY_POLICY = { surface: 'array', name: 'destination_wins_array' }.freeze
+    BACKEND_REGISTRY = Struct.new(:registered, :mutex).new(false, Mutex.new)
+
+    autoload :NodeWrapper, 'typescript/merge/node_wrapper'
+    autoload :FileAnalysis, 'typescript/merge/file_analysis'
+    autoload :Provider, 'typescript/merge/provider'
+
+    def register_backend!
+      BACKEND_REGISTRY.mutex.synchronize do
+        return if BACKEND_REGISTRY.registered
+
+        TreeHaver::BackendRegistry.register(TREE_SITTER_BACKEND)
+
+        grammar_finder = TreeHaver::GrammarFinder.new(:typescript)
+        grammar_finder.register! if grammar_finder.available?
+        TreeHaver.register_language(
+          :tsx,
+          backend_module: TreeHaver::Backends::Tslp,
+          backend_type: :tslp,
+          gem_name: 'tree_sitter_language_pack'
+        )
+
+        BACKEND_REGISTRY.registered = true
+      end
+    end
 
     def type_script_feature_profile
-      { family: "typescript", supported_dialects: ["typescript"], supported_policies: [DESTINATION_WINS_ARRAY_POLICY] }
+      {
+        family: 'typescript',
+        supported_dialects: %w[typescript tsx],
+        supported_policies: [DESTINATION_WINS_ARRAY_POLICY]
+      }
     end
 
     def available_type_script_backends
-      [TREE_SITTER_BACKEND]
+      type_script_backend_available_for_analysis?(TREE_SITTER_BACKEND.id) ? [TREE_SITTER_BACKEND] : []
     end
 
     def type_script_backend_feature_profile(backend: nil)
-      requested = backend.to_s.empty? ? TREE_SITTER_BACKEND.id : backend.to_s
-      return unsupported_feature_result("Unsupported TypeScript backend #{requested}.") unless requested == TREE_SITTER_BACKEND.id
+      requested = requested_tree_sitter_backend_id(backend)
+      unless type_script_backend_available_for_analysis?(requested)
+        return unsupported_feature_result("Unsupported TypeScript backend #{requested}.")
+      end
 
       type_script_feature_profile.merge(
         backend: requested,
@@ -45,101 +76,163 @@ module TypeScript
     end
 
     def parse_type_script(source, dialect)
-      requested = TREE_SITTER_BACKEND.id
-      return unsupported_feature_result("Unsupported TypeScript backend #{requested}.") unless requested == TREE_SITTER_BACKEND.id
-      return analyze_type_script_module(source) if dialect == "typescript"
+      unless type_script_backend_available_for_analysis?(nil)
+        diagnostic_backend = TreeHaver.current_backend_id || 'tree-sitter'
+        return unsupported_feature_result("Unsupported TypeScript backend #{diagnostic_backend}.")
+      end
+      return analyze_type_script_module(source, dialect: dialect) if %w[typescript tsx].include?(dialect)
+
+      { ok: false,
+        diagnostics: [{ severity: 'error', category: 'unsupported_feature', message: "Unsupported TypeScript dialect #{dialect}." }], policies: [] }
+    end
 
-      { ok: false, diagnostics: [{ severity: "error", category: "unsupported_feature", message: "Unsupported TypeScript dialect #{dialect}." }], policies: [] }
+    def type_script_backend_available_for_analysis?(backend_id)
+      register_backend!
+
+      if backend_id.to_s.empty?
+        TreeHaver.parser_for(:typescript, backend_type: :tree_sitter)
+      else
+        TreeHaver.with_backend(backend_id) { TreeHaver.parser_for(:typescript, backend_type: :tree_sitter) }
+      end
+      true
+    rescue TreeHaver::Error, ArgumentError
+      false
     end
 
+    def requested_tree_sitter_backend_id(backend)
+      return backend.to_s unless backend.to_s.empty?
+
+      contextual = TreeHaver.current_backend_id || ENV['TREE_HAVER_BACKEND']
+      contextual.to_s.empty? || contextual.to_s == 'auto' ? TREE_SITTER_BACKEND.id : contextual.to_s
+    end
+    private_class_method :requested_tree_sitter_backend_id
+
     def match_type_script_owners(template, destination)
-      destination_paths = destination[:owners].to_h { |owner| [owner[:path], true] }
-      template_paths = template[:owners].to_h { |owner| [owner[:path], true] }
-      {
-        matched: template[:owners].filter { |owner| destination_paths[owner[:path]] }.map { |owner| { template_path: owner[:path], destination_path: owner[:path] } },
-        unmatched_template: template[:owners].map { |owner| owner[:path] }.reject { |path| destination_paths[path] },
-        unmatched_destination: destination[:owners].map { |owner| owner[:path] }.reject { |path| template_paths[path] }
-      }
+      Ast::Merge::OwnerSelection.match_by_path(template, destination)
+    end
+
+    def merge_provider
+      @merge_provider ||= Provider.new
+    end
+
+    def register_provider!(replace: false)
+      return unless Ast::Merge.respond_to?(:register_provider)
+
+      Ast::Merge.register_provider(merge_provider, replace: replace)
     end
 
     def merge_type_script(template_source, destination_source, dialect)
       template = parse_type_script(template_source, dialect)
       return { ok: false, diagnostics: template[:diagnostics], policies: [] } unless template[:ok]
+
       destination = parse_type_script(destination_source, dialect)
       unless destination[:ok]
         return {
           ok: false,
-          diagnostics: destination[:diagnostics].map { |diagnostic| diagnostic[:category] == "parse_error" ? diagnostic.merge(category: "destination_parse_error") : diagnostic },
+          diagnostics: destination[:diagnostics].map do |diagnostic|
+            diagnostic[:category] == 'parse_error' ? diagnostic.merge(category: 'destination_parse_error') : diagnostic
+          end,
           policies: []
         }
       end
 
       destination_declarations = destination.dig(:analysis, :declarations).to_h { |item| [item[:path], item] }
       merged_declaration_texts = destination.dig(:analysis, :declarations).map { |item| item[:text] } +
-        template.dig(:analysis, :declarations).reject { |item| destination_declarations[item[:path]] }.map { |item| item[:text] }
+                                 template.dig(:analysis, :declarations).reject do |item|
+                                   destination_declarations[item[:path]]
+                                 end.map { |item| item[:text] }
       import_block = destination.dig(:analysis, :imports).map { |item| item[:text] }.join
       declaration_block = merged_declaration_texts.join("\n").rstrip
       sections = [import_block.rstrip, declaration_block].reject(&:empty?)
 
-      { ok: true, diagnostics: [], output: "#{sections.join("\n\n").rstrip}\n", policies: [DESTINATION_WINS_ARRAY_POLICY] }
+      { ok: true, diagnostics: [], output: "#{sections.join("\n\n").rstrip}\n",
+        policies: [DESTINATION_WINS_ARRAY_POLICY] }
     end
 
-    def analyze_type_script_module(source)
-      parsed = TreeHaver.parse_with_language_pack(TreeHaver::ParserRequest.new(source: source, language: "typescript", dialect: "typescript"))
-      return { ok: false, diagnostics: parsed[:diagnostics], policies: [] } unless parsed[:ok]
-      processed = TreeHaver.process_with_language_pack(TreeHaver::ProcessRequest.new(source: source, language: "typescript"))
-      return { ok: false, diagnostics: processed[:diagnostics], policies: [] } unless processed[:ok]
-
-      imports = processed[:analysis].imports.each_with_index.map do |item, index|
-        { path: "/imports/#{index}", match_key: item.source, text: import_text(source, item.span) }
+    def analyze_type_script_module(source, dialect: 'typescript')
+      analysis = FileAnalysis.new(source, dialect: dialect)
+      raise analysis.errors.first unless analysis.errors.empty?
+
+      imports = []
+      declarations = []
+      analysis.declarations.each do |wrapper|
+        signature = wrapper.signature
+        if signature.first == :import
+          imports << {
+            path: "/imports/#{imports.length}",
+            owner_kind: 'import',
+            match_key: legacy_import_key(signature),
+            text: "#{wrapper.source_text}\n"
+          }
+        else
+          name = legacy_declaration_key(signature)
+          declarations << {
+            path: "/declarations/#{name}",
+            owner_kind: 'declaration',
+            match_key: name,
+            text: "#{wrapper.source_text}\n"
+          }
+        end
       end
-      declarations = processed[:analysis].structure
-        .select { |item| item.name }
-        .map { |item| { path: "/declarations/#{item.name}", match_key: item.name, text: declaration_text(source, item.span) } }
-        .sort_by { |item| item[:path] }
 
       {
         ok: true,
         diagnostics: [],
         analysis: {
-          kind: "typescript",
-          dialect: "typescript",
-          source: source,
-          owners: imports.map { |item| { path: item[:path], owner_kind: "import", match_key: item[:match_key] } } +
-            declarations.map { |item| { path: item[:path], owner_kind: "declaration", match_key: item[:match_key] } },
+          kind: 'typescript',
+          dialect: dialect,
           imports: imports,
-          declarations: declarations
+          declarations: declarations,
+          owners: owner_views(imports + declarations)
         },
         policies: []
       }
+    rescue TreeHaver::Error, StandardError => e
+      parse_failure_result(e)
     end
     private_class_method :analyze_type_script_module
 
-    def import_text(source, span)
-      "#{slice_span(source, span)}\n"
+    def legacy_declaration_key(signature)
+      nested = signature.first == :export_declaration ? signature.fetch(1) : signature
+      value = nested.last
+      value.is_a?(Array) ? value.join(',') : value
+    end
+    private_class_method :legacy_declaration_key
+
+    def legacy_import_key(signature)
+      literal = signature.fetch(1)
+      literal.byteslice(1...-1).to_s
     end
-    private_class_method :import_text
+    private_class_method :legacy_import_key
 
-    def declaration_text(source, span)
-      "#{line_anchored_slice(source, span)}\n"
+    def parse_failure_result(error)
+      { ok: false,
+        diagnostics: [{ severity: 'error', category: 'parse_error', message: error.message }],
+        policies: [] }
     end
-    private_class_method :declaration_text
+    private_class_method :parse_failure_result
 
-    def slice_span(source, span)
-      source[span.start_byte...span.end_byte].strip
+    def owner_view(item)
+      item.slice(:path, :owner_kind, :match_key)
     end
-    private_class_method :slice_span
+    private_class_method :owner_view
 
-    def line_anchored_slice(source, span)
-      line_start = source.rindex("\n", [span.start_byte - 1, 0].max)
-      line_start = line_start ? line_start + 1 : 0
-      source[line_start...span.end_byte].strip
+    def owner_views(items)
+      imports, declarations = items.partition { |item| item.fetch(:owner_kind) == 'import' }
+      (imports + declarations.sort_by { |item| item.fetch(:path) }).map { |item| owner_view(item) }
     end
-    private_class_method :line_anchored_slice
+    private_class_method :owner_views
 
     def unsupported_feature_result(message)
-      Ast::Merge.unsupported_feature_result(message)
+      {
+        ok: false,
+        diagnostics: [{ severity: 'error', category: 'unsupported_feature', message: message }],
+        policies: []
+      }
     end
     private_class_method :unsupported_feature_result
   end
 end
+
+TypeScript::Merge.register_backend!
+TypeScript::Merge.register_provider!

data/lib/typescript-merge.rb

@@ -1,3 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "typescript/merge"
+require_relative 'typescript/merge'
+require 'version_gem'
+require_relative 'typescript/merge/version'
+
+TypeScript::Merge::Version.class_eval do
+  extend VersionGem::Basic
+end

data/sig/typescript/merge.rbs

@@ -0,0 +1,54 @@
+module TypeScript
+  module Merge
+    class NodeWrapper
+      DECLARATION_TYPES: Array[String]
+      NAMED_DECLARATIONS: Hash[String, [Symbol, Array[String]]]
+
+      attr_reader node: untyped
+      attr_reader source: String
+      attr_reader leading_comments: Array[untyped]
+      attr_reader trailing_comments: Array[untyped]
+
+      def initialize: (untyped node, source: String, ?leading_comments: Array[untyped]) -> void
+      def signature: () -> Array[untyped]
+      def membership_signature: () -> Array[untyped]
+      def grouped?: () -> bool
+      def start_byte: () -> Integer
+      def end_byte: () -> Integer
+      def start_line: () -> Integer
+      def end_line: () -> Integer
+      def source_text: () -> String
+      def semantic_tree: () -> Array[untyped]
+      def attach_trailing_comment!: (untyped comment) -> untyped
+    end
+
+    class FileAnalysis
+      attr_reader source: String
+      attr_reader root_node: untyped
+      attr_reader declarations: Array[NodeWrapper]
+      attr_reader errors: Array[StandardError]
+      attr_reader backend: Symbol
+      attr_reader dialect: Symbol
+
+      def initialize: (String source, ?dialect: Symbol) -> void
+    end
+
+    class Provider
+      def provider_id: () -> String
+      def family: () -> String
+      def capabilities: () -> Hash[Symbol, untyped]
+      def analyze: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def diff2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def merge2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+      def merge3: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
+    end
+
+    def self.merge_provider: () -> Provider
+    def self.register_provider!: (?replace: bool) -> untyped
+
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end