ruby-fedora 0.1.2 → 0.9.0

data/lib/active_fedora/relationship.rb

@@ -0,0 +1,43 @@
+module ActiveFedora
+  
+  class Relationship 
+    
+    attr_accessor :subject, :predicate, :object, :is_literal, :data_type
+    def initialize(attr={})
+      attr.merge!({:is_literal => false})
+      self.subject = attr[:subject]
+      @predicate = attr[:predicate]
+      self.object = attr[:object]
+      @is_literal = attr[:is_literal]
+      @data_type = attr[:data_type]
+    end
+    
+    def subject=(subject)
+      @subject = generate_uri(subject)
+    end
+    
+    def subject_pid=(pid)
+      @subject = "info:fedora/#{pid}"
+    end
+    
+    def object=(object)
+      @object = generate_uri(object)
+    end
+    
+    def object_pid=(pid)
+      @object = "info:fedora/#{pid}"
+    end
+    
+    def generate_uri(input)
+      if input.class == Symbol || input == nil
+        return input
+      elsif input.respond_to?(:pid)
+        return "info:fedora/#{input.pid}"
+      else
+        input.include?("info:fedora") ? input : "info:fedora/#{input}"
+      end
+    end
+  
+  end
+  
+end

data/lib/active_fedora/rels_ext_datastream.rb

@@ -0,0 +1,43 @@
+require 'active_fedora/semantic_node'
+
+module ActiveFedora
+  class RelsExtDatastream < Datastream
+    
+    include ActiveFedora::SemanticNode
+    
+    def initialize(attrs=nil)
+      super
+      self.dsid = "RELS-EXT"
+    end
+    
+    def save
+      if @dirty == true
+        self.content = to_rels_ext(self.pid)
+      end
+      super
+    end
+      
+    def pid=(pid)
+      super
+      self.blob = <<-EOL
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="info:fedora/#{pid}">
+        </rdf:Description>
+      </rdf:RDF>
+      EOL
+    end
+    
+    def to_solr(solr_doc = Solr::Document.new)
+      self.relationships.each_pair do |subject, predicates|
+        if subject == :self || subject == "info:fedora/#{self.pid}"
+          predicates.each_pair do |predicate, values|
+            values.each do |val|
+              solr_doc << Solr::Field.new("#{predicate}_field" => val)
+            end
+          end
+        end
+      end
+      return solr_doc
+    end
+  end
+end

data/lib/active_fedora/semantic_node.rb

@@ -0,0 +1,221 @@
+module ActiveFedora
+  module SemanticNode 
+    include MediaShelfClassLevelInheritableAttributes
+    ms_inheritable_attributes  :class_relationships, :internal_uri
+    include Extlib::Assertions
+    
+    attr_accessor :internal_uri, :relationships
+    
+    PREDICATE_MAPPINGS = Hash[:is_member_of => "isMemberOf",
+                          :is_part_of => "isPartOf",
+                          :has_part => "hasPart",
+                          :conforms_to => "conformsTo"]
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    def add_relationship(relationship)
+      # Only accept ActiveFedora::Relationships as input arguments
+      assert_kind_of 'relationship',  relationship, ActiveFedora::Relationship
+      register_triple(relationship.subject, relationship.predicate, relationship.object)
+    end
+    
+    def register_triple(subject, predicate, object)
+      register_subject(subject)
+      register_predicate(subject, predicate)
+      relationships[subject][predicate] << object
+    end
+    
+    def register_subject(subject)
+      if !relationships.has_key?(subject) 
+          relationships[subject] = {} 
+      end
+    end
+  
+    def register_predicate(subject, predicate)
+      register_subject(subject)
+      if !relationships[subject].has_key?(predicate) 
+        relationships[subject][predicate] = []
+      end
+    end
+    
+    def outbound_relationships()
+      if !internal_uri.nil? && !relationships[internal_uri].nil?
+        return relationships[:self].merge(relationships[internal_uri]) 
+      else
+        return relationships[:self]
+      end
+    end
+    
+    def relationships
+      @relationships ||= relationships_from_class
+    end
+    
+    def relationships_from_class
+      rels = {}
+      self.class.relationships.each_pair do |subj, pred|
+        rels[subj] = {}
+        pred.each_key do |pred_key|
+          rels[subj][pred_key] = []
+        end
+      end
+      #puts "rels from class: #{rels.inspect}"
+      return rels
+    end
+    
+    # Creates a RELS-EXT datastream for insertion into a Fedora Object
+    # @pid
+    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+    def to_rels_ext(pid, relationships=self.relationships)
+      starter_xml = <<-EOL
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="info:fedora/#{pid}">
+        </rdf:Description>
+      </rdf:RDF>
+      EOL
+      xml = REXML::Document.new(starter_xml)
+    
+      # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
+      # puts ""
+      # puts "Iterating through a(n) #{self.class}"
+      # puts "=> whose relationships are #{self.relationships.inspect}"
+      # puts "=> and whose outbound relationships are #{self.outbound_relationships.inspect}"
+      self.outbound_relationships.each do |predicate, targets_array|
+        targets_array.each do |target|
+          # puts ". #{predicate} #{target}"
+          xml.root.elements["rdf:Description"].add_element(self.class.predicate_lookup(predicate), {"xmlns" => "info:fedora/fedora-system:def/relations-external#", "rdf:resource"=>target})
+        end
+      end
+      xml.to_s
+    end
+    
+    module ClassMethods
+      
+    # Anticipates usage of a relationship in classes that include this module
+    # Creates a key in the @relationships array for the predicate provided.  Assumes
+    # :self as the subject of the relationship unless :inbound => true, in which case the 
+    # predicate is registered under @relationships[:inbound][#{predicate}]
+    #
+    # TODO:
+    # Custom Methods:
+    # A custom finder method will be appended based on the relationship name.
+    # ie. 
+    # class Foo
+    #   relationship "container", :is_member_of  
+    # end
+    # foo = Foo.new
+    # foo.parts
+    #
+    # Special Predicate Short Hand:
+    # These symbols map to the uris of corresponding Fedora RDF predicates
+    # :is_member_of, :has_member, :is_part_of, :has_part  
+      def has_relationship(name, predicate, opts = {})
+        opts = {:singular => nil, :inbound => false}.merge(opts)
+        opts[:inbound] == true ? register_predicate(:inbound, predicate) : register_predicate(:self, predicate) 
+      
+        if opts[:inbound] == true
+          create_inbound_relationship_finders(name, predicate, opts)
+        else        
+          create_outbound_relationship_finders(name, predicate, opts)
+        end
+      
+      end
+    
+      def create_inbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END
+        def #{name}
+          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
+          hits = SolrService.instance.conn.query("#{predicate}_field:\#{escaped_uri}").hits
+          results = []
+          hits.each do |hit|
+            classname = Kernel.const_get(hit["active_fedora_model_field"].first)
+            results << Fedora::Repository.instance.find_model(hit["id"], classname)
+          end
+          return results
+        end
+        def #{name}_ids
+          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
+          SolrService.instance.conn.query("#{predicate}_field:\#{escaped_uri}")
+        end 
+        END
+      end
+    
+      def create_outbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END
+        def #{name}
+          results = []
+          outbound_relationships[#{predicate.inspect}].each do |rel|
+            uri_as_pid = rel.gsub("info:fedora/", "")
+            results << Fedora::Repository.instance.find_model(uri_as_pid, ActiveFedora::Base)
+          end
+          return results
+        end
+        def #{name}_ids
+          results = []
+          outbound_relationships[#{predicate.inspect}].each do |rel|
+            results << rel
+          end
+        end 
+        END
+      end
+    
+      # relationships are tracked as a hash of structure {subject => {predicate => [object]}}
+      def relationships
+        @class_relationships ||= Hash[:self => {}]
+      end
+    
+    
+      def register_subject(subject)
+        if !relationships.has_key?(subject) 
+            relationships[subject] = {} 
+        end
+      end
+    
+      def register_predicate(subject, predicate)
+        register_subject(subject)
+        if !relationships[subject].has_key?(predicate) 
+          relationships[subject][predicate] = []
+        end
+      end
+    
+      #alias_method :register_target, :register_object
+    
+      # Creates a RELS-EXT datastream for insertion into a Fedora Object
+      # @pid
+      # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+      def relationships_to_rels_ext(pid, relationships=self.relationships)
+        starter_xml = <<-EOL
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+          <rdf:Description rdf:about="info:fedora/#{pid}">
+          </rdf:Description>
+        </rdf:RDF>
+        EOL
+        xml = REXML::Document.new(starter_xml)
+      
+        # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
+        self.outbound_relationships.each do |predicate, targets_array|
+          targets_array.each do |target|
+            #puts ". #{predicate} #{target}"
+            xml.root.elements["rdf:Description"].add_element(predicate_lookup(predicate), {"xmlns" => "info:fedora/fedora-system:def/relations-external#", "rdf:resource"=>target})
+          end
+        end
+        xml.to_s
+      end
+    
+      # If predicate is a symbol, looks up the predicate in the PREDICATE_MAPPINGS
+      # If predicate is not a Symbol, returns the predicate untouched
+      # @throws UnregisteredPredicateError if the predicate is a symbol but is not found in the PREDICATE_MAPPINGS
+      def predicate_lookup(predicate)
+        if predicate.class == Symbol 
+          if PREDICATE_MAPPINGS.has_key?(predicate)
+            return PREDICATE_MAPPINGS[predicate]
+          else
+            throw UnregisteredPredicateError
+          end
+        end
+        return predicate
+      end
+    end
+  end
+end

data/lib/active_fedora/solr_service.rb

@@ -0,0 +1,20 @@
+require 'solr'
+module ActiveFedora 
+  class SolrService
+    attr_reader :conn
+    def self.register(host=nil, args={})
+      Thread.current[:solr_service]=self.new(host, args)
+
+    end
+    def initialize(host, args)
+      host = 'http://localhost:8080/solr' unless host
+      opts = {:autocommit=>:on}.merge(args)
+      @conn = Solr::Connection.new(host, opts)
+    end
+    def self.instance
+      raise SolrNotInitialized unless Thread.current[:solr_service]
+      Thread.current[:solr_service]
+    end
+  end
+  class SolrNotInitialized < StandardError;end
+end

data/lib/fedora/base.rb

@@ -12,7 +12,7 @@ class Hash
 end
 
 class Fedora::BaseObject
-  attr_accessor :attributes, :blob, :uri, :url
+  attr_accessor :attributes, :blob, :uri
   attr_reader :errors, :uri
   attr_writer :new_object
   
@@ -24,6 +24,7 @@ class Fedora::BaseObject
     @attributes = attrs || {}
     @errors = []
     @blob = attributes.delete(:blob)
+    @repository = Fedora::Repository.instance
   end
   
   def [](key)

data/lib/fedora/connection.rb

@@ -1,64 +1,14 @@
 require "base64"
+gem 'multipart-post'
+require 'net/http/post/multipart'
 require 'cgi'
 require "mime/types"
 require 'net/http'
 require 'net/https'
 
-# 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={})
-    mime_type = param_hash.delete(:content_type)
-    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, mime_type)
-      when String then text_to_multipart(param_name, param_value, mime_type)
-      else ""      
-      end
-    }.join('') + "--#{boundary_token}--\r\n"
-  end
-  
-private
-  def file_to_multipart(key,file, mime_type = nil)
-    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
 
-module RubyFedora
+module Fedora
   # This class is based on ActiveResource::Connection so MIT license applies.
   class ConnectionError < StandardError # :nodoc:
     attr_reader :response
@@ -110,7 +60,7 @@ module RubyFedora
   # This class is used by ActiveResource::Base to interface with REST
   # services.
   class Connection
-    attr_reader :site
+    attr_reader :site, :surrogate
     attr_accessor :format
 
     class << self
@@ -121,10 +71,11 @@ module RubyFedora
 
     # 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])
+    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.
@@ -144,97 +95,116 @@ module RubyFedora
       request(:delete, path, build_request_headers(headers))
     end
 
-    # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
-    # Used to update resources.
-    def put(path, body = '', headers = {})
-      if body.is_a?(File)
-        multipart_request(Net::HTTP::Put.new(path, build_request_headers(headers)), body, headers)      
-      else
-        request(:put, path, body.to_s, build_request_headers(headers))
-      end      
-    end
-        
-    # Execute a POST request.
-    # Used to create new resources.
-    def post(path, body = '', headers = {})
-      if body.is_a?(File)
-        multipart_request(Net::HTTP::Post.new(path, build_request_headers(headers)), body, headers)
-      else
-        request(:post, path, body.to_s, build_request_headers(headers))
-      end
-    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 multipart_request(req, file, headers = {})
-        result = nil
-        http.start do |conn|
-          req.set_multipart_data(:file => file, :content_type => headers['Content-Type'])
-          result = conn.request(req)
+    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
-        handle_response(result)
+        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
-    
-      # Makes request to remote service.
-      def request(method, path, *arguments)
-        result = http.send(method, path, *arguments)
-        handle_response(result)
+    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)
 
-      # Handles response and error codes from remote service.
-      def handle_response(response)
-        case response.code.to_i
-          when 301,302
-            raise(Redirection.new(response))
-          when 200...400
-            response
-          when 400
-            raise(BadRequest.new(response))
-          when 401
-            raise(UnauthorizedAccess.new(response))
-          when 403
-            raise(ForbiddenAccess.new(response))
-          when 404
-            raise(ResourceNotFound.new(response))
-          when 405
-            raise(MethodNotAllowed.new(response))
-          when 409
-            raise(ResourceConflict.new(response))
-          when 422
-            raise(ResourceInvalid.new(response))
-          when 401...500
-            raise(ClientError.new(response))
-          when 500...600
-            raise(ServerError.new(response))
-          else
-            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
-        end
-      end
+    end
 
-      # Creates new Net::HTTP instance for communication with
-      # remote service and resources.
-      def http
-        http             = Net::HTTP.new(@site.host, @site.port)
-        http.use_ssl     = @site.is_a?(URI::HTTPS)
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
-        http
-      end
+    # Makes request to remote service.
+    def request(method, path, *arguments)
+      result = http.send(method, path, *arguments)
+      handle_response(result)
+    end
 
-      def default_header
-        @default_header ||= { 'Content-Type' => format.mime_type }
-      end
-      
-      # Builds headers for request to remote service.
-      def build_request_headers(headers)
-        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") } : {})
+    # Handles response and error codes from remote service.
+    def handle_response(response)
+      case response.code.to_i
+      when 301,302
+        raise(Redirection.new(response))
+      when 200...400
+        response
+      when 400
+        raise(BadRequest.new(response))
+      when 401
+        raise(UnauthorizedAccess.new(response))
+      when 403
+        raise(ForbiddenAccess.new(response))
+      when 404
+        raise(ResourceNotFound.new(response))
+      when 405
+        raise(MethodNotAllowed.new(response))
+      when 409
+        raise(ResourceConflict.new(response))
+      when 422
+        raise(ResourceInvalid.new(response))
+      when 401...500
+        raise(ClientError.new(response))
+      when 500...600
+        raise(ServerError.new(response))
+      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)
+      http.use_ssl     = @site.is_a?(URI::HTTPS)
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+      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