pluggaloid 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2549e40abed501bd7546a76f8368daed95e8436a
+  data.tar.gz: e28a4c206fe73a1d6baac70902ac64c29be1f9ff
+SHA512:
+  metadata.gz: 831b352d0c7aad2f39b44de0da81ccf984e9568834f731fbf160cf929181f998c001102bfabc1eabe86158e4aaacf3775251584a5826fdf1113590d04f99ee7a
+  data.tar.gz: 09ffac441afd19d38dd4e318cd95cedd3d202f8eb35eb3e57e8a3314658c593219021ed61f11adeb36541a47d732e0938e3a4b418e6f6f5c504f99782557cfe1

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pluggaloid.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Toshiaki Asai
+
+MIT License
+
+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,63 @@
+# Pluggaloid
+
+mikutterのプラグイン機構です。
+登録したプラグイン同士がイベントを使って通信できるようになります。
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pluggaloid'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pluggaloid
+
+## Usage
+
+```ruby
+require 'pluggaloid'
+
+main = Pluggaloid.new(Delayer.generate_class(priority: %i<high normal low>, default: :normal))
+
+main.Plugin.create(:write_to_stdout) do
+  on_logging do |message|
+    puts "logging: #{message}"
+  end
+end
+
+main.Plugin.call(:logging, "boot.")
+main.Plugin.call(:logging, "event test.")
+main.Plugin.call(:logging, "exit.")
+
+main.Delayer.run while not main.Delayer.empty?
+```
+
+### Pluggaloid::new
+
+Pluggaloid::newは、プラグイン機構を制御するためのDelayer, Plugin, Event, Listener, Filterのサブクラスを新しく作って返すメソッドです。
+戻り値はStructで、それぞれのクラス名がメンバの名前になっています。
+
+| Member   | Description                         |
+|----------|-------------------------------------|
+| Delayer  | Pluggaloid::new に渡したDelayer     |
+| Plugin   | Pluggaloid::Plugin のサブクラス     |
+| Event    | Pluggaloid::Event のサブクラス      |
+| Listener | Pluggaloid::Listener のサブクラス   |
+| Filter   | Pluggaloid::Filter のサブクラス     |
+
+コンストラクタの唯一の引数には `Delayer.generate_class(priority: %i<high normal low>, default: :normal)`のように、優先順位付きでデフォルト優先度が設定されたDelayerを渡します。
+
+## Contributing
+
+1. Fork it ( https://github.com/toshia/pluggaloid/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.warning = true
+  t.verbose = true
+end
+
+
+
+
+
+
+
+
+

data/lib/pluggaloid.rb

@@ -0,0 +1,21 @@
+require "pluggaloid/version"
+require "pluggaloid/plugin"
+require 'pluggaloid/event'
+require 'pluggaloid/listener'
+require 'pluggaloid/filter'
+require 'pluggaloid/error'
+
+require 'delayer'
+
+module Pluggaloid
+  VM = Struct.new(*%i<Delayer Plugin Event Listener Filter>)
+
+  def self.new(delayer)
+    vm = VM.new(delayer,
+                Class.new(Plugin),
+                Class.new(Event),
+                Class.new(Listener),
+                Class.new(Filter))
+    vm.Plugin.vm = vm.Event.vm = vm
+  end
+end

data/lib/pluggaloid/error.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+module Pluggaloid
+  class Error < ::StandardError; end
+
+  class ArgumentError < Error; end
+
+  class TypeError < Error; end
+
+  class FilterError < Error; end
+
+  class NoDefaultDelayerError < Error; end
+end

data/lib/pluggaloid/event.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+
+class Pluggaloid::Event
+  include InstanceStorage
+
+  # オプション。以下のキーを持つHash
+  # :prototype :: 引数の数と型。Arrayで、type_strictが解釈できる条件を設定する
+  # :priority :: Delayerの優先順位
+  attr_accessor :options
+
+  # フィルタを別のスレッドで実行する。偽ならメインスレッドでフィルタを実行する
+  @filter_another_thread = false
+
+  def initialize(*args)
+    super
+    @options = {}
+    @listeners = []
+    @filters = [] end
+
+  def vm
+    self.class.vm end
+
+  # イベントの優先順位を取得する
+  # ==== Return
+  # プラグインの優先順位
+  def priority
+    if @options.has_key? :priority
+      @options[:priority] end end
+
+  # イベントを引数 _args_ で発生させる
+  # ==== Args
+  # [*args] イベントの引数
+  # ==== Return
+  # Delayerか、イベントを待ち受けているリスナがない場合はnil
+  def call(*args)
+    if self.class.filter_another_thread
+      if @filters.empty?
+        vm.delayer.new(*Array(priority)) do
+        call_all_listeners(args) end
+      else
+        Thread.new do
+          filtered_args = filtering(*args)
+          if filtered_args.is_a? Array
+            vm.Delayer.new(*Array(priority)) do
+              call_all_listeners(filtered_args) end end end end
+    else
+      vm.Delayer.new(*Array(priority)) do
+        args = filtering(*args) if not @filters.empty?
+        call_all_listeners(args) if args.is_a? Array end end end
+
+  # 引数 _args_ をフィルタリングした結果を返す
+  # ==== Args
+  # [*args] 引数
+  # ==== Return
+  # フィルタされた引数の配列
+  def filtering(*args)
+    catch(:filter_exit) {
+      @filters.reduce(args){ |acm, event_filter|
+        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
+    @listeners << listener
+    self end
+
+  def delete_listener(event_filter)
+    @listeners.delete(event_filter)
+    self end
+
+  # イベントフィルタを追加する
+  # ==== Args
+  # [event_filter] イベントフィルタ(Filter)
+  # ==== Return
+  # self
+  def add_filter(event_filter)
+    unless event_filter.is_a? Pluggaloid::Filter
+      raise Pluggaloid::ArgumentError, "First argument must be Pluggaloid::Filter, but given #{event_filter.class}." end
+    @filters << event_filter
+    self end
+
+  # イベントフィルタを削除する
+  # ==== Args
+  # [event_filter] イベントフィルタ(EventFilter)
+  # ==== Return
+  # self
+  def delete_filter(event_filter)
+    @filters.delete(event_filter)
+    self end
+
+  private
+  def call_all_listeners(args)
+    catch(:plugin_exit) do
+      @listeners.each do |listener|
+        listener.call(*args) end end end
+
+  class << self
+    attr_accessor :filter_another_thread, :vm
+
+    alias __clear_aF4e__ clear!
+    def clear!
+      @filter_another_thread = false
+      __clear_aF4e__()
+    end
+  end
+
+  clear!
+end

data/lib/pluggaloid/filter.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+class Pluggaloid::Filter
+  # フィルタ内部で使う。フィルタの実行をキャンセルする。Plugin#filtering はfalseを返し、
+  # イベントのフィルタの場合は、そのイベントの実行自体をキャンセルする。
+  # また、 _result_ が渡された場合、Event#filtering の戻り値は _result_ になる。
+  def self.cancel!(result=false)
+    throw :filter_exit, result end
+
+  # ==== Args
+  # [event] 監視するEventのインスタンス
+  # [&callback] コールバック
+  def initialize(event, &callback)
+    raise Pluggaloid::TypeError, "Argument `event' must be instance of Pluggaloid::Event, but given #{event.class}." unless event.is_a? Pluggaloid::Event
+    @event = event
+    @callback = Proc.new
+    event.add_filter self end
+
+  # イベントを実行する
+  # ==== Args
+  # [*args] イベントの引数
+  # ==== Return
+  # 加工後の引数の配列
+  def filtering(*args)
+    length = args.size
+    result = @callback.call(*args, &self.class.method(:cancel!))
+    if length != result.size
+      raise Pluggaloid::FilterError, "filter changes arguments length (#{length} to #{result.size})" end
+    result end
+
+  # このリスナを削除する
+  # ==== Return
+  # self
+  def detach
+    @event.delete_filter(self)
+    self end
+
+end

data/lib/pluggaloid/listener.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+class Pluggaloid::Listener
+  # プラグインコールバックをこれ以上実行しない。
+  def self.cancel!
+    throw :plugin_exit, false end
+
+  # ==== Args
+  # [event] 監視するEventのインスタンス
+  # [&callback] コールバック
+  def initialize(event, &callback)
+    raise Pluggaloid::TypeError, "Argument `event' must be instance of Pluggaloid::Event, but given #{event.class}." unless event.is_a? Pluggaloid::Event
+    @event = event
+    @callback = Proc.new
+    event.add_listener(self) end
+
+  # イベントを実行する
+  # ==== Args
+  # [*args] イベントの引数
+  def call(*args)
+    @callback.call(*args, &self.class.method(:cancel!)) end
+
+  # このリスナを削除する
+  # ==== Return
+  # self
+  def detach
+    @event.delete_listener(self)
+    self end
+end

data/lib/pluggaloid/plugin.rb

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+
+require 'instance_storage'
+require 'delayer'
+
+# プラグインの本体。
+# DSLを提供し、イベントやフィルタの管理をする
+module Pluggaloid
+  class Plugin
+    include InstanceStorage
+
+    class << self
+      attr_writer :vm
+
+      def vm
+        @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)
+                  vm.Event.vm = vm end end
+
+      # プラグインのインスタンスを返す。
+      # ブロックが渡された場合、そのブロックをプラグインのインスタンスのスコープで実行する
+      # ==== Args
+      # [plugin_name] プラグイン名
+      # ==== Return
+      # Plugin
+      def create(plugin_name, &body)
+        self[plugin_name].instance_eval(&body) if body
+        self[plugin_name] end
+
+      # イベントを宣言する。
+      # ==== Args
+      # [event_name] イベント名
+      # [options] 以下のキーを持つHash
+      # :prototype :: 引数の数と型。Arrayで、type_strictが解釈できる条件を設定する
+      # :priority :: Delayerの優先順位
+      def defevent(event_name, options = {})
+        vm.Event[event_name].options = options end
+
+      # イベント _event_name_ を発生させる
+      # ==== Args
+      # [event_name] イベント名
+      # [*args] イベントの引数
+      # ==== Return
+      # Delayer
+      def call(event_name, *args)
+        vm.Event[event_name].call(*args) end
+
+      # 引数 _args_ をフィルタリングした結果を返す
+      # ==== Args
+      # [*args] 引数
+      # ==== Return
+      # フィルタされた引数の配列
+      def filtering(event_name, *args)
+        vm.Event[event_name].filtering(*args) end
+
+      # 互換性のため
+      def uninstall(plugin_name)
+        self[plugin_name].uninstall end
+
+      # 互換性のため
+      def filter_cancel!
+        vm.Filter.cancel! end
+
+      alias plugin_list instances_name
+
+      alias __clear_aF4e__ clear!
+      def clear!
+        if defined?(@vm) and @vm
+          @vm.Event.clear!
+          @vm = nil end
+        __clear_aF4e__() end
+    end
+
+    # プラグインの名前
+    attr_reader :name
+
+    # spec
+    attr_accessor :spec
+
+    # 最初にプラグインがロードされた時刻(uninstallされるとリセットする)
+    attr_reader :defined_time
+
+    # ==== Args
+    # [plugin_name] プラグイン名
+    def initialize(*args)
+      super
+      @defined_time = Time.new.freeze
+      @events = Set.new
+      @filters = Set.new end
+
+    # イベントリスナを新しく登録する
+    # ==== Args
+    # [event_name] イベント名
+    # [&callback] イベントのコールバック
+    # ==== Return
+    # Pluggaloid::Listener
+    def add_event(event_name, &callback)
+      result = vm.Listener.new(vm.Event[event_name], &callback)
+      @events << result
+      result end
+
+    # イベントフィルタを新しく登録する
+    # ==== Args
+    # [event_name] イベント名
+    # [&callback] イベントのコールバック
+    # ==== Return
+    # EventFilter
+    def add_event_filter(event_name, &callback)
+      result = vm.Filter.new(vm.Event[event_name], &callback)
+      @filters << result
+      result end
+
+    # イベントを削除する。
+    # 引数は、Pluggaloid::ListenerかPluggaloid::Filterのみ(on_*やfilter_*の戻り値)。
+    # 互換性のため、二つ引数がある場合は第一引数は無視され、第二引数が使われる。
+    # ==== Args
+    # [*args] 引数
+    # ==== Return
+    # self
+    def detach(*args)
+      listener = args.last
+      if listener.is_a? vm.Listener
+        @events.delete(listener)
+        listener.detach
+      elsif listener.is_a? vm.Filter
+        @filters.delete(listener)
+        listener.detach end
+      self end
+
+    # このプラグインを破棄する
+    # ==== Return
+    # self
+    def uninstall
+      @events.map(&:detach)
+      @filters.map(&:detach)
+      self.class.destroy name
+      execute_unload_hook
+      self end
+
+    # イベント _event_name_ を宣言する
+    # ==== Args
+    # [event_name] イベント名
+    # [options] イベントの定義
+    def defevent(event_name, options={})
+      vm.Event[event_name].options.merge!({plugin: self}.merge(options)) end
+
+    # DSLメソッドを新しく追加する。
+    # 追加されたメソッドは呼ぶと &callback が呼ばれ、その戻り値が返される。引数も順番通り全て &callbackに渡される
+    # ==== Args
+    # [dsl_name] 新しく追加するメソッド名
+    # [&callback] 実行されるメソッド
+    # ==== Return
+    # self
+    def defdsl(dsl_name, &callback)
+      self.class.instance_eval {
+        define_method(dsl_name, &callback) }
+      self end
+
+    # プラグインが Plugin.uninstall される時に呼ばれるブロックを登録する。
+    def onunload
+      @unload_hook ||= []
+      @unload_hook.push(Proc.new) end
+    alias :on_unload :onunload
+
+    # マジックメソッドを追加する。
+    # on_?name :: add_event(name)
+    # filter_?name :: add_event_filter(name)
+    def method_missing(method, *args, &proc)
+      case method.to_s
+      when /\Aon_?(.+)\Z/
+        add_event($1.to_sym, &proc)
+      when /\Afilter_?(.+)\Z/
+        add_event_filter($1.to_sym, &proc)
+      when /\Ahook_?(.+)\Z/
+        add_event_hook($1.to_sym, &proc)
+      else
+        super end end
+
+    private
+
+    def execute_unload_hook
+      @unload_hook.each{ |unload| unload.call } if(defined?(@unload_hook)) end
+
+    def vm
+      self.class.vm end
+
+  end
+end

data/lib/pluggaloid/version.rb

@@ -0,0 +1,3 @@
+module Pluggaloid
+  VERSION = "1.0.0"
+end

data/pluggaloid.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pluggaloid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pluggaloid"
+  spec.version       = Pluggaloid::VERSION
+  spec.authors       = ["Toshiaki Asai"]
+  spec.email         = ["toshi.alternative@gmail.com"]
+  spec.summary       = %q{Extensible plugin system}
+  spec.description   = %q{Pluggaloid is extensible plugin system for mikutter.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'delayer'
+  spec.add_dependency 'instance_storage', ">= 1.0.0", "< 2.0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/test/multi_vm_test.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+require 'bundler/setup'
+require 'minitest/autorun'
+
+require 'pluggaloid'
+
+describe(Pluggaloid) do
+  before do
+    Delayer.default = Delayer.generate_class(priority: %i<high normal low>, default: :normal)
+    Pluggaloid::Plugin.clear!
+  end
+
+  def eval_all_events(delayer=Delayer)
+    native = Thread.list
+    yield if block_given?
+    delayer.run while not(delayer.empty? and (Thread.list - native).empty?)
+  end
+
+  it "should take new plugin classes" do
+    pluggaloid = Pluggaloid.new(Delayer.default)
+    assert_equal Delayer.default, pluggaloid.Delayer, ""
+    assert_includes(pluggaloid.Plugin.ancestors, Pluggaloid::Plugin, "Plugin should subbclass of Pluggaloid::Plugin")
+    assert_includes(pluggaloid.Event.ancestors, Pluggaloid::Event, "Event should subbclass of Pluggaloid::Event")
+    assert_includes(pluggaloid.Listener.ancestors, Pluggaloid::Listener, "Listener should subbclass of Pluggaloid::Listener")
+    assert_includes(pluggaloid.Filter.ancestors, Pluggaloid::Filter, "Filter should subbclass of Pluggaloid::Filter")
+  end
+
+  it "call event in new vm" do
+    vm_a = Pluggaloid.new(Delayer.generate_class(priority: %i<high normal low>, default: :normal))
+    vm_b = Pluggaloid.new(Delayer.generate_class(priority: %i<high normal low>, default: :normal))
+    foo = bar = false
+    vm_a.Plugin.create(:foo_plugin) do
+      on_foo do
+        foo = true end end
+    vm_b.Plugin.create(:bar_plugin) do
+      on_bar do
+        bar = true end end
+
+    assert_equal(%i<foo_plugin>, vm_a.Plugin.instances_name)
+    assert_equal(%i<bar_plugin>, vm_b.Plugin.instances_name)
+
+    eval_all_events(vm_a.Delayer) do
+      vm_a.Plugin.call(:foo)
+      vm_a.Plugin.call(:bar) end
+    assert foo, "Event foo should be called"
+    refute bar, "Event bar should not be called"
+
+    foo = bar = false
+    eval_all_events(vm_b.Delayer) do
+      vm_b.Plugin.call(:foo)
+      vm_b.Plugin.call(:bar) end
+    refute foo, "Event foo should not be called"
+    assert bar, "Event bar should be called"
+  end
+end

data/test/plugin_test.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+require 'bundler/setup'
+require 'minitest/autorun'
+
+require 'pluggaloid'
+
+describe(Pluggaloid::Plugin) do
+  before do
+    Delayer.default = Delayer.generate_class(priority: %i<high normal low>, default: :normal)
+    Pluggaloid::Plugin.clear!
+  end
+
+  def eval_all_events
+    native = Thread.list
+    yield if block_given?
+    Delayer.run while not(Delayer.empty? and (Thread.list - native).empty?)
+  end
+
+  it "fire and filtering event, receive a plugin" do
+    sum = 0
+    Pluggaloid::Plugin.create(:event) do
+      on_increase do |v|
+        sum += v end
+
+      filter_increase do |v|
+        [v * 2] end end
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1) end
+    assert_equal(2, sum)
+  end
+
+  it "filter in another thread" do
+    filter_thread = nil
+    Pluggaloid::Plugin.create(:event) do
+      on_thread do
+      end
+
+      filter_thread do
+        filter_thread = Thread.current
+        [] end end
+    eval_all_events do
+      Pluggaloid::Event[:thread].call end
+    assert filter_thread
+    assert_equal Thread.current, filter_thread
+
+    Pluggaloid::Event.filter_another_thread = true
+    filter_thread = nil
+    eval_all_events do
+      Pluggaloid::Event[:thread].call end
+    assert filter_thread, "The filter doesn't run."
+    refute_equal Thread.current, filter_thread, 'The filter should execute in not a main thread'
+  end
+
+  it "uninstall" do
+    sum = 0
+    Pluggaloid::Plugin.create(:event) do
+      on_increase do |v|
+        sum += v end
+      filter_increase do |v|
+        [v * 2] end end
+    eval_all_events do
+      Pluggaloid::Plugin.create(:event).uninstall
+      Pluggaloid::Event[:increase].call(1) end
+    assert_equal(0, sum)
+  end
+
+  it "detach" do
+    sum = 0
+    event = filter = nil
+    Pluggaloid::Plugin.create(:event) do
+      event = on_increase do |v|
+        sum += v end
+      filter = filter_increase do |v|
+        [v * 2] end end
+    eval_all_events do
+      Pluggaloid::Event[:increase].call(1) end
+    assert_equal(2, sum, "It should execute filter when event called")
+
+    eval_all_events do
+      Pluggaloid::Plugin[:event].detach filter
+      Pluggaloid::Event[:increase].call(1) end
+    assert_equal(3, sum, "It should not execute detached filter when event called")
+
+    eval_all_events do
+      Pluggaloid::Plugin.create(:event).detach event
+      Pluggaloid::Event[:increase].call(1) end
+    assert_equal(3, sum, "It should not executed detached event")
+  end
+
+  it "get plugin list" do
+    assert_empty(Pluggaloid::Plugin.plugin_list, "Plugin list must empty in first time")
+    Pluggaloid::Plugin.create(:plugin_0)
+    assert_equal(%i<plugin_0>, Pluggaloid::Plugin.plugin_list, "The new plugin should appear plugin list")
+    Pluggaloid::Plugin.create(:plugin_1)
+    assert_equal(%i<plugin_0 plugin_1>, Pluggaloid::Plugin.plugin_list, "The new plugin should appear plugin list")
+  end
+
+  it "dsl method defevent" do
+    Pluggaloid::Plugin.create :defevent do
+      defevent :increase, prototype: [Integer] end
+    assert_equal([Integer], Pluggaloid::Event[:increase].options[:prototype])
+    assert_equal(Pluggaloid::Plugin[:defevent], Pluggaloid::Event[:increase].options[:plugin])
+  end
+
+  it "unload hook" do
+    value = 0
+    Pluggaloid::Plugin.create(:unload) {
+      on_unload {
+        value += 2 }
+      on_unload {
+        value += 1 } }
+    assert_equal(value, 0)
+    Pluggaloid::Plugin.create(:unload).uninstall
+    assert_equal(value, 3)
+  end
+
+  describe "defdsl" do
+    it "simple dsl" do
+      Pluggaloid::Plugin.create :dsl_def do
+        defdsl :twice do |number|
+          number * 2 end end
+
+      dsl_use = Pluggaloid::Plugin[:dsl_use]
+      assert_equal(4, dsl_use.twice(2))
+      assert_equal(0, dsl_use.twice(0))
+      assert_equal(-26, dsl_use.twice(-13))
+    end
+
+    it "callback dsl" do
+      Pluggaloid::Plugin.create :dsl_def do
+        defdsl :rejector do |value, &condition|
+          value.reject(&condition) end end
+
+      dsl_use = Pluggaloid::Plugin.create(:dsl_use)
+      assert_equal([2, 4, 6], dsl_use.rejector(1..6){ |d| 0 != (d & 1) })
+    end
+  end
+
+  it 'raises NoDefaultDelayerError if Delayer do not have default delayer' do
+    Delayer.default = nil
+    Pluggaloid::Plugin.clear!
+    assert_raises(Pluggaloid::NoDefaultDelayerError) do
+      Pluggaloid::Plugin.create(:raises) do
+        on_no_default_delayer_error do; end end end
+  end
+
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: pluggaloid
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Toshiaki Asai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delayer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: instance_storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: Pluggaloid is extensible plugin system for mikutter.
+email:
+- toshi.alternative@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pluggaloid.rb
+- lib/pluggaloid/error.rb
+- lib/pluggaloid/event.rb
+- lib/pluggaloid/filter.rb
+- lib/pluggaloid/listener.rb
+- lib/pluggaloid/plugin.rb
+- lib/pluggaloid/version.rb
+- pluggaloid.gemspec
+- test/multi_vm_test.rb
+- test/plugin_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Extensible plugin system
+test_files:
+- test/multi_vm_test.rb
+- test/plugin_test.rb