sunspot 2.0.0 → 2.5.0

data/lib/sunspot/type.rb

@@ -375,6 +375,26 @@ module Sunspot
       end
     end
 
+    class DateRangeType < DateType
+      def indexed_name(name)
+        "#{name}_dr"
+      end
+
+      def to_indexed(value)
+        if value.respond_to?(:first) && value.respond_to?(:last)
+          "[#{super value.first} TO #{super value.last}]"
+        else
+          super value
+        end
+      end
+
+      def cast(value)
+        return super unless m = value.match(/^\[(?<start>.+) TO (?<end>.+)\]$/)
+        Range.new super(m[:start]), super(m[:end])
+      end
+    end
+    register DateRangeType, Range
+
     class ClassType < AbstractType
       def indexed_name(name) #:nodoc:
         'class_name'

data/lib/sunspot/util.rb

@@ -1,14 +1,14 @@
 module Sunspot
-  # 
+  #
   # The Sunspot::Util module provides utility methods used elsewhere in the
   # library.
   #
   module Util #:nodoc:
     class <<self
-      # 
+      #
       # Get all of the superclasses for a given class, including the class
       # itself.
-      # 
+      #
       # ==== Parameters
       #
       # clazz<Class>:: class for which to get superclasses
@@ -23,7 +23,7 @@ module Sunspot
         superclasses
       end
 
-      # 
+      #
       # Convert a string to snake case
       #
       # ==== Parameters
@@ -38,7 +38,7 @@ module Sunspot
         string.scan(/(^|[A-Z])([^A-Z]+)/).map! { |word| word.join.downcase }.join('_')
       end
 
-      # 
+      #
       # Convert a string to camel case
       #
       # ==== Parameters
@@ -53,7 +53,23 @@ module Sunspot
         string.split('_').map! { |word| word.capitalize }.join
       end
 
-      # 
+      #
+      # Convert snake case string to method case (Java style)
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to convert to method case
+      #
+      # ==== Returns
+      #
+      # String:: String in method case
+      #
+      def method_case(string)
+        first = true
+        string.split('_').map! { |word| word = first ? word : word.capitalize; first = false; word }.join
+      end
+
+      #
       # Get a constant from a fully qualified name
       #
       # ==== Parameters
@@ -70,13 +86,13 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # Evaluate the given proc in the context of the given object if the
       # block's arity is non-positive, or by passing the given object as an
       # argument if it is negative.
-      # 
+      #
       # ==== Parameters
-      # 
+      #
       # object<Object>:: Object to pass to the proc
       #
       def instance_eval_or_call(object, &block)
@@ -108,7 +124,7 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # When generating boosts, Solr requires that the values be in standard
       # (not scientific) notation. We would like to ensure a minimum number of
       # significant digits (i.e., digits that are not prefix zeros) for small
@@ -122,7 +138,7 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # Perform a deep merge of hashes, returning the result as a new hash.
       # See #deep_merge_into for rules used to merge the hashes
       #
@@ -139,7 +155,7 @@ module Sunspot
         deep_merge_into({}, left, right)
       end
 
-      # 
+      #
       # Perform a deep merge of the right hash into the left hash
       #
       # ==== Parameters
@@ -155,9 +171,49 @@ module Sunspot
         deep_merge_into(left, left, right)
       end
 
+      #
+      # Escapes characters for the Solr query parser
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to escape
+      #
+      # ==== Returns
+      #
+      # String:: escaped string
+      #
+      def escape(value)
+        # RSolr.solr_escape doesn't handle spaces or period chars,
+        # which do need to be escaped
+        RSolr.solr_escape(value).gsub(/([\s\.])/, '\\\\\1')
+      end
+
+      def parse_json_facet(field_name, options, setup)
+        field = setup.field(field_name)
+        if options[:time_range]
+          unless field.type.is_a?(Sunspot::Type::TimeType)
+            raise(
+              ArgumentError,
+              ':time_range can only be specified for Date or Time fields'
+            )
+          end
+          Sunspot::Query::DateFieldJsonFacet.new(field, options, setup)
+        elsif options[:range]
+          unless [Sunspot::Type::TimeType, Sunspot::Type::FloatType, Sunspot::Type::IntegerType ].find{|type| field.type.is_a?(type)}
+            raise(
+              ArgumentError,
+              ':range can only be specified for date or numeric fields'
+            )
+          end
+          Sunspot::Query::RangeJsonFacet.new(field, options, setup)
+        else
+          Sunspot::Query::FieldJsonFacet.new(field, options, setup)
+        end
+      end
+
       private
 
-      # 
+      #
       # Deep merge two hashes into a third hash, using rules that produce nice
       # merged parameter hashes. The rules are as follows, for a given key:
       #
@@ -224,7 +280,15 @@ module Sunspot
       end
 
       def id
-        @__calling_context__.__send__(:id)
+        begin
+          @__calling_context__.__send__(:id)
+        rescue ::NoMethodError => e
+          begin
+            @__receiver__.__send__(:id)
+          rescue ::NoMethodError
+            raise(e)
+          end
+        end
       end
 
       # Special case due to `Kernel#sub`'s existence

data/lib/sunspot/version.rb

@@ -1,3 +1,3 @@
 module Sunspot
-  VERSION = '2.0.0'
+  VERSION = '2.5.0'
 end

data/spec/api/adapters_spec.rb

@@ -2,33 +2,58 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe Sunspot::Adapters::InstanceAdapter do
   it "finds adapter by superclass" do
-    Sunspot::Adapters::InstanceAdapter::for(Model).should be(AbstractModelInstanceAdapter)
+    expect(Sunspot::Adapters::InstanceAdapter::for(Model)).to be(AbstractModelInstanceAdapter)
   end
 
   it "finds adapter by mixin" do
-    Sunspot::Adapters::InstanceAdapter::for(MixModel).should be(MixInModelInstanceAdapter)
+    expect(Sunspot::Adapters::InstanceAdapter::for(MixModel)).to be(MixInModelInstanceAdapter)
   end
 
   it 'throws NoAdapterError if anonymous module passed in' do
-    lambda do
+    expect do
       Sunspot::Adapters::InstanceAdapter::for(Module.new)
-    end.should raise_error(Sunspot::NoAdapterError)
+    end.to raise_error(Sunspot::NoAdapterError)
+  end
+
+  it "registers adapters found by ancestor lookup with the descendant class" do
+    expect(Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel)).to be(nil)
+    Sunspot::Adapters::InstanceAdapter::for(UnseenModel)
+    expect(Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel)).to be(AbstractModelInstanceAdapter)
+  end
+
+  it "appends ID prefix when configured" do
+    expect(AbstractModelInstanceAdapter.new(ModelWithPrefixId.new).index_id).to eq "USERDATA!ModelWithPrefixId 1"
+  end
+
+  it "supports nested ID prefixes" do
+    expect(AbstractModelInstanceAdapter.
+      new(ModelWithNestedPrefixId.new).index_id).to eq "USER!USERDATA!ModelWithNestedPrefixId 1"
+  end
+
+  it "doesn't appends ID prefix when not configured" do
+    expect(AbstractModelInstanceAdapter.new(ModelWithoutPrefixId.new).index_id).to eq "ModelWithoutPrefixId 1"
   end
 end
 
 describe Sunspot::Adapters::DataAccessor do
   it "finds adapter by superclass" do
-    Sunspot::Adapters::DataAccessor::for(Model).should be(AbstractModelDataAccessor)
+    expect(Sunspot::Adapters::DataAccessor::for(Model)).to be(AbstractModelDataAccessor)
   end
 
   it "finds adapter by mixin" do
-    Sunspot::Adapters::DataAccessor::for(MixModel).should be(MixInModelDataAccessor)
+    expect(Sunspot::Adapters::DataAccessor::for(MixModel)).to be(MixInModelDataAccessor)
   end
 
   it 'throws NoAdapterError if anonymous module passed in' do
-    lambda do
+    expect do
       Sunspot::Adapters::DataAccessor::for(Module.new)
-    end.should raise_error(Sunspot::NoAdapterError)
+    end.to raise_error(Sunspot::NoAdapterError)
+  end
+
+  it "registers adapters found by ancestor lookup with the descendant class" do
+    expect(Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel)).to be(nil)
+    Sunspot::Adapters::DataAccessor::for(UnseenModel)
+    expect(Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel)).to be(AbstractModelDataAccessor)
   end
 end
 
@@ -39,30 +64,30 @@ describe Sunspot::Adapters::Registry do
   let(:mixin_accessor){ Sunspot::Adapters::DataAccessor::for(MixModel) }
 
   it "registers and retrieves a data accessor for abstractclass" do
-      registry.retrieve(AbstractModel).should be_a(abstractclass_accessor)
+      expect(registry.retrieve(AbstractModel)).to be_a(abstractclass_accessor)
   end
 
   it "registers and retrieves a data accessor for superclass" do
-      registry.retrieve(Model).should be_a(superclass_accessor)
+      expect(registry.retrieve(Model)).to be_a(superclass_accessor)
   end
 
   it "registers and retrieves a data accessor for mixin" do
-      registry.retrieve(MixModel).should be_a(mixin_accessor)
+      expect(registry.retrieve(MixModel)).to be_a(mixin_accessor)
   end
 
   it "injects inherited attributes" do
-    AbstractModelDataAccessor.any_instance.stub(:inherited_attributes).and_return([:to_be_injected])
+    allow_any_instance_of(AbstractModelDataAccessor).to receive(:inherited_attributes).and_return([:to_be_injected])
     in_registry_data_accessor = registry.retrieve(AbstractModel)
     in_registry_data_accessor.to_be_injected = "value"
-    registry.retrieve(Model).to_be_injected.should == "value"
+    expect(registry.retrieve(Model).to_be_injected).to eq("value")
   end
 
   it "not overrides inherited attributes" do
-    AbstractModelDataAccessor.any_instance.stub(:inherited_attributes).and_return([:to_be_injected])
+    allow_any_instance_of(AbstractModelDataAccessor).to receive(:inherited_attributes).and_return([:to_be_injected])
     parent_data_accessor = registry.retrieve(AbstractModel)
     current_data_accessor = registry.retrieve(Model)
     parent_data_accessor.to_be_injected = "value"
     current_data_accessor.to_be_injected = "safe-value"
-    registry.retrieve(Model).to_be_injected.should == "safe-value"
+    expect(registry.retrieve(Model).to_be_injected).to eq("safe-value")
   end
 end

data/spec/api/batcher_spec.rb

@@ -2,12 +2,12 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe Sunspot::Batcher do
   it "includes Enumerable" do
-    described_class.should include Enumerable
+    expect(described_class).to include Enumerable
   end
 
   describe "#each" do
     let(:current) { [:foo, :bar] }
-    before { subject.stub(:current).and_return current }
+    before { allow(subject).to receive(:current).and_return current }
 
     it "iterates over current" do
       yielded_values = []
@@ -16,25 +16,25 @@ describe Sunspot::Batcher do
         yielded_values << value
       end
 
-      yielded_values.should eq current
+      expect(yielded_values).to eq current
     end
   end
 
   describe "adding to current batch" do
     it "#push pushes to current" do
       subject.push :foo
-      subject.current.should include :foo
+      expect(subject.current).to include :foo
     end
 
     it "#<< pushes to current" do
       subject.push :foo
-      subject.current.should include :foo
+      expect(subject.current).to include :foo
     end
 
     it "#concat concatinates on current batch" do
       subject << :foo
       subject.concat [:bar, :mix]
-      should include :foo, :bar, :mix
+      is_expected.to include :foo, :bar, :mix
     end
   end
 
@@ -46,7 +46,7 @@ describe Sunspot::Batcher do
       end
 
       it "is empty by default" do
-        subject.current.should be_empty
+        expect(subject.current).to be_empty
       end
     end
 
@@ -58,7 +58,7 @@ describe Sunspot::Batcher do
       end
 
       it "returns the same as last time" do
-        subject.current.should eq subject.current
+        expect(subject.current).to eq subject.current
       end
     end
   end
@@ -71,7 +71,7 @@ describe Sunspot::Batcher do
     it "changes current" do
       subject << :foo
       subject.start_new
-      should_not include :foo
+      is_expected.not_to include :foo
     end
   end
 
@@ -88,25 +88,25 @@ describe Sunspot::Batcher do
       it "changes current" do
         subject << :foo
         subject.end_current
-        should_not include :foo
+        is_expected.not_to include :foo
       end
 
       it "returns current" do
         subject << :foo
-        subject.end_current.should include :foo
+        expect(subject.end_current).to include :foo
       end
     end
   end
 
   describe "#batching?" do
     it "is false when depth is 0" do
-      subject.should_receive(:depth).and_return 0
-      should_not be_batching
+      expect(subject).to receive(:depth).and_return 0
+      is_expected.not_to be_batching
     end
 
     it "is true when depth is more than 0" do
-      subject.should_receive(:depth).and_return 1
-      should be_batching
+      expect(subject).to receive(:depth).and_return 1
+      is_expected.to be_batching
     end
   end
 end

data/spec/api/binding_spec.rb

@@ -6,7 +6,7 @@ describe "DSL bindings" do
     session.search(Post) do
       value = test_method
     end
-    value.should == 'value'
+    expect(value).to eq('value')
   end
 
   it 'should give access to calling context\'s id method in search DSL' do
@@ -14,7 +14,7 @@ describe "DSL bindings" do
     session.search(Post) do
       value = id
     end
-    value.should == 16
+    expect(value).to eq(16)
   end
 
   it 'should give access to calling context\'s methods in nested DSL block' do
@@ -24,7 +24,7 @@ describe "DSL bindings" do
         value = test_method
       end
     end
-    value.should == 'value'
+    expect(value).to eq('value')
   end
 
   it 'should give access to calling context\'s methods in double-nested DSL block' do

data/spec/api/class_set_spec.rb

@@ -2,23 +2,23 @@ require "spec_helper"
 
 describe Sunspot::ClassSet do
   it "is enumerable" do
-    class1, class2 = stub(:name => "Class1"), stub(:name => "Class2")
+    class1, class2 = double(:name => "Class1"), double(:name => "Class2")
 
     set = described_class.new
     set << class1 << class2
 
-    set.to_a.should =~ [class1, class2]
+    expect(set.to_a).to match_array([class1, class2])
   end
 
   it "replaces classes with the same name" do
     set = described_class.new
 
-    class1 = stub(:name => "Class1")
+    class1 = double(:name => "Class1")
     set << class1
-    set.to_a.should == [class1]
+    expect(set.to_a).to eq([class1])
 
-    class1_dup = stub(:name => "Class1")
+    class1_dup = double(:name => "Class1")
     set << class1_dup
-    set.to_a.should == [class1_dup]
+    expect(set.to_a).to eq([class1_dup])
   end
 end