Module: TypeScript::Merge

Defined in:
lib/typescript/merge.rb,
lib/typescript/merge/version.rb,
lib/typescript/merge/provider.rb,
lib/typescript/merge/node_wrapper.rb,
lib/typescript/merge/file_analysis.rb,
sig/typescript/merge.rbs

Defined Under Namespace

Modules: Version Classes: FileAnalysis, NodeWrapper, Provider

Constant Summary collapse

PACKAGE_NAME = 
'typescript-merge'
TREE_SITTER_BACKEND = 
TreeHaver::KREUZBERG_LANGUAGE_PACK_BACKEND
DESTINATION_WINS_ARRAY_POLICY = 
{ surface: 'array', name: 'destination_wins_array' }.freeze
BACKEND_REGISTRY = 
Struct.new(:registered, :mutex).new(false, Mutex.new)
VERSION =

Current gem version exposed at the traditional constant location.

Returns:

  • (String) 
Version::VERSION

Class Method Summary collapse

Class Method Details

.available_type_script_backends ⇒ Object 



47
48
49
 
# File 'lib/typescript/merge.rb', line 47

def available_type_script_backends
  type_script_backend_available_for_analysis?(TREE_SITTER_BACKEND.id) ? [TREE_SITTER_BACKEND] : []
end

.match_type_script_owners(template, destination) ⇒ Object 



110
111
112
 
# File 'lib/typescript/merge.rb', line 110

def match_type_script_owners(template, destination)
  Ast::Merge::OwnerSelection.match_by_path(template, destination)
end

.merge_provider ⇒ Provider

Returns:



114
115
116
 
# File 'lib/typescript/merge.rb', line 114

def merge_provider
  @merge_provider ||= Provider.new
end

.merge_type_script(template_source, destination_source, dialect) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/typescript/merge.rb', line 124

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 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 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] }
end

.parse_type_script(source, dialect) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
 
# File 'lib/typescript/merge.rb', line 78

def parse_type_script(source, dialect)
  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

.register_backend! ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/typescript/merge.rb', line 20

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

.register_provider!(replace: false) ⇒ Object

Parameters:

  • replace: (Boolean) (defaults to: false)

Returns:

  • (Object) 


118
119
120
121
122
 
# File 'lib/typescript/merge.rb', line 118

def register_provider!(replace: false)
  return unless Ast::Merge.respond_to?(:register_provider)

  Ast::Merge.register_provider(merge_provider, replace: replace)
end

.type_script_backend_available_for_analysis?(backend_id) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/typescript/merge.rb', line 89

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

.type_script_backend_feature_profile(backend: nil) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/typescript/merge.rb', line 51

def type_script_backend_feature_profile(backend: nil)
  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,
    backend_ref: TREE_SITTER_BACKEND.to_h,
    supports_dialects: true
  )
end

.type_script_feature_profile ⇒ Object 



39
40
41
42
43
44
45
 
# File 'lib/typescript/merge.rb', line 39

def type_script_feature_profile
  {
    family: 'typescript',
    supported_dialects: %w[typescript tsx],
    supported_policies: [DESTINATION_WINS_ARRAY_POLICY]
  }
end

.type_script_plan_context(backend: nil) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/typescript/merge.rb', line 64

def type_script_plan_context(backend: nil)
  profile = type_script_backend_feature_profile(backend: backend)
  return profile if profile[:ok] == false

  {
    family_profile: type_script_feature_profile,
    feature_profile: {
      backend: profile[:backend],
      supports_dialects: true,
      supported_policies: profile[:supported_policies]
    }
  }
end