Class: Glossarist::ReferenceResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/glossarist/reference_resolver.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ReferenceResolver

Returns a new instance of ReferenceResolver.



5
6
7
8
9
10
11
 
# File 'lib/glossarist/reference_resolver.rb', line 5

def initialize
  @local_adapter = nil
  @package_adapters = []
  @bibliography_adapters = []
  @route_adapter = ResolutionAdapter::Route.new
  @remote_adapters = []
end

Instance Method Details

#add_route(from:, to:) ⇒ Object 



26
27
28
 
# File 'lib/glossarist/reference_resolver.rb', line 26

def add_route(from:, to:)
  @route_adapter.add(from: from, to: to)
end

#classify(reference, concept: nil) ⇒ Object 



119
120
121
122
123
124
 
# File 'lib/glossarist/reference_resolver.rb', line 119

def classify(reference, concept: nil)
  return "unknown" unless reference.is_a?(ConceptReference)

  resolved = resolve(reference, concept: concept)
  classify_from_resolution(reference, resolved)
end

#load_collection(collection_dir) ⇒ Object 



106
107
108
109
110
111
112
113
 
# File 'lib/glossarist/reference_resolver.rb', line 106

def load_collection(collection_dir)
  config_path = File.join(collection_dir, "collection.yaml")
  if File.exist?(config_path)
    load_collection_config(config_path, collection_dir)
  else
    load_gcr_directory(collection_dir)
  end
end

#register_bibliography(source_id, concepts) ⇒ Object 



35
36
37
38
 
# File 'lib/glossarist/reference_resolver.rb', line 35

def register_bibliography(source_id, concepts)
  @bibliography_adapters << ResolutionAdapter::Bibliography.new(source_id,
                                                                concepts)
end

#register_package(package_or_concepts, uri_prefix: nil) ⇒ Object

Raises:

  • (ArgumentError) 


17
18
19
20
21
22
23
24
 
# File 'lib/glossarist/reference_resolver.rb', line 17

def register_package(package_or_concepts, uri_prefix: nil)
  concepts = extract_concepts(package_or_concepts)
  prefix = uri_prefix || infer_uri_prefix(package_or_concepts)
  raise ArgumentError, "uri_prefix required" unless prefix

  @package_adapters << ResolutionAdapter::Package.new(concepts,
                                                      uri_prefix: prefix)
end

#register_remote(uri_prefix:, endpoint:) ⇒ Object 



30
31
32
33
 
# File 'lib/glossarist/reference_resolver.rb', line 30

def register_remote(uri_prefix:, endpoint:)
  @remote_adapters << ResolutionAdapter::Remote.new(uri_prefix: uri_prefix,
                                                    endpoint: endpoint)
end

#register_self(concepts) ⇒ Object 



13
14
15
 
# File 'lib/glossarist/reference_resolver.rb', line 13

def register_self(concepts)
  @local_adapter = ResolutionAdapter::Local.new(concepts)
end

#registered_datasets ⇒ Object 



115
116
117
 
# File 'lib/glossarist/reference_resolver.rb', line 115

def registered_datasets
  @package_adapters.map(&:uri_prefix)
end

#resolve(reference, concept: nil) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/glossarist/reference_resolver.rb', line 40

def resolve(reference, concept: nil)
  if concept && reference.is_a?(ConceptReference) && reference.cite?
    source = concept.find_source_by_id(reference.concept_id)
    return source&.origin
  end

  if reference.local?
    return @local_adapter&.resolve(reference)
  end

  routed_ref = apply_routes(reference)

  @bibliography_adapters.each do |adapter|
    result = adapter.resolve(routed_ref)
    return result if result
  end

  @package_adapters.each do |adapter|
    result = adapter.resolve(routed_ref)
    return result if result
  end

  @remote_adapters.each do |adapter|
    result = adapter.resolve(routed_ref)
    return result if result
  end

  nil
end

#resolve_all(concept, extractor: nil) ⇒ Object 



70
71
72
73
74
75
 
# File 'lib/glossarist/reference_resolver.rb', line 70

def resolve_all(concept, extractor: nil)
  extractor ||= ReferenceExtractor.new
  refs = extract_refs(concept, extractor)
  source_concept = concept.is_a?(ManagedConcept) ? concept : nil
  refs.map { |ref| [ref, resolve(ref, concept: source_concept)] }
end

#validate_all(package_or_concepts, extractor: nil, mode: :multi) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/glossarist/reference_resolver.rb', line 77

def validate_all(package_or_concepts, extractor: nil, mode: :multi)
  concepts = extract_concepts(package_or_concepts)
  extractor ||= ReferenceExtractor.new
  result = ValidationResult.new

  concepts.each do |concept|
    refs = extract_refs(concept, extractor)
    termid = extract_termid(concept)
    source_concept = concept.is_a?(ManagedConcept) ? concept : nil

    refs.each do |ref|
      resolved = resolve(ref, concept: source_concept)
      if resolved.nil?
        scope = ref.local? ? "intra-set" : "inter-set (#{ref.source})"
        result.add_warning("#{termid}: Unresolvable #{scope} reference: #{ref.term} -> #{ref.concept_id}")
      end
    end

    if mode == :single && !@local_adapter
      external_refs = refs.select(&:external?)
      if external_refs.any?
        result.add_warning("#{termid}: #{external_refs.size} external reference(s) not checked in single mode")
      end
    end
  end

  result
end