Module: TreeHaver::BackendRegistry

Defined in:
lib/tree_haver/backend_registry.rb

Constant Summary collapse

CATEGORIES = 
%i[backend gem parsing grammar engine capability other].freeze

Class Method Summary collapse

Class Method Details

.all ⇒ Object 



21
22
23
24
25
 
# File 'lib/tree_haver/backend_registry.rb', line 21

def all
  mutex.synchronize do
    backends.values.map { |backend| BackendReference.new(**deep_dup(backend)) }
  end
end

.available?(name) ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/tree_haver/backend_registry.rb', line 39

def available?(name)
  key = name.to_sym
  checker = mutex.synchronize do
    return availability_cache[key] if availability_cache.key?(key)

    availability_checkers[key]
  end
  return false unless checker

  result = checker.call ? true : false
  mutex.synchronize { availability_cache[key] = result }
  result
rescue StandardError
  false
end

.clear! ⇒ Object 



132
133
134
135
136
137
138
139
 
# File 'lib/tree_haver/backend_registry.rb', line 132

def clear!
  mutex.synchronize do
    backends.clear
    availability_checkers.clear
    availability_cache.clear
    tag_registry.clear
  end
end

.clear_cache! ⇒ Object 



127
128
129
130
 
# File 'lib/tree_haver/backend_registry.rb', line 127

def clear_cache!
  mutex.synchronize { availability_cache.clear }
  nil
end

.fetch(id) ⇒ Object 



16
17
18
19
 
# File 'lib/tree_haver/backend_registry.rb', line 16

def fetch(id)
  data = mutex.synchronize { backends[id] }
  data && BackendReference.new(**deep_dup(data))
end

.register(backend) ⇒ Object 



9
10
11
12
13
14
 
# File 'lib/tree_haver/backend_registry.rb', line 9

def register(backend)
  mutex.synchronize do
    backends[backend.id] = deep_dup(backend.to_h)
  end
  nil
end

.register_availability_checker(name, checker = nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/tree_haver/backend_registry.rb', line 27

def register_availability_checker(name, checker = nil, &block)
  callable = checker || block
  raise ArgumentError, 'Must provide a checker callable or block' unless callable
  raise ArgumentError, 'Checker must respond to #call' unless callable.respond_to?(:call)

  mutex.synchronize do
    availability_checkers[name.to_sym] = callable
    availability_cache.delete(name.to_sym)
  end
  nil
end

.register_tag(tag_name, category:, backend_name: nil, require_path: nil, checker: nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/tree_haver/backend_registry.rb', line 55

def register_tag(tag_name, category:, backend_name: nil, require_path: nil, checker: nil, &block)
  callable = checker || block
  raise ArgumentError, 'Must provide a checker callable or block' unless callable
  raise ArgumentError, 'Checker must respond to #call' unless callable.respond_to?(:call)
  raise ArgumentError, "Invalid category: #{category}" unless CATEGORIES.include?(category)

  tag = tag_name.to_sym
  backend = backend_name || inferred_backend_name(tag)

  mutex.synchronize do
    tag_registry[tag] = {
      category: category,
      backend_name: backend.to_sym,
      require_path: require_path,
      checker: callable
    }
    availability_checkers[backend.to_sym] = callable
    availability_cache.delete(backend.to_sym)
  end

  define_availability_method(backend.to_sym, tag)
  nil
end

.registered?(name) ⇒ Boolean

Returns:

  • (Boolean) 


79
80
81
 
# File 'lib/tree_haver/backend_registry.rb', line 79

def registered?(name)
  mutex.synchronize { availability_checkers.key?(name.to_sym) }
end

.registered_backends ⇒ Object 



83
84
85
 
# File 'lib/tree_haver/backend_registry.rb', line 83

def registered_backends
  mutex.synchronize { availability_checkers.keys.dup }
end

.registered_tags ⇒ Object 



87
88
89
 
# File 'lib/tree_haver/backend_registry.rb', line 87

def registered_tags
  mutex.synchronize { tag_registry.keys.dup }
end

.tag_available?(tag_name) ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/tree_haver/backend_registry.rb', line 105

def tag_available?(tag_name)
  tag = tag_name.to_sym
  metadata = mutex.synchronize { tag_registry[tag]&.dup }
  return available?(inferred_backend_name(tag)) unless metadata

  if metadata[:require_path]
    begin
      require metadata[:require_path]
    rescue LoadError
      return false
    end
  end

  available?(metadata[:backend_name])
end

.tag_metadata(tag_name) ⇒ Object 



97
98
99
 
# File 'lib/tree_haver/backend_registry.rb', line 97

def tag_metadata(tag_name)
  mutex.synchronize { tag_registry[tag_name.to_sym]&.dup }
end

.tag_registered?(tag_name) ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
 
# File 'lib/tree_haver/backend_registry.rb', line 101

def tag_registered?(tag_name)
  mutex.synchronize { tag_registry.key?(tag_name.to_sym) }
end

.tag_summary ⇒ Object 



121
122
123
124
125
 
# File 'lib/tree_haver/backend_registry.rb', line 121

def tag_summary
  registered_tags.each_with_object({}) do |tag, summary|
    summary[tag] = tag_available?(tag)
  end
end

.tags_by_category(category) ⇒ Object 



91
92
93
94
95
 
# File 'lib/tree_haver/backend_registry.rb', line 91

def tags_by_category(category)
  mutex.synchronize do
    tag_registry.select { |_, metadata| metadata[:category] == category }.keys
  end
end