iopromise 0.1.0

data/lib/iopromise/faraday/executor_pool.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'continuable_hydra'
+
+module IOPromise
+  module Faraday
+    class FaradayExecutorPool < IOPromise::ExecutorPool::Base
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        # mark all pending promises as executing since they could be started any time now.
+        # ideally we would do this on dequeue.
+        @pending.each do |promise|
+          begin_executing(promise) unless promise.started_executing?
+        end
+
+        ContinuableHydra.for_current_thread.execute_continue(ready_readers, ready_writers, ready_exceptions)
+      end
+    end
+  end
+end

data/lib/iopromise/faraday/multi_socket_action.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'ethon'
+
+Ethon::Curl.ffi_lib 'curl'
+Ethon::Curl.attach_function :multi_socket_action, :curl_multi_socket_action, [:pointer, :int, :int, :pointer], :multi_code
+
+module IOPromise
+  module Faraday
+    class MultiSocketAction < Ethon::Multi
+      CURL_POLL_NONE = 0
+      CURL_POLL_IN = 1
+      CURL_POLL_OUT = 2
+      CURL_POLL_INOUT = 3
+      CURL_POLL_REMOVE = 4
+    
+      CURL_SOCKET_BAD = -1
+      CURL_SOCKET_TIMEOUT = CURL_SOCKET_BAD
+    
+      CURLM_OK = 0
+
+      CURL_CSELECT_IN  = 0x01
+      CURL_CSELECT_OUT = 0x02
+      CURL_CSELECT_ERR = 0x04
+      
+      def initialize(options = {})
+        super(options)
+    
+        @read_fds = {}
+        @write_fds = {}
+        @select_timeout = nil
+    
+        self.socketfunction = @keep_socketfunction = proc do |handle, sock, what, userp, socketp|
+          if what == CURL_POLL_REMOVE
+            @read_fds.delete(sock)
+            @write_fds.delete(sock)
+          else
+            # reuse existing if we have it anywhere
+            io = @read_fds[sock] || @write_fds[sock] || IO.for_fd(sock).tap { |io| io.autoclose = false }
+            if what == CURL_POLL_INOUT
+              @read_fds[sock] = io
+              @write_fds[sock] = io
+            elsif what == CURL_POLL_IN
+              @read_fds[sock] = io
+              @write_fds.delete(sock)
+            elsif what == CURL_POLL_OUT
+              @read_fds.delete(sock)
+              @write_fds[sock] = io
+            end
+          end
+          CURLM_OK
+        end
+    
+        self.timerfunction = @keep_timerfunction = proc do |handle, timeout_ms, userp|
+          if timeout_ms > 0x7fffffffffffffff # FIXME: wrongly encoded
+            @select_timeout = nil
+          else
+            @select_timeout = timeout_ms.to_f / 1_000
+          end
+          CURLM_OK
+        end
+      end
+    
+      def perform
+        # stubbed out, we don't want any of the multi_perform logic
+      end
+    
+      def run
+        # stubbed out, we don't want any of the multi_perform logic
+      end
+    
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        running_handles = ::FFI::MemoryPointer.new(:int)
+        
+        flags = Hash.new(0)
+    
+        unless ready_readers.nil?
+          ready_readers.each do |s|
+            flags[s.fileno] |= CURL_CSELECT_IN
+          end
+        end
+        unless ready_writers.nil?
+          ready_writers.each do |s|
+            flags[s.fileno] |= CURL_CSELECT_OUT
+          end
+        end
+        unless ready_exceptions.nil?
+          ready_exceptions.each do |s|
+            flags[s.fileno] |= CURL_CSELECT_ERR
+          end
+        end
+        
+        flags.each do |fd, bitmask|
+          Ethon::Curl.multi_socket_action(handle, fd, bitmask, running_handles)
+        end
+    
+        if flags.empty?
+          Ethon::Curl.multi_socket_action(handle, CURL_SOCKET_TIMEOUT, 0, running_handles)
+        end
+    
+        check
+    
+        [@read_fds.values, @write_fds.values, [], @select_timeout]
+      end
+    end
+  end
+end

data/lib/iopromise/faraday/promise.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'continuable_hydra'
+require_relative 'executor_pool'
+
+module IOPromise
+  module Faraday
+    class FaradayPromise < ::IOPromise::Base
+      def self.parallel_manager
+        ContinuableHydra.for_current_thread
+      end
+    
+      def initialize(response = nil)
+        super()
+    
+        @response = response
+        @started = false
+
+        unless @response.nil?
+          @response.on_complete do |response_env|
+            fulfill(@response)
+            execute_pool.complete(self)
+          end
+        end
+    
+        ::IOPromise::ExecutorContext.current.register(self) unless @response.nil?
+      end
+    
+      def wait
+        if @response.nil?
+          super
+        else
+          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
+        end
+      end
+    
+      def execute_pool
+        FaradayExecutorPool.for(Thread.current)
+      end
+    end
+  end
+end

data/lib/iopromise/memcached.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'memcached/client'
+
+module IOPromise
+  module Memcached
+    class << self
+      def new(*args, **kwargs)
+        ::IOPromise::Memcached::Client.new(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/iopromise/memcached/client.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'memcached'
+require_relative 'promise'
+
+module IOPromise
+  module Memcached
+    class Client
+      def initialize(*args, **kwargs)
+        if args.first.is_a?(::Memcached::Client)
+          @client = args.first.clone
+        else
+          @client = ::Memcached::Client.new(*args, **kwargs)
+        end
+      end
+
+      def get_as_promise(key)
+        MemcachePromise.new(@client, key)
+      end
+    end
+  end
+end

data/lib/iopromise/memcached/executor_pool.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module Memcached
+    class MemcacheExecutorPool < ::IOPromise::ExecutorPool::Batch
+      def next_batch
+        super
+
+        unless @current_batch.empty?
+          @keys_to_promises = @current_batch.group_by { |promise| promise.key }
+          @current_batch.each { |promise| begin_executing(promise) }
+          begin
+            memcache_client.begin_get_multi(@keys_to_promises.keys)
+          rescue => e
+            @keys_to_promises.values.flatten.each do |promise|
+              promise.reject(e)
+              complete(promise)
+              @current_batch.delete(promise)
+            end
+
+            @keys_to_promises = nil
+          end
+        end
+      end
+
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        if @current_batch.empty?
+          next_batch
+        end
+
+        return [[], [], [], nil] if @current_batch.empty?
+
+        so_far, readers, writers = memcache_client.continue_get_multi
+
+        # when we're done (nothing to wait on), fill in any remaining keys with nil for completions to occur
+        if readers.empty? && writers.empty?
+          @keys_to_promises.each do |key, _|
+            so_far[key] = nil unless so_far.include? key
+          end
+        end
+
+        so_far.each do |key, value|
+          next unless @keys_to_promises[key]
+          @keys_to_promises[key].each do |promise|
+            next if promise.fulfilled?
+
+            promise.fulfill(value)
+            complete(promise)
+            @current_batch.delete(promise)
+          end
+        end
+
+        [readers, writers, [], nil]
+      end
+
+      def memcache_client
+        @connection_pool
+      end
+    end
+  end
+end

data/lib/iopromise/memcached/promise.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'executor_pool'
+
+module IOPromise
+  module Memcached
+    class MemcachePromise < ::IOPromise::Base
+      attr_reader :key
+
+      def initialize(client = nil, key = nil)
+        super()
+    
+        @client = client
+        @key = key
+    
+        ::IOPromise::ExecutorContext.current.register(self) unless @client.nil? || @key.nil?
+      end
+    
+      def wait
+        if @client.nil? || @key.nil?
+          super
+        else
+          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
+        end
+      end
+    
+      def execute_pool
+        MemcacheExecutorPool.for(@client)
+      end
+    end
+  end
+end

data/lib/iopromise/rack/context_middleware.rb

@@ -0,0 +1,20 @@
+
+module IOPromise
+  module Rack
+    class ContextMiddleware
+      def initialize(app)
+        @app = app
+      end
+    
+      def call(env)
+        ::IOPromise::ExecutorContext.push
+        begin
+          status, headers, body = @app.call(env)
+        ensure
+          ::IOPromise::ExecutorContext.pop
+        end
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/iopromise/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module IOPromise
+  VERSION = '0.1.0'
+end

data/lib/iopromise/view_component.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'view_component/data_loader'
+
+module IOPromise
+  module ViewComponent
+    
+  end
+end

data/lib/iopromise/view_component/data_loader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "view_component/engine"
+
+module IOPromise
+  module ViewComponent
+    module DataLoader
+      module ClassMethods
+        def attr_promised_data(*args)
+          @promised_data ||= []
+          @promised_data.concat(args)
+
+          args.each do |arg|
+            self.class_eval("def #{arg};@#{arg}.sync;end")
+          end
+        end
+    
+        def promised_data_keys
+          @promised_data ||= []
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def data_as_promise
+        @data_promise ||= begin
+          promises = self.class.promised_data_keys.map do |k|
+            p = instance_variable_get('@' + k.to_s)
+            if p.is_a?(IOPromise::ViewComponent::DataLoader)
+              # recursively preload all nested data
+              p.data_as_promise
+            else
+              # for any local promises, we'll unwrap them before completing
+              p.then do |result|
+                if result.is_a?(IOPromise::ViewComponent::DataLoader)
+                  # likewise, if we resolved a promise that we can recurse, load that data too.
+                  result.data_as_promise
+                else
+                  result
+                end
+              end
+            end
+          end
+
+          Promise.all(promises)
+        end
+      end
+
+      def sync
+        data_as_promise.sync
+        self
+      end
+
+      def render_in(*)
+        sync
+        super
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: iopromise
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Theo Julienne
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: promise.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+description: This gem extends promise.rb promises to support an extremely simple pattern
+  for "continuing" execution of the promise in an asynchronous non-blocking way.
+email:
+- theo.julienne@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- iopromise.gemspec
+- lib/iopromise.rb
+- lib/iopromise/dalli.rb
+- lib/iopromise/dalli/client.rb
+- lib/iopromise/dalli/executor_pool.rb
+- lib/iopromise/dalli/patch_dalli.rb
+- lib/iopromise/dalli/promise.rb
+- lib/iopromise/dalli/response.rb
+- lib/iopromise/deferred.rb
+- lib/iopromise/deferred/executor_pool.rb
+- lib/iopromise/deferred/promise.rb
+- lib/iopromise/executor_context.rb
+- lib/iopromise/executor_pool/base.rb
+- lib/iopromise/executor_pool/batch.rb
+- lib/iopromise/executor_pool/sequential.rb
+- lib/iopromise/faraday.rb
+- lib/iopromise/faraday/connection.rb
+- lib/iopromise/faraday/continuable_hydra.rb
+- lib/iopromise/faraday/executor_pool.rb
+- lib/iopromise/faraday/multi_socket_action.rb
+- lib/iopromise/faraday/promise.rb
+- lib/iopromise/memcached.rb
+- lib/iopromise/memcached/client.rb
+- lib/iopromise/memcached/executor_pool.rb
+- lib/iopromise/memcached/promise.rb
+- lib/iopromise/rack/context_middleware.rb
+- lib/iopromise/version.rb
+- lib/iopromise/view_component.rb
+- lib/iopromise/view_component/data_loader.rb
+homepage: https://github.com/theojulienne/iopromise
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/theojulienne/iopromise
+  source_code_uri: https://github.com/theojulienne/iopromise
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.9
+signing_key: 
+specification_version: 4
+summary: Simple non-blocking IO promises for Ruby.
+test_files: []