json-ld 1.1.8 → 1.1.9

data/lib/json/ld/reader.rb

@@ -6,12 +6,6 @@ module JSON::LD
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class Reader < RDF::Reader
     format Format
-    
-    ##
-    # Override normal symbol generation
-    def self.to_sym
-      :jsonld
-    end
 
     ##
     # Initializes the RDF/JSON reader instance.
@@ -29,12 +23,14 @@ module JSON::LD
         @options[:base] ||= base_uri.to_s if base_uri
         begin
           # Trim non-JSON stuff in script.
-          input = input.read if input.respond_to?(:read)
-          input = input.to_s.sub(%r(\A[^{\[]*)m, '').sub(%r([^}\]]*\Z)m, '') 
-          @doc = JSON.load(input)
+          @doc = if input.respond_to?(:read)
+            input
+          else
+            StringIO.new(input.to_s.sub(%r(\A[^{\[]*)m, '').sub(%r([^}\]]*\Z)m, ''))
+          end
         rescue JSON::ParserError => e
           raise RDF::ReaderError, "Failed to parse input document: #{e.message}" if validate?
-          @doc = JSON.parse("{}")
+          @doc = StringIO.new("{}")
         end
 
         if block_given?
@@ -51,6 +47,8 @@ module JSON::LD
     # @see   RDF::Reader#each_statement
     def each_statement(&block)
       JSON::LD::API.toRdf(@doc, @options, &block)
+    rescue ::JSON::LD::JsonLdError => e
+      raise RDF::ReaderError, e.message
     end
 
     ##

data/lib/json/ld/utils.rb

@@ -10,7 +10,7 @@ module JSON::LD
     def node?(value)
       value.is_a?(Hash) &&
         (value.keys & %w(@value @list @set)).empty? &&
-        !(value.keys - ['@id']).empty?
+        (value.length > 1 || !value.has_key?('@id'))
     end
 
     ##
@@ -78,6 +78,100 @@ module JSON::LD
       end
     end
 
+    ##
+    # Compares two JSON-LD values for equality. Two JSON-LD values will be
+    # considered equal if:
+    # 
+    # 1. They are both primitives of the same type and value.
+    # 2. They are both @values with the same @value, @type, @language,
+    #   and @index, OR
+    # 3. They both have @ids that are the same.
+    # 
+    # @param [Object] v1 the first value.
+    # @param [Object] v2 the second value.
+    # 
+    # @return [Boolean] v1 and v2 are considered equal
+    def compare_values(v1, v2)
+      case
+      when node?(v1) && node?(v2) then v1['@id'] && v1['@id'] == v2['@id']
+      when value?(v1) && value?(v2)
+        v1['@value'] == v2['@value'] &&
+        v1['@type'] == v2['@type'] &&
+        v1['@language'] == v2['@language'] &&
+        v1['@index'] == v2['@index']
+      else
+        v1 == v2
+      end
+    end
+
+    # Adds a value to a subject. If the value is an array, all values in the
+    # array will be added.
+    # 
+    # @param [Hash] subject the hash to add the value to.
+    # @param [String] property the property that relates the value to the subject.
+    # @param [Object] value the value to add.
+    # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean] :property_is_array
+    #   true if the property is always (false)
+    #   an array, false if not.
+    # @option options [Boolean] :allow_duplicate (true)
+    #   true to allow duplicates, false not to (uses
+    #     a simple shallow comparison of subject ID or value).
+    def add_value(subject, property, value, options = {})
+      options = {property_is_array: false, allow_duplicate: true}.merge(options)
+
+      if value.is_a?(Array)
+        subject[property] = [] if value.empty? && options[:property_is_array]
+        value.each {|v| add_value(subject, property, v, options)}
+      elsif subject[property]
+        # check if subject already has value if duplicates not allowed
+        _has_value = !options[: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 || options[:property_is_array])
+          subject[property] = [subject[property]]
+        end
+        subject[property] << value unless _has_value
+      else
+        subject[property] = options[:property_is_array] ? [value] : value
+      end
+    end
+
+    # Returns True if the given subject has the given property.
+    # 
+    # @param subject the subject to check.
+    # @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)
+      return false unless value = subject[property]
+      !value.is_a?(Array) || !value.empty?
+    end
+
+    # Determines if the given value is a property of the given subject.
+    # 
+    # @param [Hash] subject the subject to check.
+    # @param [String] property the property to check.
+    # @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)
+        val = subject[property]
+        is_list = list?(val)
+        if val.is_a?(Array) || is_list
+          val = val['@list'] if is_list
+          val.any? {|v| compare_values(value, v)}
+        elsif !val.is_a?(Array)
+          compare_values(value, val)
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+
     private
 
     # Merge the last value into an array based for the specified key if hash is not null and value is not already in that array
@@ -125,8 +219,14 @@ module JSON::LD
       list = args
       list << yield if block_given?
       message = " " * depth * 2 + (list.empty? ? "" : list.join(": "))
-      puts message if JSON::LD::debug?
-      @options[:debug] << message if @options[:debug].is_a?(Array)
+      case @options[:debug]
+      when Array
+        @options[:debug] << message
+      when TrueClass
+        $stderr.puts message
+      else
+        $stderr.puts message if JSON::LD::debug?
+      end
     end
 
     # Increase depth around a method invocation
@@ -194,7 +294,7 @@ module JSON::LD
     # @return [String]
     def get_sym(old = "")
       old = old.to_s.sub(/_:/, '')
-      if old && self.has_key?(old)
+      if !old.empty? && self.has_key?(old)
         self[old]
       elsif !old.empty?
         @num += 1

data/lib/json/ld/writer.rb

@@ -64,12 +64,6 @@ module JSON::LD
     # @return [Context] context used to load and administer contexts
     attr_reader :context
 
-    ##
-    # Override normal symbol generation
-    def self.to_sym
-      :jsonld
-    end
-
     ##
     # Initializes the RDF-LD writer instance.
     #
@@ -114,16 +108,6 @@ module JSON::LD
       end
     end
 
-    ##
-    # Write whole graph
-    #
-    # @param  [Graph] graph
-    # @return [void]
-    def write_graph(graph)
-      debug {"Add graph #{graph.inspect}"}
-      @repo = graph
-    end
-
     ##
     # Adds a statement to be serialized
     # @param  [RDF::Statement] statement

data/spec/api_spec.rb

@@ -25,9 +25,9 @@ describe JSON::LD::API do
       end
 
       it "loads document with loader and loads context" do
-        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/foo", anything).and_return(remote_doc)
-        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
-        JSON::LD::API.new("http://example.com/foo", nil)
+        expect(described_class).to receive(:documentLoader).with("http://example.com/foo", anything).and_return(remote_doc)
+        expect(described_class).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
+        described_class.new("http://example.com/foo", nil)
       end
     end
 
@@ -52,12 +52,18 @@ describe JSON::LD::API do
       end
 
       it "processes document and retrieves linked context" do
-        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
-        JSON::LD::API.new(remote_doc, nil)
+        expect(described_class).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
+        described_class.new(remote_doc, nil)
       end
     end
   end
 
+  context "when validating", pending: ("JRuby support for jsonlint" if RUBY_ENGINE == "jruby") do
+    it "detects invalid JSON" do
+      expect {described_class.new(StringIO.new(%({"a": "b", "a": "c"})), nil, validate: true)}.to raise_error(JSON::LD::JsonLdError::LoadingDocumentFailed)
+    end
+  end
+
   context "Test Files" do
     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
       test = File.basename(filename).sub(/-input\..*$/, '')
@@ -66,24 +72,23 @@ describe JSON::LD::API do
       compacted = filename.sub(/-input\..*$/, '-compacted.json')
       context = filename.sub(/-input\..*$/, '-context.json')
       expanded = filename.sub(/-input\..*$/, '-expanded.json')
-      automatic = filename.sub(/-input\..*$/, '-automatic.json')
       ttl = filename.sub(/-input\..*$/, '-rdf.ttl')
       
       context test do
         it "expands" do
           options = {debug: @debug}
           options[:expandContext] = File.open(context) if context
-          jld = JSON::LD::API.expand(File.open(filename), options)
+          jld = described_class.expand(File.open(filename), options)
           expect(jld).to produce(JSON.load(File.open(expanded)), @debug)
         end if File.exist?(expanded)
         
         it "compacts" do
-          jld = JSON::LD::API.compact(File.open(filename), File.open(context), debug: @debug)
+          jld = described_class.compact(File.open(filename), File.open(context), debug: @debug)
           expect(jld).to produce(JSON.load(File.open(compacted)), @debug)
         end if File.exist?(compacted) && File.exist?(context)
         
         it "frame" do
-          jld = JSON::LD::API.frame(File.open(filename), File.open(frame), debug: @debug)
+          jld = described_class.frame(File.open(filename), File.open(frame), debug: @debug)
           expect(jld).to produce(JSON.load(File.open(framed)), @debug)
         end if File.exist?(framed) && File.exist?(frame)
 

data/spec/format_spec.rb

@@ -4,12 +4,10 @@ require 'spec_helper'
 require 'rdf/spec/format'
 
 describe JSON::LD::Format do
-  before :each do
-    @format_class = JSON::LD::Format
+  it_behaves_like 'an RDF::Format' do
+    let(:format_class) {JSON::LD::Format}
   end
 
-  include RDF_Format
-
   describe ".for" do
     formats = [
       :jsonld,
@@ -20,7 +18,7 @@ describe JSON::LD::Format do
       {content_type:   'application/x-ld+json'},
     ].each do |arg|
       it "discovers with #{arg.inspect}" do
-        expect(RDF::Format.for(arg)).to eq @format_class
+        expect(RDF::Format.for(arg)).to eq described_class
       end
     end
 
@@ -31,7 +29,7 @@ describe JSON::LD::Format do
       type:     %({\n"@type": {),
     }.each do |sym, str|
       it "detects #{sym}" do
-        expect(@format_class.for {str}).to eq @format_class
+        expect(described_class.for {str}).to eq described_class
       end
     end
 
@@ -41,7 +39,7 @@ describe JSON::LD::Format do
   end
 
   describe "#to_sym" do
-    specify {expect(@format_class.to_sym).to eq :jsonld}
+    specify {expect(described_class.to_sym).to eq :jsonld}
   end
 
   describe ".detect" do
@@ -49,7 +47,7 @@ describe JSON::LD::Format do
       jsonld: '{"@context" => "foo"}',
     }.each do |sym, str|
       it "detects #{sym}" do
-        expect(@format_class.detect(str)).to be_truthy
+        expect(described_class.detect(str)).to be_truthy
       end
     end
 
@@ -64,7 +62,7 @@ describe JSON::LD::Format do
       turtle:     "@prefix foo: <bar> .\n foo:a foo:b <c> .",
     }.each do |sym, str|
       it "does not detect #{sym}" do
-        expect(@format_class.detect(str)).to be_falsey
+        expect(described_class.detect(str)).to be_falsey
       end
     end
   end

data/spec/reader_spec.rb

@@ -8,16 +8,11 @@ describe JSON::LD::Reader do
   let!(:doap_nt) {File.expand_path("../../etc/doap.nt", __FILE__)}
   let!(:doap_count) {File.open(doap_nt).each_line.to_a.length}
 
-  before(:each) do
-    @reader_input = File.read(doap)
-    @reader = JSON::LD::Reader.new(@reader_input)
-    @reader_count = doap_count
+  it_behaves_like 'an RDF::Reader' do
+    let(:reader_input) {File.read(doap)}
+    let(:reader) {JSON::LD::Reader.new(reader_input)}
+    let(:reader_count) {doap_count}
   end
-  before :each do
-    @reader = JSON::LD::Reader.new(StringIO.new(""))
-  end
-
-  include RDF_Reader
 
   describe ".for" do
     formats = [
@@ -34,6 +29,14 @@ describe JSON::LD::Reader do
     end
   end
 
+  context "when validating", pending: ("JRuby support for jsonlint" if RUBY_ENGINE == "jruby") do
+    it "detects invalid JSON" do
+      expect do |b|
+        described_class.new(StringIO.new(%({"a": "b", "a": "c"})), validate: true).each_statement(&b)
+      end.to raise_error(RDF::ReaderError)
+    end
+  end
+
   context :interface do
     {
       plain: %q({

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ require "bundler/setup"
 require 'rspec'
 require 'rdf'
 require 'rdf/isomorphic'
-require 'json/ld'
 require 'rdf/nquads'
 require 'rdf/turtle'
 require 'rdf/trig'
@@ -15,6 +14,17 @@ require 'yaml'
 require 'restclient/components'
 require 'rack/cache'
 require 'matchers'
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require 'json/ld'
 
 JSON_STATE = JSON::State.new(
   indent:       "  ",
@@ -36,16 +46,13 @@ RestClient.enable Rack::Cache,
 ::RSpec.configure do |c|
   c.filter_run focus: true
   c.run_all_when_everything_filtered = true
-  c.exclusion_filter = {
-    ruby: lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
-  }
   c.include(RDF::Spec::Matchers)
 end
 
 # Heuristically detect the input stream
 def detect_format(stream)
   # Got to look into the file to see
-  if stream.is_a?(IO) || stream.is_a?(StringIO)
+  if stream.respond_to?(:rewind) && stream.respond_to?(:read)
     stream.rewind
     string = stream.read(1000)
     stream.rewind

data/spec/streaming_writer_spec.rb

@@ -5,12 +5,10 @@ require 'rdf/spec/writer'
 require 'json/ld/streaming_writer'
 
 describe JSON::LD::StreamingWriter do
-  before :each do
-    @writer = JSON::LD::Writer.new(StringIO.new(""), stream: true)
+  it_behaves_like 'an RDF::Writer' do
+    let(:writer) {JSON::LD::Writer.new(StringIO.new(""), stream: true)}
   end
 
-  include RDF_Writer
-
   context "simple tests" do
     it "should use full URIs without base" do
       input = %(<http://a/b> <http://a/c> <http://a/d> .)

data/spec/suite_from_rdf_spec.rb

@@ -9,6 +9,7 @@ describe JSON::LD do
     describe m.name do
       m.entries.each do |t|
         specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+          pending "Shared list BNode in different graphs" if t.property('input').include?("fromRdf-0021")
           t.run self
         end
       end

data/spec/suite_helper.rb

@@ -85,7 +85,7 @@ module Fixtures
 
       # Execute the test
       def run(rspec_example = nil)
-        @debug = ["test: #{inspect}", "source: #{input}"]
+        debug = @debug = ["test: #{inspect}", "source: #{input}"]
         @debug << "context: #{context}" if context_loc
         @debug << "options: #{options.inspect}" unless options.empty?
         @debug << "frame: #{frame}" if frame_loc
@@ -97,23 +97,23 @@ module Fixtures
         end
 
         if positiveTest?
-          debug << "expected: #{expect rescue nil}" if expect_loc
+          @debug << "expected: #{expect rescue nil}" if expect_loc
           begin
             result = case testType
             when "jld:ExpandTest"
-              JSON::LD::API.expand(input_loc, options.merge(debug: @debug))
+              JSON::LD::API.expand(input_loc, options.merge(debug: debug))
             when "jld:CompactTest"
-              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(debug: @debug))
+              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(debug: debug))
             when "jld:FlattenTest"
-              JSON::LD::API.flatten(input_loc, context_loc, options.merge(debug: @debug))
+              JSON::LD::API.flatten(input_loc, context_loc, options.merge(debug: debug))
             when "jld:FrameTest"
-              JSON::LD::API.frame(input_loc, frame_loc, options.merge(debug: @debug))
+              JSON::LD::API.frame(input_loc, frame_loc, options.merge(debug: debug))
             when "jld:FromRDFTest"
               repo = RDF::Repository.load(input_loc, format: :nquads)
               @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-              JSON::LD::API.fromRdf(repo, options.merge(debug: @debug))
+              JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
             when "jld:ToRDFTest"
-              JSON::LD::API.toRdf(input_loc, options.merge(debug: @debug)).map do |statement|
+              JSON::LD::API.toRdf(input_loc, options.merge(debug: debug)).map do |statement|
                 to_quad(statement)
               end
             else
@@ -123,12 +123,12 @@ module Fixtures
               if testType == "jld:ToRDFTest"
                 expected = expect
                 rspec_example.instance_eval {
-                  expect(result.sort.join("")).to produce(expected, @debug)
+                  expect(result.sort.join("")).to produce(expected, debug)
                 }
               else
                 expected = JSON.load(expect)
                 rspec_example.instance_eval {
-                  expect(result).to produce(expected, @debug)
+                  expect(result).to produce(expected, debug)
                 }
               end
             else
@@ -142,26 +142,26 @@ module Fixtures
             fail("Invalid Frame: #{e.message}")
           end
         else
-          @debug << "expected: #{property('expect')}" if property('expect')
+          debug << "expected: #{property('expect')}" if property('expect')
           t = self
           rspec_example.instance_eval do
             if t.evaluationTest?
               expect do
                 case t.testType
                 when "jld:ExpandTest"
-                  JSON::LD::API.expand(t.input_loc, options.merge(debug: @debug))
+                  JSON::LD::API.expand(t.input_loc, options.merge(debug: debug))
                 when "jld:CompactTest"
-                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(debug: @debug))
+                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(debug: debug))
                 when "jld:FlattenTest"
-                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(debug: @debug))
+                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(debug: debug))
                 when "jld:FrameTest"
-                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(debug: @debug))
+                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(debug: debug))
                 when "jld:FromRDFTest"
                   repo = RDF::Repository.load(t.input_loc)
-                  @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-                  JSON::LD::API.fromRdf(repo, options.merge(debug: @debug))
+                  debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
+                  JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: @debug)).map do |statement|
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: debug)).map do |statement|
                     t.to_quad(statement)
                   end
                 else