Module: Go::Merge

Defined in:
lib/go/merge.rb,
lib/go/merge/version.rb,
sig/go/merge.rbs

Defined Under Namespace

Modules: Version

Constant Summary collapse

PACKAGE_NAME = 
'go-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_go_backends ⇒ Object 



33
34
35
 
# File 'lib/go/merge.rb', line 33

def available_go_backends
  go_backend_available_for_analysis?(TREE_SITTER_BACKEND.id) ? [TREE_SITTER_BACKEND] : []
end

.go_backend_available_for_analysis?(backend_id) ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/go/merge.rb', line 75

def go_backend_available_for_analysis?(backend_id)
  register_backend!

  if backend_id.to_s.empty?
    TreeHaver.parser_for(:go, backend_type: :tree_sitter)
  else
    TreeHaver.with_backend(backend_id) { TreeHaver.parser_for(:go, backend_type: :tree_sitter) }
  end
  true
rescue TreeHaver::Error, ArgumentError
  false
end

.go_backend_feature_profile(backend: nil) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/go/merge.rb', line 37

def go_backend_feature_profile(backend: nil)
  requested = requested_tree_sitter_backend_id(backend)
  unless go_backend_available_for_analysis?(requested)
    return unsupported_feature_result("Unsupported Go backend #{requested}.")
  end

  go_feature_profile.merge(
    backend: requested,
    backend_ref: TREE_SITTER_BACKEND.to_h,
    supports_dialects: true
  )
end

.go_feature_profile ⇒ Object 



29
30
31
 
# File 'lib/go/merge.rb', line 29

def go_feature_profile
  { family: 'go', supported_dialects: ['go'], supported_policies: [DESTINATION_WINS_ARRAY_POLICY] }
end

.go_plan_context(backend: nil) ⇒ Object 



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

def go_plan_context(backend: nil)
  profile = go_backend_feature_profile(backend: backend)
  return profile if profile[:ok] == false

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

.match_go_owners(template, destination) ⇒ Object 



96
97
98
 
# File 'lib/go/merge.rb', line 96

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

.merge_go(template_source, destination_source, dialect) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/go/merge.rb', line 100

def merge_go(template_source, destination_source, dialect)
  template = parse_go(template_source, dialect)
  return { ok: false, diagnostics: template[:diagnostics], policies: [] } unless template[:ok]

  destination = parse_go(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_go(source, dialect) ⇒ Object 



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

def parse_go(source, dialect)
  unless go_backend_available_for_analysis?(nil)
    diagnostic_backend = TreeHaver.current_backend_id || 'tree-sitter'
    return unsupported_feature_result("Unsupported Go backend #{diagnostic_backend}.")
  end
  return analyze_go_module(source) if dialect == 'go'

  { ok: false,
    diagnostics: [{ severity: 'error', category: 'unsupported_feature', message: "Unsupported Go dialect #{dialect}." }], policies: [] }
end

.register_backend! ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/go/merge.rb', line 16

def register_backend!
  BACKEND_REGISTRY.mutex.synchronize do
    return if BACKEND_REGISTRY.registered

    TreeHaver::BackendRegistry.register(TREE_SITTER_BACKEND)

    grammar_finder = TreeHaver::GrammarFinder.new(:go)
    grammar_finder.register! if grammar_finder.available?

    BACKEND_REGISTRY.registered = true
  end
end