pluggaloid-1.0.2/0000755000175000017500000000000012615377022011722 5ustar daidaipluggaloid-1.0.2/metadata.yml0000644000175000017500000000622512615377022014232 0ustar daidai--- !ruby/object:Gem::Specification name: pluggaloid version: !ruby/object:Gem::Version version: 1.0.2 platform: ruby authors: - Toshiaki Asai autorequire: bindir: bin cert_chain: [] date: 2015-10-25 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.1 signing_key: specification_version: 4 summary: Extensible plugin system test_files: - test/multi_vm_test.rb - test/plugin_test.rb pluggaloid-1.0.2/test/0000755000175000017500000000000012615377022012701 5ustar daidaipluggaloid-1.0.2/test/plugin_test.rb0000644000175000017500000001067412615377022015573 0ustar daidai# -*- coding: utf-8 -*- require 'bundler/setup' require 'minitest/autorun' require 'pluggaloid' describe(Pluggaloid::Plugin) do before do Delayer.default = Delayer.generate_class(priority: %i, 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 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 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 pluggaloid-1.0.2/test/multi_vm_test.rb0000644000175000017500000000375312615377022016131 0ustar daidai# -*- coding: utf-8 -*- require 'bundler/setup' require 'minitest/autorun' require 'pluggaloid' describe(Pluggaloid) do before do Delayer.default = Delayer.generate_class(priority: %i, 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, 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.0.2/pluggaloid.gemspec0000644000175000017500000000177512615377022015430 0ustar daidai# 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 pluggaloid-1.0.2/lib/0000755000175000017500000000000012615377022012470 5ustar daidaipluggaloid-1.0.2/lib/pluggaloid/0000755000175000017500000000000012615377022014617 5ustar daidaipluggaloid-1.0.2/lib/pluggaloid/version.rb0000644000175000017500000000005212615377022016626 0ustar daidaimodule Pluggaloid VERSION = "1.0.2" end pluggaloid-1.0.2/lib/pluggaloid/plugin.rb0000644000175000017500000001335012615377022016444 0ustar daidai# -*- coding: utf-8 -*- require 'instance_storage' require 'delayer' 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) 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 pluggaloid-1.0.2/lib/pluggaloid/listener.rb0000644000175000017500000000147212615377022016775 0ustar daidai# -*- 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 pluggaloid-1.0.2/lib/pluggaloid/filter.rb0000644000175000017500000000245212615377022016434 0ustar daidai# -*- 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 pluggaloid-1.0.2/lib/pluggaloid/event.rb0000644000175000017500000000601212615377022016264 0ustar daidai# -*- 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 pluggaloid-1.0.2/lib/pluggaloid/error.rb0000644000175000017500000000034512615377022016277 0ustar daidai# -*- 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 pluggaloid-1.0.2/lib/pluggaloid.rb0000644000175000017500000000077112615377022015151 0ustar daidairequire "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) 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 pluggaloid-1.0.2/Rakefile0000644000175000017500000000025612615377022013372 0ustar daidairequire "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.0.2/README.md0000644000175000017500000000362412615377022013206 0ustar daidai# 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 pluggaloid-1.0.2/LICENSE.txt0000644000175000017500000000205612615377022013550 0ustar daidaiCopyright (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.0.2/Gemfile0000644000175000017500000000013712615377022013216 0ustar daidaisource 'https://rubygems.org' # Specify your gem's dependencies in pluggaloid.gemspec gemspec pluggaloid-1.0.2/.gitignore0000644000175000017500000000017512615377022013715 0ustar daidai/.bundle/ /.yardoc /Gemfile.lock /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ *.bundle *.so *.o *.a mkmf.log vendor/