lib/yuuki/caller.rb in yuuki-0.1.2 vs lib/yuuki/caller.rb in yuuki-0.1.3

@@ -3,74 +3,98 @@
 require 'set'
 require 'yuuki/runner'
 
 module Yuuki
   class Caller
+    # requires all the rb files in the given directory
+    # @param [String] require_dir directory
+    # @param [Boolean] recursive
     def self.require_dir(require_dir, recursive: false)
       Dir.glob(recursive ? "#{require_dir}/**/*.rb" : "#{require_dir}/*.rb"){|file| require file}
     end
 
+    # @param [Object] instances
     def initialize(*instances)
       @instances = Set.new
       @threads = []
       add(*instances)
     end
 
+    # adds instances to yuuki
+    # @param [Object] instances
     def add(*instances)
       instances.each do |instance|
         # create instance if class is given
         if instance.is_a?(Class)
           klass = instance
-          instance = instance.new
+          # check the klass is extended
+          raise Yuuki::Error, 'Runner instance must be extend Yuuki::Runner' unless klass.singleton_class.include?(Yuuki::Runner)
+          instance = instance.allocate
+          instance.instance_variable_set(:@yuuki, self)
+          instance.send(:initialize)
         else
-          klass = instance.class
+          # check the klass is extended
+          raise Yuuki::Error, 'Runner instance must be extend Yuuki::Runner' unless instance.class.singleton_class.include?(Yuuki::Runner)
+          # add @yuuki to the instance
+          instance.instance_variable_set(:@yuuki, self)
         end
 
-        # check the klass is extended
-        raise Yuuki::Error, 'Runner instance must be extend Yuuki::Runner' unless klass.singleton_class.include?(Yuuki::Runner)
-
-        # add @yuuki to the instance
-        instance.instance_variable_set(:@yuuki, self)
-
         # regist
         @instances << instance
       end
     end
 
+    # returns runners
+    # @return [Array<[Method, Hash<Symbol, Object>]>]
     def runners
       list = @instances.flat_map do |instance|
         methods = instance.class.instance_variable_get(:@yuuki_methods)
         methods.select{|_sig, meta| meta[:enabled]}.map{|sig, meta| [instance.method(sig), meta]}
       end
       list.sort_by{|_method, meta| -(meta[:priority] || 0)}
     end
 
+    # runs all methods
+    # @param [Object] args arguments
     def run(**args, &block)
       run_internal(runners, args, &block)
     end
 
+    # runs all selected methods
+    # @param [Proc] proc_select
+    # @param [Object] args arguments
     def run_select(proc_select, **args, &block)
       run_internal(runners.select(&proc_select), args, &block)
     end
 
+    # runs all methods with the specified tags
+    # @param [Symbol] tags
+    # @param [Object] args arguments
     def run_tag(*tags, **args, &block)
       run_select(proc{|_method, meta| meta[:tags]&.intersect?(tags)}, **args, &block)
     end
 
+    # runs the specific method
+    # @param [Class, nil] klass
+    # @param [Symbol, nil] method_sig method name
+    # @param [Object] args arguments
     def run_method(klass, method_sig, **args, &block)
       select_proc = proc do |method, _meta|
         flag_klass = klass ? method.receiver.instance_of?(klass) : true
         flag_method = method_sig ? method.name == method_sig : true
         flag_klass && flag_method
       end
       run_select(select_proc, **args, &block)
     end
 
+    # joins all runnning threads
     def join
       @threads.each(&:join)
       @threads.select!(&:alive?)
     end
 
+    # returns whether any thread is alive
+    # @return [Boolean]
     def alive?
       @threads.select!(&:alive?)
       !@threads.empty?
     end
     alias running? alive?