Module: RoadForest::Graph::Normalization

Included in:
Application::ServicesHost, GraphFocus, ReadOnlyManager, RemoteHost, RemoteHost::AuthorizationDecider, SourceRigor::GraphStore, SourceRigor::Parcel, TypeHandlers::JSONLD, TypeHandlers::RDFHandler, TypeHandlers::RDFa
Defined in:
lib/roadforest/graph/normalization.rb

Constant Summary collapse

Vocabs = 
{}

Instance Method Summary collapse

Instance Method Details

#expand_curie(from) ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/roadforest/graph/normalization.rb', line 129

def expand_curie(from)
  case from
  when Array
    case from.length
    when 2
      prefix, property = *from
      return interned_uri(expand_curie_pair(prefix.to_s, property.to_s))
    when 1
      return expand_curie(from.first)
    else
      return from
    end
  else
    return from
  end
end

#expand_curie_pair(prefix, property) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/roadforest/graph/normalization.rb', line 108

def expand_curie_pair(prefix, property)
  vocab = Vocabs.fetch(prefix) do
    vocab = RDF::Vocabulary.detect do |vocab|
      unless vocab.__prefix__.is_a? RDF::URI
        Vocabs[vocab.__prefix__.to_s] = vocab
      end
      vocab.__prefix__.to_s == prefix
    end
    #p k => vocab #ok
    if vocab.nil?
      raise "Don't know a vocabulary for prefix #{prefix.inspect} in CURIE #{prefix}:#{property}"
    end
    vocab
  end
  begin
    vocab[property]
  rescue KeyError
    raise KeyError, "No property #{property} in #{vocab.inspect} - (try: #{vocab.methods(false).sort.inspect})"
  end
end

#interned_uri(value) ⇒ Object 



167
168
169
 
# File 'lib/roadforest/graph/normalization.rb', line 167

def interned_uri(value)
  RDF::URI.intern(uri(value))
end

#literal(object) ⇒ Object 



75
76
77
 
# File 'lib/roadforest/graph/normalization.rb', line 75

def literal(object)
  RDF::Literal.new(object)
end

#normalize_context(from) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/roadforest/graph/normalization.rb', line 43

def normalize_context(from)
  case from
  when Array
    from = uri(expand_curie(from))
  when RDF::URI, Addressable::URI, String
    from = uri(from)
  else
    return nil
  end
  from.fragment = nil
  return RDF::URI.intern(from.to_s)
end

#normalize_property(prefix, property = nil) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/roadforest/graph/normalization.rb', line 146

def normalize_property(prefix, property = nil)
  if property.nil?
    property = prefix

    case property
    when Array
      normalize_property(*property)
    when String
      RDF::URI.intern(property)
    else
      property
    end
  else
    expand_curie([prefix, property])
  end
end

#normalize_resource(from) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/roadforest/graph/normalization.rb', line 25

def normalize_resource(from)
  from = expand_curie(from)
  case from
  when nil
    from = RDF::Node.new
  when RDF::Resource
  when /^_:/
    from = RDF::Resource.new(from)
  when String, RDF::URI, Addressable::URI
    from = interned_uri(from)
  when Symbol
    from = RDF::Node.new(from)
  else
    from = RDF::Resource.new(from)
  end
  return from
end

#normalize_statement(subject, predicate, object, context = nil) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
 
# File 'lib/roadforest/graph/normalization.rb', line 9

def normalize_statement(subject, predicate, object, context=nil)
  subject = normalize_resource(subject) || RDF::Node.new
  predicate = normalize_uri(predicate)
  object = normalize_term(object) || RDF::Node.new
  unless context.nil?
    context = normalize_resource(context)
  end

  RDF::Statement.new(subject, predicate, object, :context => context)
end

#normalize_term(object) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/roadforest/graph/normalization.rb', line 67

def normalize_term(object)
  if Array === object
    RDF::Resource.new(expand_curie(object))
  else
    object
  end
end

#normalize_tuple(tuple) ⇒ Object 



20
21
22
23
 
# File 'lib/roadforest/graph/normalization.rb', line 20

def normalize_tuple(tuple)
  subject, predicate, object, context = *tuple
  [ normalize_resource(subject) || RDF::Node.new, normalize_uri(predicate), normalize_term(object) || RDF::Node.new, normalize_resource(context) ]
end

#normalize_uri(from) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
 
# File 'lib/roadforest/graph/normalization.rb', line 56

def normalize_uri(from)
  from = expand_curie(from)
  case from
  when nil
  when RDF::URI
  else
    from = interned_uri(from)
  end
  return from
end

#relevant_prefixes_for_graph(graph) ⇒ Object 



79
80
81
82
83
84
 
# File 'lib/roadforest/graph/normalization.rb', line 79

def relevant_prefixes_for_graph(graph)
  Hash[ vocabularies_in_graph(graph).map do |prefix|
    vocab = Vocabs[prefix]
    [prefix, vocab.to_uri]
  end]
end

#root_url ⇒ Object 



163
164
165
 
# File 'lib/roadforest/graph/normalization.rb', line 163

def root_url
  nil
end

#uri(value) ⇒ Object 



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/roadforest/graph/normalization.rb', line 171

def uri(value)
  if root_url
    value = root_url.join(value)
  else
    value = RDF::URI.new(value)
  end

  if !value.query.nil? and value.query.empty?
    value.query = nil
  end
  value.canonicalize!
  value.validate!

  value
end

#vocabularies_in_graph(graph) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/roadforest/graph/normalization.rb', line 86

def vocabularies_in_graph(graph)
  patterns = Vocabs.map do |prefix, vocab|
    [%r{^#{vocab.to_uri}}, prefix]
  end

  vocabs = {}

  graph.each_statement do |statement|
    statement.to_a.each do |field|
      next unless RDF::URI === field
      field = field.to_s
      patterns.each do |pattern, vocab|
        if pattern =~ field
          vocabs[vocab] = true
        end
      end
    end
  end

  vocabs.keys
end