solrizer 2.2.0 → 3.0.0.pre1

data/spec/units/field_mapper_spec.rb

@@ -3,39 +3,127 @@ require 'spec_helper'
 describe Solrizer::FieldMapper do
   
   # --- Test Mappings ----
-  
   class TestMapper0 < Solrizer::FieldMapper
-    id_field 'ident'
-    index_as :searchable, :suffix => '_s',    :default => true
-    index_as :edible,     :suffix => '_food'
-    index_as :laughable,  :suffix => '_haha', :default => true do |type|
-      type.integer :suffix => '_ihaha' do |value, field_name|
-        "How many #{field_name}s does it take to screw in a light bulb? #{value.capitalize}."
+    self.id_field= 'ident'
+    module Descriptors0
+      # Produces a _s suffix (overrides _tim)
+      def self.unstemmed_searchable
+        @unstemmed_searchable ||= UnstemmedDescriptor.new()
       end
-      type.default do |value|
-        "Knock knock. Who's there? #{value.capitalize}. #{value.capitalize} who?"
+
+      # Produces a _s suffix (overrides _tim)
+      def self.searchable
+        @searchable ||= SearchableDescriptor.new()
       end
-    end
-    index_as :fungible, :suffix => '_f0' do |type|
-      type.integer :suffix => '_f1'
-      type.date
-      type.default :suffix => '_f2'
-    end
-    index_as :unstemmed_searchable, :suffix => '_s' do |type|
-      type.date do |value|
-        "#{value} o'clock"
+
+      # Produces a _s suffix (overrides _tim)
+      def self.another_searchable
+        @another_searchable ||= SearchableDescriptor.new()
+      end
+
+      def self.edible
+        @edible ||= EdibleDescriptor.new()
+      end
+
+      def self.fungible
+        @fungible ||= FungibleDescriptor.new()
+      end
+
+      def self.laughable
+        @laughable ||= LaughableDescriptor.new()
+      end
+
+      class UnstemmedDescriptor < Solrizer::Descriptor
+        def name_and_converter(field_name, args)
+          [field_name + '_s', lambda { |value| "#{value} o'clock" }]
+        end
+      end
+
+      class SearchableDescriptor < Solrizer::Descriptor
+        def name_and_converter(field_name, args)
+          [field_name.to_s + '_s']
+        end
+      end
+
+      class EdibleDescriptor < Solrizer::Descriptor
+        def name_and_converter(field_name, args)
+          [field_name + '_food']
+        end
+      end
+
+      class FungibleDescriptor < Solrizer::Descriptor
+        def name_and_converter(field_name, args)
+          [field_name + fungible_type(args[:type])]
+        end
+        def fungible_type(type)
+          case type
+          when :integer
+            '_f1'
+          when :date
+            '_f0'
+          else
+            '_f2'
+          end
+        end
+      end
+
+      class LaughableDescriptor < Solrizer::Descriptor
+        def name_and_converter(field_name, args)
+          field_type = args[:type]
+          [field_name + laughable_type(field_type), laughable_converter(field_type)]
+        end
+
+        def laughable_type(type)
+          case type
+          when :integer
+            '_ihaha'
+          else
+            '_haha'
+          end
+        end
+
+        def laughable_converter(type)
+          case type
+          when :integer
+            lambda do |value, field_name| 
+              "How many #{field_name}s does it take to screw in a light bulb? #{value}."
+            end
+          else
+            lambda do |value| 
+              "Knock knock. Who's there? #{value.capitalize}. #{value.capitalize} who?"
+            end
+          end
+        end
       end
     end
+
+    self.descriptors = [Descriptors0, Solrizer::DefaultDescriptors]
   end
   
   class TestMapper1 < TestMapper0
-    index_as :searchable do |type|
-      type.date :suffix => '_d'
-    end
-    index_as :fungible, :suffix => '_f3' do |type|
-      type.garble  :suffix => '_f4'
-      type.integer :suffix => '_f5'
+    module Descriptors1
+      def self.fungible
+        @fungible ||= FungibleDescriptor.new()
+      end
+
+      class FungibleDescriptor < TestMapper0::Descriptors0::FungibleDescriptor
+        def name_and_converter(field_name, args)
+          [field_name + fungible_type(args[:type])]
+        end
+
+        def fungible_type(type)
+            case type
+            when :garble
+              '_f4'
+            when :integer
+              '_f5'
+            else
+              super
+            end
+        end
+      end
     end
+    self.descriptors = [Descriptors1, Descriptors0, Solrizer::DefaultDescriptors]
   end
   
   before(:each) do
@@ -50,185 +138,133 @@ describe Solrizer::FieldMapper do
   it "should handle the id field" do
     @mapper.id_field.should == 'ident'
   end
+
+
+  describe "extract_type" do
+    it "should map objects to symbols" do
+      @mapper.extract_type(7).should == :integer
+      @mapper.extract_type(nil).should == nil
+      @mapper.extract_type(Date.today).should == :date
+      @mapper.extract_type("Hi").should == :string
+    end
+  end
   
   describe '.solr_name' do
     it "should map based on index_as" do
-      @mapper.solr_name('bar', :string, :edible).should == 'bar_food'
-      @mapper.solr_name('bar', :string, :laughable).should == 'bar_haha'
+      @mapper.solr_name('bar', :edible).should == 'bar_food'
+      @mapper.solr_name('bar', :laughable, type: :string).should == 'bar_haha'
     end
 
     it "should default the index_type to :searchable" do
-      @mapper.solr_name('foo', :string).should == 'foo_s'
+      @mapper.solr_name('foo').should == 'foo_s'
     end
-    
+
     it "should map based on data type" do
-      @mapper.solr_name('foo', :integer, :fungible).should == 'foo_f1'
-      @mapper.solr_name('foo', :garble,  :fungible).should == 'foo_f2'  # based on type.default
-      @mapper.solr_name('foo', :date,    :fungible).should == 'foo_f0'  # type.date falls through to container
+      @mapper.solr_name('foo', :fungible, type: :integer).should == 'foo_f1'
+      @mapper.solr_name('foo', :fungible, type: :garble).should == 'foo_f2'  # based on type.default
+      @mapper.solr_name('foo', :fungible, type: :date).should == 'foo_f0'  # type.date falls through to container
     end
   
     it "should return nil for an unknown index types" do
-      silence do
-        @mapper.solr_name('foo', :string, :blargle).should == nil
-      end
+      lambda { 
+        @mapper.solr_name('foo', :blargle)
+      }.should raise_error(Solrizer::UnknownIndexMacro, "Unable to find `blargle' in [TestMapper0::Descriptors0, Solrizer::DefaultDescriptors]")
     end
     
     it "should allow subclasses to selectively override suffixes" do
       @mapper = TestMapper1.new
-      @mapper.solr_name('foo', :date).should == 'foo_d'   # override
-      @mapper.solr_name('foo', :string).should == 'foo_s' # from super
-      @mapper.solr_name('foo', :integer, :fungible).should == 'foo_f5'  # override on data type
-      @mapper.solr_name('foo', :garble,  :fungible).should == 'foo_f4'  # override on data type
-      @mapper.solr_name('foo', :fratz,   :fungible).should == 'foo_f2'  # from super
-      @mapper.solr_name('foo', :date,    :fungible).should == 'foo_f3'  # super definition picks up override on index type
+      @mapper.solr_name('foo', type: :date).should == 'foo_s'
+      @mapper.solr_name('foo', type: :string).should == 'foo_s'
+      @mapper.solr_name('foo', :fungible, type: :integer).should == 'foo_f5'  # override on data type
+      @mapper.solr_name('foo', :fungible, type: :garble).should == 'foo_f4'  # override on data type
+      @mapper.solr_name('foo', :fungible, type: :fratz).should == 'foo_f2'  # from super
+      @mapper.solr_name('foo', :fungible, type: :date).should == 'foo_f0'  # super definition picks up override on index type
     end
     
-    it "should support field names as symbols" do
-      @mapper.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_s"
-    end
     
-    it "should support scenarios where field_type is nil" do
-      mapper = Solrizer::FieldMapper::Default.new
-      mapper.solr_name(:heifer, nil, :searchable).should == "heifer_t"
+    it "should raise an error when field_type is nil" do
+      mapper = Solrizer::FieldMapper.new
+      lambda { mapper.solr_name(:heifer, nil, :searchable)}.should raise_error Solrizer::InvalidIndexDescriptor
     end
   end
   
   describe '.solr_names_and_values' do
     it "should map values based on index_as" do
-      @mapper.solr_names_and_values('foo', 'bar', :string, [:searchable, :laughable, :edible]).should == {
+      @mapper.solr_names_and_values('foo', 'bar', [:searchable, :laughable, :edible]).should == {
         'foo_s'    => ['bar'],
         'foo_food' => ['bar'],
         'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
       }
     end
     
-    it "should apply default index_as mapping unless excluded with not_" do
-      @mapper.solr_names_and_values('foo', 'bar', :string, []).should == {
-        'foo_s' => ['bar'],
-        'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
-      }
-      @mapper.solr_names_and_values('foo', 'bar', :string, [:edible, :not_laughable]).should == {
-        'foo_s' => ['bar'],
-        'foo_food' => ['bar']
-      }
-      @mapper.solr_names_and_values('foo', 'bar', :string, [:not_searchable, :not_laughable]).should == {}
-    end
-  
     it "should apply mappings based on data type" do
-      @mapper.solr_names_and_values('foo', 'bar', :integer, [:searchable, :laughable]).should == {
-        'foo_s'     => ['bar'],
-        'foo_ihaha' => ["How many foos does it take to screw in a light bulb? Bar."]
+      @mapper.solr_names_and_values('foo', 7, [:searchable, :laughable]).should == {
+        'foo_s'     => ['7'],
+        'foo_ihaha' => ["How many foos does it take to screw in a light bulb? 7."]
       }
     end
     
-    it "should skip unknown index types" do
-      silence do
-        @mapper.solr_names_and_values('foo', 'bar', :string, [:blargle]).should == {
-          'foo_s' => ['bar'],
-          'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
-        }
-      end
+    it "should raise error on unknown index types" do
+      lambda { 
+        @mapper.solr_names_and_values('foo', 'bar', [:blargle])
+      }.should raise_error(Solrizer::UnknownIndexMacro, "Unable to find `blargle' in [TestMapper0::Descriptors0, Solrizer::DefaultDescriptors]")
     end
     
     it "should generate multiple mappings when two return the _same_ solr name but _different_ values" do
-      @mapper.solr_names_and_values('roll', 'rock', :date, [:unstemmed_searchable, :not_laughable]).should == {
+      @mapper.solr_names_and_values('roll', 'rock', [:unstemmed_searchable, :searchable]).should == {
         'roll_s' => ["rock o'clock", 'rock']
       }
     end
     
     it "should not generate multiple mappings when two return the _same_ solr name and the _same_ value" do
-      @mapper.solr_names_and_values('roll', 'rock', :string, [:unstemmed_searchable, :not_laughable]).should == {
+      @mapper.solr_names_and_values('roll', 'rock', [:another_searchable, :searchable]).should == {
         'roll_s' => ['rock'],
       }
     end
-  end
 
-  describe "#load_mappings" do 
-    before(:each) do
-      class TestMapperLoading < Solrizer::FieldMapper
-      end
+    it "should return an empty hash when value is nil" do
+      @mapper.solr_names_and_values('roll', nil, [:another_searchable, :searchable]).should == { }
     end
-    it "should take mappings file as an optional argument" do
-      file_path = File.join(File.dirname(__FILE__), "..", "fixtures","test_solr_mappings.yml")
-  	  TestMapperLoading.load_mappings(file_path)
-  	  mapper = TestMapperLoading.new
-      mappings_from_file = YAML::load(File.open(file_path))
-      mapper.id_field.should == "pid"
-      mapper.mappings[:edible].opts[:default].should == true
-      mapper.mappings[:edible].data_types[:boolean].opts[:suffix].should == "_edible_bool"
-      mappings_from_file["edible"].each_pair do |k,v|
-        mapper.mappings[:edible].data_types[k.to_sym].opts[:suffix].should == v        
-      end
-      mapper.mappings[:displayable].opts[:suffix].should == mappings_from_file["displayable"]
-      mapper.mappings[:facetable].opts[:suffix].should == mappings_from_file["facetable"]
-      mapper.mappings[:sortable].opts[:suffix].should == mappings_from_file["sortable"]
-	  end
-	  it 'should default to using the mappings from config/solr_mappings.yml' do
-	    TestMapperLoading.load_mappings
-  	  mapper = TestMapperLoading.new
-  	  default_file_path = File.join(File.dirname(__FILE__), "..", "..","config","solr_mappings.yml")
-      mappings_from_file = YAML::load(File.open(default_file_path))
-      mapper.id_field.should == mappings_from_file["id"]
-      mappings_from_file["searchable"].each_pair do |k,v|
-        mapper.mappings[:searchable].data_types[k.to_sym].opts[:suffix].should == v        
-      end
-      mapper.mappings[:displayable].opts[:suffix].should == mappings_from_file["displayable"]
-      mapper.mappings[:facetable].opts[:suffix].should == mappings_from_file["facetable"]
-      mapper.mappings[:sortable].opts[:suffix].should == mappings_from_file["sortable"]
-    end
-    it "should wipe out pre-existing mappings without affecting other FieldMappers" do
-      TestMapperLoading.load_mappings
-      file_path = File.join(File.dirname(__FILE__), "..", "fixtures","test_solr_mappings.yml")
-  	  TestMapperLoading.load_mappings(file_path)
-  	  mapper = TestMapperLoading.new
-  	  mapper.mappings[:searchable].should be_nil
-  	  default_mapper = Solrizer::FieldMapper::Default.new
-  	  default_mapper.mappings[:searchable].should_not be_nil
-  	end
-  	it "should raise an informative error if the yaml file is structured improperly"
-  	it "should raise an informative error if there is no YAML file"
-	end
-  
-  describe Solrizer::FieldMapper::Default do
+  end
+
+  describe Solrizer::FieldMapper do
     before(:each) do
-      @mapper = Solrizer::FieldMapper::Default.new
+      @mapper = Solrizer::FieldMapper.new
     end
   	
     it "should call the id field 'id'" do
       @mapper.id_field.should == 'id'
     end
+
+    it "should default the index_type to :searchable" do
+      @mapper.solr_name('foo', :type=>:string).should == 'foo_tesim'
+    end
+    
+    it "should support field names as symbols" do
+      @mapper.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_ssim"
+    end
     
     it "should not apply mappings for searchable by default" do
       # Just sanity check a couple; copy & pasting all data types is silly
-      @mapper.solr_names_and_values('foo', 'bar', :string, []).should == {  }
-      @mapper.solr_names_and_values('foo', "1", :integer, []).should == { }
+      @mapper.solr_names_and_values('foo', 'bar', []).should == {  }
+      @mapper.solr_names_and_values('foo', "1",[]).should == { }
     end
 
     it "should support full ISO 8601 dates" do
-      @mapper.solr_names_and_values('foo', "2012-11-06",              :date, [:searchable]).should == { 'foo_dt' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', "November 6th, 2012",      :date, [:searchable]).should == { 'foo_dt' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', Date.parse("6 Nov. 2012"), :date, [:searchable]).should == { 'foo_dt' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', '', :date, [:searchable]).should == { 'foo_dt' => [] }
+      @mapper.solr_names_and_values('foo', "2012-11-06",  [:dateable]).should == { 'foo_dtsi' =>["2012-11-06T00:00:00Z"] }
+      @mapper.solr_names_and_values('foo', "November 6th, 2012",  [:dateable]).should == { 'foo_dtsi' =>["2012-11-06T00:00:00Z"] }
+      @mapper.solr_names_and_values('foo', "6 Nov. 2012", [:dateable]).should == { 'foo_dtsi' =>["2012-11-06T00:00:00Z"] }
+      @mapper.solr_names_and_values('foo', '', [:dateable]).should == { 'foo_dtsi' => [] }
     end
     
     it "should support displayable, facetable, sortable, unstemmed" do
-      @mapper.solr_names_and_values('foo', 'bar', :string, [:searchable, :displayable, :facetable, :sortable, :unstemmed_searchable]).should == {
-        'foo_t' => ['bar'],
-        'foo_display' => ['bar'],
-        'foo_facet' => ['bar'],
-        'foo_sort' => ['bar'],
-        'foo_unstem_search' => ['bar'],
+      @mapper.solr_names_and_values('foo', 'bar', [:searchable, :displayable, :facetable, :sortable, :unstemmed_searchable]).should == {
+        "foo_tesim" => ["bar"], #searchable
+        "foo_sim" => ["bar"], #facetable
+        "foo_ssm" => ["bar"], #displayable
+        "foo_ssi" => ["bar"], #sortable
+        "foo_tim" => ["bar"] #unstemmed_searchable
       }
     end
   end
-  
-  def silence
-    old_level = @mapper.logger.level
-    @mapper.logger.level = 100
-    begin
-      yield
-    ensure
-      @mapper.logger.level = old_level
-    end
-  end
 end

data/spec/units/xml_extractor_spec.rb

@@ -2,25 +2,24 @@ require 'spec_helper'
 
 describe Solrizer::XML::Extractor do
   
-  before(:all) do
+  before do
     @extractor = Solrizer::Extractor.new
   end
+
+  let(:result) { @extractor.xml_to_solr(fixture("druid-bv448hq0314-descMetadata.xml"))}
   
   describe ".xml_to_solr" do
     it "should turn simple xml into a solr document" do
-      desc_meta = fixture("druid-bv448hq0314-descMetadata.xml")
-
-      result = @extractor.xml_to_solr(desc_meta)
-      result[:type_t].should == "text"
-      result[:medium_t].should == "Paper Document"
-      result[:rights_t].should == "Presumed under copyright. Do not publish."
-      result[:date_t].should == "1985-12-30"
-      result[:format_t].should be_kind_of(Array)
-      result[:format_t].should include("application/tiff")
-      result[:format_t].should include("application/pdf")
-      result[:format_t].should include("application/jp2000")
-      result[:title_t].should == "This is a Sample Title"
-      result[:publisher_t].should == "Sample Unversity"
+      result[:type_tesim].should == "text"
+      result[:medium_tesim].should == "Paper Document"
+      result[:rights_tesim].should == "Presumed under copyright. Do not publish."
+      result[:date_tesim].should == "1985-12-30"
+      result[:format_tesim].should be_kind_of(Array)
+      result[:format_tesim].should include("application/tiff")
+      result[:format_tesim].should include("application/pdf")
+      result[:format_tesim].should include("application/jp2000")
+      result[:title_tesim].should == "This is a Sample Title"
+      result[:publisher_tesim].should == "Sample Unversity"
 
     end
   end

data/spec/units/xml_terminology_based_solrizer_spec.rb

@@ -26,7 +26,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
   
     it "should iterate through the terminology terms, calling .solrize_term on each and passing in the solr doc" do
       solr_doc = Hash.new
-      @mods_article.field_mapper = Solrizer::FieldMapper::Default.new
+      @mods_article.field_mapper = Solrizer::FieldMapper.new
       Samples::ModsArticle.terminology.terms.each_pair do |k,v|
         @mods_article.should_receive(:solrize_term).with(v, solr_doc, @mods_article.field_mapper)
       end
@@ -37,16 +37,16 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
 
       solr_doc =  @mods_article.to_solr
       solr_doc["abstract"].should be_nil
-      solr_doc["abstract_t"].should == ["ABSTRACT"]
-      solr_doc["title_info_1_language_t"].should == ["finnish"]
-      solr_doc["person_1_role_0_text_t"].should == ["teacher"]
+      solr_doc["abstract_tesim"].should == ["ABSTRACT"]
+      solr_doc["title_info_1_language_tesim"].should == ["finnish"]
+      solr_doc["person_1_role_0_text_tesim"].should == ["teacher"]
       # No index_as on the code field.
-      solr_doc["person_1_role_0_code_t"].should be_nil 
-      solr_doc["person_last_name_t"].sort.should == ["FAMILY NAME", "Gautama"]
-      solr_doc["topic_tag_t"].sort.should == ["CONTROLLED TERM", "TOPIC 1", "TOPIC 2"]
+      solr_doc["person_1_role_0_code_tesim"].should be_nil 
+      solr_doc["person_last_name_tesim"].sort.should == ["FAMILY NAME", "Gautama"]
+      solr_doc["topic_tag_tesim"].sort.should == ["CONTROLLED TERM", "TOPIC 1", "TOPIC 2"]
       
       # These are a holdover from an old verison of OM
-      solr_doc['journal_0_issue_0_publication_date_dt'].should == ["2007-02-01T00:00:00Z"]
+      solr_doc['journal_0_issue_0_publication_date_dtsi'].should == ["2007-02-01T00:00:00Z"]
 
       
     end
@@ -69,7 +69,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       @mods_article.solrize_term(term, fake_solr_doc)
       
       expected_names = ["DR.", "FAMILY NAME", "GIVEN NAMES"]
-      %w(_t _display _facet).each do |suffix|
+      %w(_tesim _sim).each do |suffix|
         actual_names = fake_solr_doc["name_0_namePart#{suffix}"].sort
         {suffix => actual_names}.should == {suffix => expected_names}
       end
@@ -79,14 +79,14 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       unless RUBY_VERSION.match("1.8.7")
         solr_doc = Hash.new
         result = @mods_article.solrize_term(Samples::ModsArticle.terminology.retrieve_term(:pub_date), solr_doc)
-        solr_doc["pub_date_dt"].should == ["2007-02-01T00:00:00Z"]
+        solr_doc["pub_date_dtsi"].should == ["2007-02-01T00:00:00Z"]
       end
     end
 
     it "should add fields based on type using ref" do
       solr_doc = Hash.new
       result = @mods_article.solrize_term(Samples::ModsArticle.terminology.retrieve_term(:issue_date), solr_doc)
-      solr_doc["issue_date_dt"].should == ["2007-02-15T00:00:00Z"]
+      solr_doc["issue_date_dtsi"].should == ["2007-02-15T00:00:00Z"]
     end
 
     it "shouldn't index terms where index_as is an empty array" do
@@ -95,7 +95,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       term.children[:namePart].index_as = []
 
       @mods_article.solrize_term(term, fake_solr_doc)
-      fake_solr_doc["name_0_namePart_t"].should be_nil
+      fake_solr_doc["name_0_namePart_tesim"].should be_nil
     end
 
     it "shouldn't index terms where index_as is searchable" do
@@ -105,16 +105,7 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
 
       @mods_article.solrize_term(term, fake_solr_doc)
       
-      fake_solr_doc["name_0_namePart_t"].sort.should == ["DR.", "FAMILY NAME", "GIVEN NAMES"]
+      fake_solr_doc["name_0_namePart_tesim"].sort.should == ["DR.", "FAMILY NAME", "GIVEN NAMES"]
     end
-    
-  end
-
-  describe ".solrize_node" do
-    it "should optionally allow you to provide the Hash to add fields to and return that document when done"
-    it "should create a solr field containing node.text"
-    it "should create hierarchical field entries if parents is not empty"
-    it "should only create one node if parents is empty"
   end
-
 end