pluggaloid-1.1.1/0000755000004100000410000000000012706311701013667 5ustar www-datawww-datapluggaloid-1.1.1/Rakefile0000644000004100000410000000025612706311701015337 0ustar www-datawww-datarequire "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 pluggaloid-1.1.1/Gemfile0000644000004100000410000000013712706311701015163 0ustar www-datawww-datasource 'https://rubygems.org' # Specify your gem's dependencies in pluggaloid.gemspec gemspec pluggaloid-1.1.1/LICENSE.txt0000644000004100000410000000205612706311701015515 0ustar www-datawww-dataCopyright (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. pluggaloid-1.1.1/lib/0000755000004100000410000000000012706311701014435 5ustar www-datawww-datapluggaloid-1.1.1/lib/pluggaloid/0000755000004100000410000000000012706311701016564 5ustar www-datawww-datapluggaloid-1.1.1/lib/pluggaloid/listener.rb0000644000004100000410000000156512706311701020745 0ustar www-datawww-data# -*- coding: utf-8 -*- require 'securerandom' require 'set' class Pluggaloid::Listener < Pluggaloid::Handler # プラグインコールバックをこれ以上実行しない。 def self.cancel! throw :plugin_exit, false end # ==== Args # [event] 監視するEventのインスタンス # [name:] 名前(String | nil) # [slug:] イベントリスナスラッグ(Symbol | nil) # [tags:] Pluggaloid::HandlerTag|Array リスナのタグ # [&callback] コールバック def initialize(event, **kwrest, &callback) super @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 pluggaloid-1.1.1/lib/pluggaloid/identity.rb0000644000004100000410000000106412706311701020743 0ustar www-datawww-data# -*- coding: utf-8 -*- =begin rdoc slugと名前をもつオブジェクト。 これの参照を直接持たずとも、slugで一意に参照したり、表示名を設定することができる =end class Pluggaloid::Identity attr_reader :name, :slug # ==== Args # [name:] 名前(String | nil) # [slug:] ハンドラスラッグ(Symbol | nil) def initialize(slug: SecureRandom.uuid, name: slug) @name = name.to_s.freeze @slug = slug.to_sym end def inspect "#<#{self.class} slug: #{slug.inspect}, name: #{name.inspect}>" end end pluggaloid-1.1.1/lib/pluggaloid/plugin.rb0000644000004100000410000001747312706311701020423 0ustar www-datawww-data# -*- coding: utf-8 -*- require 'instance_storage' require 'delayer' require 'securerandom' require 'set' # プラグインの本体。 # 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, Pluggaloid::HandlerTag) 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] 監視するEventのインスタンス # [name:] 名前(String | nil) # [slug:] イベントリスナスラッグ(Symbol | nil) # [tags:] Pluggaloid::HandlerTag|Array リスナのタグ # [&callback] コールバック # ==== Return # Pluggaloid::Listener def add_event(event_name, **kwrest, &callback) result = vm.Listener.new(vm.Event[event_name], **kwrest, &callback) @events << result result end # イベントフィルタを新しく登録する # ==== Args # [event] 監視するEventのインスタンス # [name:] 名前(String | nil) # [slug:] フィルタスラッグ(Symbol | nil) # [tags:] Pluggaloid::HandlerTag|Array フィルタのタグ # [&callback] コールバック # ==== Return # Pluggaloid::Filter def add_event_filter(event_name, **kwrest, &callback) result = vm.Filter.new(vm.Event[event_name], **kwrest, &callback) @filters << result result end # このプラグインのHandlerTagを作る。 # ブロックが渡された場合は、ブロックの中を実行し、ブロックの中で定義された # Handler全てにTagを付与する。 # ==== Args # [slug] スラッグ # [name] タグ名 # ==== Return # Pluggaloid::HandlerTag def handler_tag(slug=SecureRandom.uuid, name=slug) tag = case slug when String, Symbol vm.HandlerTag.new(slug: slug.to_sym, name: name.to_s, plugin: self) when vm.HandlerTag slug else raise Pluggaloid::TypeError, "Argument `slug' must be instance of Symbol, String or Pluggaloid::HandlerTag, but given #{slug.class}." end if block_given? handlers = @events + @filters yield tag (@events + @filters - handlers).each do |handler| handler.add_tag(tag) end else tag end end # イベントリスナを列挙する # ==== Return # Set of Pluggaloid::Listener def listeners if block_given? @events.each(&Proc.new) else @events.dup end end # フィルタを列挙する # ==== Return # Set of Pluggaloid::Filter def filters if block_given? @filters.each(&Proc.new) else @filters.dup end end # イベントを削除する。 # 引数は、Pluggaloid::ListenerかPluggaloid::Filterのみ(on_*やfilter_*の戻り値)。 # 互換性のため、二つ引数がある場合は第一引数は無視され、第二引数が使われる。 # ==== Args # [*args] 引数 # ==== Return # self def detach(*args) listener = args.last case listener when vm.Listener @events.delete(listener) listener.detach when vm.Filter @filters.delete(listener) listener.detach when Enumerable listener.each(&method(:detach)) else raise ArgumentError, "Argument must be Pluggaloid::Listener, Pluggaloid::Filter, Pluggaloid::HandlerTag or Enumerable. But given #{listener.class}." end self end # このプラグインを破棄する # ==== Return # self def uninstall vm.Event[:unload].call(self.name) vm.Delayer.new do @events.map(&:detach) @filters.map(&:detach) self.class.destroy name end 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 callback = Proc.new add_event(:unload) do |plugin_slug| if plugin_slug == self.name callback.call end end end alias :on_unload :onunload # マジックメソッドを追加する。 # on_?name :: add_event(name) # filter_?name :: add_event_filter(name) def method_missing(method, *args, **kwrest, &proc) case method.to_s when /\Aon_?(.+)\Z/ add_event($1.to_sym, *args, **kwrest, &proc) when /\Afilter_?(.+)\Z/ add_event_filter($1.to_sym, **kwrest, &proc) when /\Ahook_?(.+)\Z/ add_event_hook($1.to_sym, &proc) else super end end private def vm self.class.vm end end end pluggaloid-1.1.1/lib/pluggaloid/filter.rb0000644000004100000410000000247212706311701020403 0ustar www-datawww-data# -*- coding: utf-8 -*- class Pluggaloid::Filter < Pluggaloid::Handler # フィルタ内部で使う。フィルタの実行をキャンセルする。Plugin#filtering はfalseを返し、 # イベントのフィルタの場合は、そのイベントの実行自体をキャンセルする。 # また、 _result_ が渡された場合、Event#filtering の戻り値は _result_ になる。 def self.cancel!(result=false) throw :filter_exit, result end # ==== Args # [event] 監視するEventのインスタンス # [name:] 名前(String | nil) # [slug:] フィルタスラッグ(Symbol | nil) # [tags:] Pluggaloid::HandlerTag|Array フィルタのタグ # [&callback] コールバック def initialize(event, **kwrest, &callback) super @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 pluggaloid-1.1.1/lib/pluggaloid/event.rb0000644000004100000410000000625112706311701020236 0ustar www-datawww-data# -*- 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 if @listeners.map(&:slug).include?(listener.slug) raise Pluggaloid::DuplicateListenerSlugError, "Listener slug #{listener.slug} already exists." 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 pluggaloid-1.1.1/lib/pluggaloid/version.rb0000644000004100000410000000005212706311701020573 0ustar www-datawww-datamodule Pluggaloid VERSION = "1.1.1" end pluggaloid-1.1.1/lib/pluggaloid/handler.rb0000644000004100000410000000265412706311701020535 0ustar www-datawww-data# -*- coding: utf-8 -*- =begin rdoc イベントのListenerやFilterのスーパクラス。 イベントに関連付けたり、タグを付けたりできる =end class Pluggaloid::Handler < Pluggaloid::Identity Lock = Mutex.new attr_reader :tags # ==== Args # [event] 監視するEventのインスタンス # [name:] 名前(String | nil) # [slug:] ハンドラスラッグ(Symbol | nil) # [tags:] Pluggaloid::HandlerTag|Array リスナのタグ # [&callback] コールバック def initialize(event, tags: [], **kwrest) raise Pluggaloid::TypeError, "Argument `event' must be instance of Pluggaloid::Event, but given #{event.class}." unless event.is_a? Pluggaloid::Event super(**kwrest) @event = event _tags = tags.is_a?(Pluggaloid::HandlerTag) ? [tags] : Array(tags) _tags.each{|t| raise "#{t} is not a Pluggaloid::HandlerTag" unless t.is_a?(Pluggaloid::HandlerTag) } @tags = Set.new(_tags).freeze end def add_tag(tag) raise Pluggaloid::TypeError, "Argument `tag' must be instance of Pluggaloid::HandlerTag, but given #{tag.class}." unless tag.is_a? Pluggaloid::HandlerTag Lock.synchronize do @tags = Set.new([tag, *@tags]).freeze end self end def remove_tag(tag) Lock.synchronize do @tags -= tag @tags.freeze end self end def inspect "#<#{self.class} event: #{@event.name.inspect}, slug: #{slug.inspect}, name: #{name.inspect}>" end end pluggaloid-1.1.1/lib/pluggaloid/handler_tag.rb0000644000004100000410000000506512706311701021367 0ustar www-datawww-data# -*- coding: utf-8 -*- require 'securerandom' =begin rdoc = リスナをまとめて管理するプラグイン Pluggaloid::Listener や、 Pluggaloid::Filter をまとめて扱うための仕組み。 Pluggaloid::Plugin#add_event などの引数 _tags:_ に、このインスタンスを設定する。 == インスタンスの作成 Pluggaloid::Plugin#handler_tag を使って生成する。 Pluggaloid::HandlerTag の _plugin:_ 引数には、レシーバ(Pluggaloid::Plugin)が渡される。 Pluggaloid::HandlerTag は、このプラグインの中でだけ使える。複数のプラグインのリスナ をまとめて管理することはできない。 == リスナにタグをつける Pluggaloid::Plugin#add_event または Pluggaloid::Plugin#add_event_filter の _tags:_ 引数にこれのインスタンスを渡す。 == このタグがついたListenerやFilterを取得する Enumerable をincludeしていて、リスナやフィルタを取得することができる。 また、 - Pluggaloid::HandlerTag#listeners で、 Pluggaloid::Listener だけ - Pluggaloid::HandlerTag#filters で、 Pluggaloid::Filter だけ を対象にした Enumerator を取得することができる == このタグがついたリスナを全てdetachする Pluggaloid::Plugin#detach の第一引数に Pluggaloid::HandlerTag の インスタンスを渡すことで、そのHandlerTagがついたListener、Filterは全てデタッチ される =end class Pluggaloid::HandlerTag < Pluggaloid::Identity include Enumerable # ==== Args # [name:] タグの名前(String | nil) def initialize(plugin:, **kwrest) super(**kwrest) @plugin = plugin end # このTagがついている Pluggaloid::Listener と Pluggaloid::Filter を全て列挙する # ==== Return # Enumerable def each if block_given? Enumerator.new do |y| listeners{|x| y << x } filters{|x| y << x } end.each(&Proc.new) else Enumerator.new do |y| listeners{|x| y << x } filters{|x| y << x } end end end # このTagがついている Pluggaloid::Listener を全て列挙する # ==== Return # Enumerable def listeners if block_given? listeners.each(&Proc.new) else @plugin.to_enum(:listeners).lazy.select{|l| l.tags.include?(self) } end end # このTagがついている Pluggaloid::Filter を全て列挙する # ==== Return # Enumerable def filters if block_given? filters.each(&Proc.new) else @plugin.to_enum(:filters).lazy.select{|l| l.tags.include?(self) } end end end pluggaloid-1.1.1/lib/pluggaloid/error.rb0000644000004100000410000000042612706311701020244 0ustar www-datawww-data# -*- 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 class DuplicateListenerSlugError < Error; end end pluggaloid-1.1.1/lib/pluggaloid.rb0000644000004100000410000000120712706311701017111 0ustar www-datawww-datarequire "pluggaloid/version" require "pluggaloid/plugin" require 'pluggaloid/event' require "pluggaloid/identity" require "pluggaloid/handler" require 'pluggaloid/listener' require 'pluggaloid/filter' require "pluggaloid/handler_tag" require 'pluggaloid/error' require 'delayer' module Pluggaloid VM = Struct.new(*%i) def self.new(delayer) vm = VM.new(delayer, Class.new(Plugin), Class.new(Event), Class.new(Listener), Class.new(Filter), Class.new(HandlerTag)) vm.Plugin.vm = vm.Event.vm = vm end end pluggaloid-1.1.1/test/0000755000004100000410000000000012706311701014646 5ustar www-datawww-datapluggaloid-1.1.1/test/multi_vm_test.rb0000644000004100000410000000357012706311701020073 0ustar www-datawww-data# -*- coding: utf-8 -*- require 'bundler/setup' require 'minitest/autorun' require 'pluggaloid' require_relative 'helper' describe(Pluggaloid) do include PluggaloidTestHelper before do Delayer.default = Delayer.generate_class(priority: %i, default: :normal) Pluggaloid::Plugin.clear! 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, default: :normal)) vm_b = Pluggaloid.new(Delayer.generate_class(priority: %i, 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, vm_a.Plugin.instances_name) assert_equal(%i, 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 pluggaloid-1.1.1/test/helper.rb0000644000004100000410000000034512706311701016454 0ustar www-datawww-data# -*- coding: utf-8 -*- module PluggaloidTestHelper 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 end pluggaloid-1.1.1/test/plugin_test.rb0000644000004100000410000001407512706311701017537 0ustar www-datawww-data# -*- 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, default: :normal) Pluggaloid::Plugin.clear! 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 success = filter_thread = nil Pluggaloid::Plugin.create(:event) do on_thread do end on_unhandled do success = true 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 Pluggaloid::Event[:unhandled].call end assert filter_thread, "The filter doesn't run." assert success, "Event :unhandled 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, Pluggaloid::Plugin.plugin_list, "The new plugin should appear plugin list") Pluggaloid::Plugin.create(:plugin_1) assert_equal(%i, 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 describe "unload hook" do before do @value = value = [] Pluggaloid::Plugin.create(:temporary) { on_unload { value << 2 } on_unload { value << 1 } } Pluggaloid::Plugin.create(:eternal) { on_unload { raise "try to unload eternal plugin" } } end it 'should not call unload event it is not unload' do assert_empty(@value) end describe 'unload temporary plugin' do before do eval_all_events do Pluggaloid::Plugin.create(:temporary).uninstall end end it 'was called unload hooks' do assert_equal([1, 2].sort, @value.sort) end end 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 describe "named listener" do it 'raises when duplicate slug registered to equally events' do assert_raises(Pluggaloid::DuplicateListenerSlugError) do Pluggaloid::Plugin.create :duplicate_slug do on_a(slug: :duplicate){} on_a(slug: :duplicate){} end end end it 'was not raises when duplicate slug registered to another events' do Pluggaloid::Plugin.create :duplicate_slug do on_a(slug: :duplicate){} on_b(slug: :duplicate){} end end it 'successful when dupliacte name registered to another events' do a = b = nil Pluggaloid::Plugin.create :duplicate_name do a = on_a(name: "duplicate"){} b = on_b(name: "duplicate"){} end assert_equal("duplicate", a.name, 'a.name should be "duplicate"') assert_equal("duplicate", b.name, 'b.name should be "duplicate"') end it 'include listener slug and name in Pluggaloid::Listener#inspect' do a = nil Pluggaloid::Plugin.create :inspect do a = on_a(slug: :inspect_slug, name: "inspect name"){} end assert(a.inspect.include?("inspect_slug"), 'Pluggaloid::Listener.inspect does not include slug') assert(a.inspect.include?("inspect name"), 'Pluggaloid::Listener.inspect does not include name') end end end pluggaloid-1.1.1/test/handler_tag_test.rb0000644000004100000410000000665012706311701020511 0ustar www-datawww-data# -*- coding: utf-8 -*- require 'bundler/setup' require 'minitest/autorun' require 'pluggaloid' require_relative 'helper' describe(Pluggaloid::HandlerTag) do include PluggaloidTestHelper before do Delayer.default = Delayer.generate_class(priority: %i, default: :normal) Pluggaloid::Plugin.clear! @pluggaloid = Pluggaloid.new(Delayer.default) end describe 'plugin tag' do before do a = b = c = d = fd = tag_a = tag_b = tag_c = tag_d = nil lst = @lst = [] @plugin = @pluggaloid.Plugin.create :parent do a = on_a{ lst << :a } tag_a = handler_tag :tag_a tag_b = handler_tag :tag_b tag_c = handler_tag :tag_c tag_d = handler_tag :tag_d b = on_b(tags: tag_a){ lst << :b } c = on_c(tags: [tag_a, tag_b]){ lst << :c } handler_tag tag_d do d = on_d(tags: [tag_b]){ lst << :d } handler_tag tag_c do fd = filter_d{|&stop| stop.call } end end end @a, @b, @c, @d, @fd = a, b, c, d, fd @tag_a, @tag_b, @tag_c, @tag_d = tag_a, tag_b, tag_c, tag_d end it 'plugin has 4 listeners' do assert_equal 4, @plugin.listeners.count end it 'listener a has no tag' do assert_empty @a.tags end it 'listener b has tag_a' do assert_equal Set.new([@tag_a]), @b.tags end it 'listener c has tag_a and tag_b' do assert_equal Set.new([@tag_a, @tag_b]), @c.tags end it 'listener d has tag_b and tag_d' do assert_equal Set.new([@tag_b, @tag_d]), @d.tags end it 'filter fd has tag_c and tag_d' do assert_equal Set.new([@tag_c, @tag_d]), @fd.tags end describe 'detach tag_a' do before do @plugin.detach(@tag_a) @pluggaloid.Event[:a].call @pluggaloid.Event[:b].call @pluggaloid.Event[:c].call eval_all_events(@pluggaloid.Delayer) end it 'should not call event in tag' do assert_equal [:a], @lst end end describe 'detach tag_c' do before do @pluggaloid.Event[:a].call @pluggaloid.Event[:b].call @pluggaloid.Event[:c].call @pluggaloid.Event[:d].call end describe 'detach' do before do @plugin.detach(@tag_c) eval_all_events(@pluggaloid.Delayer) end it 'should not call filter' do assert_equal [:a, :b, :c, :d], @lst end end describe 'does not detach' do before do eval_all_events(@pluggaloid.Delayer) end it 'should call filter' do assert_equal [:a, :b, :c], @lst end end end describe 'each' do it 'should count of listeners and filters are 2' do assert_equal 2, @tag_a.count end it 'should count of listeners are 2 in tag_a' do assert_equal 2, @tag_a.listeners.count end it 'should there are no filter in tag_a' do assert_equal 0, @tag_a.filters.count end it 'should count of listeners are 2 in tag_b' do assert_equal 2, @tag_b.listeners.count end it 'should there are no filter in tag_b' do assert_equal 0, @tag_b.filters.count end it 'should there are no listener in tag_c' do assert_equal 0, @tag_c.listeners.count end it 'should has one filter in tag_c' do assert_equal 1, @tag_c.filters.count end end end end pluggaloid-1.1.1/.gitignore0000644000004100000410000000017512706311701015662 0ustar www-datawww-data/.bundle/ /.yardoc /Gemfile.lock /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ *.bundle *.so *.o *.a mkmf.log vendor/pluggaloid-1.1.1/pluggaloid.gemspec0000644000004100000410000000205012706311701017360 0ustar www-datawww-data# 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.required_ruby_version = '>= 2.1.0' 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 pluggaloid-1.1.1/README.md0000644000004100000410000000362412706311701015153 0ustar www-datawww-data# 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, 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, 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