concurrent-ruby 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f224c72d89a1bd079ad1086c9ed28a1d4d6432c718b9e0624c9a32afc8500cc8
-  data.tar.gz: dfb811189c8e7eeb2ea1f17fc1e680657dffe767c77bb09312e85a4f29f2bd60
+  metadata.gz: 366b0c4f0d3184143a58a6b30538fe9997e7dfad19c8ea38a468168d680f3bdf
+  data.tar.gz: 010f0ee92f5132a2ed41da7d789a72955691dbcf880c579fd121cb366ba000bc
 SHA512:
-  metadata.gz: 807b1aac5e1bdee569df0b9e38fff1ed339f2c8569cd0a7ab565cbbecb23ffc9c6cf968e457e2acecf3abd187ac43da16dc2fb91716c912e78c08aa122dcaf0e
-  data.tar.gz: 07c37140aa1417ad32daa0de92f4c0883c7a96c1c53fba9aa09e34598632b3ad274283034064df41181e59964d0c79e41d083f17912e8e121c4f2d774c988b81
+  metadata.gz: 876b3302b218236cb89bd838e3030e2c5937d9682edd8e88a47d538ec5f0da21a7d49b55452e278e6c01b7210cb51c4bad3afc6b5767294f16890f5bd630e69b
+  data.tar.gz: 938906cad82d61617a0267dc28dc99e18420c7872593344c1c6adb4fa54c751839226703e1ce6ea81e79dcd35b2650e5868c6c11bcaf83c02d2fb105aa8b35a2

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Current
 
+* (#990) Add missing `require 'fiber'` for `FiberLocalVar`.
+* (#989) Optimize `Concurrent::Map#[]` on CRuby by letting the backing Hash handle the `default_proc`.
+
 ## Release v1.2.0 (23 Jan 2023)
 
 * (#962) Fix ReentrantReadWriteLock to use the same granularity for locals as for Mutex it uses.

data/Rakefile

@@ -271,6 +271,7 @@ namespace :release do
   task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
 
   namespace :publish do
+    publish_base = true
     publish_edge = false
 
     task :ask do
@@ -289,8 +290,8 @@ namespace :release do
     desc '** tag HEAD with current version and push to github'
     task :tag => :ask do
       Dir.chdir(__dir__) do
-        sh "git tag v#{Concurrent::VERSION}"
-        sh "git push origin v#{Concurrent::VERSION}"
+        sh "git tag v#{Concurrent::VERSION}" if publish_base
+        sh "git push origin v#{Concurrent::VERSION}" if publish_base
         sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
         sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
       end
@@ -299,11 +300,11 @@ namespace :release do
     desc '** push all *.gem files to rubygems'
     task :rubygems => :ask do
       Dir.chdir(__dir__) do
-        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
+        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem" if publish_base
         sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem"
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem" if publish_base
       end
     end
 

data/lib/concurrent-ruby/concurrent/atomic/locals.rb

@@ -1,3 +1,4 @@
+require 'fiber'
 require 'concurrent/utility/engine'
 require 'concurrent/constants'
 

data/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb

@@ -9,8 +9,8 @@ module Concurrent
     # @!visibility private
     class MriMapBackend < NonConcurrentMapBackend
 
-      def initialize(options = nil)
-        super(options)
+      def initialize(options = nil, &default_proc)
+        super(options, &default_proc)
         @write_lock = Mutex.new
       end
 

data/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb

@@ -12,8 +12,10 @@ module Concurrent
       # directly without calling each other. This is important because of the
       # SynchronizedMapBackend which uses a non-reentrant mutex for performance
       # reasons.
-      def initialize(options = nil)
-        @backend = {}
+      def initialize(options = nil, &default_proc)
+        validate_options_hash!(options) if options.kind_of?(::Hash)
+        @backend = Hash.new(&default_proc)
+        @default_proc = default_proc
       end
 
       def [](key)
@@ -55,7 +57,7 @@ module Concurrent
       end
 
       def compute(key)
-        store_computed_value(key, yield(@backend[key]))
+        store_computed_value(key, yield(get_or_default(key, nil)))
       end
 
       def merge_pair(key, value)
@@ -67,7 +69,7 @@ module Concurrent
       end
 
       def get_and_set(key, value)
-        stored_value = @backend[key]
+        stored_value = get_or_default(key, nil)
         @backend[key] = value
         stored_value
       end
@@ -109,13 +111,11 @@ module Concurrent
         @backend.fetch(key, default_value)
       end
 
-      alias_method :_get, :[]
-      alias_method :_set, :[]=
-      private :_get, :_set
       private
+
       def initialize_copy(other)
         super
-        @backend = {}
+        @backend = Hash.new(&@default_proc)
         self
       end
 

data/lib/concurrent-ruby/concurrent/map.rb

@@ -46,6 +46,12 @@ module Concurrent
     #   @note Atomic methods taking a block do not allow the `self` instance
     #     to be used within the block. Doing so will cause a deadlock.
 
+    # @!method []=(key, value)
+    #   Set a value with key
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [Object] the new value
+
     # @!method compute_if_absent(key)
     #   Compute and store new value for key if the key is absent.
     #   @param [Object] key
@@ -119,41 +125,38 @@ module Concurrent
     #   @return [true, false] true if deleted
     #   @!macro map.atomic_method
 
-    #
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
+    # NonConcurrentMapBackend handles default_proc natively
+    unless defined?(Collection::NonConcurrentMapBackend) and self < Collection::NonConcurrentMapBackend
 
-      super(options)
-      @default_proc = block
-    end
+      # @param [Hash, nil] options options to set the :initial_capacity or :load_factor. Ignored on some Rubies.
+      # @param [Proc] default_proc Optional block to compute the default value if the key is not set, like `Hash#default_proc`
+      def initialize(options = nil, &default_proc)
+        if options.kind_of?(::Hash)
+          validate_options_hash!(options)
+        else
+          options = nil
+        end
 
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-        # would be returned)
-        # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
+        super(options)
+        @default_proc = default_proc
       end
-    end
 
-    # Set a value with key
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object] the new value
-    def []=(key, value)
-      super
+      # Get a value with key
+      # @param [Object] key
+      # @return [Object] the value
+      def [](key)
+        if value = super # non-falsy value is an existing mapping, return it right away
+          value
+          # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # would be returned)
+          # note: nil == value check is not technically necessary
+        elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
+          @default_proc.call(self, key)
+        else
+          value
+        end
+      end
     end
 
     alias_method :get, :[]

data/lib/concurrent-ruby/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-23 00:00:00.000000000 Z
+date: 2023-02-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.