active-fedora 3.0.7 → 3.1.0.pre1

data/lib/fedora/base.rb

@@ -1,38 +0,0 @@
-require 'xmlsimple'
-
-class Hash
-  
-  # Produces a valid Fedora query based on the current hash
-  # @example
-  #   {:q => 'test', :num => 5}.to_fedora_query # => 'q=test&num=5'
-  def to_fedora_query
-    self.collect { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.sort * '&'
-  end
-  
-  def self.from_xml(xml)
-    XmlSimple.xml_in(xml, 'ForceArray' => false)
-  end
-end
-
-class Fedora::BaseObject
-  attr_accessor :attributes, :blob, :uri
-  attr_reader :errors, :uri
-  attr_writer :new_object
-  
-  # @param [Hash] attrs object attributes
-  def initialize(attrs = {})
-    @new_object = true
-    @attributes = attrs || {}
-    @errors = []
-    @blob = attributes.delete(:blob)
-    @repository = Fedora::Repository.instance
-  end
-  
-  def [](key)
-    @attributes[key]
-  end
-  
-  def new_object?
-    @new_object
-  end
-end

data/lib/fedora/connection.rb

@@ -1,218 +0,0 @@
-require "base64"
-gem 'multipart-post'
-require 'net/http/post/multipart'
-require 'cgi'
-require "mime/types"
-require 'net/http'
-require 'net/https'
-
-
-
-module Fedora
-  # This class is based on ActiveResource::Connection so MIT license applies.
-  class ConnectionError < StandardError # :nodoc:
-    attr_reader :response
-
-    def initialize(response, message = nil)
-      @response = response
-      @message  = message
-    end
-
-    def to_s
-      "Failed with #{response.code} #{@message.to_s}"
-    end
-  end
-
-  # 3xx Redirection
-  class Redirection < ConnectionError # :nodoc:
-    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end    
-  end 
-
-  # 4xx Client Error
-  class ClientError < ConnectionError; end # :nodoc:
-  
-  # 400 Bad Request
-  class BadRequest < ClientError; end # :nodoc
-  
-  # 401 Unauthorized
-  class UnauthorizedAccess < ClientError; end # :nodoc
-  
-  # 403 Forbidden
-  class ForbiddenAccess < ClientError; end # :nodoc
-  
-  # 404 Not Found
-  class ResourceNotFound < ClientError; end # :nodoc:
-  
-  # 409 Conflict
-  class ResourceConflict < ClientError; end # :nodoc:
-
-  # 5xx Server Error
-  class ServerError < ConnectionError; end # :nodoc:
-
-  # 405 Method Not Allowed
-  class MethodNotAllowed < ClientError # :nodoc:
-    def allowed_methods
-      @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
-    end
-  end
-
-  # Class to handle connections to remote web services.
-  # This class is used by ActiveResource::Base to interface with REST
-  # services.
-  class Connection
-    attr_reader :site, :surrogate
-    attr_accessor :format
-
-    class << self
-      def requests
-        @@requests ||= []
-      end
-    end
-
-    # The +site+ parameter is required and will set the +site+
-    # attribute to the URI for the remote resource service.
-    def initialize(site, format = ActiveResource::Formats[:xml], surrogate=nil)
-      raise ArgumentError, 'Missing site URI' unless site
-      self.site = site
-      self.format = format
-      @surrogate=surrogate
-    end
-
-    # Set URI for remote service.
-    def site=(site)
-      @site = site.is_a?(URI) ? site : URI.parse(site)
-    end
-
-    # Execute a GET request.
-    # Used to get (find) resources.
-    def get(path, headers = {})
-      format.decode(request(:get, path, build_request_headers(headers)).body)
-    end
-
-    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
-    # Used to delete resources.
-    def delete(path, headers = {})
-      request(:delete, path, build_request_headers(headers))
-    end
-
-
-
-    def raw_get(path, headers = {})
-      request(:get, path, build_request_headers(headers))
-    end
-    def post(path, body='', headers={})
-      do_method(:post, path, body, headers)
-    end
-    def put( path, body='', headers={})
-      do_method(:put, path, body, headers)
-    end
-
-    private
-    def do_method(method, path, body = '', headers = {})
-      meth_map={:put=>Net::HTTP::Put::Multipart, :post=>Net::HTTP::Post::Multipart}
-      raise "undefined method: #{method}" unless meth_map.has_key? method
-      headers = build_request_headers(headers) 
-      if body.respond_to?(:read)
-        if body.respond_to?(:original_filename?)
-          filename = File.basename(body.original_filename)
-          io = UploadIO.new(body, mime_type,filename)
-        elsif body.path
-          filename = File.basename(body.path)
-        else
-          filename="NOFILE"
-        end
-        mime_types = MIME::Types.of(filename)
-        mime_type ||= mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
-
-        io = nil
-        if body.is_a?(File)
-          io = UploadIO.new(body.path,mime_type)
-        else
-          io =UploadIO.new(body, mime_type, filename)
-        end
-
-        req = meth_map[method].new(path, {:file=>io}, headers)
-        multipart_request(req)
-      else
-        request(method, path, body.to_s, headers)
-      end
-    end
-    def multipart_request(req)
-      result = nil
-      result = http.start do |conn|
-        conn.read_timeout=60600 #these can take a while
-        conn.request(req)
-      end
-      handle_response(result)
-
-    end
-
-    # Makes request to remote service.
-    def request(method, path, *arguments)
-      result = http.send(method, path, *arguments)
-      handle_response(result)
-    end
-
-    # Handles response and error codes from remote service.
-    def handle_response(response)
-      message = "Error from Fedora: #{response.body}"
-      case response.code.to_i
-      when 301,302
-        raise(Redirection.new(response))
-      when 200...400
-        response
-      when 400
-        raise(BadRequest.new(response, message))
-      when 401
-        raise(UnauthorizedAccess.new(response, message))
-      when 403
-        raise(ForbiddenAccess.new(response, message))
-      when 404
-        raise(ResourceNotFound.new(response, message))
-      when 405
-        raise(MethodNotAllowed.new(response, message))
-      when 409
-        raise(ResourceConflict.new(response, message))
-      when 422
-        raise(ResourceInvalid.new(response, message))
-      when 423...500
-        raise(ClientError.new(response, message))
-      when 500...600
-        raise(ServerError.new(response, message))
-      else
-        raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
-      end
-    end
-
-    # Creates new Net::HTTP instance for communication with
-    # remote service and resources.
-    def http
-      http = Net::HTTP.new(@site.host, @site.port)
-      if(@site.is_a?(URI::HTTPS))
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-        if (defined?(SSL_CLIENT_CERT_FILE) && !SSL_CLIENT_CERT_FILE.nil? && defined?(SSL_CLIENT_KEY_FILE) && !SSL_CLIENT_KEY_FILE.nil? && defined?(SSL_CLIENT_KEY_PASS) && !SSL_CLIENT_KEY_PASS.nil?)
-          http.cert = OpenSSL::X509::Certificate.new( File.read(SSL_CLIENT_CERT_FILE) )
-          http.key = OpenSSL::PKey::RSA.new( File.read(SSL_CLIENT_KEY_FILE), SSL_CLIENT_KEY_PASS )
-        end
-      end
-      http
-    end
-
-    def default_header
-      @default_header ||= { 'Content-Type' => format.mime_type }
-    end
-
-    # Builds headers for request to remote service.
-    def build_request_headers(headers)
-      headers.merge!({"From"=>surrogate}) if @surrogate
-      authorization_header.update(default_header).update(headers)
-    end
-
-    # Sets authorization header; authentication information is pulled from credentials provided with site URI.
-    def authorization_header
-      (@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
-    end
-  end
-end

data/lib/fedora/datastream.rb

@@ -1,67 +0,0 @@
-require 'fedora/base'
-require 'fedora/repository'
-
-class Fedora::Datastream < Fedora::BaseObject
-  
-  
-  def initialize(attrs = {})
-    super
-    if attrs
-      if attrs[:mime_type]
-        self.mime_type = attrs[:mime_type]
-      elsif attrs[:mimeType]
-        self.mime_type = attrs[:mimeType]
-      elsif attrs["mimeType"]
-        self.mime_type = attrs["mimeType"]
-      elsif attrs["mime_type"]
-        self.mime_type = attrs["mime_type"]
-      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
-  
-  def mime_type
-    @mime_type
-  end
-
-  def mime_type=(new_mime_type)
-    @mime_type =  new_mime_type
-  end
-
-  # See http://www.fedora.info/definitions/identifiers/
-  def uri
-    "fedora:info/#{pid}/datastreams/#{dsid}"
-  end
-  
-  # @return [String] 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

@@ -1,161 +0,0 @@
-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
-  
-  # @return [String] url of the datastream 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