believer 0.2.4 → 0.2.5

data/README.md

@@ -72,6 +72,7 @@ The following methods can be used to query class instances.
 * select: specify which fields to load. Using none defaults to all fields being loaded.
 * limit: limit the number of results to a maximum
 * order: specify the order of the results
+* allow_filtering: allow or disallow filtering (see ALLOW FILTERING in Cassandra CQL docs)
 
 All methods are chainable, meaning you can
 
@@ -121,6 +122,23 @@ Album.order(:name, :asc)
 Album.order(:name, :desc)
 ```
 
+#### pluck
+In order to retrieve just the the value(s) of one or more columns, the pluck method can be used.
+This method does not instantiate any Believer::Base instances
+
+``` ruby
+# Select single column value
+Album.where(:artist_name => 'Michael Jackson').pluck(:name) # -> ['Off the wall', 'Thriller', 'Bad']
+# Select multiple column values
+Album.where(:artist_name => 'Michael Jackson').pluck(:name, :release_date) # -> [['Off the wall', '1979-01-01', 'Thriller', 'Bad']
+```
+
+#### allow_filtering
+``` ruby
+Album.allow_filtering(true) # -> SELECT * FROM albums ALLOW FILTERING
+Album.allow_filtering(false) # -> SELECT * FROM albums
+```
+
 #### Method chaining
 All query methods can be chained.
 This is done by creating and returning a clone of the receiver. The clone is the receiver of the query method.
@@ -194,6 +212,8 @@ development:
         logger:
             # Use STDOUT to log messages
             use_environment: false
+            # Log at info (1) level -> no CQL prints
+            level: 1
 
 development:
     host: 127.0.0.1

data/lib/believer/base.rb

@@ -21,10 +21,6 @@ module Believer
 
     def initialize(attrs = {})
       @attributes = {}
-      #puts "Attrs: #{attrs.to_json}"
-      #self.class.columns.each do |name, colum_definition|
-      #  send("#{name}=".to_sym, attrs[name.to_s])
-      #end if attrs.present?
       attrs.each do |name, val|
         send("#{name}=".to_sym, val)
       end if attrs.present?
@@ -37,6 +33,10 @@ module Believer
     end
 
     def ==(obj)
+      eql?(obj)
+    end
+
+    def eql?(obj)
       return false if obj.nil?
       return false unless obj.is_a?(self.class)
       equal_key_values?(obj)
@@ -49,4 +49,6 @@ module Believer
   end
 
 
-end
+end
+
+ActiveSupport.run_load_hooks(:believer, Believer::Base)

data/lib/believer/command.rb

@@ -1,7 +1,7 @@
 module Believer
   class Command
 
-    attr_accessor :record_class
+    attr_accessor :record_class, :consistency_level
 
     def initialize(attrs = {})
       attrs.each do |name, value|
@@ -14,8 +14,14 @@ module Believer
       self.class.new(query_attributes)
     end
 
+    def consistency(level)
+      c = clone
+      c.consistency_level = level
+      c
+    end
+
     def query_attributes
-      {:record_class => @record_class}
+      {:record_class => @record_class, :consistency_level => @consistency_level}
     end
 
     def command_name
@@ -23,16 +29,14 @@ module Believer
     end
 
     def execute(name = nil)
-      name = "#{record_class.name} #{command_name}" if name.nil?
       @record_class.connection_pool.with do |connection|
         cql = to_cql
         begin
-          #start = Time.now
-          #res = connection.execute(cql)
-          #puts "#{name} #{sprintf "%.3f", (Time.now - start)*1000.0} ms: #{cql}"
-          #return res
+          name = "#{record_class.name} #{command_name}" if name.nil?
           return ActiveSupport::Notifications.instrument('cql.believer', :cql => cql, :name => name) do
-            return connection.execute(cql)
+            exec_opts = {}
+            exec_opts[:consistency] = consistency_level unless consistency_level.nil?
+            return connection.execute(cql, exec_opts)
           end
         rescue Cql::Protocol::DecodingError => e
           # Decoding errors tend to #$%# up the connection, resulting in no more activity, so a reconnect is performed here.

data/lib/believer/ddl.rb

@@ -8,7 +8,7 @@ module Believer
       def drop_table
         connection_pool.with do |connection|
           cql = "DROP TABLE #{table_name}"
-          ActiveSupport::Notifications.instrument('deserialize.believer', :class => self, :cql => cql, :method => :drop) do
+          ActiveSupport::Notifications.instrument('ddl.believer', :class => self, :cql => cql, :method => :drop) do
             connection.execute(cql)
           end
         end

data/lib/believer/environment/base_env.rb

@@ -24,7 +24,6 @@ module Believer
         return nil unless believer_configuration[:logger]
         return environment_logger if believer_configuration[:logger][:use_environment] && respond_to?(:environment_logger)
         unless @std_logger
-          puts believer_configuration[:logger]
           @std_logger = ::Logger.new(STDOUT)
           if believer_configuration[:logger][:level] && believer_configuration[:logger][:level].is_a?(Numeric)
             @std_logger.level = believer_configuration[:logger][:level].to_i
@@ -102,8 +101,6 @@ module Believer
           WITH #{ks_props_s}
         KS_DEF
 
-        puts ks_def
-
         conn.execute(ks_def)
       end
 

data/lib/believer/extending.rb

@@ -0,0 +1,58 @@
+module Believer
+  module Extending
+
+    # Used to extend a scope with additional methods, either through
+    # a module or through a block provided.
+    #
+    # The object returned is a relation, which can be further extended.
+    #
+    # === Using a module
+    #
+    #   module Pagination
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #
+    #   scope = Model.scoped.extending(Pagination)
+    #   scope.page(params[:page])
+    #
+    # You can also pass a list of modules:
+    #
+    #   scope = Model.scoped.extending(Pagination, SomethingElse)
+    #
+    # === Using a block
+    #
+    #   scope = Model.scoped.extending do
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #   scope.page(params[:page])
+    #
+    # You can also use a block and a module list:
+    #
+    #   scope = Model.scoped.extending(Pagination) do
+    #     def per_page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
+
+      relation = clone
+      relation.send(:apply_modules, modules.flatten)
+      relation
+    end
+
+    def apply_modules(modules)
+      unless modules.empty?
+        @extensions += modules
+        modules.each {|extension| extend(extension) }
+      end
+    end
+
+  end
+end

data/lib/believer/extensions/will_paginate.rb

@@ -0,0 +1,173 @@
+require 'will_paginate/per_page'
+require 'will_paginate/page_number'
+require 'will_paginate/collection'
+require 'believer'
+
+module Believer
+  module Extensions
+    # = Paginating finders for Believer models
+    #
+    # WillPaginate adds +paginate+, +per_page+ and other methods to
+    # Believer::Base class methods and associations.
+    #
+    # In short, paginating finders are equivalent to ActiveRecord finders; the
+    # only difference is that we start with "paginate" instead of "find" and
+    # that <tt>:page</tt> is required parameter:
+    #
+    #   @posts = Post.paginate :all, :page => params[:page], :order => 'created_at DESC'
+    #
+    module WillPaginate
+      # makes a Relation look like WillPaginate::Collection
+      module RelationMethods
+        include ::WillPaginate::CollectionMethods
+
+        attr_accessor :current_page
+        attr_writer :total_entries, :wp_count_options
+
+        def per_page(value = nil)
+          if value.nil? then
+            limit_value
+          else
+            limit(value)
+          end
+        end
+
+        # TODO: solve with less relation clones and code dups
+        def limit(num)
+          rel = super
+          if rel.current_page
+            rel.offset rel.current_page.to_offset(rel.limit_value).to_i
+          else
+            rel
+          end
+        end
+
+        def offset(value = nil)
+          if value.nil? then
+            offset_value
+          else
+            super(value)
+          end
+        end
+
+        def total_entries
+          @total_entries ||= begin
+            if loaded? and size < limit_value and (current_page == 1 or size > 0)
+              offset_value + size
+            else
+              @total_entries_queried = true
+              result = count
+              result = result.size if result.respond_to?(:size) and !result.is_a?(Integer)
+              result
+            end
+          end
+        end
+
+        def count
+          if limit_value
+            excluded = [:order, :limit, :offset]
+            excluded << :includes unless eager_loading?
+            rel = self.except(*excluded)
+            # TODO: hack. decide whether to keep
+            rel = rel.apply_finder_options(@wp_count_options) if defined? @wp_count_options
+            rel.count
+          else
+            super
+          end
+        end
+
+        # workaround for Active Record 3.0
+        def size
+          if !loaded? and limit_value and group_values.empty?
+            [super, limit_value].min
+          else
+            super
+          end
+        end
+
+        # overloaded to be pagination-aware
+        def empty?
+          if !loaded? and offset_value
+            result = count
+            result = result.size if result.respond_to?(:size) and !result.is_a?(Integer)
+            result <= offset_value
+          else
+            super
+          end
+        end
+
+        def clone
+          copy_will_paginate_data super
+        end
+
+        # workaround for Active Record 3.0
+        def scoped(options = nil)
+          copy_will_paginate_data super
+        end
+
+        def to_a
+          if current_page.nil? then
+            super # workaround for Active Record 3.0
+          else
+            ::WillPaginate::Collection.create(current_page, limit_value) do |col|
+              col.replace super
+              col.total_entries ||= total_entries
+            end
+          end
+        end
+
+        private
+
+        def copy_will_paginate_data(other)
+          other.current_page = current_page unless other.current_page
+          other.total_entries = nil if defined? @total_entries_queried
+          other.wp_count_options = @wp_count_options if defined? @wp_count_options
+          other
+        end
+      end
+
+      module Pagination
+        def paginate(options)
+          options = options.dup
+          pagenum = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
+          per_page = options.delete(:per_page) || self.per_page
+          total = options.delete(:total_entries)
+
+          count_options = options.delete(:count)
+          options.delete(:page)
+
+          rel = limit(per_page.to_i).page(pagenum)
+          rel = rel.apply_finder_options(options) if options.any?
+          rel.wp_count_options = count_options if count_options
+          rel.total_entries = total.to_i unless total.blank?
+          rel
+        end
+
+        def page(num)
+          rel = scoped.extending(RelationMethods)
+          pagenum = ::WillPaginate::PageNumber(num.nil? ? 1 : num)
+          per_page = rel.limit_value || self.per_page
+          rel = rel.offset(pagenum.to_offset(per_page).to_i)
+          rel = rel.limit(per_page) unless rel.limit_value
+          rel.current_page = pagenum
+          rel
+        end
+      end
+
+      module BaseMethods
+
+      end
+
+      # mix everything into Believer
+      ::Believer::Base.extend ::WillPaginate::PerPage
+      ::Believer::Base.extend Pagination
+      #::Believer::Base.extend BaseMethods
+
+      klasses = [::Believer::Relation]
+
+      # support pagination on associations and scopes
+      klasses.each { |klass| klass.send(:include, Pagination) }
+    end
+  end
+end
+

data/lib/believer/filter_command.rb

@@ -8,7 +8,6 @@ module Believer
     end
 
     def wheres
-      #puts "Wheres: #{@wheres}"
       @wheres ||= []
     end
 

data/lib/believer/query.rb

@@ -1,6 +1,11 @@
+require 'believer/extending'
+
 module Believer
   class Query < FilterCommand
-    attr_accessor :record_class, :selects, :order_by, :limit_to
+    include Extending
+
+    attr_accessor :record_class, :selects, :order_by, :limit_to, :filtering_allowed
+    alias :filtering_allowed? :filtering_allowed
 
     delegate *(Enumerable.instance_methods(false).map {|enum_method| enum_method.to_sym}), :to => :to_a
     delegate :each, :size, :[], :to => :to_a
@@ -12,7 +17,26 @@ module Believer
 
     def query_attributes
       attrs = super
-      attrs.merge(:order_by => @order_by, :selects => @selects, :limit_to => @limit_to)
+      attrs.merge(:order_by => @order_by, :selects => @selects, :limit_to => @limit_to, :filtering_allowed => filtering_allowed)
+    end
+
+    def pluck(*fields)
+      fields.each do |f|
+        raise "Unknown field #{f} for class #{record_class}" unless record_class.columns.has_key?(f)
+      end
+      q = clone
+      q.selects = fields
+      rows = q.execute
+      pluck_res = []
+      rows.each do |r|
+        if fields.size > 1
+          pluck_res << fields.map {|f| record_class.columns[f].convert_to_type(r[f.to_s]) }
+        else
+          f = fields[0]
+          pluck_res << record_class.columns[f].convert_to_type(r[f.to_s])
+        end
+      end
+      pluck_res
     end
 
     def select(*fields)
@@ -20,7 +44,6 @@ module Believer
       q.selects ||= []
       q.selects += fields
       q.selects.flatten!
-      #puts "New selects: #{q.selects}, added: #{fields}"
       q
     end
 
@@ -44,11 +67,18 @@ module Believer
       end
     end
 
+    def allow_filtering(b = true)
+      q = clone
+      q.filtering_allowed = b
+      q
+    end
+
     def to_cql
       cql = "SELECT "
       if @selects && @selects.any?
         cql << "#{@selects.join(', ')}"
       else
+        #@record_class.environment.believer_configuration[:expand_columns]
         cql << @record_class.columns.keys.join(',')
         #cql << "*"
       end
@@ -57,6 +87,7 @@ module Believer
       cql << " WHERE #{wheres.map { |wc| "#{wc.to_cql}" }.join(' AND ')}" if wheres.any?
       cql << " #{order_by.to_cql}" unless order_by.nil?
       cql << " #{limit_to.to_cql}" unless limit_to.nil?
+      cql << " ALLOW FILTERING" if filtering_allowed?
       cql
     end
 
@@ -90,7 +121,6 @@ module Believer
         result = execute
         notify_payload = {:class => @record_class}
         @loaded_objects = ActiveSupport::Notifications.instrument('deserialize.believer', notify_payload) do
-          start = Time.now
           objects = []
           result.each do |row|
             objects << record_class.instantiate_from_result_rows(row)
@@ -98,7 +128,6 @@ module Believer
           notify_payload[:count] = objects.count
           objects
         end
-        #puts "Took #{sprintf "%.3f", (Time.now - start)*1000.0} ms to deserialize #{@loaded_objects.size} object(s)"
       end
       @loaded_objects
     end

data/lib/believer/test/test_run_life_cycle.rb

@@ -17,21 +17,26 @@ module Believer
         observe Believer::Base
 
         def cleanup
-          unless @saved_models.nil? || @saved_models.empty?
-            @saved_models.each do |model|
+          unless @observed_models.nil? || @observed_models.empty?
+            @observed_models.each do |model|
               begin
                 model.destroy
               rescue Exception => e
                 puts "Could not destroy model #{model}: #{e}\n#{e.backtrace.join("\n")}"
               end
             end
-            @saved_models = nil
+            @observed_models = nil
           end
         end
 
+        def observed_models
+          return @observed_models.dup unless @observed_models.nil?
+          []
+        end
+
         def after_save(model)
-          @saved_models ||= []
-          @saved_models << model
+          @observed_models ||= []
+          @observed_models << model
         end
 
       end

data/lib/believer/version.rb

@@ -1,5 +1,5 @@
 module Believer
   module Version
-    VERSION = '0.2.4'
+    VERSION = '0.2.5'
   end
 end

data/spec/believer/environment_spec.rb

@@ -12,21 +12,25 @@ describe Believer::Environment do
   end
 
   it 'load the rails configuration' do
+    if defined?(Rails)
+      puts "Rails: #{Rails}"
+    end
     Rails = Struct.new(:root, :env, :logger).new(File.join(RSpec.configuration.test_files_dir, 'rails'), :test, nil)
     env = Believer::Base.environment
     env.class.should == Believer::Environment::RailsEnv
     env.configuration[:host].should == '123.456.789.0'
-    #remove_const(Rails)
-    Rails = nil
+    Object.instance_eval { remove_const :Rails}
   end
 
   it 'load the Merb configuration' do
+    if defined?(Merb)
+      puts "Rails: #{Merb}"
+    end
     Merb = Struct.new(:root, :environment, :logger).new(File.join(RSpec.configuration.test_files_dir, 'merb'), :test, nil)
     env = Believer::Base.environment
     env.class.should == Believer::Environment::MerbEnv
     env.configuration[:host].should == 'merb.test.local'
-    #remove_const(Merb)
-    Merb = nil
+    Object.instance_eval { remove_const :Merb}
   end
 
 end

data/spec/believer/extensions/will_paginate_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Believer::Extensions::WillPaginate' do
+
+  before :each do
+    @count = 10
+  end
+
+  it '' do
+
+  end
+end

data/spec/believer/query_spec.rb

@@ -1,7 +1,28 @@
 require 'spec_helper'
 
 describe Believer::Query do
- include Believer::Test::TestRunLifeCycle
+  include Believer::Test::TestRunLifeCycle
+
+  let :artists do
+    Test::Artist.create(
+        [
+            {:name => 'Beatles', :label => 'Apple'},
+            {:name => 'Jethro Tull', :label => 'Crysalis'},
+            {:name => 'Pink Floyd', :label => 'Epic'},
+            {:name => 'Michael Jackson', :label => 'Epic'}
+    ])
+  end
+
+  let :albums do
+    Test::Album.create(
+        [
+            {:artist_name => 'Beatles', :name => 'Help'},
+            {:artist_name => 'Jethro Tull', :name => 'Aqualung'},
+            {:artist_name => 'Jethro Tull', :name => 'Standup'},
+            {:artist_name => 'Michael Jackson', :name => 'Thriller'}
+        ])
+
+  end
 
   it 'create simple statement' do
     q = Believer::Query.new(:record_class => Test::Album)
@@ -14,18 +35,58 @@ describe Believer::Query do
     q.to_cql.should == "SELECT name, artist FROM albums WHERE name = 'Revolver' AND release_date = '2013-01-01 00:00:00+0000' ORDER BY name DESC LIMIT 10"
   end
 
-  it 'should behave like an Enumerable' do
+  it 'should include allow filtering clause' do
+    q = Believer::Query.new(:record_class => Test::Album)
+    q = q.select(:name)
+    expect(q.to_cql).to eql "SELECT name FROM albums"
+    q = q.allow_filtering(true)
+    expect(q.to_cql).to eql "SELECT name FROM albums ALLOW FILTERING"
+    q = q.allow_filtering(false)
+    expect(q.to_cql).to eql "SELECT name FROM albums"
+  end
 
-    @objects = Test::Artist.create([
-        {:name => 'Beatles', :label => 'Apple'},
-        {:name => 'Jethro Tull', :label => 'Crysalis'},
-        {:name => 'Pink Floyd', :label => 'Epic'}
-    ])
-    q = Believer::Query.new(:record_class => Test::Artist).where(:name => @objects.map {|o|o.name})
+  it 'should behave like an Enumerable' do
+    q = Believer::Query.new(:record_class => Test::Artist).where(:name => artists.map { |o| o.name })
     Enumerable.instance_methods(false).each do |enum_method|
       q.respond_to?(enum_method.to_sym).should == true
     end
-    q.first.should == @objects.first
+  end
+
+  it 'should order' do
+    q = Believer::Query.new(:record_class => Test::Album).select(:name)
+    q = q.order(:release_date, :desc)
+    expect(q.to_cql).to eql("SELECT name FROM albums ORDER BY release_date DESC")
+  end
+
+  it 'should be able to pluck single column values' do
+    albums
+    q = Believer::Query.new(:record_class => Test::Album).where(:artist_name => 'Jethro Tull')
+    album_names = q.pluck(:name)
+    expect(album_names.size).to eql(2)
+    expect(album_names).to include('Standup')
+    expect(album_names).to include('Aqualung')
+  end
+
+  it 'should be able to pluck multiple column values' do
+    albums
+    q = Believer::Query.new(:record_class => Test::Album).where(:artist_name => 'Jethro Tull').order(:name)
+    album_names = q.pluck(:name, :artist_name)
+    expect(album_names).to eql([['Aqualung', 'Jethro Tull'], ['Standup', 'Jethro Tull']])
+  end
+
+  it 'should not be able to pluck if an unknown column name is used' do
+    albums
+    q = Believer::Query.new(:record_class => Test::Album).where(:artist_name => 'Jethro Tull').order(:name)
+    begin
+      q.pluck(:artist_xxx)
+      fail
+    rescue Exception => e
+    end
+    begin
+      q.pluck(:name, :artist_xxx)
+      fail
+    rescue Exception => e
+    end
   end
 
 end

data/spec/believer/test_run_life_cycle_spec.rb

@@ -4,47 +4,57 @@ require 'spec_helper'
 describe Believer::Test::TestRunLifeCycle do
   include Believer::Test::TestRunLifeCycle
 
-  before :all do
-    @destroyed_count = 0
-    @destroy_monitor = lambda do |obj|
-      @destroyed_count += 1
-    end
+  CREATE_COUNT = 10
 
+  before :all do
+    @monitor = Monitor.new
     begin
-      XXX.drop_table
-
+      Fly.drop_table
     rescue
     ensure
-          XXX.create_table
+      Fly.create_table
+      @created = []
+      CREATE_COUNT.times do |i|
+        @created << Fly.create(:name => "artist_#{i}", :kill_monitor => @monitor)
+      end
     end
   end
 
   after :all do
-    puts "DROP TABLE XXXX"
-    @destroyed_count.should == @created.size
-    XXX.drop_table
+    Fly.drop_table
+    @monitor.kill_count.should == @created.size
+  end
+
+  after :each do
   end
 
   before :each do
-    @created = []
-    10.times do |i|
-      @created << XXX.create(:name => "artist_#{i}", :destroy_monitor => @destroy_monitor)
-    end
   end
 
   it "should clean all created objects, even after a fail" do
-    #fail
+    Believer::Test::TestRunLifeCycle::Destructor.instance.observed_models.size.should == CREATE_COUNT
+  end
+
+  class Monitor
+    attr_reader :kill_count
+
+    def initialize
+      @kill_count = 0
+    end
+
+    def destroyed
+      @kill_count += 1
+    end
   end
 
-  class XXX < Believer::Base
+  class Fly < Believer::Base
     column :name, :type => :string
     primary_key :name
-    cattr_accessor :destroyed_count
 
-    attr_accessor :destroy_monitor
+    attr_accessor :kill_monitor
 
     before_destroy do
-      @destroy_monitor.call(self)
+      self.kill_monitor.destroyed
     end
   end
 

data/spec/support/test_classes.rb

@@ -65,7 +65,7 @@ module Test
           :host => '127.0.0.1',
           :keyspace => 'believer_test_space',
           :believer => {
-              :logger => {:level => ::Logger::DEBUG}
+              :logger => {:level => ::Logger::INFO}
           }
       }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: believer
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-25 00:00:00.000000000 Z
+date: 2013-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -107,6 +107,22 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! 'An Object Relational Mapping library for CQL3 '
 email:
 - jerphaes@gmail.com
@@ -130,6 +146,8 @@ files:
 - lib/believer/environment/merb_env.rb
 - lib/believer/environment/rails_env.rb
 - lib/believer/environment.rb
+- lib/believer/extending.rb
+- lib/believer/extensions/will_paginate.rb
 - lib/believer/filter_command.rb
 - lib/believer/finder_methods.rb
 - lib/believer/insert.rb
@@ -154,6 +172,7 @@ files:
 - spec/believer/delete_spec.rb
 - spec/believer/empty_result_spec.rb
 - spec/believer/environment_spec.rb
+- spec/believer/extensions/will_paginate_spec.rb
 - spec/believer/finder_methods_spec.rb
 - spec/believer/insert_spec.rb
 - spec/believer/limit_spec.rb
@@ -198,6 +217,7 @@ test_files:
 - spec/believer/delete_spec.rb
 - spec/believer/empty_result_spec.rb
 - spec/believer/environment_spec.rb
+- spec/believer/extensions/will_paginate_spec.rb
 - spec/believer/finder_methods_spec.rb
 - spec/believer/insert_spec.rb
 - spec/believer/limit_spec.rb