yuuki 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f43903b0871e192e128847cf0e772066dec93cfa0b882afb9ac53bb0dfbf3ca
-  data.tar.gz: 1114888a7eb4a790792556ab6aa03b9ace4da9a15bd56201f8fdf98cf855df30
+  metadata.gz: 49851d0c15f259e4c54568ff173a45b9ae9316e25c4120fd3d12926f2560fcfb
+  data.tar.gz: f17a0f2ec8d4de59becb43c9f6e4de08de3b38534583250f1899da127576188c
 SHA512:
-  metadata.gz: 742ddbe4914aa114d780a8a5bdd6285ba04c6ca651fa23d62c995741b155a935c58742240eb51114f43c6ab82347ea1d457a92f40b63ae87324fbf81ae8073a7
-  data.tar.gz: 6ae20a7613818d726fd3442a7057354355106656a42c45c9f8c8dcf1dd1eb8172905307f35b9559e7e15c4e3c0b4f60cfad74017ccd254edff93dabf8fab485f
+  metadata.gz: a2ef440f3446c5d737abfa611f81731b06905189013c3220560a00a9f0e23d6422180a699934a9161711390a49d2e5bbf61f5178bd4316c6c1bcc2e1bad33889
+  data.tar.gz: 895d9874e7455840667ea75a90bb02c669d5b384a88b0412ee3bd4be58082465489317b483d2b8e28de81d6d2224f5819bb6af5b34fb1bb9a907b1db053e4164

data/.gitignore

@@ -6,5 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
-/test/
 Gemfile.lock

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in yuuki.gemspec

data/README.md

@@ -20,7 +20,32 @@ Or install it yourself as:
 
 ## Usage
 
-あとで書く。
+```ruby
+require 'yuuki'
+
+class HogeClass
+  extend Yuuki::Runner
+
+  add :a
+  def a
+    puts 'a'
+  end
+
+  add :b
+  tag :b, :tag_b
+  def b
+    puts 'b'
+  end
+end
+
+yuuki = Yuuki::Caller.new(HogeClass)
+yuuki.run
+# a
+# b
+
+yuuki.run_tag(:tag_b)
+# b
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,12 @@
-require "bundler/gem_tasks"
-task :default => :spec
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: %i[test]

data/lib/yuuki/caller.rb

@@ -1,135 +1,173 @@
+# frozen_string_literal: true
+
+require 'set'
 require 'yuuki/runner'
 
 module Yuuki
-    class Caller
-        Runner = Struct.new(:method, :tags, :exclude, :threading, :priority)
-
-        def self.require_dir(dir, recursive = false)
-            Dir.glob(recursive ? "#{require_dir}/**/*.rb" : "#{require_dir}/*.rb"){|file| require file}
-        end
-
-        def initialize(*klass)
-            @runners = []
-            @threads = []
-            add(*klass)
-        end
-
-        def add(*klass)
-            klass.each do |klass|
-                instance = klass.new
-                instance.instance_variable_set(:@caller, self)
-                info = klass.instance_variable_get(:@runner_info) || {}
-                methods = klass.public_instance_methods(false)
-                methods |= klass.instance_variable_get(:@runner_adds) || []
-                methods -= klass.instance_variable_get(:@runner_excepts) || []
-                @runners += methods.map do |method|
-                    tags = info.dig(method, :tags) || []
-                    exclude = !!info.dig(method, :exclude)
-                    threading = !!info.dig(method, :threading)
-                    priority = info.dig(method, :priority) || 0
-                    Runner.new(instance.method(method), tags, exclude, threading, priority)
-                end
-            end
-            @runners.sort_by!{|e| -e.priority}
-        end
-
-        def run(**args)
-            run_internal(@runners.reject(&:exclude), args)
-        end
+  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
 
-        def run_all(**args)
-            run_internal(@runners, args)
-        end
+    # @param [Object] instances
+    def initialize(*instances)
+      @instances = Set.new
+      @threads = []
+      add(*instances)
+    end
 
-        def run_class(*klass, **args)
-            run_internal(@runners.select{|e| !e.exclude && klass.any?{|k| e.method.receiver.instance_of?(k)}}, args)
+    # 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
+          # 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
+          # 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
 
-        def run_class_all(*klass, **args)
-            run_internal(@runners.select{|e| klass.any?{|k| e.method.receiver.instance_of?(k)}}, args)
-        end
+        # regist
+        @instances << instance
+      end
+    end
 
-        def run_tag(*tags, **args)
-            run_internal(@runners.select{|e| tags.any?{|t| e.tags.any?(t)}}, args)
-        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
 
-        def run_select(**args)
-            run_internal(@runners.select{|e| yield(e)}, args)
-        end
+    # runs all methods
+    # @param [Object] args arguments
+    def run(**args, &block)
+      run_internal(runners, args, &block)
+    end
 
-        def run_method(klass, method, **args)
-            runners = klass ? @runners.select{|e| e.method.receiver.class == klass} : @runners
-            runners.select!{|e| e.method.name == method} if method
-            run_internal(runners, args)
-        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
 
-        def join
-            @threads.each(&:join)
-        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
 
-        def alive?
-            @threads.any?(&:alive?)
-        end
-        alias running? alive?
+    # 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
 
-        private
+    # joins all runnning threads
+    def join
+      @threads.each(&:join)
+      @threads.select!(&:alive?)
+    end
 
-        def run_internal(runners, args)
-            runners.each do |runner|
-                if runner.threading
-                    @threads << Thread.new(runner.method, args) do |method, args|
-                        run_method_internal(method, args)
-                    end
-                else
-                    run_method_internal(runner.method, args)
-                end
-            end
-            @threads.select!(&:alive?)
+    # returns whether any thread is alive
+    # @return [Boolean]
+    def alive?
+      @threads.select!(&:alive?)
+      !@threads.empty?
+    end
+    alias running? alive?
+
+    private
+
+    def run_internal(runners, args, &block)
+      @threads.select!(&:alive?)
+      runners.each do |method, meta|
+        if meta[:thread]
+          thread = Thread.new(method, args, block) do |thread_method, thread_args, thread_block|
+            run_method_internal(thread_method, thread_args, &thread_block)
+          end
+          thread.priority = meta[:priority] || 0
+          @threads << thread
+        else
+          run_method_internal(method, args, &block)
         end
+      end
+    end
 
-        def run_method_internal(method, args)
-            params = method.parameters
-            return method[] if params.size == 0
-            params_array = []
-            params_hash = {}
-            params_block = nil
-            nonspecified_last_opt = nil
-            params.each do |type, name|
-                case type
-                when :req
-                    raise Yuuki::Error.new("A required argument '#{name}' was not found on running #{method.owner}::#{method.name}") unless args.key?(name)
-                    params_array << args[name]
-                when :opt
-                    next nonspecified_last_opt = name unless args.key?(name)
-                    raise Yuuki::Error.new("A required argument '#{nonspecified_last_opt}' was not found"\
-                        " on running #{method.owner}::#{method.name}"" with optional argument '#{name}'") if nonspecified_last_opt
-                    params_array << args[name]
-                when :rest
-                    next unless args.key?(name)
-                    raise Yuuki::Error.new("A required argument '#{nonspecified_last_opt}' not found"\
-                        " on running #{method.owner}::#{method.name}"" with rest argument '#{name}'") if nonspecified_last_opt
-                    if args[name].respond_to?(:to_ary)
-                        params_array += args[name]
-                    else
-                        params_array << args[name]
-                    end
-                when :keyreq
-                    raise Yuuki::Error.new("A required key argument '#{name}' was not found on running #{method.owner}::#{method.name}") unless args.key?(name)
-                    params_hash[name] = args[name]
-                when :key
-                    params_hash[name] = args[name] if args.key?(name)
-                when :keyrest
-                    next unless args.key?(name)
-                    if args[name].respond_to?(:to_hash)
-                        params_hash.merge!(args[name])
-                    else
-                        params_hash[name] = args[name]
-                    end
-                when :block
-                    params_block = args[name]
-                end
-            end
-            params_hash.empty? ? method[*params_array, &params_block] : method[*params_array, **params_hash, &params_block]
+    def run_method_internal(method, args, &block)
+      params = method.parameters
+      return method[] if params.empty?
+      params_array = []
+      params_hash = {}
+      params_block = nil
+      nonspecified_last_opt = nil
+      params.each do |type, name|
+        case type
+        when :req
+          raise Yuuki::Error, "A required argument '#{name}' was not found on running #{method.owner}::#{method.name}" unless args.key?(name)
+          params_array << args[name]
+        when :opt
+          # if parameters do not contain the :opt argument, treat it as not specified
+          next nonspecified_last_opt = name unless args.key?(name)
+          if nonspecified_last_opt
+            # if there already exist non-specified :opt arguments, no more specified :opt argument is allowed
+            raise Yuuki::Error, "A required argument '#{nonspecified_last_opt}' was not found"\
+                    " on running #{method.owner}::#{method.name}"" with optional argument '#{name}'"
+          end
+          params_array << args[name]
+        when :rest
+          next unless args.key?(name)
+          if nonspecified_last_opt
+            # if there already exist non-specified :opt arguments, the :rest argument cannot be handled
+            raise Yuuki::Error, "A required argument '#{nonspecified_last_opt}' not found"\
+                    " on running #{method.owner}::#{method.name}"" with rest argument '#{name}'"
+          end
+          if args[name].respond_to?(:to_ary)
+            params_array += args[name]
+          else
+            params_array << args[name]
+          end
+        when :keyreq
+          raise Yuuki::Error, "A required key argument '#{name}' was not found on running #{method.owner}::#{method.name}" unless args.key?(name)
+          params_hash[name] = args[name]
+        when :key
+          params_hash[name] = args[name] if args.key?(name)
+        when :keyrest
+          next unless args.key?(name)
+          if args[name].respond_to?(:to_hash)
+            params_hash.merge!(args[name])
+          else
+            params_hash[name] = args[name]
+          end
+        when :block
+          params_block = args[name]
         end
+      end
+      params_block = block unless params.any?{|type, _| type == :block}
+      params_hash.empty? ? method[*params_array, &params_block] : method[*params_array, **params_hash, &params_block]
     end
+  end
 end

data/lib/yuuki/error.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module Yuuki
-    class Error < StandardError
-    end
+  class Error < StandardError
+  end
 end

data/lib/yuuki/periodic.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'yuuki/caller'
+require 'yuuki/runner'
+
+module Yuuki
+  module Runner
+    # sets interval to the method
+    # @param [Symbol] methods method names
+    # @param [Integer] interval
+    def periodic(*methods, interval)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:periodic] = interval
+      end
+    end
+
+    # sets whether the method run at the first time
+    # @param [Symbol] methods method names
+    # @param [Boolean] enabled
+    def first_run(*methods, enabled: true)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:first_run] = enabled
+      end
+    end
+  end
+end
+
+module Yuuki
+  # @attr_reader [Boolean] first_run
+  # @attr_reader [Float] current_time
+  class PeriodicCaller < Caller
+    attr_reader :first_run, :current_time
+
+    def initialize(*instances)
+      super
+      @first_run = true
+    end
+
+    # sets error callback
+    # @yield [error]
+    # @yieldparam [Exception] error
+    def on_error(&block)
+      @on_error = block
+    end
+
+    # runs the periodic caller
+    # @param [Numeric] gmtoff GMT Offset
+    # @param [Object] args arguments
+    def run(gmtoff = Time.now.gmtoff, **args, &block)
+      last_time = nil
+      loop do
+        @current_time = Time.now.to_f
+        begin
+          select_proc = proc do |_method, meta|
+            next true if @first_run && meta[:first_run]
+            next false unless meta[:periodic]
+            next false unless last_time
+            c = @current_time + gmtoff
+            l = last_time + gmtoff
+            next true if (l.div(meta[:periodic]) + 1) * meta[:periodic] <= c
+          end
+          run_select(select_proc, **args, &block)
+        rescue
+          @on_error ? @on_error[$!] : raise
+        end
+        @first_run = false
+
+        last_time = @current_time
+        ((@current_time + 1).floor - Time.now.to_f).tap{|e| sleep e if e > 0}
+      end
+    end
+  end
+end

data/lib/yuuki/runner.rb

@@ -1,48 +1,59 @@
-require 'yuuki/error'
+# frozen_string_literal: true
 
-module Yuuki
-    class RunnerBase
-        class << self
-            private
-
-            def add(*methods)
-                @runner_adds ||= []
-                @runner_adds |= methods
-            end
+require 'set'
 
-            def delete(*methods)
-                @runner_excepts ||= []
-                @runner_excepts |= methods
-            end
+module Yuuki
+  module Runner
+    # adds methods to yuuki
+    # @param [Symbol] methods method names
+    def add(*methods)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:enabled] = true
+      end
+    end
 
-            def tag(method, *tags)
-                @runner_info ||= {}
-                @runner_info[method] ||= {}
-                @runner_info[method][:tags] ||= []
-                @runner_info[method][:tags] |= tags
-            end
+    # deletes methods from yuuki
+    # @param [Symbol] methods method names
+    def delete(*methods)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:enabled] = false
+      end
+    end
 
-            def exclude(*methods)
-                @runner_info ||= {}
-                methods.each do |method|
-                    @runner_info[method] ||= {}
-                    @runner_info[method][:exclude] = true
-                end
-            end
+    # adds tags to the method
+    # @param [Symbol] method method name
+    # @param [Symbol] tags tag names
+    def tag(method, *tags)
+      @yuuki_methods ||= {}
+      @yuuki_methods[method] ||= {}
+      @yuuki_methods[method][:tags] ||= Set.new
+      @yuuki_methods[method][:tags].merge(tags)
+    end
 
-            def threading(*methods)
-                @runner_info ||= {}
-                methods.each do |method|
-                    @runner_info[method] ||= {}
-                    @runner_info[method][:threading] = true
-                end
-            end
+    # enables threading for the methods
+    # @param [Symbol] methods method names
+    # @param [Boolean] enabled
+    def thread(*methods, enabled: true)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:thread] = enabled
+      end
+    end
 
-            def priority(method, priority)
-                @runner_info ||= {}
-                @runner_info[method] ||= {}
-                @runner_info[method][:priority] = priority
-            end
-        end
+    # sets priority to the method
+    # @param [Symbol] methods method names
+    # @param [Numeric] priority
+    def priority(*methods, priority)
+      @yuuki_methods ||= {}
+      methods.each do |method|
+        @yuuki_methods[method] ||= {}
+        @yuuki_methods[method][:priority] = priority
+      end
     end
+  end
 end

data/lib/yuuki/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Yuuki
-    VERSION = '0.1.0'
+  VERSION = '0.1.3'
 end

data/lib/yuuki.rb

@@ -1,4 +1,6 @@
-require 'yuuki/runner'
+# frozen_string_literal: true
+
 require 'yuuki/caller'
 require 'yuuki/error'
+require 'yuuki/runner'
 require 'yuuki/version'

data/sig/yuuki/caller.rbs

@@ -0,0 +1,25 @@
+# TypeProf 0.21.2
+
+# Classes
+module Yuuki
+  class Caller
+    @instances: Set[untyped]
+    @threads: Array[Thread]
+
+    def self.require_dir: (String require_dir, ?recursive: bool) -> void
+    def initialize: (*untyped instances) -> void
+    def add: (*untyped instances) -> void
+    def runners: -> Array[untyped]
+    def run: (**untyped) -> void
+    def run_select: (^(Method, Hash[Symbol, untyped]) -> bool proc_select, **untyped) -> void
+    def run_tag: (*Symbol tags, **untyped) -> void
+    def run_method: (Class klass, Symbol method_sig, **untyped) -> void
+    def join: -> void
+    def alive?: -> bool
+    alias running? alive?
+
+    private
+    def run_internal: (Array[untyped] runners, Hash[Symbol, untyped] args) -> void
+    def run_method_internal: (Method method, Hash[Symbol, untyped] args) -> void
+  end
+end

data/sig/yuuki/error.rbs

@@ -0,0 +1,7 @@
+# TypeProf 0.21.2
+
+# Classes
+module Yuuki
+  class Error < StandardError
+  end
+end

data/sig/yuuki/periodic.rbs

@@ -0,0 +1,19 @@
+# TypeProf 0.21.2
+
+# Classes
+module Yuuki
+  module Runner
+    def periodic: (Symbol method, Integer interval) -> void
+    def first_run: (Symbol method, ?enabled: bool) -> void
+  end
+
+  class PeriodicCaller < Caller
+    @on_error: Proc
+
+    attr_reader first_run: bool
+    attr_reader current_time: Float
+    def initialize: (*untyped instances) -> void
+    def on_error: {(Exception) -> void} -> void
+    def run: (?Integer gmtoff, **untyped) -> void
+  end
+end

data/sig/yuuki/runner.rbs

@@ -0,0 +1,14 @@
+# TypeProf 0.21.2
+
+# Classes
+module Yuuki
+  module Runner
+    @yuuki_methods: Hash[Symbol, Hash[Symbol, untyped]]
+
+    def add: (*Symbol methods) -> void
+    def delete: (*Symbol methods) -> void
+    def tag: (Symbol method, *Symbol tags) -> void
+    def thread: (*Symbol methods, ?enabled: bool) -> void
+    def priority: (*Symbol methods, Numeric priority) -> void
+  end
+end

data/sig/yuuki/version.rbs

@@ -0,0 +1,6 @@
+# TypeProf 0.21.2
+
+# Classes
+module Yuuki
+  VERSION: String
+end

data/yuuki.gemspec

@@ -1,28 +1,30 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$:.unshift(lib) unless $:.include?(lib)
 require 'yuuki/version'
 
 Gem::Specification.new do |spec|
-    spec.name          = 'yuuki'
-    spec.version       = Yuuki::VERSION
-    spec.authors       = ['Ishotihadus']
-    spec.email         = ['hanachan.pao@gmail.com']
+  spec.name = 'yuuki'
+  spec.version       = Yuuki::VERSION
+  spec.authors       = ['Ishotihadus']
+  spec.email         = ['hanachan.pao@gmail.com']
 
-    spec.summary       = 'A caller / runner framework for Ruby'
-    spec.description   = 'A caller / runner framework for Ruby.'
-    spec.homepage      = 'https://github.com/ishotihadus/yuuki'
-    spec.license       = 'MIT'
+  spec.summary       = 'A caller / runner framework for Ruby'
+  spec.description   = 'A caller / runner framework for Ruby.'
+  spec.homepage      = 'https://github.com/ishotihadus/yuuki'
+  spec.license       = 'MIT'
 
-    # Specify which files should be added to the gem when it is released.
-    # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-    spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-    end
-    spec.bindir        = 'exe'
-    spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-    spec.require_paths = ['lib']
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject{|f| f.match(%r{^(test|spec|features)/})}
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}){|f| File.basename(f)}
+  spec.require_paths = ['lib']
 
-    spec.add_development_dependency 'bundler'
-    spec.add_development_dependency 'rake'
-    spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yuuki
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Ishotihadus
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-03-16 00:00:00.000000000 Z
+date: 2022-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -59,6 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
@@ -69,14 +70,20 @@ files:
 - lib/yuuki.rb
 - lib/yuuki/caller.rb
 - lib/yuuki/error.rb
+- lib/yuuki/periodic.rb
 - lib/yuuki/runner.rb
 - lib/yuuki/version.rb
+- sig/yuuki/caller.rbs
+- sig/yuuki/error.rbs
+- sig/yuuki/periodic.rbs
+- sig/yuuki/runner.rbs
+- sig/yuuki/version.rbs
 - yuuki.gemspec
 homepage: https://github.com/ishotihadus/yuuki
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: A caller / runner framework for Ruby
 test_files: []