unique_by 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4360207db16c47e063005d3f50983411710de6f8
-  data.tar.gz: f2aa0cb2ff36558ca288fe4f8397645edd55a28a
+  metadata.gz: c877eeb4bee389ff8f304f38825a35ab1ce2c398
+  data.tar.gz: 87108e22b935547a8deb63355979f9fd2a16eef1
 SHA512:
-  metadata.gz: 2e91b8a6f86e7b1fb936807adf396e63ccecba95f3b8ab9ae892e17f6671ecfaba7928b960a6e581a9a8455f4a3a0e48635033fa5d2dfcbad783fdf94d001daf
-  data.tar.gz: ad167e6e1778ed2d855144b1c548a330e2b293664d5234746119dc5026a84497448c9f937a475d8e42616c6fcf3d774563482bd8c124de433f4f9bb78f1f4829
+  metadata.gz: e5e50dd6ce9bcb170af31c2e171388c2bec13e650685f62cded4a11fefeaf6d9d8d81a3915f37c4254ba002ce80b1fe0f15938da0356fba6b1020ffac2bc4419
+  data.tar.gz: 328cdd45129518b3e131ecd8e562ae6e216de0f4ad9da433e2b9e3a9a39c6b597c16fd10d1e3c0d368b43c4ca2ade12c68d5e1b9dc4a34377b169de0b50ef6c4

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/unique_by/version.rb

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

data/lib/unique_by.rb

@@ -3,7 +3,8 @@ require "unique_by/version"
 module UniqueBy
   module Generator
     # For a primary_key 'id', generates:
-    #   ::unique_id_from(group, id) => unique_id
+    #   ::id_group_value_from(group) => group_value
+    #   ::unique_id_from(id, group) => unique_id
     #   ::id_from(unique_id) => id
     #   ::id_group_from(unique_id) => group
     #   #id_group => group
@@ -13,56 +14,66 @@ module UniqueBy
     def unique_by(*group_block_names, total: nil, bits: nil, &group_block)
       bits, total = Array(bits), Array(total)
 
-      raise ArgumentError, "must pass either bits or total to #unique_by" \
-        unless bits.any? or total.any?
-      raise ArgumentError, "both bits (#{bits.inspect}) and total (#{total.inspect}) passed to #unique_by" \
-        if bits.any? and total.any?
+      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 amount of bits/total (#{bits.length + total.length})" \
-        if group_block_names.any? and not block_given? and group_block_names.length != bits.length + total.length
+      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 }
 
       pk = primary_key # converting to a local variable
 
-      define_singleton_method :"unique_#{pk}_from" do |group_value, value|
-        (value.to_i << bits.sum) + group_value.to_i
+      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])
+        end
+      end
+
+      define_singleton_method :"unique_#{pk}_from" do |id, group|
+        (id.to_i << bits.inject(&:+)) + send(:"#{pk}_group_value_from", group)
       end
 
-      define_singleton_method :"#{pk}_from" do |value|
-        value.to_i >> bits
+      define_singleton_method :"#{pk}_from" do |id|
+        id.to_i >> bits.inject(&:+)
       end
 
-      define_singleton_method :"#{pk}_group_from" do |value|
-        value.to_i & ((2 ** bits.sum) - 1)
+      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
       end
 
       define_method :"#{pk}_group" do
-        group_values = group_block_names.map { |group_block_name| send(group_block_name) }
-        group_values.push(*Array(instance_eval(group_block))) if group_block
-        raise "amount of groups (#{group_values.length}) doesn't match amount of bits/total (#{bits.length})" if group_values.length != bits.length
-        group_values.each_with_index.reduce(0) do |group, (group_value, i)|
-          raise "group must implement #to_i, #{group_value} given" \
-            unless group_value.respond_to?(&:to_i)
-          (group << bits[i]) + (group_value.to_i % total[i])
-        end
+        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
       end
 
       define_method :"unique_#{pk}" do
         primary_key = send(pk)
-        raise "#{pk} must implement #to_i, #{primary_key.inspect} given" \
+        raise TypeError, "#{pk} must implement #to_i, #{primary_key.inspect} given" \
           unless primary_key.respond_to?(:to_i)
-        self.class.send(:"unique_#{pk}_from", send(:"#{pk}_group"), primary_key.to_i)
+        self.class.send(:"unique_#{pk}_from", primary_key.to_i, send(:"#{pk}_group"))
       end
 
-      define_singleton_method :"find_by_unique_#{pk}" do |value|
-        send(:"find_by_#{pk}". send(:"#{pk}_from", value))
+      define_singleton_method :"find_by_unique_#{pk}" do |id|
+        send(:"find_by_#{pk}", send(:"#{pk}_from", id))
       end
 
-      define_singleton_method :"find_by_unique_#{pk}!" do |value|
-        send(:"find_by_#{pk}!". send(:"#{pk}_from", value))
+      define_singleton_method :"find_by_unique_#{pk}!" do |id|
+        send(:"find_by_#{pk}!", send(:"#{pk}_from", id))
       end
     end
   end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+require 'rspec/its'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/unique_by_spec.rb

@@ -0,0 +1,253 @@
+require 'unique_by'
+
+module BaseBill
+  def self.included(base)
+    super
+    base.extend UniqueBy::Generator
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def primary_key
+      :bill_id
+    end
+
+    def find_by_bill_id(bill_id)
+    end
+
+    def find_by_bill_id!(bill_id)
+    end
+  end
+end
+
+class TablesBase < Struct.new(:bill_id)
+  include BaseBill
+end
+
+class ShardedTablesBase < Struct.new(:bill_id, :client_id, :x)
+  include BaseBill
+end
+
+describe UniqueBy::Generator do
+  shared_context "finder methods" do
+    specify "find_by_bill_id" do
+      expect(klass).to receive(:find_by_bill_id).with(id)
+      klass.find_by_unique_bill_id(unique_id)
+    end
+    specify "find_by_bill_id!" do
+      expect(klass).to receive(:find_by_bill_id!).with(id)
+      klass.find_by_unique_bill_id!(unique_id)
+    end
+  end
+
+  context "shards" do
+    let(:klass) do
+      Class.new(Struct.new(:bill_id, :client_id)) do
+        include BaseBill
+        unique_by(:client_id, total: 10)
+      end
+    end
+
+    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(2)).to eq(2 % 16) }
+        specify { expect(klass.unique_bill_id_from(431, 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) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == 2 }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    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(7)).to eq(7 % 16) }
+        specify { expect(klass.unique_bill_id_from(431, 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) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == 7 }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    end
+  end
+
+  context "tables" do
+    let(:medical_klass) do
+      Class.new(TablesBase) do
+        unique_by(total: 2) { 10 }
+      end
+    end
+    let(:utility_klass) do
+      Class.new(TablesBase) do
+        unique_by(total: 2) { 11 }
+      end
+    end
+
+    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(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_from(unique_id)).to eq(839) }
+        specify { expect(medical_klass.bill_id_group_from(unique_id)).to eq(10 % 2) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == 10 }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    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(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_from(unique_id)).to eq(839) }
+        specify { expect(utility_klass.bill_id_group_from(unique_id)).to eq(11 % 2) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == 11 }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    end
+  end
+
+  context "sharded tables" do
+    let(:medical_klass) do
+
+      Class.new(ShardedTablesBase) do
+        unique_by(:client_id, :x, total: [10, 200, 2, 20]) { [10, y] }
+        def x
+          53
+        end
+        def y
+          20
+        end
+      end
+    end
+
+    let(:utility_klass) do
+      Class.new(ShardedTablesBase) do
+        unique_by(:client_id, :x, bits: [4, 8, 1, 5]) { [11, y] }
+        def x
+          853
+        end
+        def y
+          40
+        end
+      end
+    end
+
+    let(:medical_bill) { medical_klass.new(9428, 5, 128) }
+    let(:utility_bill) { utility_klass.new(9428, 8, 255) }
+    let(:id) { 9428 }
+
+    context "with total" do
+      let(:klass) { medical_klass }
+      subject { medical_bill }
+
+      let(:tempered_group) { [5 % 16, 53 % 256, 10 % 2, 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_from(unique_id)).to eq(9428) }
+        specify { expect(medical_klass.bill_id_group_from(unique_id)).to eq(tempered_group) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == [5, 53, 10, 20] }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    end
+
+    context "with bits" do
+      let(:klass) { utility_klass }
+      subject { utility_bill }
+
+      let(:tempered_group) { [8 % 16, 853 % 256, 11 % 2, 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_from(unique_id)).to eq(9428) }
+        specify { expect(utility_klass.bill_id_group_from(unique_id)).to eq(tempered_group) }
+
+        include_context "finder methods"
+      end
+
+      describe "instance methods" do
+        its(:bill_id_group) { should == [8, 853, 11, 40] }
+        its(:unique_bill_id) { should == unique_id }
+      end
+    end
+  end
+
+  context "errors" do
+    let(:klass) do
+      Class.new do
+        include BaseBill
+      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)") }
+    end
+
+    describe "class methods" do
+      pending
+    end
+
+    describe "instance methods" do
+      pending
+    end
+  end
+end

data/unique_by.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["oded.niv@gmail.com"]
   spec.summary       = %q{Specify uniqueness group for an attribute.}
   spec.description   = %q{Allows uniqueness of a record when sharding (specifying the shard ID as the group) or span accross tables (receipts).}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/odedniv/unique_by"
   spec.license       = "UNLICENSE"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "rspec-its", "~> 1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unique_by
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-16 00:00:00.000000000 Z
+date: 2014-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - ~>
       - !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
   as the group) or span accross tables (receipts).
 email:
@@ -47,14 +61,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - README.md
 - Rakefile
 - UNLICENSE
 - lib/unique_by.rb
 - lib/unique_by/version.rb
+- spec/spec_helper.rb
+- spec/unique_by_spec.rb
 - unique_by.gemspec
-homepage: ''
+homepage: https://github.com/odedniv/unique_by
 licenses:
 - UNLICENSE
 metadata: {}
@@ -78,4 +95,6 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Specify uniqueness group for an attribute.
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/unique_by_spec.rb