unique_by 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c877eeb4bee389ff8f304f38825a35ab1ce2c398
-  data.tar.gz: 87108e22b935547a8deb63355979f9fd2a16eef1
+  metadata.gz: 4839ad7e8c93eabad52a34ae43774c3a4fa31ead
+  data.tar.gz: d205bd87ab905c57bbc620df6400a36fe9c95fba
 SHA512:
-  metadata.gz: e5e50dd6ce9bcb170af31c2e171388c2bec13e650685f62cded4a11fefeaf6d9d8d81a3915f37c4254ba002ce80b1fe0f15938da0356fba6b1020ffac2bc4419
-  data.tar.gz: 328cdd45129518b3e131ecd8e562ae6e216de0f4ad9da433e2b9e3a9a39c6b597c16fd10d1e3c0d368b43c4ca2ade12c68d5e1b9dc4a34377b169de0b50ef6c4
+  metadata.gz: afe1110aa03ea678e269655cbbd8d10ff7cbca5406b62a5193724f5617789db734d93e033a56d6077611e3ef9c54ead59dc5a1f80035c74a73ccbcf29cd5deba
+  data.tar.gz: fe7ac2951507f1b2a709f905469881f3e29b4c67d3c1a110b3bd8448d82d869932a13a3758c9de217121b296e989ee50366b17f2cea089ef35deeb1b5babefa4

data/README.md

@@ -12,7 +12,9 @@ When do you need this?
 
 Add this line to your application's Gemfile:
 
-    gem 'unique_by'
+```ruby
+gem 'unique_by'
+```
 
 And then execute:
 
@@ -28,84 +30,112 @@ Or install it yourself as:
 
 You first need to specify a unique group in your model:
 
-    # == Schema Info
-    #
-    # Table name: medical_bills
-    #
-    #  id                  :integer(11)    not null, primary key
-    #  client_id           :integer(11)
-    #
+```ruby
+# == Schema Info
+#
+# Table name: medical_bills
+#
+#  id                  :integer(11)    not null, primary key
+#  client_id           :integer(11)
+#
 
-    class MedicalBill < ActiveRecord::Base
-      unique_by :client_id, total: 50
-    end
+class MedicalBill < ActiveRecord::Base
+  unique_by client_id: 50 # total of 50 clients
+end
+```
 
 then, you can use these basic methods:
 
-    bill1 = MedicalBill.find(123) # from a DB shard for client_id = 1
-    bill2 = MedicalBill.find(123) # from a DB shard for client_id = 2
+```ruby
+bill1 = MedicalBill.find(123) # from a DB shard for client_id = 1
+bill2 = MedicalBill.find(123) # from a DB shard for client_id = 2
 
-    bill1.unique_id
-    => "62p"
-    bill2.unique_id
-    => "62q"
-    MedicalBill.find_by_unique_id("62p") # from DB shard for client_id = 1
-    => #<MedicalBill id: 123, client_id: 1>
-    MedicalBill.find_by_unique_id("62q") # from DB shard for client_id = 2
-    => #<MedicalBill id: 123, client_id: 2>
+bill1.unique_id
+=> 7873
+bill2.unique_id
+=> 7874
+MedicalBill.find_by_unique_id(7873) # from DB shard for client_id = 1
+=> #<MedicalBill id: 123, client_id: 1>
+MedicalBill.find_by_unique_id(7874) # from DB shard for client_id = 2
+=> #<MedicalBill id: 123, client_id: 2>
+```
 
 You can use the internal methods:
 
-    MedicalBill.unique_id_from(1, 123) # gives the unique_id from client_id, id
-    => "62p"
-    MedicalBill.id_from("62p") # gives the id
-    => 123
-    MedicalBill.id_group_from("62q") # gives the client_id
-    => 2
-
-And use bits instead of total:
-
-    class MedicalBill < ActiveRecord::Base
-      unique_by :client_id, bits: 6 # equivalent to total: 64
-    end
+```ruby
+MedicalBill.unique_id_from(123, client_id: 1) # gives the unique_id
+=> 7873
+MedicalBill.id_from(7873) # gives the id
+=> 123
+MedicalBill.id_group_from(7874) # gives the client_id
+=> { client_id: 2 }
+```
 
 You can specify multiple unique group attributes:
 
-    class MedicalBill < ActiveRecord::Base
-      unique_by :client_id, :client_part, total: [50, 5]
-    end
+```ruby
+class MedicalBill < ActiveRecord::Base
+  unique_by client_id: 50, client_part: 5 # total of 50 clients and 5 parts
+end
+```
 
 ### Multiple tables example
 
-You can supply a block to give your own mechanism for determining the
-group:
+You can supply a block to give a custom mechanism for determining the group:
 
-    class MedicalBill < ActiveRecord::Base
-      unique_by(total: 2) { 1 }
-    end
-    class UtilityBill < ActiveRecord::Base
-      unique_by(total: 2) { 2 }
-    end
+```ruby
+class MedicalBill < ActiveRecord::Base
+  unique_by(type: 2) { { type: 1 } }
+end
+class UtilityBill < ActiveRecord::Base
+  unique_by(type: 2) { { type: 2 } }
+end
+```
 
 You can supply both group attributes and a block, and the block can also
-return an array:
+return more than one field:
 
-    class MedicalBill < ActiveRecord::Base
-      unique(:client_id, :client_part, total: [50, 5, 10, 20]) { [self.x * self.y, self.z / 2] }
-    end
+```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
 you want the above methods in another class you can extend it:
 
-    class MyClass
-      extend UniqueBy::Generator
-
-      def self.primary_key
-        :id # or 'id'
-      end
-    end
+```ruby
+class MyClass
+  extend UniqueBy::Generator
+
+  def self.primary_key
+    :id # or 'id'
+  end
+end
+```
+
+## See also
+
+After adding the unique groups to the id, the unique_id might turn out pretty
+large. You could use [rebase_attr](https://github.com/odedniv/rebase_attr) to
+fix that:
+
+```ruby
+class MedicalBill < ActiveRecord::Base
+  unique_by client_id: 500
+  rebase_attr :unique_id, to: 32, readable: true
+end
+
+bill = MedicalBill.find(3528918) # from a DB shard for client_id = 1
+bill.unique_id
+=> "ywr3bxx"
+MedicalBill.find_by_unique_id(MedicalBill.decode_unique_id("ywr3bxx"))
+=> #<MedicalBill id: 3528918, client_id: 1>
+```
 
 ## Contributing
 

data/lib/unique_by/version.rb

@@ -1,3 +1,3 @@
 module UniqueBy
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/lib/unique_by.rb

@@ -11,69 +11,65 @@ 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_block_names, total: nil, bits: nil, &group_block)
-      bits, total = Array(bits), Array(total)
+    def unique_by(**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) }
 
-      raise ArgumentError, "must pass either total or bits to #unique_by" \
-        unless total.any? or bits.any?
-      raise ArgumentError, "both total (#{total.inspect}) and bits (#{bits.inspect}) passed to #unique_by" \
-        if total.any? and bits.any?
-      raise ArgumentError, "must pass a group generator block" \
-        unless group_block_names.any? or block_given?
-      raise ArgumentError, "amount of group names (#{group_block_names.length}) doesn't match total/bits (#{total.length + bits.length})" \
-        if (not block_given? and group_block_names.length != total.length + bits.length) or \
-           (block_given? and group_block_names.length > total.length + bits.length)
-
-      bits = total.map { |t| Math.log2(t).ceil } if bits.empty?
-      total = bits.map { |b| 2 ** b }
+      bits = Hash[group_totals.map { |k, t| [k, Math.log2(t).ceil] }]
+      totals = Hash[bits.map { |k, b| [k, 2 ** b] }] # real total
 
       pk = primary_key # converting to a local variable
 
-      define_singleton_method :"#{pk}_group_value_from" do |group|
-        Array(group).each_with_index.reduce(0) do |group_value, (g, i)|
-          raise TypeError, "group must implement #to_i, #{g.inspect} given" \
-            unless g.respond_to?(:to_i)
-          (group_value << bits[i]) + (g.to_i % total[i])
+      define_singleton_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_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])
         end
       end
 
-      define_singleton_method :"unique_#{pk}_from" do |id, group|
-        (id.to_i << bits.inject(&:+)) + send(:"#{pk}_group_value_from", group)
+      define_singleton_method :"unique_#{pk}_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)
       end
 
-      define_singleton_method :"#{pk}_from" do |id|
-        id.to_i >> bits.inject(&:+)
+      define_singleton_method :"#{pk}_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(&:+)
       end
 
-      define_singleton_method :"#{pk}_group_from" do |id|
-        group = bits.reverse.zip(total.reverse).map do |b, t|
-          g = id & (t - 1)
-          id >>= b
-          g
-        end.reverse
-        group.length == 1 ? group[0] : group
+      define_singleton_method :"#{pk}_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)
+        Hash[group_totals.keys.reverse.map do |group_name|
+          g = unique_id & (totals[group_name] - 1)
+          unique_id >>= bits[group_name]
+          [group_name, g]
+        end.reverse]
       end
 
       define_method :"#{pk}_group" do
-        group = group_block_names.map { |group_block_name| send(group_block_name) }
-        group.push(*Array(instance_eval(&group_block))) if group_block
-        raise ArgumentError, "amount of groups (#{group.length}) doesn't match amount of bits/total (#{bits.length})" if group.length != bits.length
-        group.length == 1 ? group[0] : group
+        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)
       end
 
       define_method :"unique_#{pk}" do
-        primary_key = send(pk)
-        raise TypeError, "#{pk} must implement #to_i, #{primary_key.inspect} given" \
-          unless primary_key.respond_to?(:to_i)
-        self.class.send(:"unique_#{pk}_from", primary_key.to_i, send(:"#{pk}_group"))
+        self.class.send(:"unique_#{pk}_from", send(pk), **send(:"#{pk}_group"))
       end
 
-      define_singleton_method :"find_by_unique_#{pk}" do |id|
-        send(:"find_by_#{pk}", send(:"#{pk}_from", id))
+      define_singleton_method :"find_by_unique_#{pk}" do |unique_id|
+        send(:"find_by_#{pk}", send(:"#{pk}_from", unique_id))
       end
 
-      define_singleton_method :"find_by_unique_#{pk}!" do |id|
-        send(:"find_by_#{pk}!", send(:"#{pk}_from", id))
+      define_singleton_method :"find_by_unique_#{pk}!" do |unique_id|
+        send(:"find_by_#{pk}!", send(:"#{pk}_from", unique_id))
       end
     end
   end

data/spec/unique_by_spec.rb

@@ -44,7 +44,7 @@ describe UniqueBy::Generator do
     let(:klass) do
       Class.new(Struct.new(:bill_id, :client_id)) do
         include BaseBill
-        unique_by(:client_id, total: 10)
+        unique_by(client_id: 10)
       end
     end
 
@@ -57,17 +57,28 @@ describe UniqueBy::Generator do
       subject { bill1 }
 
       describe "class methods" do
-        specify { expect(klass.bill_id_group_value_from(2)).to eq(2 % 16) }
-        specify { expect(klass.unique_bill_id_from(431, 2)).to eq(unique_id) }
+        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(2 % 16) }
+        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
 
         include_context "finder methods"
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == 2 }
+        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
     end
 
@@ -76,16 +87,16 @@ describe UniqueBy::Generator do
       subject { bill2 }
 
       describe "class methods" do
-        specify { expect(klass.bill_id_group_value_from(7)).to eq(7 % 16) }
-        specify { expect(klass.unique_bill_id_from(431, 7)).to eq(unique_id) }
+        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(7 % 16) }
+        specify { expect(klass.bill_id_group_from(unique_id)).to eq(client_id: 7 % 16) }
 
         include_context "finder methods"
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == 7 }
+        its(:bill_id_group) { should == { client_id: 7 } }
         its(:unique_bill_id) { should == unique_id }
       end
     end
@@ -94,12 +105,12 @@ describe UniqueBy::Generator do
   context "tables" do
     let(:medical_klass) do
       Class.new(TablesBase) do
-        unique_by(total: 2) { 10 }
+        unique_by(type: 2) { { type: 10 } }
       end
     end
     let(:utility_klass) do
       Class.new(TablesBase) do
-        unique_by(total: 2) { 11 }
+        unique_by(type: 2) { { type: 11 } }
       end
     end
 
@@ -113,16 +124,16 @@ describe UniqueBy::Generator do
       subject { medical_bill }
 
       describe "class methods" do
-        specify { expect(medical_klass.bill_id_group_value_from(10)).to eq(10 % 2) }
-        specify { expect(medical_klass.unique_bill_id_from(839, 10)).to eq(unique_id) }
+        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(10 % 2) }
+        specify { expect(medical_klass.bill_id_group_from(unique_id)).to eq(type: 10 % 2) }
 
         include_context "finder methods"
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == 10 }
+        its(:bill_id_group) { should == { type: 10 } }
         its(:unique_bill_id) { should == unique_id }
       end
     end
@@ -133,16 +144,16 @@ describe UniqueBy::Generator do
       subject { utility_bill }
 
       describe "class methods" do
-        specify { expect(utility_klass.bill_id_group_value_from(11)).to eq(11 % 2) }
-        specify { expect(utility_klass.unique_bill_id_from(839, 11)).to eq(unique_id) }
+        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(11 % 2) }
+        specify { expect(utility_klass.bill_id_group_from(unique_id)).to eq(type: 11 % 2) }
 
         include_context "finder methods"
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == 11 }
+        its(:bill_id_group) { should == { type: 11 } }
         its(:unique_bill_id) { should == unique_id }
       end
     end
@@ -150,9 +161,8 @@ describe UniqueBy::Generator do
 
   context "sharded tables" do
     let(:medical_klass) do
-
       Class.new(ShardedTablesBase) do
-        unique_by(:client_id, :x, total: [10, 200, 2, 20]) { [10, y] }
+        unique_by(client_id: 10, x: 200, type: 2, y: 20) { { type: 10, y: y } }
         def x
           53
         end
@@ -164,7 +174,7 @@ describe UniqueBy::Generator do
 
     let(:utility_klass) do
       Class.new(ShardedTablesBase) do
-        unique_by(:client_id, :x, bits: [4, 8, 1, 5]) { [11, y] }
+        unique_by(client_id: 2**4, x: 2**8, type: 2**1, y: 2**5) { { type: 11, y: y } }
         def x
           853
         end
@@ -178,17 +188,17 @@ describe UniqueBy::Generator do
     let(:utility_bill) { utility_klass.new(9428, 8, 255) }
     let(:id) { 9428 }
 
-    context "with total" do
+    context "medical bill" do
       let(:klass) { medical_klass }
       subject { medical_bill }
 
-      let(:tempered_group) { [5 % 16, 53 % 256, 10 % 2, 20 % 32] }
+      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 }
 
       describe "class methods" do
-        specify { expect(medical_klass.bill_id_group_value_from([5, 53, 10, 20])).to eq(group_value) }
-        specify { expect(medical_klass.unique_bill_id_from(9428, [5, 53, 10, 20])).to eq(unique_id) }
+        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) }
 
@@ -196,22 +206,22 @@ describe UniqueBy::Generator do
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == [5, 53, 10, 20] }
+        its(:bill_id_group) { should == { client_id: 5, x: 53, type: 10, y: 20 } }
         its(:unique_bill_id) { should == unique_id }
       end
     end
 
-    context "with bits" do
+    context "utility bill" do
       let(:klass) { utility_klass }
       subject { utility_bill }
 
-      let(:tempered_group) { [8 % 16, 853 % 256, 11 % 2, 40 % 32] }
+      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 }
 
       describe "class methods" do
-        specify { expect(utility_klass.bill_id_group_value_from([8, 853, 11, 40])).to eq(group_value) }
-        specify { expect(utility_klass.unique_bill_id_from(9428, [8, 853, 11, 40])).to eq(unique_id) }
+        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) }
 
@@ -219,35 +229,93 @@ describe UniqueBy::Generator do
       end
 
       describe "instance methods" do
-        its(:bill_id_group) { should == [8, 853, 11, 40] }
+        its(:bill_id_group) { should == { client_id: 8, x: 853, type: 11, y: 40 } }
         its(:unique_bill_id) { should == unique_id }
       end
     end
   end
 
   context "errors" do
-    let(:klass) do
-      Class.new do
-        include BaseBill
+    describe "#unique_by" do
+      let(:klass) do
+        Class.new do
+          include BaseBill
+        end
       end
-    end
 
-    describe "#unique_by" do
-      specify { expect { klass.unique_by(:x) }.to raise_error(ArgumentError, "must pass either total or bits to #unique_by") }
-      specify { expect { klass.unique_by(:x, total: [5, 4], bits: [2, 7]) }.to raise_error(ArgumentError, "both total ([5, 4]) and bits ([2, 7]) passed to #unique_by") }
-      specify { expect { klass.unique_by(total: 5) }.to raise_error(ArgumentError, "must pass a group generator block") }
-      specify { expect { klass.unique_by(:x, :y, total: 5) }.to raise_error(ArgumentError, "amount of group names (2) doesn't match total/bits (1)") }
-      specify { expect { klass.unique_by(:x, :y, total: [3, 2, 5]) }.to raise_error(ArgumentError, "amount of group names (2) doesn't match total/bits (3)") }
-      specify { expect { klass.unique_by(:x, :y, total: [3, 2, 5]) { } }.not_to raise_error }
-      specify { expect { klass.unique_by(:x, :y, :z, bits: [3, 2]) { } }.to raise_error(ArgumentError, "amount of group names (3) doesn't match total/bits (2)") }
+      specify { expect { klass.unique_by }.to raise_error(ArgumentError, "must pass a group definition (Hash of name => total)") }
+      specify { expect { klass.unique_by(x: :a) }.to raise_error(ArgumentError, "group definition must be a Hash of name => Fixnum, {:x=>:a} given") }
     end
 
     describe "class methods" do
-      pending
+      let(:klass) do
+        Class.new(Struct.new(:bill_id, :client_id)) do
+          include BaseBill
+          unique_by client_id: 10
+        end
+      end
+
+      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(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") }
+      specify { expect { klass.unique_bill_id_from(431, 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(:a, client_id: 5) }.to raise_error(TypeError, "bill_id must implement #to_i, :a given") }
+      specify { expect { klass.bill_id_from(:a) }.to raise_error(TypeError, "unique_bill_id must implement #to_i, :a given") }
+      specify { expect { klass.bill_id_group_from(:a) }.to raise_error(TypeError, "unique_bill_id must implement #to_i, :a given") }
     end
 
     describe "instance methods" do
-      pending
+      let(:klass) do
+        Class.new(Struct.new(:bill_id, :client_id, :block)) do
+          include BaseBill
+          unique_by(client_id: 10, x: 5) { block }
+        end
+      end
+
+      context "nil group" do
+        let(:bill) { klass.new(431, nil, { x: 2 }) }
+        specify { expect { bill.unique_bill_id }.to raise_error(TypeError, "bill_id group client_id must not be nil") }
+      end
+
+      context "invalid group" do
+        let(:bill) { klass.new(431, :a, { x: 2 }) }
+        specify { expect { bill.unique_bill_id }.to raise_error(TypeError, "bill_id group client_id must implement #to_i, :a given") }
+      end
+
+      context "nil block group" do
+        let(:bill) { klass.new(431, 5, { x: nil }) }
+        specify { expect { bill.unique_bill_id }.to raise_error(TypeError, "bill_id group x must not be nil") }
+      end
+
+      context "invalid block group" do
+        let(:bill) { klass.new(431, 5, :a) }
+        specify { expect { bill.unique_bill_id }.to raise_error(TypeError, "bill_id group block must return a Hash with any of the following keys: [:client_id, :x], :a given") }
+      end
+
+      context "invalid block group value" do
+        let(:bill) { klass.new(431, 5, { x: :a }) }
+        specify { expect { bill.unique_bill_id }.to raise_error(TypeError, "bill_id group x must implement #to_i, :a given") }
+      end
+
+      context "unknown block group keys" do
+        context "too few" do
+          let(:bill) { klass.new(431, 5, { }) }
+          specify { expect { bill.unique_bill_id }.to raise_error(NameError, "undefined method `x' for #<struct bill_id=431, client_id=5, block={}>") }
+        end
+
+        context "too many" do
+          let(:bill) { klass.new(431, 5, { x: 2, y: 12 }) }
+          specify { expect { bill.unique_bill_id }.to raise_error(ArgumentError, "unknown bill_id group passed to block: [:y]") }
+        end
+
+        context "different" do
+          let(:bill) { klass.new(431, 5, { y: 12 }) }
+          specify { expect { bill.unique_bill_id }.to raise_error(ArgumentError, "unknown bill_id group passed to block: [:y]") }
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unique_by
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-17 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler