Make Resource Enumerable to allow easy RDF serialization.

Author: gkellogg

lib/json/ld/resource.rb

@@ -2,60 +2,59 @@ module JSON::LD
   # Simple Ruby reflector class to provide native
   # access to JSON-LD objects
   class Resource
-    # @!attribute [r] attributes
+    include RDF::Enumerable
+
     # @return [Hash<String => Object] Object representation of resource
     attr_reader :attributes
 
-    # @!attribute [r] id
     # @return [String] ID of this resource
     attr_reader :id
 
-    # @!attribute [r] context
     # @return [JSON::LD::Context] Context associated with this resource
     attr_reader :context
 
+    ##
     # Is this resource clean (i.e., saved to mongo?)
     #
     # @return [Boolean]
     def clean?; @clean; end
 
+    ##
     # Is this resource dirty (i.e., not yet saved to mongo?)
     #
     # @return [Boolean]
     def dirty?; !clean?; end
-    
+
+    ##
     # Has this resource been reconciled against a mongo ID?
     #
     # @return [Boolean]
     def reconciled?; @reconciled; end
 
+    ##
     # Has this resource been resolved so that
     # all references are to other Resources?
     #
     # @return [Boolean]
     def resolved?; @resolved; end
 
+    ##
     # Anonymous resources have BNode ids or no schema:url
     #
     # @return [Boolean]
     def anonymous?; @anon; end
 
+    ##
     # Is this a stub resource, which has not yet been
     # synched or created within the DB?
     def stub?; !!@stub; end
 
+    ##
     # Is this a new resource, which has not yet been
     # synched or created within the DB?
     def new?; !!@new; end
 
-    # Manage contexts used by resources.
-    #
-    # @param [String] ctx
-    # @return [JSON::LD::Context]
-    def self.set_context(ctx)
-      (@@contexts ||= {})[ctx] = JSON::LD::Context.new.parse(ctx)
-    end
-
+    ##
     # A new resource from the parsed graph
     # @param [Hash{String => Object}] node_definition
     # @param [Hash{Symbol => Object}] options
@@ -76,8 +75,7 @@ def self.set_context(ctx)
     #   This is a stand-in for another resource that has
     #   not yet been retrieved (or created) from Mongo
     def initialize(node_definition, options = {})
-      @context_name = options[:context]
-      @context = self.class.set_context(@context_name)
+      @context = options[:context]
       @clean = options.fetch(:clean, false)
       @new = options.fetch(:new, true)
       @reconciled = options.fetch(:reconciled, !@new)
@@ -91,12 +89,14 @@ def initialize(node_definition, options = {})
       @anon = @id.nil? || @id.to_s[0,2] == '_:'
     end
 
+    ##
     # Return a hash of this object, suitable for use by for ETag
     # @return [Fixnum]
     def hash
       self.deresolve.hash
     end
 
+    ##
     # Reverse resolution of resource attributes.
     # Just returns `attributes` if
     # resource is unresolved. Otherwise, replaces `Resource`
@@ -134,6 +134,7 @@ def deresolve
       compacted.delete_if {|k, v| k == '@context'}
     end
 
+    ##
     # Serialize to JSON-LD, minus `@context` using
     # a deresolved version of the attributes
     #
@@ -143,6 +144,13 @@ def to_json(options = nil)
       deresolve.to_json(options)
     end
 
+    ##
+    # Enumerate over statements associated with this resource
+    def each(&block)
+      JSON::LD::API.toRdf(attributes, expandContext: context, &block)
+    end
+
+    ##
     # Update node references using the provided map.
     # This replaces node references with Resources,
     # either stub or instantiated.
@@ -186,29 +194,7 @@ def update_obj(obj, reference_map)
       self
     end
 
-    # Merge resources
-    # FIXME: If unreconciled or unresolved resources are merged
-    # against reconciled/resolved resources, they will appear
-    # to not match, even if they are really the same thing.
-    #
-    # @param [Resource] resource
-    # @return [Resource] self
-    def merge(resource)
-      if attributes.neq?(resource.attributes)
-        resource.attributes.each do |p, v|
-          next if p == 'id'
-          if v.nil? or (v.is_a?(Array) and v.empty?)
-            attributes.delete(p)
-          else
-            attributes[p] = v
-          end
-        end
-        @resolved = @clean = false
-      end
-      self
-    end
-
-    #
+    ##
     # Override this method to implement save using
     # an appropriate storage mechanism.
     #
@@ -218,12 +204,14 @@ def merge(resource)
     #
     # @return [Boolean] true or false if resource not saved
     def save
-      raise NotImplemented
+      raise NotImplementedError
     end
 
+    ##
     # Access individual fields, from subject definition
     def property(prop_name); @attributes.fetch(prop_name, nil); end
 
+    ##
     # Access individual fields, from subject definition
     def method_missing(method, *args)
       property(method.to_s)

spec/resource_spec.rb

@@ -3,5 +3,75 @@
 require 'spec_helper'
 
 describe JSON::LD::Resource do
-  it "is pending"
+  subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"})}
+  describe "#initialize" do
+    specify {expect(subject).not_to be_nil}
+    specify {expect(subject).to be_a(JSON::LD::Resource)}
+    specify {expect(subject).not_to be_clean}
+    specify {expect(subject).to be_anonymous}
+    specify {expect(subject).to be_dirty}
+    specify {expect(subject).to be_new}
+    specify {expect(subject).not_to be_resolved}
+    specify {expect(subject).not_to be_stub}
+    context "schema:name property" do
+      specify {expect(subject.property("http://schema.org/name")).to eq "foo"}
+    end
+
+    describe "compacted with context" do
+      subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"}, :compact => true, :context => {"@vocab" => "http://schema.org/"})}
+      specify {expect(subject).not_to be_nil}
+      specify {expect(subject).to be_a(JSON::LD::Resource)}
+      specify {expect(subject).not_to be_clean}
+      specify {expect(subject).to be_anonymous}
+      specify {expect(subject).to be_dirty}
+      specify {expect(subject).to be_new}
+      specify {expect(subject).not_to be_resolved}
+      specify {expect(subject).not_to be_stub}
+      its(:name) {should eq "foo"}
+    end
+  end
+
+  describe "#deresolve" do
+    it "FIXME"
+  end
+
+  describe "#resolve" do
+    it "FIXME"
+  end
+
+  describe "#hash" do
+    specify {subject.hash.should be_a(Fixnum)}
+      
+    it "returns the hash of the attributes" do
+      subject.hash.should == subject.deresolve.hash
+    end
+  end
+
+  describe "#to_json" do
+    it "has JSON" do
+      subject.to_json.should be_a(String)
+      JSON.parse(subject.to_json).should be_a(Hash)
+    end
+    it "has same ID" do
+      JSON.parse(subject.to_json)['@id'].should == subject.id
+    end
+  end
+
+  describe "#each" do
+    specify {expect {|b| subject.each(&b)}.to yield_with_args(RDF::Statement)}
+  end
+
+  describe RDF::Enumerable do
+    specify {expect(subject).to be_enumerable}
+
+    it "initializes a graph" do
+      g = RDF::Graph.new << subject
+      expect(g.count).to eq 1
+      expect(g.objects.first).to eq "foo"
+    end
+  end
+
+  describe "#save" do
+    specify {expect {subject.save}.to raise_error(NotImplementedError)}
+  end
 end