active-fedora 1.0.5 → 1.1.0

data/lib/active_fedora/base.rb

@@ -6,7 +6,7 @@ SOLR_DOCUMENT_ID = "id" unless defined?(SOLR_DOCUMENT_ID)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
 
 module ActiveFedora
-
+  
   # This class ties together many of the lower-level modules, and
   # implements something akin to an ActiveRecord-alike interface to
   # fedora. If you want to represent a fedora object in the ruby
@@ -32,6 +32,7 @@ module ActiveFedora
     ms_inheritable_attributes  :ds_specs
     include Model
     include SemanticNode
+    include SolrMapper
 
     has_relationship "collection_members", :has_collection_member
     
@@ -56,7 +57,7 @@ module ActiveFedora
         attrs = attrs.merge!({:pid=>Fedora::Repository.instance.nextid})  
         @new_object=true
       else
-        @new_object=false
+        @new_object = attrs[:new_object] == false ? false : true
       end
       @inner_object = Fedora::FedoraObject.new(attrs)
       @datastreams = {}
@@ -75,23 +76,24 @@ module ActiveFedora
     #Saves a Base object, and any dirty datastreams, then updates 
     #the Solr index for this object.
     def save
-      metadata_is_dirty = false
+      #@metadata_is_dirty = false
       # If it's a new object, set the conformsTo relationship for Fedora CMA
       if new_object? 
-        add_relationship(:conforms_to, ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
-        metadata_is_dirty = true
+        result = create
+      else
+        result = update
       end
       @new_object = false
-      Fedora::Repository.instance.save(@inner_object)
-      datastreams_in_memory.each do |k,ds|
-        if ds.dirty? || ds.new_object? 
-          if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.instance_of?(ActiveFedora::RelsExtDatastream)
-            metadata_is_dirty = true
-          end
-          ds.save
-        end 
-      end
-      self.update_index if metadata_is_dirty == true && ENABLE_SOLR_UPDATES
+      self.update_index if @metadata_is_dirty == true && ENABLE_SOLR_UPDATES
+      @metadata_is_dirty == false
+      return result
+    end
+    
+    # Refreshes the object's info from Fedora
+    # Note: Currently just registers any new datastreams that have appeared in fedora
+    def refresh
+      inner_object.load_attributes_from_fedora
+      @datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
     end
 
     #Deletes a Base object, also deletes the info indexed in Solr, and 
@@ -115,7 +117,8 @@ module ActiveFedora
       if @new_object
         @datastreams = datastreams_in_memory
       else
-        @datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
+        @datastreams = (@datastreams == {}) ? datastreams_in_fedora : datastreams_in_memory
+        #@datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
       end
 
     end
@@ -327,10 +330,11 @@ module ActiveFedora
     def self.deserialize(doc) #:nodoc:
       pid = doc.elements['/foxml:digitalObject'].attributes['PID']
       
-      proto = self.new(:pid=>pid)
+      proto = self.new(:pid=>pid, :new_object=>false)
       proto.datastreams.each do |name,ds|
-        ds.new_object = false
         doc.elements.each("//foxml:datastream[@ID='#{name}']") do |el|
+          # datastreams remain marked as new if the foxml doesn't have an entry for that datastream
+          ds.new_object = false
           proto.datastreams[name]=ds.class.from_xml(ds, el)
         end
       end
@@ -343,7 +347,7 @@ module ActiveFedora
     #system_create_date, system_modified_date, active_fedora_model_field, 
     #and the object id.
     def fields
-      fields = {:id => {:values => [pid]}, :system_create_date => {:values => [self.create_date]}, :system_modified_date => {:values => [self.modified_date]}, :active_fedora_model_field => {:values => [self.class.inspect]}}
+      fields = {:id => {:values => [pid]}, :system_create_date => {:values => [self.create_date], :type=>:date}, :system_modified_date => {:values => [self.modified_date], :type=>:date}, :active_fedora_model => {:values => [self.class.inspect], :type=>:symbol}}
       datastreams.values.each do |ds|        
         fields.merge!(ds.fields) if ds.kind_of?(ActiveFedora::MetadataDatastream)
       end
@@ -353,7 +357,7 @@ module ActiveFedora
     #Returns the xml version of this object as a string.
     def to_xml(xml=REXML::Document.new("<xml><fields/><content/></xml>"))
       fields_xml = xml.root.elements['fields']
-      {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model_field => self.class.inspect}.each_pair do |attribute_name, value|
+      {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model => self.class.inspect}.each_pair do |attribute_name, value|
         el = REXML::Element.new(attribute_name.to_s)
         el.text = value
         fields_xml << el
@@ -366,7 +370,7 @@ module ActiveFedora
 
     #Return a Solr::Document version of this object.
     def to_solr(solr_doc = Solr::Document.new)
-      solr_doc << {SOLR_DOCUMENT_ID.to_sym => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model_field => self.class.inspect}
+      solr_doc << {SOLR_DOCUMENT_ID.to_sym => pid, solr_name(:system_create, :date) => self.create_date, solr_name(:system_modified, :date) => self.modified_date, solr_name(:active_fedora_model, :symbol) => self.class.inspect}
       datastreams.each_value do |ds|
         solr_doc = ds.to_solr(solr_doc) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
       end
@@ -440,7 +444,9 @@ module ActiveFedora
       else
         ds_array = datastreams.values
       end
+      result = params.dup
       params.each do |key,value|
+        result[key] = value.dup
         ds_array.each do |dstream|
           if dstream.fields[key.to_sym]
             aname="#{key}_values"
@@ -454,13 +460,20 @@ module ActiveFedora
                 false
               end
             end 
-            cpv.each { |y,z| curval<<z}#just append everything left
+            cpv.each do |y,z| 
+              curval<<z #just append everything left
+              if y == "-1"
+                new_array_index = curval.length - 1
+                result[key][new_array_index.to_s] = params[key]["-1"]
+              end
+            end
             curval.delete_if {|x| x == :delete || x == "" || x == nil}
             dstream.send("#{aname}=", curval) #write it back to the ds
           end
         end
+        result[key].delete("-1")
       end
-
+      return result
     end
     
     def self.pids_from_uris(uris) 
@@ -485,6 +498,29 @@ module ActiveFedora
         end
       end
     end
+    
+    # Deals with preparing new object to be saved to Fedora, then pushes it and its datastreams into Fedora. 
+    def create
+      add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
+      @metadata_is_dirty = true
+      update
+      #@datastreams = datastreams_in_fedora
+    end
+    
+    # Pushes the object and all of its new or dirty datastreams into Fedora
+    def update
+      result = Fedora::Repository.instance.save(@inner_object)
+      datastreams_in_memory.each do |k,ds|
+        if ds.dirty? || ds.new_object? 
+          if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.instance_of?(ActiveFedora::RelsExtDatastream)
+            @metadata_is_dirty = true
+          end
+          result = ds.save
+        end 
+      end
+      refresh
+      return result
+    end
 
 
   end

data/lib/active_fedora/datastream.rb

@@ -6,7 +6,7 @@ module ActiveFedora
     
     attr_accessor :dirty, :last_modified, :fields
   
-    def initialize(attrs = nil)
+    def initialize(attrs = {})
       @fields={}
       @dirty = false
       super

data/lib/active_fedora/metadata_datastream.rb

@@ -1,6 +1,9 @@
 module ActiveFedora
   #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
   class MetadataDatastream < Datastream
+    
+    include ActiveFedora::SolrMapper
+    
     attr_accessor :fields
 
     #constructor, calls up to ActiveFedora::Datastream's constructor
@@ -110,13 +113,17 @@ module ActiveFedora
     protected
 
     def generate_solr_symbol(field_name, field_type) # :nodoc:
-      if field_name.to_s[-field_type.to_s.length - 1 .. -1] == "_#{field_type.to_s}"
-        return field_name.to_sym
-      elsif field_type == :string
-        return "#{field_name.to_s}_field".to_sym
-      else
-        return "#{field_name.to_s}_#{field_type.to_s}".to_sym
-      end
+      solr_name(field_name, field_type)
+      # #if field_name.to_s[-field_type.to_s.length - 1 .. -1] == "_#{field_type.to_s}"
+      # #  return field_name.to_sym
+      # case field_type
+      # when :date
+      #   return "#{field_name.to_s}_dt".to_sym
+      # when :string
+      #   return "#{field_name.to_s}_t".to_sym
+      # else
+      #   return "#{field_name.to_s}_t".to_sym
+      # end
     end
 
   end

data/lib/active_fedora/model.rb

@@ -56,14 +56,14 @@ module ActiveFedora
       def find(args)
         if args == :all
           escaped_class_name = self.name.gsub(/(:)/, '\\:')
-          q = "active_fedora_model_field:#{escaped_class_name}"
+          q = "active_fedora_model_s:#{escaped_class_name}"
         elsif args.class == String
           escaped_id = args.gsub(/(:)/, '\\:')
           q = "#{SOLR_DOCUMENT_ID}:#{escaped_id}"
         end
         hits = SolrService.instance.conn.query(q).hits 
         results = hits.map do |hit|
-          obj = Fedora::Repository.instance.find_model(hit["id"], self)
+          obj = Fedora::Repository.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
           #obj.inner_object.new_object = false
           #return obj
         end
@@ -77,7 +77,7 @@ module ActiveFedora
 
 
       #  If query is :all, this method will query Solr for all instances
-      #  of self.type (based on active_fedora_model_field as indexed
+      #  of self.type (based on active_fedora_model_s as indexed
       #  by Solr). If the query is any other string, this method simply does
       #  a pid based search (id:query). 
       #
@@ -89,7 +89,7 @@ module ActiveFedora
       def find_by_solr(query, args={})
         if query == :all
           escaped_class_name = self.name.gsub(/(:)/, '\\:')
-          SolrService.instance.conn.query("active_fedora_model_field:#{escaped_class_name}", args)
+          SolrService.instance.conn.query("active_fedora_model_s:#{escaped_class_name}", args)
         elsif query.class == String
           escaped_id = query.gsub(/(:)/, '\\:')          
           SolrService.instance.conn.query("#{SOLR_DOCUMENT_ID}:#{escaped_id}", args)

data/lib/active_fedora/rels_ext_datastream.rb

@@ -43,7 +43,7 @@ module ActiveFedora
         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)
+              solr_doc << Solr::Field.new("#{predicate}_s" => val)
             end
           end
         end

data/lib/active_fedora/semantic_node.rb

@@ -26,7 +26,8 @@ module ActiveFedora
                           :is_annotation_of => "isAnnotationOf",
                           :has_annotation => "hasAnnotation",
                           :has_equivalent => "hasEquivalent",
-                          :conforms_to => "conformsTo"]
+                          :conforms_to => "conformsTo",
+                          :has_model => "hasModel"]
     PREDICATE_MAPPINGS.freeze
     
     def self.included(klass)
@@ -147,14 +148,14 @@ module ActiveFedora
         class_eval <<-END
         def #{name}(opts={})
           escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
-          solr_result = SolrService.instance.conn.query("#{predicate}_field:\#{escaped_uri}")
+          solr_result = SolrService.instance.conn.query("#{predicate}_s:\#{escaped_uri}")
           if opts[:response_format] == :solr
             return solr_result
           else
             if opts[:response_format] == :id_array
               id_array = []
               solr_result.hits.each do |hit|
-                id_array << hit["id"]
+                id_array << hit[SOLR_DOCUMENT_ID]
               end
               return id_array
             else

data/lib/active_fedora/solr_mapper.rb

@@ -0,0 +1,17 @@
+require 'active_fedora/solr_service'
+
+module ActiveFedora 
+  module SolrMapper
+    
+    # Generates solr field names from settings in solr_mappings
+    def solr_name(field_name, field_type)
+      name = field_name.to_s + ActiveFedora::SolrService.mappings[field_type.to_s].to_s
+      if field_name.kind_of?(Symbol)
+        return name.to_sym
+      else
+        return name.to_s
+      end
+    end
+    
+  end
+end

data/lib/active_fedora/solr_service.rb

@@ -1,7 +1,9 @@
 require 'solr'
 module ActiveFedora 
   class SolrService
+    @@mappings = {}
     attr_reader :conn
+        
     def self.register(host=nil, args={})
       Thread.current[:solr_service]=self.new(host, args)
 
@@ -11,26 +13,29 @@ module ActiveFedora
       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
+    
     def self.reify_solr_results(solr_result)
       unless solr_result.is_a?(Solr::Response::Standard)
         raise ArgumentError.new("Only solr responses (Solr::Response::Standard) are allowed. You provided a #{solr_result.class}")
       end
       results = []
       solr_result.hits.each do |hit|
-        model_value = hit["active_fedora_model_field"].first
+        model_value = hit["active_fedora_model_s"].first
         if model_value.include?("::")
           classname = eval(model_value)
         else
           classname = Kernel.const_get(model_value)
         end
-        results << Fedora::Repository.instance.find_model(hit["id"], classname)
+        results << Fedora::Repository.instance.find_model(hit[SOLR_DOCUMENT_ID], classname)
       end
       return results
     end
+    
     def self.construct_query_for_pids(pid_array)
       query = ""
       pid_array.each_index do |i|
@@ -40,9 +45,46 @@ module ActiveFedora
       query = "id:NEVER_USE_THIS_ID" if query.empty? || query == "id:"
       return query
     end
+    
     def self.escape_uri_for_query(uri)
       return uri.gsub(/(:)/, '\\:')
     end
+    
+    def self.mappings
+      @@mappings
+    end
+    def self.mappings=(mappings)
+      @@mappings = mappings
+    end    
+    
+    def self.logger      
+      @logger ||= defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : Logger.new(STDOUT)
+    end
+    
+    # Loads solr mappings from yml file.
+    # @config_path This is the path to the directory where your mappings file is stored. @default "RAILS_ROOT/config/solr_mappings.yml"
+    # @mappings_file This is the filename for your solr mappings YAML file.  @default solr_mappings.yml
+    def self.load_mappings( config_path=nil )
+
+      if config_path.nil? 
+        if defined?(RAILS_ROOT)
+          config_path = File.join(RAILS_ROOT, "config", "solr_mappings.yml")
+        end
+        # Default to using the config file within the gem 
+        if !File.exist?(config_path.to_s)
+          config_path = File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings.yml")          
+        end
+      end
+
+      logger.info("FEDORA: loading SolrService mappings from #{File.expand_path(config_path)}")
+
+      @@mappings = YAML::load(File.open(config_path))
+      
+      mappings["id"] = "id" unless mappings["id"]
+    end
+    
+    self.load_mappings
+    
   end
   class SolrNotInitialized < StandardError;end
 end

data/lib/fedora/base.rb

@@ -0,0 +1,38 @@
+require 'xmlsimple'
+
+class Hash
+  #   {:q => 'test', :num => 5}.to_query # => 'q=test&num=5'
+  #   let's avoid stomping on rails' version eh?
+  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
+  
+  # == Parameters
+  # attrs<Hash>:: 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

@@ -0,0 +1,210 @@
+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} #{response.message if response.respond_to?(:message)}"
+    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)
+      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