Class: YAML_LD::API

Inherits:

JSON::LD::API

Object
JSON::LD::API
YAML_LD::API

show all

Defined in:: vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb

Overview

A YAML-LD processor based on JSON-LD.

See Also:

https://www.w3.org/TR/json-ld11-api/#the-application-programming-interface

Author:

Gregg Kellogg

Constant Summary collapse

LINK_REL_CONTEXT = The following constants are used to reduce object allocations

%w(rel http://www.w3.org/ns/yaml-ld#context).freeze

LINK_REL_ALTERNATE =

%w(rel alternate).freeze

LINK_TYPE_JSONLD =

%w(type application/ld+yaml).freeze

Instance Attribute Summary

Attributes inherited from JSON::LD::API

#context, #input, #namer, #value

Class Method Summary collapse

.compact(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ String
Compacts the given input according to the steps in the Compaction Algorithm.
.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options) {|remote_document| ... } ⇒ Object
Default document loader for YAML_LD.
.expand(input, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld, RDF::URI| ... } ⇒ String
Expands the given input according to the steps in the Expansion Algorithm.
.flatten(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ Object, Hash
This algorithm flattens an expanded YAML-LD document by collecting all properties of a node in a single object and labeling all blank nodes with blank node identifiers.
.frame(input, frame, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ Object, Hash
Frames the given input using the frame according to the steps in the Framing Algorithm.
.fromRdf(input, useRdfType: false, useNativeTypes: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|jsonld| ... } ⇒ Object, Hash
Take an ordered list of RDF::Statements and turn them into a JSON-LD document.
.htmlLoader(content, url:, extractAllScripts: false, **options) ⇒ Object
Extracts a single YAML script, or a stream of YAML scripts from HTML script tags.
.serializer(object, *args, **options) ⇒ Object
The default serializer for serialzing Ruby Objects to JSON.
.toRdf(input, expanded: false, documentLoader: self.method(:documentLoader), **options) {|statement| ... } ⇒ RDF::Enumerable
Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.

Methods inherited from JSON::LD::API

add_script_loader, loadRemoteDocument, load_html, validate_input

Methods included from RDF::Util::Logger

#log_debug, #log_depth, #log_error, #log_fatal, #log_info, #log_recover, #log_recovering?, #log_statistics, #log_warn, #logger

Methods included from JSON::LD::Frame

#cleanup_null, #cleanup_preserve, #count_blank_node_identifiers, #count_blank_node_identifiers_internal, #frame, #prune_bnodes, #remove_dependents

Methods included from JSON::LD::Utils

#add_value, #as_array, #as_resource, #blank_node?, #compare_values, #graph?, #has_value?, #index?, #list?, #node?, #node_or_ref?, #node_reference?, #property?, #simple_graph?, #value?

Methods included from JSON::LD::FromRDF

#from_statements

Methods included from JSON::LD::Flatten

#create_annotations, #create_node_map, #rename_bnodes

Methods included from JSON::LD::ToRDF

#item_to_rdf, #node, #parse_list

Methods included from JSON::LD::Compact

#compact

Methods included from JSON::LD::Expand

#expand

Class Method Details

.compact(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `String`

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 either returned or yielded, if a block is given.

Parameters:

input (String, #read, Hash, Array) —
The YAML-LD object to copy and perform the expansion upon.
context (String, #read, Hash, Array, JSON::LD::Context) —
The base context to use when compacting the input.
serializer (Proc) (defaults to: self.method(:serializer)) —
(nil) A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via #to_yaml. See serializer.
expanded (Boolean) (defaults to: false) —
(false) Input is already expanded
options (Hash{Symbol => Object})

Options Hash (**options):

:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

YAML_LD

Yield Parameters:

yamlld (Array<Hash>) —
The expanded YAML-LD document

Yield Returns:

(String) —
returned YAML serialization

Returns:

(String) —
If a block is given, the result of evaluating the block is returned, otherwise, the expanded YAML-LD document

Raises:

(JsonLdError)

See Also:

https://www.w3.org/TR/json-ld11-api/#compaction-algorithm

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 112

def self.compact(input, context, expanded: false,
                 documentLoader: self.method(:documentLoader),
                 serializer: self.method(:serializer),
                 **options,
                 &block)
  JSON::LD::API.add_script_loader('application/ld+yaml', self.method(:htmlLoader))
  JSON::LD::API.compact(input, context, expanded: expanded,
                       allowed_content_types: %r(application/(.+\+)?yaml),
                       documentLoader: documentLoader, 
                       extendedRepresentation: options[:extendedYAML],
                       processingMode: 'json-ld-1.1',
                       serializer: serializer,
                       **options,
                       &block)
end

.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options) {|remote_document| ... } ⇒ `Object`

Default document loader for YAML_LD.

Parameters:

url (RDF::URI, String)
extractAllScripts (Boolean) (defaults to: false) —
If set to true, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
profile (String) (defaults to: nil) —
When the resulting contentType is text/html or application/xhtml+xml, this option determines the profile to use for selecting a JSON-LD script elements.
requestProfile (String) (defaults to: nil) —
One or more IRIs to use in the request as a profile parameter.
options (Hash<Symbol => Object>)

Yields:

remote_document

Yield Parameters:

remote_document (RemoteDocument, RDF::Util::File::RemoteDocument)

Raises:

(IOError)

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 298

def self.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options, &block)
  if url.respond_to?(:read)
    base_uri = options[:base]
    base_uri ||= url.base_uri if url.respond_to?(:base_uri)
    content_type = options[:content_type]
    content_type ||= url.content_type if url.respond_to?(:content_type)
    context_url = if url.respond_to?(:links) && url.links &&
      # Any JSON type other than ld+json
      (content_type == 'application/json' || content_type.match?(%r(application/(^ld)+json)))
      link = url.links.find_link(JSON::LD::API::LINK_REL_CONTEXT)
      link.href if link
    elsif  url.respond_to?(:links) && url.links &&
      # Any YAML type
      content_type.match?(%r(application/(\w+\+)*yaml))
      link = url.links.find_link(LINK_REL_CONTEXT)
      link.href if link
    end

    content = case content_type
    when nil, %r(application/(\w+\+)*yaml)
      # Parse YAML
      Representation.load(url.read, filename: url.to_s, **options)
    else
      url.read
    end
    block.call(RemoteDocument.new(content,
      documentUrl: base_uri,
      contentType: content_type,
      contextUrl: context_url))
  elsif url.to_s.match?(/\.yaml\w*$/) || content_type.to_s.match?(%r(application/(\w+\+)*yaml))
    # Parse YAML
    content = Representation.load(RDF::Util::File.open_file(url.to_s).read,
                                         filename: url.to_s,
                                         **options)

    block.call(RemoteDocument.new(content,
      documentUrl: base_uri,
      contentType: content_type,
      contextUrl: context_url))
  else
    RDF::Util::File.open_file(url, **options, &block)
  end
end

.expand(input, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld, RDF::URI| ... } ⇒ `String`

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 either returned or yielded

Parameters:

input (String, #read, Hash, Array) —
The YAML-LD object to copy and perform the expansion upon.
documentLoader (Proc) (defaults to: self.method(:documentLoader)) —
The callback of the loader to be used to retrieve remote documents and contexts, and to parse IO objects. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature. The remote document returned must be parsed if it is YAML.
serializer (Proc) (defaults to: self.method(:serializer)) —
(nil) A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via #to_yaml. See serializer.
options (Hash{Symbol => Object})

Options Hash (**options):

:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

YAML_LD, base_iri

Yield Parameters:

yamlld (Array<Hash>) —
The expanded YAML-LD document
RDF::URI (RDF::URI The document base as determined during expansion) —
The document base as determined during expansion

Yield Returns:

(String) —
returned YAML serialization

Returns:

(String) —
If a block is given, the result of evaluating the block is returned, otherwise, the expanded YAML-LD document

Raises:

(JsonLdError)

See Also:

https://www.w3.org/TR/json-ld11-api/#expansion-algorithm

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 71

def self.expand(input,
                documentLoader: self.method(:documentLoader),
                serializer: self.method(:serializer),
                **options,
                &block)
  JSON::LD::API.add_script_loader('application/ld+yaml', self.method(:htmlLoader))
  JSON::LD::API.expand(input,
                       allowed_content_types: %r(application/(.+\+)?yaml),
                       documentLoader: documentLoader, 
                       extendedRepresentation: options[:extendedYAML],
                       processingMode: 'json-ld-1.1',
                       serializer: serializer,
                       **options,
                       &block)
end

.flatten(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `Object`, `Hash`

This algorithm flattens an expanded YAML-LD document by collecting all properties of a node in a single object and labeling all blank nodes with blank node identifiers. This resulting uniform shape of the document, may drastically simplify the code required to process YAML-LD data in certain applications.

The resulting Array is either returned, or yielded if a block is given.

Parameters:

input (String, #read, Hash, Array) —
The YAML-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
context (String, #read, Hash, Array, JSON::LD::EvaluationContext) —
An optional external context to use additionally to the context embedded in input when expanding the input.
expanded (Boolean) (defaults to: false) —
(false) Input is already expanded
serializer (Proc) (defaults to: self.method(:serializer)) —
(nil) A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via #to_yaml. See serializer.
options (Hash{Symbol => Object})

Options Hash (**options):

:createAnnotations (Boolean) —
Unfold embedded nodes which can be represented using @annotation.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

YAML_LD

Yield Parameters:

yamlld (Array<Hash>) —
The expanded YAML-LD document

Yield Returns:

(String) —
returned YAML serialization

Returns:

(Object, Hash) —
If a block is given, the result of evaluating the block is returned, otherwise, the flattened JSON-LD document

See Also:

https://www.w3.org/TR/json-ld11-api/#framing-algorithm

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 154

def self.flatten(input, context, expanded: false,
                 documentLoader: self.method(:documentLoader),
                 serializer: self.method(:serializer),
                 **options,
                 &block)
  JSON::LD::API.add_script_loader('application/ld+yaml', self.method(:htmlLoader))
  JSON::LD::API.flatten(input, context, expanded: expanded,
                        allowed_content_types: %r(application/(.+\+)?yaml),
                        documentLoader: documentLoader, 
                        extendedRepresentation: options[:extendedYAML],
                        processingMode: 'json-ld-1.1',
                        serializer: serializer,
                        **options,
                        &block)
end

.frame(input, frame, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `Object`, `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 either returned, or yielded if a block is given.

Parameters:

input (String, #read, Hash, Array) —
The YAML-LD object or array of YAML-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
frame (String, #read, Hash, Array) —
The frame to use when re-arranging the data.
expanded (Boolean) (defaults to: false) —
(false) Input is already expanded
options (Hash) —
a customizable set of options

Options Hash (**options):

:embed ('@always', '@link', '@once', '@never') — default: '@once' —
a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.
:explicit (Boolean) — default: false —
a flag specifying that for properties to be included in the output, they must be explicitly declared in the framing context.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:requireAll (Boolean) — default: false —
A flag specifying that all properties present in the input frame must either have a default value or be present in the JSON-LD input for the frame to match.
:omitDefault (Boolean) — default: false —
a flag specifying that properties that are missing from the JSON-LD input should be omitted from the output.
:pruneBlankNodeIdentifiers (Boolean) — default: true —
removes blank node identifiers that are only used once.
:omitGraph (Boolean) —
does not use @graph at top level unless necessary to describe multiple objects, defaults to true if processingMode is 1.1, otherwise false.
:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

YAML_LD

Yield Parameters:

yamlld (Array<Hash>) —
The expanded YAML-LD document

Yield Returns:

(String) —
returned YAML serialization

Returns:

(Object, Hash) —
If a block is given, the result of evaluating the block is returned, otherwise, the framed JSON-LD document

Raises:

(InvalidFrame)

See Also:

https://www.w3.org/TR/json-ld11-api/#framing-algorithm

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 201

def self.frame(input, frame, expanded: false,
               documentLoader: self.method(:documentLoader),
               serializer: self.method(:serializer),
               **options,
               &block)
  JSON::LD::API.add_script_loader('application/ld+yaml', self.method(:htmlLoader))
  JSON::LD::API.frame(input, frame, expanded: expanded,
                      allowed_content_types: %r(application/(.+\+)?yaml),
                      documentLoader: documentLoader, 
                      extendedRepresentation: options[:extendedYAML],
                      processingMode: 'json-ld-1.1',
                      serializer: serializer,
                      **options,
                      &block)
end

.fromRdf(input, useRdfType: false, useNativeTypes: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|jsonld| ... } ⇒ `Object`, `Hash`

Take an ordered list of RDF::Statements and turn them into a JSON-LD document.

The resulting Array is either returned or yielded, if a block is given.

Parameters:

input (RDF::Enumerable)
useRdfType (Boolean) (defaults to: false) —
(false) If set to true, the JSON-LD processor will treat rdf:type like a normal property instead of using @type.
useNativeTypes (Boolean) (defaults to: false) —
(false) use native representations
serializer (Proc) (defaults to: self.method(:serializer)) —
(nil) A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via #to_yaml. See serializer.
options (Hash{Symbol => Object})

Options Hash (**options):

:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

jsonld

Yield Parameters:

jsonld (Hash) —
The JSON-LD document in expanded form

Yield Returns:

(Object) —
returned object

Returns:

(Object, Hash) —
If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 268

def self.fromRdf(input, useRdfType: false, useNativeTypes: false,
                 documentLoader: self.method(:documentLoader),
                 serializer: self.method(:serializer),
                 **options,
                 &block)
  JSON::LD::API.fromRdf(input,
                        allowed_content_types: %r(application/(.+\+)?yaml),
                        documentLoader: documentLoader, 
                        extendedRepresentation: options[:extendedYAML],
                        processingMode: 'json-ld-1.1',
                        serializer: serializer,
                        useRdfType: useRdfType,
                        useNativeTypes: useNativeTypes,
                        **options,
                        &block)
end

.htmlLoader(content, url:, extractAllScripts: false, **options) ⇒ `Object`

Extracts a single YAML script, or a stream of YAML scripts from HTML script tags.

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 344

def self.htmlLoader(content, url:, extractAllScripts: false, **options)
  if extractAllScripts
    Representation.load_stream(content.unindent, filename: url.to_s, **options)
  else
    Representation.load(content, filename: url.to_s, **options)
  end
end

.serializer(object, *args, **options) ⇒ `Object`

The default serializer for serialzing Ruby Objects to JSON.

Defaults to MultiJson.dump

Parameters:

object (Object)
args (Array<Object>) —
other arguments that may be passed for some specific implementation.
options (Hash<Symbol, Object>) —
options passed from the invoking context.

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 362

def self.serializer(object, *args, **options)
  # de-alias any objects to avoid the use of aliases and anchors
  "%YAML 1.2\n" + Representation.dump(object, **options)
end

.toRdf(input, expanded: false, documentLoader: self.method(:documentLoader), **options) {|statement| ... } ⇒ `RDF::Enumerable`

Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.

Parameters:

input (String, #read, Hash, Array) —
The YAML-LD object to process when outputting statements.
expanded (Boolean) (defaults to: false) —
(false) Input is already expanded
options (Hash) —
a customizable set of options

Options Hash (**options):

:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:produceGeneralizedRdf (Boolean) — default: false —
If true, output will include statements having blank node predicates, otherwise they are dropped.
:base (RDF::URI, String, #to_s) —
The Base IRI to use when expanding the document. This overrides the value of input if it is a IRI. If not specified and input is not an IRI, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from input, options[:base] will be modified with this value.
:compactArrays (Boolean) — default: true —
If set to true, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to false, all arrays will remain arrays even if they have just one element.
:compactToRelative (Boolean) — default: true —
Creates document relative IRIs when compacting, if true, otherwise leaves expanded.
:documentLoader (Proc) —
The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See documentLoader for the method signature.
:expandContext (String, #read, Hash, Array, JSON::LD::Context) —
A context that is used to initialize the active context when expanding a document.
:extendedYAML (Boolean) — default: false —
Use the expanded internal representation.
:extractAllScripts (Boolean) —
If set, when given an HTML input without a fragment identifier, extracts all script elements with type application/ld+json into an array during expansion.
:flatten (Boolean, String, RDF::URI) —
If set to a value that is not false, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of flatten must be either an IRI value representing the name of the graph to flatten, or true. If the value is true, then the first graph encountered in the input document is selected and flattened.
:language (String) —
When set, this has the effect of inserting a context definition with @language set to the associated value, creating a default language for interpreting string values.
:lowercaseLanguage (Boolean) —
By default, language tags are left as is. To normalize to lowercase, set this option to true.
:ordered (Boolean) — default: true —
Order traversal of dictionary members by key when performing algorithms.
:rdfstar (Boolean) — default: false —
support parsing JSON-LD-star statement resources.
:rename_bnodes (Boolean) — default: true —
Rename bnodes as part of expansion, or keep them the same.
:unique_bnodes (Boolean) — default: false —
Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
:validate (Boolean) —
Validate input, if a string or readable object.

Yields:

statement

Yield Parameters:

statement (RDF::Statement)

Returns:

(RDF::Enumerable) —
set of statements, unless a block is given.

Raises:

(JsonLdError)

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/yaml-ld-d851238cc6dc/lib/yaml_ld/api.rb', line 232

def self.toRdf(input, expanded: false,
               documentLoader: self.method(:documentLoader),
               **options,
               &block)
  JSON::LD::API.add_script_loader('application/ld+yaml', self.method(:htmlLoader))
  JSON::LD::API.toRdf(input, expanded: expanded,
                      allowed_content_types: %r(application/(.+\+)?yaml),
                      documentLoader: documentLoader, 
                      extendedRepresentation: options[:extendedYAML],
                      processingMode: 'json-ld-1.1',
                      **options,
                      &block)
end

Class: YAML_LD::API

Overview

Constant Summary collapse

Constants inherited from JSON::LD::API

Constants included from RDF::Util::Logger

Constants included from JSON::LD::Compact

Constants included from JSON::LD::Expand

Instance Attribute Summary

Attributes inherited from JSON::LD::API

Class Method Summary collapse

Methods inherited from JSON::LD::API

Methods included from RDF::Util::Logger

Methods included from JSON::LD::Frame

Methods included from JSON::LD::Utils

Methods included from JSON::LD::FromRDF

Methods included from JSON::LD::Flatten

Methods included from JSON::LD::ToRDF

Methods included from JSON::LD::Compact

Methods included from JSON::LD::Expand

Class Method Details

.compact(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ String

.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options) {|remote_document| ... } ⇒ Object

.expand(input, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld, RDF::URI| ... } ⇒ String

.flatten(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ Object, Hash

.frame(input, frame, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ Object, Hash

.fromRdf(input, useRdfType: false, useNativeTypes: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|jsonld| ... } ⇒ Object, Hash

.htmlLoader(content, url:, extractAllScripts: false, **options) ⇒ Object

.serializer(object, *args, **options) ⇒ Object

.toRdf(input, expanded: false, documentLoader: self.method(:documentLoader), **options) {|statement| ... } ⇒ RDF::Enumerable

.compact(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `String`

.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options) {|remote_document| ... } ⇒ `Object`

.expand(input, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld, RDF::URI| ... } ⇒ `String`

.flatten(input, context, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `Object`, `Hash`

.frame(input, frame, expanded: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|yamlld| ... } ⇒ `Object`, `Hash`

.fromRdf(input, useRdfType: false, useNativeTypes: false, documentLoader: self.method(:documentLoader), serializer: self.method(:serializer), **options) {|jsonld| ... } ⇒ `Object`, `Hash`

.htmlLoader(content, url:, extractAllScripts: false, **options) ⇒ `Object`

.serializer(object, *args, **options) ⇒ `Object`

.toRdf(input, expanded: false, documentLoader: self.method(:documentLoader), **options) {|statement| ... } ⇒ `RDF::Enumerable`