blacklight 3.1.2 → 3.2.0pre1

data/lib/blacklight/configuration/fields.rb

@@ -0,0 +1,142 @@
+module Blacklight
+  class Configuration
+
+    # This mixin provides Blacklight::Configuration with generic
+    # solr fields configuration
+    module Fields
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Add a configuration block for a collection of solr fields
+        def define_field_access(key)
+          key = key.to_s if respond_to? :to_s
+
+          self.default_values[key.pluralize.to_sym] = ActiveSupport::OrderedHash.new
+
+          unless self.const_defined? key.camelcase
+            class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+              class #{key.camelcase} < SolrField; end
+            END_EVAL
+          end
+    
+          class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+            def add_#{key}(*args, &block)
+              add_solr_field("#{key}", *args, &block)
+            end
+          END_EVAL
+        end
+      end
+
+      module InstanceMethods
+        # Add a solr field configuration to the given configuration key
+        #
+        # The recommended and strongly encouraged format is a field name, configuration pair, e.g.:
+        #     add_solr_field :index_field, 'format', :label => 'Format' 
+        #
+        # Alternative formats include:
+        #
+        # * a field name and block format:
+        #
+        #     add_solr_field :index_field, 'format' do |field|
+        #       field.label = 'Format'
+        #     end
+        #
+        # * a plain block:
+        #
+        #     add_solr_field :index_field do |field|
+        #       field.field = 'format'
+        #       field.label = 'Format'
+        #     end
+        # 
+        # * a configuration hash:
+        #
+        #     add_solr_field :index_field, :field => 'format', :label => 'Format'
+        #   
+        # * a Field instance: 
+        #
+        #     add_solr_field :index_field, IndexField.new(:field => 'format', :label => 'Format')
+        #
+        # * an array of hashes: 
+        #
+        #     add_solr_field :index_field, [{:field => 'format', :label => 'Format'}, IndexField.new(:field => 'date', :label => 'Date')]
+        #
+        #
+        # @param String config_key 
+        # @param Array *args 
+        # @para
+        #
+        def add_solr_field config_key, *args, &block
+          field_config = case args.first
+            when String
+              field_config_from_key_and_hash(config_key, *args)
+            when Symbol
+              args.first = args.first.to_s
+              field_config_from_key_and_hash(config_key, *args)
+            when Array
+              field_config_from_array(config_key, *args)
+            else
+              field_config_from_field_or_hash(config_key, *args)
+          end
+
+          return if field_config.is_a? Array
+    
+          if block_given?
+            yield field_config
+          end
+              
+          field_config.normalize!(self)
+          field_config.validate!
+
+          self[config_key.pluralize][ field_config.field ] = field_config            
+        end
+
+        protected
+        # Add a solr field by a solr field name and hash 
+        def field_config_from_key_and_hash config_key, solr_field, field_or_hash = {}
+          field_config = field_config_from_field_or_hash(config_key, field_or_hash)
+          field_config.field = solr_field
+
+          field_config
+        end
+
+        # Add multiple solr fields using a hash or Field instance
+        def field_config_from_array config_key, array_of_fields_or_hashes
+          array_of_fields_or_hashes.map do |field_or_hash| 
+            add_solr_field(config_key, field_or_hash)
+          end
+        end
+
+        # Add a solr field using a hash or Field instance
+        def field_config_from_field_or_hash config_key, field_or_hash = {}
+          hash_arg_to_config(field_or_hash, field_class_from_key(config_key))
+        end
+
+        # for our add_* methods, takes the optional hash param,
+        # and makes it into a specific config OpenStruct, like
+        # FacetField or SearchField. Or if the param already was
+        # one, that's cool. Or if the param is nil, make
+        # an empty one. Second argument is an actual class object. 
+        def hash_arg_to_config(hash_arg, klass)
+          case hash_arg
+          when Hash 
+            klass.new(hash_arg)
+          when NilClass 
+            klass.new
+          else 
+            # this assumes it already is an element of klass, or acts like one,
+            # if not something bad will happen later, that's your problem. 
+            hash_arg
+          end
+        end
+
+        private
+        # convert a config key to the appropriate Field class
+        def field_class_from_key key
+          "Blacklight::Configuration::#{key.camelcase}".constantize
+        end
+
+      end
+    end
+  end
+end

data/lib/blacklight/configuration/search_field.rb

@@ -0,0 +1,12 @@
+module Blacklight
+  class Configuration::SearchField < Configuration::SolrField
+    def normalize! blacklight_config
+      # Some normalization, calculate display_label from key,
+      # and make sure we have a qt from defaults.             
+      self.key = self.field
+      self.label ||= self.key.try(:titlecase)
+      self.qt ||= blacklight_config.default_solr_params[:qt] if blacklight_config.default_solr_params
+    end
+  end
+end
+

data/lib/blacklight/configuration/solr_field.rb

@@ -0,0 +1,12 @@
+module Blacklight
+  class Configuration::SolrField < OpenStructWithHashAccess
+    def normalize! blacklight_config
+      self.label ||= self.field.try(:titleize)
+    end
+  
+    def validate!
+      raise ArgumentError.new("Must supply a solr field name") if self.field.nil?
+    end
+  end
+end
+

data/lib/blacklight/configuration/sort_field.rb

@@ -0,0 +1,17 @@
+module Blacklight
+  class Configuration::SortField < Configuration::SolrField
+    def normalize! blacklight_config
+      self.sort ||= self.field
+
+      self.field ||= self.key
+      self.field ||= self.label.try(:parameterize)
+      self.field ||= self.sort
+
+      self.key ||= self.field
+    end
+
+    def validate!
+      raise ArgumentError.new("Must supply a solr sort string") if self.sort.nil?
+    end
+  end
+end

data/lib/blacklight/controller.rb

@@ -5,6 +5,8 @@
 module Blacklight::Controller 
 
   def self.included(base)
+    base.send :include, Blacklight::SearchFields
+
     base.send :before_filter, :default_html_head # add JS/stylesheet stuff
     # now in application.rb file under config.filter_parameters
     # filter_parameter_logging :password, :password_confirmation 
@@ -22,9 +24,9 @@ module Blacklight::Controller
     base.send :helper_method, :extra_head_content
     base.send :helper_method, :stylesheet_links
     base.send :helper_method, :javascript_includes
+    base.send :helper_method, :has_user_authentication_provider?
   end
 
-  
     # test for exception notifier plugin
     def error
       raise RuntimeError, "Generating a test error..."
@@ -40,14 +42,7 @@ module Blacklight::Controller
     # http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html
     # for how to turn off a filter in a sub-class and such.
     def default_html_head
-      if use_asset_pipeline?
-        stylesheet_links  << ["application"]
-        javascript_includes << ["application"]
-      else
-        stylesheet_links << ['yui', 'jquery/ui-lightness/jquery-ui-1.8.1.custom.css', 'blacklight/blacklight', {:media=>'all'}]
-      
-        javascript_includes << ['jquery-1.4.2.min.js', 'jquery-ui-1.8.1.custom.min.js', 'blacklight/blacklight' ]
-      end
+ 
     end
     
     
@@ -117,6 +112,16 @@ module Blacklight::Controller
       flash.discard if request.xhr?
     end
 
+    ##
+    #
+    #
+    def has_user_authentication_provider?
+      respond_to? :current_user
+    end           
+
+    def require_user_authentication_provider
+      raise ActionController::RoutingError.new('Not Found') unless has_user_authentication_provider?
+    end
     ##
     # To handle failed authorization attempts, redirect the user to the 
     # login form and persist the current request uri as a parameter
@@ -126,13 +131,10 @@ module Blacklight::Controller
       #   (e.g. protected page -> logout -> returned to protected page -> home)
       redirect_to root_url and flash.discard and return if request.referer and request.referer.ends_with? request.fullpath
 
+      redirect_to root_url and return unless has_user_authentication_provider?
+
       redirect_to new_user_session_url(:referer => request.fullpath)
     end
   
-    private
-    # Detect if the Rails asset pipeline is enabled
-    def use_asset_pipeline?
-      Rails.application.config.respond_to?(:assets) and Rails.application.config.assets.enabled
-    end
 end
 

data/lib/blacklight/engine.rb

@@ -3,7 +3,7 @@
 require "blacklight"
 require "rails"
 
-module Blackight
+module Blacklight
   class Engine < Rails::Engine
 
     # BlacklightHelper is needed by all helpers, so we inject it

data/lib/blacklight/global_configurable.rb

@@ -0,0 +1,46 @@
+module Blacklight::GlobalConfigurable
+  
+  # The config environment name used by the #config method
+  #
+  # Example:
+  #   class MyThing
+  #     extend Blacklight::GlobalConfigurable
+  #   end
+  # 
+  # Now MyThing.config will be the result of:
+  #   MyThing.configure(:production) {|config|}
+  #
+  # You set shared attributes by leaving the first argument blank or passing the :shared value:
+  #   MyThing.configure {|config|} 
+  # or
+  #   MyThing.cofigure(:shared) {|config|}
+  
+  # sets the @configs variable to a new Hash with empty Hash for :shared key and @config to nil
+  def reset_configs!
+    @config = nil
+    @configs = {:shared=>{}}
+  end
+  
+  # A hash of all environment configs
+  # The key is the environment name, the value a Hash
+  def configs
+    @configs ? @configs : (reset_configs! and @configs)
+  end
+  
+  # The main config accessor. It merges the current configs[::Rails.env] 
+  # with configs[:shared] and lazy-loads @config to the result.
+  def config
+    @config ||= configs[:shared].merge(configs[::Rails.env] ||= {})
+  end
+  alias_method :blacklight_config, :config
+  
+  # Accepts a value for the environment to configure and a block
+  # A hash is yielded to the block
+  # If the "env" != :shared,
+  # the hash is created by deep cloning the :shared environment config.
+  # This makes it possible to create defaults in the :shared config
+  def configure(env = :shared, &blk)
+    configs[env] = {}
+    yield configs[env]
+  end
+end

data/lib/blacklight/search_fields.rb

@@ -2,16 +2,16 @@
 ##
 # Module to deal with accessing (and setting some defaults) in an array of
 # hashes that describe Blacklight search fields.  Requires the base class this
-# module is added to implements a #config method that returns a hash, where
-# config[:search_fields] will be an array of hashes describing search fields.
+# module is added to implements a #blacklight_config method that returns a hash, where
+# blacklight_config[:search_fields] will be an array of hashes describing search fields.
 #
-# = Search Field Configuration Hash =
+# = Search Field blacklight_configuration Hash =
 # [:key]
 #   "title", required, unique key used in search URLs to specify search_field 
-# [:display_label]
+# [:label]
 #   "Title",  # user-displayable label, optional, if not supplied :key.titlecase will be used
 # [:qt]
-#   "search", # Solr qt param, request handler, usually can be left blank; defaults to Blacklight.config[:default_solr_params][:qt] if not specified. 
+#   "search", # Solr qt param, request handler, usually can be left blank; defaults to blacklight_config[:default_solr_params][:qt] if not specified. 
 # [:solr_parameters]
 #   {:qf => "something"} # optional hash of additional parameters to pass to solr for searches on this field.
 # [:solr_local_parameters]
@@ -21,88 +21,55 @@
 # 
 # Optionally you can supply a :key, which is what Blacklight will use
 # to identify this search field in HTTP query params. If no :key is
-# supplied, one will be computed from the :display_label. If that will
+# supplied, one will be computed from the :label. If that will
 # result in a collision of keys, you should supply one explicitly. 
 #
 ##
 module Blacklight::SearchFields
   extend ActiveSupport::Memoizable
+  extend ActiveSupport::Concern
 
-  # Looks up search field config list from config[:search_fields], and
+  included do
+    helper Blacklight::SearchFields if respond_to? :helper
+  end
+
+  # Looks up search field config list from blacklight_config[:search_fields], and
   # 'normalizes' all field config hashes using normalize_config method. 
   # Memoized for efficiency of normalization. 
   def search_field_list
-    normalized = config[:search_fields].collect {|obj| normalize_config(obj)}
-
-    if (duplicates = normalized.collect{|h| h[:key]}.uniq!)
-      raise "Duplicate keys found in search_field config: #{duplicates.inspect}"
-    end
-    
-    normalized
+    blacklight_config.search_fields.values
   end
-  memoize :search_field_list
 
   # Returns suitable argument to options_for_select method, to create
   # an html select based on #search_field_list. Skips search_fields
   # marked :include_in_simple_select => false
   def search_field_options_for_select
-    search_field_list.collect do |field_def|
-      [field_def[:display_label],  field_def[:key]] unless field_def[:include_in_simple_select] == false
+    blacklight_config.search_fields.collect do |key, field_def|
+      [field_def.label,  field_def.key] unless field_def.include_in_simple_select == false
     end.compact
   end
 
-  # Looks up a search field config hash from search_field_list having
+  # Looks up a search field blacklight_config hash from search_field_list having
   # a certain supplied :key. 
   def search_field_def_for_key(key)
-    return nil if key.blank?
-    search_field_list.find {|c| c[:key] == key}
+    blacklight_config.search_fields[key]
   end
 
   # Returns default search field, used for simpler display in history, etc.
-  # if not set in config, defaults to first field listed in #search_field_list
+  # if not set in blacklight_config, defaults to first field listed in #search_field_list
   def default_search_field
-    config[:default_search_field] || search_field_list[0]
+    blacklight_config.default_search_field || search_field_list.first
   end
-  memoize :default_search_field
 
   # Shortcut for commonly needed operation, look up display
   # label for the key specified. Returns "Keyword" if a label
   # can't be found. 
   def label_for_search_field(key)
     field_def = search_field_def_for_key(key)
-    if field_def && field_def[:display_label]
-       field_def[:display_label]
+    if field_def && field_def.label
+       field_def.label
     else
        "Keyword"
     end            
   end
-
-  protected
-  # Fill in missing default values in a search_field config hash.
-  def normalize_config(field_hash)
-
-
-    # Accept legacy two-element array, if it's not a Hash, assume it's legacy.
-    # No great way to 'duck type' here. 
-    unless ( field_hash.kind_of?(Hash))      
-      # Consistent with legacy behavior where two fields can have the same label,
-      # as long as they have different qt's, we base the unique :key on :qt. 
-      field_hash = {:display_label => field_hash[0], :key => field_hash[1], :qt => field_hash[1]}
-    else
-      # Make a copy of passed in Hash so we don't alter original. 
-      field_hash = field_hash.clone
-    end        
-
-    raise Exception.new("Search field config is missing ':key' => #{field_hash.inspect}") unless field_hash[:key]
-    
-    # If no display_label was provided, turn the :key into one.      
-    field_hash[:display_label] ||= field_hash[:key].titlecase
-
-    # If no :qt was provided, take from config default
-    field_hash[:qt] ||= config[:default_solr_params][:qt] if config[:default_solr_params]
-  
-    field_hash
-  end
-  
-  
 end

data/lib/blacklight/solr/document.rb

@@ -85,6 +85,7 @@ module Blacklight::Solr::Document
     base.send :include, RSolr::Ext::Model
     base.send :include, InstanceMethods
     base.send :extend,  ClassMethods
+    base.send :extend, ActiveModel::Naming
    
     # after_initialize hook comes from RSolr::Ext::Model, I think.
     # We need to make sure all extensions get applied.
@@ -97,6 +98,10 @@ module Blacklight::Solr::Document
     def id
       self[self.class.unique_key]
     end
+
+    def to_param
+      URI.escape(CGI.escape(id), '.')
+    end
   end
 
 
@@ -201,9 +206,14 @@ module Blacklight::Solr::Document
   module ClassMethods
     attr_writer :registered_extensions
 
-     def unique_key
-       Blacklight.config[:unique_key] || 'id'
-     end
+    attr_writer :unique_key
+    def unique_key
+      # XXX Blacklight.config[:unique_key] should be deprecated soon
+      @unique_key ||= Blacklight.config[:unique_key] if Blacklight.respond_to?(:config) and Blacklight.config[:unique_key]
+      @unique_key ||= 'id' 
+
+      @unique_key
+    end
 
      def connection
       @connection ||= Blacklight.solr