Module: JSON::LD::ToRDF
Instance Method Summary collapse
- #graph_to_rdf(active_graph) {|statement| ... } ⇒ Object
-
#node ⇒ Object
Create a new named node using the sequence.
-
#parse_list(list) {|statement| ... } ⇒ Array<RDF::Statement>
Parse a List.
-
#parse_object(item) ⇒ RDF::Value
Parse an item, either a value object or a node definition.
Methods included from Utils
#as_resource, #blank_node?, #index?, #list?, #node?, #node_reference?, #value?
Instance Method Details
#graph_to_rdf(active_graph) {|statement| ... } ⇒ Object
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
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
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 |