solrizer 2.2.0 → 3.0.0.pre1

data/lib/solrizer/field_mapper.rb

@@ -1,58 +1,41 @@
 require "loggable"
-require 'active_support'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
 module Solrizer
-  
+
+  class SolrizerError < RuntimeError; end #nodoc#
+  class InvalidIndexDescriptor < SolrizerError; end #nodoc# 
+  class UnknownIndexMacro < SolrizerError; end #nodoc# 
   # Maps Term names and values to Solr fields, based on the Term's data type and any index_as options.
   #
   # The basic structure of a mapper is:
   #
   # == Mapping on Index Type
   #
-  # To define a custom mapper:
-  #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     index_as :searchable, :suffix => '_search'
-  #     index_as :edible,     :suffix => '_food'
-  #   end
-  #
-  #   #   t.dish_name   :index_as => [:searchable]            -maps to->   dish_name_search
-  #   #   t.ingredients :index_as => [:searchable, :edible]   -maps to->   ingredients_search, ingredients_food
-  #
-  # (See Solrizer::XML::TerminologyBasedSolrizer for instructions on applying a custom mapping once you have defined it.)
-  #
-  # == Default Index Types
-  #
-  # You can mark a particular index type as a default. It will then always be included unless terms explicity
-  # exclude it with the "not_" prefix:
-  #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     index_as :searchable, :suffix => '_search', :default => true
-  #     index_as :edible,     :suffix => '_food'
-  #   end
-  #
-  #   #   t.dish_name                                                   -maps to->   dish_name_search
-  #   #   t.ingredients :index_as => [:edible]                          -maps to->   ingredients_search, ingredients_food
-  #   #   t.secret_ingredients :index_as => [:not_searchable, :edible]  -maps to->   secret_ingredients_food
-  #
-  # == Mapping on Data Type
+  # To add a custom mapper to the default mapper
+  # 
+  #   module Solrizer::DefaultDescriptors
+  #     def self.some_field_type
+  #       @some_field_type ||= Descriptor.new(:string, :stored, :indexed, :multivalued)
+  #     end
   #
-  # A mapper can apply different suffixes based on a term's data type:
+  #     # Or some totally different field:
+  #     def self.edible
+  #       @some_field_type ||= EdibleDescriptor.new()
+  #     end
   #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     index_as :searchable, :suffix => '_search' do |type|
-  #       type.date    :suffix => '_date'
-  #       type.integer :suffix => '_numeric'
-  #       type.float   :suffix => '_numeric'
+  #     class EdibleDescriptor < Solrizer::Descriptor
+  #       def name_and_converter(field_name, field_type)
+  #         [field_name + '_food']
+  #       end
   #     end
-  #     index_as :edible, :suffix => '_food'
   #   end
   #
-  #   #   t.published   :type => :date, :index_as => [:searchable]     -maps to->   published_date
-  #   #   t.votes       :type => :integer, :index_as => [:searchable]  -maps to->   votes_numeric
+  #   #   t.dish_name   :index_as => [:some_field_type]           -maps to->   dish_name_ssim
+  #   #   t.ingredients :index_as => [:some_field_type, :edible]  -maps to->   ingredients_ssim, ingredients_food
   #
-  # If a specific data type doesn't appear in the list, the mapper falls back to the index_as:
+  # (See Solrizer::XML::TerminologyBasedSolrizer for instructions on applying a custom mapping once you have defined it.)
   #
-  #   #   t.description :type => :text, :index_as => [:searchable]     -maps to->   description_search
   #
   # == Custom Value Converters
   #
@@ -60,185 +43,130 @@ module Solrizer
   # generation of Solr values by attaching a custom value converter block to a data type:
   #
   #   require 'time'
-  #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     index_as :searchable, :suffix => '_search' do |type|
-  #       type.date do |value|
-  #         Time.parse(value).utc.to_i
-  #       end
+  #   module Solrizer::DefaultDescriptors
+  #     def self.searchable
+  #       @searchable ||= SearchableDescriptor.new(:string, :stored, :indexed, :multivalued, converter: my_converter)
   #     end
-  #   end
-  #
-  # Note that the nesting order is always:
-  #
-  #   FieldMapper definition
-  #     index_as
-  #       data type
-  #         value converter
-  #
-  # You can use the special data type "default" to apply custom value conversion to any data type:
   #
-  #   require 'time'
-  #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     index_as :searchable do |type|
-  #       type.date :suffix => '_date' do |value|
-  #         Time.parse(value).utc.to_i
-  #       end
-  #       type.default :suffix => '_search' do |value|
-  #         value.to_s.strip
+  #     def self.my_converter
+  #       lambda do |type|
+  #         case type
+  #         when :date
+  #           lambda { |value| Time.parse(value).utc.to_i }
+  #         else
+  #           lambda { |value| value.to_s.strip }
+  #         end
   #       end
   #     end
   #   end
   #
   # This example converts searchable dates to milliseconds, and strips extra whitespace from all other searchable data types.
   #
-  # Note that the :suffix option may appear on the data types and the index_as. The search order for the suffix on a field
-  # of type foo is:
-  # 1. type.foo
-  # 2. type.default
-  # 3. index_as
-  # The suffix is optional in all three places.
-  #
-  # Note that a single Term with multiple index types can translate into multiple Solr fields, because we may want Solr to
-  # index a single field in multiple ways. However, if two different mappings generate both the same solr field name
-  # _and_ the same value, the mapper will only emit a single field.
   #
   # == ID Field
   #
   # In addition to the normal field mappings, Solrizer gives special treatment to an ID field. If you want that
   # logic (and you probably do), specify a name for this field:
   #
-  #   class CustomMapper < Solrizer::FieldMapper
-  #     id_field 'id' 
-  #   end
+  #   Solrizer::FieldMapper.id_field  = 'id' 
+  #
   #
   # == Extending the Default
   #
-  # The default mapper is Solrizer::FieldMapper::Default. You can customize the default mapping by subclassing it.
+  # The default mapper is Solrizer::FieldMapper. You can customize the default mapping by subclassing it.
   # For example, to override the ID field name and the default suffix for sortable, and inherit everything else:
   #
-  #   class CustomMapperBasedOnDefault < Solrizer::FieldMapper::Default
-  #     id_field 'guid'
-  #     index_as :sortable, :suffix => '_xsort'
+  #   class CustomMapperBasedOnDefault < Solrizer::FieldMapper
+  #     self.id_field = 'guid'
+  #
+  #     module MyCustomIndexDescriptors
+  #       def self.my_converter
+  #         @my_converter ||= Descriptor.new(:string, :stored, :indexed, :multivalued)
+  #       end
+  #     end
+  #
+  #     self.descriptors = [MyCustomIndexDescriptors, DefaultDescriptors]
   #   end
   
   class FieldMapper
     
     include Loggable
     
-    # ------ Class methods ------
+    # ------ Instance methods ------
     
-    @@instance_init_actions = Hash.new { |h,k| h[k] = [] }
+    attr_reader :id_field, :default_index_types
+    class_attribute :id_field
+    class_attribute :descriptors
+    # set defaults
+    self.descriptors = [DefaultDescriptors]
+    self.id_field = 'id'
+
     
-    def self.id_field(field_name)
-      add_instance_init_action do
-        @id_field = field_name
-      end
+    def initialize
+      self.id_field = self.class.id_field
     end
+
+    # Given a specific field name, data type, and index type, returns the corresponding solr name.
     
-    def self.index_as(index_type, opts = {}, &block)
-      add_instance_init_action do
-        mapping = (@mappings[index_type] ||= IndexTypeMapping.new)
-        mapping.opts.merge! opts
-        yield DataTypeMappingBuilder.new(mapping) if block_given?
+    # TODO field type is the input format, maybe we could just detect that?
+    # @param index_type is a FieldDescriptor
+    def solr_name(field_name, *opts)
+      index_type, args = if opts.first.kind_of? Hash
+        [:searchable, opts.first]
+      elsif opts.empty?
+        [:searchable, {type: :text}]
+      else
+        [opts[0], opts[1] || {}]
       end
-    end
-    
-    # Loads solr mappings from yml file.
-    # Assumes that string values are solr field name suffixes.  
-    # This is meant as a simple entry point for working with solr mappings.  For more powerful control over solr mappings, create your own subclasses of FieldMapper instead of using a yml file.
-    # @param [String] config_path This is the path to the directory where your mappings file is stored. Defaults to "Rails.root/config/solr_mappings.yml"
-    def self.load_mappings( config_path=nil )
 
-      if config_path.nil? 
-        if defined?(Rails.root) && !Rails.root.nil?
-          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
+      indexer(index_type).name_and_converter(field_name, args).first
+    end
 
-      logger.debug("SOLRIZER: loading field name mappings from #{File.expand_path(config_path)}")
-      mappings_from_file = YAML::load(File.open(config_path))
-      
-      self.clear_mappings
-      
-      # Set id_field from file if it is available
-      id_field_from_file = mappings_from_file.delete("id")
-      if id_field_from_file.nil?
-        id_field "id"
+    # @param index_type [Symbol]
+    # search through the descriptors (class attribute) until a module is found that responds to index_type, then call it.
+    def index_type_macro(index_type)
+      klass = self.class.descriptors.find { |klass| klass.respond_to? index_type}
+      if klass
+        klass.send(index_type)
       else
-        id_field id_field_from_file
+        raise UnknownIndexMacro, "Unable to find `#{index_type}' in #{self.class.descriptors}"
       end
-      
-      default_index_type = mappings_from_file.delete("default")
-      mappings_from_file.each_pair do |index_type, type_settings| 
-        if type_settings.kind_of?(Hash)
-          index_as index_type.to_sym, :default => index_type == default_index_type do |t|
-            type_settings.each_pair do |field_type, suffix|
-              eval("t.#{field_type} :suffix=>\"#{suffix}\"")
-            end
-          end
-        else
-          index_as index_type.to_sym, :default => index_type == default_index_type, :suffix=>type_settings 
-        end
-      end      
     end
 
-    # Reset all of the mappings
-    def self.clear_mappings
-      logger.debug "resetting mappings for #{self.to_s}"
-      @@instance_init_actions[self] = []
-    end
-  
-  private
-  
-    def self.add_instance_init_action(&block)
-      @@instance_init_actions[self] << lambda do |mapper|
-        mapper.instance_eval &block
-      end
-    end
-  
-    def self.apply_instance_init_actions(instance)
-      if self.superclass.respond_to? :apply_instance_init_actions
-        self.superclass.apply_instance_init_actions(instance)
-      end
-      @@instance_init_actions[self].each do |action|
-        action.call(instance)
+    # # @param index_type is a FieldDescriptor or a symbol that points to a method that returns a field descriptor
+    def indexer(index_type)
+      index_type = case index_type
+      when Symbol
+        index_type_macro(index_type)
+      when Array
+        raise "It's not yet supposed to be an array"
+        #IndexDescriptors::Descriptor.new(*index_type)
+      else
+        index_type
       end
-    end
-    
-  
-  public
-    
-    # ------ Instance methods ------
-    
-    attr_reader :id_field, :default_index_types, :mappings
-    
-    def initialize
-      @mappings = {}
-      self.class.apply_instance_init_actions(self)
-      @default_index_types = @mappings.select { |ix_type, mapping| mapping.opts[:default] }.map(&:first)
+
+      raise InvalidIndexDescriptor, "index type should be an IndexDescriptor, you passed: #{index_type}" unless index_type.kind_of? Descriptor
+      index_type
     end
 
-    # Given a specific field name, data type, and index type, returns the corresponding solr name.
-    
-    def solr_name(field_name, field_type, index_type = :searchable)
-      name, mapping, data_type_mapping = solr_name_and_mappings(field_name, field_type, index_type)
-      name
+    def extract_type(value)
+      case value
+      when NilClass
+      when Fixnum
+        :integer
+      else
+        value.class.to_s.underscore.to_sym
+      end
     end
 
     # Given a field name-value pair, a data type, and an array of index types, returns a hash of
     # mapped names and values. The values in the hash are _arrays_, and may contain multiple values.
     
-    def solr_names_and_values(field_name, field_value, field_type, index_types)
-      # Determine the set of index types, adding defaults and removing not_xyz
+    def solr_names_and_values(field_name, field_value, index_types)
+      return {} unless field_value
       
+      # Determine the set of index types, adding defaults and removing not_xyz
       index_types ||= []
-      index_types += default_index_types
       index_types.uniq!
       index_types.dup.each do |index_type|
         if index_type.to_s =~ /^not_(.*)/
@@ -253,19 +181,21 @@ module Solrizer
       
       index_types.each do |index_type|
         # Get mapping for field
-        name, mapping, data_type_mapping = solr_name_and_mappings(field_name, field_type, index_type)
+        name, converter = indexer(index_type).name_and_converter(field_name, type: extract_type(field_value))
+        #name, converter = solr_name_and_converter(field_name, index_type, field_type)
         next unless name
         
         # Is there a custom converter?
-        value = if data_type_mapping && data_type_mapping.converter
-          converter = data_type_mapping.converter
+        # TODO instead of a custom converter, look for input data type and output data type. Create a few methods that can do that cast.
+
+        value = if converter
           if converter.arity == 1
             converter.call(field_value)
           else
             converter.call(field_value, field_name)
           end
         else
-          field_value
+          field_value.to_s
         end
         
         # Add mapped name & value, unless it's a duplicate
@@ -275,116 +205,5 @@ module Solrizer
       
       results
     end
-    
-  private
-  
-    def solr_name_and_mappings(field_name, field_type, index_type)
-      field_name = field_name.to_s
-      mapping = @mappings[index_type]
-      unless mapping
-        logger.debug "Unknown index type '#{index_type}' for field #{field_name}"
-        return nil
-      end
-      
-      data_type_mapping = mapping.data_types[field_type] || mapping.data_types[:default]
-      
-      suffix = data_type_mapping.opts[:suffix] if data_type_mapping
-      suffix ||= mapping.opts[:suffix]
-      name = field_name + suffix
-      
-      [name, mapping, data_type_mapping]
-    end
-
-    class IndexTypeMapping
-      attr_accessor :opts, :data_types
-      
-      def initialize
-        @opts = {}
-        @data_types = {}
-      end
-    end
-    
-    class DataTypeMapping
-      attr_accessor :opts, :converter
-      
-      def initialize
-        @opts = {}
-      end
-    end
-    
-    class DataTypeMappingBuilder
-      def initialize(index_type_mapping)
-        @index_type_mapping = index_type_mapping
-      end
-      
-      def method_missing(method, *args, &block)
-        data_type_mapping = (@index_type_mapping.data_types[method] ||= DataTypeMapping.new)
-        data_type_mapping.opts.merge! args[0] if args.length > 0
-        data_type_mapping.converter = block if block_given?
-      end
-    end
-    
-    # ------ Default mapper ------
-  
-  public
-
-    module Defaults
-      extend ActiveSupport::Concern
-      included do 
-        id_field 'id'
-        index_as :searchable do |t|
-          t.default :suffix => '_t'
-          t.date :suffix => '_dt' do |value|
-            iso8601_date(value)
-          end
-          t.string  :suffix => '_t'
-          t.text    :suffix => '_t'
-          t.symbol  :suffix => '_s'
-          t.integer :suffix => '_i'
-          t.long    :suffix => '_l'
-          t.boolean :suffix => '_b'
-          t.float   :suffix => '_f'
-          t.double  :suffix => '_d'
-        end
-        index_as :displayable, :suffix => '_display' do |t|
-          t.date do |value|
-            value.to_s
-          end
-        end
-        index_as :facetable, :suffix => '_facet' do |t|
-          t.date do |value|
-            value.to_s
-          end
-        end
-
-        index_as :sortable, :suffix => '_sort' do |t|
-          t.date do |value|
-            value.to_s
-          end
-        end
-
-        index_as :unstemmed_searchable, :suffix => '_unstem_search'
-      end
-    end
-
-    class Default < FieldMapper
-      include Defaults
-    end
-
-    protected
-
-    def self.iso8601_date(value)
-      begin 
-        if value.is_a?(Date) 
-          DateTime.parse(value.to_s).to_time.utc.iso8601 
-        elsif !value.empty?
-          DateTime.parse(value).to_time.utc.iso8601
-        end
-      rescue ArgumentError => e
-        raise ArgumentError, "Unable to parse `#{value}' as a date-time object"
-      end
-    end
-    
   end
-    
 end

data/lib/solrizer/version.rb

@@ -1,3 +1,3 @@
 module Solrizer
-  VERSION = "2.2.0"
+  VERSION = "3.0.0.pre1"
 end

data/lib/solrizer/xml/extractor.rb

@@ -8,21 +8,21 @@ module Solrizer::XML::Extractor
   #
   # @param [xml] text xml content to index
   # @param [Hash] solr_doc
-  def xml_to_solr( text, solr_doc=Hash.new )
+  def xml_to_solr( text, solr_doc=Hash.new, mapper = Solrizer.default_field_mapper )
     doc = XmlSimple.xml_in( text )
     
     doc.each_pair do |name, value|
       if value.kind_of?(Array) 
         if value.first.kind_of?(Hash)
           # This deals with the way xml-simple handles nodes with attributes
-          solr_doc.merge!({:"#{name}_t" => "#{value.first["content"]}"})
+          solr_doc.merge!({mapper.solr_name(name, :searchable, :type=>:text).to_sym => "#{value.first["content"]}"})
         elsif value.length > 1
-          solr_doc.merge!({:"#{name}_t" => value})
+          solr_doc.merge!({mapper.solr_name(name, :searchable, :type=>:text).to_sym => value})
         else
-          solr_doc.merge!({:"#{name}_t" => "#{value.first}"})
+          solr_doc.merge!({mapper.solr_name(name, :searchable, :type=>:text).to_sym => "#{value.first}"})
         end
       else
-        solr_doc.merge!({:"#{name}_t" => "#{value}"})
+        solr_doc.merge!({mapper.solr_name(name, :searchable, :type=>:text).to_sym => "#{value}"})
       end
     end
 

data/lib/solrizer/xml/terminology_based_solrizer.rb

@@ -35,17 +35,10 @@ module Solrizer::XML::TerminologyBasedSolrizer
       nodeset = doc.term_values(*term_pointer)
       
       nodeset.each do |n|
-        
-        # TODO: Solrizer::FieldMapper::Default is supposed to translate dates into full ISO 8601 formatted strings.
-        # However, there an integration issue with ActiveFedora using OM: it ignores the default field mapper given
-        # in this gem that does this. So, the following is a workaround until it is fixed.
-        node = n.is_a?(Date) ? DateTime.parse(n.to_s).to_time.utc.iso8601 : n.to_s
-        
-        doc.solrize_node(node.to_s, term_pointer, term, solr_doc, field_mapper)
+        doc.solrize_node(n, term_pointer, term, solr_doc, field_mapper)
         unless term.kind_of? OM::XML::NamedTermProxy
           term.children.each_pair do |child_term_name, child_term|
-            next if child_term.kind_of? OM::XML::NamedTermProxy and term.is_root_term?
-            doc.solrize_term(child_term, solr_doc, field_mapper, opts={:parents=>parents+[{term.name=>nodeset.index(node.to_s)}]})
+            doc.solrize_term(child_term, solr_doc, field_mapper, opts={:parents=>parents+[{term.name=>nodeset.index(n)}]})
           end
         end
       end
@@ -63,26 +56,17 @@ module Solrizer::XML::TerminologyBasedSolrizer
     # @return [Hash] the solr doc
     def solrize_node(node_value, doc, term_pointer, term, solr_doc = Hash.new, field_mapper = nil, opts = {})
       return solr_doc unless term.index_as && !term.index_as.empty?
-
-      directive = term_to_solrizer_directive(term)
       
       generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
-      create_and_insert_terms(generic_field_name_base, node_value, directive, solr_doc)
-
+      create_and_insert_terms(generic_field_name_base, node_value, term.index_as, solr_doc)
       
       if term_pointer.length > 1
         hierarchical_field_name_base = OM::XML::Terminology.term_hierarchical_name(*term_pointer)
-        create_and_insert_terms(hierarchical_field_name_base, node_value, directive, solr_doc)
+        create_and_insert_terms(hierarchical_field_name_base, node_value, term.index_as, solr_doc)
       end
       solr_doc
     end
 
-    private
-
-    def term_to_solrizer_directive(term)
-      Solrizer::Directive.new(term.type, term.index_as)
-    end
-    
   end
 
   

data/lib/solrizer.rb

@@ -4,7 +4,7 @@ module Solrizer
   end
 
   def self.default_field_mapper
-    @@default_field_mapper ||= Solrizer::FieldMapper::Default.new
+    @@default_field_mapper ||= Solrizer::FieldMapper.new
   end
 
   def self.default_field_mapper=(field_mapper)

data/solrizer.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.add_dependency "stomp"
   s.add_dependency "daemons"
   s.add_dependency "activesupport"
-  s.add_development_dependency 'rspec', '~>2.0'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'RedCloth' # yard depends on redcloth

data/spec/fixtures/mods_article.rb

@@ -76,7 +76,6 @@ module Samples
         t.url(:path=>"url")
       }
       t.publication_url(:proxy=>[:location,:url])
-      t.root_title(:proxy => [:mods, :title_info, :main_title], :index_as => [:searchable])
       t.title(:proxy=>[:title_info, :main_title])
       t.journal_title(:proxy=>[:journal, :title_info, :main_title])
       t.pub_date(:proxy=>[:journal, :issue, :publication_date])

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'active_model'
 
 
 if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/

data/spec/units/common_spec.rb

@@ -12,28 +12,24 @@ describe Solrizer::Common do
 
   it "should handle many field types" do
     solr_doc = {}
-    directive = Solrizer::Directive.new(:string, [:displayable, :searchable, :sortable] )
-    Foo.create_and_insert_terms('my_name', 'value', directive, solr_doc)
-    solr_doc.should == {'my_name_t' => ['value'], 'my_name_sort' => ['value'], 'my_name_display' => ['value']}
+    Foo.create_and_insert_terms('my_name', 'value', [:displayable, :searchable, :sortable], solr_doc)
+    solr_doc.should == {'my_name_ssm' => ['value'], 'my_name_ssi' => ['value'], 'my_name_tesim' => ['value']}
   end
   it "should handle dates that are searchable" do
     solr_doc = {}
-    directive = Solrizer::Directive.new(:date, [:searchable] )
-    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), directive, solr_doc)
-    solr_doc.should == {'my_name_dt' => ['2013-01-10T00:00:00Z']}
+    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:searchable], solr_doc)
+    solr_doc.should == {'my_name_dtsi' => ['2013-01-10T00:00:00Z']}
   end
 
   it "should handle dates that are displayable" do
     solr_doc = {}
-    directive = Solrizer::Directive.new(:date, [:displayable])
-    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), directive, solr_doc)
-    solr_doc.should == {'my_name_display' => ['2013-01-10']}
+    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:displayable], solr_doc)
+    solr_doc.should == {'my_name_ssm' => ['2013-01-10']}
   end
 
   it "should handle dates that are sortable" do
     solr_doc = {}
-    directive = Solrizer::Directive.new(:date, [:sortable])
-    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), directive, solr_doc)
-    solr_doc.should == {'my_name_sort' => ['2013-01-10']}
+    Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:sortable], solr_doc)
+    solr_doc.should == {'my_name_ssi' => ['2013-01-10']}
   end
 end

data/spec/units/extractor_spec.rb

@@ -22,8 +22,9 @@ describe Solrizer::Extractor do
 
   describe "#insert_solr_field_value" do
     it "should initialize a solr doc list if it is nil" do
-       solr_doc = {'title_t' => nil }
-       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_t', 'Frank')
+       solr_doc = {'title_tesim' => nil }
+       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Frank')
+       solr_doc.should == {"title_tesim"=>["Frank"]}
     end
   end