RubyGems - umlaut - Versions diffs - 3.0.5 → 3.1.0.pre1 - Mend

umlaut 3.0.5 → 3.1.0.pre1

Files changed (385) hide show

data/app/helpers/umlaut/footer_helper.rb CHANGED Viewed

@@ -15,7 +15,7 @@ module Umlaut::FooterHelper
         content << umlaut_config.footer_credit + " | "
       end
-      content << "Powered by ".html_safe + link_to("Umlaut", "http://github.com/team_umlaut/umlaut") + ". ".html_safe
+      content << "Powered by ".html_safe + link_to("Umlaut", "https://github.com/team-umlaut/umlaut") + ". ".html_safe
       credit_segments = []

data/app/helpers/umlaut/helper.rb CHANGED Viewed

@@ -58,5 +58,39 @@ module Umlaut::Helper
     end
   end
+  # Button for showing permalink, dynamically loaded
+  # with js if neccesary. works with load_permalink.js
+  def render_umlaut_permalink
+    if @user_request
+      content_tag("div", :class => "umlaut-permalink") do
+        render_umlaut_permalink_toggle +
+        render_umlaut_permalink_content
+      end
+    end
+  end
+  def render_umlaut_permalink_toggle
+    link_to({:action => "get_permalink", :"umlaut.request_id" => @user_request.id},
+             :class => "umlaut-load-permalink btn btn-mini",
+             :data => {"umlaut-toggle-permalink"=>"true"}) do
+        content_tag("i") + " Short link"
+    end
+  end
+  # Proper content area to be shown by umlaut_permalink_toggle,
+  # and loaded with content AJAXy.
+  def render_umlaut_permalink_content
+    content_tag("div",
+        :id => "umlaut-permalink-value",
+        :class=> "umlaut-permalink-value",
+        :style => "display: none;",
+        :'data-loaded' => current_permalink_url.present? ) do
+      link_to(current_permalink_url, current_permalink_url) if current_permalink_url
+    end
+  end
 end

data/app/helpers/umlaut/html_head_helper.rb CHANGED Viewed

@@ -1,42 +1,33 @@
 # Rails view helpers for outputting standard Umlaut content included
 # in html <head>. Generally a layout will call #render_umlaut_head_content
-# to render all standard Umlaut <head> content in a future-compatible way.
+# to render all standard Umlaut <head> content in a future-compatible way.
 module Umlaut::HtmlHeadHelper
   # usually called in layout, render a link tag with opensearch auto-discovery
   def render_opensearch_link
-    tag("link",
-        :rel => "search",
-        :type => "application/opensearchdescription+xml",
+    tag("link", :rel => "search", :type => "application/opensearchdescription+xml",
         :title =>  umlaut_config.opensearch_short_name,
-        :href => url_for(:controller=>'open_search', :only_path=>false)
-        )
+        :href => url_for(:controller=>'open_search', :only_path=>false))
   end
   # used on non-js progress page, we need to refresh the page
-  # if requested by presence of @meta_refresh_self ivar.
-  # this method usually called in a layout.
+  # if requested by presence of @meta_refresh_self ivar.
+  # this method usually called in a layout.
   def render_meta_refresh
-     if @meta_refresh_self
-      tag( "meta",
-        "http-equiv" => "refresh",
-        "content" => @meta_refresh_self
-        )
-      else
-        ""
-      end
+    (@meta_refresh_self) ?
+      tag("meta", "http-equiv" => "refresh", "content" => @meta_refresh_self) : ""
   end
   # standard umlaut head content, may later include more
   # stuff, local/custom layouts should call this in HEAD
   # to get forwards-compatible umlaut standard head content
   def render_umlaut_head_content
     render_opensearch_link + render_meta_refresh
   end
   # String meant for use in <title>
   def umlaut_title_text
     umlaut_config.app_name + (@page_title ? " | #{@page_title}" : "")
   end
-end
+end

data/{lib → app/mixin_logic}/marc_helper.rb RENAMED Viewed

@@ -222,7 +222,7 @@ module MarcHelper
     if options[:include_repro_info] && marc['533']
       marc['533'].subfields.each do |s|
         if ( s.code == 'a' )
-          parts.push('<em>' + s.value.gsub(/[^\w\s]/, '') + '</em>:'  )
+          parts.push(s.value.gsub(/[^\w\s]/, '') + ':'  )
         elsif (! options[:exclude_533_fields].include?( s.code ))
           parts.push(s.value)
         end

data/{lib → app/mixin_logic}/metadata_helper.rb RENAMED Viewed

@@ -302,11 +302,12 @@ module MetadataHelper
   end
   # Look at weird bad OpenURLs, use heuristics to see if the 'title' probably
-  # represents a journal rather than a book.
-  def title_is_serial?(rft)
-    (rft.format != "book" &&
-    ( ! rft.metadata['jtitle'].blank?) &&
-    rft.metadata['btitle'].blank?)
+  # represents a journal rather than a book. A guess at best, based on the bad
+  # data we've seen, sigh.
+  def title_is_serial?(rft)
+    rft.format != "book" &&
+    ( rft.metadata['jtitle'].present? || %w{journal article}.include?(rft.metadata["genre"]) ) &&
+    rft.metadata['btitle'].blank?
   end
 end

data/{lib → app/mixin_logic}/umlaut_http.rb RENAMED Viewed

File without changes

data/{lib → app/mixin_logic}/xml_schema_helper.rb RENAMED Viewed

File without changes

data/app/models/collection.rb CHANGED Viewed

@@ -1,4 +1,4 @@
-require 'CronTab' # for understanding CronTab format for expiring responses.
+require 'cron_tab' # for understanding CronTab format for expiring responses.
 # A Collection object encapsulates a given UmlautRequest, and a given
 # list of Umlaut services that should be run off that request.
@@ -6,35 +6,37 @@ require 'CronTab' # for understanding CronTab format for expiring responses.
 # That's exactly what it's initialized with: an umlaut request, and
 # list of service definitions. Third parameter pass in an umlaut configuration
 # object, to get various timeout values. If you don't pass one in, defaults
-# will be used.
+# will be used.
 #
-# The Collection holds and executes the logic for running those services,
+# The Collection holds and executes the logic for running those services,
 # foreground and background, making sure no service is run twice if it's
-# already in progress, timing out expired services, etc.
+# 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
   # a_umlaut_request is an UmlautRequest, representing a request for services for a context
-  # object.
-  # service_hash is a hash of hashes with service definitions, as would
+  # object.
+  # service_hash is a hash of hashes with service definitions, as would
   # be in services.yml
   # config is a Confstruct::Configuration associated with the current controller,
   # has a few config options in it relevant to collection service exec; but
-  # don't pass in, we'll use a blank one with default values, no prob.
-  def initialize(a_umlaut_request, service_hash, config = Confstruct::Configuration.new)
+  # don't pass in, we'll use a blank one with default values, no prob.
+  def initialize(a_umlaut_request, service_hash, config = Confstruct::Configuration.new)
     self.umlaut_request = a_umlaut_request
     self.logger = Rails.logger
     self.response_expire_interval = config.lookup!("response_expire_interval", 1.day)
     self.response_expire_crontab_format = config.lookup!("response_expire_crontab_format", nil)
     self.background_service_timeout =  config.lookup!("background_service_timeout", 30.seconds)
     self.requeue_failedtemporary_services = config.lookup!("requeue_failedtemporary_services", 500.seconds)
     # @service_definitions will be a two-level hash, pointing to an array.. Task is Standard, LinkOut, etc.
     # { [task] => { [priority_level] => [config1, config2, config3],
     #                [priority_level_2] => [configa], }
@@ -43,7 +45,7 @@ class Collection
     @service_definitions_flat = service_hash
     @service_definitions = {}
-    # Arrange services by type and priority in @service_definitions
+    # Arrange services by type and priority in @service_definitions
     gather_services
   end
@@ -52,103 +54,103 @@ class Collection
   # in progress.
   #
   # This method can be run on a request multiple times, it'll only re-execute
-  # services that are executable (not already running, or timed out).
+  # services that are executable (not already running, or timed out).
   # That characteristic is used when this method is called on a page refresh
-  # or background update status check.
+  # or background update status check.
   #
   # Sets all services in collection to have a 'queued' status if appropriate.
-  # Then actually executes the services that are dispatchable (queued).
+  # Then actually executes the services that are dispatchable (queued).
   def dispatch_services!
     queued_service_ids = prepare_for_dispatch!
     dispatch_foreground!(queued_service_ids)
-    dispatch_background!(queued_service_ids)
+    dispatch_background!(queued_service_ids)
   end
   # Call prepare_for_dispatch! first, the return value from that call
   # is suitable as argument for this call: queued_service_ids, list of
   # service id's already identified as suitable for running, and
-  # marked queued in the DispatchedService table.
+  # marked queued in the DispatchedService table.
   #
   # Will run such services in foreground priority waves. And then reload
   # the UmlautRequest object in the current thread, to pick up any
-  # changes made in service threads.
+  # changes made in service threads.
   def dispatch_foreground!(queued_service_ids)
     # Foreground services
-    (0..9).each do | priority |
+    (0..9).each do | priority |
       services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)
-      next if services_to_run.empty?
+      next if services_to_run.empty?
       ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
     end
     # Need to reload the request from db, so it gets changes
     # made by services in threads, so future code (such as view rendering)
-    # will see changes.
+    # will see changes.
     umlaut_request.reload
   end
   # Call prepare_for_dispatch! first, the return value from that call
   # is suitable as argument for this call: queued_service_ids, list of
   # service id's already identified as suitable for running, and
   # marked queued in the DispatchedService table.
   #
-  # Will run such services in background priority waves.
+  # Will run such services in background priority waves.
   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,
     # we're going to let it keep doing it's thing in the background after
     # we return a response to the browser
     backgroundThread = Thread.new(self, umlaut_request) do | t_collection,  t_request|
       # Tell our AR extension not to allow implicit checkouts
       ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
       begin
         # Set priority to lower for background thread; may or may not
-        # actually have an effect in MRI, unclear, but can't hurt.
+        # actually have an effect in MRI, unclear, but can't hurt.
         prior = Thread.current.priority
-        Thread.current.priority = prior - 1
+        Thread.current.priority = prior - 1
         # Try to give the thread scheduler another hint, really, get
-        # other stuff done before this thread.
+        # other stuff done before this thread.
         Thread.pass
         ('a'..'z').each do | priority |
             services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)
           next if services_to_run.empty?
-          ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
-        end
+          ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
+        end
       rescue Exception => e
         # We are divorced from any HTTP request at this point, and may not
         # have access to an ActiveRecord connection. Not much
-        # we can do except log it.
+        # we can do except log it.
         # If we're catching an exception here, service processing was
         # probably interrupted, which is bad. You should not intentionally
         # raise exceptions to be caught here.
         #
         # Normally even unexpected exceptions were caught inside the ServiceWave,
         # and logged to db as well as logfile if possible, only bugs in ServiceWave
-        # itself should wind up caught here.
+        # 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   " + clean_backtrace(e).join("\n"))
       end
     end
   end
   # Goes through all services and marks them with a DispatchedService
-  # record in 'queued' state.
+  # record in 'queued' state.
   #
-  # Will time out any too-old services in a running state.
+  # Will time out any too-old services in a running state.
   #
-  # Will remove DispatchedService status for
+  # Will remove DispatchedService status for
   # any services marked failed that are old enough to re-run, or services
-  # that are too old to re-use.   Such services are then queuable.
+  # that are too old to re-use.   Such services are then queuable.
   #
   # Returns array of Service identifiers for services that are now
-  # queued and execable.
+  # queued and execable.
   def prepare_for_dispatch!
     # Go through currently dispatched services, looking for timed out
     # services -- services still in progress that have taken too long,
@@ -160,50 +162,50 @@ class Collection
           if ( (ds.status == DispatchedService::InProgress ||
                 ds.status == DispatchedService::Queued ) &&
                 (Time.now - ds.updated_at) > self.background_service_timeout)
                 ds.store_exception( Exception.new("background service timed out (took longer than #{self.background_service_timeout} to run); thread assumed dead.")) unless ds.exception_info
-                # Fail it temporary, it'll be run again.
+                # Fail it temporary, it'll be run again.
                 ds.status = DispatchedService::FailedTemporary
                 ds.save!
                 logger.warn("Background service timed out, thread assumed dead. #{umlaut_request.id} / #{ds.service_id}")
            end
           # go through dispatched_services and delete:
-          # 1) old completed dispatches, too old to use.
+          # 1) old completed dispatches, too old to use.
           # 2) failedtemporary dispatches that are older than our resurrection time
-          # -> And all responses associated with those dispatches.
-          # After being deleted, they'll end up re-queued.
+          # -> And all responses associated with those dispatches.
+          # After being deleted, they'll end up re-queued.
           if ( (ds.completed? && completed_dispatch_expired?(ds) ) ||
                (  ds.status == DispatchedService::FailedTemporary &&
-                 (Time.now - ds.updated_at) > self.requeue_failedtemporary_services
+                 (Time.now - ds.updated_at) > self.requeue_failedtemporary_services
                 )
               )
             # Need to expire. Delete all the service responses, and
             # the DispatchedService record, and service will be automatically
             # run again.
             serv_id = ds.service_id
-            umlaut_request.service_responses.each do |response|
+            umlaut_request.service_responses.each do |response|
               if response.service_id == serv_id
-                umlaut_request.service_responses.delete(response)
+                umlaut_request.service_responses.delete(response)
                 response.destroy
               end
             end
             umlaut_request.dispatched_services.delete(ds)
             ds.destroy
           end
       end
       # Queue any services without a dispatch marker at all, keeping
-      # track of queued services, already existing or newly created.
+      # track of queued services, already existing or newly created.
       # Just in case, we're going to refetch dispatched_services from the db,
       # in case some other http request or background service updated things
-      # recently.
+      # recently.
       umlaut_request.dispatched_services.reset
       self.get_service_definitions.each do |service|
         service_id = service['service_id']
         # use in-memory #to_a search, don't go to db each time!
@@ -212,61 +214,61 @@ class Collection
         else
           umlaut_request.new_dispatch_object!(service_id, DispatchedService::Queued).save!
           queued_service_ids.push(service_id)
-        end
+        end
       end
     end
     return queued_service_ids
   end
   def completed_dispatch_expired?(ds)
     interval = self.response_expire_interval
     crontab = self.response_expire_crontab_format
     now = Time.now
-    return nil unless interval || crontab
+    return nil unless interval || crontab
     expired_interval = interval && (now - ds.created_at > interval)
     expired_crontab = crontab && (now > CronTab.new(crontab).nexttime(ds.created_at))
     return expired_interval || expired_crontab
   end
   # Instantiate new copies of services included in this collection, which
   # services specified by options, can combine:
   # :task => Service::StandardTask (default) or Service::LinkOutFilterTask
   # :level => priority level, default to returning services from all.
-  # :ids => list of id's, only those.
+  # :ids => list of id's, only those.
   def instantiate_services!(options ={})
     get_service_definitions(options).collect do |svc_def|
       ServiceStore.instantiate_service!(svc_def, umlaut_request)
     end
   end
   # Deprecated, use #instantiate_services! with :task => Service::LinkOutFilter.
   def link_out_service_level(level)
-    instantiate_services!(:task => Service::LinkOutFilterTask,
+    instantiate_services!(:task => Service::LinkOutFilterTask,
                           :level => level)
   end
   # Get service definition hashes for services in this institution.
-  # options, returned in an array.
+  # options, returned in an array.
   # Does return a mutatable array that Collection mutates
-  # internally, but clients really ought not to mutate.
+  # internally, but clients really ought not to mutate.
   # :task => Service::StandardTask (default) or Service::LinkOutFilterTask
-  # :level => priority level, default to returning services from all.
-  # :ids => list of service unique ids, return only these.
+  # :level => priority level, default to returning services from all.
+  # :ids => list of service unique ids, return only these.
   def get_service_definitions(options = {})
     options[:task] ||= Service::StandardTask
     configs_for_task = @service_definitions[ options[:task] ] || {}
     service_configs = case options[:level]
                         when nil
                           # All of of them for this task
@@ -277,29 +279,29 @@ class Collection
      if options[:ids]
        service_configs = service_configs.find_all {|s| options[:ids].include? s["service_id"] }
      end
-     return service_configs
+     return service_configs
   end
   protected
-  # Arrange services in hash according to task type and priority.
+  # Arrange services in hash according to task type and priority.
   def gather_services
     @service_definitions_flat.each_pair do | unique_id, svc_def |
       next if svc_def.nil?
       svc_def['service_id'] = unique_id
       task = svc_def['task'] || Service::StandardTask
       level = svc_def['priority'] || 3
       @service_definitions[task] ||= {}
       @service_definitions[task][level] ||= []
-      @service_definitions[task][level] << svc_def
-    end
+      @service_definitions[task][level] << svc_def
+    end
   end
 end