rubydora 0.0.2

data/lib/rubydora/ext/solr.rb

@@ -0,0 +1,103 @@
+module Rubydora::Ext
+  # Mapping Fedora objects to Solr documents
+  module Solr
+    # load this module by mixing into appropriate modules
+    # @param [Hash] args
+    # @option args [Class] :digital_object
+    # @option args [Class] :datastream
+    def self.load args = { :digital_object => Rubydora::DigitalObject, :datastream => Rubydora::Datastream}
+      args[:digital_object].send(:include, Rubydora::Ext::Solr::DigitalObjectMixin) if args[:digital_object]
+      args[:datastream].send(:include, Rubydora::Ext::Solr::DatastreamMixin) if args[:datastream]
+    end
+
+    # Datastreams mixin
+    module DatastreamMixin
+      # Initialize solr mapping logic
+      # @param [Class] base
+      def self.included(base)
+        base.instance_eval %Q{
+          class << self; attr_accessor :solr_mapping_logic end
+        }  
+
+        base.class_eval %Q{
+          attr_writer :solr_mapping_logic
+          def solr_mapping_logic
+            @solr_mapping_logic ||= self.class.solr_mapping_logic.dup
+          end
+        }
+
+        base.solr_mapping_logic ||= []
+      end
+
+      # sets appropriate solr document parameters for this datastream
+      # @param [Hash] doc Solr document object (pass-by-reference)
+      def to_solr(doc = {})
+      end
+
+    end
+
+    # DigitalObject mixin
+    module DigitalObjectMixin
+      # Initialize solr mapping logic
+      # @param [Class] base 
+      def self.included(base)
+        base.instance_eval %Q{
+          class << self; attr_accessor :solr_mapping_logic end
+        }  
+
+        base.class_eval %Q{
+          attr_writer :solr_mapping_logic
+          def solr_mapping_logic
+            @solr_mapping_logic ||= self.class.solr_mapping_logic.dup
+          end
+        }
+
+        base.solr_mapping_logic ||= [:object_profile_to_solr,:datastreams_to_solr, :relations_to_solr]
+      end
+
+      ##
+      # Set appropriate solr document attributes for this object
+      # @param [Hash] doc Solr document object (pass-by-reference)
+      def to_solr(doc = {})
+        self.solr_mapping_logic.each do |method_name|
+          send(method_name, doc)
+        end
+
+        doc.reject { |k,v| v.nil? or v.empty? }
+      end
+
+      # add solr document attributes from the object profile
+      # @param [Hash] doc Solr document object (pass-by-reference)
+      def object_profile_to_solr doc
+        doc['id'] = pid
+        doc['pid_s'] = pid
+
+        self.profile.each do |key, value|
+          doc["#{key}_s"] = value
+        end
+      end
+
+      # add solr document attributes from the object datastreams
+      # @param [Hash] doc Solr document object (pass-by-reference)
+      def datstreams_to_solr doc
+        datastreams.each do |dsid, ds|
+          doc['disseminates_s'] ||= []
+          doc['disseminates_s'] << [dsid]
+          ds.to_solr(doc)
+        end
+      end
+
+      # add solr document attributes by querying the resource index
+      # @param [Hash] doc Solr document object (pass-by-reference)
+      def relations_to_solr doc
+        self.repository.sparql("SELECT ? relation ?object FROM <#ri> WHERE {
+   #{uri} ?relation ?object
+}").each do |row|
+          solr_field = "ri_#{row['relation'].split('#').last}_s"
+          doc[solr_field] ||= []
+          doc[solr_field] << row['object']
+        end
+      end
+    end
+  end
+end

data/lib/rubydora/ext.rb

@@ -0,0 +1,5 @@
+module Rubydora
+  # Extensions namespace
+  module Ext
+  end
+end

data/lib/rubydora/extension_parameters.rb

@@ -0,0 +1,40 @@
+module Rubydora
+# Copied in part from projectblacklight.org
+  module ExtensionParameters
+    # setup extension support
+    def self.included(base)
+      base.extend ExtendableClassMethods
+
+      base.after_initialize do
+        apply_extensions
+      end
+    end
+
+    # try to apply registered extensions
+    def apply_extensions
+      self.class.registered_extensions.each do |registration|
+        self.extend( registration[:module_obj] ) if registration[:condition_proc].nil? || registration[:condition_proc].call( self )
+      end
+    end
+
+  # Certain class-level modules needed for the document-specific
+  # extendability architecture
+  module ExtendableClassMethods
+    attr_writer :registered_extensions
+
+    # registered_extensions accessor
+    # @return [Array]
+    def registered_extensions
+      @registered_extensions ||= []
+    end
+
+    # register extensions
+    # @param [Module] module_obj
+    # @yield &condition
+    def use_extension( module_obj, &condition )
+      registered_extensions << {:module_obj => module_obj, :condition_proc => condition}    
+    end
+
+  end
+  end
+end

data/lib/rubydora/models_mixin.rb

@@ -0,0 +1,28 @@
+module Rubydora
+  ##
+  # Provide access to registered content models
+  # FIXME: Ruby 1.9 provides instance_exec, which should make it
+  # possible to subsume this into Rubydora::RelationshipsMixin
+  module ModelsMixin
+ 
+    # Provides an accessor to the object content models
+    # @param [Hash] args
+    # @option args [Array] :values if nil, will query the resource index for related objects
+    # @return [ArrayWithCallback<Rubydora::DigitalObject>] an array that will call the #relationship_changed callback when values are modified 
+    def models args = {}
+      @models = nil if args.delete(:refetch)
+      @models ||= relationship('info:fedora/fedora-system:def/model#hasModel', :values => args[:values] || profile['objModels'] || [])
+    end
+
+    # provides a setter that behaves as does #models
+    def models= arr
+      arr &&= [arr] unless arr.is_a? Array
+      old = models.dup || []
+      arr = @models = relationship('info:fedora/fedora-system:def/model#hasModel', :values => arr.flatten)
+      relationship_changed('info:fedora/fedora-system:def/model#hasModel', {:+ => arr - old, :- => old - arr }, @models)
+
+      @models
+    end
+    alias_method :model=, :models=
+  end
+end

data/lib/rubydora/relationships_mixin.rb

@@ -0,0 +1,101 @@
+module Rubydora
+  #
+  # This model inject RELS-EXT-based helper methods 
+  # for Fedora objects
+  #
+  module RelationshipsMixin
+
+    # FIXME: This should probably be defined on the DigitalObject
+    # Map Rubydora accessors to Fedora RELS-EXT predicates
+    RELS_EXT = {"annotations"=>"info:fedora/fedora-system:def/relations-external#hasAnnotation",
+                "has_metadata"=>"info:fedora/fedora-system:def/relations-external#hasMetadata",
+                "description_of"=>"info:fedora/fedora-system:def/relations-external#isDescription_of",
+                "part_of"=>"info:fedora/fedora-system:def/relations-external#isPart_of",
+                "descriptions"=>"info:fedora/fedora-system:def/relations-external#hasDescription",
+                "dependent_of"=>"info:fedora/fedora-system:def/relations-external#isDependent_of",
+                "constituents"=>"info:fedora/fedora-system:def/relations-external#hasConstituent",
+                "parts"=>"info:fedora/fedora-system:def/relations-external#hasPart",
+                "memberOfCollection"=>"info:fedora/fedora-system:def/relations-external#isMemberOfCollection",
+                "member_of"=>"info:fedora/fedora-system:def/relations-external#isMember_of",
+                "equivalents"=>"info:fedora/fedora-system:def/relations-external#hasEquivalent",
+                "derivations"=>"info:fedora/fedora-system:def/relations-external#hasDerivation",
+                "derivation_of"=>"info:fedora/fedora-system:def/relations-external#isDerivation_of",
+                "subsets"=>"info:fedora/fedora-system:def/relations-external#hasSubset",
+                "annotation_of"=>"info:fedora/fedora-system:def/relations-external#isAnnotation_of",
+                "metadata_for"=>"info:fedora/fedora-system:def/relations-external#isMetadataFor",
+                "dependents"=>"info:fedora/fedora-system:def/relations-external#hasDependent",
+                "subset_of"=>"info:fedora/fedora-system:def/relations-external#isSubset_of",
+                "constituent_of"=>"info:fedora/fedora-system:def/relations-external#isConstituent_of",
+                "collection_members"=>"info:fedora/fedora-system:def/relations-external#hasCollectionMember",
+                "members"=>"info:fedora/fedora-system:def/relations-external#hasMember"}
+
+    # generate accessor methods for each RELS_EXT property
+    def self.included(base)
+
+        # FIXME: ugly, but functional..
+        RELS_EXT.each do |name, property|
+          base.class_eval <<-RUBY
+            def #{name.to_s} args = {}
+              relationships[:#{name}] = nil if args.delete(:refetch)
+              relationships[:#{name}] ||= relationship('#{property}', args)
+            end
+
+            def #{name.to_s}= arr
+              arr &&= [arr] unless arr.is_a? Array
+              old = #{name.to_s}.dup || []
+              arr = relationships[:#{name}] = relationship('#{property}', :values => arr.flatten)
+              relationship_changed('#{property}', {:+ => arr - old, :- => old - arr },  arr)
+
+              arr
+            end
+          RUBY
+        end
+    end
+          
+    ##
+    # Provides an accessor to the `predicate` RELS-EXT relationship
+    # Using ArrayWithCallback, will commit any changes to Fedora
+    #
+    # @param [String] predicate
+    # @param [Hash] args
+    # @option args [Array] :values if nil, will query the resource index for related objects
+    # @return [ArrayWithCallback<Rubydora::DigitalObject>] an array that will call the #relationship_changed callback when values are modified
+    def relationship predicate, args = {}
+      arr = ArrayWithCallback.new(args[:values] || repository.find_by_sparql_relationship(fqpid, predicate))
+      arr.on_change << lambda { |arr, diff| relationship_changed(predicate, diff, arr) } 
+
+      arr
+    end
+
+
+    ##
+    # Given a predicate and a diff between before and after states
+    # commit the appropriate changes to Fedora
+    #
+    # @param [String] predicate
+    # @param [Hash] diff
+    # @option diff [Hash] :+ additions
+    # @option diff [Hash] :- deletions
+    # @param [Array] arr the current relationship state
+    def relationship_changed predicate, diff, arr = []
+      diff[:+] ||= []
+      diff[:-] ||= []
+
+      diff[:+].each do |o| 
+        obj_uri = (( o.fqpid if o.respond_to? :fqpid ) || ( o.uri if o.respond_to? :uri ) || (o.to_s if o.respond_to? :to_s?) || o )
+        repository.add_relationship :subject => fqpid, :predicate => predicate, :object => obj_uri
+      end        
+
+      diff[:-].each do |o| 
+        obj_uri = (( o.fqpid if o.respond_to? :fqpid ) || ( o.uri if o.respond_to? :uri ) || (o.to_s if o.respond_to? :to_s?) || o )
+        repository.purge_relationship :subject => fqpid, :predicate => predicate, :object => obj_uri
+      end        
+    end
+
+    # accessor to all retrieved relationships
+    # @return [Hash]
+    def relationships
+      @relationships ||= {}
+    end
+  end
+end

data/lib/rubydora/repository.rb

@@ -0,0 +1,82 @@
+module Rubydora
+  # Fedora Repository object that provides API access
+  class Repository
+    include ResourceIndex
+    include RestApiClient
+
+    # repository configuration (see #initialize)
+    attr_reader :config
+
+    # @param [Hash] options
+    # @option options [String] :url
+    # @option options [String] :user
+    # @option options [String] :password
+    def initialize options = {}
+      @config = options
+      load_api_abstraction
+    end
+
+    # {include:DigitalObject.find}
+    def find pid
+      DigitalObject.find(pid, self)
+    end
+
+    # repository profile (from API-A-LITE data)
+    # @return [Hash]
+    def profile
+      @profile ||= begin
+        profile_xml = client['describe?xml=true'].get
+        profile_xml.gsub! '<fedoraRepository', '<fedoraRepository xmlns="http://www.fedora.info/definitions/1/0/access/"' unless profile_xml =~ /xmlns=/
+        doc = Nokogiri::XML(profile_xml)
+        xmlns = { 'access' => "http://www.fedora.info/definitions/1/0/access/"  }
+        h = doc.xpath('/access:fedoraRepository/*', xmlns).inject({}) do |sum, node|
+                     sum[node.name] ||= []
+                     case node.name
+                       when "repositoryPID"
+                         sum[node.name] << Hash[*node.xpath('access:*', xmlns).map { |x| [node.name, node.text]}.flatten]
+                       else
+                         sum[node.name] << node.text
+                     end
+                     sum
+                   end
+        h.select { |key, value| value.length == 1 }.each do |key, value|
+          next if key == "objModels"
+          h[key] = value.first
+        end
+
+        h
+      rescue
+        nil
+      end
+    end
+
+    # @return [Float] repository version
+    def version
+      @version ||= profile['repositoryVersion'].to_f rescue nil
+    end
+
+    # Raise an error if unable to connect to the API endpoint
+    def ping
+      raise "Unable to establish connection to Fedora Repository" unless profile
+      true
+    end
+
+    protected
+
+    # Load fallback API implementations for older versions of Fedora
+    def load_api_abstraction
+      return unless version
+
+      if version <= 3.0
+      end
+
+      if version < 3.4
+        require 'rubydora/rest_api_client/v33'
+        self.extend Rubydora::RestApiClient::V33
+      end
+
+      true
+    end
+
+  end
+end

data/lib/rubydora/resource_index.rb

@@ -0,0 +1,43 @@
+module Rubydora
+  # Fedora resource index helpers
+  module ResourceIndex
+    # Find new objects using a sparql query
+    # @param [String] query SPARQL query
+    # @param [Hash] options 
+    # @option options [String] :binding the SPARQL binding name to create new objects from
+    # @return [Array<Rubydora::DigitalObject>]
+    def find_by_sparql query, options = { :binding => 'pid' }
+      self.sparql(query).map { |x| self.find(x[options[:binding]]) rescue nil }
+    end
+
+    # Find new objects by their relationship to a subject
+    # @param [String] subject Subject URI 
+    # @param [String] predicate Predicate URI
+    # @return [Array<Rubydora::DigitalObject>]
+    def find_by_sparql_relationship subject, predicate
+      find_by_sparql <<-RELSEXT
+        SELECT ?pid FROM <#ri> WHERE {
+          <#{subject}> <#{predicate}> ?pid 
+        }
+      RELSEXT
+    end
+
+    # Run a raw SPARQL query and return a FasterCSV object
+    # @param [String] query SPARQL query
+    # @return [FasterCSV::Table]
+    def sparql query
+      FasterCSV.parse(self.risearch(query), :headers => true)
+    end
+
+    protected
+    # Run a raw query against the Fedora risearch resource index
+    # @param [String] query
+    # @param [Hash] options
+    def risearch query, options = {}
+      request_params = { :dt => 'on', :format => 'CSV', :lang => 'sparql', :limit => nil, :query => query, :type => 'tuples' }.merge(options)
+
+      self.client['risearch'].post request_params
+    end
+
+  end
+end

data/lib/rubydora/rest_api_client/v33.rb

@@ -0,0 +1,36 @@
+module Rubydora::RestApiClient
+  # Fall-back implementations for fcrepo < 3.4
+  module V33
+    # SOAP API endpoint
+    # @return [SOAP::WSDLDriverFactory]
+    def soap
+     return @soap if @soap
+     gem "soap4r"
+     require 'soap/wsdlDriver'
+
+     @soap = SOAP::WSDLDriverFactory.new("#{ config[:url] }/wsdl?api=API-M").create_rpc_driver
+     @soap.options['protocol.http.basic_auth'] << [config[:url], config[:user], config[:password]]
+
+     @soap
+       
+    end
+
+    # {include:RestApiClient#relationships}
+    def relationships options = {}
+      nil
+    end
+
+    # {include:RestApiClient#add_relationship}
+    def add_relationship options = {}
+      pid = options.delete(:pid) || options[:subject]
+      self.soap.addRelationship(:pid => pid, :relationship => options[:predicate], :object => options[:object], :isLiteral => false, :datatype => nil)
+    end
+
+    # {include:RestApiClient#purge_relationship}
+    def purge_relationship options = {}
+      pid = options.delete(:pid) || options[:subject]
+      self.soap.purgeRelationship(:pid => pid, :relationship => options[:predicate], :object => options[:object], :isLiteral => false, :datatype => nil)
+    end
+
+  end
+end