scooby_snacks 0.3

data/lib/scooby_snacks.rb

@@ -0,0 +1,11 @@
+require "scooby_snacks/version"
+
+module ScoobySnacks
+  require 'scooby_snacks/metadata_schema'
+  require 'scooby_snacks/field'
+  require 'scooby_snacks/presenter_behavior'
+  require 'scooby_snacks/solr_behavior'
+  require 'scooby_snacks/work_form_behavior'
+  require 'scooby_snacks/work_model_behavior'
+  require 'scooby_snacks/blacklight_configuration'
+end

data/lib/scooby_snacks/blacklight_configuration.rb

@@ -0,0 +1,68 @@
+module ScoobySnacks
+  class BlacklightConfiguration
+    
+    def self.add_all_fields(config)
+      self.add_show_fields(config)
+      self.add_search_fields(config)
+      self.add_facet_fields(config)
+      self.add_sort_fields(config)
+      self.add_search_result_display_fields(config)
+    end
+
+    def self.add_show_fields(config)
+       self.schema.display_fields.each do |field|
+         begin
+           config.add_show_field field.solr_search_name, label: field.label
+         rescue 
+           Rails.logger.error "error adding field: #{field.solr_search_name} for property #{field.label}. Redundant definition?"
+         end
+       end
+    end
+
+    def self.add_search_fields(config)
+      self.schema.searchable_fields.each do |field|
+        config.add_search_field(field.name) do |new_field|
+          new_field.label = field.label
+          new_field.solr_local_parameters = {
+            qf: field.solr_search_name,
+            pf: field.solr_search_name
+          }
+        end
+      end
+    end
+ 
+    def self.add_facet_fields(config)
+       self.schema.facet_fields.each do |field|
+         config.add_facet_field field.solr_facet_name, {label: field.label, limit: field.facet_limit}
+      end
+    end
+ 
+    def self.add_sort_fields(config)
+       self.schema.sortable_fields.each do |field|
+         config.add_sort_field field.solr_sort_name, label: field.label
+      end
+    end
+
+    def self.add_search_result_display_fields(config)
+       self.schema.search_result_display_fields.each do |field|
+         config.add_index_field(field.solr_search_name, self.get_index_options(field))
+      end
+    end
+
+    def self.get_index_options field
+        options = {}
+        options[:label] =  field.label || field.name
+        options[:index_itemprop] = field.itemprop if field.itemprop
+        options[:helper_method] = field.helper_method if field.helper_method
+        options[:link_to_search] = field.solr_search_name if field.search?
+        return options
+    end
+
+    private
+
+    def self.schema
+      ScoobySnacks::METADATA_SCHEMA
+    end
+
+  end
+end

data/lib/scooby_snacks/field.rb

@@ -0,0 +1,174 @@
+module ScoobySnacks
+  class Field
+    
+    attr_reader :name, :label, :oai_element, :oai_ns
+
+    def solr_sort_name
+      return false unless sort?
+      @solr_sort_name ||= Solrizer.solr_name(name, :stored_sortable)
+    end
+
+    def initialize name, raw_array
+      @raw_array = raw_array
+      @name = name
+      @label = raw_array['label'] || name.underscore.humanize
+
+      if @raw_array['OAI'] && (oai_split =  @raw_array['OAI'].split(':',2))
+        @oai_ns = oai_split.first.downcase
+        @oai_element = oai_split.last
+      end
+    end
+
+    # here we define methods for simple boolean attributes associate with metadata fields
+    # ("meta-metadata properties")
+    ScoobySnacks::MetadataSchema.boolean_attributes.each do |attribute_name|
+      # Skip any attribute we have a custom method for
+      next if [:controlled].include? attribute_name
+      #define a method for this attribute
+      define_method("#{attribute_name}?".to_sym) do
+        # For boolean attributes, we cache the result to avoid repeated string comparison operations
+        attribute = instance_variable_get("@#{attribute_name}")
+        return attribute unless attribute.nil?
+        attribute = @raw_array[attribute_name.to_s].to_s.downcase.strip == "true"
+        instance_variable_set("@#{attribute_name}", attribute)
+        return attribute
+      end
+    end
+
+    # here we define methods for simple string attributes associate with metadata fields
+    # ("meta-metadata properties")
+    ScoobySnacks::MetadataSchema.string_attributes.each do |attribute_name|
+      # For string attributes, we just pull the result straight from the raw array        
+      define_method("#{attribute_name}".to_sym) do
+        @raw_array[attribute_name.to_s]
+      end
+    end
+
+    def controlled?
+      return @controlled unless @controlled.nil?
+      @controlled = false
+      @controlled = true if @raw_array['controlled'].to_s == "true"
+      @controlled = true if @raw_array['input'].to_s.include? "controlled"
+      @controlled = true if (@raw_array['vocabularies'].is_a?(Array) && !@raw_array['vocabularies'].empty?)
+      @controlled = true if (@raw_array['vocabulary'].is_a?(Hash) && !@raw_array['vocabulary'].empty?)
+      return @controlled
+    end
+
+    def predicate
+      return @predicate if @predicate
+      raise ArgumentError.new("invalid predicate definition. Raw array: #{@raw_array.inspect}") if  @raw_array["predicate"].nil?
+      namespace_prefix = @raw_array["predicate"].split(":").first
+      predicate_name = @raw_array["predicate"].split(":",2).last
+      #sort out the predicate namespace if necessary
+      namespaces = schema.namespaces
+      if namespaces.key?(namespace_prefix) 
+        namespace_url = namespaces[namespace_prefix]
+        raise ArgumentError.new("invalid predicate definition: #{@raw_array['predicate']}") unless namespace_url.include?("http")
+        @predicate = ::RDF::URI.new(namespace_url + predicate_name)
+      elsif defined?("::RDF::Vocab::#{namespace_prefix}".constantize)
+        @predicate = "::RDF::Vocab::#{namespace_prefix}".constantize.send predicate_name
+      else
+        raise ArgumentError.new("invalid predicate definition: #{@raw_array['predicate']}")
+      end
+      @predicate
+    end
+
+    def date?
+      @date ||= (@raw_array['input'].to_s.downcase.include? "date") || (@raw_array['data_type'].to_s.downcase.include? "date")  
+    end
+
+    def itemprop
+      @raw_array['index_itemprop'] || @raw_array['itemprop']
+    end
+
+    def helper_method
+      method_name = (@raw_array['index_helper_method'] || @raw_array['helper_method'])
+      method_name.to_sym unless method_name.nil?
+    end
+
+    def search?
+      searchable?
+    end
+
+    def sort?
+      sortable?
+    end
+
+    def index_itemprop
+      itemprop
+    end
+
+    def oai?
+      !@oai_element.nil? && !@oai_ns.nil?
+    end
+
+    def display_options
+      options = {label: label}
+      if search?
+        options[:render_as] = :linked 
+        options[:search_field] = solr_search_name
+      end
+      return options
+    end
+
+    def in_display_group? group_name
+      display_groups.each { |display_group| break true if (display_group.downcase == group_name.to_s.downcase) }==true
+    end
+
+    def search_result_display?
+      in_display_group? "search_result"
+    end
+
+    def display_groups
+      @raw_array['display_groups'] || Array(@raw_array['display_group'])      
+    end
+
+    def display_group
+      display_groups.first
+    end
+
+    def vocabularies
+      @raw_array['vocabularies'] || Array(@raw_array['vocabulary'])
+    end
+
+    def primary_vocabulary
+      vocabularies.first
+    end
+
+    def solr_name(facet: nil, keyword: false, string: false, symbol: false, tokenize: true)
+      facet = facet? if facet.nil?
+      facet = facet or keyword or string or symbol or !tokenize
+      case @raw_array['data_type'].downcase
+      when /string/, /keyword/, /symbol/
+        type = "s"
+      when /date/
+        type = "d"
+      else
+        type = "te"
+      end
+      type = "s" if facet
+      index = (search? or facet) ? "i" : ""
+      multiple = multiple? ? "m" : ""
+      return "#{name}_#{type}s#{index}#{multiple}"
+    end
+
+    def solr_search_name
+      solr_name
+    end
+
+    def solr_facet_name
+      solr_name(facet: true)
+    end
+
+    private
+
+    def schema
+      if defined? ScoobySnacks::METADATA_SCHEMA
+        return ScoobySnacks::METADATA_SCHEMA
+      else
+        @schema ||= ScoobySnacks::MetadataSchema.new
+      end
+    end
+
+  end
+end

data/lib/scooby_snacks/initialize.rb

@@ -0,0 +1,4 @@
+
+# set the global constant
+ScoobySnacks::METADATA_SCHEMA = ScoobySnacks::MetadataSchema.new
+

data/lib/scooby_snacks/metadata_schema.rb

@@ -0,0 +1,170 @@
+module ScoobySnacks
+  class MetadataSchema
+
+    attr_reader :fields, :namespaces
+    
+    SS_BOOLEAN_ATTRIBUTES = [:facet,
+                             :searchable,
+                             :sortable,
+                             :multiple, 
+                             :full_text_searchable,
+                             :required,
+                             :work_title, 
+                             :hidden,
+                             :stored_in_solr,
+                             :controlled]
+    SS_STRING_ATTRIBUTES = [:facet_limit, 
+                            :helper_method, 
+                            :input, 
+                            :definition]
+
+    SS_DISPLAY_GROUPS = [:primary,
+                         :secondary, 
+                         :search_result, 
+                         :editor_primary]
+
+    # override this locally to define app-specific attributes
+    def self.custom_boolean_attributes
+      []
+    end
+    
+    # override this locally to define app-specific attributes
+    def self.custom_string_attributes
+      []
+    end
+
+    # override this locally to define app-specific display groups
+    def self.custom_display_groups
+      []
+    end
+
+    def self.boolean_attributes
+      SS_BOOLEAN_ATTRIBUTES + custom_boolean_attributes
+    end
+
+    def self.string_attributes
+      SS_STRING_ATTRIBUTES + custom_string_attributes
+    end
+
+    def self.display_groups
+      SS_DISPLAY_GROUPS + custom_display_groups
+    end
+
+    def initialize (schema_config_path: nil, raw_schema: nil)
+      schema_config_path ||= default_schema_config_path
+      raw_schema ||= YAML.load_file(schema_config_path)
+      @namespaces = raw_schema['namespaces']
+      raw_fields = (raw_schema['fields'] || raw_schema['properties'])
+      @fields = raw_fields.except('default').keys.reduce({}) do |fields, field_name|
+        field = raw_fields['default'].deep_merge raw_fields[field_name]
+        fields[field_name] = ScoobySnacks::Field.new(field_name,field)
+        fields
+      end
+    end
+
+    # define methods to list display group contents
+    display_groups.each do |display_group|
+      define_method("#{display_group}_display_field_names") do 
+        field_names = instance_variable_get("@#{display_group}_display_field_names")
+        if field_names.nil?
+          send("#{display_group}_display_fields".to_sym).map{|field| field.name}
+        else
+          field_names
+        end
+      end
+      define_method("#{display_group}_display_fields") do 
+        field_names = instance_variable_get("@#{display_group}_display_field_names")
+        return field_names.map{|name| get_field(name)} unless field_names.nil?
+        fields = @fields.values.select{|field| field.in_display_group?(display_group)}
+        instance_variable_set("@#{display_group}_display_field_names", fields.map{|field| field.name})
+        return fields       
+      end
+    end
+
+    # Define methods to cache and return lists of fields & field names
+    # that share certain boolean characteristics (controlled, required, etc). 
+    boolean_attributes.each do |attribute|
+      # Skip any attribute we have a custom method for      
+      next if [:work_title].include? attribute
+      define_method("#{attribute}_fields".to_sym) do
+        @fields.values.select{|field| field.send("#{attribute}?".to_sym)}
+      end
+      define_method("#{attribute}_field_names".to_sym) do
+        field_names = send("#{attribute}_fields".to_sym).map{|field| field.name}
+        instance_variable_set("@#{attribute}_field_names".to_sym, field_names)
+      end
+    end
+
+    def get_field(name)
+      @fields[name.to_s] || @fields[label_map[name.to_s]]
+    end
+
+    def get_property(name)
+      get_field(name)
+    end
+
+    def all_field_names
+      @fields.keys
+    end
+
+    def default_text_search_solrized_field_names
+      # Include all fields marked for full text search that are also individual search fields
+      # and therefore excluded from the 'all_text_timv' search field
+      field_names = (full_text_searchable_field_names & searchable_field_names).uniq
+      field_solr_names = field_names.map{|field_name| get_field(field_name).solr_search_name }
+      return( field_solr_names + [full_text_field_name] )
+    end
+
+    def full_text_field_name
+      "all_text_timv"
+    end
+
+    def work_title_field
+      @fields.values.select{|field| field.in_display_group?("title") || field.work_title?}.first
+    end
+
+    def work_title_field_name
+      work_title_field.name
+    end
+
+    def display_field_names
+      primary_display_field_names + secondary_display_field_names
+    end
+
+    def display_fields
+      primary_display_fields + secondary_display_fields
+    end
+
+    # A few aliases for these methods since I've been using both conventions
+    def sort_fields
+      sortable_fields
+    end
+
+    def sort_field_names
+      sortable_field_names
+    end
+
+    def search_fields
+      searchable_fields
+    end
+
+    def search_field_names
+      searchable_field_names
+    end
+
+    private
+
+    def label_map
+      @label_map ||= @fields.values.reduce({}){|map,field| map[field.label] = field.name if field.label.present?; map }
+    end
+
+    def default_schema_config_path
+      @schema_config_path ||= File.join(Rails.root.to_s,'config',schema_config_filename)
+    end
+
+    def schema_config_filename
+      "metadata.yml"
+    end
+
+  end
+end

data/lib/scooby_snacks/presenter_behavior.rb

@@ -0,0 +1,10 @@
+module ScoobySnacks::PresenterBehavior
+  extend ActiveSupport::Concern
+  included do
+    ScoobySnacks::METADATA_SCHEMA.display_fields.each do |field|
+      next if respond_to? field.name
+      delegate field.name.to_sym, to: :solr_document
+    end
+  end
+end
+

data/lib/scooby_snacks/solr_behavior.rb

@@ -0,0 +1,71 @@
+module ScoobySnacks::SolrBehavior
+  extend ActiveSupport::Concern
+
+  class_methods do
+
+    def attribute(name, type, field)
+      define_method name do
+        type.coerce(self[field])
+      end
+    end
+
+    def solr_name(*args)
+      if ScoobySnacks::METADATA_SCHEMA.all_field_names.include?(args.first)
+        ScoobySnacks::METADATA_SCHEMA.get_field(args.first).solr_name
+      else
+        Solrizer.solr_name(*args)
+      end
+    end
+
+    def add_field_semantics(label,solr_name)
+      field_semantics.merge!(label => Array.wrap(solr_name)) {|key, old_val, new_val| Array.wrap(old_val) + Array.wrap(new_val)}
+    end
+
+  end
+
+
+  #TODO This has to do with solr coercing the right type
+  # for each field. I need to remember exactly how this
+  # works (this part of the code is old & borrowed)
+  module Solr
+    class Array
+      # @return [Array]
+      def self.coerce(input)
+        ::Array.wrap(input)
+      end
+    end
+
+    class String
+      # @return [String]
+      def self.coerce(input)
+        ::Array.wrap(input).first
+      end
+    end
+
+    class Date
+      # @return [Date]
+      def self.coerce(input)
+        field = String.coerce(input)
+        return if field.blank?
+        begin
+          ::Date.parse(field)
+        rescue ArgumentError
+          Rails.logger.info "Unable to parse date: #{field.first.inspect}"
+        end
+      end
+    end
+  end
+
+
+  included do
+
+    # Loop through all properties from all work types
+    ScoobySnacks::METADATA_SCHEMA.stored_in_solr_fields.each do |field|
+      next if respond_to? field.name
+      # define a attribute for the current property
+      attribute(field.name.to_sym, (field.date? ? Solr::Date : Solr::Array), field.solr_search_name) unless field.hidden?           
+      add_field_semantics(field.oai_element, field.solr_search_name) if (field.oai? && field.oai_ns == 'dc')
+    end
+  end
+end
+