umlaut 3.0.5 → 3.1.0.pre1

data/app/models/permalink.rb

@@ -1,29 +1,24 @@
 # attribute context_obj_serialized has an XML OpenURL ContextObject sufficient to restore
 # the original request and resolve the permalink. A link to a referent is
 # also stored. But the referent may be purged, so self.referent may be null.
-# The serialized contextobject will still be there. 
+# The serialized contextobject will still be there.
 class Permalink < ActiveRecord::Base
   belongs_to :referent
 
   # You should create Permalinks with this. Pass in a referent and referrer
   #. Will save  permalink to db
   def self.new_with_values!(rft, rfr_id)
-    permalink = Permalink.new        
-
+    permalink = Permalink.new
     permalink.referent = rft
     permalink.orig_rfr_id = rfr_id
-    
     permalink.context_obj_serialized = permalink.referent.to_context_object.xml
-
     permalink.save!
-    
     return permalink
   end
 
-
   # Takes the XML stored in self.context_obj_serialized, and turns it back
   # into an OpenURL ContextObject
   def restore_context_object
     return OpenURL::ContextObject.new_from_xml(self.context_obj_serialized)
   end
-end
+end

data/app/models/referent.rb

@@ -19,9 +19,6 @@ class Referent < ActiveRecord::Base
   # :permalink => false if you already have a permalink and don't
   # need to create one. Caller should attach that permalink to this referent!
   def self.create_by_context_object(co, options = {})    
-    options = { :permalink => UmlautController.umlaut_config.create_permalinks    
-    }.merge(options)
-        
     self.clean_up_context_object(co)    
     
     rft = Referent.new
@@ -33,10 +30,12 @@ class Referent < ActiveRecord::Base
       
       rft.set_values_from_context_object(co)
 
-      unless ( options[:permalink] == false)
-        permalink = Permalink.new_with_values!(rft, co.referrer.identifier)            
+      # Permalinks created on-demand later. But if set config to :force, can
+      # force old behavior. 
+      if options[:permalink] == :force
+        permalink = Permalink.new_with_values!(rft, co.referrer.identifier)
       end
-  
+
       # Add shortcuts.
       rft.referent_values.each do | val |
         rft.atitle = val.normalized_value if val.key_name == 'atitle' and val.metadata?
@@ -289,19 +288,19 @@ class Referent < ActiveRecord::Base
 
     if my_metadata['atitle'] && ! my_metadata['atitle'].blank?
       citation[:title] = my_metadata['atitle']
-      citation[:title_label], citation[:subtitle_label] = 
+      citation[:title_label], citation[:container_label] = 
         case my_metadata['genre']
-          when /article|journal|issue/ then ['Article Title', 'Journal Title']
-          when /bookitem|book/ then ['Chapter/Part Title', 'Book Title']
-          when /proceeding|conference/ then ['Proceeding Title', 'Conference Name']
-          when 'report' then ['Report Title','Report']    
+          when /article|journal|issue/ then ['Article Title', 'journal']
+          when /bookitem|book/ then ['Chapter/Part Title', 'book']
+          when /proceeding|conference/ then ['Proceeding Title', 'conference']
+          when 'report' then ['Report Title','report']    
           else
           if self.format == 'book'
-            ['Chapter/Part Title', 'Title']
+            ['Chapter/Part Title', 'book']
           elsif self.format == 'journal'
-            ['Article Title', 'Journal Title']
+            ['Article Title', 'journal']
           else # default fall through, use much what SFX uses. 
-            ['Title', 'Source']
+            ['Title', '']
           end
         end
       ['title','btitle','jtitle'].each do | t_type |
@@ -313,11 +312,11 @@ class Referent < ActiveRecord::Base
       end
     else      
       citation[:title_label] = case my_metadata["genre"]
-        when /article|journal|issue/ then 'Journal Title'
-        when /bookitem|book/ then 'Book Title'
-        when /proceeding|conference/ then 'Conference Name'
-        when 'report' then 'Report Title'
-        else'Title'
+        when /article|journal|issue/ then 'journal'
+        when /bookitem|book/ then 'book'
+        when /proceeding|conference/ then 'conference'
+        when 'report' then 'report'
+        else ''
       end
       ['title','btitle','jtitle'].each do | t_type |
         if ! my_metadata[t_type].blank?
@@ -372,13 +371,22 @@ class Referent < ActiveRecord::Base
   def type_of_thing
     genre = self.metadata["genre"]
     genre = nil if genre =~ /^unknown$/i
-    genre ||= "resource"
-
     genre = "book section" if genre =~ /^bookitem$/i
 
     return genre
   end
 
+  # Like type_of_thing, but if it's a contained item, give container name instead. 
+  # TODO: All of this should be I18n'd. 
+  def container_type_of_thing
+    case self.metadata["genre"]
+    when 'article'  then 'journal'
+    when 'bookitem' then 'book'
+    else self.metadata['genre']
+    end
+  end
+
+
   def remove_value(key)
     referent_values.find(:all, :conditions=> ['key_name =?', key]).each do |rv|
       referent_values.delete(rv)

data/app/models/request.rb

@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'cgi'
 
 # An ActiveRecord which represents a parsed OpenURL resolve service request,
 # and other persistent state related to Umlaut's handling of that OpenURL 
@@ -24,6 +25,9 @@ class Request < ActiveRecord::Base
   # options[:allow_create] => false, will not create a new request, return
   # nil if no existing request can be found. 
   def self.find_or_create(params, session, a_rails_request, options = {} )
+
+
+
     # Pull out the http params that are for the context object,
     # returning a CGI::parse style hash, customized for what
     # ContextObject.new_from_form_vars wants. 
@@ -47,8 +51,15 @@ class Request < ActiveRecord::Base
     request_id = nil if req == nil
 
     # Serialized fingerprint of openurl http params, suitable for looking
-    # up in the db to see if we've seen it before. 
-    param_fingerprint = self.co_params_fingerprint( co_params )
+    # up in the db to see if we've seen it before. We got our co_params
+    # direct from parsing path ourselves, but in case a before_filter
+    # added in certain other params after that, we want to merge them in
+    # too. 
+    fingerprintable_params = co_params.merge(
+      {"umlaut.service_group" => params["umlaut.service_group"]}.delete_if {|k, v| v.blank?} 
+    )
+    param_fingerprint = self.co_params_fingerprint( fingerprintable_params )
+    
     client_ip = params['req.ip'] || a_rails_request.remote_ip()
     
     unless (req || params["umlaut.force_new_request"] == "true" || param_fingerprint.blank? )
@@ -80,14 +91,13 @@ class Request < ActiveRecord::Base
   # We pull out a hash of request params (get and post) that
   # define a context object. We use CGI::parse instead of relying
   # on Rails parsing because rails parsing ignores multiple params
-  # with same key value, which is legal in CGI.
+  # with same key value, which is legal in CGI and is sometimes used in OpenURLs. 
   #
   # So in general values of this hash will be an array.
   # ContextObject.new_from_form_vars is good with that. 
   # Exception is url_ctx_fmt and url_ctx_val, which we'll
   # convert to single values, because ContextObject wants it so. 
-  def self.context_object_params(a_rails_request)
-    require 'cgi'
+  def self.context_object_params(a_rails_request)   
     
     # GET params
     co_params = CGI::parse( a_rails_request.query_string )    
@@ -102,9 +112,9 @@ class Request < ActiveRecord::Base
     co_params.delete(nil)
 
     # Exclude params that are for Rails or Umlaut, and don't belong to the
-    # context object. Except leave in umlaut.institution, that matters for
-    # cachability. 
-    excluded_keys = ["action", "controller", "page", /^umlaut\.(?!institution)/, 'rft.action', 'rft.controller']
+    # context object. Except leave in umlaut.* keys that DO matter for
+    # cacheability, like umlaut.institution (legacy) and umlaut.service_group
+    excluded_keys = ["action", "controller", "page", /\Aumlaut\.(?!(institution|service_group\[\])\Z)/, 'rft.action', 'rft.controller']
     co_params.keys.each do |key|
       excluded_keys.each do |exclude|
         co_params.delete(key) if exclude === key;
@@ -409,6 +419,7 @@ class Request < ActiveRecord::Base
   #
   # Returns nil if there aren't any params to include in the fingerprint.
   def self.co_params_fingerprint(params)
+
     # Don't use ctx_time, consider two co's equal if they are equal but for ctx_tim. 
     # exclude cache-busting "_" key that JQuery adds. Fine to bust HTTP cache, but
     # don't want to it to force new Umlaut processing. 

data/app/models/service_response.rb

@@ -11,6 +11,10 @@ ServiceResponses have a few basic attributes stored in columns in the db: 'displ
 
 In addition, there's a Hash (automatically serialized by ActiveRecord) that's stored in service_data, for arbitrary additional data that a Service can store--whatever you want, just put it in. However, there are conventions that Views expect, see below.  You can access ALL the arbitrary key/values in a ServiceResponse, built-in in attributes or from the serialized Hash, by the proxy object returned from #data_values.
 
+You can create a ServiceResponse object with ServiceResponse.create_from_hash, 
+where the hash keys may be direct iVar columns, or serialized in the
+service_data hash, you don't have to care. 
+
 ServiceResponse is connected to a Request via the ServiceType join table. The data architecture allows a ServiceResponse to be tied to multiple requests, perhaps to support some kind of cacheing re-use in the future. But at present, the code doesn't do this, a ServiceResponse will really only be related to one request. However, a ServiceResponse can be related to a single Request more than once--once per each type of service response. ServiceType is really a three way join, representing a ServiceResponse, attached to a particular Request, with a particular ServiceTypeValue.  
 
 
@@ -42,6 +46,12 @@ These are applicable only when the incoming OpenURL is an article-level citation
 
   [:coverage_checked]  boolean, default true.  False for links from, eg, the catalog, where we weren't able to pre-check if the particular citation is included at this link.
   [:can_link_to_article] boolean, default true. False if the links is _known_ not to deliver user to actual article requested, but just to a title-level page. Even though SFX links sometimes incorrectly do this, they are still not set to false here.  
+  
+== Coverage dates
+Generally only for fulltext. Right now only supplied by SFX. 
+
+  [:coverage_begin_date]  Ruby Date object representing start of coverage
+  [:coverage_end_date]  Ruby Date object representing end of coverage
  
 == highlighted_link (see also)
  [:source]   (optional, otherwise service's display_name is used)
@@ -80,7 +90,7 @@ These are applicable only when the incoming OpenURL is an article-level citation
 
 =end
 class ServiceResponse < ActiveRecord::Base  
-  @@built_in_fields = [:display_text, :url, :notes, :response_key, :value_string, :value_alt_string, :value_text]
+  @@built_in_fields = [:display_text, :url, :notes, :response_key, :value_string, :value_alt_string, :value_text, :id]
   belongs_to :request
   serialize :service_data  
   # This value is not stored in db, but is set temporarily so
@@ -98,6 +108,15 @@ class ServiceResponse < ActiveRecord::Base
     super(params)
     self.service_data = {} unless self.service_data
   end
+  
+  # Create from a hash of key/values, where some keys
+  # may be direct iVars, some may end up serialized in service_data, 
+  # you don't have to care, it will do the right thing. 
+  def self.create_from_hash(hash)
+    r = ServiceResponse.new
+    r.take_key_values(hash)
+    return r
+  end
 
   # Instantiates and returns a new Service associated with this response.
   def service
@@ -135,9 +154,11 @@ class ServiceResponse < ActiveRecord::Base
   def take_key_values(hash)    
     # copy it, cause we're gonna modify it
     hash = hash.clone
+
     hash.each_pair do |key, value|
-      if ( self.class.built_in_fields.include?(key))
-        self.send(key.to_s + '=', value)
+      setter = "#{key.to_s}="      
+      if ( self.respond_to?(setter))
+        self.send(setter, value)
         hash.delete(key)
       end
     end

data/app/models/service_store.rb

@@ -1,63 +1,132 @@
-# Loads Service definitions from Rails.root/config/umlaut_services.yml
-# instantiates services from definitions, by id.
+# A ServiceStore is a collection of umlaut service definitions, with identifiers. 
 #
-# It's terrible we need to do this globally like this, but
-# too hard to back out of legacy design now. 
+# There is one default global one that is typically used; originally this
+# was all neccesarily global state, but we refactored to be an actual object,
+# although there's still a default global one used, with class methods
+# that delegate to it, for backwards compat and convenience. 
+#
+# By default, a ServiceStore loads service definitions from 
+# Rails.root/config/umlaut_services.yml . Although in testing,
+# or for future architectural expansion, services can be manually supplied
+# instead. 
+#
+# A ServiceStore instantiates services from definitions, by id, 
+# ServiceStore.instantiate_service!("our_sfx")
+#
+# A ServiceStore's cached service definitions can be reset, useful in
+# testing:  ServiceStore.reset!
+#
+# They'll then be lazily reloaded on next access, unless manually set. 
 class ServiceStore
-  
+  @@global_service_store = ServiceStore.new
+  def self.global_service_store
+    @@global_service_store
+  end
+
+  # certain class methods all default to global default ServiceStore,
+  # for global ServiceStore.  For convenience, and backwards-compat. 
+  [ :config, :"config=", :service_definitions, :service_definition_for, 
+    :'instantiate_service!', :'reset!' ].each do |method|
+    self.define_singleton_method(method) do |*args|      
+      global_service_store.send(method, *args)
+    end
+  end
+
+
   # Returns complete hash loaded from services.yml
-  def self.config
-    # cache hash loaded from YAML, ensure it has the keys we expect. 
-    unless defined? @@services_config_list
+  def config
+    # cache hash loaded from YAML, ensure it has the keys we expect.
+    unless defined? @services_config_list
       yaml_path = File.expand_path("config/umlaut_services.yml", Rails.root)
-      if File.exists? yaml_path
-        @@services_config_list = YAML::load(File.open( yaml_path ))        
-      else
-        @@services_config_list = {}
-      end
-      @@services_config_list["default"] ||= {}
-      @@services_config_list["default"]["services"] ||= {}
+      @services_config_list = (File.exists? yaml_path) ? YAML::load(File.open(yaml_path)) : {}
+      @services_config_list["default"] ||= {}
+      @services_config_list["default"]["services"] ||= {}
     end
-    return @@services_config_list
+    return @services_config_list
   end
-  
+
+  # Manually set a config hash, as would normally be found serialized
+  # in config/umlaut_services.yml.  Useful in testing. All keys
+  # should be strings!! 
+  #
+  # Needs to have the somewhat cumbersome expected structure:
+  # ["default"]["services"] => { "service_id" => definition_hash }  
+  def config=(hash)
+    reset!
+    @services_config_list = hash
+  end
+
   # Returns hash keyed by unique service name, value service definition
-  # hash. 
-  def self.service_definitions
-    unless defined? @@service_definitions
-      @@service_definitions = {}
+  # hash.
+  def service_definitions
+    unless defined? @service_definitions
+      @service_definitions = {}
       config.each_pair do |group_name, group|
-        @@service_definitions.merge!(  group["services"]  ) if group["services"]
+        if group["services"]
+          # Add the group name to each service
+          # in the group
+          group["services"].each_pair do |service_id, service|
+            service["group"] = group_name
+          end
+          # Merge the group's services into the service definitions.
+          @service_definitions.merge!(  group["services"]  )
+        end
       end
       # set service_id key in each based on hash key
-      @@service_definitions.each_pair do |key, hash|
+      @service_definitions.each_pair do |key, hash|
         hash["service_id"] =  key
       end
     end
-    return @@service_definitions
+    return @service_definitions
   end
-  
-  def self.service_definition_for(service_id)
+
+  # Reset cached service definitions. They'll be lazily loaded when asked for, 
+  # typically by being looked up from disk again. Typically used for testing. 
+  def reset!
+    remove_instance_variable "@service_definitions"   if defined? @service_definitions
+    remove_instance_variable "@services_config_list"  if defined? @services_config_list
+  end
+
+  def service_definition_for(service_id)
     return service_definitions[service_id]
   end
-  
-  # pass in string unique key OR a service definition hash, 
+
+  # pass in array of service group ids. eg. ["group1", "-group2"]
+  #
+  # Returns a list of service definition hashes.
+  #
+  # Start with default group(s). Remove any that are mentioned with "-group_id" in
+  # the group list, add in any that are mentioned with "group_id"
+  def determine_services(specified_groups = [])    
+    services = {}
+
+    activated_service_groups = self.config.select do |group_id, group_definition|
+      ((group_id == "default" || group_definition["default"] == true)  ||
+      specified_groups.include?(group_id)) &&
+      ! specified_groups.include?("-#{group_id}")
+    end
+
+    activated_service_groups.each_pair do |group_id, group_definition|
+      services.merge! (group_definition["services"] || {})
+    end
+
+    # Remove any disabled services
+    services.reject! {|service_id, hash| hash && hash["disabled"] == true}
+
+    return services
+  end
+
+
+  # pass in string unique key OR a service definition hash,
   # and a current UmlautRequest.
-  # get back instantiated Service object. 
-  def self.instantiate_service!(service, request)
+  # get back instantiated Service object.
+  def instantiate_service!(service, request)
     definition = service.kind_of?(Hash) ? service : service_definition_for(service.to_s)
-        
-    if definition.nil?
-      raise "Service '#{service}'' does not exist in umlaut-services.yml"
-    end
-    
+    raise "Service '#{service}'' does not exist in umlaut-services.yml" if definition.nil?
     className = definition["type"] || definition["service_id"]
     classConst = Kernel.const_get(className)
     service = classConst.new(definition)
     service.request = request
-
-    return service    
+    return service
   end
-  
-  
 end