ruby-fedora 0.1.0

data/lib/ambition/adapters/active_fedora/sort.rb

@@ -0,0 +1,43 @@
+module Ambition
+  module Adapters
+    module ActiveFedora
+      class Sort < Base
+        # >> sort_by { |u| u.age }
+        # => #sort_by(:age)
+        def sort_by(method)
+          raise "Not implemented."
+        end
+
+        # >> sort_by { |u| -u.age }
+        # => #reverse_sort_by(:age)
+        def reverse_sort_by(method)
+          raise "Not implemented."
+        end
+
+        # >> sort_by { |u| u.profile.name }
+        # => #chained_sort_by(:profile, :name)
+        def chained_sort_by(receiver, method)
+          raise "Not implemented."
+        end
+
+        # >> sort_by { |u| -u.profile.name }
+        # => #chained_reverse_sort_by(:profile, :name)
+        def chained_reverse_sort_by(receiver, method)
+          raise "Not implemented."
+        end
+
+        # >> sort_by(&:name)
+        # => #to_proc(:name)
+        def to_proc(symbol)
+          raise "Not implemented."
+        end
+
+        # >> sort_by { rand }
+        # => #rand
+        def rand
+          raise "Not implemented."
+        end
+      end
+    end
+  end
+end

data/lib/fedora/base_object.rb

@@ -0,0 +1,19 @@
+class Fedora::BaseObject
+  attr_accessor :attributes, :xml_content, :uri, :url
+  attr_reader :errors, :uri
+  attr_writer :new_object
+  
+  # == Parameters
+  # attrs<Hash>:: object attributes
+  #-
+  def initialize(attrs = nil)
+    @new_object = true
+    @attributes = attrs || {}
+    @errors = []
+    @xml_content = attributes.delete(:xml_content)
+  end
+  
+  def new_object?
+    @new_object
+  end
+end

data/lib/fedora/connection.rb

@@ -0,0 +1,97 @@
+require "base64"
+require 'cgi'
+require "mime/types"
+
+# Add multipart/form-data support to net/http
+#
+# ==== Usage
+# File.open(File.expand_path('script/test.png'), 'r') do |file|
+#   http = Net::HTTP.new('localhost', 3000)
+#   begin
+#     http.start do |http|
+#       request = Net::HTTP::Post.new('/your/url/here')
+#       request.set_multipart_data(:file => file, :title => 'test.png')
+#       response = http.request(request)
+#       puts response
+#     end
+#   rescue Net::HTTPServerException => e
+#     p e
+#   end
+# end
+module Fedora::Multipart
+  def set_multipart_data(param_hash={})
+    boundary_token = [Array.new(8) {rand(256)}].join
+    self.content_type = "multipart/form-data; boundary=#{boundary_token}"
+    boundary_marker = "--#{boundary_token}\r\n"
+    self.body = param_hash.map { |param_name, param_value|
+      boundary_marker + case param_value
+      when File then file_to_multipart(param_name, param_value)
+      when String then text_to_multipart(param_name, param_value)
+      else ""      
+      end
+    }.join('') + "--#{boundary_token}--\r\n"
+  end
+  
+private
+  def file_to_multipart(key,file)
+    filename = File.basename(file.path)
+    mime_types = MIME::Types.of(filename)
+    mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+    part = %Q{Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n}
+    part += "Content-Transfer-Encoding: binary\r\n"
+    part += "Content-Type: #{mime_type}\r\n\r\n#{file.read}"
+  end
+
+  def text_to_multipart(key,value)
+    "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n#{value}\r\n"
+  end
+end
+
+class Net::HTTP::Post
+  include Fedora::Multipart
+end
+
+class Net::HTTP::Put
+  include Fedora::Multipart
+end
+
+# Add multipart/form-data support to active_resource
+module ActiveResource
+  class Connection
+    alias_method :post_without_multipart, :post
+    alias_method :put_without_multipart, :put
+    
+    def put(path, body = '', headers = {})
+      if body.is_a?(File)
+        multipart_request(Net::HTTP::Put.new(path, build_request_headers(headers)), body)      
+      else
+        put_without_multipart(path, body, headers)
+      end
+    end
+    
+    def post(path, body = '', headers = {})
+      if body.is_a?(File)
+        multipart_request(Net::HTTP::Post.new(path, build_request_headers(headers)), body)        
+      else
+        post_without_multipart(path, body, headers)
+      end
+    end
+    
+    def multipart_request(req, file)
+      logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
+      result = nil
+      time = Benchmark.realtime do
+        http.start do |conn|
+          req.set_multipart_data(:file => file)
+          result = conn.request(req)
+        end
+      end
+      logger.info "--> #{result.code} #{result.message} (#{result.body ? result.body : 0}b %.2fs)" % time if logger
+      handle_response(result)
+    end
+    
+    def raw_get(path, headers = {})
+      request(:get, path, build_request_headers(headers))
+    end
+  end
+end

data/lib/fedora/datastream.rb

@@ -0,0 +1,21 @@
+require 'fedora/base_object'
+
+class Fedora::Datastream < Fedora::BaseObject
+  def initialize(attrs = nil)
+    super
+    # TODO: check for required attributes
+  end
+  
+  def pid
+    attributes[:pid]
+  end
+  
+  def dsid
+    attributes[:dsID]
+  end
+  
+  # See http://www.fedora.info/definitions/identifiers/
+  def uri
+    "fedora:info/#{pid}/datastreams/#{dsid}"
+  end
+end

data/lib/fedora/fedora_object.rb

@@ -0,0 +1,119 @@
+require 'xmlsimple'
+require 'rexml/document'
+require 'fedora/base_object'
+
+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
+  ####
+
+  # TODO: Create appropriate attribute accessors for these values.  
+  # Where applicable, make sure that attributes are written to and read from self.attributes
+  # [pid, label, create_date, modified_date, fedora_object_type, contentModel, state, ownerID, behavior_def, behavior_mech,]
+  # API-M Search Value Equivalents: [pid, label, cDate, mDate, fType, cModel, state, ownerId, bDef, bMech,]
+  # TODO: Mix In DC attribute finders/accessors
+  # TODO: Make sure that fedora_object_type and contentModel are juggled properly. 
+  def retrieve_attr_from_fedora
+    self.attributes.merge!(objectProfile)
+    self.attributes.merge!({
+         :state => objectXML.root.elements["objectProperties/property[@NAME='info:fedora/fedora-system:def/model#state']"].attributes["value"]
+    })
+  
+  end
+
+  def create_date
+    objectProfile[:create_date]
+  end
+
+  def modified_date
+    objectProfile[:modified_date]
+  end
+
+
+  def pid
+    self.attributes[:pid]
+  end
+
+  def pid=(new_pid)
+    self.attributes.merge!({:pid => new_pid})
+  end
+
+  def state
+    self.attributes[:state]
+  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
+    self.attributes[:label]
+  end
+
+  def label=(new_label)
+    self.attributes[:label] = new_label
+  end
+
+  def content_model
+    self.attributes[:contentModel]
+  end
+
+  def content_model=(new_content_model)
+    self.attributes[:contentModel] = new_content_model
+  end
+
+  #  Get the object and read its @ownerId from the profile
+  def owner_id
+    self.attributes[:ownerID]
+  end
+
+  def owner_id=(new_owner_id)
+    self.attributes.merge!({:ownerID => new_owner_id})
+  end
+  
+  def profile
+    # Use xmlsimple to slurp the attributes
+    objectProfile = XmlSimple.xml_in(@fedora.call_resource(:retrieve, :objects_profile, {:pid => @pid}))
+    # TODO: Find out if xmlsimple automatically expands camelCased element names...
+    profile_as_array = {
+      :owner_id => objectProfile[objOwnerId],
+      :content_model => objectProfile[objContentModel],
+      :label => objectProfile[objLabel],
+      :date_created => objectProfile[objCreateDate],
+      :date_modified => objectProfile[objLastModDate]
+    }
+  end
+
+  def objectXML
+    # Use REXML to slurp the attributes (can't use xmlsimple because the XML is too complex.  Need XPath-like queries.
+    @objectXML ||= REXML::Document.new(@fedora.call_resource(:retrieve, :objects_objectXml, {:pid => @pid}))
+  end
+  
+  # See http://www.fedora.info/definitions/identifiers
+  def uri
+    "fedora:info/#{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/repository.rb

@@ -0,0 +1,199 @@
+require 'facets/hash/symbolize_keys'
+
+require 'active_resource'
+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, :dcmDate, 
+    :bMech, :title, :creator, :subject, :description, :contributor,
+    :date, :type, :format, :identifier, :source, :language, :relation, :coverage, :rights 
+  ]
+  
+  class Repository
+    attr_accessor :fedora_url
+
+    def initialize(fedora_url = "http://localhost:8080/fedora") 
+      @fedora_url = fedora_url.is_a?(URI) ? fedora_url : URI.parse(fedora_url)
+      @connection = nil
+    end
+    
+    # Fetch the raw content of either a fedora object or datastream
+    def fetch_conent(object_uri)
+      connection.raw_get("#{url_for(object_uri)}?format=xml").body
+    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 = { :format => '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?#{to_query(params)}#{includes}"))
+    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 create(object)
+      case object
+        when Fedora::FedoraObject
+          pid = (object.pid ? object : 'new')
+          response = connection.post("#{url_for(pid)}?" + object.attributes.to_query, object.xml_content)
+          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?
+          response = connection.post("#{url_for(object)}?" + object.attributes.to_query, 
+            object.xml_content)
+          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_query)
+        response.code == '307'
+      when Fedora::Datastream
+        raise ArgumentError, "Missing dsID attribute" if object.dsid.nil?
+        response = connection.put("#{url_for(object)}?" + object.attributes.to_query, object.xml_content)
+        response.code == '201'
+      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'
+    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}?#{to_query(extra_params)}").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.symbolize_keys!) }
+        when Hash
+          results << FedoraObject.new(objectFields.symbolize_keys!)
+      end
+      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 = ActiveResource::Connection.new(@fedora_url, Fedora::XmlFormat)
+      end
+      @connection
+    end
+    
+    def extract_pid(response)
+      CGI.unescape(response['Location'].split('/').last)
+    end
+    
+    #   {:q => 'test', :num => 5}.to_query # => 'q=test&num=5'
+    def to_query(hash)
+      hash.collect { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.sort * '&'
+    end
+  end
+end
+
+class FedoraObjects < Array
+  attr_accessor :session_token
+end
+