solrizer 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d77a71925151847cbb586039e03296e1b0aa2c9
-  data.tar.gz: a2bbb1286b7b037dc5a83d81f84ec098edc60283
+  metadata.gz: fdbccd31fa681a9b641d09d28db5f2658cc19c4d
+  data.tar.gz: 8b3f8f8fd164e2d9720c5bbcad56b3948ef7ffad
 SHA512:
-  metadata.gz: 76ad75ea81fb427b72a0b214637427f44ecd54d5e4b80cc43f49ae4c13598816d3756144b4b1081f7c357169595d97d7c8ce4e1137533e54e99807c619f9d9d6
-  data.tar.gz: 9294cad6b4a5661321d4a0780652af3e31fbebfeabf6b3ebe5d62577d37aaf6cc685255edb50acc5fd8782f468bb05a0d8ba1e64bb40c346c6f10202e8103250
+  metadata.gz: c2e433d14eefcbdc9f5c04aefbfaaf3a533f7cb7a8dc896b2096e0c9e9d5dfa42b659af1f66d075c7801341db15adff967900c7c09bf381e1c927a826c4f1426
+  data.tar.gz: 26a18f117e4c1e75192b14c926d7485611c4c148a751488530c75a81d7e1ae2af16619a2337d5f55a0771cb91a83ccc02863cf86d7ec0b18acb5785597935d24

data/History.txt

@@ -1,3 +1,9 @@
+h2. 3.3.0
+  * 2014-07-17: Remove dependency on mediashelf-loggable [Justin Coyne]
+  * 2014-07-17: Fix rspec deprecations [Justin Coyne]
+  * 2014-06-04: Refactor format_node_value so we don't need to check responds_to? [Justin Coyne]
+
+[Justin Coyne]
 h2. 3.2.0
   #25 Allow any field_value except nil to be inserted into a solr field
   #24 Remove dependency on solrizer-fedora, use AF to update index by pid

data/lib/solrizer.rb

@@ -1,4 +1,6 @@
 require 'active_support'
+require 'active_support/core_ext/module/attribute_accessors'
+
 module Solrizer
   extend ActiveSupport::Autoload
 
@@ -12,51 +14,55 @@ module Solrizer
   autoload :VERSION, 'solrizer/version'
   autoload :XML, 'solrizer/xml'
 
-  def self.version
-    Solrizer::VERSION
-  end
+  mattr_accessor :logger, instance_writer: false
 
-  def self.default_field_mapper
-    @@default_field_mapper ||= Solrizer::FieldMapper.new
-  end
+  class << self
+    def version
+      Solrizer::VERSION
+    end
 
-  def self.default_field_mapper=(field_mapper)
-    @@default_field_mapper = field_mapper
-  end
+    def default_field_mapper
+      @@default_field_mapper ||= Solrizer::FieldMapper.new
+    end
 
+    def default_field_mapper=(field_mapper)
+      @@default_field_mapper = field_mapper
+    end
 
-  def self.solr_name(*args)
-    default_field_mapper.solr_name(*args)
-  end
 
-  # @params [Hash] doc the hash to insert the value into
-  # @params [String] name the name of the field (without the suffix)
-  # @params [String,Date,Array] value the value (or array of values) to be inserted
-  # @params [Array,Hash] indexer_args the arguments that find the indexer
-  # @returns [Hash] doc the document that was provided with the new field inserted
-  def self.insert_field(doc, name, value, *indexer_args)
-    # adding defaults indexer 
-    indexer_args = [:stored_searchable] if indexer_args.empty?
-    default_field_mapper.solr_names_and_values(name, value, indexer_args).each do |k, v|
-      doc[k] ||= []
-      if v.is_a? Array
-        doc[k] += v
-      else
-        doc[k] = v
+    def solr_name(*args)
+      default_field_mapper.solr_name(*args)
+    end
+
+    # @params [Hash] doc the hash to insert the value into
+    # @params [String] name the name of the field (without the suffix)
+    # @params [String,Date,Array] value the value (or array of values) to be inserted
+    # @params [Array,Hash] indexer_args the arguments that find the indexer
+    # @returns [Hash] doc the document that was provided with the new field inserted
+    def insert_field(doc, name, value, *indexer_args)
+      # adding defaults indexer
+      indexer_args = [:stored_searchable] if indexer_args.empty?
+      default_field_mapper.solr_names_and_values(name, value, indexer_args).each do |k, v|
+        doc[k] ||= []
+        if v.is_a? Array
+          doc[k] += v
+        else
+          doc[k] = v
+        end
       end
+      doc
     end
-    doc
-  end
 
-  # @params [Hash] doc the hash to insert the value into
-  # @params [String] name the name of the field (without the suffix)
-  # @params [String,Date] value the value to be inserted
-  # @params [Array,Hash] indexer_args the arguments that find the indexer
-  # @returns [Hash] doc the document that was provided with the new field (replacing any field with the same name) 
-  def self.set_field(doc, name, value, *indexer_args)
-    # adding defaults indexer 
-    indexer_args = [:stored_searchable] if indexer_args.empty?
-    doc.merge! default_field_mapper.solr_names_and_values(name, value, indexer_args)
-    doc
+    # @params [Hash] doc the hash to insert the value into
+    # @params [String] name the name of the field (without the suffix)
+    # @params [String,Date] value the value to be inserted
+    # @params [Array,Hash] indexer_args the arguments that find the indexer
+    # @returns [Hash] doc the document that was provided with the new field (replacing any field with the same name) 
+    def set_field(doc, name, value, *indexer_args)
+      # adding defaults indexer
+      indexer_args = [:stored_searchable] if indexer_args.empty?
+      doc.merge! default_field_mapper.solr_names_and_values(name, value, indexer_args)
+      doc
+    end
   end
 end

data/lib/solrizer/extractor.rb

@@ -9,34 +9,35 @@ module Solrizer
 #
 class Extractor
   
-  # Insert +field_value+ for +field_name+ into +solr_doc+
-  # Handles inserting new values into a Hash while ensuring that you don't destroy or overwrite any existing values in the hash.
-  # Ensures that field values are always appended to arrays within the values hash. 
-  # Also ensures that values are run through format_node_value
-  # @param [Hash] solr_doc
-  # @param [String] field_name
-  # @param [String] field_value
-  def self.insert_solr_field_value(solr_doc, field_name, field_value)
-    formatted_value = self.format_node_value(field_value)
-    if solr_doc[field_name]
-      solr_doc[field_name] = Array(solr_doc[field_name]) << formatted_value
-    else
-      solr_doc[field_name] = formatted_value
+  class << self
+    # Insert +field_value+ for +field_name+ into +solr_doc+
+    # Handles inserting new values into a Hash while ensuring that you don't destroy or overwrite any existing values in the hash.
+    # Ensures that field values are always appended to arrays within the values hash.
+    # Also ensures that values are run through format_node_value
+    # @param [Hash] solr_doc
+    # @param [String] field_name
+    # @param [String] field_value
+    def insert_solr_field_value(solr_doc, field_name, field_value)
+      formatted_value = format_node_value(field_value)
+      if solr_doc[field_name]
+        solr_doc[field_name] = Array(solr_doc[field_name]) << formatted_value
+      else
+        solr_doc[field_name] = formatted_value
+      end
+      return solr_doc
     end
-    return solr_doc
-  end
-  
-  # Strips the majority of whitespace from the values array and then joins them with a single blank delimitter
-  # Returns an empty string if values argument is nil
-  #
-  # @param [Array] values Array of strings representing the values to be formatted
-  # @return [String] 
-  def self.format_node_value values
-    if values.nil?
-      return ""
-    else
-      values = [values] unless values.respond_to? :map
-      return values.map{|val| val.gsub(/\s+/,' ').strip}.join(" ")
+
+    # Strips the majority of whitespace from the values array and then joins them with a single blank delimitter
+    # Returns an empty string if values argument is nil
+    #
+    # @param [Array] values Array of strings representing the values to be formatted
+    # @return [String]
+    def format_node_value values
+      if values.nil?
+        ""
+      else
+        Array(values).map{|val| val.gsub(/\s+/,' ').strip}.join(" ")
+      end
     end
   end
   

data/lib/solrizer/field_mapper.rb

@@ -1,4 +1,3 @@
-require "loggable"
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/string/inflections'
 module Solrizer
@@ -100,8 +99,6 @@ module Solrizer
   
   class FieldMapper
 
-    include Loggable
-    
     # ------ Instance methods ------
     
     attr_reader :id_field, :default_index_types
@@ -228,7 +225,7 @@ module Solrizer
             values = (results[name] ||= [])
             values << value unless value.nil? || values.include?(value)
           else
-            logger.warn "Setting #{name} to `#{value}', but it already had `#{results[name]}'" if results[name]
+            Solrizer.logger.warn "Setting #{name} to `#{value}', but it already had `#{results[name]}'" if results[name] && Solrizer.logger
             results[name] = value
           end
         end

data/lib/solrizer/version.rb

@@ -1,3 +1,3 @@
 module Solrizer
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

data/solrizer.gemspec

@@ -14,7 +14,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency "nokogiri"
   s.add_dependency "xml-simple"
-  s.add_dependency "mediashelf-loggable", "~>0.4.7"
   s.add_dependency "stomp"
   s.add_dependency "daemons"
   s.add_dependency "activesupport"

data/spec/units/common_spec.rb

@@ -10,33 +10,30 @@ describe Solrizer::Common do
      Object.send(:remove_const, :Foo)
   end
 
+  let(:solr_doc) { {} }
+
   it "should handle many field types" do
-    solr_doc = {}
     Foo.create_and_insert_terms('my_name', 'value', [:displayable, :searchable, :sortable], solr_doc)
-    solr_doc.should == {'my_name_ssm' => ['value'], 'my_name_si' => 'value', 'my_name_teim' => ['value']}
+    expect(solr_doc).to eq('my_name_ssm' => ['value'], 'my_name_si' => 'value', 'my_name_teim' => ['value'])
   end
 
   it "should handle dates that are searchable" do
-    solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:stored_searchable], solr_doc)
-    solr_doc.should == {'my_name_dtsim' => ['2013-01-10T00:00:00Z']}
+    expect(solr_doc).to eq('my_name_dtsim' => ['2013-01-10T00:00:00Z'])
   end
 
   it "should handle dates that are stored_sortable" do
-    solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:stored_sortable], solr_doc)
-    solr_doc.should == {'my_name_dtsi' => '2013-01-10T00:00:00Z'}
+    expect(solr_doc).to eq('my_name_dtsi' => '2013-01-10T00:00:00Z')
   end
 
   it "should handle dates that are displayable" do
-    solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:displayable], solr_doc)
-    solr_doc.should == {'my_name_ssm' => ['2013-01-10']}
+    expect(solr_doc).to eq('my_name_ssm' => ['2013-01-10'])
   end
 
   it "should handle dates that are sortable" do
-    solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:sortable], solr_doc)
-    solr_doc.should == {'my_name_dti' => '2013-01-10T00:00:00Z'}
+    expect(solr_doc).to eq('my_name_dti' => '2013-01-10T00:00:00Z')
   end
 end

data/spec/units/extractor_spec.rb

@@ -8,15 +8,15 @@ describe Solrizer::Extractor do
   
   describe ".format_node_value" do
     it "should strip white space out of the array and join it with a single blank" do
-      Solrizer::Extractor.format_node_value([" test    \n   node    \t value \t"]).should == "test node value"
-      Solrizer::Extractor.format_node_value([" test ", "     \n   node ", "   \t value \t"]).should == "test node value"
+      expect(Solrizer::Extractor.format_node_value([" test    \n   node    \t value \t"])).to eq "test node value"
+      expect(Solrizer::Extractor.format_node_value([" test ", "     \n   node ", "   \t value \t"])).to eq "test node value"
     end
     it "should return an empty string if given an argument of nil" do
-      Solrizer::Extractor.format_node_value(nil).should == ""
+      expect(Solrizer::Extractor.format_node_value(nil)).to eq '' 
     end
 
     it "should strip white space out of a string" do
-      Solrizer::Extractor.format_node_value("raw  string\n with whitespace").should == "raw string with whitespace"
+      expect(Solrizer::Extractor.format_node_value("raw  string\n with whitespace")).to eq "raw string with whitespace"
     end
   end
 
@@ -24,19 +24,19 @@ describe Solrizer::Extractor do
     it "should initialize a solr doc list if it is nil" do
        solr_doc = {'title_tesim' => nil }
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Frank')
-       solr_doc.should == {"title_tesim"=>"Frank"}
+       expect(solr_doc).to eq("title_tesim"=>"Frank")
     end
     it "should insert multiple" do
        solr_doc = {'title_tesim' => nil }
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Frank')
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Margret')
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Joyce')
-       solr_doc.should == {"title_tesim"=>["Frank", 'Margret', 'Joyce']}
+       expect(solr_doc).to eq("title_tesim"=>["Frank", 'Margret', 'Joyce'])
     end
     it "should not make a list if a single valued field is passed in" do
        solr_doc = {}
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_dtsi', '2013-03-22T12:33:00Z')
-       solr_doc.should == {"title_dtsi"=>"2013-03-22T12:33:00Z"}
+       expect(solr_doc).to eq("title_dtsi"=>"2013-03-22T12:33:00Z")
     end
 
   end

data/spec/units/field_mapper_spec.rb

@@ -148,100 +148,100 @@ describe Solrizer::FieldMapper do
   # --- Tests ----
   
   it "should handle the id field" do
-    @mapper.id_field.should == 'ident'
+    expect(@mapper.id_field).to eq '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(Time.now).should == :time
-      @mapper.extract_type(DateTime.now).should == :time
-      @mapper.extract_type("Hi").should == :string
+      expect(@mapper.extract_type(7)).to eq :integer
+      expect(@mapper.extract_type(nil)).to eq nil
+      expect(@mapper.extract_type(Date.today)).to eq :date
+      expect(@mapper.extract_type(Time.now)).to eq :time
+      expect(@mapper.extract_type(DateTime.now)).to eq :time
+      expect(@mapper.extract_type("Hi")).to eq :string
     end
   end
   
   describe '.solr_name' do
     it "should map based on passed descriptors" do
-      @mapper.solr_name('bar', :edible).should == 'bar_food'
-      @mapper.solr_name('bar', :laughable, type: :string).should == 'bar_haha'
+      expect(@mapper.solr_name('bar', :edible)).to eq 'bar_food'
+      expect(@mapper.solr_name('bar', :laughable, type: :string)).to eq 'bar_haha'
     end
 
     it "should default the index_type to :stored_searchable" do
-      @mapper.solr_name('foo').should == 'foo_s'
+      expect(@mapper.solr_name('foo')).to eq 'foo_s'
     end
 
     it "should allow you to pass a string as the suffix" do
-      @mapper.solr_name('bar', 'quack').should == 'bar_quack'
+      expect(@mapper.solr_name('bar', 'quack')).to eq 'bar_quack'
     end
 
     it "should map based on data type" do
-      @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
+      expect(@mapper.solr_name('foo', :fungible, type: :integer)).to eq 'foo_f1'
+      expect(@mapper.solr_name('foo', :fungible, type: :garble)).to eq 'foo_f2'  # based on type.default
+      expect(@mapper.solr_name('foo', :fungible, type: :date)).to eq 'foo_f0'  # type.date falls through to container
     end
   
     it "should return nil for an unknown index types" do
-      lambda { 
+      expect { 
         @mapper.solr_name('foo', :blargle)
-      }.should raise_error(Solrizer::UnknownIndexMacro, "Unable to find `blargle' in [TestMapper0::Descriptors0, Solrizer::DefaultDescriptors]")
+      }.to 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', 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
+      expect(@mapper.solr_name('foo', type: :date)).to eq 'foo_s'
+      expect(@mapper.solr_name('foo', type: :string)).to eq 'foo_s'
+      expect(@mapper.solr_name('foo', :fungible, type: :integer)).to eq 'foo_f5'  # override on data type
+      expect(@mapper.solr_name('foo', :fungible, type: :garble)).to eq 'foo_f4'  # override on data type
+      expect(@mapper.solr_name('foo', :fungible, type: :fratz)).to eq 'foo_f2'  # from super
+      expect(@mapper.solr_name('foo', :fungible, type: :date)).to eq 'foo_f0'  # super definition picks up override on index type
     end
     
     
     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
+      expect { mapper.solr_name(:heifer, nil, :searchable) }.to raise_error Solrizer::InvalidIndexDescriptor
     end
   end
   
   describe '.solr_names_and_values' do
     it "should map values based on passed descriptors" do
-      @mapper.solr_names_and_values('foo', 'bar', [:stored_searchable, :laughable, :edible]).should == {
+      expect(@mapper.solr_names_and_values('foo', 'bar', [:stored_searchable, :laughable, :edible])).to eq(
         'foo_s'    => ['bar'],
         'foo_food' => ['bar'],
         'foo_haha' => ["Knock knock. Who's there? Bar. Bar who?"]
-      }
+      )
     end
     
     it "should apply mappings based on data type" do
-      @mapper.solr_names_and_values('foo', 7, [:stored_searchable, :laughable]).should == {
+      expect(@mapper.solr_names_and_values('foo', 7, [:stored_searchable, :laughable])).to eq(
         'foo_s'     => ['7'],
         'foo_ihaha' => ["How many foos does it take to screw in a light bulb? 7."]
-      }
+      )
     end
     
     it "should raise error on unknown index types" do
-      lambda { 
+      expect { 
         @mapper.solr_names_and_values('foo', 'bar', [:blargle])
-      }.should raise_error(Solrizer::UnknownIndexMacro, "Unable to find `blargle' in [TestMapper0::Descriptors0, Solrizer::DefaultDescriptors]")
+      }.to 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', [:unstemmed_searchable, :stored_searchable]).should == {
+      expect(@mapper.solr_names_and_values('roll', 'rock', [:unstemmed_searchable, :stored_searchable])).to eq(
         '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', [:another_stored_searchable, :stored_searchable]).should == {
+      expect(@mapper.solr_names_and_values('roll', 'rock', [:another_stored_searchable, :stored_searchable])).to eq(
         'roll_s' => ['rock'],
-      }
+      )
     end
 
     it "should return an empty hash when value is nil" do
-      @mapper.solr_names_and_values('roll', nil, [:another_stored_searchable, :stored_searchable]).should == { }
+      expect(@mapper.solr_names_and_values('roll', nil, [:another_stored_searchable, :stored_searchable])).to eq({ })
     end
   end
 
@@ -251,33 +251,33 @@ describe Solrizer::FieldMapper do
     end
   	
     it "should call the id field 'id'" do
-      @mapper.id_field.should == 'id'
+      expect(@mapper.id_field).to eq 'id'
     end
 
     it "should default the index_type to :stored_searchable" do
-      @mapper.solr_name('foo', :type=>:string).should == 'foo_tesim'
+      expect(@mapper.solr_name('foo', :type=>:string)).to eq 'foo_tesim'
     end
     
     it "should support field names as symbols" do
-      @mapper.solr_name(:active_fedora_model, :symbol).should == "active_fedora_model_ssim"
+      expect(@mapper.solr_name(:active_fedora_model, :symbol)).to eq "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', []).should == {  }
-      @mapper.solr_names_and_values('foo', "1",[]).should == { }
+      expect(@mapper.solr_names_and_values('foo', 'bar', [])).to eq({  })
+      expect(@mapper.solr_names_and_values('foo', "1",[])).to eq({ })
     end
 
     it "should support full ISO 8601 dates" do
-      @mapper.solr_names_and_values('foo', "2012-11-06",  [:dateable]).should == { 'foo_dtsim' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', "November 6th, 2012",  [:dateable]).should == { 'foo_dtsim' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', "6 Nov. 2012", [:dateable]).should == { 'foo_dtsim' =>["2012-11-06T00:00:00Z"] }
-      @mapper.solr_names_and_values('foo', '', [:dateable]).should == { 'foo_dtsim' => [] }
+      expect(@mapper.solr_names_and_values('foo', "2012-11-06",  [:dateable])).to eq('foo_dtsim' =>["2012-11-06T00:00:00Z"])
+      expect(@mapper.solr_names_and_values('foo', "November 6th, 2012",  [:dateable])).to eq('foo_dtsim' =>["2012-11-06T00:00:00Z"])
+      expect(@mapper.solr_names_and_values('foo', "6 Nov. 2012", [:dateable])).to eq('foo_dtsim' =>["2012-11-06T00:00:00Z"])
+      expect(@mapper.solr_names_and_values('foo', '', [:dateable])).to eq('foo_dtsim' => [])
     end
 
     it "should support searchable, stored_searchable, displayable, facetable, sortable, stored_sortable, unstemmed" do
       descriptors = [:searchable, :stored_searchable, :displayable, :facetable, :sortable, :stored_sortable, :unstemmed_searchable]
-      @mapper.solr_names_and_values('foo', 'bar', descriptors).should == {
+      expect(@mapper.solr_names_and_values('foo', 'bar', descriptors)).to eq(
         "foo_teim" => ["bar"], #searchable
         "foo_tesim" => ["bar"], #stored_searchable
         "foo_ssm" => ["bar"], #displayable
@@ -285,13 +285,13 @@ describe Solrizer::FieldMapper do
         "foo_si" => "bar", #sortable
         "foo_ssi" => "bar", #stored_sortable
         "foo_tim" => ["bar"] #unstemmed_searchable
-      }
+      )
     end
 
     it "should support stored_sortable" do
       time = Time.iso8601("2012-11-06T15:16:17Z")
-      @mapper.solr_names_and_values('foo', time, :stored_sortable).should == {"foo_dtsi" => "2012-11-06T15:16:17Z"} 
-      @mapper.solr_names_and_values('foo', 'bar', :stored_sortable).should == {"foo_ssi" => "bar"} 
+      expect(@mapper.solr_names_and_values('foo', time, :stored_sortable)).to eq("foo_dtsi" => "2012-11-06T15:16:17Z")
+      expect(@mapper.solr_names_and_values('foo', 'bar', :stored_sortable)).to eq("foo_ssi" => "bar")
     end
   end
 end

data/spec/units/solrizer_spec.rb

@@ -7,68 +7,68 @@ describe Solrizer do
       let(:doc) { Hash.new }
       it "should insert a field with the default (stored_searchable) indexer" do
         Solrizer.insert_field(doc, 'foo', 'A name')
-        doc.should == {'foo_tesim' => ['A name']}
+        expect(doc).to eq('foo_tesim' => ['A name'])
       end
       it "should not create an array of fields that are not multivalued" do
         Solrizer.insert_field(doc, 'foo', 'A name', :sortable)
-        doc.should == {'foo_si' => 'A name'}
+        expect(doc).to eq('foo_si' => 'A name')
       end
       it "should insert a field with multiple indexers" do
         Solrizer.insert_field(doc, 'foo', 'A name', :sortable, :facetable)
-        doc.should == {'foo_si' => 'A name', 'foo_sim' => ['A name']}
+        expect(doc).to eq('foo_si' => 'A name', 'foo_sim' => ['A name'])
       end
       it "should insert Dates" do
         Solrizer.insert_field(doc, 'foo', Date.parse('2013-01-13'))
-        doc.should == {'foo_dtsim' => ["2013-01-13T00:00:00Z"]}
+        expect(doc).to eq('foo_dtsim' => ["2013-01-13T00:00:00Z"])
       end
       it "should insert Times" do
         Solrizer.insert_field(doc, 'foo', Time.parse('2013-01-13T22:45:56+06:00'))
-        doc.should == {'foo_dtsim' => ["2013-01-13T16:45:56Z"]}
+        expect(doc).to eq('foo_dtsim' => ["2013-01-13T16:45:56Z"])
       end
       it "should insert true Booleans" do
         Solrizer.insert_field(doc, 'foo', true)
-        doc.should == {'foo_bsi' => true}
+        expect(doc).to eq('foo_bsi' => true)
       end
       it "should insert false Booleans" do
         Solrizer.insert_field(doc, 'foo', false)
-        doc.should == {'foo_bsi' => false}
+        expect(doc).to eq('foo_bsi' => false)
       end
 
       it "should insert multiple values" do
         Solrizer.insert_field(doc, 'foo', ['A name', 'B name'], :sortable, :facetable)
-        doc.should == {'foo_si' => 'B name', 'foo_sim' => ['A name', 'B name']}
+        expect(doc).to eq('foo_si' => 'B name', 'foo_sim' => ['A name', 'B name'])
       end
 
       it 'should insert nothing when passed a nil value' do
         Solrizer.insert_field(doc, 'foo', nil, :sortable, :facetable)
-        doc.should == {}
+        expect(doc).to eq( { } )
       end
     end
 
     describe "on a document with values" do
-      before{ @doc = {'foo_si' => 'A name', 'foo_sim' => ['A name']}}
+      let(:doc) { {'foo_si' => 'A name', 'foo_sim' => ['A name']} }
 
       it "should not overwrite muli-values that exist before" do
-        Solrizer.insert_field(@doc, 'foo', 'B name', :sortable, :facetable)
-        @doc.should == {'foo_si' => 'B name', 'foo_sim' => ['A name', 'B name']}
+        Solrizer.insert_field(doc, 'foo', 'B name', :sortable, :facetable)
+        expect(doc).to eq('foo_si' => 'B name', 'foo_sim' => ['A name', 'B name'])
       end
     end
   end
   describe ".set_field" do
     describe "on a document with values" do
-      before{ @doc = {'foo_si' => ['A name'], 'foo_sim' => ['A name']}}
+      let(:doc) { {'foo_si' => ['A name'], 'foo_sim' => ['A name']} }
 
       it "should overwrite values that exist before" do
-        Solrizer.set_field(@doc, 'foo', 'B name', :sortable, :facetable)
-        @doc.should == {'foo_si' => 'B name', 'foo_sim' => ['B name']}
+        Solrizer.set_field(doc, 'foo', 'B name', :sortable, :facetable)
+        expect(doc).to eq('foo_si' => 'B name', 'foo_sim' => ['B name'])
       end
     end
   end
 
   describe ".solr_name" do
     it "should delegate to default_field_mapper" do
-        Solrizer.solr_name('foo', type: :string).should == "foo_tesim"
-        Solrizer.solr_name('foo', :sortable).should == "foo_si"
+        expect(Solrizer.solr_name('foo', type: :string)).to eq "foo_tesim"
+        expect(Solrizer.solr_name('foo', :sortable)).to eq "foo_si"
     end
   end
 end

data/spec/units/xml_extractor_spec.rb

@@ -10,16 +10,16 @@ describe Solrizer::XML::Extractor do
   
   describe ".xml_to_solr" do
     it "should turn simple xml into a solr document" do
-      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"
+      expect(result[:type_tesim]).to eq "text"
+      expect(result[:medium_tesim]).to eq "Paper Document"
+      expect(result[:rights_tesim]).to eq "Presumed under copyright. Do not publish."
+      expect(result[:date_tesim]).to eq "1985-12-30"
+      expect(result[:format_tesim]).to be_kind_of(Array)
+      expect(result[:format_tesim]).to include("application/tiff")
+      expect(result[:format_tesim]).to include("application/pdf")
+      expect(result[:format_tesim]).to include("application/jp2000")
+      expect(result[:title_tesim]).to eq "This is a Sample Title"
+      expect(result[:publisher_tesim]).to eq "Sample Unversity"
     end
   end
   

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solrizer
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Matt Zumwalt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mediashelf-loggable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.7
 - !ruby/object:Gem::Dependency
   name: stomp
   requirement: !ruby/object:Gem::Requirement