Implement FNV hashing in the project (#14)

Implement FNV (Fowler–Noll–Vo) hashing in the project instead of pulling
in a separate gem. This normally wouldn't really be worth it, but the
algorithm is extremely simple to implement, and it is somewhat nice to
keep the gem so that it has no dependencies.

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Implement the FNV (Fowler–Noll–Vo) hashing algorithm in the project and drop dependency on the `fnv-hash` gem. [PR #14](https://github.com/riverqueue/riverqueue-ruby/pull/14).
+
 ## [0.3.0] - 2024-04-27
 
 ### Added

Gemfile.lock

@@ -2,7 +2,6 @@ PATH
   remote: .
   specs:
     riverqueue (0.3.0)
-      fnv-hash
 
 GEM
   remote: https://rubygems.org/
@@ -32,7 +31,6 @@ GEM
     drb (2.2.1)
     ffi (1.16.3)
     fileutils (1.7.2)
-    fnv-hash (0.2.0)
     i18n (1.14.4)
       concurrent-ruby (~> 1.0)
     io-console (0.7.2)

lib/client.rb

@@ -191,11 +191,11 @@ def insert_many(args)
 
       @driver.transaction do
         lock_key = if @advisory_lock_prefix.nil?
-          Fnv::Hash.fnv_1(lock_str, size: 64)
+          FNV.fnv1_hash(lock_str, size: 64)
         else
           # Steep should be able to tell that this is not nil, but it can't.
           prefix = @advisory_lock_prefix #: Integer # rubocop:disable Layout/LeadingCommentSpace
-          prefix << 32 | Fnv::Hash.fnv_1(lock_str, size: 32)
+          prefix << 32 | FNV.fnv1_hash(lock_str, size: 32)
         end
 
         # Packs a uint64 then unpacks to int64, which we need to do to keep the

lib/fnv.rb

@@ -0,0 +1,41 @@
+module River
+  # FNV is the Fowler–Noll–Vo hash function, a simple hash that's very easy to
+  # implement, and hash the perfect characteristics for use with the 64 bits of
+  # available space in a PG advisory lock.
+  #
+  # I'm implemented it myself so that the River gem can stay dependency free
+  # (and because it's quite easy to do).
+  module FNV
+    def self.fnv1_hash(str, size:)
+      hash = OFFSET_BASIS.fetch(size)
+      mask = MASK.fetch(size)
+      prime = PRIME.fetch(size)
+
+      str.each_byte do |byte|
+        hash *= prime
+        hash &= mask # take lower N bits of multiplication product
+        hash ^= byte
+      end
+
+      hash
+    end
+
+    MASK = {
+      32 => 0xffffffff, # mask 32 bits long
+      64 => 0xffffffffffffffff # mask 64 bits long
+    }.freeze
+    private_constant :MASK
+
+    OFFSET_BASIS = {
+      32 => 0x811c9dc5,
+      64 => 0xcbf29ce484222325
+    }.freeze
+    private_constant :OFFSET_BASIS
+
+    PRIME = {
+      32 => 0x01000193,
+      64 => 0x00000100000001B3
+    }.freeze
+    private_constant :PRIME
+  end
+end

lib/riverqueue.rb

@@ -1,5 +1,6 @@
 require "json"
 
+require_relative "fnv"
 require_relative "insert_opts"
 require_relative "job"
 

riverqueue.gemspec

@@ -14,6 +14,4 @@ Gem::Specification.new do |s|
     "rubygems_mfa_required" => "true",
     "source_code_uri" => "https://github.com/riverqueue/riverqueue-ruby"
   }
-
-  s.add_dependency "fnv-hash"
 end

sig/fnv.rbs

@@ -0,0 +1,9 @@
+module River
+  module FNV
+    def self.fnv1_hash: (String, size: 32 | 64) -> Integer
+
+    MASK: Hash[Integer, Integer]
+    OFFSET_BASIS: Hash[Integer, Integer]
+    PRIME: Hash[Integer, Integer]
+  end
+end

spec/client_spec.rb

@@ -222,7 +222,7 @@ def check_bigint_bounds(int)
         lock_str = "unique_keykind=#{job_args.kind}" \
           "&queue=#{River::QUEUE_DEFAULT}" \
           "&state=#{River::Client.const_get(:DEFAULT_UNIQUE_STATES).join(",")}"
-        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, Fnv::Hash.fnv_1(lock_str, size: 64)))])
+        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, River::FNV.fnv1_hash(lock_str, size: 64)))])
       end
 
       it "inserts a new unique job with all options" do
@@ -245,7 +245,7 @@ def check_bigint_bounds(int)
           "&period=#{client.send(:truncate_time, now, 15 * 60).utc.strftime("%FT%TZ")}" \
           "&queue=#{River::QUEUE_DEFAULT}" \
           "&state=#{[River::JOB_STATE_AVAILABLE].join(",")}"
-        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, Fnv::Hash.fnv_1(lock_str, size: 64)))])
+        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, River::FNV.fnv1_hash(lock_str, size: 64)))])
       end
 
       it "inserts a new unique job with advisory lock prefix" do
@@ -265,7 +265,7 @@ def check_bigint_bounds(int)
         lock_str = "unique_keykind=#{job_args.kind}" \
           "&queue=#{River::QUEUE_DEFAULT}" \
           "&state=#{River::Client.const_get(:DEFAULT_UNIQUE_STATES).join(",")}"
-        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, 123456 << 32 | Fnv::Hash.fnv_1(lock_str, size: 32)))])
+        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, 123456 << 32 | River::FNV.fnv1_hash(lock_str, size: 32)))])
 
         lock_key = mock_driver.advisory_lock_calls[0]
         expect(lock_key >> 32).to eq(123456)
@@ -300,7 +300,7 @@ def job_args_to_row(job_args, insert_opts: River::InsertOpts.new)
           "&period=#{client.send(:truncate_time, now, 15 * 60).utc.strftime("%FT%TZ")}" \
           "&queue=#{River::QUEUE_DEFAULT}" \
           "&state=#{[River::JOB_STATE_AVAILABLE].join(",")}"
-        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, Fnv::Hash.fnv_1(lock_str, size: 64)))])
+        expect(mock_driver.advisory_lock_calls).to eq([check_bigint_bounds(client.send(:uint64_to_int64, River::FNV.fnv1_hash(lock_str, size: 64)))])
       end
 
       it "skips unique check if unique opts empty" do