umlaut 3.3.1 → 4.0.0.beta1

data/app/helpers/resolve_helper.rb

@@ -175,6 +175,7 @@ module ResolveHelper
     # for limit.
     options = {:limit => options} unless options.kind_of?(Hash)
     options[:limit] ||= 5
+    options[:ul_class] ||= "list-unstyled"
     return "" if list.empty?
     visible_list  = (list.length > options[:limit]) ? list.slice(0, options[:limit]-1) : list
     hidden_list   = (list.length > options[:limit]) ? list.slice((options[:limit]-1)..list.length-1) : []
@@ -261,8 +262,8 @@ module ResolveHelper
       return nil
     end
 
-    start   = response[:coverage_begin_date].try(:year) || I18n.t("umlaut.coverage_summary.open_start", :default => "first")
-    finish  = response[:coverage_end_date].try(:year) || I18n.t("umlaut.coverage_summary.open_end", :default => "latest")
+    start   = response[:coverage_begin_date].try(:year) || I18n.t("umlaut.citation.coverage_summary.open_start")
+    finish  = response[:coverage_end_date].try(:year) || I18n.t("umlaut.citation.coverage_summary.open_end")
 
     content_tag("span", :class=>"coverage_summary") do
       "#{start} – #{finish}:"

data/app/helpers/search_helper.rb

@@ -7,56 +7,53 @@ module SearchHelper
   end
 
   # pass in an openurl context obj.
-  # return an OpenStruct with atitle_label, title_label
+  # return an OpenStruct with :atitle and :title labels
+  #
+  # Uses i18n
+  #
+  # Much of this duplicates Referent.type_thing_name and container_type_of_thing, 
+  # although we don't have a Referent here, that logic should be combined. TODO
   def referent_labels(context_obj = @current_context_object)
     ref_meta = context_obj.referent.metadata
     result = OpenStruct.new
-    if ref_meta['genre'].blank?
-      case @current_context_object.referent.format 
-      when  'book'
-        result.atitle = 'Chapter/Part Title'
-      when @current_context_object.referent.format == 'journal'
-        result.atitle = 'Article Title'
-      end
-      result.title = 'Title'      
-    else
-      case ref_meta["genre"]
-      when /article|journal|issue/
-        result.atitle = 'Article Title'
-        result.title = 'Journal Title'
-      when /bookitem|book/
-        result.atitle = 'Chapter/Part Title'
-        result.title = 'Book Title'
-      when /proceeding|conference/
-        result.atitle = 'Proceeding Title'
-        result.title = 'Conference Name'
-      when 'report'
-        result.atitle = 'Report Title'
-        result.title = 'Report'
-      end
+
+    type_of_thing_key = ref_meta['genre']
+    type_of_thing_key = context_obj.referent.format if type_of_thing_key.blank?
+    type_of_thing_key = type_of_thing_key.downcase
+
+    a_key = type_of_thing_key
+    if a_key == "journal" && ref_meta['atitle'].present?
+      a_key = "article"
     end
+    result.atitle = I18n.t(a_key, :scope => "umlaut.citation.genre", :default => "")
+
+    c_key = type_of_thing_key
+    c_key = 'journal' if c_key == "article"
+    c_key = 'book'    if c_key == "bookitem"
+    result.title =  I18n.t(c_key, :scope => "umlaut.citation.genre", :default => "")
+
     return result    
   end
   
   # A-Z buttons in search page
   def group_list
-    group_list ||= ('A'..'Z').to_a.push('0-9').push('Other')  
+    group_list ||= ('A'..'Z').to_a.push('0-9').push(t('umlaut.search.browse_other'))
   end
 
   # Date dropdowns in search page
-  def date
+  def search_date_select
     years + months + days
   end
 
   def years
-    select_year(nil, {:prompt => true, :start_year => Date.today.year, :end_year => 1950}, {:name => "__year", :class=>"year input-small"})
+    select_year(nil, {:prompt => true, :start_year => Date.today.year, :end_year => 1950}, {:name => "__year", :class=>"year form-control"})
   end
 
   def months
-    select_month(nil, {:prompt => true, :use_short_month => true}, {:name => "__month", :class=>"month input-small"})
+    select_month(nil, {:prompt => true, :use_short_month => true}, {:name => "__month", :class=>"month form-control"})
   end
 
   def days
-    select_day(nil, {:prompt => true}, {:name => "__day", :class=>"day input-small"})
+    select_day(nil, {:prompt => true}, {:name => "__day", :class=>"day form-control"})
   end
 end

data/app/helpers/umlaut/footer_helper.rb

@@ -11,7 +11,7 @@ module Umlaut::FooterHelper
     if @collection
       content = "".html_safe
             
-      content << "Powered by ".html_safe + link_to("Umlaut", "https://github.com/team-umlaut/umlaut") + ". ".html_safe
+      content << t('umlaut.misc.powered_by_umlaut').html_safe + " " + link_to("Umlaut", "https://github.com/team-umlaut/umlaut") + ". ".html_safe
       
       credit_segments = []
       
@@ -31,9 +31,7 @@ module Umlaut::FooterHelper
       
       
       if credit_segments.length > 0
-        content << "Using services from ".html_safe
-        content << credit_segments.join(", ").html_safe
-        content << " and others.".html_safe
+        content << t("umlaut.misc.credits_html", :credits => safe_join(credit_segments, ", "))
       end
       
       return content
@@ -65,9 +63,9 @@ module Umlaut::FooterHelper
     options = {:text => "[D]", :title => "Toggle on-screen debug info"}.merge(options)
     
     text = options.delete(:text)
-    javascript = " jQuery('.debug_info').toggle();"  
+    options[:onclick] ||= " jQuery('.debug_info').toggle();"  
   
-    return link_to_function(text, javascript, options)  
+    return link_to(text, "#", options)  
   end
 
 end

data/app/helpers/umlaut/helper.rb

@@ -7,8 +7,6 @@ module Umlaut::Helper
   include Umlaut::FooterHelper
   include Umlaut::HtmlHeadHelper
   
-  
-  
   # pass in an OpenURL::ContextObject, outputs a link.
   def resolver_link(context_object, params={})
     
@@ -72,11 +70,12 @@ module Umlaut::Helper
   end
 
   def render_umlaut_permalink_toggle    
-
-    link_to({:action => "get_permalink", :"umlaut.request_id" => @user_request.id}, 
-             :class => "umlaut-load-permalink btn btn-mini", 
+    link_to({:controller => "resolve", 
+             :action => "get_permalink", 
+             :"umlaut.request_id" => @user_request.id}, 
+             :class => "umlaut-load-permalink btn btn-default btn-xs", 
              :data => {"umlaut-toggle-permalink"=>"true"}) do
-        content_tag("i") + " Short link"
+        content_tag("i") + " #{t('umlaut.permalink.name')}"
     end
   end
 
@@ -94,5 +93,40 @@ module Umlaut::Helper
     end
   end
 
-  
+  # Create dropdown if we have multiple locales, link if just two
+  def render_locale_selector
+    num_locales = I18n.config.available_locales.size
+    if num_locales > 2
+      render_locale_dropdown
+    elsif num_locales == 2
+      render_locale_link
+    end
+  end
+
+  # create a link for the non-active locale
+  def render_locale_link
+    locales = I18n.config.available_locales
+    other_locale = (locales - [I18n.locale]).pop
+    link_to t(:language_name, :locale => other_locale), params.merge(:'umlaut.locale' => other_locale)
+  end
+
+  # Create a dropdown with the current language at the top
+  def render_locale_dropdown
+    locale_options = Array.new
+    #make sure the locales display with their titles
+    I18n.config.available_locales.each do |loc|
+      locale_options.push([t('language_name', :locale => loc), loc])
+    end
+    form_tag({controller: params[:controller], action: params[:action]}, {method: "get"} ) do
+      #output select tag with language options, current language set to selected
+      concat(select_tag('umlaut.locale'.to_sym, options_for_select(locale_options, I18n.locale), onchange: 'this.form.submit()'))
+       # send the url params as hidden fields
+       params.each do |param|
+         unless param[0] == 'controller' || param[0] == 'action' || param[0] == 'umlaut.locale'
+           concat(hidden_field_tag("#{param[0]}", "#{param[1]}"))
+         end
+       end
+    end
+  end
+
 end

data/app/helpers/umlaut/url_generation.rb

@@ -11,33 +11,14 @@ module Umlaut::UrlGeneration
   # This is neccesary for our partial_html_sections service
   # to work properly. Just set @generate_url_with_host = true
   # in your controller, and urls will be generated with hostnames
-  # for the remainder of that action. 
-  def url_for(argument = {})    
-    if @generate_urls_with_host
-      case argument
-      when Hash
-        # Force only_path = false if not already set
-        argument[:only_path] = false if argument[:only_path].nil?
-        return super(argument)
-      when String
-        # We already have a straight string, if it looks relative, 
-        # absolutize it. 
-        if argument.starts_with?("/")
-          return root_url.chomp("/") + argument
-        else
-          return super(argument)
-        end
-      when :back
-        return super(argument)
-      else 
-        # polymorphic, we want to force polymorphic_url instead
-        # of default polymorphic_path         
-        return polymorphic_url(argument)
-      end    
-    else
-      # @generate_urls_with_host not set, just super
-      super(argument)
-    end    
+  # for the remainder of that action.
+  def url_for(*arguments)
+    url = super
+    if @generate_urls_with_host && url.starts_with?("/")
+      #regex replace trailing slashes or trailing locale if present
+      url = root_url.gsub(/(\/$)?(\/\?.*)?/, '') + url
+    end
+    return url
   end
 
   # over-ride path_to_image to generate complete urls with hostname and everything
@@ -58,7 +39,7 @@ module Umlaut::UrlGeneration
   
   # We want stylesheets and javascripts to do the exact same thing,
   # magic of polymorphous super() makes it work:
-  def path_to_stylesheet(source)
+  def path_to_stylesheet(*args)
     path = super
     if @generate_urls_with_host    
       path = request.protocol() + request.host_with_port() + path
@@ -66,7 +47,7 @@ module Umlaut::UrlGeneration
     return path
   end
 
-  def path_to_javascript(source)
+  def path_to_javascript(*args)
     path = super
     if @generate_urls_with_host    
       path = request.protocol() + request.host_with_port() + path

data/app/mixin_logic/umlaut_http.rb

@@ -35,11 +35,14 @@ module UmlautHttp
 
     # Bunch of headers we proxy as-is from the original client request,
     # supplying reasonable defaults. 
-    
     header["User-Agent"] = orig_env['HTTP_USER_AGENT'] || 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0'
     header['Accept'] = orig_env['HTTP_ACCEPT'] || 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
     header['Accept-Language'] = orig_env['HTTP_ACCEPT_LANGUAGE'] || 'en-us,en;q=0.5'
-    header['Accept-Encoding'] = orig_env['HTTP_ACCEPT_ENCODING'] || ''
+
+    # Do NOT pass on accept-encoding, we don't want gzip or compressed response. 
+    #header['Accept-Encoding'] = orig_env['HTTP_ACCEPT_ENCODING'] || ''
+    header['Accept-Encoding'] = "identity"
+
     header["Accept-Charset"] = orig_env['HTTP_ACCEPT_CHARSET'] || 'UTF-8,*'
 
     # Set referrer to be, well, an Umlaut page, like the one we are

data/app/models/collection.rb

@@ -1,4 +1,5 @@
 require 'cron_tab' # for understanding CronTab format for expiring responses.
+require 'confstruct'
 
 # A Collection object encapsulates a given UmlautRequest, and a given
 # list of Umlaut services that should be run off that request.
@@ -12,13 +13,15 @@ require 'cron_tab' # for understanding CronTab format for expiring responses.
 # foreground and background, making sure no service is run twice if it's
 # already in progress, timing out expired services, etc.
 class Collection
-
   attr_accessor :umlaut_request
   attr_accessor :logger
   # configs
   attr_accessor :response_expire_interval, :response_expire_crontab_format, :background_service_timeout, :requeue_failedtemporary_services
 
-
+  # generally only set to true in testing, can be set for the whole class
+  # or for particular Collection instances. 
+  class_attribute :forward_background_exceptions
+  self.forward_background_exceptions = true
   
   # a_umlaut_request is an UmlautRequest, representing a request for services for a context
   # object.
@@ -60,12 +63,15 @@ class Collection
   #
   # Sets all services in collection to have a 'queued' status if appropriate.
   # Then actually executes the services that are dispatchable (queued).
+  #
+  # Returns the Thread object used for dispatching background services
   def dispatch_services!
     queued_service_ids = prepare_for_dispatch!
 
     dispatch_foreground!(queued_service_ids)
 
-    dispatch_background!(queued_service_ids)
+    # return main thread for background services.
+    return dispatch_background!(queued_service_ids)
   end
 
   # Call prepare_for_dispatch! first, the return value from that call
@@ -96,6 +102,8 @@ class Collection
   # marked queued in the DispatchedService table.
   #
   # Will run such services in background priority waves.
+  #
+  # Returns the Thread object used for dispatching background services. 
   def dispatch_background!(queued_service_ids)
     # Now we do some crazy magic, start a Thread to run our background
     # services. We are NOT going to wait for this thread to join,
@@ -134,7 +142,14 @@ class Collection
         # and logged to db as well as logfile if possible, only bugs in ServiceWave
         # itself should wind up caught here.
         Thread.current[:exception] = e
-        logger.error("Background Service execution exception: #{e}\n\n   " + clean_backtrace(e).join("\n"))
+        logger.error("Background Service execution exception: #{e}\n\n   " + Rails.backtrace_cleaner.clean(e.backtrace).join("\n"))
+
+        # One exception is in test environment, when we may be intentionally
+        # trying to get exceptions to propagate up from ServiceWave to here,
+        # and then onward, in order to be caught by tests. 
+        if self.forward_background_exceptions
+          raise e
+        end
       end
     end
   end
@@ -155,6 +170,7 @@ class Collection
     # Go through currently dispatched services, looking for timed out
     # services -- services still in progress that have taken too long,
     # as well as service responses that are too old to be used.
+
     queued_service_ids = []
     DispatchedService.transaction do
       umlaut_request.dispatched_services.each do | ds |
@@ -193,8 +209,7 @@ class Collection
               end
             end
 
-            umlaut_request.dispatched_services.delete(ds)
-            ds.destroy
+            umlaut_request.dispatched_services.destroy(ds)            
           end
       end
 

data/app/models/dispatched_service.rb

@@ -27,6 +27,19 @@ class DispatchedService < ActiveRecord::Base
     @service ||= ServiceStore.instantiate_service!( self.service_id, request )
   end
 
+  # Calls service.service_type_generated, but cautious of service_id
+  # that is no longer in the ServiceStore
+  #
+  # Note, this means all service types that could possibly be generated
+  # by this service, not those that actually have been
+  def can_generate_service_types
+    if ServiceStore.service_definition_for( self.service_id ) 
+      service.service_types_generated
+    else
+      []
+    end
+  end
+
   # For old-time's sake, true can be used for Succesful
   # and false can be used for FailedTemporary (that keeps
   # previous semantics for false intact). 

data/app/models/referent.rb

@@ -1,3 +1,5 @@
+require 'i18n'
+
 # Note: There are a few actual attributes stored as Columns in referent --
 # these were originally used for identifying a Referent identifying the
 # 'same thing' as an incoming OpenURL, to re-use it. But we don't re-use
@@ -15,9 +17,9 @@ class Referent < ActiveRecord::Base
   has_many :referent_values
   has_many :permalinks
 
-  # Does call save! on referent created.
-  # :permalink => false if you already have a permalink and don't
-  # need to create one. Caller should attach that permalink to this referent!
+  # Pass in :permalink => :force to force creation of a permalink, otherwise
+  # no permalink is created by this method, one can be lazily created when
+  # needed. 
   def self.create_by_context_object(co, options = {})    
     self.clean_up_context_object(co)    
     
@@ -40,10 +42,10 @@ class Referent < ActiveRecord::Base
       rft.referent_values.each do | val |
         rft.atitle = val.normalized_value if val.key_name == 'atitle' and val.metadata?
         rft.title = val.normalized_value if val.key_name.match(/^[bj]?title$/) and val.metadata? 
-        rft.issn = val.normalized_value if val.key_name == 'issn' and val.metadata?
-        rft.isbn = val.normalized_value if val.key_name == 'isbn' and val.metadata?      
+        rft.issn = val.normalized_value.gsub(/[^\d]/, '')[0,8] if val.key_name == 'issn' and val.metadata?
+        rft.isbn = val.normalized_value.gsub(/[^\d]/, '')[0,13] if val.key_name == 'isbn' and val.metadata?      
         rft.volume = val.normalized_value if val.key_name == 'volume' and val.metadata?
-        rft.year = val.normalized_value if val.key_name == 'date' and val.metadata?
+        rft.year = val.normalized_value.gsub(/[^\d]/, '')[0,4] if val.key_name == 'date' and val.metadata?
       end
       rft.save!
 
@@ -107,61 +109,44 @@ class Referent < ActiveRecord::Base
   end
 
 
-  # Find or create a ReferentValue object hanging off this
-  # Referent, with given key name and value. key_name can
-  # be 'identifier', 'format', or any metadata key.
-  def ensure_value!(key_name, value)
-     normalized_value = ReferentValue.normalize(value)
-     
-     rv = ReferentValue.find(:first, 
-                       :conditions => { :referent_id => self.id,
-                                        :key_name => key_name,
-                                        :normalized_value => normalized_value })
-      unless (rv)
-        rv = ReferentValue.new
-        rv.referent = self
-        
-        rv.key_name = key_name
-        rv.value = value
-        rv.normalized_value = normalized_value
-        
-        if key_name == "private_data"
-          rv.private_data = true
-        elsif key_name != "identifier" && key_name != "format"
-          rv.metadata = true
-        end
-
-        rv.save!
-      end
-      return rv
+  # private use. Adds a referent_value and returns it, does NOT persist
+  # it to db. referent_value is constructed with ActiveRecord build, and
+  # will be saved when Referent (self) is saved, works on persisted or
+  # unpersisted Referent. 
+  def build_referent_value(key_name, value)
+    return self.referent_values.build(
+      :key_name         => key_name, 
+      :value            => value, 
+      :normalized_value => ReferentValue.normalize(value),
+      :private_data     => (key_name == "private_data"),
+      :metadata         => (key_name != "identifier" && key_name != "format")
+    )
   end
+
   
   # Populate the referent_values table with a ropenurl contextobject object
+  # Note, does NOT save self, self may still be unsaved. 
   def set_values_from_context_object(co)
-    
     rft = co.referent
-
   
     # Multiple identifiers are possible! 
     rft.identifiers.each do |id_string|
-      ensure_value!('identifier', id_string)            
+      build_referent_value('identifier', id_string)            
     end
     if rft.format
-      ensure_value!('format', rft.format)
+      build_referent_value('format', rft.format)
     end
     if rft.private_data
       # this comes in as "pid" or "rft_dat", we store it in
       # our database as "private_data", sorry, easiest way to
       # fit this in at the moment. 
-      ensure_value!("private_data", rft.private_data)
+      build_referent_value("private_data", rft.private_data)
     end
     
     rft.metadata.each { | key, value |
-      next unless value
-      ensure_value!( key, value)      
-    }
-
-    
+      next unless value.present?
+      build_referent_value( key, value)      
+    }    
   end
 
   # pass in a Referent, or a ropenurl ContextObjectEntity that has a metadata
@@ -219,17 +204,14 @@ class Referent < ActiveRecord::Base
 
   def add_identifier(id)
     unless ( identifiers.find{|i| i == id}  )
-      self.referent_values.create(:key_name => 'identifier', :value => id, :normalized_value => ReferentValue.normalize(id), :metadata => false, :private_data => false).save!            
+      Referent.with_connection do 
+        self.referent_values.create(:key_name => 'identifier', :value => id, :normalized_value => ReferentValue.normalize(id), :metadata => false, :private_data => false).save!            
+      end
     end
   end
   
   def format
-    self.referent_values
-    self.referent_values.each { | val |    
-      if val.key_name == 'format'
-        return val.value
-      end
-    }    
+    self.referent_values.to_a.find { | val | val.key_name == 'format'}.try(:value)
   end
 
   # Some shortcuts for pulling out/manipulating specific especially
@@ -281,7 +263,8 @@ class Referent < ActiveRecord::Base
 
   # Creates a hash for use in View code to display a citation
   #
-  # Crazy if/else tree logic, should be refactored, needs more tests first prob. 
+  # TODO, move to_citation, type_of_thing, and container_type_of_thing OUT
+  # of Refernet, to helper module or own class. 
   def to_citation
     citation = {}
     # call self.metadata once and use the array for efficiency, don't
@@ -290,43 +273,24 @@ class Referent < ActiveRecord::Base
 
     if my_metadata['atitle'].present?
       citation[:title] = my_metadata['atitle']
-      citation[:title_label], citation[:container_label] = 
-        case my_metadata['genre']
-          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', 'book']
-          elsif self.format == 'journal'
-            ['Article Title', 'Journal']
-          else # default fall through, use much what SFX uses. 
-            ['Title', '']
-          end
-        end
       ['title','btitle','jtitle'].each do | t_type |
-        if ! my_metadata[t_type].blank?
-          citation[:subtitle] = my_metadata[t_type]
-          citation[:container_title] = my_metadata[t_type]
+        if my_metadata[t_type].present?
+          citation[:container_title] = my_metadata[t_type]      
           break
         end
       end
-    else      
-      citation[:title_label] = case my_metadata["genre"]
-        when /article|journal|issue/i then 'Journal'
-        when /bookitem|book/i then 'Book'
-        when /proceeding|conference/i then 'Conference'
-        when 'report' then 'Report'
-        else nil
-      end
+    else # only top-level thing, no sub-thing
       ['title','btitle','jtitle'].each do | t_type |
-        if ! my_metadata[t_type].blank?
+        if my_metadata[t_type].present?
           citation[:title] = my_metadata[t_type]
           break
         end
       end      
     end
+
+    citation[:title_label] = I18n.t("umlaut.citation.title_of_x", :x =>  self.type_of_thing, :default => "umlaut.citation.title_label")
+    citation[:container_label] = self.container_type_of_thing    
+
     # add publisher for books
     if (my_metadata['genre'] =~ /book/i)
       citation[:pub] = my_metadata['pub'] unless my_metadata['pub'].blank?
@@ -372,26 +336,40 @@ class Referent < ActiveRecord::Base
   end
 
   def type_of_thing
-    genre = self.metadata["genre"]
-    genre = nil if genre =~ /^unknown$/i
-    genre = "book section" if genre =~ /^bookitem$/i
+    metadata = self.metadata
 
-    return genre
+    key = metadata["genre"]
+    key = self.format if key.blank?
+    key = key.downcase
+
+    if key == "journal" && metadata['atitle'].present?
+      key = 'article'
+    end
+    
+    label = I18n.t(key, :scope => "umlaut.citation.genre", :default => "")
+    label = nil if label.blank?
+
+    return label
   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'] || self.format
+    i18n_key = case self.metadata['genre']    
+      when 'article'  then 'journal'
+      when 'bookitem' then 'book'
+      else self.metadata['genre'] || self.format
     end
+
+    label = I18n.t(i18n_key, :scope => "umlaut.citation.genre", :default => "")
+    label = nil if label.blank?
+
+    return label
   end
 
 
   def remove_value(key)
-    referent_values.find(:all, :conditions=> ['key_name =?', key]).each do |rv|
+    referent_values.where(:key_name => key).to_a.each do |rv|
+      rv.delete
       referent_values.delete(rv)
     end    
   end