pluggaloid 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35247bc23e35e0883f0ad31b3e837573fcb09dda2858efd62f8a9136b147e3ff
-  data.tar.gz: 685d655ef114502abc8c953339496ada5a59dea23d9e6cd0fbbd483650b6a7f1
+  metadata.gz: e068709da8ec715bcb2454af10c5b8cdf60f8da92b96357fef5996753af4930c
+  data.tar.gz: 4bd0da1c90d5bfa19a21f436e7f59b272f93804619386b6b30b6c3ecc42c23db
 SHA512:
-  metadata.gz: 0ab87b2b058152cade220fcfe1b258ea681854216d43e51333b897cbbdf421bc41f4737a07e4bbcc5c8ec49bd8bea4ed5bed1469ecc20cc3ebfa4282f7679057
-  data.tar.gz: 3a4c6f326aadded01ee31e2a1dfd600236caebfe99a15e8e056e84a53d1997f33c73485383ced9efd190e8068713109054f2f03d619a1c0a7258de900bd32499
+  metadata.gz: 91f7e39fed67236f339ca54b72deff6d68b4bc5482ddcfb5fd589edadea3628532e6a71f239228989dc9928ceaf25a7af947ff5444bd733ff20d23714b392511
+  data.tar.gz: a625889e2d9b505d7713688b0bd744b2cc5b54ec4f396a007680a54d8f4c99aa3c99c48ce45ea6d9022b3c85028196adeb3765a0c30f99ba16fdeb51559273e9

data/README.md

@@ -54,6 +54,25 @@ Pluggaloid::newは、プラグイン機構を制御するためのDelayer, Plugi
 
 コンストラクタの唯一の引数には `Delayer.generate_class(priority: %i<high normal low>, default: :normal)`のように、優先順位付きでデフォルト優先度が設定されたDelayerを渡します。
 
+## Reactive Filter
+
+### each_slice(times)
+
+_times_ 要素ずつブロックに渡して繰り返します。
+要素数が _times_ で割り切れないときは、要素が _times_ 個になるまで待ちます。
+
+### throttle(sec)
+
+最後に要素を受信してから、 _sec_ 秒の間に受信した要素を捨てます。
+
+### debounce(sec)
+
+_sec_ 秒要素を受信しなかった場合、最後の要素を送信する。
+
+### buffer(sec)
+
+_sec_ 秒の間に受信した要素を、 _sec_ 秒ごとに配列にまとめて送信する。
+
 ## Contributing
 
 1. Fork it ( https://github.com/toshia/pluggaloid/fork )

data/lib/pluggaloid/event.rb

@@ -18,6 +18,7 @@ class Pluggaloid::Event
     @options = {}
     @listeners = [].freeze
     @filters = [].freeze
+    @subscribers = {}
   end
 
   def vm
@@ -62,18 +63,29 @@ class Pluggaloid::Event
         event_filter.filtering(*acm) } } end
 
   def add_listener(listener)
-    unless listener.is_a? Pluggaloid::Listener
-      raise Pluggaloid::ArgumentError, "First argument must be Pluggaloid::Listener, but given #{listener.class}."
-    end
-    Lock.synchronize do
-      if @listeners.map(&:slug).include?(listener.slug)
-        raise Pluggaloid::DuplicateListenerSlugError, "Listener slug #{listener.slug} already exists."
+    case listener
+    when Pluggaloid::Listener
+      Lock.synchronize do
+        if @listeners.map(&:slug).include?(listener.slug)
+          raise Pluggaloid::DuplicateListenerSlugError, "Listener slug #{listener.slug} already exists."
+        end
+        @listeners = [*@listeners, listener].freeze
+      end
+    when Pluggaloid::Subscriber
+      Lock.synchronize do
+        @subscribers[listener.accepted_hash] ||= []
+        @subscribers[listener.accepted_hash] << listener
       end
-      @listeners = [*@listeners, listener].freeze
+    else
+      raise Pluggaloid::ArgumentError, "First argument must be Pluggaloid::Listener or Pluggaloid::Subscriber, but given #{listener.class}."
     end
     self
   end
 
+  def subscribe?(*args)
+    !@listeners.empty? || @subscribers.key?(argument_hash(args))
+  end
+
   def delete_listener(listener)
     Lock.synchronize do
       @listeners = @listeners.dup
@@ -83,6 +95,17 @@ class Pluggaloid::Event
     self
   end
 
+  def delete_subscriber(listener)
+    Lock.synchronize do
+      ss = @subscribers[listener.accepted_hash]
+      ss.delete(listener)
+      if ss.empty?
+        @subscribers.delete(listener.accepted_hash)
+      end
+    end
+    self
+  end
+
   # イベントフィルタを追加する
   # ==== Args
   # [event_filter] イベントフィルタ(Filter)
@@ -109,8 +132,28 @@ class Pluggaloid::Event
     self
   end
 
+  def argument_hash(args)
+    args.each_with_index.map do |item, i|
+      if i != yield_index
+        item.hash
+      end
+    end.compact.freeze
+  end
+
+  def yield_index
+    unless defined?(@yield_index)
+      @yield_index = self.options[:prototype].index(Pluggaloid::STREAM)
+    end
+    @yield_index
+  end
+
   private
   def call_all_listeners(args)
+    if yield_index
+      @subscribers[argument_hash(args)]&.each do |subscriber|
+        subscriber.call(*args)
+      end
+    end
     catch(:plugin_exit) do
       @listeners.each do |listener|
         listener.call(*args)

data/lib/pluggaloid/plugin.rb

@@ -18,12 +18,14 @@ module Pluggaloid
         @vm ||= begin
                   raise Pluggaloid::NoDefaultDelayerError, "Default Delayer was not set." unless Delayer.default
                   vm = Pluggaloid::VM.new(
-                    Delayer.default,
-                    self,
-                    Pluggaloid::Event,
-                    Pluggaloid::Listener,
-                    Pluggaloid::Filter,
-                    Pluggaloid::HandlerTag)
+                    Delayer: Delayer.default,
+                    Plugin: self,
+                    Event: Pluggaloid::Event,
+                    Listener: Pluggaloid::Listener,
+                    Filter: Pluggaloid::Filter,
+                    HandlerTag: Pluggaloid::HandlerTag,
+                    Subscriber: Pluggaloid::Subscriber
+                  )
                   vm.Event.vm = vm end end
 
       # プラグインのインスタンスを返す。
@@ -126,6 +128,26 @@ module Pluggaloid
       @filters << result
       result end
 
+    def subscribe(event_name, *specs, **kwrest, &block)
+      if block
+        result = vm.Subscriber.new(vm.Event[event_name], *specs, **kwrest, &block)
+        @events << result
+        result
+      else
+        Stream.new(
+          Enumerator.new do |yielder|
+            @events << vm.Subscriber.new(vm.Event[event_name], *specs, **kwrest) do |stream|
+              stream.each(&yielder.method(:<<))
+            end
+          end.lazy
+        )
+      end
+    end
+
+    def subscribe?(event_name, *specs)
+      vm.Event[event_name].subscribe?(*specs)
+    end
+
     # このプラグインのHandlerTagを作る。
     # ブロックが渡された場合は、ブロックの中を実行し、ブロックの中で定義された
     # Handler全てにTagを付与する。
@@ -187,7 +209,7 @@ module Pluggaloid
     def detach(*args)
       listener = args.last
       case listener
-      when vm.Listener
+      when vm.Listener, vm.Subscriber
         @events.delete(listener)
         listener.detach
       when vm.Filter
@@ -253,6 +275,8 @@ module Pluggaloid
       when method_name.start_with?('filter')
         event_name = method_name[(method_name[6] == '_' ? 7 : 6)..method_name.size]
         add_event_filter(event_name.to_sym, **kwrest, &proc)
+      else
+        super
       end
     end
 

data/lib/pluggaloid/stream.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pluggaloid
+  class Stream
+    include Enumerable
+
+    def initialize(enumerator)
+      @enumerator = enumerator
+    end
+
+    def throttle(sec)
+      throttling = 0
+      @enumerator.select do |item|
+        r0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if throttling <= r0
+          throttling = r0 + sec
+        end
+      end
+    end
+
+    def debounce(sec)
+      throttling_promise = nil
+      Stream.new(
+        Enumerator.new do |yielder|
+          @enumerator.each do |item|
+            throttling_promise&.cancel
+            throttling_promise = Delayer.new(delay: sec) do
+              yielder << item
+            end
+          end
+        end.lazy
+      )
+    end
+
+    def buffer(sec)
+      throttling_promise = nil
+      buffer = []
+      Stream.new(
+        Enumerator.new do |yielder|
+          @enumerator.each do |item|
+            buffer << item
+            throttling_promise ||= Delayer.new(delay: sec) do
+              yielder << buffer.freeze
+              buffer = []
+              throttling_promise = nil
+            end
+          end
+        end.lazy
+      )
+    end
+
+    def merge(*streams)
+      Stream.new(Merge.new(self, *streams).lazy)
+    end
+
+    (Enumerator.instance_methods - Enumerator.superclass.instance_methods).each do |method_name|
+      define_method(method_name) do |*rest, **kwrest, &block|
+        if kwrest.empty?
+          r = @enumerator.__send__(method_name, *rest, &block)
+        else
+          r = @enumerator.__send__(method_name, *rest, **kwrest, &block)
+        end
+        if r.is_a?(Enumerator::Lazy)
+          Pluggaloid::Stream.new(r)
+        else
+          r
+        end
+      end
+    end
+
+    class Merge
+      include Enumerable
+
+      def initialize(*sources)
+        @sources = sources
+      end
+
+      def each(&block)
+        fiber = Fiber.new do
+          loop do
+            block.call(Fiber.yield)
+          end
+        end
+        fiber.resume
+        @sources.each do |source|
+          source.each(&fiber.method(:resume))
+        end
+        self
+      end
+    end
+  end
+end

data/lib/pluggaloid/subscriber.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require 'securerandom'
+require 'set'
+
+class Pluggaloid::Subscriber < Pluggaloid::Handler
+  attr_reader :accepted_hash
+
+  # ==== Args
+  # [event] 監視するEventのインスタンス
+  # [name:] 名前(String | nil)
+  # [slug:] イベントリスナスラッグ(Symbol | nil)
+  # [tags:] Pluggaloid::HandlerTag|Array リスナのタグ
+  # [&callback] コールバック
+  def initialize(event, *specs, **kwrest, &callback)
+    super(event, **kwrest)
+    @callback = callback
+    @accepted_hash = @event.argument_hash(specs)
+    event.add_listener(self)
+  end
+
+  # イベントを実行する
+  # ==== Args
+  # [stream] イベントの引数
+  def call(*args)
+    @callback.call(args[@event.yield_index])
+  end
+
+  # このリスナを削除する
+  # ==== Return
+  # self
+  def detach
+    @event.delete_subscriber(self)
+    self
+  end
+end

data/lib/pluggaloid/version.rb

@@ -1,3 +1,3 @@
 module Pluggaloid
-  VERSION = "1.2.0"
+  VERSION = '1.3.0'
 end

data/lib/pluggaloid.rb

@@ -1,9 +1,11 @@
 require "pluggaloid/version"
 require "pluggaloid/plugin"
+require 'pluggaloid/stream'
 require 'pluggaloid/event'
 require "pluggaloid/identity"
 require "pluggaloid/handler"
 require 'pluggaloid/listener'
+require 'pluggaloid/subscriber'
 require 'pluggaloid/filter'
 require "pluggaloid/handler_tag"
 require 'pluggaloid/error'
@@ -11,15 +13,19 @@ require 'pluggaloid/error'
 require 'delayer'
 
 module Pluggaloid
-  VM = Struct.new(*%i<Delayer Plugin Event Listener Filter HandlerTag>)
+  VM = Struct.new(*%i<Delayer Plugin Event Listener Filter HandlerTag Subscriber>, keyword_init: true)
+
+  class PrototypeStream; end
+  STREAM = PrototypeStream.new.freeze
 
   def self.new(delayer)
-    vm = VM.new(delayer,
-                Class.new(Plugin),
-                Class.new(Event),
-                Class.new(Listener),
-                Class.new(Filter),
-                Class.new(HandlerTag))
+    vm = VM.new(Delayer: delayer,
+                Plugin: Class.new(Plugin),
+                Event: Class.new(Event),
+                Listener: Class.new(Listener),
+                Filter: Class.new(Filter),
+                HandlerTag: Class.new(HandlerTag),
+                Subscriber: Class.new(Subscriber))
     vm.Plugin.vm = vm.Event.vm = vm
   end
 end

data/pluggaloid.gemspec

@@ -18,9 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = '>= 2.5.0'
 
-  spec.add_dependency 'delayer', '>= 1.0.0', '< 2.0'
+  spec.add_dependency 'delayer', '>= 1.1.0', '< 2.0'
   spec.add_dependency 'instance_storage', ">= 1.0.0", "< 2.0.0"
 
   spec.add_development_dependency "bundler"

data/test/plugin_test.rb

@@ -202,4 +202,12 @@ describe(Pluggaloid::Plugin) do
     end
   end
 
+  it 'call undefined method in plugin context' do
+    assert_raises(NameError) do
+      Pluggaloid::Plugin.create(:raises) do
+        undefined_call
+      end
+    end
+  end
+
 end

data/test/reactive_test.rb

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+
+require 'bundler/setup'
+require 'minitest/autorun'
+
+require 'pluggaloid'
+require_relative 'helper'
+
+describe(Pluggaloid::Plugin) do
+  include PluggaloidTestHelper
+
+  before do
+    Delayer.default = Delayer.generate_class(priority: %i<high normal low>, default: :normal)
+    Pluggaloid::Plugin.clear!
+  end
+
+  it "subscribe" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1) do |v|
+        sum = v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, [:one])
+      Pluggaloid::Event[:increase].call(2, [:two])
+    end
+
+    assert_equal(%i[one], sum)
+  end
+
+  it "subscribe?" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1) do |v|
+      end
+    end
+    assert(Pluggaloid::Plugin[:event].subscribe?(:increase, 1))
+    refute(Pluggaloid::Plugin[:event].subscribe?(:increase, 2))
+
+  end
+
+  it "subscribe? returns always true if plugin listener exist" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      on_increase do |i, y|
+      end
+    end
+    assert(Pluggaloid::Plugin[:event].subscribe?(:increase, 1))
+    assert(Pluggaloid::Plugin[:event].subscribe?(:increase, 2))
+  end
+
+  it "subscribe enumerable" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).each do |v|
+        sum = v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, [:one])
+      Pluggaloid::Event[:increase].call(2, [:two])
+    end
+
+    assert_equal(:one, sum)
+  end
+
+  it "detach" do
+    sum = 0
+    subscriber = nil
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Pluggaloid::STREAM]
+      subscriber = subscribe(:increase) do |v|
+        sum += v
+      end
+    end
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1)
+    end
+    assert_equal(1, sum, "It should execute subscriber when event called")
+
+    eval_all_events do
+      Pluggaloid::Plugin[:event].detach subscriber
+      Pluggaloid::Event[:increase].call(1)
+    end
+    assert_equal(1, sum, "It should not execute detached subscriber when event called")
+  end
+
+  it "subscribe enumerable chain" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).map{|v| v.to_s }.each do |v|
+        sum << v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, [:one])
+      Pluggaloid::Event[:increase].call(2, [:two])
+      Pluggaloid::Event[:increase].call(1, [:three])
+    end
+
+    assert_equal(%w[one three], sum)
+  end
+
+  it "subscribe each_slice" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).each_slice(3).each do |v|
+        sum << v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, 100.times)
+    end
+
+    assert_equal([0, 1, 2], sum.first)
+    assert_equal([96, 97, 98], sum.last)
+    assert_equal(33, sum.size)
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, [100, 101])
+    end
+
+    assert_equal([99, 100, 101], sum.last)
+    assert_equal(34, sum.size)
+  end
+
+  it "throttle" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).throttle(0.001).each do |v|
+        sum << v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, (1..10).to_a)
+      Pluggaloid::Event[:increase].call(1, (11..20).to_a)
+    end
+
+    assert_equal(1, sum.last)
+    assert_equal(1, sum.size)
+
+    sleep 0.01
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, (21..30).to_a)
+    end
+
+    assert_equal(21, sum.last)
+    assert_equal(2, sum.size)
+  end
+
+  it "debounce" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).debounce(0.01).each do |v|
+        sum << v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, (1..10).to_a)
+      Pluggaloid::Event[:increase].call(1, (11..20).to_a)
+    end
+
+    assert_equal(0, sum.size)
+
+    sleep 0.02
+    Delayer.run
+
+    assert_equal(1, sum.size)
+    assert_equal(20, sum.last)
+  end
+
+  it "buffer" do
+    sum = []
+
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).buffer(0.01).each do |v|
+        sum << v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, (1..10).to_a)
+      Pluggaloid::Event[:increase].call(1, (11..20).to_a)
+    end
+
+    assert_equal(0, sum.size)
+
+    sleep 0.1
+    Delayer.run
+    Pluggaloid::Event[:increase].call(1, [21])
+    Delayer.run
+
+    assert_equal(1, sum.size)
+    assert_equal((1..20).to_a, sum.last)
+  end
+
+  it "merge" do
+    sum = sum1 = sum2 = 0
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
+      subscribe(:increase, 1).each do |v|
+        sum1 += v
+      end
+
+      subscribe(:increase, 2).each do |v|
+        sum2 += v
+      end
+
+      subscribe(:increase, 1).merge(subscribe(:increase, 2)).each do |v|
+        sum += v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1, (1..10).to_a)
+      Pluggaloid::Event[:increase].call(2, (11..20).to_a)
+    end
+
+    assert_equal((1..10).to_a.sum, sum1)
+    assert_equal((11..20).to_a.sum, sum2)
+    assert_equal((1..20).to_a.sum, sum)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pluggaloid
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Toshiaki Asai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-01 00:00:00.000000000 Z
+date: 2020-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayer
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -113,12 +113,15 @@ files:
 - lib/pluggaloid/identity.rb
 - lib/pluggaloid/listener.rb
 - lib/pluggaloid/plugin.rb
+- lib/pluggaloid/stream.rb
+- lib/pluggaloid/subscriber.rb
 - lib/pluggaloid/version.rb
 - pluggaloid.gemspec
 - test/handler_tag_test.rb
 - test/helper.rb
 - test/multi_vm_test.rb
 - test/plugin_test.rb
+- test/reactive_test.rb
 homepage: https://rubygems.org/gems/pluggaloid
 licenses:
 - MIT
@@ -131,14 +134,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Extensible plugin system
@@ -147,3 +150,4 @@ test_files:
 - test/helper.rb
 - test/multi_vm_test.rb
 - test/plugin_test.rb
+- test/reactive_test.rb