async-tools 0.1.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 434f1d892b6acee168dbbde217a37879fdbf203e4a64bd3dd4ab49fee1feef44
-  data.tar.gz: 0e8fa621829f5f77c7d96d22c4f753b81668ee32e291c34ebf09d97d11f9ec2a
+  metadata.gz: 37e9af668ebad3f0c2356cc2a428b1bedf8b432e239099dd1b961f16d0b01036
+  data.tar.gz: 201bc5e60a2b19e5a1b1498c14c0e792e96bd21a688b3605f443e6f98a2b6f29
 SHA512:
-  metadata.gz: 1f96eedf368fca4bf9fe1b86f6c4b2d312f8b8f40a09dac2a3b2b905b250272a84d77f79cd0e2eb4f2cc1ef87eea67366f114722ed7907c187f77586af44a640
-  data.tar.gz: 61d05af06a151b19a7a01013efee71ee251a8f011732e904f7f6485438c5cbb86341e27106190ba2e516005342854e564f19d8248cc7928749cedcd4a543f0eb
+  metadata.gz: f92056eef4bc4dc65210c682b8637fc6e39088b1213cca0f4b9bf54a06a5b736ce841c351bbaf211bac3777ccda8a7220ee2a926d822e54758a83e87b5c856f8
+  data.tar.gz: e463ee25e793a281c1130ede835c427f03c47f15bd51d708f28396533652ef6be14e7ecd0b08b577ec2dadf73e8ec90522bc986a6911b64ea1f049c3c5cd264e

data/.github/workflows/main.yml

@@ -1,6 +1,8 @@
 name: Ruby
 
-on: [push]
+on:
+  - push
+  - workflow_dispatch
 
 jobs:
   lint:

data/.rubocop.yml

@@ -51,3 +51,12 @@ Metrics/MethodLength:
 
 Lint/UnusedBlockArgument:
   Enabled: false
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/NumberedParametersLimit:
+  Max: 2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    async-tools (0.1.9)
+    async-tools (0.2.1)
       async (~> 2.3)
       zeitwerk (~> 2.6)
 

data/Rakefile

@@ -9,4 +9,4 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task default: [:spec, :rubocop]

data/lib/async/app.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class Async::App
+  # rubocop:disable Style/GlobalVars
+
+  module Injector
+    def inject(name)
+      define_method(name) do
+        $__ASYNC_APP.container[name]
+      end
+      private name
+    end
+  end
+
+  module Component
+    def self.included(base)
+      base.extend(Injector)
+      base.inject(:bus)
+
+      base.include(Async::Logger)
+
+      strict = Dry.Types::Strict
+
+      string_like = (strict::String | strict::Symbol).constructor(&:to_s)
+      kv = strict::Hash.map(string_like, strict::String)
+
+      base.const_set(:T, Module.new do
+        include Dry.Types
+        const_set(:StringLike, string_like)
+        const_set(:KV, kv)
+      end)
+    end
+  end
+
+  extend Injector
+  include Async::Logger
+
+  inject :bus
+
+  def initialize
+    raise "only one instance of #{self.class} is allowed" if $__ASYNC_APP
+
+    $__ASYNC_APP = self
+
+    container.register(:bus, Async::Bus.new(:__async_app))
+
+    set_traps!
+    @task = Async::Task.current
+    container_config.each { container.register(_1, _2) }
+    run!
+    info { "Started" }
+  rescue StandardError => e
+    fatal { e }
+    stop
+    exit(1)
+  end
+  # rubocop:enable Style/GlobalVars
+
+  def container = @container ||= Dry::Container.new
+  def run! = nil
+  def container_config = {}
+
+  def stop
+    @task&.stop
+    info { "Stopped" }
+  end
+
+  private
+
+  def set_traps!
+    trap("INT") do
+      force_exit! if @stopping
+      @stopping = true
+      warn { "Interrupted, stopping. Press ^C once more to force exit." }
+      stop
+    end
+
+    trap("TERM") { stop }
+  end
+
+  def force_exit!
+    fatal { "Forced exit" }
+    exit(1)
+  end
+end

data/lib/async/bus.rb

@@ -1,12 +1,47 @@
 # frozen_string_literal: true
 
-# Threading is not supported!
-module Async::Bus
-  class << self
-    def get(name = :default)
-      @buses ||= {}
-      @buses[name] ||= Bus.new(name:)
-      @buses[name]
+class Async::Bus
+  include Async::Logger
+  # dry-events is not a dependency of async-tools on purpose.
+  # add it to your bundle yourself
+
+  # Semantics:
+  # - Lazily registeres events
+  # - Synchronous by default
+  # - Catches exceptions in subscribers, logs them
+  def initialize(name)
+    @name = name
+    @w = Class.new.include(Dry::Events::Publisher[name]).new
+  end
+
+  # BLOCKING unless subscribers run in tasks
+  def publish(name, *args, **params)
+    @w.register_event(name)
+    @w.publish(name, payload: (args.first || params))
+  rescue StandardError => e
+    log_error(name, e)
+  end
+
+  # NON-BLOCKING
+  def subscribe(name)
+    @w.register_event(name)
+    @w.subscribe(name) { yield(_1[:payload]) }
+  end
+
+  # NON-BLOCKING, runs subscriber in a task
+  def async_subscribe(name, parent: Async::Task.current)
+    subscribe(name) do |event|
+      parent.async  do
+        yield(event)
+      rescue StandardError => e
+        log_error(name, e)
+      end
     end
   end
+
+  def convert(from_event, to_event) = subscribe(from_event) { publish(to_event, **yield(_1)) }
+
+  private
+
+  def log_error(name, e) = warn("Subscriber for #{name.inspect} failed with exception.", e)
 end

data/lib/async/logger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Async::Logger
+  [:debug, :info, :warn, :error, :fatal].each do |name|
+    define_method(name) do |*args, &block|
+      info = respond_to?(:logger_info, true) ? logger_info : nil
+
+      Console.logger.public_send(name, self, info, *args, &block)
+    end
+  end
+end

data/lib/async/timer.rb

@@ -44,17 +44,21 @@ class Async::Timer
     @active = true
 
     @task = @parent.async do
-      call if @run_on_start || run
+      rescued_call if @run_on_start || run
 
       loop do
         sleep(@delay)
-        call
+        rescued_call
         break unless @repeat
-      rescue StandardError => e
-        @on_error.call(e)
       ensure
         @active = false
       end
     end
   end
+
+  def rescued_call
+    call
+  rescue StandardError => e
+    @on_error.call(e)
+  end
 end

data/lib/async/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Async # rubocop:disable Style/ClassAndModuleChildren
   module Tools
-    VERSION = "0.1.9"
+    VERSION = "0.2.1"
   end
 end

data/lib/async/tools.rb

@@ -12,6 +12,7 @@ loader = Zeitwerk::Loader.new
 loader.tag = File.basename(__FILE__, ".rb")
 loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
 loader.push_dir(File.expand_path("..", __dir__.to_s))
+
 loader.setup
 
 module Async

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.1
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -60,9 +60,10 @@ files:
 - async-tools.gemspec
 - bin/console
 - bin/setup
+- lib/async/app.rb
 - lib/async/bus.rb
-- lib/async/bus/bus.rb
 - lib/async/channel.rb
+- lib/async/logger.rb
 - lib/async/q.rb
 - lib/async/result_notification.rb
 - lib/async/timer.rb

data/lib/async/bus/bus.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-class Async::Bus::Bus
-  attr_reader :name
-
-  include Console
-
-  def initialize(name: :default, limit: 10, parent: Async::Task.current)
-    @name = name
-    @limit = limit
-    @parent = parent
-
-    @closed = false
-
-    @subscribers = Hash.new { |hash, key| hash[key] = [] }
-  end
-
-  # Blocks if any of output channels is full!
-  def publish(nameable_or_event, **payload)
-    check_if_open!
-    name, payload = normalize(nameable_or_event, payload)
-
-    subs = @subscribers[name]
-    return if subs.empty?
-
-    subs.each do |chan|
-      publishing_blocked if chan.full?
-      chan << [name, payload]
-    end
-    Async::Task.current.yield
-  end
-
-  # Blocks!
-  def subscribe(nameable, callable = nil, &block)
-    check_if_open!
-    callable ||= block
-    unless callable.respond_to?(:call)
-      raise ArgumentError, "callable or block must be provided. callable must respond to :call"
-    end
-
-    event_name = normalize(nameable).first
-
-    chan = Async::Channel.new(@limit)
-    @subscribers[event_name] << chan
-    serve(chan, event_name, callable)
-  end
-
-  def async_subscribe(*, **, &) = @parent.async { subscribe(*, **, &) }
-  def on_event(&block) = @on_event_callback = block
-
-  def close
-    return if @closed
-
-    @closed = true
-
-    @subscribers.values.flatten.each(&:close)
-    @subscribers.clear
-  end
-
-  private
-
-  def normalize(nameable, payload = nil)
-    return [nameable, payload] if nameable.is_a?(Symbol)
-    return [nameable.to_sym, payload] if nameable.is_a?(String)
-    return [nameable.event_name.to_sym, nameable] if nameable.respond_to?(:event_name)
-
-    n = nameable[:event_name] || nameable["event_name"]
-    return [n.to_sym, nameable] if n
-
-    raise ArgumentError, "cannot infer event name from #{nameable.inspect}"
-  end
-
-  def serve(chan, event_name, callable)
-    stopped = false
-    unsub = lambda {
-      chan.close
-      stopped = true
-      @subscribers[event_name].delete(chan)
-    }
-
-    chan.each do |name, payload|
-      @on_event_callback&.call(wrapper)
-      callable.call(payload, unsub:, meta: { bus: self })
-      break if stopped
-    end
-  end
-
-  def publishing_blocked
-    logger.warn(self) { "One of the subscribers is slow, blocking publishing. Event name: #{name}" }
-  end
-
-  def check_if_open!
-    raise "Bus is closed" if @closed
-  end
-end