json-ld 2.0.0.1 → 2.1.0

data/lib/json/ld/from_rdf.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'rdf/nquads'
 
 module JSON::LD
@@ -9,8 +11,10 @@ module JSON::LD
     # Representation is in expanded form
     #
     # @param [Array<RDF::Statement>, RDF::Enumerable] input
+    # @param [Boolean] useRdfType (false)
+    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @return [Array<Hash>] the JSON-LD document in normalized form
-    def from_statements(input)
+    def from_statements(input, useRdfType: false)
       default_graph = {}
       graph_map = {'@default' => default_graph}
       node_usages_map = {}
@@ -22,7 +26,7 @@ module JSON::LD
 
       # For each triple in input
       input.each do |statement|
-        log_debug("statement") { statement.to_nquads.chomp}
+        #log_debug("statement") { statement.to_nquads.chomp}
 
         name = statement.graph_name ? ec.expand_iri(statement.graph_name).to_s : '@default'
         
@@ -38,13 +42,13 @@ module JSON::LD
           statement.object.literal?
 
         # If predicate equals rdf:type, and object is an IRI or blank node identifier, append object to the value of the @type member of node. If no such member exists, create one and initialize it to an array whose only item is object. Finally, continue to the next RDF triple.
-        if statement.predicate == RDF.type && statement.object.resource? && !@options[:useRdfType]
+        if statement.predicate == RDF.type && statement.object.resource? && !useRdfType
           merge_value(node, '@type', statement.object.to_s)
           next
         end
 
         # Set value to the result of using the RDF to Object Conversion algorithm, passing object and use native types.
-        value = ec.expand_value(nil, statement.object, @options)
+        value = ec.expand_value(nil, statement.object, useNativeTypes: @options[:useNativeTypes], log_depth: @options[:log_depth])
 
         merge_value(node, statement.predicate.to_s, value)
 
@@ -71,7 +75,7 @@ module JSON::LD
           list, list_nodes = [], []
 
           # If property equals rdf:rest, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Continue with the following steps:
-          log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
+          #log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
           while property == RDF.rest.to_s &&
               node_usages_map[node['@id']].uniq.length == 1 &&
               blank_node?(node) &&
@@ -118,7 +122,7 @@ module JSON::LD
         node.delete(:usages)
         result << node unless node_reference?(node)
       end
-      log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
+      #log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
       result
     end
   end

data/lib/json/ld/reader.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   ##
   # A JSON-LD parser in Ruby.

data/lib/json/ld/resource.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   # Simple Ruby reflector class to provide native
   # access to JSON-LD objects

data/lib/json/ld/streaming_writer.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   ##
   # Streaming writer interface.
@@ -17,7 +19,7 @@ module JSON::LD
       else Context.new.parse(@options[:context])
       end
 
-      log_debug("prologue") {"context: #{context.inspect}"}
+      #log_debug("prologue") {"context: #{context.inspect}"}
       if context
         @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
       else
@@ -37,7 +39,7 @@ module JSON::LD
     #
     # @return [void] `self`
     def stream_statement(statement)
-      log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
+      #log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
       if @current_graph != statement.graph_name
         end_graph
         start_graph(statement.graph_name)
@@ -72,7 +74,7 @@ module JSON::LD
     # Complete open statements
     # @return [void] `self`
     def stream_epilogue
-      log_debug("epilogue") {"state: #{@state.inspect}"}
+      #log_debug("epilogue") {"state: #{@state.inspect}"}
       end_graph
       if context
         @output.puts "\n]}"
@@ -85,7 +87,7 @@ module JSON::LD
     private
     
     def start_graph(resource)
-      log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
+      #log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
       if resource
         @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
         @output.puts %({"@id": "#{resource}", "@graph": [)
@@ -95,7 +97,7 @@ module JSON::LD
     end
 
     def end_graph
-      log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
+      #log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
       end_node
       if @current_graph
         @output.write %(]})
@@ -104,7 +106,7 @@ module JSON::LD
     end
 
     def end_node
-      log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
+      #log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
       @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
       if @current_node_def
         node_def = if context

data/lib/json/ld/to_rdf.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'rdf'
 require 'rdf/nquads'
 
@@ -38,14 +40,14 @@ module JSON::LD
       end
 
       subject = item['@id'] ? as_resource(item['@id']) : node
-      log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
+      #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
       item.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 |v|
             object = as_resource(v)
-            log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
+            #log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
             yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name)
           end
         when '@graph'
@@ -57,11 +59,11 @@ module JSON::LD
           raise "Huh?" unless values.is_a?(Hash)
           values.each do |prop, vv|
             predicate = as_resource(prop)
-            log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+            #log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
             # For each item in values
             vv.each do |v|
               if list?(v)
-                log_debug("item_to_rdf")  {"list: #{v.inspect}"}
+                #log_debug("item_to_rdf")  {"list: #{v.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(v['@list'], graph_name: graph_name, &block)
 
@@ -70,7 +72,7 @@ module JSON::LD
               else
                 # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
                 object = item_to_rdf(v, graph_name: graph_name, &block)
-                log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+                #log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
                 # yield subject, prediate, and literal to results.
                 yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
               end
@@ -82,12 +84,12 @@ module JSON::LD
           # Otherwise, property is an IRI or Blank Node identifier
           # Initialize predicate from  property as an IRI or Blank node
           predicate = as_resource(property)
-          log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+          #log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
 
           # For each item in values
           values.each do |v|
             if list?(v)
-              log_debug("item_to_rdf")  {"list: #{v.inspect}"}
+              #log_debug("item_to_rdf")  {"list: #{v.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(v['@list'], graph_name: graph_name, &block)
 
@@ -96,7 +98,7 @@ module JSON::LD
             else
               # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
               object = item_to_rdf(v, graph_name: graph_name, &block)
-              log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
+              #log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
               # yield subject, prediate, and literal to results.
               yield RDF::Statement(subject, predicate, object, graph_name: graph_name)
             end
@@ -117,7 +119,7 @@ module JSON::LD
     # @return [Array<RDF::Statement>]
     #   Statements for each item in the list
     def parse_list(list, graph_name: nil, &block)
-      log_debug('parse_list') {"list: #{list.inspect}"}
+      #log_debug('parse_list') {"list: #{list.inspect}"}
 
       last = list.pop
       result = first_bnode = last ? node : RDF.nil

data/lib/json/ld/utils.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   module Utils
     ##

data/lib/json/ld/version.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD::VERSION
   VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
   MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chomp.split(".")

data/lib/json/ld/writer.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'json/ld/streaming_writer'
 module JSON::LD
   ##

data/spec/context_spec.rb

@@ -92,6 +92,27 @@ describe JSON::LD::Context do
           expect(ec.provided_context).to produce(ctx, logger)
         end
       end
+
+      context "pre-loaded remote" do
+        let(:ctx) {"http://example.com/preloaded"}
+        before(:all) {
+          JSON::LD::Context.add_preloaded("http://example.com/preloaded",
+          JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+        )}
+        after(:all) {JSON::LD::Context::PRELOADED.clear}
+
+        it "does not load referenced context" do
+          expect(JSON::LD::API).not_to receive(:documentLoader).with(ctx, anything)
+          ec = subject.parse(ctx)
+        end
+
+        it "uses loaded context" do
+          ec = subject.parse(ctx)
+          expect(ec.send(:mappings)).to produce({
+            "foo"   => "http://example.com/"
+          }, logger)
+        end
+      end
     end
 
     context "Array" do
@@ -356,6 +377,7 @@ describe JSON::LD::Context do
           "@language" => "en"
         }
       }, logger)
+      expect(subject.to_rb).not_to be_empty
     end
 
     it "@vocab" do
@@ -365,16 +387,18 @@ describe JSON::LD::Context do
           "@vocab" => "http://example.com/"
         }
       }, logger)
+      expect(subject.to_rb).not_to be_empty
     end
 
     it "term mappings" do
-      expect(subject.
-        parse({'foo' => "http://example.com/"}).send(:clear_provided_context).
-        serialize).to produce({
+      c = subject.
+        parse({'foo' => "http://example.com/"}).send(:clear_provided_context)
+      expect(c.serialize).to produce({
         "@context" => {
           "foo" => "http://example.com/"
         }
       }, logger)
+      expect(c.to_rb).not_to be_empty
     end
 
     it "@type with dependent prefixes in a single context" do
@@ -1332,4 +1356,50 @@ describe JSON::LD::Context do
       expect(subject.reverse_term('reverse')).to eql subject.term_definitions['ex']
     end
   end
+
+  describe JSON::LD::Context::TermDefinition do
+    context "with nothing" do
+      subject {described_class.new("term")}
+      its(:term) {is_expected.to eq "term"}
+      its(:id) {is_expected.to be_nil}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term"))}
+    end
+
+    context "with id" do
+      subject {described_class.new("term", id: "http://example.org/term")}
+      its(:term) {is_expected.to eq "term"}
+      its(:id) {is_expected.to eq "http://example.org/term"}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", id: "http://example.org/term"))}
+    end
+
+    context "with type_mapping" do
+      subject {described_class.new("term", type_mapping: "http://example.org/type")}
+      its(:type_mapping) {is_expected.to eq "http://example.org/type"}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", type_mapping: "http://example.org/type"))}
+    end
+
+    context "with container_mapping" do
+      subject {described_class.new("term", container_mapping: "@set")}
+      its(:container_mapping) {is_expected.to eq "@set"}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", container_mapping: "@set"))}
+    end
+
+    context "with language_mapping" do
+      subject {described_class.new("term", language_mapping: "en")}
+      its(:language_mapping) {is_expected.to eq "en"}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", language_mapping: "en"))}
+    end
+
+    context "with reverse_property" do
+      subject {described_class.new("term", reverse_property: true)}
+      its(:reverse_property) {is_expected.to be_truthy}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", reverse_property: true))}
+    end
+
+    context "with simple" do
+      subject {described_class.new("term", simple: true)}
+      its(:simple) {is_expected.to be_truthy}
+      its(:to_rb) {is_expected.to eq %(TermDefinition.new("term", simple: true))}
+    end
+  end
 end

data/spec/frame_spec.rb

@@ -512,7 +512,7 @@ describe JSON::LD::API do
       end
     end
 
-    describe "@reverse", skip:true do
+    describe "@reverse" do
       {
         "embed matched frames with @reverse" => {
           frame: {
@@ -550,6 +550,44 @@ describe JSON::LD::API do
             }]
           }
         },
+        "embed matched frames with reversed property" => {
+          frame: {
+            "@context" => {
+              "ex" => "http://example.org/",
+              "excludes" => {"@reverse" => "ex:includes"}
+            },
+            "@type" => "ex:Type1",
+            "excludes" => {}
+          },
+          input: [
+            {
+              "@context" => {"ex" => "http://example.org/"},
+              "@id" => "ex:Sub1",
+              "@type" => "ex:Type1"
+            },
+            {
+              "@context" => {"ex" => "http://example.org/"},
+              "@id" => "ex:Sub2",
+              "@type" => "ex:Type2",
+              "ex:includes" => {"@id" => "ex:Sub1"}
+            },
+          ],
+          output:{
+            "@context" => {
+              "ex" => "http://example.org/",
+              "excludes" => {"@reverse" => "ex:includes"}
+            },
+            "@graph" => [{
+              "@id" => "ex:Sub1",
+              "@type" => "ex:Type1",
+              "excludes" => {
+                "@id" => "ex:Sub2",
+                "@type" => "ex:Type2",
+                "ex:includes" => {"@id" => "ex:Sub1"}
+              }
+            }]
+          }
+        },
       }.each do |title, params|
         it title do
           begin
@@ -583,5 +621,63 @@ describe JSON::LD::API do
       data = framed["@graph"].first
       expect(data["mising_value"]).to be_nil
     end
+
+    it "issue #28" do
+      input = JSON.parse %({
+        "@context": {
+          "rdfs": "http://www.w3.org/2000/01/rdf-schema#"
+        },
+        "@id": "http://www.myresource/uuid",
+        "http://www.myresource.com/ontology/1.0#talksAbout": [
+          {
+            "@id": "http://rdf.freebase.com/ns/m.018w8",
+            "rdfs:label": [
+              {
+                "@value": "Basketball",
+                "@language": "en"
+              }
+            ]
+          }
+        ]
+      })
+      frame = JSON.parse %({
+        "@context": {
+          "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+          "talksAbout": {
+            "@id": "http://www.myresource.com/ontology/1.0#talksAbout",
+            "@type": "@id"
+          },
+          "label": {
+            "@id": "rdfs:label",
+            "@language": "en"
+          }
+        },
+        "@id": "http://www.myresource/uuid"
+      })
+      expected = JSON.parse %({
+        "@context": {
+          "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+          "talksAbout": {
+            "@id": "http://www.myresource.com/ontology/1.0#talksAbout",
+            "@type": "@id"
+          },
+          "label": {
+            "@id": "rdfs:label",
+            "@language": "en"
+          }
+        },
+        "@graph": [
+          {
+            "@id": "http://www.myresource/uuid",
+            "talksAbout": {
+              "@id": "http://rdf.freebase.com/ns/m.018w8",
+              "label": "Basketball"
+            }
+          }
+        ]
+      })
+      framed = JSON::LD::API.frame(input, frame, logger: logger)
+      expect(framed).to produce(expected, logger)
+    end
   end
 end