active-fedora 1.0.5 → 1.1.0

data/lib/fedora/datastream.rb

@@ -0,0 +1,56 @@
+require 'fedora/base'
+require 'fedora/repository'
+
+class Fedora::Datastream < Fedora::BaseObject
+  
+  attr_accessor :mime_type
+  
+  def initialize(attrs = {})
+    super
+    if attrs
+      if attrs[:mime_type] 
+        self.mime_type = attrs[:mime_type]
+      elsif attrs[:mimeType] 
+        self.mime_type = attrs[:mimeType]
+      end 
+    end
+    self.control_group='M' if @attributes[:mimeType]
+  end
+  
+  def pid
+    attributes[:pid]
+  end
+
+  def control_group
+    @attributes[:controlGroup]
+  end
+  def control_group=(cg)
+    @attributes[:controlGroup]=cg
+  end
+  
+  def dsid
+    if attributes.has_key?(:dsid) 
+      attributes[:dsid]
+    else
+      attributes[:dsID]
+    end
+  end
+  
+  def label
+    @attributes[:dsLabel]
+  end
+  
+  def label=(new_label)
+    @attributes[:dsLabel] = new_label
+  end
+  
+  # See http://www.fedora.info/definitions/identifiers/
+  def uri
+    "fedora:info/#{pid}/datastreams/#{dsid}"
+  end
+  
+  # @returns the url of the datastream in Fedora, without the repository userinfo
+  def url
+    return "#{Fedora::Repository.instance.base_url}/objects/#{pid}/datastreams/#{dsid}"
+  end
+end

data/lib/fedora/fedora_object.rb

@@ -0,0 +1,161 @@
+require 'xmlsimple'
+require 'rexml/document'
+require 'fedora/base'
+
+class Fedora::FedoraObject < Fedora::BaseObject
+  attr_accessor :target_repository
+
+  # = Parameters
+  # attrs<Hash>:: fedora object attributes (see below)
+  #
+  # == Attributes (attrs)
+  # namespace<Symbol>::
+  # pid<Symbol>::
+  # state<Symbol>::
+  # label<Symbol>::
+  # contentModel<Symbol>::
+  # objectXMLFormat<Symbol>::
+  # ownerID<Symbol>::
+  #-
+  def initialize(attrs = nil)
+    super
+    # TODO: check for required attributes
+  end
+
+  ####
+  #  Attribute Accessors
+  ####
+  
+  
+  def load_attributes_from_fedora
+    #self.attributes.merge!(profile)
+    attributes.merge!(profile)
+  end
+  
+  # Reads all object properties from the object's FOXML into a hash.  Provides slightly more info than .profile, including the object state.
+  def properties_from_fedora
+    #object_rexml = REXML::Document.new(object_xml)
+    #properties = {
+    #     :pid => object_rexml.root.attributes["PID"],
+    #     :state => object_rexml.root.elements["//foxml:property[@NAME='info:fedora/fedora-system:def/model#state']"].attributes["VALUE"],
+    #     :create_date => object_rexml.root.elements["//foxml:property[@NAME='info:fedora/fedora-system:def/model#createdDate']"].attributes["VALUE"],
+    #     :modified_date => object_rexml.root.elements["//foxml:property[@NAME='info:fedora/fedora-system:def/view#lastModifiedDate']"].attributes["VALUE"],
+    #     :owner_id => object_rexml.root.elements['//foxml:property[@NAME="info:fedora/fedora-system:def/model#ownerId"]'].attributes['VALUE']
+    #}
+    #label_element = object_rexml.root.elements["//foxml:property[@NAME='info:fedora/fedora-system:def/model#label']"]
+    #if profile_hash[:label]
+    # properties.merge!({:label => label_element.attributes["VALUE"]})
+    #end
+    return profile
+  end
+
+  def create_date
+    if attributes[:create_date] 
+      return attributes[:create_date]
+    elsif !new_object?
+        properties_from_fedora[:create_date]
+    else 
+      return nil
+    end
+  end
+
+  def modified_date
+    if attributes[:modified_date] 
+      return attributes[:modified_date]
+    elsif !new_object?
+        properties_from_fedora[:modified_date]
+    else 
+      return nil
+    end
+  end
+
+
+  def pid
+    self.attributes[:pid]
+  end
+
+  def pid=(new_pid)
+    self.attributes.merge!({:pid => new_pid})
+  end
+
+  def state
+    if attributes[:state] 
+      return attributes[:state]
+    elsif !new_object?
+        properties_from_fedora[:state]
+    else 
+      return nil
+    end
+  end
+
+  def state=(new_state)
+    if ["I", "A", "D"].include? new_state
+      self.attributes[:state]  = new_state
+    else
+      raise 'The object state of "' + new_state + '" is invalid. The allowed values for state are:  A (active), D (deleted), and I (inactive).'
+    end
+  end
+
+  def label
+    if attributes[:label] 
+      return attributes[:label]
+    elsif !new_object?
+        properties_from_fedora[:label]
+    else 
+      return nil
+    end
+  end
+
+  def label=(new_label)
+    self.attributes[:label] = new_label
+  end
+
+  #  Get the object and read its @ownerId from the profile
+  def owner_id
+    if attributes[:owner_id] 
+      return attributes[:owner_id]
+    elsif !new_object?
+        properties_from_fedora[:owner_id]
+    else 
+      return nil
+    end
+  end
+
+  def owner_id=(new_owner_id)
+    self.attributes.merge!({:ownerID => new_owner_id})
+  end
+  
+  def profile
+    # Use xmlsimple to slurp the attributes
+    retrieved_profile = XmlSimple.xml_in(Fedora::Repository.instance.fetch_custom(self.pid, :profile))
+    label = retrieved_profile["objLabel"].first unless retrieved_profile["objLabel"].first == {}
+    profile_hash = Hash[:pid => retrieved_profile["pid"],
+                          :owner_id => retrieved_profile["objOwnerId"].first,
+                          :label => label,
+                          :create_date =>  retrieved_profile["objCreateDate"].first,
+                          :modified_date => retrieved_profile["objLastModDate"].first,
+                          :methods_list_url => retrieved_profile["objDissIndexViewURL"].first,
+                          :datastreams_list_url => retrieved_profile["objItemIndexViewURL"].first,
+                          :state => retrieved_profile["objState"].first 
+                        ]                           
+  end
+
+  def object_xml
+    Fedora::Repository.instance.fetch_custom(pid, :objectXML)
+  end
+  
+  def self.object_xml(pid=pid)
+    Fedora::Repository.instance.fetch_custom(pid, :objectXML)
+  end
+  
+  # See http://www.fedora.info/definitions/identifiers
+  def uri
+    "fedora:info/#{pid}"
+  end
+  
+  # @returns the url of the object in Fedora, without the repository userinfo
+  def url
+    repo_url = Fedora::Repository.instance.fedora_url
+    return "#{repo_url.scheme}://#{repo_url.host}:#{repo_url.port}#{repo_url.path}/objects/#{pid}"
+  end
+end  

data/lib/fedora/formats.rb

@@ -0,0 +1,30 @@
+module Fedora
+  module XmlFormat
+    extend self
+    
+    def extension
+      "xml"
+    end
+    
+    def mime_type
+      "text/xml"
+    end
+    
+    def encode(hash)
+      hash.to_xml
+    end
+    
+    def decode(xml)
+      from_xml_data(Hash.from_xml(xml))
+    end
+    
+    private
+      def from_xml_data(data)
+        if data.is_a?(Hash) && data.keys.size == 1
+          data.values.first
+        else
+          data
+        end
+      end      
+  end
+end

data/lib/fedora/generic_search.rb

@@ -0,0 +1,71 @@
+# 
+#  @Creator Matt Zumwalt, MediaShelf LLC
+#  @Copyright Matt Zumwalt, 2007.  All Rights Reserved.
+#
+ 
+module Fedora
+  class GenericSearch
+  
+    def initialize(uri, service_name)
+      @uri = "#{uri}/#{service_name}"
+      @client = HTTPClient.new(@uri)
+      @extheader = {'User-Agent'=>"RubyFedora"}
+    end
+  
+    def call_resource
+    
+    end
+  
+    # TODO: Handle ruby-tyle params, camel-casing them before passing to call_resource...
+    def update_index(params)
+      query = {:action=>action,:value=>value,:repositoryName=>repository_name,:indexName=>indexname,:restXslt=>"copyXML"}.merge(params)
+      query.merge {:operation> "updateIndex"}
+    
+      @client.get(@uri, query, @extheader)
+      return "update_index Not Implemented."
+    end
+  
+  
+    def browse_index(params)
+      # Sample: /fedoragsearch/rest?operation=browseIndex&startTerm=&fieldName=PID&termPageSize=20&indexName=FedoraIndex&restXslt=copyXml&resultPageXslt=browseIndexToResultPage
+      query = {:startTerm=>URLEncoder.encode(start_term, "UTF-8"),:fieldName=>"",:indexName=>"",:termPageSize=>"", :restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
+      query.merge {:operation> "browseIndex"}
+      @client.get(@uri, query, @extheader)
+      return "browse_index Not Implemented."
+    end
+  
+    def gfind_objects(params)
+      # Sample: /fedoragsearch/rest?operation=gfindObjects&query=test&hitPageSize=10&restXslt=copyXml
+      # fieldMaxLength limits the number of characters returned from the value of each object field.
+      # Snippets will highlight matched words within the search results.  To keep the xml as simple as possible, set snippetsMax to 0.
+      query = {:query=>URLEncoder.encode(query, "UTF-8"),:value=>value,:indexName=>indexname,:hitPageStart=>"",:hitPageSize=>"",:snippetsMax=>"0",:fieldMaxLength=>"",:restXslt=>"copyXML",:resultPageXslt=>""}.merge(params)
+      query.merge {:operation> "gfindObjects"}
+      @client.get(@uri, query, @extheader)
+      return "gfind_objects Not Implemented."
+    end
+  
+    def get_index_info(params)
+      # Sample: /fedoragsearch/rest?operation=getIndexInfo&restXslt=copyXml
+      query = {:indexName=>"",:restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
+      query.merge {:operation> "getIndexInfo"}
+      @client.get(@uri, query, @extheader)
+      return "get_index_info Not Implemented."
+    end
+  
+    def get_repository_info(params)
+      # Sample: /fedoragsearch/rest?operation=getRepositoryInfo&restXslt=copyXml
+      query = {:repositoryName=>"",:restXslt=>"copyXml", :resultPageXslt=>""}.merge(params)
+      query.merge {:operation> "getRepositoryInfo"}
+      @client.get(@uri, query, @extheader)
+      return "get_repository_info Not Implemented."
+    end
+  
+    def configure(params)
+      query = {:configName=>""}.merge(params)
+      query.merge {:operation> "configure"}
+      @client.get(@uri, query, @extheader)
+      return "configure Not Implemented."
+    end
+  
+  end
+end

data/lib/fedora/repository.rb

@@ -0,0 +1,287 @@
+
+require 'fedora/base'
+require 'fedora/connection'
+require 'fedora/formats'
+require 'fedora/fedora_object'
+require 'fedora/datastream'
+
+module Fedora
+  NAMESPACE = "fedora:info/"
+  ALL_FIELDS = [
+    :pid, :label, :fType, :cModel, :state, :ownerId, :cDate, :mDate, :dcmDate, 
+    :bMech, :title, :creator, :subject, :description, :contributor,
+    :date, :type, :format, :identifier, :source, :language, :relation, :coverage, :rights 
+  ]
+  
+  class Repository
+    
+    attr_accessor :repository_name, :base_url, :fedora_version, :pid_namespace, :pid_delimiter
+    
+    def self.flush
+      Thread.current[:repo]=nil
+    end
+    def self.register(url, surrogate=nil)
+      url = url.to_s.chop if url.to_s =~ /\/\Z/
+      Thread.current[:repo]= Fedora::Repository.new(url, surrogate)
+      begin
+        repo = Thread.current[:repo]
+        attributes = repo.describe_repository
+        repo.repository_name = attributes["repositoryName"].first
+        repo.base_url = attributes["repositoryBaseURL"].first
+        repo.fedora_version = attributes["repositoryVersion"].first
+        repo.pid_namespace = attributes["repositoryPID"].first["PID-namespaceIdentifier"].first
+        repo.pid_delimiter = attributes["repositoryPID"].first["PID-delimiter"].first
+      rescue
+      end
+      Thread.current[:repo]
+    end
+    def self.instance
+      raise "did you register a repo?" unless Thread.current[:repo]
+      Thread.current[:repo]
+    end
+    class StringResponse < String
+      attr_reader :content_type
+      
+      def initialize(s, content_type)
+        super(s)
+        @content_type = content_type
+      end
+    end
+    
+    attr_accessor :fedora_url
+
+    def initialize(fedora_url, surrogate=nil)
+      @fedora_url = fedora_url.is_a?(URI) ? fedora_url : URI.parse(fedora_url)
+      @surrogate = surrogate
+      @connection = nil
+    end
+    
+    # Fetch the raw content of either a fedora object or datastream
+    def fetch_content(object_uri)
+      response = connection.raw_get("#{url_for(object_uri)}?format=xml")
+      StringResponse.new(response.body, response.content_type)
+    end
+    
+
+    
+    # Find fedora objects with http://www.fedora.info/wiki/index.php/API-A-Lite_findObjects
+    #
+    # == Parameters
+    # query<String>:: the query string to be sent to Fedora.
+    # options<Hash>:: see below
+    #
+    # == Options<Hash> keys
+    # limit<String|Number>:: set the maxResults parameter in fedora
+    # select<Symbol|Array>:: the fields to returned.  To include all fields, pass :all as the value.
+    #                           The field "pid" is always included.
+    #
+    # == Examples
+    #    find_objects("label=Image1")
+    #    find_objects("pid~demo:*", "label=test")
+    #    find_objects("label=Image1", :include => :all)
+    #    find_objects("label=Image1", :include => [:label])
+    #-
+    def find_objects(*args)
+      raise ArgumentError, "Missing query string" unless args.length >= 1
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      
+      fields = options[:select]
+      fields = (fields.nil? || (fields == :all)) ? ALL_FIELDS : ([:pid] + ([fields].flatten! - [:pid]))
+      
+      query = args.join(' ')
+      params = { :resultFormat => 'xml', :query => query }
+      params[:maxResults] = options[:limit] if options[:limit]
+      params[:sessionToken] = options[:sessionToken] if options[:sessionToken]
+      includes = fields.inject("") { |s, f| s += "&#{f}=true"; s }
+      
+      convert_xml(connection.get("#{fedora_url.path}/objects?#{params.to_fedora_query}#{includes}"))
+    end
+    def find_model(pid, klazz)
+      obj = self.find_objects("pid=#{pid}").first
+      doc = REXML::Document.new(obj.object_xml, :ignore_whitespace_nodes=>:all)
+      klazz.deserialize(doc)
+    end
+    
+    # Create the given object if it's new (not obtained from a find method).  Otherwise update the object.
+    #
+    # == Return
+    # boolean:: whether the operation is successful
+    #-
+    def save(object)
+      object.new_object? ? create(object) : update(object)
+    end
+
+    def nextid
+      d = REXML::Document.new(connection.post(fedora_url.path+"/management/getNextPID?xml=true").body)
+      d.elements['//pid'].text
+    end
+
+  
+    def create(object)
+      case object
+        when Fedora::FedoraObject
+          pid = (object.pid ? object : 'new')
+          response = connection.post("#{url_for(pid)}?" + object.attributes.to_fedora_query, object.blob)
+          if response.code == '201'
+            object.pid = extract_pid(response) 
+            object.new_object = false
+            true
+          else
+            false
+          end
+        when Fedora::Datastream
+          raise ArgumentError, "Missing dsID attribute" if object.dsid.nil?
+          extra_headers = {}
+          extra_headers['Content-Type'] = object.attributes[:mimeType] if object.attributes[:mimeType]
+          response = connection.post("#{url_for(object)}?" + object.attributes.to_fedora_query, 
+            object.blob, extra_headers)
+          if response.code == '201'
+            object.new_object = false
+            true
+          else
+            false
+          end
+        else
+          raise ArgumentError, "Unknown object type"
+      end
+      
+    end
+  
+    # Update the given object
+    # == Return
+    # boolean:: whether the operation is successful
+    #-
+    def update(object)
+      raise ArgumentError, "Missing pid attribute" if object.nil? || object.pid.nil?
+      case object
+      when Fedora::FedoraObject
+        response = connection.put("#{url_for(object)}?" + object.attributes.to_fedora_query)
+        response.code == '200' || '307'
+      when Fedora::Datastream
+        raise ArgumentError, "Missing dsID attribute" if object.dsid.nil?
+        response = connection.put("#{url_for(object)}?" + object.attributes.to_fedora_query, object.blob)
+        response.code == '200' || '201'
+        return response.code
+      else
+        raise ArgumentError, "Unknown object type"
+      end
+    end
+  
+    # Delete the given pid
+    # == Parameters
+    # object<Object|String>:: The object to delete.  
+    #       This can be a uri String ("demo:1", "fedora:info/demo:1") or any object that responds uri method.
+    #
+    # == Return
+    # boolean:: whether the operation is successful
+    #-
+    def delete(object)
+      raise ArgumentError, "Object must not be nil" if object.nil?
+      response = connection.delete("#{url_for(object)}")
+      response.code == '200' or response.code == '204'  # Temporary hack around error in Fedora 3.0 Final's REST API
+    end
+    
+    # Export the given object
+    # == Parameters
+    # object<String|Object>:: a fedora uri, pid, FedoraObject instance
+    # method<Symbol>::        the method to fetch such as :export, :history, :versions, etc
+    # extra_params<Hash>::    any other extra parameters to pass to fedora
+    #
+    def export(object, extra_params={})
+      extra_params = {:format=>:foxml, :context=>:archive}.merge!(extra_params)
+      if extra_params[:format].kind_of?(String)
+        format = extra_params[:format]
+      else
+        format = case extra_params[:format]
+          when :atom then "info:fedora/fedora-system:ATOM-1.1"
+          when :atom_zip then "info:fedora/fedora-system:ATOMZip-1.1"
+          when :mets then "info:fedora/fedora-system:METSFedoraExt-1.1"
+          when :foxml then "info:fedora/fedora-system:FOXML-1.1"
+          else "info:fedora/fedora-system:FOXML-1.1"
+        end
+      end
+      fetch_custom(object, "export", :format=>format, :context=>extra_params[:context].to_s)
+    end
+    
+    def ingest(content_to_ingest, extra_params={})
+      if extra_params[:pid]
+        url = url_for(extra_params[:pid])
+      else
+        url = url_for("new")
+      end
+      
+      if content_to_ingest.kind_of?(File) 
+        content_to_ingest = content_to_ingest.read
+      end
+        
+      connection.post(url,content_to_ingest)
+    end
+
+    # Fetch the given object using custom method.  This is used to fetch other aspects of a fedora object,
+    # such as profile, versions, etc...
+    # == Parameters
+    # object<String|Object>:: a fedora uri, pid, FedoraObject instance
+    # method<Symbol>::        the method to fetch such as :export, :history, :versions, etc
+    # extra_params<Hash>::    any other extra parameters to pass to fedora
+    #
+    # == Returns
+    # This method returns raw xml response from the server
+    #-
+    def fetch_custom(object, method, extra_params = { :format => 'xml' })
+      path = case method
+        when :profile then ""
+        else "/#{method}"
+      end
+      
+      extra_params.delete(:format) if method == :export
+      connection.raw_get("#{url_for(object)}#{path}?#{extra_params.to_fedora_query}").body
+    end
+    
+    def describe_repository
+      result_body = connection.raw_get("#{fedora_url.path}/describe?xml=true").body
+      XmlSimple.xml_in(result_body)
+    end
+    
+  private
+    def convert_xml(response)
+      results = FedoraObjects.new
+      return results unless response && response['resultList']
+
+      results.session_token = response['listSession']['token'] if response['listSession']
+      objectFields = response['resultList']['objectFields']
+      case objectFields
+        when Array
+          objectFields.each { |attrs| results << FedoraObject.new(attrs.rekey!) }
+        when Hash
+          results << FedoraObject.new(objectFields.rekey!)
+      end
+      results.each {|result| result.new_object = false}
+      results
+    end
+    
+    def url_for(object)
+      uri = object.respond_to?(:uri) ? object.uri : object.to_s
+      uri = (uri[0..NAMESPACE.length-1] == NAMESPACE ? uri[NAMESPACE.length..-1] : uri) # strip of fedora:info namespace
+      "#{fedora_url.path}/objects/#{uri}"
+    end
+    
+    # Low level access to the remote fedora server
+    # The +refresh+ parameter toggles whether or not the connection is refreshed at every request
+    # or not (defaults to +false+).
+    def connection(refresh = false)
+      if refresh || @connection.nil?
+        @connection = Fedora::Connection.new(@fedora_url, Fedora::XmlFormat, @surrogate)
+      end
+      @connection
+    end
+    
+    def extract_pid(response)
+      CGI.unescape(response['Location'].split('/').last)
+    end
+  end
+end
+
+class FedoraObjects < Array
+  attr_accessor :session_token
+end
+