randumb 0.4.0 → 0.6.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OTI0OTBlMWNhNTc3MWQxYzU5MDM0YzAwNmM5NWI3OTFmNzhlYzA0Nw==
-  data.tar.gz: !binary |-
-    YzNlMmUzYTA3ZDRmZDI4ZmE5YTIyMzFiMGNlMTA2ZDNiMjRjZDFjNQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OTkzMmIzZmQ1ZDg0YjhjYmFiODhhNDRhZWFkN2RkNzdjYTQ4NTE5ZDgzOTIx
-    NTY4NTk4YjVhOTZmMTFhNWJlZjM5Zjg0OGE3YzMyNmFmM2QwZDA1ZDRjYTY3
-    YTRmYzVkNjExY2UwMTc4MDBhZWFmZjFjNzkzYTgwMzI2MjQzYjM=
-  data.tar.gz: !binary |-
-    OWJjZjUzODMzOWY2MWYwZWU1YWQzZDAxMWNkOWYyM2E3ZTQyZTNmMmE4ODI4
-    ZjY4NjE5ZjBjMzkyNDFmZTFhZWJlMGQ4YWNlOTg2YjdiNzA3M2NmNzhhNGZj
-    ZDUzMTZjNjgwYTI3ZWYzNjE0MDdkMWNmNjNlOWY4MGQ0ZWU2ZWY=
+SHA256:
+  metadata.gz: 9fd0e54ae7de8a15766df8a33d65edd4a5d1eab2cb3ba36b27c6f9541ab39a72
+  data.tar.gz: ed1afd68fa829e7e236d92d44fda28439492b004eda2c8d45b11b1b85f8feee3
+SHA512:
+  metadata.gz: 7031236bbde306b4c508d019956514ebe0a9b93b037f0d2cc2a539ea694b55c33c05b6728cfaae952f663b2727f919b974a863ddc905b15c77e70ca99c149c91
+  data.tar.gz: 7431df3f579c21e3076507b85564375646db6e78135ac0420d399c62e50474bafe3a1d827bc1f174edb57f22c8a68dbbaf7eb6b8e656e845e23476dfbb4bc310

data/lib/randumb.rb

@@ -1,4 +1,5 @@
 require 'randumb/version'
+require 'randumb/syntax'
 require 'randumb/relation'
 
 # Mix it in

data/lib/randumb/relation.rb

@@ -9,47 +9,44 @@ module Randumb
 
       # If the max_items argument is omitted, one random entity will be returned.
       # If you provide the integer argument, you will get back an array of records.
-      def random(max_items = nil)
-        random_weighted(nil, max_items)
+      def random(max_items = nil, opts={})
+        ActiveSupport::Deprecation.warn "The random() method will be depricated in randumb 1.0 in favor of the order_by_rand scope."
+        relation = clone
+        return random_by_id_shuffle(max_items, opts) if is_randumb_postges_case?(relation)
+        scope = relation.order_by_rand(opts)
+
+        scope = scope.limit(max_items) if override_limit?(max_items, relation)
+
+        # return first record if method was called without parameters
+        max_items ? scope.to_a : scope.first
       end
 
       # If ranking_column is provided, that named column wil be multiplied
       # by a random number to determine probability of order. The ranking column must be numeric.
-      def random_weighted(ranking_column, max_items = nil)
+      def random_weighted(ranking_column, max_items = nil, opts={})
+        ActiveSupport::Deprecation.warn "The random_weighted() method will be depricated in randumb 1.0 in favor of the order_by_rand_weighted scope."
         relation = clone
-        return random_by_id_shuffle(max_items) if is_randumb_postges_case?(relation, ranking_column)
+        return random_by_id_shuffle(max_items, opts) if is_randumb_postges_case?(relation, ranking_column)
         raise_unless_valid_ranking_column(ranking_column)
-        # get clause for current db type
-        order_clause = random_order_clause(ranking_column)
 
-        the_scope = if ::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR < 2
-          # AR 3.0.0 support
-          relation.order(order_clause)
-        else
-          # keep prior orders and append random
-          all_orders = (relation.orders + [order_clause]).join(", ")
-          # override all previous orders
-          relation.reorder(all_orders) 
-        end
-        
+        scope = relation.order_by_rand_weighted(ranking_column, opts)
+
         # override the limit if they are requesting multiple records
-        if max_items && (!relation.limit_value || relation.limit_value > max_items)
-          the_scope = the_scope.limit(max_items)
-        end
+        scope = scope.limit(max_items) if override_limit?(max_items, relation)
 
         # return first record if method was called without parameters
-        max_items ? the_scope.to_a : the_scope.first
+        max_items ? scope.to_a : scope.first
       end
 
 
       # This was my first implementation, adding it as an option for people to use
       # and to fall back on for pesky DB one off situations...
       #    https://github.com/spilliton/randumb/issues/7
-      def random_by_id_shuffle(max_items = nil)
+      def random_by_id_shuffle(max_items = nil, opts={})
         return_first_record = max_items.nil? # see return switch at end
         max_items ||= 1
         relation = clone
-        ids = fetch_random_ids(relation, max_items)
+        ids = fetch_random_ids(relation, max_items, opts)
 
         # build new scope for final query
         the_scope = klass.includes(includes_values)
@@ -58,21 +55,54 @@ module Randumb
         the_scope = the_scope.select(select_values) unless select_values.empty?
 
         # get the records and shuffle since the order of the ids
-        # passed to find_all_by_id isn't retained in the result set
-        records = the_scope.find_all_by_id(ids).shuffle!
+        # passed to where() isn't retained in the result set
+        rng = random_number_generator(opts)
+        records = the_scope.where(:id => ids).to_a.shuffle!(:random => rng)
 
         # return first record if method was called without parameters
         return_first_record ? records.first : records
       end
 
+      def order_by_rand(opts = {})
+        if opts.is_a?(Hash)
+          build_order_scope(opts)
+        else
+          raise ArgumentError.new(
+            "order_by_rand() expects a hash of options.  If you need to limit "\
+            "results simply add a limit to your scope ex: Artist.order_by_rand.limit(1)"
+          )
+        end
+      end
+
+      def order_by_rand_weighted(ranking_column, opts={})
+        raise_unless_valid_ranking_column(ranking_column)
+        is_randumb_postges_case?(self, ranking_column)
+        build_order_scope(opts, ranking_column)
+      end
+
       private
 
+      def build_order_scope(options, ranking_column=nil)
+        opts = options.reverse_merge(connection: connection, table_name: table_name)
+
+        order_clause = if ranking_column
+          Randumb::Syntax.random_weighted_order_clause(ranking_column, opts)
+        else
+          Randumb::Syntax.random_order_clause(opts)
+        end
+
+        # keep prior orders and append random
+        all_orders = (arel.orders + [order_clause])
+        # override all previous orders
+        reorder(all_orders)
+      end
+
       # postgres won't let you do an order_by when also doing a distinct
       # let's just use the in-memory option in this case
-      def is_randumb_postges_case?(relation, ranking_column)
+      def is_randumb_postges_case?(relation, ranking_column=nil)
         if relation.respond_to?(:uniq_value) && relation.uniq_value && connection.adapter_name =~ /(postgres|postgis)/i
           if ranking_column
-            raise Exception, "random_weighted: not possible when using .uniq and the postgres/postgis db adapter"
+            raise Exception, "order_by_rand_weighted: not possible when using .uniq and the postgres/postgis db adapter"
           else
             return true
           end
@@ -88,36 +118,9 @@ module Randumb
         end
       end
 
-      # sligtly different for each DB
-      def random_syntax
-        if connection.adapter_name =~ /(sqlite|postgres|postgis)/i
-          "RANDOM()"
-        elsif connection.adapter_name =~ /mysql/i
-          "RAND()"
-        else
-          raise Exception, "ActiveRecord adapter: '#{connection.adapter_name}' not supported by randumb.  Send a pull request or open a ticket: https://github.com/spilliton/randumb"
-        end
-      end
-
-      # builds the order clause to be appended in where clause
-      def random_order_clause(ranking_column)
-        if ranking_column.nil?
-          random_syntax
-        else
-          if connection.adapter_name =~ /sqlite/i
-            # computer multiplication is faster than division I was once taught...so translate here
-            max_int = 9223372036854775807.0
-            multiplier = 1.0 / max_int
-            "(#{ranking_column} * ABS(#{random_syntax} * #{multiplier}) ) DESC"
-          else
-            "(#{ranking_column} * #{random_syntax}) DESC"
-          end
-        end
-      end
-
       # Returns all matching ids from the db, shuffles them,
       # then returns an array containing at most max_ids
-      def fetch_random_ids(relation, max_ids)
+      def fetch_random_ids(relation, max_ids, opts = {})
         # clear these for our id only query
         relation.select_values = []
         relation.includes_values = []
@@ -127,30 +130,54 @@ module Randumb
 
         id_results = connection.select_all(id_only_relation.to_sql)
 
+        rng = random_number_generator(opts)
         if max_ids == 1 && id_results.count > 0
-          [ id_results[ rand(id_results.count) ]['id'] ]
+          rand_index = rng.rand(id_results.count)
+          [id_results[rand_index]["id"]]
         else
-          # ActiveRecord 4 requires .to_ary
-          arr = id_results.respond_to?(:to_ary) ? id_results.to_ary : id_results
-          arr.shuffle![0,max_ids].collect!{ |h| h['id'] }
+          # ActiveRecord 4 requires .to_a
+          arr = id_results.respond_to?(:to_a) ? id_results.to_a : id_results
+          arr.shuffle!(random: rng)[0, max_ids].collect! { |h| h["id"] }
         end
       end
 
+      def random_number_generator(opts={})
+        if seed = opts[:seed]
+          Random.new(seed)
+        else
+          Random.new
+        end
+      end
+
+      def override_limit?(max_items, relation)
+        max_items && (!relation.limit_value || relation.limit_value > max_items)
+      end
+
     end
 
 
     # Class methods
+    # where(nil) is because:
+    # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
     module Base
-      def random(max_items = nil)
-        relation.random(max_items)
+      def random(max_items = nil, opts = {})
+        where(nil).random(max_items, opts)
+      end
+
+      def random_weighted(ranking_column, max_items = nil, opts = {})
+        where(nil).random_weighted(ranking_column, max_items, opts)
+      end
+
+      def random_by_id_shuffle(max_items = nil, opts = {})
+        where(nil).random_by_id_shuffle(max_items, opts)
       end
 
-      def random_weighted(ranking_column, max_items = nil)
-        relation.random_weighted(ranking_column, max_items)
+      def order_by_rand(opts = {})
+        where(nil).order_by_rand(opts)
       end
 
-      def random_by_id_shuffle(max_items = nil)
-        relation.random_by_id_shuffle(max_items)
+      def order_by_rand_weighted(ranking_column, opts={})
+        where(nil).order_by_rand_weighted(ranking_column, opts)
       end
     end
 
@@ -159,6 +186,7 @@ module Randumb
     module MethodMissingMagicks
       def method_missing(symbol, *args)
         if symbol.to_s =~ /^random_weighted_by_(\w+)$/
+          ActiveSupport::Deprecation.warn "Dynamic finders will be removed in randumb 1.0 http://guides.rubyonrails.org/active_record_querying.html#dynamic-finders"
           random_weighted($1, *args)
         else
           super
@@ -167,6 +195,7 @@ module Randumb
 
       def respond_to?(symbol, include_private=false)
         if symbol.to_s =~ /^random_weighted_by_(\w+)$/
+          ActiveSupport::Deprecation.warn "Dynamic finders will be removed in randumb 1.0 http://guides.rubyonrails.org/active_record_querying.html#dynamic-finders"
           true
         else
           super

data/lib/randumb/syntax.rb

@@ -0,0 +1,82 @@
+module Randumb
+  class Syntax
+    class << self
+
+      # builds the order clause to be appended in where clause
+      def random_order_clause(opts={})
+        random_for(opts)
+      end
+
+      # builds the order clause to be appended in where clause
+      def random_weighted_order_clause(ranking_column, opts={})
+        connection = opts[:connection]
+
+        if connection.adapter_name =~ /sqlite/i
+          # computer multiplication is faster than division I was once taught...so translate here
+          max_int = 9223372036854775807.0
+          multiplier = 1.0 / max_int
+          "(#{ranking_column} * ABS(#{random_for(opts)} * #{multiplier}) ) DESC"
+        else
+          "(#{ranking_column} * #{random_for(opts)}) DESC"
+        end
+      end
+
+      private
+
+      # sligtly different for each DB
+      def random_for(opts)
+        connection = opts[:connection]
+        adapter_name = connection.adapter_name
+        if adapter_name =~ /(sqlite)/i
+          random_for_sqlite(opts)
+        elsif adapter_name =~ /(postgres|postgis)/i
+          random_for_postgres(opts)
+        elsif adapter_name =~ /mysql/i
+          random_for_mysql(opts)
+        else
+          raise Exception, "ActiveRecord adapter: '#{adapter_name}' not supported by randumb.  Send a pull request or open a ticket: https://github.com/spilliton/randumb"
+        end
+      end
+
+      def random_for_sqlite(opts)
+        if seed = opts[:seed]
+          table_name = opts[:table_name]
+          # SQLLite does not support a random seed.  However, pseudo-randomness
+          # can be achieved by sorting on a hash of the id field (generated by
+          # multiplying the id by the random seed and ignoring everything before
+          # the decimal).
+          # See http://stackoverflow.com/questions/2171578/seeding-sqlite-random
+          seed_value = Random.new(seed.to_i).rand
+          "(SUBSTR(#{table_name}.id * #{seed_value}, LENGTH(#{table_name}.id) + 2))"
+        else
+          "RANDOM()"
+        end
+      end
+
+      def random_for_postgres(opts)
+        # Postgres random seeding requires executing an extra "SELECT SETSEED(value)" on the connection.
+        # See http://www.postgresql.org/docs/8.3/static/sql-set.html:
+        #
+        #     Sets the internal seed for the random number generator (the
+        #     function random). Allowed values are floating-point numbers
+        #     between 0 and 1, which are then multiplied by 2^(31)-1.
+        #
+        if seed = opts[:seed]
+          connection = opts[:connection]
+          seed_value = Random.new(seed.to_i).rand # map integer seed to a value: 0 <= value < 1
+          connection.execute "SELECT SETSEED(#{seed_value})"
+        end
+        "RANDOM()"
+      end
+
+      def random_for_mysql(opts)
+        if seed = opts[:seed]
+          "RAND(#{seed.to_i})"
+        else
+          "RAND()"
+        end
+      end
+
+    end
+  end
+end

data/lib/randumb/version.rb

@@ -1,3 +1,3 @@
 module Randumb
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/test/models/artist.rb

@@ -1,5 +1,11 @@
 class Artist < ActiveRecord::Base
   has_many :albums
-  
+
+  if Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("3.2")
+    default_scope { where("artists.deleted_at IS NULL") }
+  else
+    default_scope where("artists.deleted_at IS NULL")
+  end
+
   scope :at_least_three_views, -> { where("views >= 3") }
-end
+end

data/test/models/factories.rb

@@ -1,4 +1,4 @@
-FactoryGirl.define do
+FactoryBot.define do
   factory :artist do
     name { Faker::Lorem.words(3).join(' ') }
     views  { Random.rand(50) }

data/test/randumb_test.rb

@@ -1,13 +1,17 @@
 $:.unshift '.'; require File.dirname(__FILE__) + '/test_helper'
 
-class RandumbTest < Test::Unit::TestCase
-
-  def assert_equal_for_both_methods(expected, obj, params = nil)
-    assert_equal expected, obj.send(:random, params), "when calling random"
-    assert_equal expected, obj.send(:random_by_id_shuffle, params), "when calling random_by_id_shuffle"
+class RandumbTest < Minitest::Test
+
+  def assert_equal_for_both_methods(expected, obj, *params)
+    if expected.nil?
+      assert_nil obj.send(:random, *params), "when calling random"
+      assert_nil obj.send(:random_by_id_shuffle, *params), "when calling random_by_id_shuffle"
+    else
+      assert_equal expected, obj.send(:random, *params), "when calling random"
+      assert_equal expected, obj.send(:random_by_id_shuffle, *params), "when calling random_by_id_shuffle"
+    end
   end
 
-
   should "should return empty when no record in table" do
     assert_equal 0, Artist.count
 
@@ -15,36 +19,56 @@ class RandumbTest < Test::Unit::TestCase
     # above is equivalent to:
     # assert_equal nil, Artist.random
     # assert_equal nil, Artist.random_by_id_shuffle
+    assert_nil Artist.order_by_rand.first
 
     assert_equal_for_both_methods [], Artist, 1
     # above is equivalent to:
     # assert_equal [], Artist.random(1)
     # assert_equal [], Artist.random_by_id_shuffle(1)
+    assert_equal [], Artist.order_by_rand.limit(1).all
 
     assert_equal_for_both_methods nil, Artist.limit(50)
   end
 
+  should "raise helpful error if non-hash passed" do
+    error = assert_raises ArgumentError do
+      Artist.order_by_rand(10)
+    end
+    assert error.message.include?("order_by_rand")
+  end
+
   context "1 record in the table" do
     setup do
-      @high_on_fire = FactoryGirl.create(:artist, :name => "High On Fire", :views => 1)
+      @high_on_fire = FactoryBot.create(:artist, :name => "High On Fire", :views => 1)
     end
 
     should "select only 1 record even when you request more" do
       assert_equal 1, Artist.count
 
       assert_equal_for_both_methods @high_on_fire, Artist
+      assert_equal @high_on_fire, Artist.order_by_rand.first
+
       assert_equal_for_both_methods [@high_on_fire], Artist, 1
       assert_equal_for_both_methods [@high_on_fire], Artist, 30
+      assert_equal [@high_on_fire], Artist.limit(30).order_by_rand.all
     end
 
     should "not return a record that doesnt match where" do
       assert_equal_for_both_methods nil, Artist.where(:name => "The Little Gentlemen")
     end
 
+    should "respect default scope" do
+      @high_on_fire.deleted_at = Time.now.utc
+      @high_on_fire.save!
+      assert_equal 0, Artist.count
+      assert_nil Artist.order_by_rand.first
+      assert_equal @high_on_fire, Artist.unscoped.order_by_rand.first
+    end
+
     context "3 records in table" do
       setup do
-        @fiona_apple = FactoryGirl.create(:artist, :name => "Fiona Apple", :views => 3)
-        @magnetic_fields = FactoryGirl.create(:artist, :name => "The Magnetic Fields", :views => 2)
+        @fiona_apple = FactoryBot.create(:artist, :name => "Fiona Apple", :views => 3)
+        @magnetic_fields = FactoryBot.create(:artist, :name => "The Magnetic Fields", :views => 2)
       end
 
       should "apply randomness after other orders when using sql method" do
@@ -61,19 +85,27 @@ class RandumbTest < Test::Unit::TestCase
       end
 
       should "respect selecting certain columns" do
+        # this version doesn't throw for some reason...
+        skip_throw_missing = ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+
         assert_equal 3, Artist.find(@fiona_apple.id).views
 
         artists = Artist.select(:name).random(3)
         assert_equal false, artists.first.name.nil?
-        assert_raise (ActiveModel::MissingAttributeError) {artists.first.views}
+        assert_raises (ActiveModel::MissingAttributeError) { artists.first.views } unless skip_throw_missing
+
+        artists = Artist.select(:name).order_by_rand.limit(3)
+        assert_equal false, artists.first.name.nil?
+        assert_raises (ActiveModel::MissingAttributeError) { artists.first.views } unless skip_throw_missing
 
         artists = Artist.select(:name).random_by_id_shuffle(3)
         assert_equal false, artists.first.name.nil?
-        assert_raise (ActiveModel::MissingAttributeError) {artists.first.views}
+        assert_raises (ActiveModel::MissingAttributeError) { artists.first.views } unless skip_throw_missing
       end
 
       should "respect scopes" do
         assert_equal_for_both_methods [@fiona_apple], Artist.at_least_three_views, 3
+        assert_equal [@fiona_apple], Artist.at_least_three_views.order_by_rand.limit(3)
       end
 
       should "select only as many as in the db if we request more" do
@@ -92,10 +124,10 @@ class RandumbTest < Test::Unit::TestCase
 
       context "with some albums" do
         setup do
-          @tidal = FactoryGirl.create(:album, :name => "Tidal", :artist => @fiona_apple)
-          @extraordinary_machine = FactoryGirl.create(:album, :name => "Extraordinary Machine", :artist => @fiona_apple)
-          @sixty_nine_love_songs = FactoryGirl.create(:album, :name => "69 Love Songs", :artist => @magnetic_fields)
-          @snakes_for_the_divine = FactoryGirl.create(:album, :name => "Snakes For the Divine", :artist => @high_on_fire)
+          @tidal = FactoryBot.create(:album, :name => "Tidal", :artist => @fiona_apple)
+          @extraordinary_machine = FactoryBot.create(:album, :name => "Extraordinary Machine", :artist => @fiona_apple)
+          @sixty_nine_love_songs = FactoryBot.create(:album, :name => "69 Love Songs", :artist => @magnetic_fields)
+          @snakes_for_the_divine = FactoryBot.create(:album, :name => "Snakes For the Divine", :artist => @high_on_fire)
         end
 
 
@@ -103,7 +135,7 @@ class RandumbTest < Test::Unit::TestCase
           artists = Artist.includes(:albums).random(10)
           fiona_apple = artists.find { |a| a.name == "Fiona Apple" }
           # if I add a new album now, it shouldn't be in the albums assocation yet b/c it was already loaded
-          FactoryGirl.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
+          FactoryBot.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
 
           assert_equal 2, fiona_apple.albums.length
           assert_equal 3, @fiona_apple.reload.albums.length
@@ -113,7 +145,7 @@ class RandumbTest < Test::Unit::TestCase
           artists = Artist.includes(:albums).random_by_id_shuffle(10)
           fiona_apple = artists.find { |a| a.name == "Fiona Apple" }
           # if I add a new album now, it shouldn't be in the albums assocation yet b/c it was already loaded
-          FactoryGirl.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
+          FactoryBot.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
 
           assert_equal 2, fiona_apple.albums.length
           assert_equal 3, @fiona_apple.reload.albums.length
@@ -144,8 +176,8 @@ class RandumbTest < Test::Unit::TestCase
           should "work with uniq" do
             assert_equal 2, Artist.uniq.random(2).length
             assert_equal 2, Artist.uniq.random_by_id_shuffle(2).length
-            assert_not_nil Artist.uniq.random
-            assert_not_nil Artist.uniq.random_by_id_shuffle
+            assert !Artist.uniq.random.nil?
+            assert !Artist.uniq.random_by_id_shuffle.nil?
           end
         end
 
@@ -157,8 +189,8 @@ class RandumbTest < Test::Unit::TestCase
 
   context "2 records in table" do
     setup do
-      @hum = FactoryGirl.create(:artist, :name => "Hum", :views => 3)
-      @minutemen = FactoryGirl.create(:artist, :name => "Minutemen", :views => 2)
+      @hum = FactoryBot.create(:artist, :name => "Hum", :views => 3)
+      @minutemen = FactoryBot.create(:artist, :name => "Minutemen", :views => 2)
     end
 
     should "eventually render the 2 possible orders using default method" do
@@ -190,6 +222,29 @@ class RandumbTest < Test::Unit::TestCase
       assert order1_found
       assert order2_found
     end
-  end
 
+    context "using seed" do
+      setup do
+        @seed = 123
+      end
+
+      should "always return the same order using default method" do
+        seeded_order = Artist.random(2, seed: @seed)
+        10.times do
+          assert_equal seeded_order, Artist.random(2, seed: @seed)
+        end
+
+        10.times do
+          assert_equal seeded_order, Artist.order_by_rand(seed: @seed).limit(2)
+        end
+      end
+
+      should "always return the same order using shuffle method" do
+        seeded_order = Artist.random_by_id_shuffle(2, seed: @seed)
+        10.times do
+          assert_equal seeded_order, Artist.random_by_id_shuffle(2, seed: @seed)
+        end
+      end
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,33 +1,29 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'rubygems'
-require 'test/unit'
+require "minitest/autorun"
 require 'shoulda'
-require 'factory_girl'
+require 'factory_bot'
 require 'faker'
 require 'active_record'
 require 'active_support/dependencies'
-require 'active_support/core_ext/logger'
-# require 'active_record/fixtures'
 require 'randumb'
 
 MODELS_PATH = File.join(File.dirname(__FILE__), 'models')
 
-
-ActiveRecord::Base.logger = Logger.new(STDERR)
-ActiveRecord::Base.logger.level = Logger::WARN
-
 config = YAML::load(File.open(File.expand_path("../databases.yml", __FILE__)))
 version = ActiveRecord::VERSION::STRING
 driver = (ENV["DB"] or "sqlite3").downcase
 in_memory = config[driver]["database"] == ":memory:"
-    
+
 # http://about.travis-ci.org/docs/user/database-setup/
 commands = {
   "mysql"    => "mysql -e 'create database randumb_test;'",
   "postgres" => "psql -c 'create database randumb_test;' -U postgres"
 }
 %x{#{commands[driver] || true}}
-    
+
+
+
 ActiveRecord::Base.establish_connection config[driver]
 puts "Using #{RUBY_VERSION} AR #{version} with #{driver}"
 
@@ -38,16 +34,18 @@ ActiveRecord::Base.connection.create_table(:artists, :force => true) do |t|
   t.float    "rating"
   t.datetime "created_at"
   t.datetime "updated_at"
+  t.datetime "deleted_at"
 end
-  
+
 ActiveRecord::Base.connection.create_table(:albums, :force => true) do |t|
   t.string  "name"
   t.integer "views"
   t.integer "artist_id"
   t.datetime "created_at"
   t.datetime "updated_at"
+  t.datetime "deleted_at"
 end
-  
+
 # setup models for lazy load
 dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
 dep.autoload_paths.unshift MODELS_PATH
@@ -56,7 +54,7 @@ dep.autoload_paths.unshift MODELS_PATH
 require 'test/models/factories'
 
 # clear db for every test
-class Test::Unit::TestCase
+class Minitest::Test
 
   def setup
     Artist.delete_all
@@ -65,3 +63,6 @@ class Test::Unit::TestCase
 
 end
 
+
+# Silence deprications
+ActiveSupport::Deprecation.silenced = true

data/test/weighted_test.rb

@@ -1,10 +1,10 @@
 $:.unshift '.'; require File.dirname(__FILE__) + '/test_helper'
 
-class WeightedTest < Test::Unit::TestCase
+class WeightedTest < Minitest::Test
 
   should "raise exception when called with a non-existent column" do
     assert_raises(ArgumentError) do
-      Artist.random_weighted(:blah)
+      Artist.order_by_rand_weighted(:blah)
     end
     assert_raises(ArgumentError) do
       Artist.random_weighted_by_blah
@@ -13,7 +13,7 @@ class WeightedTest < Test::Unit::TestCase
 
   should "raise exception when called with a non-numeric column" do
     assert_raises(ArgumentError) do
-      Artist.random_weighted(:name)
+      Artist.order_by_rand_weighted(:name)
     end
     assert_raises(ArgumentError) do
       Artist.random_weighted_by_name
@@ -25,7 +25,7 @@ class WeightedTest < Test::Unit::TestCase
     if ENV["DB"] == "postgres"
       should "raise exception if being called with uniq/postgres" do
         assert_raises(Exception) do
-          Artist.uniq.random_weighted(:name)
+          Artist.uniq.order_by_rand_weighted(:views)
         end
       end
     else
@@ -41,7 +41,7 @@ class WeightedTest < Test::Unit::TestCase
   end
 
   should "not interfere with active record dynamic methods that use method_missing" do
-    @artist = FactoryGirl.create(:artist, :name => 'Spiritualized')
+    @artist = FactoryBot.create(:artist, :name => 'Spiritualized')
     assert_equal @artist, Artist.find_by_name('Spiritualized')
   end
 
@@ -59,13 +59,26 @@ class WeightedTest < Test::Unit::TestCase
   context "order by ranking_column" do
     setup do
       @view_counts = [1, 2, 3, 4, 5]
-      @view_counts.each { |views| FactoryGirl.create(:artist, :views => views) }
+      @view_counts.each { |views| FactoryBot.create(:artist, views: views) }
+    end
+
+    should "respect default scope" do
+      artist = Artist.last
+      artist.deleted_at = Time.now.utc
+      artist.save!
+      50.times do
+        assert Artist.random_weighted("views").id != artist.id, "should never pick deleted artist"
+      end
+      assert_equal 4, Artist.order_by_rand_weighted("views").all.length
     end
 
     should "order by ranking column with explicit method call" do
       assert_hits_per_views do
         Artist.random_weighted("views").views
       end
+      assert_hits_per_views do
+        Artist.order_by_rand_weighted("views").first.views
+      end
     end
 
     should "order by ranking column with method_missing" do
@@ -80,6 +93,12 @@ class WeightedTest < Test::Unit::TestCase
         assert(result.size == 5)
         result.first.views
       end
+
+      assert_hits_per_views do
+        result = Artist.order_by_rand_weighted("views").limit(5).all
+        assert(result.size == 5)
+        result.first.views
+      end
     end
 
     should "order by ranking column with method_missing using max_items" do
@@ -98,31 +117,45 @@ class WeightedTest < Test::Unit::TestCase
           result.last.views
         end
       end
+
+      assert_raises(MiniTest::Assertion) do
+        assert_hits_per_views do
+          result = Artist.order_by_rand_weighted(:views).limit(3)
+          assert(result.size == 3)
+          result.last.views
+        end
+      end
     end
 
     should "order by ranking column with method_missing using 1 max_items" do
       assert_hits_per_views do
         result = Artist.random_weighted_by_views(1)
-        assert(result.size == 1)
+        assert_equal 1, result.length
         result.first.views
       end
-    end
 
-    def assert_hits_per_views
-      hits_per_views = Hash.new
-      @view_counts.each { |views| hits_per_views[views] = 0 }
-      
-      1000.times do
-        hits_per_views[yield] += 1
-      end
-      last_count = 0
-      @view_counts.each do |views|
-        hits = hits_per_views[views]
-        assert(hits >= last_count, "#{hits} > #{last_count} : There were an unexpected number of visits: #{hits_per_views.to_yaml}")
-        last_count = hits
+      assert_hits_per_views do
+        result = Artist.order_by_rand_weighted(:views).limit(1)
+        assert_equal 1, result.length
+        result.first.views
       end
     end
   end
 
+  def assert_hits_per_views
+    hits_per_views = Hash.new
+    @view_counts.each { |views| hits_per_views[views] = 0 }
+
+    1000.times do
+      hits_per_views[yield] += 1
+    end
+    last_count = 0
+    @view_counts.each do |views|
+      hits = hits_per_views[views]
+      assert(hits >= last_count, "#{hits} > #{last_count} : There were an unexpected number of visits: #{hits_per_views.to_yaml}")
+      last_count = hits
+    end
+  end
+
 
-end
+end

metadata

@@ -1,111 +1,181 @@
 --- !ruby/object:Gem::Specification
 name: randumb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Zachary Kloepping
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-20 00:00:00.000000000 Z
+date: 2020-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.20
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.20
 - !ruby/object:Gem::Dependency
   name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.7
+        version: 0.4.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.7
+        version: 0.4.10
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: factory_girl
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -114,9 +184,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/randumb.rb
 - lib/randumb/relation.rb
+- lib/randumb/syntax.rb
 - lib/randumb/version.rb
-- lib/randumb.rb
 - test/models/album.rb
 - test/models/artist.rb
 - test/models/factories.rb
@@ -133,17 +204,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.5
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Adds the ability to pull random records from ActiveRecord