json-ld 3.1.3 → 3.1.8

data/lib/json/ld/streaming_writer.rb

@@ -64,8 +64,8 @@ module JSON::LD
           {"@value" => MultiJson.load(statement.object.to_s), "@type" => "@json"}
         else
           lit = {"@value" => statement.object.to_s}
-          lit["@type"] = statement.object.datatype.to_s if statement.object.has_datatype?
-          lit["@language"] = statement.object.language.to_s if statement.object.has_language?
+          lit["@type"] = statement.object.datatype.to_s if statement.object.datatype?
+          lit["@language"] = statement.object.language.to_s if statement.object.language?
           lit
         end
       end
@@ -91,7 +91,7 @@ module JSON::LD
     def start_graph(resource)
       #log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
       if resource
-        @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
+        @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
         @output.puts %({"@id": "#{resource}", "@graph": [)
         @state = :in_graph
       end
@@ -109,7 +109,7 @@ module JSON::LD
 
     def end_node
       #log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
-      @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
+      @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
       if @current_node_def
         node_def = if context
           compacted = JSON::LD::API.compact(@current_node_def, context, rename_bnodes: false, **@options)

data/lib/json/ld/to_rdf.rb

@@ -16,6 +16,8 @@ module JSON::LD
     # @return RDF::Resource the subject of this item
     def item_to_rdf(item, graph_name: nil, &block)
       # Just return value object as Term
+      return unless item
+
       if value?(item)
         value, datatype = item.fetch('@value'), item.fetch('@type', nil)
 
@@ -46,7 +48,7 @@ module JSON::LD
           # Only valid for rdf:JSON
           value = value.to_json_c14n
         else
-          if item.has_key?('@direction') && @options[:rdfDirection]
+          if item.key?('@direction') && @options[:rdfDirection]
             # Either serialize using a datatype, or a compound-literal
             case @options[:rdfDirection]
             when 'i18n-datatype'
@@ -61,7 +63,7 @@ module JSON::LD
           end
 
           # 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
+          datatype ||= item.key?('@language') ? RDF.langString : RDF::XSD.string
           if datatype == RDF::URI(RDF.to_uri + "JSON")
             value = value.to_json_c14n
           end
@@ -76,11 +78,13 @@ module JSON::LD
         return parse_list(item['@list'], graph_name: graph_name, &block)
       end
 
-      # Skip if '@id' is nil
-      subject = if item.has_key?('@id')
-        item['@id'].nil? ? nil : as_resource(item['@id'])
-      else
-        node
+      subject = case item['@id']
+      when nil then node
+      when String then as_resource(item['@id'])
+      when Object
+        # Embedded statement
+        # (No error checking, as this is done in expansion)
+        to_enum(:item_to_rdf, item['@id']).to_a.first
       end
 
       #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}

data/lib/json/ld/utils.rb

@@ -11,8 +11,8 @@ module JSON::LD
     # @return [Boolean]
     def node?(value)
       value.is_a?(Hash) &&
-        !(value.has_key?('@value') || value.has_key?('@list') || value.has_key?('@set')) &&
-        (value.length > 1 || !value.has_key?('@id'))
+        !(value.key?('@value') || value.key?('@list') || value.key?('@set')) &&
+        (value.length > 1 || !value.key?('@id'))
     end
 
     ##
@@ -29,7 +29,7 @@ module JSON::LD
     # @return [Boolean]
     def node_or_ref?(value)
       value.is_a?(Hash) &&
-        !(value.has_key?('@value') || value.has_key?('@list') || value.has_key?('@set'))
+        !(value.key?('@value') || value.key?('@list') || value.key?('@set'))
     end
 
     ##
@@ -66,7 +66,7 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def simple_graph?(value)
-      graph?(value) && !value.has_key?('@id')
+      graph?(value) && !value.key?('@id')
     end
     
     ##
@@ -75,7 +75,7 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def list?(value)
-      value.is_a?(Hash) && value.has_key?('@list')
+      value.is_a?(Hash) && value.key?('@list')
     end
 
     ##
@@ -84,7 +84,7 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def index?(value)
-      value.is_a?(Hash) && value.has_key?('@index')
+      value.is_a?(Hash) && value.key?('@index')
     end
 
     ##
@@ -93,7 +93,7 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def value?(value)
-      value.is_a?(Hash) && value.has_key?('@value')
+      value.is_a?(Hash) && value.key?('@value')
     end
 
     ##
@@ -170,7 +170,7 @@ module JSON::LD
         end
       elsif subject[property]
         # check if subject already has value if duplicates not allowed
-        _has_value = !allow_duplicate && has_value(subject, property, value)
+        _has_value = !allow_duplicate && has_value?(subject, property, value)
 
         # make property an array if value not present or always an array
         if !subject[property].is_a?(Array) && (!_has_value || property_is_array)
@@ -188,7 +188,7 @@ module JSON::LD
     # @param property the property to look for.
     # 
     # @return [Boolean] true if the subject has the given property, false if not.
-    def has_property(subject, property)
+    def property?(subject, property)
       return false unless value = subject[property]
       !value.is_a?(Array) || !value.empty?
     end
@@ -200,8 +200,8 @@ module JSON::LD
     # @param [Object] value the value to check.
     # 
     # @return [Boolean] true if the value exists, false if not.
-    def has_value(subject, property, value)
-      if has_property(subject, property)
+    def has_value?(subject, property, value)
+      if property?(subject, property)
         val = subject[property]
         is_list = list?(val)
         if val.is_a?(Array) || is_list
@@ -265,7 +265,7 @@ module JSON::LD
     # @return [String]
     def get_sym(old = "")
       old = old.to_s.sub(/_:/, '')
-      if old && self.has_key?(old)
+      if old && self.key?(old)
         self[old]
       elsif !old.empty?
         self[old] = RDF::Node.new.to_unique_base[2..-1]
@@ -289,7 +289,7 @@ module JSON::LD
     # @return [String]
     def get_sym(old = "")
       old = old.to_s.sub(/_:/, '')
-      if !old.empty? && self.has_key?(old)
+      if !old.empty? && self.key?(old)
         self[old]
       elsif !old.empty?
         @num += 1

data/lib/json/ld/writer.rb

@@ -93,7 +93,7 @@ module JSON::LD
           datatype: RDF::URI,
           control: :url2,
           on: ["--context CONTEXT"],
-          description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+          description: "Context to use when compacting.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))},
         RDF::CLI::Option.new(
           symbol: :embed,
           datatype: %w(@always @once @never),
@@ -107,6 +107,13 @@ module JSON::LD
           control: :checkbox,
           on: ["--[no-]explicit"],
           description: "Only include explicitly declared properties in output (false)") {|arg| arg},
+        RDF::CLI::Option.new(
+          symbol: :frame,
+          datatype: RDF::URI,
+          control: :url2,
+          use: :required,
+          on: ["--frame FRAME"],
+          description: "Frame to use when serializing.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))},
         RDF::CLI::Option.new(
           symbol: :lowercaseLanguage,
           datatype: TrueClass,
@@ -137,7 +144,7 @@ module JSON::LD
           default: 'null',
           control: :select,
           on: ["--rdf-direction DIR", %w(i18n-datatype compound-literal)],
-          description: "How to serialize literal direction (i18n-datatype compound-literal)") {|arg| RDF::URI(arg)},
+          description: "How to serialize literal direction (i18n-datatype compound-literal)") {|arg| arg},
         RDF::CLI::Option.new(
           symbol: :requireAll,
           datatype: TrueClass,
@@ -202,7 +209,7 @@ module JSON::LD
     end
 
     ##
-    # Initializes the RDF-LD writer instance.
+    # Initializes the JSON-LD writer instance.
     #
     # @param  [IO, File] output
     #   the output stream
@@ -230,8 +237,8 @@ module JSON::LD
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
     def initialize(output = $stdout, **options, &block)
-      options[:base_uri] ||= options[:base] if options.has_key?(:base)
-      options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
+      options[:base_uri] ||= options[:base] if options.key?(:base)
+      options[:base] ||= options[:base_uri] if options.key?(:base_uri)
       super do
         @repo = RDF::Repository.new
 

data/spec/api_spec.rb

@@ -44,7 +44,7 @@ describe JSON::LD::API do
   end
 
   context "Test Files" do
-    %w(oj json_gem ok_json yajl).map(&:to_sym).each do |adapter|
+    %i(oj json_gem ok_json yajl).each do |adapter|
       context "with MultiJson adapter #{adapter.inspect}" do
         Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
           test = File.basename(filename).sub(/-input\..*$/, '')

data/spec/compact_spec.rb

@@ -3113,6 +3113,210 @@ describe JSON::LD::API do
     end
   end
 
+  context "JSON-LD*" do
+    {
+      "subject-iii": {
+        input: %([{
+          "@id": {
+            "@id": "http://example/s1",
+            "http://example/p1": [{"@id": "http://example/o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+         "@context": {"ex": "http://example/"},
+         "@id": {
+           "@id": "ex:s1",
+           "ex:p1": {"@id": "ex:o1"}
+         },
+         "ex:p": {"@id": "ex:o"}
+       })
+      },
+      "subject-iib": {
+        input: %([{
+          "@id": {
+            "@id": "http://example/s1",
+            "http://example/p1": [{"@id": "_:o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "ex:s1",
+            "ex:p1": {"@id": "_:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-iil": {
+        input: %([{
+          "@id": {
+            "@id": "http://example/s1",
+            "http://example/p1": [{"@value": "o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "ex:s1",
+            "ex:p1": "o1"
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bii": {
+        input: %([{
+          "@id": {
+            "@id": "_:s1",
+            "http://example/p1": [{"@id": "http://example/o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": {"@id": "ex:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bib": {
+        input: %([{
+          "@id": {
+            "@id": "_:s1",
+            "http://example/p1": [{"@id": "_:o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": {"@id": "_:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bil": {
+        input: %([{
+          "@id": {
+            "@id": "_:s1",
+            "http://example/p1": [{"@value": "o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": "o1"
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "object-iii":  {
+        input: %([{
+          "@id": "http://example/s",
+          "http://example/p": [{
+            "@id": {
+              "@id": "http://example/s1",
+              "http://example/p1": [{"@id": "http://example/o1"}]
+            }
+          }]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": {"@id": "ex:o1"}
+            }
+          }
+        })
+      },
+      "object-iib":  {
+        input: %([{
+          "@id": "http://example/s",
+          "http://example/p": [{
+            "@id": {
+              "@id": "http://example/s1",
+              "http://example/p1": [{"@id": "_:o1"}]
+            }
+          }]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": {"@id": "_:o1"}
+            }
+          }
+        })
+      },
+      "object-iil":  {
+        input: %([{
+          "@id": "http://example/s",
+          "http://example/p": [{
+            "@id": {
+              "@id": "http://example/s1",
+              "http://example/p1": [{"@value": "o1"}]
+            }
+          }]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": "o1"
+            }
+          }
+        })
+      },
+      "recursive-subject": {
+        input: %([{
+          "@id": {
+            "@id": {
+              "@id": "http://example/s2",
+              "http://example/p2": [{"@id": "http://example/o2"}]
+            },
+            "http://example/p1": [{"@id": "http://example/o1"}]
+          },
+          "http://example/p": [{"@id": "http://example/o"}]
+        }]),
+        context: %({"ex": "http://example/"}),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": {
+              "@id": "ex:s2",
+              "ex:p2": {"@id": "ex:o2"}
+            },
+            "ex:p1": {"@id": "ex:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+    }.each do |name, params|
+      it(name) {run_compact(params.merge(rdfstar: true))}
+    end
+  end
 
   context "problem cases" do
     {
@@ -3185,7 +3389,7 @@ describe JSON::LD::API do
     input = ::JSON.parse(input) if input.is_a?(String)
     output = ::JSON.parse(output) if output.is_a?(String)
     context = ::JSON.parse(context) if context.is_a?(String)
-    context = context['@context'] if context.has_key?('@context')
+    context = context['@context'] if context.key?('@context')
     pending params.fetch(:pending, "test implementation") unless input
     if params[:exception]
       expect {JSON::LD::API.compact(input, context, logger: logger, **params)}.to raise_error(params[:exception])
@@ -3200,8 +3404,8 @@ describe JSON::LD::API do
       expect(jld).to produce_jsonld(output, logger)
 
       # Compare expanded jld/output too to make sure list values remain ordered
-      exp_jld = JSON::LD::API.expand(jld, processingMode: 'json-ld-1.1')
-      exp_output = JSON::LD::API.expand(output, processingMode: 'json-ld-1.1')
+      exp_jld = JSON::LD::API.expand(jld, processingMode: 'json-ld-1.1', rdfstar: params[:rdfstar])
+      exp_output = JSON::LD::API.expand(output, processingMode: 'json-ld-1.1', rdfstar: params[:rdfstar])
       expect(exp_jld).to produce_jsonld(exp_output, logger)
     end
   end