outoftime-sunspot 0.7.3 → 0.8.0

data/lib/sunspot/type.rb

@@ -98,19 +98,27 @@ module Sunspot
     # UTC before indexing, and facets of Time fields always return times in UTC.
     #
     module TimeType
+
       class <<self
-        def indexed_name(name)
+        def indexed_name(name) #:nodoc:
         "#{name}_d"
         end
 
-        def to_indexed(value)
+        def to_indexed(value) #:nodoc:
           if value
-            time = value.respond_to?(:to_time) ? value.to_time : Time.parse(value.to_s)
+            time =
+              if value.respond_to?(:utc)
+                value
+              elsif %w(year mon mday).each { |method| value.respond_to?(method) }
+                Time.gm(value.year, value.mon, value.mday)
+              else
+                Time.parse(value.to_s)
+              end
             time.utc.xmlschema
           end
         end
 
-        def cast(string)
+        def cast(string) #:nodoc:
           Time.xmlschema(string)
         end
       end
@@ -122,17 +130,17 @@ module Sunspot
     #
     module BooleanType
       class <<self
-        def indexed_name(name)
+        def indexed_name(name) #:nodoc:
         "#{name}_b"
         end
 
-        def to_indexed(value)
+        def to_indexed(value) #:nodoc:
           unless value.nil?
             value ? 'true' : 'false'
           end
         end
 
-        def cast(string)
+        def cast(string) #:nodoc:
           case string
           when 'true'
             true

data/lib/sunspot/util.rb

@@ -70,6 +70,23 @@ 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)
+        if block.arity > 0
+          block.call(object)
+        else
+          object.instance_eval(&block)
+        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

data/lib/sunspot.rb

@@ -2,7 +2,8 @@ gem 'solr-ruby'
 require 'solr'
 require File.join(File.dirname(__FILE__), 'light_config')
 
-%w(adapters restriction configuration setup field facets indexer query search facet facet_row session type util dsl).each do |filename|
+%w(adapters configuration setup field data_extractor indexer
+   query search facet facet_row session type util dsl).each do |filename|
   require File.join(File.dirname(__FILE__), 'sunspot', filename)
 end
 
@@ -93,6 +94,41 @@ module Sunspot
     # internally, the fields will have different names so there is no danger
     # of conflict.
     # 
+    # ===== Dynamic Fields
+    # 
+    # For use cases which have highly dynamic data models (for instance, an
+    # open set of key-value pairs attached to a model), it may be useful to
+    # defer definition of fields until indexing time. Sunspot exposes dynamic
+    # fields, which define a data accessor (either attribute or virtual, see
+    # above), which accepts a hash of field names to values. Note that the field
+    # names in the hash are internally scoped to the base name of the dynamic
+    # field, so any time they are referred to, they are referred to using both
+    # the base name and the dynamic (runtime-specified) name.
+    #
+    # Dynamic fields are speficied in the setup block using the type name
+    # prefixed by +dynamic_+. For example:
+    # 
+    #   Sunspot.setup(Post) do
+    #     dynamic_string :custom_values do
+    #       key_value_pairs.inject({}) do |hash, key_value_pair|
+    #         hash[key_value_pair.key.to_sym] = key_value_pair.value
+    #       end
+    #     end
+    #   end
+    # 
+    # If you later wanted to facet all of the values for the key "cuisine",
+    # you could issue:
+    # 
+    #   Sunspot.search(Post) do
+    #     dynamic :custom_values do
+    #       facet :cuisine
+    #     end
+    #   end
+    # 
+    # In the documentation, +:custom_values+ is referred to as the "base name" -
+    # that is, the one specified statically - and +:cuisine+ is referred to as
+    # the dynamic name, which is the part that is specified at indexing time.
+    # 
     def setup(clazz, &block)
       Setup.setup(clazz, &block)
     end
@@ -146,6 +182,29 @@ module Sunspot
       session.commit
     end
 
+    # 
+    # Create a new Search instance, but do not execute it immediately. Generally
+    # you will want to use the #search method to execute searches using the
+    # DSL; however, if you are building searches dynamically (using the Builder
+    # pattern, for instance), it may be easier to access the Query API directly.
+    # 
+    # ==== Parameters
+    #
+    # types<Class>...::
+    #   Zero, one, or more types to search for. If no types are passed, all
+    #   configured types will be searched for.
+    #
+    # ==== Returns
+    #
+    # Sunspot::Search::
+    #   Search object, not yet executed. Query parameters can be added manually;
+    #   then #execute! should be called.
+    # 
+    def new_search(*types)
+      session.new_search(*types)
+    end
+
+
     # Search for objects in the index.
     #
     # ==== Parameters
@@ -154,6 +213,18 @@ module Sunspot
     #   Zero, one, or more types to search for. If no types are passed, all
     #   configured types will be searched.
     #
+    # ==== Options (last argument, optional)
+    #
+    # :keywords<String>:: Fulltext search string
+    # :conditions<Hash>::
+    #   Hash of key-value pairs to be used as restrictions. Keys are field
+    #   names. Scalar values are used as equality restrictions; arrays are used
+    #   as "any of" restrictions; and Ranges are used as range restrictions.
+    # :order<String>:: order field and direction (e.g., 'updated_at desc')
+    # :page<Integer>:: Page to start on for pagination
+    # :per_page<Integer>::
+    #   Number of results to use per page. Ignored if :page is not specified.
+    #
     # ==== Returns
     #
     # Sunspot::Search:: Object containing results, facets, count, etc.
@@ -201,8 +272,18 @@ module Sunspot
     #     order_by :published_at, :desc
     #     paginate 2, 15
     #   end
+    #  
+    # If the block passed to #search takes an argument, that argument will
+    # present the DSL, and the block will be evaluated in the calling context.
+    # This will come in handy for building searches using instance data or
+    # methods, e.g.:
+    #
+    #   Sunspot.search(Post) do |query|
+    #     query.with(:blog_id, @current_blog.id)
+    #   end
     #
-    # See Sunspot::DSL::Query for the full API presented inside the block.
+    # See Sunspot::DSL::Scope and Sunspot::DSL::Query for the full API presented
+    # inside the block.
     #
     def search(*types, &block)
       session.search(*types, &block)

data/spec/api/build_search_spec.rb

@@ -157,6 +157,79 @@ describe 'Search' do
     end
   end
 
+  it 'should restrict by dynamic string field with equality restriction' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['custom_string\:test_s:string']))
+    session.search Post do
+      dynamic :custom_string do
+        with :test, 'string'
+      end
+    end
+  end
+
+  it 'should restrict by dynamic integer field with less than restriction' do
+    connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_integer\:test_i:[* TO 1]']))
+    session.search Post do
+      dynamic :custom_integer do
+        with(:test).less_than(1)
+      end
+    end
+  end
+
+  it 'should restrict by dynamic float field with between restriction' do
+    connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_float\:test_fm:[2\.2 TO 3\.3]']))
+    session.search Post do
+      dynamic :custom_float do
+        with(:test).between(2.2..3.3)
+      end
+    end
+  end
+
+  it 'should restrict by dynamic time field with any of restriction' do
+    connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_time\:test_d:(2009\-02\-10T14\:00\:00Z OR 2009\-02\-13T18\:00\:00Z)']))
+    session.search Post do
+      dynamic :custom_time do
+        with(:test).any_of([Time.parse('2009-02-10 14:00:00 UTC'),
+                            Time.parse('2009-02-13 18:00:00 UTC')])
+      end
+    end
+  end
+
+  it 'should restrict by dynamic boolean field with equality restriction' do
+    connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_boolean\:test_b:false']))
+    session.search Post do
+      dynamic :custom_boolean do
+        with :test, false
+      end
+    end
+  end
+
+  it 'should negate a dynamic field restriction' do
+    connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['-custom_string\:test_s:foo']))
+    session.search Post do
+      dynamic :custom_string do
+        without :test, 'foo'
+      end
+    end
+  end
+
+  it 'should throw an UnrecognizedFieldError if an unknown dynamic field is searched by' do
+    lambda do
+      session.search Post do
+        dynamic(:bogus) { with :some, 'value' }
+      end
+    end.should raise_error(Sunspot::UnrecognizedFieldError)
+  end
+
+  it 'should throw a NoMethodError if pagination is attempted in a dynamic query' do
+    lambda do
+      session.search Post do
+        dynamic :custom_string do
+          paginate 3, 10
+        end
+      end
+    end.should raise_error(NoMethodError)
+  end
+
   it 'should paginate using default per_page when page not provided' do
     connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 30))
     session.search Post
@@ -186,7 +259,7 @@ describe 'Search' do
     end
   end
 
-  it 'should order by multiple columns' do
+  it 'should order by multiple fields' do
     connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :descending },
                                                                                    { :sort_title_s => :ascending }])).twice
     session.search Post, :order => ['average_rating desc', 'sort_title asc']
@@ -196,6 +269,34 @@ describe 'Search' do
     end
   end
 
+  it 'should order by a dynamic field' do
+    connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending }]))
+    session.search Post do
+      dynamic :custom_integer do
+        order_by :test, :desc
+      end
+    end
+  end
+
+  it 'should order by a dynamic field and static field, with given precedence' do
+    connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending },
+                                                                              { :sort_title_s => :ascending}]))
+    session.search Post do
+      dynamic :custom_integer do
+        order_by :test, :desc
+      end
+      order_by :sort_title, :asc
+    end
+  end
+
+  it 'should throw an ArgumentError if a bogus order direction is given' do
+    lambda do
+      session.search Post do
+        order_by :sort_title, :sideways
+      end
+    end.should raise_error(ArgumentError)
+  end
+
   it 'should request single field facet' do
     connection.should_receive(:query).with('(type:Post)', hash_including(:facets => { :fields => %w(category_ids_im) }))
     session.search Post do
@@ -203,13 +304,22 @@ describe 'Search' do
     end
   end
 
-  it 'should request multiple field facet' do
+  it 'should request multiple field facets' do
     connection.should_receive(:query).with('(type:Post)', hash_including(:facets => { :fields => %w(category_ids_im blog_id_i) }))
     session.search Post do
       facet :category_ids, :blog_id
     end
   end
 
+  it 'should allow faceting by dynamic string field' do
+    connection.should_receive(:query).with(anything, hash_including(:facets => { :fields => %w(custom_string:test_s) }))
+    session.search Post do
+      dynamic :custom_string do
+        facet :test
+      end
+    end
+  end
+
   it 'should build search for multiple types' do
     connection.should_receive(:query).with('(type:(Post OR Comment))', hash_including)
     session.search(Post, Comment)
@@ -245,6 +355,14 @@ describe 'Search' do
     session.search Post, Comment, :conditions => { :blog_id => 1 }
   end
 
+  it 'should allow building search using block argument rather than instance_eval' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['blog_id_i:1']))
+    @blog_id = 1
+    session.search Post do |query|
+      query.with(:blog_id, @blog_id)
+    end
+  end
+
   it 'should raise Sunspot::UnrecognizedFieldError for nonexistant fields in block scope' do
     lambda do
       session.search Post do

data/spec/api/indexer_spec.rb

@@ -115,6 +115,44 @@ describe 'indexer' do
     end
   end
 
+  describe 'dynamic fields' do
+    it 'should index string data' do
+      post(:custom_string => { :test => 'string' })
+      connection.should_receive(:add).with(hash_including(:"custom_string:test_s" => 'string'))
+      session.index(post)
+    end
+
+    it 'should index integer data with virtual accessor' do
+      post(:category_ids => [1, 2])
+      connection.should_receive(:add).with(hash_including(:"custom_integer:1_i" => '1', :"custom_integer:2_i" => '1'))
+      session.index(post)
+    end
+
+    it 'should index float data' do
+      post(:custom_fl => { :test => 1.5 })
+      connection.should_receive(:add).with(hash_including(:"custom_float:test_fm" => '1.5'))
+      session.index(post)
+    end
+
+    it 'should index time data' do
+      post(:custom_time => { :test => Time.parse('2009-05-18 18:05:00 -0400') })
+      connection.should_receive(:add).with(hash_including(:"custom_time:test_d" => '2009-05-18T22:05:00Z'))
+      session.index(post)
+    end
+
+    it 'should index boolean data' do
+      post(:custom_boolean => { :test => false })
+      connection.should_receive(:add).with(hash_including(:"custom_boolean:test_b" => 'false'))
+      session.index(post)
+    end
+
+    it 'should index multiple values for a field' do
+      post(:custom_fl => { :test => [1.0, 2.1, 3.2] })
+      connection.should_receive(:add).with(hash_including(:"custom_float:test_fm" => %w(1.0 2.1 3.2)))
+      session.index(post)
+    end
+  end
+
   it 'should throw a NoMethodError only if a nonexistent type is defined' do
     lambda { Sunspot.setup(Post) { string :author_name }}.should_not raise_error
     lambda { Sunspot.setup(Post) { bogus :journey }}.should raise_error(NoMethodError)
@@ -139,6 +177,12 @@ describe 'indexer' do
     lambda { session.index(User.new) }.should raise_error(Sunspot::NoAdapterError)
   end
 
+  it 'should throw an ArgumentError if a non-word character is included in the field name' do
+    lambda do
+      Sunspot.setup(Post) { string :"bad name" }
+    end.should raise_error(ArgumentError)
+  end
+
   private
 
   def config

data/spec/api/query_spec.rb

@@ -0,0 +1,129 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sunspot::Query do
+  before :each do
+    @config ||= Sunspot::Configuration.build
+    @connection ||= mock('connection')
+    @session ||= Sunspot::Session.new(@config, @connection)
+    @search = @session.new_search(Post)
+  end
+
+  after :each do
+    @search.execute!
+  end
+
+  it 'should perform keyword search' do
+    @search.query.keywords = 'keyword search'
+    @connection.should_receive(:query).with('(keyword search) AND (type:Post)', hash_including)
+  end
+
+  it 'should add equality restriction' do
+    @search.query.add_restriction(:title, :equal_to, 'My Pet Post')
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['title_s:My\ Pet\ Post']))
+  end
+
+  it 'should add less than restriction' do
+    @search.query.add_restriction(:average_rating, :less_than, 3.0)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[* TO 3\.0]']))
+  end
+
+  it 'should add greater than restriction' do
+    @search.query.add_restriction(:average_rating, :greater_than, 3.0)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[3\.0 TO *]']))
+  end
+
+  it 'should add between restriction' do
+    @search.query.add_restriction(:average_rating, :between, 2.0..4.0)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[2\.0 TO 4\.0]']))
+  end
+
+  it 'should add any restriction' do
+    @search.query.add_restriction(:category_ids, :any_of, [2, 7, 12])
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 OR 7 OR 12)']))
+  end
+
+  it 'should add all restriction' do
+    @search.query.add_restriction(:category_ids, :all_of, [2, 7, 12])
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 AND 7 AND 12)']))
+  end
+
+  it 'should negate restriction' do
+    @search.query.add_negated_restriction(:title, :equal_to, 'Bad Post')
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['-title_s:Bad\ Post']))
+  end
+
+  it 'should exclude instance' do
+    post = Post.new
+    @search.query.exclude_instance(post)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ["-id:Post\\ #{post.id}"]))
+  end
+
+  it 'should paginate using default per-page' do
+    @search.query.paginate(2)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 30, :start => 30))
+  end
+  
+  it 'should paginate using provided per-page' do
+    @search.query.paginate(4, 15)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 15, :start => 45))
+  end
+
+  it 'should order ascending by default' do
+    @search.query.order_by(:average_rating)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :ascending }]))
+  end
+
+  it 'should order descending if specified' do
+    @search.query.order_by(:average_rating, :desc)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :descending }]))
+  end
+
+  it 'should request a field facet' do
+    @search.query.add_field_facet(:category_ids)
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:facets => { :fields => %w(category_ids_im) }))
+  end
+
+  it 'should restrict by dynamic string field with equality restriction' do
+    @search.query.dynamic_query(:custom_string).add_restriction(:test, :equal_to, 'string')
+    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['custom_string\:test_s:string']))
+  end
+
+  it 'should restrict by dynamic integer field with less than restriction' do
+    @search.query.dynamic_query(:custom_integer).add_restriction(:test, :less_than, 1)
+    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_integer\:test_i:[* TO 1]']))
+  end
+
+  it 'should restrict by dynamic float field with between restriction' do
+    @search.query.dynamic_query(:custom_float).add_restriction(:test, :between, 2.2..3.3)
+    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_float\:test_fm:[2\.2 TO 3\.3]']))
+  end
+
+  it 'should restrict by dynamic time field with any of restriction' do
+    @search.query.dynamic_query(:custom_time).add_restriction(:test, :any_of,
+                                                              [Time.parse('2009-02-10 14:00:00 UTC'),
+                                                               Time.parse('2009-02-13 18:00:00 UTC')])
+    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_time\:test_d:(2009\-02\-10T14\:00\:00Z OR 2009\-02\-13T18\:00\:00Z)']))
+  end
+
+  it 'should restrict by dynamic boolean field with equality restriction' do
+    @search.query.dynamic_query(:custom_boolean).add_restriction(:test, :equal_to, false)
+    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_boolean\:test_b:false']))
+  end
+
+  it 'should negate a dynamic field restriction' do
+    @search.query.dynamic_query(:custom_string).add_negated_restriction(:test, :equal_to, 'foo')
+    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['-custom_string\:test_s:foo']))
+  end
+
+  it 'should order by a dynamic field' do
+    @search.query.dynamic_query(:custom_integer).order_by(:test, :desc)
+    @connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending }]))
+  end
+
+  it 'should order by a dynamic field and static field, with given precedence' do
+    @search.query.dynamic_query(:custom_integer).order_by(:test, :desc)
+    @search.query.order_by(:sort_title, :asc)
+    @connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending },
+                                                                               { :sort_title_s => :ascending}]))
+  end
+end

data/spec/api/search_retrieval_spec.rb

@@ -96,6 +96,12 @@ describe 'retrieving search' do
     facet_values(result, :featured).should == [true, false]
   end
 
+  it 'should return dynamic string facet' do
+    stub_facet(:"custom_string:test_s", 'two' => 2, 'one' => 1)
+    result = session.search(Post) { dynamic(:custom_string) { facet(:test) }}
+    result.dynamic_facet(:custom_string, :test).rows.map { |row| row.value }.should == ['two', 'one']
+  end
+
   private
 
   def stub_results(*results)

data/spec/integration/dynamic_fields_spec.rb

@@ -0,0 +1,55 @@
+describe 'dynamic fields' do
+  before :each do
+    Sunspot.remove_all
+    @posts = Post.new(:custom_string => { :cuisine => 'Pizza' }),
+             Post.new(:custom_string => { :cuisine => 'Greek' }),
+             Post.new(:custom_string => { :cuisine => 'Greek' })
+    Sunspot.index!(@posts)
+  end
+
+  it 'should search for dynamic string field' do
+    Sunspot.search(Post) do
+      dynamic(:custom_string) do
+        with(:cuisine, 'Pizza')
+      end
+    end.results.should == [@posts.first]
+  end
+
+  describe 'faceting' do
+    before :each do
+      @search = Sunspot.search(Post) do
+        dynamic :custom_string do
+          facet :cuisine
+        end
+      end
+    end
+
+    it 'should return value "value" with count 2' do
+      row = @search.dynamic_facet(:custom_string, :cuisine).rows[0]
+      row.value.should == 'Greek'
+      row.count.should == 2
+    end
+
+    it 'should return value "other" with count 1' do
+      row = @search.dynamic_facet(:custom_string, :cuisine).rows[1]
+      row.value.should == 'Pizza'
+      row.count.should == 1
+    end
+  end
+
+  it 'should order by dynamic string field ascending' do
+    Sunspot.search(Post) do
+      dynamic :custom_string do
+        order_by :cuisine, :asc
+      end
+    end.results.last.should == @posts.first
+  end
+
+  it 'should order by dynamic string field descending' do
+    Sunspot.search(Post) do
+      dynamic :custom_string do
+        order_by :cuisine, :desc
+      end
+    end.results.first.should == @posts.first
+  end
+end

data/spec/mocks/post.rb

@@ -25,8 +25,24 @@ class Post < BaseClass
     ids.map { |id| get(id) }.sort_by { |post| post.id } # this is so that results are not ordered by coincidence
   end
 
+  def custom_string
+    @custom_string ||= {}
+  end
+
+  def custom_fl
+    @custom_fl ||= {}
+  end
+
+  def custom_time
+    @custom_time ||= {}
+  end
+
+  def custom_boolean
+    @custom_boolean ||= {}
+  end
+
   private
-  attr_writer :category_ids
+  attr_writer :category_ids, :custom_string, :custom_fl, :custom_time, :custom_boolean
 end
 
 Sunspot.setup(Post) do
@@ -43,4 +59,14 @@ Sunspot.setup(Post) do
   integer :primary_category_id do |post|
     post.category_ids.first
   end
+
+  dynamic_string :custom_string
+  dynamic_float :custom_float, :multiple => true, :using => :custom_fl
+  dynamic_integer :custom_integer do
+    category_ids.inject({}) do |hash, category_id|
+      hash.merge(category_id => 1)
+    end
+  end
+  dynamic_time :custom_time
+  dynamic_boolean :custom_boolean
 end

data/spec/spec_helper.rb

@@ -1,9 +1,16 @@
 require 'rubygems'
-gem 'ruby-debug', '~>0.10'
 gem 'mislav-will_paginate', '~> 2.3'
 gem 'rspec', '~> 1.1'
-
-require 'ruby-debug'
+begin
+  gem 'ruby-debug', '~>0.10'
+  require 'ruby-debug'
+rescue Gem::LoadError
+  module Kernel
+    def debugger
+      raise("debugger is not available")
+    end
+  end
+end
 require 'spec'
 require 'will_paginate'
 require 'will_paginate/collection'