concurrent_rails 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccce9fa2655fdbc3ef00101ac7f7720ee5de9e311575962eb312c38954149e13
-  data.tar.gz: 70064aa5b257d701d26d5e9f3fb5aef92b3fd4c03af0929eb80dcbd71cf5315b
+  metadata.gz: a745bd40255c338ca8e305b8d6477d91f6a249db984e613042df56f42af674b0
+  data.tar.gz: 7e141fc895855f868f0b1d34537ab27155c75ab8db3b833a237ca86ac889448e
 SHA512:
-  metadata.gz: 68180099bbcad8418c0dd39c00858302c574a1965fc287da8932d84c8e2399b7d44f90af16ec203be10bfdf6f77ef1f63569ba7452eca505377c4fa771b74a52
-  data.tar.gz: 586e968d8a723ae7e79230d9e1cddb043302a1eebff47e2ccd63b01e31b3ad7042d7bda2c4c0a16f18c54e1114aa135ca43691d5ab53f54e7854cf5471085c8c
+  metadata.gz: 8467ca3bd91d7393e163c85ac820d182a29df3cc5d8f52baf71fccb563c0a009fd54d125f5fa98598b9c051565479381e09b88e823f20f5c5dff8b909526e62d
+  data.tar.gz: 95b7ca4107bd52b51a769adb93b56ed1c54bf1bee8d797fc8db71524afec128b092a85505c2a0953c1458a21b551d0434ccfba591797385a148ed44c3cde33cd

data/README.md

@@ -40,7 +40,7 @@ irb(main):002:0> future.value
 
 ### Delayed futures
 
-Delayed future is a future that is enqueued but not run until `#touch` or any other method that requires a resolution is called.
+A delayed future is a Future that is enqueued but not run until `#touch` or any other method that requires a resolution is called.
 
 ```ruby
 irb(main):002:0> delay = ConcurrentRails::Promises.delay { 42 }
@@ -65,9 +65,9 @@ Three methods will trigger a resolution: `#touch`, `#value` and `#wait`: `#touch
 
 Delayed and regular futures can set a callback to be executed after the resolution of the future. There are three different callbacks:
 
-* `on_resolution`: runs after the future is resolved and yields three parameters to the callback in the following order: `true/false` for future's fulfillment, `value` as the result of the future execution, and `reason`, that will be `nil` if the future fulfilled or the error that the future triggered.
+* `on_resolution`: runs after the Future is resolved and yields three parameters to the callback in the following order: `true/false` for future's fulfillment, `value` as the result of the future execution, and `reason`, that will be `nil` if the future fulfilled or the error that the future triggered.
 
-* `on_fulfillment`: runs after the future is fulfilled and yields `value` to the callback
+* `on_fulfillment`: runs after the Future is fulfilled and yields `value` to the callback
 
 * `on_rejection`: runs after the future is rejected and yields the `error` to the callback
 
@@ -81,101 +81,9 @@ delay.touch
 
 All of these callbacks have a bang version (e.g. `on_fulfillment!`). The bang version will execute the callback on the same thread pool that was initially set up and the version without bang will run asynchronously on a different executor.
 
-### (Deprecated) Future
-
-`ConcurrentRails::Future` will execute your code in a separate thread and you can check the progress of it whenever you need it. When the task is ready, you can access the result with `#result` function:
-
-```ruby
-irb(main):001:0> future = ConcurrentRails::Future.new do
-  sleep(5) # Simulate a long running task
-  42
-end
-
-# at this point, nothing has happened yet.
-
-irb(main):002:0> future.execute
-
-irb(main):003:0> future.state
-=> :processing
-
-# after 5 seconds
-irb(main):004:0> future.state
-=> :fulfilled
-
-irb(main):005:0> future.value
-=> 42
-```
-
-A task can also fail. In this case, the state of the future will be `rejected` and the exception can be accessed by invoking `reason`
-
-```ruby
-irb(main):001:1* future = ConcurrentRails::Future.new do
-irb(main):002:1*   2 / 0
-irb(main):003:0> end.execute
-
-=> #<ConcurrentRails::Future...
-
-irb(main):004:0> future.state
-=> :rejected
-
-irb(main):005:0> future.reason
-=> #<ZeroDivisionError: divided by 0>
-```
-
-### (Deprecated) Multi
-
-`ConcurrentRails::Multi` will let you execute multiple tasks in parallel and aggregate the results of each task when they are done. `Multi` accepts an undefined number of `Proc`s.
-
-```ruby
-irb(main):001:1* multi = ConcurrentRails::Multi.enqueue(
-irb(main):002:1*   -> { 42 },
-irb(main):003:1*   -> { :multi_test }
-irb(main):004:0> )
-
-=> #<ConcurrentRails::Multi:0x00007fbc3f9ca3f8 @actions=[#<Proc:0x00007fbc3f9ca470..
-irb(main):005:0> multi.complete?
-=> true
-
-irb(main):006:0> multi.compute
-=> [42, :multi_test]
-```
-
-Given the fact that you can send any number of `Proc`s, the result from `compute` will always be an array, even if you provide only one proc.
-
-```ruby
-irb(main):007:1* multi = ConcurrentRails::Multi.enqueue(
-irb(main):008:1*   -> { 42 }
-irb(main):009:0> )
-=> #<ConcurrentRails::Multi:0x00007fbc403f0b98 @actions=[#<Proc:0x00007...
-
-irb(main):010:0> multi.compute
-=> [42]
-```
-
-Same as `Future`, one of the `Multi` tasks can fail. You can access the exception by calling `#errors`:
-
-```ruby
-irb(main):001:1*  multi = ConcurrentRails::Multi.enqueue(
-irb(main):002:1*    -> { 42 },
-irb(main):003:1*    -> { 2 / 0 }
-irb(main):004:0>  )
-=> #<ConcurrentRails::Multi:0x00007fb46d3ee3a0 @actions=[#<Proc:0x00007..
-
-irb(main):005:0> multi.complete?
-=> true
-
-irb(main):006:0> multi.compute
-=> [42, nil]
-
-irb(main):007:0> multi.errors
-=> [#<ZeroDivisionError: divided by 0>]
-```
-
-It is worth mention that a failed proc will return `nil`.
-
 ## Testing
 
-If you are using RSpec, you will notice that it might not play well with threads. ActiveRecord opens a database connection for every thread and since RSpec tests are wrapped in a transaction, by the time your promise tries to access something on the database, for example, a user, gems like Database Cleaner probably already triggered and deleted the user, resulting in `ActiveRecord::RecordNotFound` errors. You have a couple of solutions like disable transactional fixtures if you are using it or update the Database Cleaner strategy (that will result in much slower tests).
+If you are using RSpec, you will notice that it might not play well with threads. ActiveRecord opens a database connection for every thread and since RSpec tests are wrapped in a transaction, by the time your promise tries to access something on the database, for example, a user, gems like Database Cleaner probably already triggered and deleted the user, resulting in `ActiveRecord::RecordNotFound` errors. You have a couple of solutions like disabling transactional fixtures if you are using it or update the Database Cleaner strategy (that will result in much slower tests).
 Since none of these solutions were satisfactory to me, I created `ConcurrentRails::Testing` with two strategies: `immediate` and `fake`. When you wrap a Promise's `future` with `immediate`, the executor gets replaced from `:io` to `:immediate`. It still returns a promise anyway. This is not the case with `fake` strategy: it executes the task outside the `ConcurrentRails` engine and returns whatever `.value` would return:
 
 `immediate` strategy:
@@ -204,11 +112,11 @@ irb(main):004:0> result.class
 => Integer
 ```
 
-You can also set the stragegy globally using `ConcurrentRails::Testing.fake!` or `ConcurrentRails::Testing.immediate!`
+You can also set the strategy globally using `ConcurrentRails::Testing.fake!` or `ConcurrentRails::Testing.immediate!`
 
 ## Further reading
 
-For more information on how Futures work and how Rails handle multithread check these links:
+For more information on how Futures works and how Rails handles multithread check these links:
 
 [Future documentation](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)
 
@@ -236,7 +144,7 @@ gem install concurrent_rails
 
 ## Contributing
 
-Pull-requests are always welcome
+Pull requests are always welcome
 
 ## License
 

data/lib/concurrent_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConcurrentRails
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-16 00:00:00.000000000 Z
+date: 2024-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Multithread is hard