sequel-seek-pagination 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e681598557874a5b7102fd630deef04e48dd08ec
-  data.tar.gz: 176755ad95e8e78978dac323661a9b9f55762a0d
+  metadata.gz: 6618c26ae7817aca156c266b2981123bb313b7c4
+  data.tar.gz: 00b368ee9b8ff804aa9f658c3793d24c98262c4f
 SHA512:
-  metadata.gz: 4581a836e385d1f061b984fbc14a94d7225d3010d67efb8b1e169f76ff80445044ec1d727bfe28c38761272e68629b1023cea8f683bf87be9c86d42c1bcca124
-  data.tar.gz: 7c191afc86655d078da0d2c49b2aab2b6bbb42f21af9558c3ada83a8053ad45f60e3c4e39a2eeb8f251f4e0b9c952b1aacc01fc66c701fb0e7afbcf2de91dc5a
+  metadata.gz: 85ad99ff1ed0031e3bd60c79492de37f5248f5702f32ce7b07bfa957338153f17d84e82acf46dc31f5e9a2bafb6c794e00614620c5059512e0d976a8cde4fd41
+  data.tar.gz: 947e63b6731d904e9ea22cc3b91f1ad0dc4ea68480c9d7dc8019352b601c2a88727abba1d164da8a8ff8818e6ba2435a47fc8bbcaabd2cc2af5cb514338d217f

data/README.md

@@ -13,16 +13,16 @@ DB.extension :seek_pagination
 ds = DB[:seek]
 ds.extension(:seek_pagination)
 
-# Use the new Dataset#seek_paginate method to get the first page.
-DB[:seek].order(:id).seek_paginate(50) # SELECT * FROM "seek" ORDER BY "id" LIMIT 50
+# Get the first page of data:
+DB[:seek].order(:id).limit(50) # SELECT * FROM "seek" ORDER BY "id" LIMIT 50
 
-# Use the last data you saw to get the second page.
+# Pass the last data to the you saw to get the second page.
 # (suppose the id of the last row you got was 1456)
-DB[:seek].order(:id).seek_paginate(50, after: 1456) # SELECT * FROM "seek" WHERE ("id" > 1456) ORDER BY "id" LIMIT 50
+DB[:seek].order(:id).limit(50).seek(value: 1456) # SELECT * FROM "seek" WHERE ("id" > 1456) ORDER BY "id" LIMIT 50
 
 # Also works when sorting by multiple columns.
-DB[:seek].order(:col1, :col2).seek_paginate(50) # SELECT * FROM "seek" ORDER BY "col1", "col2" LIMIT 50
-DB[:seek].order(:col1, :col2).seek_paginate(50, after: [12, 56]) # SELECT * FROM "seek" WHERE (("col1", "col2") > (12, 56)) ORDER BY "col1", "col2" LIMIT 50
+DB[:seek].order(:col1, :col2).limit(50) # SELECT * FROM "seek" ORDER BY "col1", "col2" LIMIT 50
+DB[:seek].order(:col1, :col2).limit(50).seek(value: [12, 56]) # SELECT * FROM "seek" WHERE (("col1", "col2") > (12, 56)) ORDER BY "col1", "col2" LIMIT 50
 ```
 
 ### Why Seek Pagination?

data/lib/sequel/extensions/seek_pagination.rb

@@ -5,27 +5,19 @@ module Sequel
   module SeekPagination
     class Error < StandardError; end
 
-    def seek_paginate(count, from: nil, after: nil, from_pk: nil, after_pk: nil, not_null: nil)
+    def seek(value: nil, pk: nil, include_exact_match: false, not_null: nil)
       order = opts[:order]
       model = @model
 
-      if order.nil? || order.length.zero?
-        raise Error, "cannot seek_paginate on a dataset with no order"
-      elsif [from, after, from_pk, after_pk].compact.count > 1
-        raise Error, "cannot pass more than one of the :from, :after, :from_pk and :after_pk arguments to seek_paginate"
-      elsif model.nil? && (from_pk || after_pk)
-        raise Error, "passed the :#{from_pk ? 'from' : 'after'}_pk option to seek_paginate on a dataset that doesn't have an associated model"
+      if !(value.nil? ^ pk.nil?)
+        raise Error, "must pass exactly one of :value and :pk to #seek"
+      elsif order.nil? || order.length.zero?
+        raise Error, "cannot call #seek on a dataset with no order"
+      elsif model.nil? && pk
+        raise Error, "attempted a primary key lookup on a dataset that doesn't have an associated model"
       end
 
-      ds = limit(count)
-
-      if values = from || after
-        values = Array(values)
-
-        if values.length != order.length
-          raise Error, "passed the wrong number of values in the :#{from ? 'from' : 'after'} option to seek_paginate"
-        end
-      elsif pk = from_pk || after_pk
+      if pk
         target_ds = where(model.qualified_primary_key_hash(pk))
 
         # Need to load the values to order from for that pk from the DB, so we
@@ -33,7 +25,7 @@ module Sequel
         # Dataset#get won't like it if we pass it expressions that aren't
         # simple columns, so we need to give it aliases for everything.
         al = :a
-        gettable = order.map do |o, i|
+        gettable = order.map do |o|
           expression = Sequel::SQL::OrderedExpression === o ? o.expression : o
           Sequel.as(expression, (al = al.next))
         end
@@ -41,27 +33,31 @@ module Sequel
         unless values = target_ds.get(gettable)
           raise NoMatchingRow.new(target_ds)
         end
+      else
+        values = Array(value)
+
+        if values.length != order.length
+          raise Error, "passed the wrong number of values to #seek"
+        end
       end
 
-      if values
-        if not_null.nil?
-          not_null = []
+      if not_null.nil?
+        not_null = []
 
-          # If the dataset was chained off a model, use its stored schema
-          # information to figure out what columns are not null.
-          if model
-            model.db_schema.each do |column, schema|
-              not_null << column if schema[:allow_null] == false
-            end
+        # If the dataset was chained off a model, use its stored schema
+        # information to figure out what columns are not null.
+        if model
+          model.db_schema.each do |column, schema|
+            not_null << column if schema[:allow_null] == false
           end
         end
-
-        # If we're paginating with a :from value, we want to include the row
-        # that has those exact values.
-        OrderedColumnSet.new(order.zip(values), include_exact_match: !!(from || from_pk), not_null: not_null).apply(ds)
-      else
-        ds
       end
+
+      OrderedColumnSet.new(
+        order.zip(values),
+        include_exact_match: include_exact_match,
+        not_null: not_null
+      ).apply(self)
     end
 
     private
@@ -92,21 +88,21 @@ module Sequel
           else
             Sequel.&(
               *length.times.map { |i|
-                allow_equal = include_exact_match || i != length - 1
+                allow_equal = include_exact_match || i != (length - 1)
                 conditions = orders[0..i]
 
                 if i.zero?
-                  conditions[0].ineq(eq: allow_equal)
+                  conditions[0].inequality_condition(allow_equal: allow_equal)
                 else
                   c = conditions[-2]
 
-                  list = if filter = conditions[-1].ineq(eq: allow_equal)
+                  list = if filter = conditions[-1].inequality_condition(allow_equal: allow_equal)
                            [Sequel.&(c.eq_filter, filter)]
                          else
                            [c.eq_filter]
                          end
 
-                  list += conditions[0..-2].map { |c| c.ineq(eq: false) }
+                  list += conditions[0..-2].map { |c| c.inequality_condition(allow_equal: false) }
 
                   Sequel.|(*list.compact)
                 end
@@ -160,25 +156,34 @@ module Sequel
         {name => nil}
       end
 
-      def ineq(eq:)
+      def inequality_condition(allow_equal:)
         nulls_upcoming = !not_null && nulls == :last
 
-        if !value.nil?
-          filter = Sequel.virtual_row{|o| o.__send__(inequality_method(eq), name, value)}
-          nulls_upcoming ? Sequel.|(filter, null_filter) : filter
-        else
-          if nulls_upcoming && eq
+        if value.nil?
+          if nulls_upcoming && allow_equal
             null_filter
-          elsif !nulls_upcoming && !eq
+          elsif !nulls_upcoming && !allow_equal
             Sequel.~(null_filter)
+          else
+            # No condition necessary.
+            nil
+          end
+        else
+          # Value is not null.
+          filter = Sequel.virtual_row { |o| o.__send__(inequality_method(allow_equal), name, value) }
+
+          if nulls_upcoming
+            Sequel.|(filter, null_filter)
+          else
+            filter
           end
         end
       end
 
-      def inequality_method(eq)
+      def inequality_method(allow_equal)
         case direction
-        when :asc  then eq ? :>= : :>
-        when :desc then eq ? :<= : :<
+        when :asc  then allow_equal ? :>= : :>
+        when :desc then allow_equal ? :<= : :<
         else raise "Bad direction: #{direction.inspect}"
         end
       end

data/lib/sequel/extensions/seek_pagination/version.rb

@@ -1,5 +1,5 @@
 module Sequel
   module SeekPagination
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
   end
 end

data/spec/seek_pagination_spec.rb

@@ -13,7 +13,7 @@ class SeekPaginationSpec < Minitest::Spec
   end
 
   class << self
-    def it_should_seek_paginate_properly(ordering)
+    def it_should_seek_properly(ordering)
       columns = ordering.map do |order|
                   case order
                   when Sequel::SQL::OrderedExpression then order.expression
@@ -24,33 +24,28 @@ class SeekPaginationSpec < Minitest::Spec
       [:plain, :model].each do |dataset_type|
         describe "for a #{dataset_type} dataset" do
           dataset = dataset_type == :plain ? DB[:seek] : SeekModel
-          dataset = dataset.order(*ordering)
+          dataset = dataset.order(*ordering).limit(100)
 
           # Can't pass any random expression to #get, so give them all aliases.
           gettable = columns.zip(:a..:z).map{|c,a| Sequel.as(c, a)}
 
-          it "should limit the dataset appropriately when a starting point is not given" do
-            assert_equal_results dataset.limit(10),
-                                 dataset.seek_paginate(10)
-          end
-
           it "should page properly when given a point to start from/after" do
             offset = rand(SEEK_COUNT)
             values = dataset.offset(offset).get(gettable)
 
-            assert_equal_results dataset.offset(offset).limit(100),
-                                 dataset.seek_paginate(100, from: values)
+            assert_equal_results dataset.offset(offset),
+                                 dataset.seek(value: values, include_exact_match: true)
 
-            assert_equal_results dataset.offset(offset + 1).limit(100),
-                                 dataset.seek_paginate(100, after: values)
+            assert_equal_results dataset.offset(offset + 1),
+                                 dataset.seek(value: values)
 
             if columns.length == 1
               # Should wrap values in an array if necessary
-              assert_equal_results dataset.offset(offset).limit(100),
-                                   dataset.seek_paginate(100, from: values.first)
+              assert_equal_results dataset.offset(offset),
+                                   dataset.seek(value: values.first, include_exact_match: true)
 
-              assert_equal_results dataset.offset(offset + 1).limit(100),
-                                   dataset.seek_paginate(100, after: values.first)
+              assert_equal_results dataset.offset(offset + 1),
+                                   dataset.seek(value: values.first)
             end
           end
 
@@ -58,11 +53,11 @@ class SeekPaginationSpec < Minitest::Spec
             offset = rand(SEEK_COUNT)
             values = dataset.offset(offset).get(gettable)
 
-            assert_equal_results dataset.offset(offset).limit(100),
-                                 dataset.seek_paginate(100, from: values, not_null: [:id, :non_nullable_1, :non_nullable_2])
+            assert_equal_results dataset.offset(offset),
+                                 dataset.seek(value: values, include_exact_match: true, not_null: [:id, :non_nullable_1, :non_nullable_2])
 
-            assert_equal_results dataset.offset(offset + 1).limit(100),
-                                 dataset.seek_paginate(100, after: values, not_null: [:id, :non_nullable_1, :non_nullable_2])
+            assert_equal_results dataset.offset(offset + 1),
+                                 dataset.seek(value: values, not_null: [:id, :non_nullable_1, :non_nullable_2])
           end
 
           if dataset_type == :model
@@ -70,11 +65,11 @@ class SeekPaginationSpec < Minitest::Spec
               offset = rand(SEEK_COUNT)
               id     = dataset.offset(offset).get(:id)
 
-              assert_equal_results dataset.offset(offset).limit(100),
-                                   dataset.seek_paginate(100, from_pk: id)
+              assert_equal_results dataset.offset(offset),
+                                   dataset.seek(pk: id, include_exact_match: true)
 
-              assert_equal_results dataset.offset(offset + 1).limit(100),
-                                   dataset.seek_paginate(100, after_pk: id)
+              assert_equal_results dataset.offset(offset + 1),
+                                   dataset.seek(pk: id)
             end
           end
         end
@@ -84,14 +79,14 @@ class SeekPaginationSpec < Minitest::Spec
 
   describe "for ordering by a single not-null column in either order" do
     [Sequel.asc(:id), Sequel.desc(:id)].each do |o1|
-      it_should_seek_paginate_properly [o1]
+      it_should_seek_properly [o1]
     end
   end
 
   describe "for ordering by two not-null columns in any order" do
     [Sequel.asc(:not_nullable_1), Sequel.desc(:not_nullable_1)].each do |o1|
       [Sequel.asc(:id), Sequel.desc(:id)].each do |o2|
-        it_should_seek_paginate_properly [o1, o2]
+        it_should_seek_properly [o1, o2]
       end
     end
   end
@@ -100,7 +95,7 @@ class SeekPaginationSpec < Minitest::Spec
     [Sequel.asc(:not_nullable_1), Sequel.desc(:not_nullable_1)].each do |o1|
       [Sequel.asc(:not_nullable_2), Sequel.desc(:not_nullable_2)].each do |o2|
         [Sequel.asc(:id), Sequel.desc(:id)].each do |o3|
-          it_should_seek_paginate_properly [o1, o2, o3]
+          it_should_seek_properly [o1, o2, o3]
         end
       end
     end
@@ -110,7 +105,7 @@ class SeekPaginationSpec < Minitest::Spec
     # We still tack on :id because the ordering needs to be unique.
     [Sequel.asc(:nullable_1), Sequel.desc(:nullable_1), Sequel.asc(:nullable_1, nulls: :first), Sequel.desc(:nullable_1, nulls: :last)].each do |o1|
       [Sequel.asc(:id), Sequel.desc(:id)].each do |o2|
-        it_should_seek_paginate_properly [o1, o2]
+        it_should_seek_properly [o1, o2]
       end
     end
   end
@@ -120,7 +115,7 @@ class SeekPaginationSpec < Minitest::Spec
     [Sequel.asc(:nullable_1), Sequel.desc(:nullable_1), Sequel.asc(:nullable_1, nulls: :first), Sequel.desc(:nullable_1, nulls: :last)].each do |o1|
       [Sequel.asc(:nullable_2), Sequel.desc(:nullable_2), Sequel.asc(:nullable_2, nulls: :first), Sequel.desc(:nullable_2, nulls: :last)].each do |o2|
         [Sequel.asc(:id), Sequel.desc(:id)].each do |o3|
-          it_should_seek_paginate_properly [o1, o2, o3]
+          it_should_seek_properly [o1, o2, o3]
         end
       end
     end
@@ -138,7 +133,7 @@ class SeekPaginationSpec < Minitest::Spec
       testing_columns = columns.sample(rand(columns.count) + 1).map(&:sample)
       testing_columns << [:id, Sequel.asc(:id), Sequel.desc(:id)].sample
 
-      it_should_seek_paginate_properly(testing_columns)
+      it_should_seek_properly(testing_columns)
     end
   end
 
@@ -154,7 +149,7 @@ class SeekPaginationSpec < Minitest::Spec
       testing_columns = columns.sample(rand(columns.count) + 1).map(&:sample)
       testing_columns << [:id, Sequel.asc(:id), Sequel.desc(:id)].sample
 
-      it_should_seek_paginate_properly(testing_columns)
+      it_should_seek_properly(testing_columns)
     end
   end
 
@@ -172,49 +167,41 @@ class SeekPaginationSpec < Minitest::Spec
     id = DB[:seek].order(:id).offset(56).get(:id)
 
     datasets.each do |dataset|
-      assert_equal_results DB[:seek].order(:id).limit(5),
-                           dataset.seek_paginate(5)
-
       assert_equal_results DB[:seek].order(:id).offset(56).limit(5),
-                           dataset.seek_paginate(5, from: id)
+                           dataset.limit(5).seek(value: id, include_exact_match: true)
 
       assert_equal_results DB[:seek].order(:id).offset(57).limit(5),
-                           dataset.seek_paginate(5, after: id)
+                           dataset.limit(5).seek(value: id)
     end
   end
 
   it "should raise an error if the dataset is not ordered" do
-    assert_error_message("cannot seek_paginate on a dataset with no order") { DB[:seek].seek_paginate(30) }
+    assert_error_message("cannot call #seek on a dataset with no order") { DB[:seek].seek(value: 3) }
   end
 
-  it "should raise an error if more than one location argument is passed to seek_paginate" do
-    assert_error_message("cannot pass more than one of the :from, :after, :from_pk and :after_pk arguments to seek_paginate") { DB[:seek].order(:id).seek_paginate(30, from: 3, after: 4) }
-    assert_error_message("cannot pass more than one of the :from, :after, :from_pk and :after_pk arguments to seek_paginate") { DB[:seek].order(:id).seek_paginate(30, from_pk: 3, after_pk: 4) }
-    assert_error_message("cannot pass more than one of the :from, :after, :from_pk and :after_pk arguments to seek_paginate") { DB[:seek].order(:id).seek_paginate(30, from: 3, after_pk: 4) }
-    assert_error_message("cannot pass more than one of the :from, :after, :from_pk and :after_pk arguments to seek_paginate") { DB[:seek].order(:id).seek_paginate(30, from_pk: 3, after: 4) }
+  it "should raise an error unless exactly one of :value and :pk is passed" do
+    assert_error_message("must pass exactly one of :value and :pk to #seek") { DB[:seek].seek }
+    assert_error_message("must pass exactly one of :value and :pk to #seek") { DB[:seek].seek(value: 3, pk: 3) }
   end
 
-  it "should raise an error if given the wrong number of values to from or after" do
-    assert_error_message("passed the wrong number of values in the :from option to seek_paginate")  { DB[:seek].order(:id, :nullable_1).seek_paginate(30, from:  [3]) }
-    assert_error_message("passed the wrong number of values in the :after option to seek_paginate") { DB[:seek].order(:id, :nullable_1).seek_paginate(30, after: [3]) }
-    assert_error_message("passed the wrong number of values in the :from option to seek_paginate")  { DB[:seek].order(:id, :nullable_1).seek_paginate(30, from:  [3, 4, 5]) }
-    assert_error_message("passed the wrong number of values in the :after option to seek_paginate") { DB[:seek].order(:id, :nullable_1).seek_paginate(30, after: [3, 4, 5]) }
+  it "should raise an error if given the wrong number of values" do
+    assert_error_message("passed the wrong number of values to #seek") { DB[:seek].order(:id, :nullable_1).seek(value: 3) }
+    assert_error_message("passed the wrong number of values to #seek") { DB[:seek].order(:id, :nullable_1).seek(value: [3]) }
+    assert_error_message("passed the wrong number of values to #seek") { DB[:seek].order(:id, :nullable_1).seek(value: [3, 4, 5]) }
   end
 
   it "should raise an error if from_pk or after_pk are passed to a dataset without an associated model" do
-    assert_error_message("passed the :from_pk option to seek_paginate on a dataset that doesn't have an associated model") { DB[:seek].order(:id, :nullable_1).seek_paginate(30, from_pk: 3) }
-    assert_error_message("passed the :after_pk option to seek_paginate on a dataset that doesn't have an associated model") { DB[:seek].order(:id, :nullable_1).seek_paginate(30, after_pk: 3) }
+    assert_error_message("attempted a primary key lookup on a dataset that doesn't have an associated model") { DB[:seek].order(:id, :nullable_1).seek(pk: 3) }
   end
 
   describe "when chained from a model" do
     it "should be able to determine from the schema what columns are not null" do
       assert_equal %(SELECT * FROM "seek" WHERE (("not_nullable_1", "not_nullable_2", "id") > (1, 2, 3)) ORDER BY "not_nullable_1", "not_nullable_2", "id" LIMIT 5),
-        SeekModel.order(:not_nullable_1, :not_nullable_2, :id).seek_paginate(5, after: [1, 2, 3]).sql
+        SeekModel.order(:not_nullable_1, :not_nullable_2, :id).seek(value: [1, 2, 3]).limit(5).sql
     end
 
     it "should raise an error when passed a pk for a record that doesn't exist in the dataset" do
-      assert_raises(Sequel::NoMatchingRow) { SeekModel.order(:id).seek_paginate(5, after_pk: -45) }
-      assert_raises(Sequel::NoMatchingRow) { SeekModel.order(:id).seek_paginate(5, from_pk:  -45) }
+      assert_raises(Sequel::NoMatchingRow) { SeekModel.order(:id).seek(pk: -45) }
     end
   end
 end

data/tasks/benchmark.rb

@@ -37,17 +37,17 @@ task :benchmark do
   DB.add_index :seek, [:non_nullable_1]
 
   {
-    "1 column, not-null, ascending, no not-null information"  => DB[:seek].order(:id.asc ).seek_paginate(30, after: rand(RECORD_COUNT) + 1),
-    "1 column, not-null, descending, no not-null information" => DB[:seek].order(:id.desc).seek_paginate(30, after: rand(RECORD_COUNT) + 1),
+    "1 column, not-null, ascending, no not-null information"  => DB[:seek].limit(30).order(:id.asc ).seek(value: rand(RECORD_COUNT) + 1),
+    "1 column, not-null, descending, no not-null information" => DB[:seek].limit(30).order(:id.desc).seek(value: rand(RECORD_COUNT) + 1),
 
-    "1 column, not-null, ascending, with not-null information"  => DB[:seek].order(:id.asc ).seek_paginate(30, after: rand(RECORD_COUNT) + 1, not_null: [:id, :not_nullable_1, :not_nullable_2]),
-    "1 column, not-null, descending, with not-null information" => DB[:seek].order(:id.desc).seek_paginate(30, after: rand(RECORD_COUNT) + 1, not_null: [:id, :not_nullable_1, :not_nullable_2]),
+    "1 column, not-null, ascending, with not-null information"  => DB[:seek].limit(30).order(:id.asc ).seek(value: rand(RECORD_COUNT) + 1, not_null: [:id, :not_nullable_1, :not_nullable_2]),
+    "1 column, not-null, descending, with not-null information" => DB[:seek].limit(30).order(:id.desc).seek(value: rand(RECORD_COUNT) + 1, not_null: [:id, :not_nullable_1, :not_nullable_2]),
 
-    "2 columns, not-null, ascending, no not-null information"  => DB[:seek].order(:non_nullable_1.asc,  :id.asc ).seek_paginate(30, after: [5, rand(RECORD_COUNT) + 1]),
-    "2 columns, not-null, descending, no not-null information" => DB[:seek].order(:non_nullable_1.desc, :id.desc).seek_paginate(30, after: [5, rand(RECORD_COUNT) + 1]),
+    "2 columns, not-null, ascending, no not-null information"  => DB[:seek].limit(30).order(:non_nullable_1.asc,  :id.asc ).seek(value: [5, rand(RECORD_COUNT) + 1]),
+    "2 columns, not-null, descending, no not-null information" => DB[:seek].limit(30).order(:non_nullable_1.desc, :id.desc).seek(value: [5, rand(RECORD_COUNT) + 1]),
 
-    "2 columns, not-null, ascending, with not-null information"  => DB[:seek].order(:non_nullable_1.asc,  :id.asc ).seek_paginate(30, after: [5, rand(RECORD_COUNT) + 1], not_null: [:id, :non_nullable_1, :non_nullable_2]),
-    "2 columns, not-null, descending, with not-null information" => DB[:seek].order(:non_nullable_1.desc, :id.desc).seek_paginate(30, after: [5, rand(RECORD_COUNT) + 1], not_null: [:id, :non_nullable_1, :non_nullable_2]),
+    "2 columns, not-null, ascending, with not-null information"  => DB[:seek].limit(30).order(:non_nullable_1.asc,  :id.asc ).seek(value: [5, rand(RECORD_COUNT) + 1], not_null: [:id, :non_nullable_1, :non_nullable_2]),
+    "2 columns, not-null, descending, with not-null information" => DB[:seek].limit(30).order(:non_nullable_1.desc, :id.desc).seek(value: [5, rand(RECORD_COUNT) + 1], not_null: [:id, :non_nullable_1, :non_nullable_2]),
   }.each do |description, ds|
     puts
     puts description + ':'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-seek-pagination
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-07 00:00:00.000000000 Z
+date: 2016-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Seek pagination for Sequel + PostgreSQL