active-fedora 5.5.0.rc1 → 5.5.0.rc2

data/History.txt

@@ -1,3 +1,7 @@
+5.5.0 (Unreleased)
+Added support for complex rdf structures.
+Changed RdfDatastream to_solr so that it uses the dsid as the solr prefix, not the datastream class name
+
 5.4.0
 HYDRA-850 Added finder methods like Base.where().limit().order().first
 Added Base.delete_all and Base.destroy_all

data/lib/active_fedora/callbacks.rb

@@ -54,26 +54,26 @@ module ActiveFedora
   # queue that is kept intact down through an inheritance hierarchy.
   #
   #   class Topic < ActiveFedora::Base
-  #     before_delete :destroy_author
+  #     before_destroy :destroy_author
   #   end
   #
   #   class Reply < Topic
-  #     before_delete :destroy_readers
+  #     before_destroy :destroy_readers
   #   end
   #
-  # Now, when <tt>Topic#delete</tt> is run only +destroy_author+ is called. When <tt>Reply#delete</tt> is
+  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
   # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation
-  # where the +before_delete+ method is overridden:
+  # where the +before_destroy+ method is overridden:
   #
   #   class Topic < ActiveFedora::Base
-  #     def before_delete() destroy_author end
+  #     def before_destroy() destroy_author end
   #   end
   #
   #   class Reply < Topic
-  #     def before_delete() destroy_readers end
+  #     def before_destroy() destroy_readers end
   #   end
   #
-  # In that case, <tt>Reply#delete</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
+  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
   # So, use the callback macros when you want to ensure that a certain callback is called for the entire
   # hierarchy, and use the regular overwriteable methods when you want to leave it up to each descendant
   # to decide whether they want to call +super+ and trigger the inherited callbacks.

data/lib/active_fedora/rdf_datastream.rb

@@ -29,11 +29,6 @@ module ActiveFedora
         Deprecation.warn(RDFDatastream, "register_vocabularies no longer has any effect and will be removed in active-fedora 6.0", caller)
       end
 
-      def prefix(name)
-        name = name.to_s unless name.is_a? String
-        pre = self.to_s.sub(/RDFDatastream$/i, '').underscore
-        return "#{pre}__#{name}".to_sym
-      end
     end
 
     attr_accessor :loaded
@@ -41,6 +36,12 @@ module ActiveFedora
       true
     end
 
+    def prefix(name)
+      name = name.to_s unless name.is_a? String
+      pre = dsid.underscore
+      return "#{pre}__#{name}".to_sym
+    end
+
     def content
       serialize
     end
@@ -67,7 +68,7 @@ module ActiveFedora
         if values
           Array(values).each do |val|    
             val = val.to_s if val.kind_of? RDF::URI
-            self.class.create_and_insert_terms(self.class.prefix(field_key), val, directive, solr_doc)
+            self.class.create_and_insert_terms(prefix(field_key), val, directive, solr_doc)
           end
         end
       end

data/lib/active_fedora/rdf_node.rb

@@ -1,6 +1,9 @@
 module ActiveFedora
   module RdfNode
     extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :TermProxy
 
     ##
     # Get the subject for this rdf object
@@ -19,7 +22,7 @@ module ActiveFedora
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     def get_values(subject, predicate)
       options = config_for_term_or_uri(predicate)
-      return TermProxy.new(self, subject, options)
+      TermProxy.new(self, subject, predicate, options)
     end
 
 
@@ -31,26 +34,27 @@ module ActiveFedora
     end
 
     # if there are any existing statements with this predicate, replace them
+    # @param [RDF::URI] subject  the subject to insert into the graph
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-
+    # @param [Array,#to_s] values  the value/values to insert into the graph
     def set_value(subject, predicate, values)
-      
-      #predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+
       options = config_for_term_or_uri(predicate)
       predicate = options[:predicate]
 
       delete_predicate(subject, predicate)
-
       Array(values).each do |arg|
-        arg = arg.to_s if arg.kind_of? RDF::Literal
-        next if arg.kind_of?(String) && arg.empty?
+        if arg.respond_to?(:rdf_subject) # an RdfObject
+          graph.insert([subject, predicate, arg.rdf_subject ])
+        else
+          arg = arg.to_s if arg.kind_of? RDF::Literal
+          next if arg.kind_of?(String) && arg.empty?
 
-        # If arg is a b-node, then copy it's statements onto the parent graph
-        arg = merge_subgraph(arg) if arg.respond_to? :graph
-        graph.insert([subject, predicate, arg])
+          graph.insert([subject, predicate, arg])
+        end
       end
 
-      return TermProxy.new(self, subject, options)
+      TermProxy.new(self, subject, predicate, options)
     end
 
  
@@ -78,7 +82,7 @@ module ActiveFedora
     def append(subject, predicate, args)
       options = config_for_term_or_uri(predicate)
       graph.insert([subject, predicate, args])
-      TermProxy.new(self, subject, options)
+      TermProxy.new(self, subject, options[:predicate], options)
     end
 
     def config_for_term_or_uri(term)
@@ -108,17 +112,9 @@ module ActiveFedora
 
     def method_missing(name, *args)
       if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
-        set_value(rdf_subject, pred, *args)  
+          set_value(rdf_subject, pred, *args)  
       elsif pred = find_predicate(name)
-        klass = target_class(pred)
-        if klass
-          # return an array of klass.new from each of the values
-          query(rdf_subject, pred).map do |solution|
-            klass.new(graph, solution.value)
-          end
-        else
           get_values(rdf_subject, pred)
-        end
       else 
         super
       end
@@ -127,15 +123,6 @@ module ActiveFedora
     end
 
     private
-    # If arg is a b-node, then copy it's statements onto the parent graph
-    def merge_subgraph(rdf_object)
-      rdf_object.graph.statements.each do |s|
-        graph.insert(s)
-      end
-      # Return the arg to point at the new b-node
-      rdf_object.rdf_subject
-    end
-
     class Builder
       def initialize(parent)
         @parent = parent
@@ -189,55 +176,6 @@ module ActiveFedora
       end
     end
 
-    class TermProxy
-
-      attr_reader :graph, :subject, :predicate, :options
-      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, :is_a?, :to => :values
-
-      def initialize(graph, subject, options)
-        @graph = graph
-
-        @subject = subject
-        @predicate = options[:predicate]
-        @options = options
-      end
-
-      def <<(*values)
-        values.each { |value| graph.append(subject, predicate, value) }
-        values
-      end
-
-      def delete(*values)
-        values.each do |value| 
-          graph.delete_predicate(subject, predicate, value)
-        end
-
-        values
-      end
-
-      def values
-        values = []
-
-        graph.query(subject, predicate).each do |solution|
-          v = solution.value
-          v = v.to_s if v.is_a? RDF::Literal
-          if options[:type] == :date
-            v = Date.parse(v)
-          end
-          values << v
-        end
-
-        values
-      end
-      
-      def method_missing(method, *args, &block)
-        if values.respond_to? method
-          values.send(method, *args, &block)
-        else
-          super
-        end
-      end
-    end
     module ClassMethods
       def config
         @config ||= {}

data/lib/active_fedora/rdf_node/term_proxy.rb

@@ -0,0 +1,64 @@
+module ActiveFedora
+  module RdfNode
+    class TermProxy
+
+      attr_reader :graph, :subject, :predicate, :options
+      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, :is_a?, :to => :values
+
+      # @param graph RDF::Graph
+      # @param subject RDF::URI
+      # @param options Hash
+      def initialize(graph, subject, predicate, options)
+        @graph = graph
+        @subject = subject
+        @predicate = predicate
+        @options = options
+      end
+
+      def build
+        new_subject = RDF::Node.new
+        graph.graph.insert([subject, predicate, new_subject])
+        graph.target_class(predicate).new(graph.graph, new_subject)
+      end
+
+      def <<(*values)
+        values.each { |value| graph.append(subject, predicate, value) }
+        values
+      end
+
+      def delete(*values)
+        values.each do |value| 
+          graph.delete_predicate(subject, predicate, value)
+        end
+
+        values
+      end
+
+      def values
+        values = []
+
+        graph.query(subject, predicate).each do |solution|
+          v = solution.value
+          v = v.to_s if v.is_a? RDF::Literal
+          if options[:type] == :date
+            v = Date.parse(v)
+          end
+          values << v
+        end
+        if options[:class_name]
+          values = values.map{ |found_subject| graph.target_class(predicate).new(graph.graph, found_subject)}
+        end
+        
+        values
+      end
+      
+      def method_missing(method, *args, &block)
+        if values.respond_to? method
+          values.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/rdf_object.rb

@@ -4,17 +4,20 @@ module ActiveFedora
 
     included do
       include RdfNode
+      attr_reader :rdf_subject, :graph
     end
 
     def graph
       @graph ||= RDF::Graph.new
-      insert_type_assertion
       @graph 
     end
 
-    def initialize(graph=RDF::Graph.new, subject=nil)
+
+    def initialize(graph, subject=nil)
+      subject ||= RDF::Node.new
       @graph = graph
-      @subject = subject
+      @rdf_subject = subject
+      insert_type_assertion
     end
 
     def get_values(subject, predicate)
@@ -26,7 +29,7 @@ module ActiveFedora
     
     def insert_type_assertion
       rdf_type = self.class.rdf_type
-      @graph.insert([@subject, RDF.type, rdf_type]) if rdf_type
+      @graph.insert([@rdf_subject, RDF.type, rdf_type]) if rdf_type
     end
   end
 end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "5.5.0.rc1"
+  VERSION = "5.5.0.rc2"
 end

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -29,15 +29,15 @@ describe "Nested Rdf Objects" do
 
 
     it "should be able to nest a complex object" do
-      comp = SpecDatastream::Component.new
+      comp = SpecDatastream::Component.new(ds.graph)
       comp.label = ["Alternator"]
       ds.parts = comp
       ds.parts.first.label.should == ["Alternator"]
     end
     it "should be able to nest many complex objects" do
-      comp1 = SpecDatastream::Component.new
+      comp1 = SpecDatastream::Component.new ds.graph
       comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new
+      comp2 = SpecDatastream::Component.new ds.graph
       comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       ds.parts.first.label.should == ["Alternator"]
@@ -45,9 +45,9 @@ describe "Nested Rdf Objects" do
     end
 
     it "should be able to clear complex objects" do
-      comp1 = SpecDatastream::Component.new
+      comp1 = SpecDatastream::Component.new ds.graph
       comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new
+      comp2 = SpecDatastream::Component.new ds.graph
       comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       ds.parts = []
@@ -63,6 +63,21 @@ _:g70350851833380 <http://purl.org/dc/terms/title> "Crankshaft" .
 END
       ds.parts.first.label.should == ["Alternator"]
     end
+
+    it "should build complex objects when a parent node doesn't exist" do
+      part = ds.parts.build
+      part.should be_kind_of SpecDatastream::Component
+      part.label = "Wheel bearing"
+      ds.parts.first.label.should == ['Wheel bearing']
+    end
+
+    it "should build complex objects when a parent node exists" do
+      ds.parts  #this creates a parts node, but it shouldn't
+      part = ds.parts.build
+      part.should be_kind_of SpecDatastream::Component
+      part.label = "Wheel bearing"
+      ds.parts.first.label.should == ['Wheel bearing']
+    end
   end
 
   describe "with type" do
@@ -94,7 +109,7 @@ END
 
 
     it "should store the type of complex objects when type is specified" do
-      comp = SpecDatastream::MediatorUser.new
+      comp = SpecDatastream::MediatorUser.new ds.graph
       comp.title = ["Doctor"]
       ds.mediator = comp
       ds.mediator.first.type.first.should be_instance_of RDF::URI

data/spec/integration/ntriples_datastream_spec.rb

@@ -68,15 +68,15 @@ describe ActiveFedora::NtriplesRDFDatastream do
     subject.date_uploaded = Date.parse('2012-11-02')
     subject.date_uploaded.first.should be_kind_of Date
     solr_document = subject.to_solr
-    solr_document["my_datastream__date_uploaded_dt"].should == ['2012-11-02T00:00:00Z']
+    solr_document["rdf__date_uploaded_dt"].should == ['2012-11-02T00:00:00Z']
   end
 
   it "should produce a solr document" do
     @subject = RdfTest.new(title: "War and Peace")
     solr_document = @subject.to_solr
-    solr_document["my_datastream__title_display"].should == ["War and Peace"]
-    solr_document["my_datastream__title_facet"].should == ["War and Peace"]
-    solr_document["my_datastream__title_t"].should == ["War and Peace"]
+    solr_document["rdf__title_display"].should == ["War and Peace"]
+    solr_document["rdf__title_facet"].should == ["War and Peace"]
+    solr_document["rdf__title_t"].should == ["War and Peace"]
   end
 
   it "should set and recall values" do

data/spec/unit/ntriples_datastream_spec.rb

@@ -67,16 +67,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
 
   describe "some dummy instances" do
     before do
-      class MyFoobarRDFDatastream < ActiveFedora::NtriplesRDFDatastream
-      end
-      class MyFoobarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
-      end
+      @one = ActiveFedora::RDFDatastream.new('fakepid', 'myFoobar')
+      @two = ActiveFedora::RDFDatastream.new('fakepid', 'myQuix')
     end
     it "should generate predictable prexies" do
-      MyFoobarRDFDatastream.prefix("baz").should == :my_foobar__baz
-    end
-    it "should generate prefixes case-insensitively" do
-      MyFoobarRDFDatastream.prefix("quux").should == MyFoobarRdfDatastream.prefix("quux")
+      @one .prefix("baz").should == :my_foobar__baz
+      @two.prefix("baz").should == :my_quix__baz
     end
   end
 
@@ -170,25 +166,25 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
     it "should iterate through @fields hash" do
       solr_doc = @subject.to_solr
-      solr_doc["my_datastream__publisher_t"].should == ["publisher1"]
-      solr_doc["my_datastream__publisher_sort"].should == ["publisher1"]
-      solr_doc["my_datastream__publisher_display"].should == ["publisher1"]
-      solr_doc["my_datastream__publisher_facet"].should == ["publisher1"]
-      solr_doc["my_datastream__based_near_t"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["my_datastream__based_near_display"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["my_datastream__based_near_facet"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["my_datastream__created_sort"].should == ["2009-10-10"]
-      solr_doc["my_datastream__created_display"].should == ["2009-10-10"]
-      solr_doc["my_datastream__title_t"].should == ["fake-title"]
-      solr_doc["my_datastream__title_sort"].should == ["fake-title"]
-      solr_doc["my_datastream__title_display"].should == ["fake-title"]
-      solr_doc["my_datastream__related_url_t"].should == ["http://example.org/"]
-      solr_doc["my_datastream__empty_field_t"].should be_nil
+      solr_doc["solr_rdf__publisher_t"].should == ["publisher1"]
+      solr_doc["solr_rdf__publisher_sort"].should == ["publisher1"]
+      solr_doc["solr_rdf__publisher_display"].should == ["publisher1"]
+      solr_doc["solr_rdf__publisher_facet"].should == ["publisher1"]
+      solr_doc["solr_rdf__based_near_t"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["solr_rdf__based_near_display"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["solr_rdf__based_near_facet"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["solr_rdf__created_sort"].should == ["2009-10-10"]
+      solr_doc["solr_rdf__created_display"].should == ["2009-10-10"]
+      solr_doc["solr_rdf__title_t"].should == ["fake-title"]
+      solr_doc["solr_rdf__title_sort"].should == ["fake-title"]
+      solr_doc["solr_rdf__title_display"].should == ["fake-title"]
+      solr_doc["solr_rdf__related_url_t"].should == ["http://example.org/"]
+      solr_doc["solr_rdf__empty_field_t"].should be_nil
 
       #should NOT have these
-      solr_doc["my_datastream__narrator"].should be_nil
-      solr_doc["my_datastream__empty_field"].should be_nil
-      solr_doc["my_datastream__creator"].should be_nil
+      solr_doc["solr_rdf__narrator"].should be_nil
+      solr_doc["solr_rdf__empty_field"].should be_nil
+      solr_doc["solr_rdf__creator"].should be_nil
     end
 
     describe "with an actual object" do
@@ -233,16 +229,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
       describe ".to_solr()" do
         it "should return the right fields" do
           @obj.to_solr.keys.count.should == 13
-          @obj.to_solr.keys.should include("my_datastream__related_url_t", "my_datastream__publisher_t", "my_datastream__publisher_sort",
-                "my_datastream__publisher_display", "my_datastream__publisher_facet", "my_datastream__created_sort",
-                "my_datastream__created_display", "my_datastream__title_t", "my_datastream__title_sort", "my_datastream__title_display",
-                "my_datastream__based_near_t", "my_datastream__based_near_facet", "my_datastream__based_near_display")
+          @obj.to_solr.keys.should include("solr_rdf__related_url_t", "solr_rdf__publisher_t", "solr_rdf__publisher_sort",
+                "solr_rdf__publisher_display", "solr_rdf__publisher_facet", "solr_rdf__created_sort",
+                "solr_rdf__created_display", "solr_rdf__title_t", "solr_rdf__title_sort", "solr_rdf__title_display",
+                "solr_rdf__based_near_t", "solr_rdf__based_near_facet", "solr_rdf__based_near_display")
 
         end
 
         it "should return the right values" do
-          @obj.to_solr["my_datastream__related_url_t"].should == ["http://example.org/blogtastic/"]
-          @obj.to_solr["my_datastream__based_near_t"].should == ["Tacoma, WA","Renton, WA"]
+          @obj.to_solr["solr_rdf__related_url_t"].should == ["http://example.org/blogtastic/"]
+          @obj.to_solr["solr_rdf__based_near_t"].should == ["Tacoma, WA","Renton, WA"]
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 5.5.0.rc1
+  version: 5.5.0.rc2
   prerelease: 6
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-15 00:00:00.000000000 Z
+date: 2013-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr
@@ -369,6 +369,7 @@ files:
 - lib/active_fedora/railtie.rb
 - lib/active_fedora/rdf_datastream.rb
 - lib/active_fedora/rdf_node.rb
+- lib/active_fedora/rdf_node/term_proxy.rb
 - lib/active_fedora/rdf_object.rb
 - lib/active_fedora/rdf_xml_writer.rb
 - lib/active_fedora/rdfxml_rdf_datastream.rb