pluggaloid 1.3.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd795f27416c6cff9155f4adbfa97cb04192a48e891d387a1a5c37a04b5b681c
-  data.tar.gz: 82a3a43fa8f01c34b879c2d85d19f0193d54e8fa3e9989040559c5b40b70e9f4
+  metadata.gz: d47426a6d55a1f8bb30898b9056766dceff9346b1fdc33561f6c21af9c2c9f98
+  data.tar.gz: c9953550293c3f3be07e5ef429d29f90651717f74b443613cd274b702578c938
 SHA512:
-  metadata.gz: b943be558a442022cd1d3ca2fec636ec6f6b8a9498cd2a8cc2fb8a3227df8675fc06f50d90d19af0c3db648703952c37123b0d41e2fc3ff4f686d0a87726d6c6
-  data.tar.gz: 3f1b7c5fcfa142ad280c3a1c67405ae42536bdcca32b9e2d1ed05a34d394602509bada0001657bfc1eaa48b1aa6465f941513119508179d61feeca52fdd3441e
+  metadata.gz: 9ac80a75430f7721d6752698deb760b883fe3f9e0a2cf4cdd5b2866b164c01815064749dd9d0acfcdbe799aad88e91346a03272ad171fdab1df20658d14c0688
+  data.tar.gz: ca65d05402e64b7daa429596275d25d2af72806c66009f7e10321f2a6a1d9c4ec9f1d7c7e6dd29494394262ad26dd13cbb8fe58374bf8a2de28072d380de5960

data/.circleci/config.yml

@@ -0,0 +1,43 @@
+version: '2.1'
+
+executors:
+  ruby:
+    parameters:
+      tag:
+        type: string
+    docker:
+      - image: circleci/ruby:<< parameters.tag >>
+
+jobs:
+  build:
+    parameters:
+       ruby-version:
+         type: string
+    executor:
+      name: ruby
+      tag: << parameters.ruby-version >>
+    steps:
+    - checkout
+    - run:
+        name: Which bundler?
+        command: bundle -v
+    - run:
+        command: bundle install --path vendor/bundle
+    - run:
+        name: test
+        command: bundle exec rake test
+workflows:
+  build:
+    jobs:
+      - build:
+          name: 'ruby-2.5'
+          ruby-version: '2.5.9'
+      - build:
+          name: 'ruby-2.6'
+          ruby-version: '2.6.7'
+      - build:
+          name: 'ruby-2.7'
+          ruby-version: '2.7.3'
+      - build:
+          name: 'ruby-3.0'
+          ruby-version: '3.0.1'

data/README.md

@@ -3,6 +3,8 @@
 mikutterのプラグイン機構です。
 登録したプラグイン同士がイベントを使って通信できるようになります。
 
+[![toshia](https://circleci.com/gh/toshia/pluggaloid.svg?style=svg)](https://circleci.com/gh/toshia/pluggaloid)
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/pluggaloid.rb

@@ -1,4 +1,5 @@
 require "pluggaloid/version"
+require 'pluggaloid/collection'
 require "pluggaloid/plugin"
 require 'pluggaloid/stream'
 require 'pluggaloid/event'
@@ -7,16 +8,20 @@ require "pluggaloid/handler"
 require 'pluggaloid/listener'
 require 'pluggaloid/subscriber'
 require 'pluggaloid/filter'
+require 'pluggaloid/stream_generator'
 require "pluggaloid/handler_tag"
+require 'pluggaloid/mirage'
 require 'pluggaloid/error'
 
 require 'delayer'
 
 module Pluggaloid
-  VM = Struct.new(*%i<Delayer Plugin Event Listener Filter HandlerTag Subscriber>, keyword_init: true)
+  VM = Struct.new(*%i<Delayer Plugin Event Listener Filter HandlerTag Subscriber StreamGenerator>, keyword_init: true)
 
   class PrototypeStream; end
+  class PrototypeCollect; end
   STREAM = PrototypeStream.new.freeze
+  COLLECT = PrototypeCollect.new.freeze
 
   def self.new(delayer)
     vm = VM.new(Delayer: delayer,
@@ -25,7 +30,8 @@ module Pluggaloid
                 Listener: Class.new(Listener),
                 Filter: Class.new(Filter),
                 HandlerTag: Class.new(HandlerTag),
-                Subscriber: Class.new(Subscriber))
+                Subscriber: Class.new(Subscriber),
+                StreamGenerator: Class.new(StreamGenerator))
     vm.Plugin.vm = vm.Event.vm = vm
   end
 end

data/lib/pluggaloid/collection.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pluggaloid
+  class Collection
+    attr_reader :values
+
+    def initialize(event, *args)
+      @event = event
+      args[event.collect_index] = nil
+      @args = args.freeze
+      @spec = argument_hash(args)
+      @values = [].freeze
+    end
+
+    def add(*v)
+      rewind do |primitive|
+        primitive + v
+      end
+    end
+    alias_method :<<, :add
+
+    def delete(*v)
+      rewind do |primitive|
+        primitive - v
+      end
+    end
+
+    def rewind(&block)
+      new_values = block.(@values.dup)
+      added, deleted = new_values - @values, @values - new_values
+      @values = new_values.freeze
+      unless added.empty?
+        args = @args.dup
+        args[@event.collect_index] = added
+        @event.collection_add_event.call(*args)
+      end
+      unless deleted.empty?
+        args = @args.dup
+        args[@event.collect_index] = deleted
+        @event.collection_delete_event.call(*args)
+      end
+      self
+    end
+
+    def argument_hash_same?(specs)
+      @spec == argument_hash(specs)
+    end
+
+    private
+
+    def argument_hash(specs)
+      @event.argument_hash(specs, @event.collect_index)
+    end
+  end
+end

data/lib/pluggaloid/error.rb

@@ -11,4 +11,10 @@ module Pluggaloid
   class NoDefaultDelayerError < Error; end
 
   class DuplicateListenerSlugError < Error; end
+
+  class UndefinedStreamIndexError < Error; end
+
+  class UndefinedCollectionIndexError < Error; end
+
+  class NoReceiverError < Error; end
 end

data/lib/pluggaloid/event.rb

@@ -18,7 +18,26 @@ class Pluggaloid::Event
     @options = {}
     @listeners = [].freeze
     @filters = [].freeze
-    @subscribers = {}
+    @subscribers = Hash.new { |h, k| h[k] = [] }
+    @stream_generators = Hash.new { |h, k| h[k] = Set.new }
+  end
+
+  def prototype
+    @options[:prototype]
+  end
+
+  # イベント _event_name_ を宣言する
+  # ==== Args
+  # [new_options] イベントの定義
+  def defevent(new_options)
+    @options.merge!(new_options)
+    if collect_index
+      new_proto = self.prototype.dup
+      new_proto[self.collect_index] = Pluggaloid::STREAM
+      collection_add_event.defevent(prototype: new_proto)
+      collection_delete_event.defevent(prototype: new_proto)
+    end
+    self
   end
 
   def vm
@@ -71,19 +90,29 @@ class Pluggaloid::Event
         end
         @listeners = [*@listeners, listener].freeze
       end
+      @stream_generators.values.each do |generators|
+        generators.each(&:on_subscribed)
+      end
     when Pluggaloid::Subscriber
+      accepted_hash = listener.accepted_hash
       Lock.synchronize do
-        @subscribers[listener.accepted_hash] ||= []
-        @subscribers[listener.accepted_hash] << listener
+        @subscribers[accepted_hash] << listener
       end
+      @stream_generators.fetch(accepted_hash, nil)&.each(&:on_subscribed)
     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))
+  # subscribe(_*specs_) で、ストリームの受信をしようとしているリスナが定義されていればtrueを返す。
+  # on_* で通常のイベントリスナが登録されて居る場合は、 _*specs_ の内容に関わらず常にtrueを返す。
+  def subscribe?(*specs)
+    !@listeners.empty? || @subscribers.key?(argument_hash(specs, nil))
+  end
+
+  def subscribe_hash?(hash)   # :nodoc:
+    !@listeners.empty? || @subscribers.key?(hash)
   end
 
   def delete_listener(listener)
@@ -103,6 +132,18 @@ class Pluggaloid::Event
         @subscribers.delete(listener.accepted_hash)
       end
     end
+    @stream_generators.fetch(listener.accepted_hash, nil)&.each(&:on_unsubscribed)
+    self
+  end
+
+  def delete_stream_generator(listener)
+    Lock.synchronize do
+      ss = @stream_generators[listener.accepted_hash]
+      ss.delete(listener)
+      if ss.empty?
+        @stream_generators.delete(listener.accepted_hash)
+      end
+    end
     self
   end
 
@@ -132,25 +173,66 @@ class Pluggaloid::Event
     self
   end
 
-  def argument_hash(args)
+  def argument_hash(args, exclude_index)
     args.each_with_index.map do |item, i|
-      if i != yield_index
+      if i != exclude_index
         item.hash
       end
     end.compact.freeze
   end
 
-  def yield_index
-    unless defined?(@yield_index)
-      @yield_index = self.options[:prototype]&.index(Pluggaloid::STREAM)
+  def stream_index
+    unless defined?(@stream_index)
+      @stream_index = self.prototype&.index(Pluggaloid::STREAM)
     end
-    @yield_index
+    @stream_index
+  end
+
+  def collect_index
+    unless defined?(@collect_index)
+      @collect_index = self.prototype&.index(Pluggaloid::COLLECT)
+    end
+    @collect_index
+  end
+
+  # defeventで定義されたprototype引数に _Pluggaloid::COLLECT_ を含むイベントに対して使える。
+  # フィルタの _Pluggaloid::COLLECT_ 引数に空の配列を渡して実行したあと、その配列を返す。
+  # ==== Args
+  # [*args] Pluggaloid::COLLECT 以外の引数のリスト
+  # ==== Return
+  # [Array] フィルタ実行結果
+  def collect(*args)
+    specified_index = args.index(Pluggaloid::COLLECT)
+    specified_index&.yield_self(&args.method(:delete_at))
+    insert_index = collect_index || specified_index
+    if insert_index
+      Enumerator.new do |yielder|
+        cargs = args.dup
+        cargs.insert(insert_index, yielder)
+        filtering(*cargs)
+      end
+    else
+      raise Pluggaloid::UndefinedCollectionIndexError, 'To call collect(), it must define prototype arguments include `Pluggaloid::COLLECT\'.'
+    end
+  end
+
+  def register_stream_generator(stream_generator)
+    @stream_generators[stream_generator.accepted_hash] << stream_generator
+    self
+  end
+
+  def collection_add_event
+    self.class['%{name}__add' % {name: name}]
+  end
+
+  def collection_delete_event
+    self.class['%{name}__delete' % {name: name}]
   end
 
   private
   def call_all_listeners(args)
-    if yield_index
-      @subscribers[argument_hash(args)]&.each do |subscriber|
+    if stream_index
+      @subscribers[argument_hash(args, stream_index)]&.each do |subscriber|
         subscriber.call(*args)
       end
     end

data/lib/pluggaloid/filter.rb

@@ -19,7 +19,8 @@ class Pluggaloid::Filter < Pluggaloid::Handler
   # [tags:] Pluggaloid::HandlerTag|Array フィルタのタグ
   # [&callback] コールバック
   def initialize(event, **kwrest, &callback)
-    super
+    kwrest[:name] ||= '%s line %i' % callback.source_location
+    super(event, **kwrest)
     @callback = callback
     event.add_filter self end
 

data/lib/pluggaloid/mirage.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pluggaloid
+  module Mirage
+    MIRAGE_ID_BASE_NUMBER = 36
+
+    module Extend
+      # `Pluggaloid::Mirage` をincludeしたClassのうち、`pluggaloid_mirage_identity`
+      # メソッドを呼ばれたインスタンスを記録するオブジェクトを返す。
+      # 戻り値は、以下のメソッドに応答すること。
+      # - `repository#[](String id)` idに対応するオブジェクトを返す
+      # - `repository#[]=(String id, self obj)` objを記録する
+      # Class毎に適したコンテナを返すようにoverrideすること
+      def pluggaloid_mirage_repository
+        @pluggaloid_mirage_repository ||= {}
+      end
+
+      # `Pluggaloid::Mirage` をincludeしたClassのnamespaceを返す。
+      # namespaceはStringで、 `Pluggaloid::Mirage` をincludeしたほかのClassと
+      # 重複しない。
+      # 同じClassであれば、別のPluggaloid host(Pluggaloid::VMやプロセス)でも
+      # 同じ値を返す。
+      def pluggaloid_mirage_namespace
+        -to_s
+      end
+
+      def inherited(klass)
+        Mirage.pluggaloid_mirage_classes[klass.pluggaloid_mirage_namespace] = klass
+      end
+    end
+
+    def self.unwrap(namespace:, id:)
+      klass = pluggaloid_mirage_classes[namespace]
+      if klass
+        result = klass.pluggaloid_mirage_repository[id]
+        unless result&.is_a?(Pluggaloid::Mirage) # nilの場合は常にraise
+          raise ArgumentError, "The id `#{id}' was not found."
+        end
+        result
+      else
+        raise ArgumentError, "The namespace `#{namespace}' was not found."
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(Extend)
+      pluggaloid_mirage_classes[klass.pluggaloid_mirage_namespace] = klass
+    end
+
+    def self.pluggaloid_mirage_classes
+      @pluggaloid_mirage_classes ||= {}
+    end
+
+    # このClassのなかで、Pluggaloid::Mirageがインスタンスを同定するためのid(String)を返す。
+    # このメソッドではなく、 `generate_pluggaloid_mirage_id` をoverrideすること
+    def pluggaloid_mirage_id
+      generate_pluggaloid_mirage_id.freeze.tap do |id|
+        self.class.pluggaloid_mirage_repository[id] = self
+        Mirage.pluggaloid_mirage_classes[self.class.pluggaloid_mirage_namespace] ||= self.class
+      end
+    end
+
+    def pluggaloid_mirage_namespace
+      self.class.pluggaloid_mirage_namespace
+    end
+
+    private
+
+    # このClassのなかで、Pluggaloid::Mirageがインスタンスを同定するためのid(String)を返す。
+    # Class毎に適したコンテナを返すようにoverrideすること
+    def generate_pluggaloid_mirage_id
+      object_id.to_s(MIRAGE_ID_BASE_NUMBER)
+    end
+  end
+end

data/lib/pluggaloid/plugin.rb

@@ -24,7 +24,8 @@ module Pluggaloid
                     Listener: Pluggaloid::Listener,
                     Filter: Pluggaloid::Filter,
                     HandlerTag: Pluggaloid::HandlerTag,
-                    Subscriber: Pluggaloid::Subscriber
+                    Subscriber: Pluggaloid::Subscriber,
+                    StreamGenerator: Pluggaloid::StreamGenerator
                   )
                   vm.Event.vm = vm end end
 
@@ -64,6 +65,17 @@ module Pluggaloid
       def filtering(event_name, *args)
         vm.Event[event_name].filtering(*args) end
 
+      # フィルタ _event_name_ を実行し、defeventでPluggaloid::COLLECTと
+      # 宣言されている引数の結果を列挙するEnumeratorを返す
+      # ==== Args
+      # [event_name] イベント名(String | Symbol)
+      # [*specs] Pluggaloid::COLLECT以外の引数
+      # ==== Return
+      # [Enumerator]
+      def collect(event_name, *specs)
+        vm.Event[event_name].collect(*specs)
+      end
+
       # 互換性のため
       def uninstall(plugin_name)
         self[plugin_name].uninstall end
@@ -116,7 +128,7 @@ module Pluggaloid
 
     # イベントフィルタを新しく登録する
     # ==== Args
-    # [event] 監視するEventのインスタンス
+    # [event_name] イベント名(String | Symbol)
     # [name:] 名前(String | nil)
     # [slug:] フィルタスラッグ(Symbol | nil)
     # [tags:] Pluggaloid::HandlerTag|Array フィルタのタグ
@@ -128,6 +140,10 @@ module Pluggaloid
       @filters << result
       result end
 
+    def generate(event_name, *specs, **kwrest, &block)
+      vm.StreamGenerator.new(vm.Event[event_name], *specs, plugin: self, **kwrest, &block)
+    end
+
     def subscribe(event_name, *specs, **kwrest, &block)
       if block
         result = vm.Subscriber.new(vm.Event[event_name], *specs, **kwrest, &block)
@@ -148,6 +164,32 @@ module Pluggaloid
       vm.Event[event_name].subscribe?(*specs)
     end
 
+    def collect(event_name, *specs)
+      self.class.collect(event_name, *specs)
+    end
+
+    # 追加・削除がフィルタに反映されるコレクションオブジェクトを作成する。
+    # 同時に _event_name_ にフィルタが定義され、フィルタが呼ばれると
+    # その時点のコレクションオブジェクトの内容を全て列挙する。
+    # フィルタと対になるコレクションオブジェクトは、 _&block_ の引数として渡される。
+    # ==== Args
+    # [event_name] イベント名(String | Symbol)
+    # [*specs] Pluggaloid::COLLECT以外の引数
+    # [&block] コレクションオブジェクトを受け取って一度だけ実行されるblock
+    # ==== Return
+    # _&block_ の戻り値
+    def collection(event_name, *specs, &block)
+      event = vm.Event[event_name]
+      mutation = Pluggaloid::Collection.new(event, *specs)
+      add_event_filter(event_name, name: 'collection(%s line %i)' % block.source_location) do |*args|
+        if mutation.argument_hash_same?(args)
+          mutation.values.each(&args[event.collect_index].method(:<<))
+        end
+        args
+      end
+      block.call(mutation)
+    end
+
     # このプラグインのHandlerTagを作る。
     # ブロックが渡された場合は、ブロックの中を実行し、ブロックの中で定義された
     # Handler全てにTagを付与する。
@@ -198,7 +240,6 @@ module Pluggaloid
       end
     end
 
-
     # イベントを削除する。
     # 引数は、Pluggaloid::ListenerかPluggaloid::Filterのみ(on_*やfilter_*の戻り値)。
     # 互換性のため、二つ引数がある場合は第一引数は無視され、第二引数が使われる。
@@ -239,7 +280,8 @@ module Pluggaloid
     # [event_name] イベント名
     # [options] イベントの定義
     def defevent(event_name, options={})
-      vm.Event[event_name].options.merge!({plugin: self}.merge(options)) end
+      vm.Event[event_name].defevent({ plugin: self, **options })
+    end
 
     # DSLメソッドを新しく追加する。
     # 追加されたメソッドは呼ぶと &callback が呼ばれ、その戻り値が返される。引数も順番通り全て &callbackに渡される

data/lib/pluggaloid/stream_generator.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+require 'securerandom'
+require 'set'
+
+class Pluggaloid::StreamGenerator < Pluggaloid::Handler
+  attr_reader :accepted_hash
+
+  def initialize(event, *specs, plugin:, **kwrest, &callback)
+    raise Pluggaloid::UndefinedStreamIndexError, 'To call generate(%{event}), it must define prototype arguments include `Pluggaloid::STREAM\'.' % {event: event.name} unless event.stream_index
+    super(event, **kwrest)
+    @callback = callback
+    @specs = specs.freeze
+    @accepted_hash = @event.argument_hash(specs, nil)
+    @last_subscribe_state = @event.subscribe?(*@specs)
+    @plugin = plugin
+    subscribe_start if @last_subscribe_state
+    @event.register_stream_generator(self)
+  end
+
+  def on_subscribed
+    if !@last_subscribe_state
+      @last_subscribe_state = true
+      subscribe_start
+    end
+  end
+
+  def on_unsubscribed
+    subscribe_state = @event.subscribe_hash?(@accepted_hash)
+    if @last_subscribe_state && !subscribe_state
+      @last_subscribe_state = false
+      subscribe_stop
+    end
+  end
+
+  # このリスナを削除する
+  # ==== Return
+  # self
+  def detach
+    @event.delete_stream_generator(self)
+    @yielder&.die
+    @yielder = nil
+    self
+  end
+
+  private
+
+  def subscribe_start
+    @tag = @plugin.handler_tag do
+      @yielder = Yielder.new(@event, args: @specs)
+      @callback.call(@yielder)
+    end
+  end
+
+  def subscribe_stop
+    @plugin.detach(@tag)
+    @yielder.die
+    @yielder = nil
+  end
+
+  class Yielder
+    def initialize(event, args:)
+      @event = event
+      @args = args.freeze
+      @alive = true
+    end
+
+    def bulk_add(lst)
+      raise Pluggaloid::NoReceiverError, "All event listener of #{self.class} already detached." if die?
+      args = @args.dup
+      args.insert(@event.stream_index, lst)
+      @event.call(*args)
+    end
+
+    def add(value)
+      bulk_add([value])
+    end
+    alias_method :<<, :add
+
+    def die?
+      !@alive
+    end
+
+    def die
+      @alive = false
+      freeze
+    end
+  end
+end

data/lib/pluggaloid/subscriber.rb

@@ -12,9 +12,10 @@ class Pluggaloid::Subscriber < Pluggaloid::Handler
   # [tags:] Pluggaloid::HandlerTag|Array リスナのタグ
   # [&callback] コールバック
   def initialize(event, *specs, **kwrest, &callback)
+    raise Pluggaloid::UndefinedStreamIndexError, 'To call subscribe(%{event}), it must define prototype arguments include `Pluggaloid::STREAM\'.' % {event: event.name} unless event.stream_index
     super(event, **kwrest)
     @callback = callback
-    @accepted_hash = @event.argument_hash(specs)
+    @accepted_hash = @event.argument_hash(specs, nil)
     event.add_listener(self)
   end
 
@@ -22,7 +23,7 @@ class Pluggaloid::Subscriber < Pluggaloid::Handler
   # ==== Args
   # [stream] イベントの引数
   def call(*args)
-    @callback.call(args[@event.yield_index])
+    @callback.call(args[@event.stream_index])
   end
 
   # このリスナを削除する

data/lib/pluggaloid/version.rb

@@ -1,3 +1,3 @@
 module Pluggaloid
-  VERSION = '1.3.1'
+  VERSION = '1.7.0'
 end

data/test/collect_test.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+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 'collect' do
+    Pluggaloid::Plugin.create(:event) do
+      defevent :list, prototype: [Integer, Pluggaloid::COLLECT]
+
+      filter_list do |i, yielder|
+        i.times(&yielder.method(:<<))
+        [i, yielder]
+      end
+    end
+
+    assert_equal([0, 1, 2], Pluggaloid::Event[:list].collect(3).to_a)
+  end
+
+  it 'fail when collect with undefined' do
+    Pluggaloid::Plugin.create(:event) do
+      filter_list do |i, yielder|
+        i.times(&yielder.method(:<<))
+        [i, yielder]
+      end
+    end
+
+    assert_raises(Pluggaloid::UndefinedCollectionIndexError) do
+      Pluggaloid::Event[:list].collect(3)
+    end
+  end
+
+  it 'success caller arguments include Pluggaloid::COLLECT when collect with undefined' do
+    Pluggaloid::Plugin.create(:event) do
+      filter_list do |i, yielder|
+        i.times(&yielder.method(:<<))
+        [i, yielder]
+      end
+    end
+
+    assert_equal([0, 1, 2], Pluggaloid::Event[:list].collect(3, Pluggaloid::COLLECT).to_a)
+  end
+
+  it 'success different caller argument specific and prototype definition' do
+    Pluggaloid::Plugin.create(:event) do
+      defevent :list, prototype: [Integer, Pluggaloid::COLLECT]
+
+      filter_list do |i, yielder|
+        i.times(&yielder.method(:<<))
+        [i, yielder]
+      end
+    end
+
+    assert_equal([0, 1, 2], Pluggaloid::Event[:list].collect(Pluggaloid::COLLECT, 3).to_a)
+  end
+
+  describe 'collection' do
+    it 'add' do
+      Pluggaloid::Plugin.create(:event) do
+        defevent :list, prototype: [Integer, Pluggaloid::COLLECT]
+        defevent :insert, prototype: [Pluggaloid::STREAM]
+
+        collection(:list, 3) do |collector|
+          subscribe(:insert).each do |i|
+            collector.add(i * 3)
+          end
+        end
+      end
+      eval_all_events do
+        Pluggaloid::Event[:insert].call([2, 5])
+      end
+      assert_equal([6, 15], Pluggaloid::Event[:list].collect(3).to_a)
+    end
+
+    it 'delete' do
+      Pluggaloid::Plugin.create(:event) do
+        defevent :list, prototype: [Integer, Pluggaloid::COLLECT]
+        defevent :destroy, prototype: [Pluggaloid::STREAM]
+
+        collection(:list, 3) do |collector|
+          collector << 1 << 2 << 3
+          subscribe(:destroy).each do |i|
+            collector.delete(i)
+          end
+        end
+      end
+      eval_all_events do
+        Pluggaloid::Event[:destroy].call([2, 4])
+      end
+      assert_equal([1, 3], Pluggaloid::Event[:list].collect(3).to_a)
+    end
+
+    it 'rewind' do
+      added = []
+      deleted = []
+      Pluggaloid::Plugin.create(:event) do
+        defevent :list, prototype: [Integer, Pluggaloid::COLLECT]
+
+        collection(:list, 3) do |collector|
+          collector << 1 << 2 << 3
+          on_rewind do |e|
+            collector.rewind do |lst|
+              e
+            end
+          end
+        end
+
+        subscribe(:list__add, 3) do |elm|
+          added += elm
+        end
+
+        subscribe(:list__delete, 3) do |elm|
+          deleted += elm
+        end
+      end
+      eval_all_events do
+        Pluggaloid::Event[:rewind].call([2, 3, 4])
+      end
+      assert_equal([2, 3, 4], Pluggaloid::Event[:list].collect(3).to_a)
+      assert_equal([1, 2, 3, 4], added)
+      assert_equal([1], deleted)
+    end
+  end
+
+end

data/test/generate_test.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+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
+
+  describe 'event' do
+    before do
+      log = @log = []
+      Pluggaloid::Plugin.create(:event) do
+        defevent :list, prototype: [Integer, Pluggaloid::STREAM]
+
+        generate(:list, 1) do |yielder|
+          log << [:g1, :start]
+          on_tick do |digit|
+            log << [:g1, digit]
+            yielder << digit
+          end
+        end
+      end
+    end
+
+    it 'does not call generate block in not subscribed' do
+      assert_equal([], @log)
+    end
+
+    it 'does not call generate block in subscribed other caller arguments' do
+      Pluggaloid::Plugin.create(:event) do
+        subscribe(:list, 2) {}
+      end
+      assert_equal([], @log)
+    end
+
+    describe 'after subscribe' do
+      before do
+        listener = nil
+        Pluggaloid::Plugin.create(:event) do
+          listener = subscribe(:list, 1) {}
+        end
+        @listener = listener
+        eval_all_events
+      end
+
+      it 'call generate block' do
+        assert_equal([[:g1, :start]], @log)
+      end
+
+      it 'call once generate block if subscribe twice' do
+        Pluggaloid::Plugin.create(:event) do
+          subscribe(:list, 1) {}
+        end
+        eval_all_events
+        assert_equal([[:g1, :start]], @log)
+      end
+
+      describe 'detach all listeners' do
+        before do
+          Pluggaloid::Plugin.create(:event).detach(@listener)
+          Pluggaloid::Plugin.call(:event, 1, [69])
+          eval_all_events
+        end
+
+        it 'should detach handlers in generate block after unsubscribed' do
+          assert_equal([[:g1, :start]], @log)
+        end
+      end
+
+    end
+
+    describe 'after add_event_listener' do
+      before do
+        listener = nil
+        Pluggaloid::Plugin.create(:event) do
+          listener = on_list { |_num, _lst| ; }
+        end
+        @listener = listener
+        eval_all_events
+      end
+
+      it 'call generate block' do
+        assert_equal([[:g1, :start]], @log)
+      end
+
+      it 'call once generate block if subscribe twice' do
+        Pluggaloid::Plugin.create(:event) do
+          on_list { |_num, _lst| ; }
+        end
+        eval_all_events
+        assert_equal([[:g1, :start]], @log)
+      end
+
+      describe 'detach all listeners' do
+        before do
+          Pluggaloid::Plugin.create(:event).detach(@listener)
+          Pluggaloid::Plugin.call(:event, 1, [105])
+          eval_all_events
+        end
+
+        it 'detach handlers in generate block after unsubscribed' do
+          assert_equal([[:g1, :start]], @log)
+        end
+      end
+
+    end
+  end
+
+end

data/test/handle_in_generate_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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 'hoge' do
+    refute Pluggaloid::Event[:tick].subscribe?
+  end
+
+  describe 'event' do
+    before do
+      log = @log = []
+      listener = nil
+      Pluggaloid::Plugin.create(:event) do
+        defevent :list, prototype: [Integer, Pluggaloid::STREAM]
+
+        generate(:list, 1) do |yielder|
+          log << [:g1, :start]
+          on_tick do |digit|
+            log << [:g1, digit]
+            yielder << digit
+          end
+        end
+
+        listener = subscribe(:list, 1) do |stream|
+          ;
+        end
+      end
+      @listener = listener
+      eval_all_events
+    end
+
+    it 'subscribed event which define in generate block' do
+      assert Pluggaloid::Event[:tick].subscribe?
+    end
+
+    describe 'unsubscribe generate stream' do
+      before do
+        Pluggaloid::Plugin.create(:event).detach(@listener)
+        eval_all_events
+      end
+
+      it 'unsubscribed event which define in generate block' do
+        refute Pluggaloid::Event[:tick].subscribe?
+      end
+    end
+  end
+end

data/test/mirage_test.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'minitest/autorun'
+
+require 'pluggaloid'
+require_relative 'helper'
+
+describe(Pluggaloid::Plugin) do
+  include PluggaloidTestHelper
+
+  it 'resume' do
+    k = Class.new do
+      include Pluggaloid::Mirage
+    end
+    a = k.new
+    assert_equal(a, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: a.pluggaloid_mirage_id))
+  end
+
+  it 'custom mirage id' do
+    k = Class.new do
+      include Pluggaloid::Mirage
+
+      def initialize(a)
+        @a = a
+      end
+
+      def generate_pluggaloid_mirage_id
+        @a.to_s
+      end
+    end
+
+    a = k.new('same')
+    b = k.new('differ')
+    assert_equal('same', a.pluggaloid_mirage_id)
+    assert_equal(a, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: a.pluggaloid_mirage_id))
+    assert_equal('differ', b.pluggaloid_mirage_id)
+    assert_equal(b, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: b.pluggaloid_mirage_id))
+  end
+
+  it 'not confuse other mirage classese' do
+    definition = ->(*) do
+      include Pluggaloid::Mirage
+
+      def initialize(a)
+        @a = a
+      end
+
+      def generate_pluggaloid_mirage_id
+        @a.to_s
+      end
+    end
+
+    k = Class.new(&definition)
+    l = Class.new(&definition)
+
+    a = k.new('same')
+    b = l.new('same')
+    c = l.new('differ')
+
+    refute_equal(k.to_s, l.to_s)
+    assert_equal('same', a.pluggaloid_mirage_id)
+    assert_equal('same', b.pluggaloid_mirage_id)
+    assert_equal('differ', c.pluggaloid_mirage_id)
+
+    assert_equal(b, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'same'))
+    assert_equal(c, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'differ'))
+    assert_equal(a, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'same'))
+    assert_raises(Pluggaloid::ArgumentError) { Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'differ') }
+  end
+
+  it 'inherit class' do
+    k = Class.new do
+      include Pluggaloid::Mirage
+
+      def initialize(a)
+        @a = a
+      end
+
+      def generate_pluggaloid_mirage_id
+        @a.to_s
+      end
+    end
+    l = Class.new(k)
+
+    a = k.new('same')
+    b = l.new('same')
+    c = l.new('differ')
+
+    refute_equal(k.to_s, l.to_s)
+    assert_equal('same', a.pluggaloid_mirage_id)
+    assert_equal('same', b.pluggaloid_mirage_id)
+    assert_equal('differ', c.pluggaloid_mirage_id)
+
+    assert_equal(b, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'same'))
+    assert_equal(c, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'differ'))
+    assert_equal(a, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'same'))
+    assert_raises(Pluggaloid::ArgumentError) { Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'differ') }
+  end
+
+  it 'inherit before include mirage' do
+    k = Class.new do
+      def initialize(a)
+        @a = a
+      end
+
+      def generate_pluggaloid_mirage_id
+        @a.to_s
+      end
+    end
+    l = Class.new(k)
+    k.include Pluggaloid::Mirage
+
+    a = k.new('same')
+    b = l.new('same')
+    c = l.new('differ')
+
+    refute_equal(k.to_s, l.to_s)
+    assert_equal('same', a.pluggaloid_mirage_id)
+    assert_equal('same', b.pluggaloid_mirage_id)
+    assert_equal('differ', c.pluggaloid_mirage_id)
+
+    assert_equal(b, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'same'))
+    assert_equal(c, Pluggaloid::Mirage.unwrap(namespace: l.to_s, id: 'differ'))
+    assert_equal(a, Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'same'))
+    assert_raises(Pluggaloid::ArgumentError) { Pluggaloid::Mirage.unwrap(namespace: k.to_s, id: 'differ') }
+  end
+
+end

data/test/reactive_test.rb

@@ -32,9 +32,33 @@ describe(Pluggaloid::Plugin) do
     assert_equal(%i[one], sum)
   end
 
-  it "subscribe?" do
+  it "subscribe 2" do
     sum = []
 
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Pluggaloid::STREAM, Integer]
+      subscribe(:increase, 1) do |v|
+        sum = v
+      end
+    end
+
+    eval_all_events do
+      Pluggaloid::Event[:increase].call([:one], 1)
+      Pluggaloid::Event[:increase].call([:two], 2)
+    end
+
+    assert_equal(%i[one], sum)
+  end
+
+  it "raises subscribe without definition" do
+    assert_raises Pluggaloid::UndefinedStreamIndexError do
+      Pluggaloid::Plugin.create(:event) do
+        subscribe(:increase, 1) { ; }
+      end
+    end
+  end
+
+  it "subscribe? first value" do
     Pluggaloid::Plugin.create(:event) do
       defevent :increase, prototype: [Integer, Pluggaloid::STREAM]
       subscribe(:increase, 1) do |v|
@@ -42,12 +66,19 @@ describe(Pluggaloid::Plugin) do
     end
     assert(Pluggaloid::Plugin[:event].subscribe?(:increase, 1))
     refute(Pluggaloid::Plugin[:event].subscribe?(:increase, 2))
+  end
 
+  it "subscribe? last value" do
+    Pluggaloid::Plugin.create(:event) do
+      defevent :increase, prototype: [Pluggaloid::STREAM, Integer]
+      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|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pluggaloid
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.7.0
 platform: ruby
 authors:
 - Toshiaki Asai
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-06 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayer
@@ -99,12 +99,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/pluggaloid.rb
+- lib/pluggaloid/collection.rb
 - lib/pluggaloid/error.rb
 - lib/pluggaloid/event.rb
 - lib/pluggaloid/filter.rb
@@ -112,13 +114,19 @@ files:
 - lib/pluggaloid/handler_tag.rb
 - lib/pluggaloid/identity.rb
 - lib/pluggaloid/listener.rb
+- lib/pluggaloid/mirage.rb
 - lib/pluggaloid/plugin.rb
 - lib/pluggaloid/stream.rb
+- lib/pluggaloid/stream_generator.rb
 - lib/pluggaloid/subscriber.rb
 - lib/pluggaloid/version.rb
 - pluggaloid.gemspec
+- test/collect_test.rb
+- test/generate_test.rb
+- test/handle_in_generate_test.rb
 - test/handler_tag_test.rb
 - test/helper.rb
+- test/mirage_test.rb
 - test/multi_vm_test.rb
 - test/plugin_test.rb
 - test/reactive_test.rb
@@ -126,7 +134,7 @@ homepage: https://rubygems.org/gems/pluggaloid
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,13 +149,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Extensible plugin system
 test_files:
+- test/collect_test.rb
+- test/generate_test.rb
+- test/handle_in_generate_test.rb
 - test/handler_tag_test.rb
 - test/helper.rb
+- test/mirage_test.rb
 - test/multi_vm_test.rb
 - test/plugin_test.rb
 - test/reactive_test.rb