bihash 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a83c5fe6e801a94f9e8166a1d7fbad9cf217ceb6350d7028c8378934c641a523
-  data.tar.gz: daefa34c37020a266fc8f82e5acdd962b4f5a8db4dbf53ad61713be5cb6bc38f
+  metadata.gz: 60d3d7134bedfa4c64127bac82258cf0ff907b370a79a6cbe1e49639ae3d1972
+  data.tar.gz: b379a5ce66b2d3b1532fa7515299a04627465eb9ec2fe3178d8824eba55bdf20
 SHA512:
-  metadata.gz: 39bb9c095ceccc8229c2646f2b1f44cba29c957f202c93ff45bd0fdeffd8b1d3e1f875cfd895aa1086c0e546a8b1304945de473710a45161724929f142e95161
-  data.tar.gz: c93e9e0b8d0564921d52242874083c6b2d41b8c5b6d3dc7045e1d7013b2fbbeb4a1a913bda8f8231f6c281701dedab8b40adebb7d6129024408b449b27e99a47
+  metadata.gz: 419635498252cfa57afbaadb1034a284732ae9b2fa69d12b38848917587281b68ede9dfdc4f9341e48f9fb3209d0090316561a3b715d8e82cac2a1e1c02cfd81
+  data.tar.gz: 30f903147f6d270f8f2c9c275e6f12c33a87184b1fcf5ee4aa19dc7a313bb6e63e5d97a23d2cffad92ebd5425a80964b6017aa02b8215583226ca40d6eeb535d

data/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.2', '3.3', '3.4', '4.0']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rake spec

data/README.md

@@ -1,7 +1,6 @@
-[![Build Status](https://travis-ci.org/Cohen-Carlisle/bihash.svg?branch=master)](https://travis-ci.org/Cohen-Carlisle/bihash)
 # Bihash
 
-A simple gem that implements a bidrectional hash
+A simple gem that implements a bidirectional hash
 
 ## Usage
 

data/bihash.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'bihash/version'
 
@@ -10,15 +9,16 @@ Gem::Specification.new do |s|
   s.email         = ['cohen.carlisle@gmail.com']
 
   s.summary       = 'Bidirectional Hash'
-  s.description   = 'A simple gem that implements a bidrectional hash'
-  s.homepage      = 'http://rubygems.org/gems/bihash'
+  s.description   = 'A simple gem that implements a bidirectional hash'
+  s.homepage      = 'https://github.com/Cohen-Carlisle/bihash'
   s.license       = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
   s.require_paths = ['lib']
 
-  s.add_development_dependency 'bundler', '~> 1.11'
-  s.add_development_dependency 'rake', '>= 10'
-  s.add_development_dependency 'minitest', '~> 5.5'
-  s.add_development_dependency 'pry', '~> 0.10'
+  s.required_ruby_version = '>= 3.2'
+
+  s.add_development_dependency 'rake', '~> 13.2'
+  s.add_development_dependency 'minitest', '~> 5.25'
+  s.add_development_dependency 'irb', '~> 1.14'
 end

data/bin/console

@@ -2,5 +2,5 @@
 require 'bundler/setup'
 require 'bihash'
 
-require 'pry'
-Pry.start
+require 'irb'
+IRB.start

data/lib/bihash/unimplemented_methods.rb

@@ -1,6 +1,20 @@
-require 'set'
-
 class Bihash
+  UNIMPLEMENTED_CLASS_METHODS = Set[
+    # a bihash is not converted to keyword args like Hash instances can be
+    'ruby2_keywords_hash',
+    'ruby2_keywords_hash?'
+  ]
+
+  def self.respond_to?(method, private = false)
+    UNIMPLEMENTED_CLASS_METHODS.include?(method.to_s) ? false : super
+  end
+
+  UNIMPLEMENTED_CLASS_METHODS.each do |method|
+    define_singleton_method(method) do |*|
+      raise NoMethodError, "Bihash::#{method} not implemented"
+    end
+  end
+
   UNIMPLEMENTED_METHODS = Set[
     # expected to only deal with half the hash: keys or values
     'keys',
@@ -13,15 +27,11 @@ class Bihash
     'transform_values!',
     # O(n) reverse lookups
     'key',
-    'index',
     'rassoc',
     'value?',
     'has_value?',
     # meaningless on bihash as both sides already hashed
-    'invert',
-    # mass removal of nil, but a bihash can have only one pair containing nil
-    'compact',
-    'compact!'
+    'invert'
   ]
 
   def respond_to?(method, private = false)

data/lib/bihash/version.rb

@@ -1,3 +1,3 @@
 class Bihash
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/lib/bihash.rb

@@ -11,32 +11,38 @@ class Bihash
   end
 
   def self.try_convert(arg)
-    h = Hash.try_convert(arg)
-    h && new_from_hash(h)
+    if arg.is_a?(self)
+      arg
+    else
+      h = Hash.try_convert(arg)
+      h && self[h]
+    end
   end
 
   def <(rhs)
     raise_error_unless_bihash(rhs)
-    merged_hash_attrs < rhs.send(:merged_hash_attrs)
+    size < rhs.size && subset?(rhs)
   end
 
   def <=(rhs)
     raise_error_unless_bihash(rhs)
-    merged_hash_attrs <= rhs.send(:merged_hash_attrs)
+    size <= rhs.size && subset?(rhs)
   end
 
   def ==(rhs)
-    rhs.is_a?(self.class) && merged_hash_attrs == rhs.send(:merged_hash_attrs)
+    rhs.is_a?(self.class) &&
+      size == rhs.size &&
+      merged_hash_attrs.eql?(rhs.send(:merged_hash_attrs))
   end
 
   def >(rhs)
     raise_error_unless_bihash(rhs)
-    merged_hash_attrs > rhs.send(:merged_hash_attrs)
+    size > rhs.size && rhs.send(:subset?, self)
   end
 
   def >=(rhs)
     raise_error_unless_bihash(rhs)
-    merged_hash_attrs >= rhs.send(:merged_hash_attrs)
+    size >= rhs.size && rhs.send(:subset?, self)
   end
 
   def [](key)
@@ -68,8 +74,19 @@ 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
+    if illegal_state?(compare_by_id: true)
+      raise 'Cannot set compare_by_identity while a key is duplicated outside its own pair'
+    end
     @forward.compare_by_identity
     @reverse.compare_by_identity
     self
@@ -110,6 +127,10 @@ class Bihash
     @default_proc = arg
   end
 
+  def deconstruct_keys(_keys)
+    merged_hash_attrs
+  end
+
   def delete(key)
     raise_error_if_frozen
     if @forward.key?(key)
@@ -129,12 +150,12 @@ class Bihash
       @forward.each { |k,v| delete(k) if yield(k,v) }
       self
     else
-      to_enum(:delete_if)
+      to_enum(:delete_if) { size }
     end
   end
 
-  def dig(*keys)
-    (@forward.key?(keys[0]) ? @forward : @reverse).dig(*keys)
+  def dig(key, *rest)
+    rest.empty? ? self[key] : self[key]&.dig(*rest)
   end
 
   def each(&block)
@@ -142,7 +163,7 @@ class Bihash
       @forward.each(&block)
       self
     else
-      to_enum(:each)
+      to_enum(:each) { size }
     end
   end
 
@@ -152,19 +173,27 @@ class Bihash
 
   alias :eql? :==
 
+  def except(*args)
+    dup_without_defaults.tap do |bh|
+      args.each do |arg|
+        bh.delete(arg)
+      end
+    end
+  end
+
   def fetch(key, *default, &block)
     (@forward.key?(key) ? @forward : @reverse).fetch(key, *default, &block)
   end
 
-  def fetch_values(*keys)
-    keys.map { |key| fetch(key) }
+  def fetch_values(*keys, &block)
+    keys.map { |key| fetch(key, &block) }
   end
 
   def filter(&block)
     if block_given?
-      dup.tap { |d| d.select!(&block) }
+      dup_without_defaults.tap { |d| d.select!(&block) }
     else
-      to_enum(:select)
+      to_enum(:select) { size }
     end
   end
 
@@ -175,7 +204,7 @@ class Bihash
       keep_if(&block)
       old_size == size ? nil : self
     else
-      to_enum(:select!)
+      to_enum(:select!) { size }
     end
   end
 
@@ -201,7 +230,7 @@ class Bihash
       @forward.each { |k,v| delete(k) unless yield(k,v) }
       self
     else
-      to_enum(:keep_if)
+      to_enum(:keep_if) { size }
     end
   end
 
@@ -211,14 +240,18 @@ class Bihash
 
   alias :member? :has_key?
 
-  def merge(other_bh)
-    dup.merge!(other_bh)
+  def merge(*other_bhs)
+    dup.merge!(*other_bhs)
   end
 
-  def merge!(other_bh)
+  def merge!(*other_bhs)
+    # NOTE: merge/merge!/update intentionally do not implement block support yet
+    #       see https://github.com/Cohen-Carlisle/bihash/issues/17
     raise_error_if_frozen
-    raise_error_unless_bihash(other_bh)
-    other_bh.each { |k,v| store(k,v) }
+    other_bhs.each do |other_bh|
+      raise_error_unless_bihash(other_bh)
+      other_bh.each { |k,v| store(k,v) }
+    end
     self
   end
 
@@ -234,9 +267,9 @@ class Bihash
 
   def reject(&block)
     if block_given?
-      dup.tap { |d| d.reject!(&block) }
+      dup_without_defaults.tap { |d| d.reject!(&block) }
     else
-      to_enum(:reject)
+      to_enum(:reject) { size }
     end
   end
 
@@ -247,15 +280,17 @@ class Bihash
       delete_if(&block)
       old_size == size ? nil : self
     else
-      to_enum(:reject!)
+      to_enum(:reject!) { size }
     end
   end
 
   def replace(other_bh)
     raise_error_if_frozen
     raise_error_unless_bihash(other_bh)
-    @forward.replace(other_bh.instance_variable_get(:@forward))
-    @reverse.replace(other_bh.instance_variable_get(:@reverse))
+    @forward = other_bh.instance_variable_get(:@forward).dup
+    @reverse = other_bh.instance_variable_get(:@reverse).dup
+    @default = other_bh.default
+    @default_proc = other_bh.default_proc
     self
   end
 
@@ -265,20 +300,17 @@ class Bihash
 
   def shift
     raise_error_if_frozen
-    if empty?
-      default_value(nil)
-    else
-      @reverse.shift
-      @forward.shift
-    end
+    @reverse.shift
+    @forward.shift
   end
 
   def_delegator :@forward, :size
 
   def slice(*args)
-    self.class.new.tap do |bh|
+    self.class.new.tap do |new_bh|
+      new_bh.compare_by_identity if compare_by_identity?
       args.each do |arg|
-        bh[arg] = self[arg] if key?(arg)
+        new_bh[arg] = self[arg] if key?(arg)
       end
     end
   end
@@ -286,10 +318,16 @@ class Bihash
   alias :store :[]=
 
   def to_h
-    @forward.dup
+    if block_given?
+      @forward.to_h { |k,v| yield(k,v) }
+    else
+      @forward.dup
+    end
   end
 
-  alias :to_hash :to_h
+  def to_hash
+    to_h
+  end
 
   def to_proc
     method(:[]).to_proc
@@ -306,6 +344,7 @@ class Bihash
   private
 
   def self.new_from_hash(h)
+    h = Hash[h.to_a] if h.compare_by_identity? && RUBY_VERSION.to_f < 3.3
     bihash = new
     bihash.instance_variable_set(:@reverse, h.invert)
     bihash.instance_variable_set(:@forward, h)
@@ -320,12 +359,22 @@ class Bihash
     @default_proc ? @default_proc.call(self, key) : @default
   end
 
-  def illegal_state?
-    fw = @forward
-    (fw.keys | fw.values).size + fw.select { |k,v| k == v }.size < fw.size * 2
+  def dup_without_defaults
+    dup.tap { |bh| bh.default = nil }
   end
 
-  def initialize(*args, &block)
+  def illegal_state?(compare_by_id: compare_by_identity?)
+    if compare_by_id
+      unique_members = (@forward.keys + @forward.values).uniq(&:object_id).count
+      duplicate_pairs = @forward.count { |k,v| k.equal?(v) }
+    else
+      unique_members = (@forward.keys | @forward.values).count
+      duplicate_pairs = @forward.count { |k,v| k.eql?(v) }
+    end
+    unique_members + duplicate_pairs < @forward.length * 2
+  end
+
+  def initialize(*args, capacity: 0, &block)
     raise_error_if_frozen
     if block_given? && !args.empty?
       raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
@@ -333,21 +382,22 @@ class Bihash
       raise ArgumentError, "wrong number of arguments (#{args.size} for 0..1)"
     end
     super()
-    @forward, @reverse = {}, {}
+    if RUBY_VERSION.to_f < 3.4
+      @forward, @reverse = {}, {}
+    else
+      @forward, @reverse = Hash.new(capacity:), Hash.new(capacity:)
+    end
     @default, @default_proc = args[0], block
   end
 
-  def initialize_copy(source)
-    super
-    @forward, @reverse = @forward.dup, @reverse.dup
-  end
+  alias :initialize_copy :replace
 
   def merged_hash_attrs
     @reverse.merge(@forward)
   end
 
   def raise_error_if_frozen
-    raise "can't modify frozen Bihash" if frozen?
+    raise FrozenError, "can't modify frozen Bihash" if frozen?
   end
 
   def raise_error_unless_bihash(obj)
@@ -355,4 +405,8 @@ class Bihash
       raise TypeError, "wrong argument type #{obj.class} (expected Bihash)"
     end
   end
+
+  def subset?(other_bh)
+    @forward.all? { |k,v| other_bh.key?(k) && other_bh[k].eql?(v) }
+  end
 end