active-fedora 5.4.0 → 5.5.0.rc1

data/lib/active_fedora/rdf_node.rb

@@ -0,0 +1,283 @@
+module ActiveFedora
+  module RdfNode
+    extend ActiveSupport::Concern
+
+    ##
+    # Get the subject for this rdf object
+    def rdf_subject
+      @subject ||= begin
+        s = self.class.rdf_subject.call(self)
+        s &&= RDF::URI.new(s) if s.is_a? String
+        s
+      end
+    end   
+
+    def reset_rdf_subject!
+      @subject = nil
+    end
+
+    # @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)
+    end
+
+
+    def target_class(predicate)
+      _, conf = self.class.config_for_predicate(predicate)
+      class_name = conf[:class_name]
+      return nil unless class_name
+      self.class.const_get(class_name.to_sym)
+    end
+
+    # if there are any existing statements with this predicate, replace them
+    # @param [Symbol, RDF::URI] predicate  the predicate 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 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])
+      end
+
+      return TermProxy.new(self, subject, options)
+    end
+
+ 
+    def delete_predicate(subject, predicate, values = nil)
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+
+      if values.nil?
+        query = RDF::Query.new do
+          pattern [subject, predicate, :value]
+        end
+
+        query.execute(graph).each do |solution|
+          graph.delete [subject, predicate, solution.value]
+        end
+      else
+        Array(values).each do |v|
+          graph.delete [subject, predicate, v]
+        end
+      end
+
+    end
+
+    # append a value 
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
+    def append(subject, predicate, args)
+      options = config_for_term_or_uri(predicate)
+      graph.insert([subject, predicate, args])
+      TermProxy.new(self, subject, options)
+    end
+
+    def config_for_term_or_uri(term)
+      case term
+      when RDF::URI
+        self.class.config.each { |k, v| return v if v[:predicate] == term}
+      else
+        self.class.config[term.to_sym]
+      end
+    end
+
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
+    def find_predicate(term)
+      conf = config_for_term_or_uri(term)
+      conf ? conf[:predicate] : nil
+    end
+
+    def query subject, predicate, &block
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+      
+      q = RDF::Query.new do
+        pattern [subject, predicate, :value]
+      end
+
+      q.execute(graph, &block)
+    end
+
+    def method_missing(name, *args)
+      if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
+        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
+    rescue ActiveFedora::UnregisteredPredicateError
+      super
+    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
+      end
+
+      def build(&block)
+        yield self
+      end
+
+      def method_missing(name, *args, &block)
+        args = args.first if args.respond_to? :first
+        raise "mapping must specify RDF vocabulary as :in argument" unless args.has_key? :in
+        vocab = args[:in]
+        field = args.fetch(:to, name).to_sym
+        class_name = args[:class_name]
+        raise "Vocabulary '#{vocab.inspect}' does not define property '#{field.inspect}'" unless vocab.respond_to? field
+        indexing = false
+        if block_given?
+          # needed for solrizer integration
+          indexing = true
+          iobj = IndexObject.new
+          yield iobj
+          data_type = iobj.data_type
+          behaviors = iobj.behaviors
+        end
+        @parent.config[name] = {:predicate => vocab.send(field) } 
+        # stuff data_type and behaviors in there for to_solr support
+        if indexing
+          @parent.config[name][:type] = data_type
+          @parent.config[name][:behaviors] = behaviors
+        end
+        @parent.config[name][:class_name] = class_name if class_name
+      end
+
+      # this enables a cleaner API for solr integration
+      class IndexObject
+        attr_accessor :data_type, :behaviors
+        def initialize
+          @behaviors = [:searchable]
+          @data_type = :string
+        end
+        def as(*args)
+          @behaviors = args
+        end
+        def type(sym)
+          @data_type = sym
+        end
+        def defaults
+          :noop
+        end
+      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 ||= {}
+      end
+
+      def map_predicates(&block)
+        builder = Builder.new(self)
+        builder.build &block
+      end
+
+      def rdf_type(uri_or_string=nil)
+        if uri_or_string
+          uri = RDF::URI.new(uri_or_string) unless uri_or_string.kind_of? RDF::URI
+          self.config[:type] = {predicate: RDF.type}
+          @rdf_type = uri
+        end
+        @rdf_type
+      end
+
+      def config_for_predicate(predicate)
+        config.each do |term, value|
+          return term, value if value[:predicate] == predicate
+        end
+        return nil
+      end
+
+      ##
+      # Register a ruby block that evaluates to the subject of the graph
+      # By default, the block returns the current object's pid
+      # @yield [ds] 'ds' is the datastream instance
+      def rdf_subject &block
+        if block_given?
+           return @subject_block = block
+        end
+
+        # Create a B-node if they don't supply the rdf_subject
+        @subject_block ||= lambda { |ds| RDF::Node.new }
+      end
+
+    end
+  end
+end
+

data/lib/active_fedora/rdf_object.rb

@@ -0,0 +1,32 @@
+module ActiveFedora
+  module RdfObject
+    extend ActiveSupport::Concern
+
+    included do
+      include RdfNode
+    end
+
+    def graph
+      @graph ||= RDF::Graph.new
+      insert_type_assertion
+      @graph 
+    end
+
+    def initialize(graph=RDF::Graph.new, subject=nil)
+      @graph = graph
+      @subject = subject
+    end
+
+    def get_values(subject, predicate)
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+      return TermProxy.new(@graph, @subject, predicate)
+    end
+
+    private
+    
+    def insert_type_assertion
+      rdf_type = self.class.rdf_type
+      @graph.insert([@subject, RDF.type, rdf_type]) if rdf_type
+    end
+  end
+end

data/lib/active_fedora/simple_datastream.rb

@@ -3,6 +3,7 @@ module ActiveFedora
   class SimpleDatastream < OmDatastream
 
     class_attribute :class_fields
+    attr_accessor :fields
     self.class_fields = []
     
     
@@ -17,6 +18,13 @@ module ActiveFedora
     end
     
 
+    #Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist
+    #when this method returns. Each term is marked as a multivalue string.
+    def initialize(digital_object=nil, dsid=nil, options={})
+      super
+      self.fields={}
+    end
+
     # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
     # each field will have the 2 magic methods:
     #   name=(arg) 

data/lib/active_fedora/solr_service.rb

@@ -1,4 +1,3 @@
-require "solrizer"
 require 'rsolr'
 
 module ActiveFedora
@@ -10,7 +9,6 @@ module ActiveFedora
     attr_reader :conn
 
     def self.register(host=nil, args={})
-      load_mappings
       Thread.current[:solr_service]=self.new(host, args)
     end
 

data/lib/active_fedora/version.rb

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

data/spec/fixtures/solr_rdf_descMetadata.nt

@@ -1,4 +1,4 @@
-<info:fedora/test:1> <http://purl.org/dc/terms/created> "fake-date" .
+<info:fedora/test:1> <http://purl.org/dc/terms/created> "2009-10-10" .
 <info:fedora/test:1> <http://purl.org/dc/terms/title> "fake-title" .
 <info:fedora/test:1> <http://purl.org/dc/terms/publisher> "publisher1" .
 <info:fedora/test:1> <http://xmlns.com/foaf/0.1/based_near> "coverage1" .

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe "Nested Rdf Objects" do
+  describe "without type" do
+    before(:each) do 
+      class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
+        map_predicates do |map|
+          map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
+        end
+
+        class Component
+          include ActiveFedora::RdfObject
+          map_predicates do |map|
+            map.label(:in=> RDF::DC, :to=>'title')
+          end
+        end
+      end
+
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :SpecDatastream)
+    end
+
+    let (:ds) do
+      mock_obj = stub(:mock_obj, :pid=>'test:124', :new? => true)
+      ds = SpecDatastream.new(mock_obj)
+    end
+
+
+    it "should be able to nest a complex object" do
+      comp = SpecDatastream::Component.new
+      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.label = ["Alternator"]
+      comp2 = SpecDatastream::Component.new
+      comp2.label = ["Crankshaft"]
+      ds.parts = [comp1, comp2]
+      ds.parts.first.label.should == ["Alternator"]
+      ds.parts.last.label.should == ["Crankshaft"]
+    end
+
+    it "should be able to clear complex objects" do
+      comp1 = SpecDatastream::Component.new
+      comp1.label = ["Alternator"]
+      comp2 = SpecDatastream::Component.new
+      comp2.label = ["Crankshaft"]
+      ds.parts = [comp1, comp2]
+      ds.parts = []
+      ds.parts.should == []
+    end
+
+    it "should load complex objects" do
+      ds.content = <<END
+_:g70350851837440 <http://purl.org/dc/terms/title> "Alternator" .
+<info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851837440 .
+<info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851833380 .
+_:g70350851833380 <http://purl.org/dc/terms/title> "Crankshaft" .
+END
+      ds.parts.first.label.should == ["Alternator"]
+    end
+  end
+
+  describe "with type" do
+    before(:each) do 
+      class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
+        map_predicates do |map|
+          map.mediator(:in=> RDF::DC, :class_name=>'MediatorUser')
+        end
+
+        class MediatorUser
+          include ActiveFedora::RdfObject
+          rdf_type "http://purl.org/dc/terms/AgentClass"
+          map_predicates do |map|
+            map.title(:in=> RDF::DC)
+          end
+        end
+      end
+
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :SpecDatastream)
+    end
+
+    let (:ds) do
+      mock_obj = stub(:mock_obj, :pid=>'test:124', :new? => true)
+      ds = SpecDatastream.new(mock_obj)
+    end
+
+
+    it "should store the type of complex objects when type is specified" do
+      comp = SpecDatastream::MediatorUser.new
+      comp.title = ["Doctor"]
+      ds.mediator = comp
+      ds.mediator.first.type.first.should be_instance_of RDF::URI
+      ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
+      ds.mediator.first.title.first.should == 'Doctor'
+    end
+
+    it "should add the type of complex object when it is not provided" do
+      ds.content = <<END
+_:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Person" .
+<info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
+END
+      ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
+    end
+
+    it "should add load the type of complex objects when provided (superceeding what is specified by the class)" do
+      ds.content = <<END
+_:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Orgainzation" .
+_:g70350851837440 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.ebu.ch/metadata/ontologies/ebucore#Organisation> .
+<info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
+END
+      ds.mediator.first.type.first.to_s.should == "http://www.ebu.ch/metadata/ontologies/ebucore#Organisation"
+    end
+  end
+end