Class: JSON::LD::API
- Inherits:
-
Object
- Object
- JSON::LD::API
- Defined in:
- lib/json/ld/api.rb
Overview
A JSON-LD processor implementing the JsonLdProcessor interface.
This API provides a clean mechanism that enables developers to convert JSON-LD data into a a variety of output formats that are easier to work with in various programming languages. If a JSON-LD API is provided in a programming environment, the entirety of the following API must be implemented.
Instance Attribute Summary collapse
-
#context ⇒ Object
Returns the value of attribute context.
-
#value ⇒ Object
Returns the value of attribute value.
Class Method Summary collapse
-
.compact(input, context, callback = nil, options = {}) {|jsonld| ... } ⇒ Hash
Compacts the given input according to the steps in the Compaction Algorithm.
-
.expand(input, context = nil, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Expands the given input according to the steps in the Expansion Algorithm.
-
.flatten(input, graph, context, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Flattens the given input according to the steps in the Flattening Algorithm.
-
.frame(input, frame, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Frames the given input using the frame according to the steps in the Framing Algorithm.
-
.fromRDF(input, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Take an ordered list of RDF::Statements and turn them into a JSON-LD document.
-
.toRDF(input, context = nil, callback = nil, options = {}) {|statement| ... } ⇒ Object
Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.
Instance Method Summary collapse
-
#initialize(input, context, options = {}) {|api| ... } ⇒ API
constructor
Initialize the API, reading in any document and setting global options.
Methods included from Frame
#cleanup_preserve, #frame, #remove_dependents
Methods included from Utils
#blank_node?, #list?, #node?, #node_reference?, #value?
Methods included from FromTriples
Methods included from Flatten
Methods included from Triples
#add_quad, #node, #parse_list, #statements
Methods included from Compact
Methods included from Expand
Constructor Details
#initialize(input, context, options = {}) {|api| ... } ⇒ API
Initialize the API, reading in any document and setting global options
If set to ‘true`, the JSON-LD processor will use the expanded `rdf:type` IRI as the property instead of `@type` when converting from RDF.
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
# File 'lib/json/ld/api.rb', line 53 def initialize(input, context, = {}, &block) @options = {:compactArrays => true}.merge() @value = case input when Array, Hash then input.dup when IO, StringIO then JSON.parse(input.read) when String content = nil RDF::Util::File.open_file(input) {|f| content = JSON.parse(f.read)} content end @context = EvaluationContext.new() @context = @context.parse(context) if context if block_given? case block.arity when 0, -1 then instance_eval(&block) else block.call(self) end end end |
Instance Attribute Details
#context ⇒ Object
Returns the value of attribute context.
28 29 30 |
# File 'lib/json/ld/api.rb', line 28 def context @context end |
#value ⇒ Object
Returns the value of attribute value.
27 28 29 |
# File 'lib/json/ld/api.rb', line 27 def value @value end |
Class Method Details
.compact(input, context, callback = nil, options = {}) {|jsonld| ... } ⇒ Hash
Compacts the given input according to the steps in the Compaction Algorithm. The input must be copied, compacted and returned if there are no errors. If the compaction fails, an appropirate exception must be thrown.
If no context is provided, the input document is compacted using the top-level context of the document
The resulting ‘Hash` is returned via the provided callback.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 |
# File 'lib/json/ld/api.rb', line 140 def self.compact(input, context, callback = nil, = {}) = result = nil # 1) Perform the Expansion Algorithm on the JSON-LD input. # This removes any existing context to allow the given context to be cleanly applied. = API.(input, nil, nil, .merge(:debug => nil)) API.new(, context, ) do debug(".compact") {"expanded input: #{.to_json(JSON_STATE)}"} result = compact(value, nil) # xxx) Add the given context to the output result = case result when Hash then self.context.serialize.merge(result) when Array kwgraph = self.context.compact_iri('@graph', :quiet => true) self.context.serialize.merge(kwgraph => result) when String kwid = self.context.compact_iri('@id', :quiet => true) self.context.serialize.merge(kwid => result) end end callback.call(result) if callback yield result if block_given? result end |
.expand(input, context = nil, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned if there are no errors. If the expansion fails, an appropriate exception must be thrown.
The resulting ‘Array` is returned via the provided callback.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
# File 'lib/json/ld/api.rb', line 97 def self.(input, context = nil, callback = nil, = {}) result = nil API.new(input, context, ) do |api| result = api.(api.value, nil, api.context) end # If, after the algorithm outlined above is run, the resulting element is an # JSON object with just a @graph property, element is set to the value of @graph's value. result = result['@graph'] if result.is_a?(Hash) && result.keys == %w(@graph) # Finally, if element is a JSON object, it is wrapped into an array. result = [result] unless result.is_a?(Array) callback.call(result) if callback yield result if block_given? result end |
.flatten(input, graph, context, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Flattens the given input according to the steps in the Flattening Algorithm. The input must be flattened and returned if there are no errors. If the flattening fails, an appropriate exception must be thrown.
The resulting ‘Array` is returned via the provided callback.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded. If there is no block, the value will be returned.
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 |
# File 'lib/json/ld/api.rb', line 192 def self.flatten(input, graph, context, callback = nil, = {}) result = nil graph ||= '@merged' # Expand input to simplify processing = API.(input) # Initialize input using frame as context API.new(, nil, ) do debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE)}"} # Generate _nodeMap_ node_map = Hash.ordered self.generate_node_map(value, node_map, (graph.to_s == '@merged' ? '@merged' : '@default'), nil, BlankNodeNamer.new("t")) result = [] # If nodeMap has no property graph, return result, otherwise set definitions to its value. definitions = node_map.fetch(graph.to_s, {}) # Foreach property and valud of definitions definitions.keys.sort.each do |prop| value = definitions[prop] result << value end result end callback.call(result) if callback yield result if block_given? result end |
.frame(input, frame, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Frames the given input using the frame according to the steps in the Framing Algorithm. The input is used to build the framed output and is returned if there are no errors. If there are no matches for the frame, null must be returned. Exceptions must be thrown if there are errors.
The resulting ‘Array` is returned via the provided callback.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 |
# File 'lib/json/ld/api.rb', line 264 def self.frame(input, frame, callback = nil, = {}) result = nil match_limit = 0 framing_state = { :embed => true, :explicit => false, :omitDefault => false, :embeds => nil, } framing_state[:embed] = [:embed] if .has_key?(:embed) framing_state[:explicit] = [:explicit] if .has_key?(:explicit) framing_state[:omitDefault] = [:omitDefault] if .has_key?(:omitDefault) # de-reference frame to create the framing object frame = case frame when Hash then frame.dup when IO, StringIO then JSON.parse(frame.read) when String content = nil RDF::Util::File.open_file(frame) {|f| content = JSON.parse(f.read)} content end # Expand frame to simplify processing = API.(frame) # Expand input to simplify processing = API.(input) # Initialize input using frame as context API.new(, nil, ) do #debug(".frame") {"context from frame: #{context.inspect}"} #debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"} #debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"} # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary all_nodes = Hash.ordered depth do generate_node_map(value, all_nodes, '@merged', nil, BlankNodeNamer.new("t")) end @node_map = all_nodes['@merged'] debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"} result = [] frame(framing_state, @node_map, [0], result, nil) debug(".frame") {"after frame: #{result.to_json(JSON_STATE)}"} # Initalize context from frame @context = depth {@context.parse(frame['@context'])} # Compact result compacted = depth {compact(result, nil)} compacted = [compacted] unless compacted.is_a?(Array) # Add the given context to the output kwgraph = context.compact_iri('@graph', :quiet => true) result = context.serialize.merge({kwgraph => compacted}) debug(".frame") {"after compact: #{result.to_json(JSON_STATE)}"} result = cleanup_preserve(result) end callback.call(result) if callback yield result if block_given? result end |
.fromRDF(input, callback = nil, options = {}) {|jsonld| ... } ⇒ Array<Hash>
Take an ordered list of RDF::Statements and turn them into a JSON-LD document.
The resulting ‘Array` is returned via the provided callback.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
382 383 384 385 386 387 388 389 390 391 392 393 |
# File 'lib/json/ld/api.rb', line 382 def self.fromRDF(input, callback = nil, = {}) = {:useNativeTypes => true}.merge() result = nil API.new(nil, nil, ) do |api| result = api.from_statements(input) end callback.call(result) if callback yield result if block_given? result end |
.toRDF(input, context = nil, callback = nil, options = {}) {|statement| ... } ⇒ Object
Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.
Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
350 351 352 353 354 355 356 357 358 359 360 361 362 363 |
# File 'lib/json/ld/api.rb', line 350 def self.toRDF(input, context = nil, callback = nil, = {}) # 1) Perform the Expansion Algorithm on the JSON-LD input. # This removes any existing context to allow the given context to be cleanly applied. = (input, context, nil, ) API.new(, nil, ) do debug(".expand") {"expanded input: #{value.to_json(JSON_STATE)}"} # Start generating statements statements("", value, nil, nil, nil) do |statement| callback.call(statement) if callback yield statement if block_given? end end end |