bihash 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5d8345deb718d95a3241b798749ff0b1a1eb571
-  data.tar.gz: 38d06e9a1d0478fe5caaaacd788efe2ec8f029ae
+  metadata.gz: b4950baf55de5c2d039c99642d21299374071b08
+  data.tar.gz: dd607c38dbe190d3cc1c230d3b85c47329d24d77
 SHA512:
-  metadata.gz: 0bb47fb6f7d979f9afccf4743fd380c3f5c87668782c5f72ac8c7004249b062bc4278bc1f16d668100d7f6439574938f7aa2cf3544ce59fd25739a299e2fea6d
-  data.tar.gz: 7b8801d5e0d0f3bd19dc4f98d3c8025ae4e2f50c0d70655597845272086801bf92a0ae1fad07508f41eb02b8594e17c3fce28191f295e9b357f65df60f4b5efc
+  metadata.gz: e78ef70b4e47ef0ea27c40b337fde30a21840ff426216280d6fb58922b3a5cf6acac1d70e8185b0567a8aa3210e67655e62663af7a11f59e95ad9362c2db9d28
+  data.tar.gz: 8d5bbda0bd6d9326314398d521e1db3fd3d52263cbaf0c4dacf3e7760180e7b8b65e90564507b9a5f72c939ea6f9019dbf5c93fbec13365c4bef9076da408415

data/lib/bihash.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
 require 'bihash/version'
+require 'bihash/unimplemented_methods'
 
 class Bihash
   include Enumerable
@@ -14,8 +15,28 @@ class Bihash
     h && new_from_hash(h)
   end
 
+  def <(rhs)
+    raise_error_unless_bihash(rhs)
+    merged_hash_attrs < rhs.send(:merged_hash_attrs)
+  end
+
+  def <=(rhs)
+    raise_error_unless_bihash(rhs)
+    merged_hash_attrs <= rhs.send(:merged_hash_attrs)
+  end
+
   def ==(rhs)
-    rhs.is_a?(self.class) && rhs.send(:merged_hash_attrs) == merged_hash_attrs
+    rhs.is_a?(self.class) && merged_hash_attrs == rhs.send(:merged_hash_attrs)
+  end
+
+  def >(rhs)
+    raise_error_unless_bihash(rhs)
+    merged_hash_attrs > rhs.send(:merged_hash_attrs)
+  end
+
+  def >=(rhs)
+    raise_error_unless_bihash(rhs)
+    merged_hash_attrs >= rhs.send(:merged_hash_attrs)
   end
 
   def [](key)
@@ -47,6 +68,14 @@ class Bihash
     self
   end
 
+  def compact
+    dup.tap { |d| d.compact! }
+  end
+
+  def compact!
+    reject! { |k1, k2| k1.nil? || k2.nil? }
+  end
+
   def compare_by_identity
     raise_error_if_frozen
     @forward.compare_by_identity
@@ -112,6 +141,10 @@ class Bihash
     end
   end
 
+  def dig(*keys)
+    (@forward.key?(keys[0]) ? @forward : @reverse).dig(*keys)
+  end
+
   def each(&block)
     if block_given?
       @forward.each(&block)
@@ -131,6 +164,10 @@ class Bihash
     (@forward.key?(key) ? @forward : @reverse).fetch(key, *default, &block)
   end
 
+  def fetch_values(*keys)
+    keys.map { |key| fetch(key) }
+  end
+
   def_delegator :@forward, :flatten
 
   def has_key?(arg)
@@ -186,7 +223,7 @@ class Bihash
 
   def reject(&block)
     if block_given?
-      dup.delete_if(&block)
+      dup.tap { |d| d.reject!(&block) }
     else
       to_enum(:reject)
     end
@@ -213,7 +250,7 @@ class Bihash
 
   def select(&block)
     if block_given?
-      dup.keep_if(&block)
+      dup.tap { |d| d.select!(&block) }
     else
       to_enum(:select)
     end
@@ -248,6 +285,12 @@ class Bihash
     @forward.dup
   end
 
+  alias :to_hash :to_h
+
+  def to_proc
+    method(:[]).to_proc
+  end
+
   alias :to_s :inspect
 
   alias :update :merge!

data/lib/bihash/unimplemented_methods.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+class Bihash
+  UNIMPLEMENTED_METHODS = Set[
+    # expected to only deal with half the hash: keys or values
+    'keys',
+    'values',
+    'each_key',
+    'each_value',
+    'transform_values',
+    'transform_values!',
+    # O(n) reverse lookups
+    'key',
+    'index',
+    'rassoc',
+    'value?',
+    'has_value?',
+    # meaningless on bihash as both sides already hashed
+    'invert'
+  ]
+
+  def respond_to?(method, private = false)
+    UNIMPLEMENTED_METHODS.include?(method.to_s) ? false : super
+  end
+
+  UNIMPLEMENTED_METHODS.each do |method|
+    define_method(method) do |*|
+      raise NoMethodError, "Bihash##{method} not implemented"
+    end
+  end
+end

data/lib/bihash/version.rb

@@ -1,3 +1,3 @@
 class Bihash
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/spec/bihash_spec.rb

@@ -5,6 +5,17 @@ describe Bihash do
     Bihash.must_include Enumerable
   end
 
+  Bihash::UNIMPLEMENTED_METHODS.each do |method|
+    it "should report that it does not respond to ##{method}" do
+      Bihash.new.respond_to?(method).must_equal false
+    end
+
+    it "should raise NoMethodError if ##{method} is called" do
+      error = -> { Bihash.new.send(method) }.must_raise NoMethodError
+      error.message.must_equal "Bihash##{method} not implemented"
+    end
+  end
+
   describe '::[]' do
     it 'should be able to create an empty bihash' do
       bh = Bihash[]
@@ -66,7 +77,7 @@ describe Bihash do
       bh = Bihash.new
       bh.must_be_instance_of Bihash
       bh.must_be_empty
-      bh[:not_a_key].must_equal nil
+      bh[:not_a_key].must_be_nil
     end
 
     it 'should create an empty bihash with a default if given an object arg' do
@@ -111,8 +122,13 @@ describe Bihash do
       bh[2].must_equal :k2
     end
 
+    it 'should convert a bihash to a bihash' do
+      bh = Bihash[:key => 'value']
+      Bihash.try_convert(bh).must_equal bh
+    end
+
     it 'should return nil if the object does not respond to #to_hash' do
-      Bihash.try_convert(Object.new).must_equal nil
+      Bihash.try_convert(Object.new).must_be_nil
     end
 
     it 'should not accept a hash with duplicate values' do
@@ -120,6 +136,42 @@ describe Bihash do
     end
   end
 
+  describe '#<' do
+    it 'should raise an error if the right hand side is not a bihash' do
+      -> { Bihash[a: 1, b: 2] < {a: 1, b: 2, c: 3} }.must_raise TypeError
+    end
+
+    it 'should return true when the argument is a strict subset of self' do
+      (Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2, c: 3]).must_equal true
+    end
+
+    it 'should return false when the argument is equal to self' do
+      (Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2]).must_equal false
+    end
+
+    it 'should return false when the argument is not a subset of self' do
+      (Bihash[a: 1, b: 2, c: 3] < Bihash[a: 1, b: 2]).must_equal false
+    end
+  end
+
+  describe '#<=' do
+    it 'should raise an error if the right hand side is not a bihash' do
+      -> { Bihash[a: 1, b: 2] <= {a: 1, b: 2, c: 3} }.must_raise TypeError
+    end
+
+    it 'should return true when the argument is a strict subset of self' do
+      (Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2, c: 3]).must_equal true
+    end
+
+    it 'should return true when the argument is equal to self' do
+      (Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2]).must_equal true
+    end
+
+    it 'should return false when the argument is not a subset of self' do
+      (Bihash[a: 1, b: 2, c: 3] <= Bihash[a: 1, b: 2]).must_equal false
+    end
+  end
+
   describe '#==' do
     it 'should return true when two bihashes have the same pairs' do
       bh1, bh2 = Bihash[:k1 => 1, :k2 => 2], Bihash[2 => :k2, 1 => :k1]
@@ -137,6 +189,42 @@ describe Bihash do
     end
   end
 
+  describe '#>' do
+    it 'should raise an error if the right hand side is not a bihash' do
+      -> { Bihash[a: 1, b: 2] > {a: 1, b: 2, c: 3} }.must_raise TypeError
+    end
+
+    it 'should return true when the argument is a strict superset of self' do
+      (Bihash[a: 1, b: 2, c: 3] > Bihash[a: 1, b: 2]).must_equal true
+    end
+
+    it 'should return false when the argument is equal to self' do
+      (Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2]).must_equal false
+    end
+
+    it 'should return false when the argument is not a superset of self' do
+      (Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2, c: 3]).must_equal false
+    end
+  end
+
+  describe '#>=' do
+    it 'should raise an error if the right hand side is not a bihash' do
+      -> { Bihash[a: 1, b: 2] >= {a: 1, b: 2, c: 3} }.must_raise TypeError
+    end
+
+    it 'should return true when the argument is a strict superset of self' do
+      (Bihash[a: 1, b: 2, c: 3] >= Bihash[a: 1, b: 2]).must_equal true
+    end
+
+    it 'should return true when the argument is equal to self' do
+      (Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2]).must_equal true
+    end
+
+    it 'should return false when the argument is not a superset of self' do
+      (Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2, c: 3]).must_equal false
+    end
+  end
+
   describe '#[]' do
     it 'should return the other pair' do
       bh = Bihash[:key => 'value']
@@ -147,10 +235,10 @@ describe Bihash do
     it 'should return falsey values correctly' do
       bh1 = Bihash[nil => false]
       bh1[nil].must_equal false
-      bh1[false].must_equal nil
+      bh1[false].must_be_nil
 
       bh2 = Bihash[false => nil]
-      bh2[false].must_equal nil
+      bh2[false].must_be_nil
       bh2[nil].must_equal false
     end
   end
@@ -201,14 +289,57 @@ describe Bihash do
 
     it 'should return nil if the argument is not a key' do
       bh = Bihash.new(404)
-      bh.assoc(:not_a_key).must_equal nil
+      bh.assoc(:not_a_key).must_be_nil
     end
 
     it 'should find the key using #==' do
       bh = Bihash[[] => 'array']
       bh['array'] << 'modified'
       bh.assoc(['modified']).must_equal [['modified'], 'array']
-      bh.assoc([]).must_equal nil
+      bh.assoc([]).must_be_nil
+    end
+  end
+
+  describe '#compact' do
+    describe 'when any pairs contain a nil key' do
+      it 'should return a new bihash with any pairs containing nil removed' do
+        bh = Bihash[1 => :one, 2 => nil, 3 => :three]
+        bh.compact.must_equal Bihash[1 => :one, 3 => :three]
+        bh.must_equal Bihash[1 => :one, 2 => nil, 3 => :three]
+      end
+    end
+
+    describe 'no pairs contain a nil key' do
+      it 'should return a copy of the original bihash' do
+        bh = Bihash[1 => :one, 2 => :two, 3 => :three]
+        compacted_bh = bh.compact
+        compacted_bh.must_equal Bihash[1 => :one, 2=> :two, 3 => :three]
+        compacted_bh.object_id.wont_equal bh.object_id
+      end
+    end
+  end
+
+  describe '#compact!' do
+    it 'should delete any pairs containing nil' do
+      bh1 = Bihash[1 => :one, 2 => nil, 3 => :three]
+      bh1_id = bh1.object_id
+      bh1.compact!.object_id.must_equal bh1_id
+      bh1.must_equal Bihash[1 => :one, 3 => :three]
+
+      bh2 = Bihash[1 => :one, 2 => nil, 3 => :three]
+      bh2_id = bh2.object_id
+      bh2.compact!.object_id.must_equal bh2_id
+      bh2.must_equal Bihash[1 => :one, 3 => :three]
+    end
+
+    it 'should return nil if no changes were made to the bihash' do
+      bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+      bh.compact!.must_be_nil
+      bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+    end
+
+    it 'should raise RuntimeError if called on a frozen bihash' do
+      -> { Bihash.new.freeze.compact! }.must_raise RuntimeError
     end
   end
 
@@ -229,7 +360,7 @@ describe Bihash do
       bh = Bihash[1 => :one]
       clone = bh.clone
       clone[2] = :two
-      bh[2].must_equal nil
+      bh[2].must_be_nil
     end
   end
 
@@ -238,8 +369,8 @@ describe Bihash do
       bh = Bihash.new.compare_by_identity
       key1, key2 = 'key', 'value'
       bh[key1] = key2
-      bh['key'].must_equal nil
-      bh['value'].must_equal nil
+      bh['key'].must_be_nil
+      bh['value'].must_be_nil
       bh[key1].must_equal 'value'
       bh[key2].must_equal 'key'
     end
@@ -264,9 +395,9 @@ describe Bihash do
     describe 'when there is not a default proc' do
       it 'should return the default' do
         bh1 = Bihash[:key => 'value']
-        bh1.default.must_equal nil
-        bh1.default(:not_a_key).must_equal nil
-        bh1.default(:key).must_equal nil
+        bh1.default.must_be_nil
+        bh1.default(:not_a_key).must_be_nil
+        bh1.default(:key).must_be_nil
 
         bh2 = Bihash.new(404)
         bh2[:key] = 'value'
@@ -278,7 +409,7 @@ describe Bihash do
 
     describe 'when there is a default proc' do
       it 'should return the default if called with no argument' do
-        Bihash.new { 'proc called' }.default.must_equal nil
+        Bihash.new { 'proc called' }.default.must_be_nil
       end
 
       it 'should call the default proc when called with an argument' do
@@ -317,8 +448,8 @@ describe Bihash do
     end
 
     it 'should return nil if there is no default proc' do
-      Bihash.new.default_proc.must_equal nil
-      Bihash.new(404).default_proc.must_equal nil
+      Bihash.new.default_proc.must_be_nil
+      Bihash.new(404).default_proc.must_be_nil
     end
   end
 
@@ -333,8 +464,8 @@ describe Bihash do
     it 'should set the default value to nil if argument is nil' do
       bh = Bihash.new(:default_object)
       bh[:not_a_key].must_equal :default_object
-      (bh.default_proc = nil).must_equal nil
-      bh[:not_a_key].must_equal nil
+      (bh.default_proc = nil).must_be_nil
+      bh[:not_a_key].must_be_nil
     end
 
     it 'should raise TypeError if not given a non-proc (except nil)' do
@@ -397,12 +528,35 @@ describe Bihash do
     end
   end
 
+  describe '#dig' do
+    it 'should traverse nested bihashes' do
+      bh = Bihash[foo: Bihash[bar: Bihash[baz: 4]]]
+      bh.dig(:foo, :bar, :baz).must_equal 4
+      bh.dig(:foo, :bar, 4).must_equal :baz
+    end
+
+    it 'should traverse nested hashes' do
+      bh = Bihash[foo: {bar: {baz: 4}}]
+      bh.dig(:foo, :bar, :baz).must_equal 4
+    end
+
+    it 'should traverse nested arrays' do
+      bh = Bihash[foo: [[4]]]
+      bh.dig(:foo, 0, 0).must_equal 4
+    end
+
+    it 'should return nil if any intermediate step is nil' do
+      bh = Bihash[foo: Bihash[bar: Bihash[baz: 4]]]
+      bh.dig(:foo, :bur, :boz).must_be_nil
+    end
+  end
+
   describe '#dup' do
     it 'should make a copy of the bihash' do
       bh = Bihash[1 => :one]
       dup = bh.dup
       dup[2] = :two
-      bh[2].must_equal nil
+      bh[2].must_be_nil
     end
   end
 
@@ -448,10 +602,10 @@ describe Bihash do
     it 'should return falsey values correctly' do
       bh1 = Bihash[nil => false]
       bh1.fetch(nil).must_equal false
-      bh1.fetch(false).must_equal nil
+      bh1.fetch(false).must_be_nil
 
       bh2 = Bihash[false => nil]
-      bh2.fetch(false).must_equal nil
+      bh2.fetch(false).must_be_nil
       bh2.fetch(nil).must_equal false
     end
 
@@ -470,8 +624,28 @@ describe Bihash do
     end
   end
 
+  describe '#fetch_values' do
+    it 'should return an array of values corresponding to the given keys' do
+      Bihash[1 => :one, 2 => :two].fetch_values(1, 2).must_equal [:one, :two]
+      Bihash[1 => :one, 2 => :two].fetch_values(:one, :two).must_equal [1, 2]
+      Bihash[1 => :one, 2 => :two].fetch_values(1, :two).must_equal [:one, 2]
+    end
+
+    it 'should raise a KeyError if any key is not found' do
+      -> { Bihash.new.fetch_values(404) }.must_raise KeyError
+    end
+
+    it 'should not duplicate entries if a key equals its value' do
+      Bihash[:key => :key].fetch_values(:key).must_equal [:key]
+    end
+
+    it 'should return an empty array with no args' do
+      Bihash[:key => 'value'].fetch_values.must_equal []
+    end
+  end
+
   describe '#flatten' do
-    it 'extract the pairs into an array' do
+    it 'should extract the pairs into an array' do
       Bihash[:k1 => 'v1', :k2 => 'v2'].flatten.must_equal [:k1, 'v1', :k2, 'v2']
     end
 
@@ -574,7 +748,7 @@ describe Bihash do
     it 'should recompute all key hash values and return the bihash' do
       bh = Bihash[[] => :array]
       bh[:array] << 1
-      bh[[1]].must_equal nil
+      bh[[1]].must_be_nil
       bh.rehash[[1]].must_equal :array
       bh[[1]].must_equal :array
     end
@@ -591,14 +765,16 @@ describe Bihash do
   end
 
   describe '#reject' do
-    describe 'should return a bihash with items not rejected by the block' do
-      it 'when some items are rejected' do
+    describe 'when some items are rejected' do
+      it 'should return a bihash with items not rejected by the block' do
         bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
         bh.reject { |k1,k2| k1.even? }.must_equal Bihash[1 => :one, 3 => :three]
         bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       end
+    end
 
-      it 'when no items are rejected' do
+    describe 'when no items are rejected' do
+      it 'should return a bihash with items not rejected by the block' do
         bh = Bihash[1 => :one, 3 => :three, 5 => :five, 7 => :seven]
         bh.reject { |k1,k2| k1.even? }.must_equal bh
         bh.must_equal bh
@@ -622,7 +798,7 @@ describe Bihash do
 
     it 'should return nil if no changes were made to the bihash' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-      bh.reject! { |key1, key2| key1 > 5 }.must_equal nil
+      bh.reject! { |key1, key2| key1 > 5 }.must_be_nil
       bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
     end
 
@@ -658,14 +834,16 @@ describe Bihash do
   end
 
   describe '#select' do
-    describe 'should return a bihash with items selected by the block' do
-      it 'when only some items are selected' do
+    describe 'when only some items are selected' do
+      it 'should return a bihash with items selected by the block' do
         bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
         bh.select { |k1,k2| k1.even? }.must_equal Bihash[2 => :two, 4 => :four]
         bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       end
+    end
 
-      it 'when all items are selected' do
+    describe 'when all items are selected' do
+      it 'should return a bihash with items selected by the block' do
         bh = Bihash[2 => :two, 4 => :four, 6 => :six, 8 => :eight]
         bh.select { |k1,k2| k1.even? }.must_equal bh
         bh.must_equal bh
@@ -689,7 +867,7 @@ describe Bihash do
 
     it 'should return nil if no changes were made to the bihash' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-      bh.select! { |key1, key2| key1 < 5 }.must_equal nil
+      bh.select! { |key1, key2| key1 < 5 }.must_be_nil
       bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
     end
 
@@ -712,7 +890,7 @@ describe Bihash do
     end
 
     it 'should return the default value if bihash is empty' do
-      Bihash.new.shift.must_equal nil
+      Bihash.new.shift.must_be_nil
       Bihash.new(404).shift.must_equal 404
       Bihash.new { 'd3f4u17' }.shift.must_equal 'd3f4u17'
     end
@@ -736,6 +914,21 @@ describe Bihash do
       h.delete(:key1)
       bh.must_include :key1
     end
+
+    it 'should be an alias of #to_hash' do
+      bh = Bihash.new
+      bh.method(:to_hash).must_equal bh.method(:to_h)
+    end
+  end
+
+  describe '#to_proc' do
+    it 'should convert the bihash to a proc' do
+      Bihash[].to_proc.must_be_instance_of Proc
+    end
+
+    it 'should call #[] on the bihash when the proc is called' do
+      Bihash[:key => 'value'].to_proc.call(:key).must_equal 'value'
+    end
   end
 
   describe '#to_s' do

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'bihash'
 
-require 'minitest/spec'
 require 'minitest/autorun'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bihash
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Cohen Carlisle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-20 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,6 +84,7 @@ files:
 - bin/console
 - bin/setup
 - lib/bihash.rb
+- lib/bihash/unimplemented_methods.rb
 - lib/bihash/version.rb
 - spec/bihash_spec.rb
 - spec/spec_helper.rb
@@ -107,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Bidirectional Hash