Module: JSON::LD::ToRDF

Includes:
Utils
Included in:
API
Defined in:
lib/json/ld/to_rdf.rb

Instance Method Summary collapse

Methods included from Utils

#as_resource, #blank_node?, #index?, #list?, #node?, #node_reference?, #value?

Instance Method Details

#graph_to_rdf(active_graph) {|statement| ... } ⇒ Object

Parameters:

  • active_graph (Hash{String => Hash}) —

    A hash of IRI to Node definitions

Yields:

  • statement

Yield Parameters:

  • statement (RDF::Statement) 


14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/json/ld/to_rdf.rb', line 14

def graph_to_rdf(active_graph, &block)
  debug('graph_to_rdf') {"graph_to_rdf: #{active_graph.inspect}"}

  # For each id-node in active_graph
  active_graph.each do |id, node|
    # Initialize subject as the IRI or BNode representation of id
    subject = as_resource(id)
    debug("graph_to_rdf")  {"subject: #{subject.to_ntriples} (id: #{id})"}

    # For each property-values in node
    node.each do |property, values|
      case property
      when '@type'
        # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
        values.each do |value|
          object = as_resource(value)
          debug("graph_to_rdf")  {"type: #{object.to_ntriples}"}
          yield RDF::Statement.new(subject, RDF.type, object)
        end
      when /^@/
        # Otherwise, if @type is any other keyword, skip to the next property-values pair
      else
        # Otherwise, property is an IRI or Blank Node identifier
        # Initialize predicate from  property as an IRI or Blank node
        predicate = as_resource(property)
        debug("graph_to_rdf")  {"predicate: #{predicate.to_ntriples}"}

        # For each item in values
        values.each do |item|
          if item.has_key?('@list')
            debug("graph_to_rdf")  {"list: #{item.inspect}"}
            # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
            object = parse_list(item['@list']) {|stmt| yield stmt}

            # Append a triple composed of subject, prediate, and object to results and add all triples from list_results to results.
            yield RDF::Statement.new(subject, predicate, object)
          else
            # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
            object = parse_object(item)
            debug("graph_to_rdf")  {"object: #{object.to_ntriples}"}
            # Append a triple composed of subject, prediate, and literal to results.
            yield RDF::Statement.new(subject, predicate, object)
          end
        end
      end
    end
  end
end

#node ⇒ Object

Create a new named node using the sequence



133
134
135
 
# File 'lib/json/ld/to_rdf.rb', line 133

def node
  RDF::Node.new(namer.get_sym)
end

#parse_list(list) {|statement| ... } ⇒ Array<RDF::Statement>

Parse a List

Parameters:

  • list (Array) —

    The Array to serialize as a list

Yields:

  • statement

Yield Parameters:

  • statement (RDF::Resource)

Returns:

  • (Array<RDF::Statement>) —

    Statements for each item in the list



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/json/ld/to_rdf.rb', line 109

def parse_list(list)
  debug('parse_list') {"list: #{list.inspect}"}

  last = list.pop
  result = first_bnode = last ? node : RDF.nil

  list.each do |list_item|
    # Set first to the result of the Object Converstion algorithm passing item.
    object = parse_object(list_item)
    yield RDF::Statement.new(first_bnode, RDF.first, object)
    rest_bnode = node
    yield RDF::Statement.new(first_bnode, RDF.rest, rest_bnode)
    first_bnode = rest_bnode
  end
  if last
    object = parse_object(last)
    yield RDF::Statement.new(first_bnode, RDF.first, object)
    yield RDF::Statement.new(first_bnode, RDF.rest, RDF.nil)
  end
  result
end

#parse_object(item) ⇒ RDF::Value

Parse an item, either a value object or a node definition

Parameters:

  • item (Hash)

Returns:

  • (RDF::Value) 


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/json/ld/to_rdf.rb', line 67

def parse_object(item)
  if item.has_key?('@value')
    # Otherwise, if element is a JSON object that contains the key @value
    # Initialize value to the value associated with the @value key in element. Initialize datatype to the value associated with the @type key in element, or null if element does not contain that key.
    value, datatype = item.fetch('@value'), item.fetch('@type', nil)

    case value
    when TrueClass, FalseClass
      # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
      value = value.to_s
      datatype ||= RDF::XSD.boolean.to_s
    when Float, Fixnum
      # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
      lit = RDF::Literal.new(value, :canonicalize => true)
      value = lit.to_s
      datatype ||= lit.datatype
    else
      # Otherwise, if datatype is null, set it to xsd:string or xsd:langString, depending on if item has a @language key.
      datatype ||= item.has_key?('@language') ? RDF.langString : RDF::XSD.string
    end
    datatype = RDF::URI(datatype) if datatype && !datatype.is_a?(RDF::URI)
              
    # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
    language = item.fetch('@language', nil)
    RDF::Literal.new(value, :datatype => datatype, :language => language)
  else
    # Otherwise, value must be a node definition containing only @id whos value is an IRI or Blank Node identifier
    raise "Expected node reference, got #{item.inspect}" unless item.keys == %w(@id)
    # Return value associated with @id as an IRI or Blank node
    as_resource(item['@id'])
  end
end