unique_by 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5403c00bf28bbe7858fa14d407bdbda99527de7e
-  data.tar.gz: e9e0dcd9a442febb74ffd046edda31edfc9f4f9d
+  metadata.gz: 3318e49786c29b9bc711ccd7cedf5b62b0795ddf
+  data.tar.gz: 33d06afb8219b74f89614b0bf30f2d2d1f65aadb
 SHA512:
-  metadata.gz: 2d4d75f32cde147d62e1c6e0a51580c0e4d339fa964d0675413562415ae58b49c650cf5752428d1d164d16e1576d88950b7d7e04d260ef0d2b6be16b8a9a1bce
-  data.tar.gz: ec47fa855292e7e207ada64eb92f54852c114578297a68adedf5895edb0b35d7f5b68171a6a2c94b1a894f77e70484e14af4ed5304d61dcb56b3e9cdf4dc1375
+  metadata.gz: 30fa8eeaf072a6b026a68a9b12868eb9d8069419f586b0521941756071cb7b9a5b4c940954ddfea4ef6dcf8ce57dcebe5253d8620e13aa8be35e83f1a165288f
+  data.tar.gz: 0b27d32f656175a51bd363f85f741bf8b3bf3e094b98db695d75c128170e57429d0cce02429c770a09322fc3504c59511efd4618b0253f6407b984dd6e5bb272

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+**3.0.0**
+* Calculate unique value by multiplying in exact total rather closest power of
+  2 (bitwise).
+
+  ***INCOMPATIBLE:*** when your totals are not powers of 2. If you already depend
+                      on previous values of this gem, change your values to the
+                      closest power of 2.
+
+For example:
+
+```ruby
+unique_by client_id: 500
+```
+
+Should be:
+
+```ruby
+unique_by client_id: 512
+```
+
+* Allow passing `:primary_key` explicitly.
+
+  *MINOR INCOMPATIBLE:* if your group was named `primary_key`.
+
+**2.1.0**
+* Remove useless finder methods, you should create your own based on the group.
+
+  *MINOR INCOMPATIBLE:* if you used the finder methods.
+* Using `generate_method` gem, which means generated methods are 'inherited'
+  instead of defined in the class itself.
+
+  *MINOR INCOMPATIBLE:* when expected to override your methods.
+
+**2.0.0**
+* *MINOR INCOMPATIBLE:* key-value arguments instead of totals/bits.
+
+**1.0.0**
+* First stable version.

data/README.md

@@ -56,7 +56,7 @@ bill2.unique_id
 => 7874
 ```
 
-You can use the internal methods:
+You can use the singleton methods:
 
 ```ruby
 MedicalBill.unique_id_from(123, client_id: 1) # gives the unique_id
@@ -96,22 +96,39 @@ You can supply a block to give a custom mechanism for determining the group:
 
 ```ruby
 class MedicalBill < ActiveRecord::Base
-  unique_by(type: 2) { { type: 1 } }
+  unique_by(type_index: 2) { { type_index: 0 } }
 end
 class UtilityBill < ActiveRecord::Base
-  unique_by(type: 2) { { type: 2 } }
+  unique_by(type_index: 2) { { type_index: 1 } }
 end
 ```
 
-You can supply both group attributes and a block, and the block can also
-return more than one field:
+Groups can also be served as a singleton method:
 
 ```ruby
 class MedicalBill < ActiveRecord::Base
-  unique_by(client_id: 50, client_part: 5, xy: 10, halfz: 20) do
-    { xy: self.x * self.y, halfz: self.z / 2 }
+  unique_by type_index: 2
+  def self.type_index
+    0
   end
 end
+class UtilityBill < ActiveRecord::Base
+  unique_by type_index: 2
+  def self.type_index
+    1
+  end
+end
+```
+
+In either case, if all the groups are specified as singleton methods or served
+within the block WITHOUT using the instance (`self`), you can use the singleton
+methods without explicitly specifying the groups for this class:
+
+```ruby
+MedicalBill.unique_id_from(123)
+=> 247
+UtilityBill.unique_id_from(123)
+=> 246
 ```
 
 It is recommended to create finder methods that will find records according to
@@ -121,14 +138,25 @@ their id group, like so:
 module Bill
   module_function
   def find_by_unique_id(unique_id)
-    case MedicalBill.id_group_from(unique_id)[:type]
-      when 1 then MedicalBill.find(MedicalBill.id_from(unique_id))
-      when 2 then UtilityBill.find(UtilityBill.id_from(unique_id))
+    case MedicalBill.id_group_from(unique_id)[:type_index]
+      when MedicalBill.type_index then MedicalBill.find(MedicalBill.id_from(unique_id))
+      when UtilityBill.type_index then UtilityBill.find(UtilityBill.id_from(unique_id))
     end
   end
 end
 ```
 
+You can supply both group attributes and a block, and the block can also
+return more than one field:
+
+```ruby
+class MedicalBill < ActiveRecord::Base
+  unique_by(client_id: 50, client_part: 5, xy: 10, halfz: 20) do
+    { xy: self.x * self.y, halfz: self.z / 2 }
+  end
+end
+```
+
 ## Not ActiveRecord
 
 The generator module is already included in `ActiveRecord::Base`, but if
@@ -138,6 +166,10 @@ you want the above methods in another class you can extend it:
 class MyClass
   extend UniqueBy::Generator
 
+  unique_by ..., primary_key: :id
+  #
+  # OR
+  #
   def self.primary_key
     :id # or 'id'
   end
@@ -152,7 +184,7 @@ fix that:
 
 ```ruby
 class MedicalBill < ActiveRecord::Base
-  unique_by client_id: 500
+  unique_by client_id: 32**2 # two base32 letters
   rebase_attr :unique_id, to: 32, readable: true # digits and leters, without '0', 'o', '1' and 'l'
 end
 

data/lib/unique_by.rb

@@ -12,60 +12,79 @@ module UniqueBy
     #   #unique_id => unique_id
     #   ::find_by_unique_id(unique_id) => find_by_id(id_from(unique_id))
     #   ::find_by_unique_id!(unique_id) => find_by_id!(id_from(unique_id))
-    def unique_by(**group_totals, &group_block)
+    def unique_by(primary_key: self.primary_key, **group_totals, &group_block)
       raise ArgumentError, "must pass a group definition (Hash of name => total)" if group_totals.empty?
       raise ArgumentError, "group definition must be a Hash of name => Fixnum, #{group_totals.inspect} given" unless group_totals.values.all? { |t| t.is_a?(Fixnum) }
 
-      bits = Hash[group_totals.map { |k, t| [k, Math.log2(t).ceil] }]
-      totals = Hash[bits.map { |k, b| [k, 2 ** b] }] # real total
+      generate_singleton_methods do
+        define_method :"#{primary_key}_group" do |**group|
+          raise ArgumentError, "unknown #{primary_key} group keys: #{group.keys - group_totals.keys}" if (group.keys - group_totals.keys).any?
+          next group if (group_totals.keys - group.keys).none?
 
-      pk = primary_key # converting to a local variable
+          group_from_block = group_block ? instance_eval(&group_block) : {}
+          raise TypeError, "#{primary_key} group block must return a Hash with any of the following keys: #{group_totals.keys}, #{group_from_block.inspect} given" unless group_from_block.is_a?(Hash)
+          raise ArgumentError, "unknown #{primary_key} group passed to block: #{group_from_block.keys - group_totals.keys}" if (group_from_block.keys - group_totals.keys).any?
+          group.update(group_from_block)
+          next group if (group_totals.keys - group.keys).none?
 
-      generate_singleton_methods do
-        define_method :"#{pk}_group_value_from" do |**group|
-          raise ArgumentError, "unknown #{pk} group keys: #{group.keys - group_totals.keys}" if (group.keys - group_totals.keys).any?
-          raise ArgumentError, "missing #{pk} group keys: #{group_totals.keys - group.keys}" if (group_totals.keys - group.keys).any?
+          group.update(Hash[(group_totals.keys - group.keys).map { |group_name| [group_name, send(group_name)] }])
+
+          group
+        end
+
+        define_method :"#{primary_key}_group_value_from" do |**group|
+          group = send(:"#{primary_key}_group", **group)
           group_totals.keys.reduce(0) do |group_value, group_name|
             g = group[group_name]
-            raise TypeError, "#{pk} group #{group_name} must not be nil" if g.nil?
-            raise TypeError, "#{pk} group #{group_name} must implement #to_i, #{g.inspect} given" unless g.respond_to?(:to_i)
-            (group_value << bits[group_name]) + (g.to_i % totals[group_name])
+            raise TypeError, "#{primary_key} group #{group_name} must not be nil" if g.nil?
+            raise TypeError, "#{primary_key} group #{group_name} must implement #to_i, #{g.inspect} given" unless g.respond_to?(:to_i)
+            (group_value * group_totals[group_name]) + (g.to_i % group_totals[group_name])
           end
         end
 
-        define_method :"unique_#{pk}_from" do |id, **group|
+        define_method :"unique_#{primary_key}_from" do |id, **group|
           break nil if id.nil?
-          raise TypeError, "#{pk} must implement #to_i, #{id.inspect} given" unless id.respond_to?(:to_i)
-          (id.to_i << bits.values.inject(&:+)) + send(:"#{pk}_group_value_from", **group)
+          raise TypeError, "#{primary_key} must implement #to_i, #{id.inspect} given" unless id.respond_to?(:to_i)
+          (id.to_i * group_totals.values.inject(&:*)) + send(:"#{primary_key}_group_value_from", **group)
         end
 
-        define_method :"#{pk}_from" do |unique_id|
+        define_method :"#{primary_key}_from" do |unique_id|
           break nil if unique_id.nil?
-          raise TypeError, "unique_#{pk} must implement #to_i, #{unique_id.inspect} given" unless unique_id.respond_to?(:to_i)
-          unique_id.to_i >> bits.values.inject(&:+)
+          raise TypeError, "unique_#{primary_key} must implement #to_i, #{unique_id.inspect} given" unless unique_id.respond_to?(:to_i)
+          unique_id.to_i / group_totals.values.inject(&:*)
         end
 
-        define_method :"#{pk}_group_from" do |unique_id|
+        define_method :"#{primary_key}_group_from" do |unique_id|
           break nil if unique_id.nil?
-          raise TypeError, "unique_#{pk} must implement #to_i, #{unique_id.inspect} given" unless unique_id.respond_to?(:to_i)
+          raise TypeError, "unique_#{primary_key} must implement #to_i, #{unique_id.inspect} given" unless unique_id.respond_to?(:to_i)
           Hash[group_totals.keys.reverse.map do |group_name|
-            g = unique_id & (totals[group_name] - 1)
-            unique_id >>= bits[group_name]
+            g = unique_id % group_totals[group_name]
+            unique_id /= group_totals[group_name]
             [group_name, g]
           end.reverse]
         end
       end
 
       generate_methods do
-        define_method :"#{pk}_group" do
+        define_method :"#{primary_key}_group" do
           group_from_block = group_block ? instance_eval(&group_block) : {}
-          raise TypeError, "#{pk} group block must return a Hash with any of the following keys: #{group_totals.keys}, #{group_from_block.inspect} given" unless group_from_block.is_a?(Hash)
-          raise ArgumentError, "unknown #{pk} group passed to block: #{group_from_block.keys - group_totals.keys}" if (group_from_block.keys - group_totals.keys).any?
-          Hash[(group_totals.keys - group_from_block.keys).map { |group_name| [group_name, send(group_name)] }].merge(group_from_block)
+          raise TypeError, "#{primary_key} group block must return a Hash with any of the following keys: #{group_totals.keys}, #{group_from_block.inspect} given" unless group_from_block.is_a?(Hash)
+          raise ArgumentError, "unknown #{primary_key} group passed to block: #{group_from_block.keys - group_totals.keys}" if (group_from_block.keys - group_totals.keys).any?
+          group = group_from_block.merge( # like reverse_merge, as we don't set keys that were in the block
+            Hash[
+              (group_totals.keys - group_from_block.keys).map do |group_name|
+                [
+                  group_name,
+                  (respond_to?(group_name) or not self.class.respond_to?(group_name)) ? send(group_name) : self.class.send(group_name) # would rather crash on instance method missing
+                ]
+              end
+            ]
+          )
+          group
         end
 
-        define_method :"unique_#{pk}" do
-          self.class.send(:"unique_#{pk}_from", send(pk), **send(:"#{pk}_group"))
+        define_method :"unique_#{primary_key}" do
+          self.class.send(:"unique_#{primary_key}_from", send(primary_key), **send(:"#{primary_key}_group"))
         end
       end
     end

data/lib/unique_by/version.rb

@@ -1,3 +1,3 @@
 module UniqueBy
-  VERSION = "2.1.0"
+  VERSION = "3.0.0"
 end

data/spec/unique_by_spec.rb

@@ -23,6 +23,31 @@ class ShardedTablesBase < Struct.new(:bill_id, :client_id, :x)
 end
 
 describe UniqueBy::Generator do
+  shared_examples_for "unique by" do |id:, group:, tempered_group:, group_value:, unique_id:|
+    describe "class methods" do
+      specify { expect(klass.bill_id_group_value_from(group)).to eq(group_value) }
+      specify { expect(klass.unique_bill_id_from(id, **group)).to eq(unique_id) }
+      specify { expect(klass.bill_id_from(unique_id)).to eq(id) }
+      specify { expect(klass.bill_id_group_from(unique_id)).to eq(tempered_group) }
+
+      context "nil id" do
+        specify { expect(klass.unique_bill_id_from(nil, client_id: 2)).to be_nil }
+        specify { expect(klass.bill_id_from(nil)).to be_nil }
+        specify { expect(klass.bill_id_group_from(nil)).to be_nil }
+      end
+    end
+
+    describe "instance methods" do
+      its(:bill_id_group) { should == group }
+      its(:unique_bill_id) { should == unique_id }
+
+      context "nil id" do
+        before { bill.bill_id = nil }
+        its(:unique_bill_id) { should be_nil }
+      end
+    end
+  end
+
   context "shards" do
     let(:klass) do
       Class.new(Struct.new(:bill_id, :client_id)) do
@@ -33,51 +58,29 @@ describe UniqueBy::Generator do
 
     let(:bill1) { klass.new(431, 2) }
     let(:bill2) { klass.new(431, 7) }
-    let(:id) { 431 }
 
     context "bill1" do
-      let(:unique_id) { (431 << 4) + (2 % 16) }
-      subject { bill1 }
-
-      describe "class methods" do
-        specify { expect(klass.bill_id_group_value_from(client_id: 2)).to eq(2 % 16) }
-        specify { expect(klass.unique_bill_id_from(431, client_id: 2)).to eq(unique_id) }
-        specify { expect(klass.bill_id_from(unique_id)).to eq(431) }
-        specify { expect(klass.bill_id_group_from(unique_id)).to eq(client_id: 2 % 16) }
-
-        context "nil id" do
-          specify { expect(klass.unique_bill_id_from(nil, client_id: 2)).to be_nil }
-          specify { expect(klass.bill_id_from(nil)).to be_nil }
-          specify { expect(klass.bill_id_group_from(nil)).to be_nil }
-        end
-      end
-
-      describe "instance methods" do
-        its(:bill_id_group) { should == { client_id: 2 } }
-        its(:unique_bill_id) { should == unique_id }
-
-        context "nil id" do
-          before { bill1.bill_id = nil }
-          its(:unique_bill_id) { should be_nil }
-        end
-      end
+      subject(:bill) { bill1 }
+
+      it_behaves_like "unique by", {
+        id: 431,
+        group: { client_id: 2 },
+        tempered_group: { client_id: 2 % 10 },
+        group_value: group_value = 2 % 10,
+        unique_id: (431 * 10) + group_value,
+      }
     end
 
     context "bill2" do
-      let(:unique_id) { (431 << 4) + (7 % 16) }
-      subject { bill2 }
-
-      describe "class methods" do
-        specify { expect(klass.bill_id_group_value_from(client_id: 7)).to eq(7 % 16) }
-        specify { expect(klass.unique_bill_id_from(431, client_id: 7)).to eq(unique_id) }
-        specify { expect(klass.bill_id_from(unique_id)).to eq(431) }
-        specify { expect(klass.bill_id_group_from(unique_id)).to eq(client_id: 7 % 16) }
-      end
-
-      describe "instance methods" do
-        its(:bill_id_group) { should == { client_id: 7 } }
-        its(:unique_bill_id) { should == unique_id }
-      end
+      subject(:bill) { bill2 }
+
+      it_behaves_like "unique by", {
+        id: 431,
+        group: { client_id: 7 },
+        tempered_group: { client_id: 7 % 10 },
+        group_value: group_value = 7 % 10,
+        unique_id: (431 * 10) + group_value,
+      }
     end
   end
 
@@ -95,49 +98,38 @@ describe UniqueBy::Generator do
 
     let(:medical_bill) { medical_klass.new(839) }
     let(:utility_bill) { utility_klass.new(839) }
-    let(:id) { 839 }
 
     context "medical bill" do
       let(:klass) { medical_klass }
-      let(:unique_id) { (839 << 1) + (10 % 2) }
-      subject { medical_bill }
-
-      describe "class methods" do
-        specify { expect(medical_klass.bill_id_group_value_from(type: 10)).to eq(10 % 2) }
-        specify { expect(medical_klass.unique_bill_id_from(839, type: 10)).to eq(unique_id) }
-        specify { expect(medical_klass.bill_id_from(unique_id)).to eq(839) }
-        specify { expect(medical_klass.bill_id_group_from(unique_id)).to eq(type: 10 % 2) }
-      end
-
-      describe "instance methods" do
-        its(:bill_id_group) { should == { type: 10 } }
-        its(:unique_bill_id) { should == unique_id }
-      end
+      subject(:bill) { medical_bill }
+
+      it_behaves_like "unique by", {
+        id: 839,
+        group: { type: 10 },
+        tempered_group: { type: 10 % 2 },
+        group_value: group_value = (10 % 2),
+        unique_id: (839 * 2) + group_value,
+      }
     end
 
     context "utility bill" do
       let(:klass) { utility_klass }
-      let(:unique_id) { (839 << 1) + (11 % 2) }
-      subject { utility_bill }
-
-      describe "class methods" do
-        specify { expect(utility_klass.bill_id_group_value_from(type: 11)).to eq(11 % 2) }
-        specify { expect(utility_klass.unique_bill_id_from(839, type: 11)).to eq(unique_id) }
-        specify { expect(utility_klass.bill_id_from(unique_id)).to eq(839) }
-        specify { expect(utility_klass.bill_id_group_from(unique_id)).to eq(type: 11 % 2) }
-      end
-
-      describe "instance methods" do
-        its(:bill_id_group) { should == { type: 11 } }
-        its(:unique_bill_id) { should == unique_id }
-      end
+      subject(:bill) { utility_bill }
+
+      it_behaves_like "unique by", {
+        id: 839,
+        group: { type: 11 },
+        tempered_group: { type: 11 % 2 },
+        group_value: group_value = (11 % 2),
+        unique_id: (839 * 2) + group_value,
+      }
     end
   end
 
   context "sharded tables" do
     let(:medical_klass) do
       Class.new(ShardedTablesBase) do
-        unique_by(client_id: 10, x: 200, type: 2, y: 20) { { type: 10, y: y } }
+        unique_by(client_id: 10, x: 200, type: 2, y: 30) { { type: 10, y: y } }
         def x
           53
         end
@@ -149,7 +141,7 @@ describe UniqueBy::Generator do
 
     let(:utility_klass) do
       Class.new(ShardedTablesBase) do
-        unique_by(client_id: 2**4, x: 2**8, type: 2**1, y: 2**5) { { type: 11, y: y } }
+        unique_by(client_id: 10, x: 200, type: 2, y: 30) { { type: 11, y: y } }
         def x
           853
         end
@@ -161,48 +153,92 @@ describe UniqueBy::Generator do
 
     let(:medical_bill) { medical_klass.new(9428, 5, 128) }
     let(:utility_bill) { utility_klass.new(9428, 8, 255) }
-    let(:id) { 9428 }
 
     context "medical bill" do
       let(:klass) { medical_klass }
-      subject { medical_bill }
+      subject(:bill) { medical_bill }
+
+      it_behaves_like "unique by", {
+        id: 9428,
+        group: { client_id: 5, x: 53, type: 10, y: 20 },
+        tempered_group: { client_id: 5 % 10, x: 53 % 200, type: 10 % 2, y: 20 % 30 },
+        group_value: group_value = ((5 % 10) * 200*2*30) + ((53 % 200) * 2*30) + ((10 % 2) * 30) + (20 % 30),
+        unique_id: (9428 * 10*200*2*30) + group_value,
+      }
+    end
+
+    context "utility bill" do
+      let(:klass) { utility_klass }
+      subject(:bill) { utility_bill }
+
+      it_behaves_like "unique by", {
+        id: 9428,
+        group: { client_id: 8, x: 853, type: 11, y: 40 },
+        tempered_group: { client_id: 8 % 10, x: 853 % 200, type: 11 % 2, y: 40 % 30 },
+        group_value: group_value = ((8 % 10) * 200*2*30) + ((853 % 200) * 2*30) + ((11 % 2) * 30) + (40 % 30),
+        unique_id: (9428 * 10*200*2*30) + group_value,
+      }
+    end
+  end
+
+  context "override primary key" do
+    let(:klass) do
+      Class.new(Struct.new(:bill_id, :client_id)) do
+        extend UniqueBy::Generator
+        unique_by(client_id: 10, primary_key: :bill_id)
+      end
+    end
+    subject(:bill) { klass.new(431, 2) }
+
+    it_behaves_like "unique by", {
+      id: 431,
+      group: { client_id: 2 },
+      tempered_group: { client_id: 2 % 10 },
+      group_value: group_value = 2 % 10,
+      unique_id: (431 * 10) + group_value,
+    }
+  end
 
-      let(:tempered_group) { { client_id: 5 % 16, x: 53 % 256, type: 10 % 2, y: 20 % 32 } }
-      let(:group_value) { ((5 % 16) << 14) + ((53 % 256) << 6) + ((10 % 2) << 5) + (20 % 32) }
-      let(:unique_id) { (9428 << 18) + group_value }
+  context "constant groups" do
+    let(:instance) { klass.new(49, 5) }
 
+    shared_examples_for "unique by" do
       describe "class methods" do
-        specify { expect(medical_klass.bill_id_group_value_from(client_id: 5, x: 53, type: 10, y: 20)).to eq(group_value) }
-        specify { expect(medical_klass.unique_bill_id_from(9428, client_id: 5, x: 53, type: 10, y: 20)).to eq(unique_id) }
-        specify { expect(medical_klass.bill_id_from(unique_id)).to eq(9428) }
-        specify { expect(medical_klass.bill_id_group_from(unique_id)).to eq(tempered_group) }
+        subject { klass }
+        its(:id_group_value_from) { should == 5 }
+        specify { expect(klass.unique_id_from(49)).to eq(495) }
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == { client_id: 5, x: 53, type: 10, y: 20 } }
-        its(:unique_bill_id) { should == unique_id }
+        subject { instance }
+        its(:id_group) { should == { type: 5 } }
+        its(:unique_id) { should == 495 }
       end
     end
 
-    context "utility bill" do
-      let(:klass) { utility_klass }
-      subject { utility_bill }
+    context "in static method" do
+      let(:klass) do
+        Class.new(Struct.new(:id, :type)) do
+          extend UniqueBy::Generator
+          unique_by(type: 10, primary_key: :id)
+          def self.type
+            5
+          end
+        end
+      end
 
-      let(:tempered_group) { { client_id: 8 % 16, x: 853 % 256, type: 11 % 2, y: 40 % 32 } }
-      let(:group_value) { ((8 % 16) << 14) + ((853 % 256) << 6) + ((11 % 2) << 5) + (40 % 32) }
-      let(:unique_id) { (9428 << 18) + group_value }
+      it_behaves_like "unique by"
+    end
 
-      describe "class methods" do
-        specify { expect(utility_klass.bill_id_group_value_from(client_id: 8, x: 853, type: 11, y: 40)).to eq(group_value) }
-        specify { expect(utility_klass.unique_bill_id_from(9428, client_id: 8, x: 853, type: 11, y: 40)).to eq(unique_id) }
-        specify { expect(utility_klass.bill_id_from(unique_id)).to eq(9428) }
-        specify { expect(utility_klass.bill_id_group_from(unique_id)).to eq(tempered_group) }
+    context "in block" do
+      let(:klass) do
+        Class.new(Struct.new(:id, :type)) do
+          extend UniqueBy::Generator
+          unique_by(type: 10, primary_key: :id) { { type: 5 } }
+        end
       end
 
-      describe "instance methods" do
-        its(:bill_id_group) { should == { client_id: 8, x: 853, type: 11, y: 40 } }
-        its(:unique_bill_id) { should == unique_id }
-      end
+      it_behaves_like "unique by"
     end
   end
 
@@ -228,7 +264,7 @@ describe UniqueBy::Generator do
 
       specify { expect { klass.bill_id_group_value_from(x: 2) }.to raise_error(ArgumentError, "unknown bill_id group keys: [:x]") }
       specify { expect { klass.bill_id_group_value_from(client_id: 5, x: 2) }.to raise_error(ArgumentError, "unknown bill_id group keys: [:x]") }
-      specify { expect { klass.bill_id_group_value_from() }.to raise_error(ArgumentError, "missing bill_id group keys: [:client_id]") }
+      specify { expect { klass.bill_id_group_value_from() }.to raise_error(NoMethodError, /^undefined method `client_id' for/) }
       specify { expect { klass.bill_id_group_value_from(client_id: nil) }.to raise_error(TypeError, "bill_id group client_id must not be nil") }
       specify { expect { klass.bill_id_group_value_from(client_id: :a) }.to raise_error(TypeError, "bill_id group client_id must implement #to_i, :a given") }
       specify { expect { klass.unique_bill_id_from(431, client_id: nil) }.to raise_error(TypeError, "bill_id group client_id must not be nil") }

data/unique_by.gemspec

@@ -12,6 +12,10 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Allows uniqueness of a record when sharding (specifying the shard ID as the group) or span accross tables (receipts).}
   spec.homepage      = "https://github.com/odedniv/unique_by"
   spec.license       = "UNLICENSE"
+  spec.post_install_message = <<MSG
+Upgrading from a previous major version could have destructive results.
+Make sure you go through all INCOMPATIBLEs mentioned in the changelog!
+MSG
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: unique_by
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: generate_method
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 description: Allows uniqueness of a record when sharding (specifying the shard ID
@@ -74,8 +74,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
@@ -89,18 +90,20 @@ homepage: https://github.com/odedniv/unique_by
 licenses:
 - UNLICENSE
 metadata: {}
-post_install_message: 
+post_install_message: |
+  Upgrading from a previous major version could have destructive results.
+  Make sure you go through all INCOMPATIBLEs mentioned in the changelog!
 rdoc_options: []
 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: []