standard-procedure-async 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b92c0e8440b6f2ad4b0c95cc83ac562ece4124490f15982f1d6531efec3ca2b1
+  data.tar.gz: ba0100a22ccbf8c572489111b841bdee403347e2f3a65172b8584594ebd026e5
+SHA512:
+  metadata.gz: ec6d3846f51149189ae18dffbf38af10cbb9c317ac9b546b1e336b726219d040b7b0d5fab65dd4a33c1be079ad093703947236c46ce1345af0f33cc5474bb50d
+  data.tar.gz: fb99264092314bad0f9c4c1e7d1061e2530456bf59b409eadbbe6f5f4a216ad69d71a5abd2fd3a74c4d0c1de0d9fa4f50b7f2053259de9435bfd3e9f7eb34fc8

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-05-30
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in standard-procedure-async.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "standard", "~> 1.3"

data/Gemfile.lock

@@ -0,0 +1,134 @@
+PATH
+  remote: .
+  specs:
+    standard-procedure-async (0.1.0)
+      concurrent-ruby (>= 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (7.0.5)
+      actionview (= 7.0.5)
+      activesupport (= 7.0.5)
+      rack (~> 2.0, >= 2.2.4)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (7.0.5)
+      activesupport (= 7.0.5)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (7.0.5)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.2.2)
+    concurrent_rails (0.4.1)
+      railties (>= 5.2)
+    crass (1.0.6)
+    diff-lcs (1.5.0)
+    erubi (1.12.0)
+    i18n (1.13.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.0.0)
+    loofah (2.21.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    method_source (1.0.0)
+    minitest (5.18.0)
+    nokogiri (1.15.2-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.2-x86_64-linux)
+      racc (~> 1.4)
+    parallel (1.23.0)
+    parser (3.2.2.1)
+      ast (~> 2.4.1)
+    racc (1.6.2)
+    rack (2.2.7)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (7.0.5)
+      actionpack (= 7.0.5)
+      activesupport (= 7.0.5)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.0)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.50.2)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.1)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.16.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    standard (1.28.2)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.0.1)
+    standard-custom (1.0.0)
+      lint_roller (~> 1.0)
+    standard-performance (1.0.1)
+      lint_roller (~> 1.0)
+      rubocop-performance (~> 1.16.0)
+    thor (1.2.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    zeitwerk (2.6.8)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  activesupport
+  concurrent_rails
+  railties
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  standard (~> 1.3)
+  standard-procedure-async!
+
+BUNDLED WITH
+   2.3.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Rahoul Baruah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# Standard::Procedure::Async
+
+## The Actor model
+
+The [Actor Model](https://en.wikipedia.org/wiki/Actor_model) is widely regarded as one of the safest ways to write thread-safe code.  Each "actor" maintains a single internal thread and as messages are received by the actor (via method calls), the thread responds to those messages sequentially.  This means that no matter which thread sends a message to the actor, the actor's internal behaviour is always thread-safe.  
+
+The actual implementation does not use a thread-per-object as that could get very costly.  Instead, each actor maintains a queue of incoming messages and then uses a [Future](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html) to actually perform those messages.  The future uses a thread which is allocated from Concurrent Ruby's internal thread pool, freeing up resources when the system is quiet and increasing the number of workers when the system is busy.  
+
+## Why does this gem exist?
+
+Two reasons.  
+
+Concurrent-ruby has a simple implementation of this model, using the [Async](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Async.html) mixin.  However, Concurrent::Async uses [IVar](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/IVar.html)s which are now deprecated.  
+
+In addition, while concurrent-ruby is an excellent library, it does not work well with Ruby on Rails.  The [Rails Executor](https://guides.rubyonrails.org/threading_and_code_execution.html) ensures that any threads interact safely with the framework.  But concurrent-ruby knows nothing about the executor.
+
+Finally, using the actor model is infectious.  If you mark a public method as asynchronous, in order to be safe, you have to mark them all as asynchronous.  Concurrent::Async's syntax relies on the caller using `@my_object.async.my_method` which means that it is easy to forget and miss an asynchronous call.  Which in turn will result in inconsistent behaviour and hard to trace bugs.  
+
+So [Standard::Procedure::Async::Actor](https://github.com/standard-procedure/async/blob/main/lib/standard/procedure/async/actor.rb) replaces the IVars with a mix of Futures and MVars.  The MVar is used to transfer the return values of any methods back to the calling thread and the Future is used to do the work in a separate thread.  
+
+In addition, if you are in a Ruby on Rails project, Standard::Procedure::Async uses [Luiz Kowalski](https://github.com/luizkowalski)'s [concurrent_rails](https://github.com/luizkowalski/concurrent_rails) gem.  This is a layer above concurrent-ruby's Futures that ensure any future code is run within the Rails Executor.  
+
+Finally, instead of relying on the caller to call `async` on asynchronous methods, we define the asynchronous methods on the class itself with the `async` definition.  The caller simply uses `@my_object.my_method` and it will always be run safely in an alternate thread.  There is also an implementation of `await`, making it easy to resolve the results of your method calls.  
+
+## Adding `async` and `await` capabilities to ruby objects
+
+Instead of defining methods on your class with ruby's `def` keyword, include the [Standard::Procedure::Async::Actor](https://github.com/standard-procedure/async/blob/main/lib/standard/procedure/async/actor.rb) module and use the `async` class method.  
+
+When you call an asynchronous method, it immediately returns an internal message object.  If you don't care about the return value from the method, you can discard this object immediately.  But if you do need the return value, you can call `value` on this message object - and your thread will then wait until the return value is ready.  Alternatively, you can use `await`, effectively turning your asynchronous method into a synchronous one.  
+
+An added bonus (or negative, depending upon your point of view) is that this syntax is very similar to Javascript's async/await pairing, which similarly marks out asychronous function calls and waits until any Promises are ready to return their values.  
+
+Example usage:
+```ruby
+class MyObject 
+  include Standard::Procedure::Async::Actor 
+
+  def initialize name 
+    @name = name 
+    @status = :idle
+  end
+
+  async :report_status do 
+    @status
+  end
+
+  async :greet do 
+    "Hello #{@name}".freeze
+  end
+
+  async :rename do |new_name|
+    @name = new_name.freeze
+  end 
+
+  async :do_some_long_running_task do 
+    @status = :in_progress
+    do_part_two_of_the_long_running_task
+    @status 
+  end
+
+  private 
+
+  async :do_part_two_of_the_long_running_task do 
+    sleep 10 
+    _rename "John"
+    @status = :done
+  end
+end
+
+@my_object = MyObject.new "George"
+
+puts await { @my_object.greet } # => "Hello George"
+await { @my_object.rename "Ringo" }
+puts await { @my_object.greet } # => "Hello Ringo"
+@my_object.rename "Paul" # Note: we didn't use await here - we'll talk about that later
+puts await { @my_object.greet } # => "Hello Paul"
+
+@initial_status = @my_object.do_some_long_running_task 
+puts @initial_status # => a internal message object
+puts @initial_status.value # => :in_progress
+sleep 11
+@final_status = await { @my_object.report_status }
+puts @final_status # => :done
+puts await { @my_object.greet } # => Hello John
+```
+
+### Defining asynchronous methods
+
+When defining `MyObject`, we use `async` instead of `def` for each method.  For example, we use `async :greet` instead of `def greet`.  This creates two methods - `greet` and `_greet`.  `_greet` is the actual implementation of the method and `greet` is the asynchronous wrapper around it.  
+
+### Awaiting the results from those methods
+
+The asynchronous wrapper always returns an object containing a [Concurrent::MVar](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MVar.html) which is empty until the actor has completed its work.  
+
+If you need the return value from the method, there are two ways to access it.  
+
+You can call `value` on the returned object, or you can use the `await` method (which is just a fancy wrapper around `value`).  In both cases the calling thread will block until the value is returned.  In the example above, you can see what happens if you use neither of these methods - `puts @initial_status` returns the internal message object itself, not any meaningful information.  The next line then calls `@initial_status.value` to wait until the return value is generated.  
+
+### The sequence of asynchronous calls
+
+In the example above there is the following code:
+
+```ruby
+@my_object.rename "Paul"
+puts await { @my_object.greet } # => "Hello Paul"
+```
+The call to `rename` is asynchronous, so you may expect that sometimes the following call to `greet` would return "Hello Paul" and other times it would return "Hello Ringo" (the previous value) - depending on the timing of the two calls.  
+
+However, it will _always_ return "Hello Paul".  
+
+This is because internally, the actor queues all method calls.  So even if the call to `rename` takes a long time to complete, the subsequent call to `greet` will not start until `rename` has finished.  
+
+Another example of the same behaviour is in `do_some_long_running_task`:
+
+```ruby
+  async :do_some_long_running_task do 
+    @status = :in_progress
+    do_part_two_of_the_long_running_task
+    @status 
+  end
+```
+
+When `@my_object.do_some_long_running_task` is called, the message `do_some_long_running_task` is added to the queue.  
+
+When the queue starts processing that message, `_do_some_long_running_task` (the implementation of the method) changes the status to :in_progress, then adds `do_part_two_of_the_long_running_task` to the message queue.  This second message will _not_ start processing immediately as it is behind the unfinished `do_some_long_running_task`.  `_do_some_long_running_task` returns the value of status (which is still :in_progress) and completes, which allows the next message on the queue to start.  And that next message is probably `do_part_two_of_the_long_running_task` - but it might not be, as other threads may have got there first.  
+
+### The rules of using actors
+
+- If you make a public method asynchronous, you need to make _all_ public methods asynchronous.  You cannot mix and match asynchronous and synchronous usage. The simplest way to comply is to make all your public methods as `async` and your protected and private methods as synchronous.  If you have to call an async method on `self` use the internal implementation (which starts with `_`).
+- Never make internal instance variables directly accessible without an asynchronous method call.  Do not use `attr_reader` or `attr_accessor` -  these will bypass the internal queue and you may get inconsistent results from the actor.  For the same reason, never update internal variables outside of an asynchronous call.  
+- When an object is calling its own internal methods, never use `await` or `value` as this will cause your actor to block indefinitely.  If you don't care about the return value or if it does not matter when the method starts and finishes, call the asynchronous method.  If you need the return value or need to be sure that the method runs immediately then use the internal implementation - `_rename` instead of `rename`.
+- Avoid class variables.  These are effectively global variables that are accessible without any locking around them, so you could get inconsistent results.  If you must have class variables, intialize them on startup and if they are mutable, use concurrent-ruby's thread-safe objects.  
+
+## Making Rails work with Concurrent-Ruby
+
+[Concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) is amazing, providing an extensive suite of tools to make multi-threaded programming as safe as it can possibly be in ruby (which isn't perfect, as ruby's dynamic semantics make it impossible to be completely safe).  
+
+However, concurrent-ruby doesn't play well with [Ruby on Rails](https://rubyonrails.org).  Rails is a big complex framework that auto-loads code and has lots of data stored in class variables (which are effectively globals that can be written to and read from any thread at any time).  Therefore it includes the [Rails Executor](https://guides.rubyonrails.org/threading_and_code_execution.html) which ensures that the framework is aware when other threads may be touching Rails code.  
+
+This gem checks to see if `Rails` is defined, and if so, it attempts to load [Luiz Kowalski](https://github.com/luizkowalski)'s [concurrent_rails](https://github.com/luizkowalski/concurrent_rails) gem.  This provides a wrapper around concurrent-ruby's [Promises](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html) factory that ensures the Rails Executor is loaded before the threaded code is run.  This gem then uses the concurrent-rails Future instead of concurrent-ruby's Future, so it can be sure that your code is both thread-safe and rails-safe.  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'standard-procedure-async'
+```
+
+If you are using Ruby on Rails, you must also add in the `concurrent_rails` gem, or this gem will raise an error when you try to use it.
+
+```ruby
+gem 'concurrent_rails'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install standard-procedure-async
+
+## Development
+
+Coming soon
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/standard-procedure-async.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/lib/standard/procedure/async/actor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "concurrent/array"
+require "concurrent/mvar"
+require "concurrent/immutable_struct"
+
+module Standard::Procedure::Async
+  module Actor
+    def self.included base
+      base.class_eval do
+        extend ClassMethods
+
+        def initialize *args
+          super
+          @_messages = Concurrent::Array.new
+        end
+      end
+    end
+
+    module ClassMethods
+      def async name, &implementation
+        name = name.to_sym
+        implementation_name = :"_#{name}"
+
+        define_method name.to_sym do |*args, &block|
+          _add_message_to_queue(implementation_name, *args, &block)
+        end
+
+        define_method implementation_name do |*args, &block|
+          implementation.call(*args, &block)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :_messages
+
+    def _add_message_to_queue name, *args, &block
+      message = Message.new(self, name, args, block, Concurrent::MVar.new)
+      _messages << message
+      _perform_messages if _messages.count == 1
+      message
+    end
+
+    def _perform_messages
+      Standard::Procedure::Async.promises.future do
+        while (message = _messages.shift)
+          message.call
+        end
+      end
+    end
+
+    class Message < Concurrent::ImmutableStruct.new(:target, :name, :args, :block, :result)
+      def value
+        result.take
+      end
+
+      def call
+        result.put target.send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/standard/procedure/async/await.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def await &block
+    block.call.value
+  end
+end

data/lib/standard/procedure/async/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Standard::Procedure::Async
+  class Error < StandardError
+  end
+end

data/lib/standard/procedure/async/promises.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "rails_not_loaded_error"
+require "concurrent/promises"
+
+module Standard::Procedure::Async
+  class Promises
+    def initialize
+      @promises = rails_is_loaded? ? ConcurrentRails::Promises : Concurrent::Promises
+    end
+
+    attr_reader :promises
+
+    def future &block
+      @promises.future(&block)
+    end
+
+    private
+
+    def rails_is_loaded?
+      return false if !defined?(Rails::Railtie)
+      raise RailsNotLoadedError if !defined?(ConcurrentRails) || !defined?(Rails::Railtie)
+      true
+    end
+  end
+end

data/lib/standard/procedure/async/rails_not_loaded_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Standard::Procedure::Async
+  class RailsNotLoadedError < Error
+  end
+end

data/lib/standard/procedure/async/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Standard
+  module Procedure
+    module Async
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/standard/procedure/async.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "async/version"
+require_relative "async/error"
+require_relative "async/promises"
+require_relative "async/actor"
+require_relative "async/await"
+module Standard
+  module Procedure
+    module Async
+      def self.promises
+        @promises ||= Promises.new
+      end
+    end
+  end
+end

data/sig/standard/procedure/async.rbs

@@ -0,0 +1,8 @@
+module Standard
+  module Procedure
+    module Async
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

data/standard-procedure-async.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/standard/procedure/async/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "standard-procedure-async"
+  spec.version = Standard::Procedure::Async::VERSION
+  spec.authors = ["Rahoul Baruah"]
+  spec.email = ["rahoulb@standardprocedure.app"]
+
+  spec.summary = "A simple wrapper around Concurrent::Future to make concurrent-ruby Rails-friendly."
+  spec.description = "Provides a wrapper around concurrent-ruby's Concurrent::Future to automatically wrap it in a Rails-friendly executor."
+  spec.homepage = "https://github.com/standard-procedure/async"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/standard-procedure/async"
+  spec.metadata["changelog_uri"] = "https://github.com/standard-procedure/async/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "concurrent-ruby", ">= 1.0"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "railties"
+  spec.add_development_dependency "concurrent_rails"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: standard-procedure-async
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rahoul Baruah
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides a wrapper around concurrent-ruby's Concurrent::Future to automatically
+  wrap it in a Rails-friendly executor.
+email:
+- rahoulb@standardprocedure.app
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/standard/procedure/async.rb
+- lib/standard/procedure/async/actor.rb
+- lib/standard/procedure/async/await.rb
+- lib/standard/procedure/async/error.rb
+- lib/standard/procedure/async/promises.rb
+- lib/standard/procedure/async/rails_not_loaded_error.rb
+- lib/standard/procedure/async/version.rb
+- sig/standard/procedure/async.rbs
+- standard-procedure-async.gemspec
+homepage: https://github.com/standard-procedure/async
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/standard-procedure/async
+  source_code_uri: https://github.com/standard-procedure/async
+  changelog_uri: https://github.com/standard-procedure/async/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.12
+signing_key:
+specification_version: 4
+summary: A simple wrapper around Concurrent::Future to make concurrent-ruby Rails-friendly.
+test_files: []