solrizer 0.2.0 → 0.3.0

data/lib/solrizer/field_name_mapper.rb

@@ -1,62 +1,48 @@
-require "yaml"
+# Re-Introduced for backwards compatibility
+module Solrizer::FieldNameMapper
+    
+  # Class Methods -- These methods will be available on classes that include this Module 
+  
+  module ClassMethods
+    def mappings
+      return self.default_field_mapper.mappings
+    end
 
-module Solrizer
-  module FieldNameMapper
-      
-  # Module Methods & Attributes
-  @@mappings = {}
-  
-  # Generates solr field names from settings in solr_mappings
-  def self.solr_name(field_name, field_type)
-    name = field_name.to_s + self.mappings[field_type.to_s].to_s
-    if field_name.kind_of?(Symbol)
-      return name.to_sym
-    else
-      return name.to_s
+    def id_field
+      return self.default_field_mapper.id_field
+    end
+
+    # Re-loads solr mappings for the default field mapper's class 
+    # and re-sets the default field mapper to an FieldMapper instance with those mappings.
+    def load_mappings( config_path=nil)
+      self.default_field_mapper.class.load_mappings(config_path)
+      self.default_field_mapper = self.default_field_mapper.class.new
+    end
+    
+    def solr_name(field_name, field_type, index_type = :searchable)
+      self.default_field_mapper.solr_name(field_name, field_type, index_type)
+    end
+    
+    def default_field_mapper
+      @@default_field_mapper ||= Solrizer::FieldMapper::Default.new
+    end
+
+    def default_field_mapper=(field_mapper)
+      @@default_field_mapper = field_mapper
     end
   end
   
-  def self.mappings
-    @@mappings
-  end
-  
-  def self.mappings=(mappings)
-    @@mappings = mappings
-  end
+  # Instance Methods -- These methods will be available on instances of classes that include this module
   
-  # Instance Methods
+  attr_accessor :ox_namespaces
   
-  def solr_name(field_name, field_type)
-    ::Solrizer::FieldNameMapper.solr_name(field_name, field_type)
+  def self.included(klass)
+    klass.extend(ClassMethods)
   end
   
-  def self.logger      
-    @logger ||= defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : Logger.new(STDOUT)
-  end
   
-  # Loads solr mappings from yml file.
-  # @config_path This is the path to the directory where your mappings file is stored. @default "RAILS_ROOT/config/solr_mappings.yml"
-  # @mappings_file This is the filename for your solr mappings YAML file.  @default solr_mappings.yml
-  def self.load_mappings( config_path=nil )
-
-    if config_path.nil? 
-      if defined?(RAILS_ROOT)
-        config_path = File.join(RAILS_ROOT, "config", "solr_mappings.yml")
-      end
-      # Default to using the config file within the gem 
-      if !File.exist?(config_path.to_s)
-        config_path = File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings.yml")          
-      end
-    end
-
-    logger.info("SOLRIZER: loading field name mappings from #{File.expand_path(config_path)}")
-
-    @@mappings = YAML::load(File.open(config_path))
-
-    mappings["id"] = "id" unless mappings["id"]
+  def solr_name(field_name, field_type, index_type = :searchable)   
+    self.class.solr_name(field_name, field_type, index_type)
   end
   
-  # This ensures that some mappings will always be loaded
-  self.load_mappings
-end #FieldNameMapper
-end #Solrizer
+end

data/lib/solrizer/html/extractor.rb

@@ -0,0 +1,36 @@
+require 'solr'
+require 'rexml/document'
+require "nokogiri"
+require 'yaml'
+
+module Solrizer::HTML::Extractor
+  
+  #
+  # This method strips html tags out and returns content to be indexed in solr
+  #
+  def html_to_solr( ds, solr_doc=Solr::Document.new )
+    
+    text = CGI.unescapeHTML(ds.content)
+    doc = Nokogiri::HTML(text)
+    
+    # html to story_display
+    stories = doc.xpath('//story')
+        
+    stories.each do |story|
+      solr_doc << Solr::Field.new(:story_display => story.children.to_xml)
+    end
+    
+    #strip out text and put in story_t
+    text_nodes = doc.xpath("//text()")
+    text = String.new
+    
+     text_nodes.each do |text_node|
+       text << text_node.content
+     end
+    
+     solr_doc << Solr::Field.new(:story_t => text)
+     
+     return solr_doc
+  end
+  
+end

data/lib/solrizer/html.rb

@@ -0,0 +1,7 @@
+require "solrizer"
+module Solrizer::HTML
+end
+
+Dir[File.join(File.dirname(__FILE__),"html","*.rb")].each {|file| require file }
+
+Solrizer::Extractor.send(:include, Solrizer::HTML::Extractor)

data/lib/solrizer/xml/extractor.rb

@@ -0,0 +1,31 @@
+require 'solr'
+require 'rexml/document'
+require "nokogiri"
+require 'yaml'
+
+module Solrizer::XML::Extractor
+  
+  def extract_tags(text)
+    doc = REXML::Document.new( text )
+    extract_tag(doc, 'archivist_tags').merge(extract_tag(doc, 'donor_tags'))
+  end
+  
+  def extract_tag(doc, type)
+    tags = doc.elements["/fields/#{type}"]
+    return {} unless tags
+    {type => tags.text.split(/,/).map {|t| t.strip}}
+  end
+
+  #
+  # This method extracts solr fields from simple xml
+  #
+  def xml_to_solr( text, solr_doc=Solr::Document.new )
+    doc = REXML::Document.new( text )
+    doc.root.elements.each do |element|
+      solr_doc << Solr::Field.new( :"#{element.name}_t" => "#{element.text}" )
+    end
+
+    return solr_doc
+  end
+  
+end

data/lib/solrizer/xml/terminology_based_solrizer.rb

@@ -1,15 +1,19 @@
 # This module is only suitable to mix into Classes that use the OM::XML::Document Module
 module Solrizer::XML::TerminologyBasedSolrizer
   
+  def self.default_field_mapper
+    @@default_field_mapper ||= Solrizer::FieldMapper::Default.new
+  end
+  
   # Module Methods
   
   # Build a solr document from +doc+ based on its terminology
   # @doc  OM::XML::Document
   # @solr_doc (optional) Solr::Document to populate
-  def self.solrize(doc, solr_doc=Solr::Document.new)
+  def self.solrize(doc, solr_doc=Solr::Document.new, field_mapper = nil)
     unless doc.class.terminology.nil?
       doc.class.terminology.terms.each_pair do |term_name,term|
-        doc.solrize_term(term, solr_doc)     
+        doc.solrize_term(term, solr_doc, field_mapper)
         # self.solrize_by_term(accessor_name, accessor_info, :solr_doc=>solr_doc)
       end
     end
@@ -21,7 +25,7 @@ module Solrizer::XML::TerminologyBasedSolrizer
   # term identified by +term_pointer+ within +terminology+
   # @doc OM::XML::Document or Nokogiri::XML::Node
   # @term_pointer Array pointing to the desired term in +terminology+  
-  def self.solrize_term(doc, term, solr_doc = Solr::Document.new, opts={})
+  def self.solrize_term(doc, term, solr_doc = Solr::Document.new, field_mapper = nil, opts={})
     terminology = doc.class.terminology
     parents = opts.fetch(:parents, [])
 
@@ -37,9 +41,9 @@ module Solrizer::XML::TerminologyBasedSolrizer
     nodeset.each do |node|
       # create solr fields
       
-      self.solrize_node(node, doc, term_pointer, term, solr_doc)
+      self.solrize_node(node, doc, term_pointer, term, solr_doc, field_mapper)
       term.children.each_pair do |child_term_name, child_term|
-        doc.solrize_term(child_term, solr_doc, opts={:parents=>parents+[{term.name=>nodeset.index(node)}]})
+        doc.solrize_term(child_term, solr_doc, field_mapper, opts={:parents=>parents+[{term.name=>nodeset.index(node)}]})
         # self.solrize_term(doc, child_term_name, child_term, opts={:solr_doc=>solr_doc, :parents=>parents+[{accessor_name=>nodeset.index(node)}] })
       end
     end
@@ -51,7 +55,8 @@ module Solrizer::XML::TerminologyBasedSolrizer
   # @doc OM::XML::Document or Nokogiri::XML::Node
   # @term_pointer Array pointing to the desired term in +terminology+
   # @solr_doc (optional) Solr::Document to populate
-  def self.solrize_node(node, doc, term_pointer, term, solr_doc = Solr::Document.new)
+  def self.solrize_node(node, doc, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = nil, opts = {})
+    field_mapper ||= self.default_field_mapper
     terminology = doc.class.terminology
     # term = terminology.retrieve_term(*term_pointer)
     
@@ -62,43 +67,34 @@ module Solrizer::XML::TerminologyBasedSolrizer
     end
     
     generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
-    generic_field_name = generate_solr_symbol(generic_field_name_base, term.data_type)
     
-    solr_doc << Solr::Field.new(generic_field_name => node_value)
+    field_mapper.solr_names_and_values(generic_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
+      solr_doc << Solr::Field.new(field_name => field_value)
+    end
     
     if term_pointer.length > 1
       hierarchical_field_name_base = OM::XML::Terminology.term_hierarchical_name(*term_pointer)
-      hierarchical_field_name = self.generate_solr_symbol(hierarchical_field_name_base, term.data_type)
-      solr_doc << Solr::Field.new(hierarchical_field_name => node_value)
+      field_mapper.solr_names_and_values(hierarchical_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
+        solr_doc << Solr::Field.new(field_name => field_value)
+      end
     end
     solr_doc
   end
   
-  # Use Solrizer::FieldNameMapper to generate an appropriate solr field name +field_name+ and +field_type+
-  def self.generate_solr_symbol(field_name, field_type) # :nodoc:
-    Solrizer::FieldNameMapper.solr_name(field_name, field_type)
-  end
-  
   # Instance Methods
   
+  attr_accessor :field_mapper
   
-  def to_solr(solr_doc = Solr::Document.new) # :nodoc:
-    Solrizer::XML::TerminologyBasedSolrizer.solrize(self, solr_doc)
+  def to_solr(solr_doc = Solr::Document.new, field_mapper = self.field_mapper) # :nodoc:
+    Solrizer::XML::TerminologyBasedSolrizer.solrize(self, solr_doc, field_mapper)
   end
   
-  
-  def solrize_term(term, solr_doc = Solr::Document.new, opts={})
-    Solrizer::XML::TerminologyBasedSolrizer.solrize_term(self, term, solr_doc, opts)    
+  def solrize_term(term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
+    Solrizer::XML::TerminologyBasedSolrizer.solrize_term(self, term, solr_doc, field_mapper, opts)    
   end
   
-  def solrize_node(node, term_pointer, term, solr_doc = Solr::Document.new)
-    Solrizer::XML::TerminologyBasedSolrizer.solrize_node(node, self, term_pointer, solr_doc)
-  end
-  
-  protected
-
-  def generate_solr_symbol(field_name, field_type) # :nodoc:
-    Solrizer::XML::TerminologyBasedSolrizer.generate_solr_symbol(field_name, field_type)
+  def solrize_node(node, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
+    Solrizer::XML::TerminologyBasedSolrizer.solrize_node(node, self, term_pointer, solr_doc, field_mapper, opts)
   end
   
-end
+end

data/lib/solrizer/xml.rb

@@ -1,4 +1,7 @@
+require "solrizer"
+require "om"
 module Solrizer::XML
 end
+Dir[File.join(File.dirname(__FILE__),"xml","*.rb")].each {|file| require file }
 
-require "solrizer/xml/terminology_based_solrizer"
+Solrizer::Extractor.send(:include, Solrizer::XML::Extractor)

data/lib/solrizer.rb

@@ -1,115 +1,4 @@
 require 'rubygems'
-require 'solrizer/indexer.rb'
-require 'solrizer/field_name_mapper.rb'
+module Solrizer;end
 
-# Let people explicitly require xml support if they want it ...
-# require 'solrizer/xml.rb'
-
-# require 'fastercsv'
-require "ruby-debug"
-
-
-module Solrizer
-class Solrizer
-
-  attr_accessor :indexer, :index_full_text
-
-  #
-  # This method initializes the indexer
-  # If passed an argument of :index_full_text=>true, it will perform full-text indexing instead of indexing fields only.
-  #
-  def initialize( opts={} )
-    @@index_list = false unless defined?(@@index_list)
-    if opts[:index_full_text] == true || opts[:index_full_text] == "true"
-      @index_full_text = true 
-    else
-      @index_full_text = false 
-    end
-    @indexer = Indexer.new( :index_full_text=>@index_full_text )
-  end
-
-  #
-  # This method solrizes the given Fedora object's full-text and facets into the search index
-  #
-  def solrize( obj )
-    # retrieve the Fedora object based on the given unique id
-      
-      begin
-      
-      start = Time.now
-      print "Retrieving object #{obj} ..."
-
-      case obj
-      when ActiveFedora::Base
-        # do nothing
-      when Fedora::FedoraObject
-        obj = Repository.get_object( obj.pid )
-      when String
-        obj = Repository.get_object( obj )
-      else
-        raise "you must pass either a ActiveFedora::Base, Fedora::RepositoryObject, or a String.  You submitted a #{obj.class}"
-      end
-      
-      # obj = obj.kind_of?(ActiveFedora::Base) ? obj : Repository.get_object( obj )
-        
-          obj_done = Time.now
-          obj_done_elapse = obj_done - start
-          puts  " completed. Duration: #{obj_done_elapse}"
-          
-         print "\t Indexing object #{obj.pid} ... "
-         # add the keywords and facets to the search index
-         index_start = Time.now
-         indexer.index( obj )
-         
-         index_done = Time.now
-         index_elapsed = index_done - index_start
-         
-          puts "completed. Duration:  #{index_elapsed} ."
-        
-      
-      rescue Exception => e
-           p "unable to index #{obj}.  Failed with #{e.inspect}"
-        
-      
-      end #begin
-  
-  end
-  
-  #
-  # This method retrieves a comprehensive list of all the unique identifiers in Fedora and 
-  # solrizes each object's full-text and facets into the search index
-  def solrize_objects
-    # retrieve a list of all the pids in the fedora repository
-    num_docs = 1000000   # modify this number to guarantee that all the objects are retrieved from the repository
-    puts "WARNING: You have turned off indexing of Full Text content.  Be sure to re-run indexer with @@index_full_text set to true in main.rb" if index_full_text == false
-
-    if @@index_list == false
-      
-      objects = Fedora::Repository.instance.find_objects(:limit=>num_docs)
-
-      puts "Shelving #{objects.length} Fedora objects"
-      objects.each do |object|
-        solrize( object )
-      end
-     
-    else
-    
-       if File.exists?(@@index_list)
-          arr_of_pids = FasterCSV.read(@@index_list, :headers=>false)
-          
-          puts "Indexing from list at #{@@index_list}"
-          puts "Shelving #{arr_of_pids.length} Fedora objects"
-          
-         arr_of_pids.each do |row|
-            pid = row[0]
-            solrize( pid )
-	 end #FASTERCSV
-        else
-          puts "#{@@index_list} does not exists!"
-        end #if File.exists
-     
-    end #if Index_LISTS
-  end #solrize_objects
-
-end #class
-end #module
+Dir[File.join(File.dirname(__FILE__),"solrizer","*.rb")].each {|file| require file }

data/lib/tasks/solrizer.rake

@@ -1,33 +1,13 @@
 namespace :solrizer do
   
-  desc 'Index a fedora object of the given pid.'
-  task :solrize => :environment do 
-    index_full_text = ENV['FULL_TEXT'] == 'true'
-    if ENV['PID']
-      puts "indexing #{ENV['PID'].inspect}"
-      solrizer = Solrizer::Solrizer.new :index_full_text=> index_full_text
-      solrizer.solrize(ENV['PID'])
-      puts "Finished shelving #{ENV['PID']}"
-    else
-      puts "You must provide a pid using the format 'solrizer::solrize_object PID=sample:pid'."
-    end
+  desc 'Placeholder for generic solrization task.'
+  task :solrize do
+    puts "Nobody here.  Possibly you meant to run rake solrizer:fedora:solrize PID=..."
   end
   
-  desc 'Index all objects in the repository.'
-  task :solrize_objects => :environment do
-    index_full_text = ENV['FULL_TEXT'] == 'true'
-    if ENV['INDEX_LIST']
-      @@index_list = ENV['INDEX_LIST']
-    end
-    
-    puts "Re-indexing Fedora Repository."
-    puts "Fedora URL: #{ActiveFedora.fedora_config[:url]}"
-    puts "Fedora Solr URL: #{ActiveFedora.solr_config[:url]}"
-    puts "Blacklight Solr Config: #{Blacklight.solr_config.inspect}"
-    puts "Doing full text index." if index_full_text
-    solrizer = Solrizer::Solrizer.new :index_full_text=> index_full_text
-    solrizer.solrize_objects
-    puts "Solrizer task complete."
-  end  
+  desc 'Placeholder for generic solrization task.'
+  task :solrize_objects do
+    puts "Nobody here.  Possibly you meant to run rake solrizer:fedora:solrize_objects"
+  end
   
 end

data/solrizer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{solrizer}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt"]
-  s.date = %q{2010-09-15}
+  s.date = %q{2010-10-26}
   s.description = %q{Use solrizer to populate solr indexes from Fedora repository content or from other sources.  You can run solrizer from within your apps, using the provided rake tasks, or as a JMS listener}
   s.email = %q{matt.zumwalt@yourmediashelf.com}
   s.extra_rdoc_files = [
@@ -18,6 +18,8 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
      "History.txt",
      "LICENSE",
      "README.textile",
@@ -27,34 +29,32 @@ Gem::Specification.new do |s|
      "config/hydra_types.yml",
      "config/solr.yml",
      "config/solr_mappings.yml",
+     "config/solr_mappings_af_0.1.yml",
      "lib/solrizer.rb",
-     "lib/solrizer/configuration.rb",
      "lib/solrizer/extractor.rb",
+     "lib/solrizer/field_mapper.rb",
      "lib/solrizer/field_name_mapper.rb",
-     "lib/solrizer/indexer.rb",
-     "lib/solrizer/main.rb",
-     "lib/solrizer/replicator.rb",
-     "lib/solrizer/repository.rb",
+     "lib/solrizer/html.rb",
+     "lib/solrizer/html/extractor.rb",
      "lib/solrizer/xml.rb",
+     "lib/solrizer/xml/extractor.rb",
      "lib/solrizer/xml/terminology_based_solrizer.rb",
      "lib/tasks/solrizer.rake",
      "solrizer.gemspec",
+     "spec/.rspec",
      "spec/fixtures/druid-bv448hq0314-descMetadata.xml",
      "spec/fixtures/druid-bv448hq0314-extProperties.xml",
      "spec/fixtures/druid-cm234kq4672-extProperties.xml",
      "spec/fixtures/druid-cm234kq4672-stories.xml",
      "spec/fixtures/druid-hc513kw4806-descMetadata.xml",
      "spec/fixtures/mods_articles/hydrangea_article1.xml",
-     "spec/fixtures/rels_ext_cmodel.xml",
-     "spec/fixtures/solr_mappings_af_0.1.yml",
-     "spec/integration/indexer_spec.rb",
+     "spec/fixtures/test_solr_mappings.yml",
      "spec/rcov.opts",
-     "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/units/extractor_spec.rb",
+     "spec/units/field_mapper_spec.rb",
      "spec/units/field_name_mapper_spec.rb",
-     "spec/units/indexer_spec.rb",
-     "spec/units/shelver_spec.rb",
+     "spec/units/xml_extractor_spec.rb",
      "spec/units/xml_terminology_based_solrizer_spec.rb"
   ]
   s.homepage = %q{http://github.com/projecthydra/solrizer}
@@ -63,12 +63,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{A utility for building solr indexes, usually from Fedora repository content.}
   s.test_files = [
-    "spec/integration/indexer_spec.rb",
-     "spec/spec_helper.rb",
+    "spec/spec_helper.rb",
      "spec/units/extractor_spec.rb",
+     "spec/units/field_mapper_spec.rb",
      "spec/units/field_name_mapper_spec.rb",
-     "spec/units/indexer_spec.rb",
-     "spec/units/shelver_spec.rb",
+     "spec/units/xml_extractor_spec.rb",
      "spec/units/xml_terminology_based_solrizer_spec.rb"
   ]
 
@@ -77,18 +76,39 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<active-fedora>, [">= 1.1.5"])
-      s.add_runtime_dependency(%q<om>, [">= 1.0.0"])
-      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_runtime_dependency(%q<solr-ruby>, [">= 0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_runtime_dependency(%q<om>, [">= 0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_runtime_dependency(%q<mediashelf-loggable>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug-base>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["< 2.0.0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
-      s.add_dependency(%q<active-fedora>, [">= 1.1.5"])
-      s.add_dependency(%q<om>, [">= 1.0.0"])
-      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<solr-ruby>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<om>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<mediashelf-loggable>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_dependency(%q<ruby-debug-base>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["< 2.0.0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
-    s.add_dependency(%q<active-fedora>, [">= 1.1.5"])
-    s.add_dependency(%q<om>, [">= 1.0.0"])
-    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<solr-ruby>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<om>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<mediashelf-loggable>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<ruby-debug>, [">= 0"])
+    s.add_dependency(%q<ruby-debug-base>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["< 2.0.0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end
 

data/spec/fixtures/test_solr_mappings.yml

@@ -0,0 +1,16 @@
+id: pid
+default: edible
+edible:
+  date: _edible_date
+  string: _edible_string
+  text: _edible_text
+  symbol: _edible_sym
+  integer: _edible_int
+  long: _edible_long
+  boolean: _edible_bool
+  float: _edible_float
+  double: _edible_double
+displayable: _display
+facetable: _facet
+sortable: _sort
+unstemmed_searchable: _unstem_search

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'spec'
 require 'spec/autorun'
 
 require 'solrizer'
+require "ruby-debug"
 
 Spec::Runner.configure do |config|