delayer 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e740459b8f4d9abb415778feffba4e4a80c506df2ccd393e443cd5aecf28d1d
-  data.tar.gz: 0fd9a1f1c7d3dad89a77712df97bf069d524ba7db66fc2e1158e8c6846643eee
+  metadata.gz: e7fea45fe078293c50cf946662ce8aace4acf2aa40b30abf894cedf117473b30
+  data.tar.gz: d4f0e01ce8dfce355d90022b73431d695061d6bff5fe15280d47c95b3b60f28f
 SHA512:
-  metadata.gz: efd0f011041ddc6124f86ff2cd18466e8fe52e317ed7dbe3b54210d613115db513a5d57e5566d619c836c63fc96a478567c60838750b44e2845bf3c085abb7cc
-  data.tar.gz: 1adbcf303d86d6179d4a554a6d4c09c1f5dc9006d56bcce890028c4498498268aa6a1396d2576255972f3f4f329dae8234770256098b7a8406dbde9b3a2cf9f5
+  metadata.gz: 27c1f3aca5d5e4745d341667d5ce2cdb3a032402b9fe94269017bb59535e70f6f97d00d3d4d68ddb7932d0bcb9dc13f9f3bf57a693c52fb06adc762b4d181b12
+  data.tar.gz: 8d80f9c8d5c06707d68f9df0017e6598a18212322c3065ffdf497e5ee5c427e703a83ea2c975bd8a66f6be3fd956171b109ee3ca44de71d933f98baeaebd0483

data/.circleci/config.yml

@@ -0,0 +1,40 @@
+version: '2.1'
+
+executors:
+  ruby:
+    parameters:
+      tag:
+        type: string
+    docker:
+      - image: circleci/ruby:<< parameters.tag >>
+
+jobs:
+  build:
+    parameters:
+       ruby-version:
+         type: string
+    executor:
+      name: ruby
+      tag: << parameters.ruby-version >>
+    steps:
+    - checkout
+    - run:
+        name: Which bundler?
+        command: bundle -v
+    - run:
+        command: bundle install --path vendor/bundle
+    - run:
+        name: test
+        command: bundle exec rake test
+workflows:
+  build:
+    jobs:
+      - build:
+          name: 'ruby-2.6'
+          ruby-version: '2.6.7'
+      - build:
+          name: 'ruby-2.7'
+          ruby-version: '2.7.3'
+      - build:
+          name: 'ruby-3.0'
+          ruby-version: '3.0.1'

data/README.md

@@ -1,5 +1,7 @@
 # Delayer
 
+[![toshia](https://circleci.com/gh/toshia/delayer.svg?style=svg)](https://circleci.com/gh/toshia/delayer)
+
 Delay Any task. Similar priority-queue.
 
 ## Installation

data/Steepfile

@@ -0,0 +1,19 @@
+target :lib do
+  signature "sig"
+  check "lib"                       # Directory name
+  # ignore "lib/templates/*.rb"
+  # library "pathname", "set"       # Standard libraries
+  # library "strong_json"           # Gems
+  # library "instance_storage"
+  library "monitor"
+  library "set"
+end
+
+# target :spec do
+#   signature "sig", "sig-private"
+#
+#   check "spec"
+#
+#   # library "pathname", "set"       # Standard libraries
+#   # library "rspec"
+# end

data/delayer.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Delay the processing}
   spec.homepage      = "https://github.com/toshia/delayer"
   spec.license       = "MIT"
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = '>= 2.6.0'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/lib/delayer.rb

@@ -3,6 +3,7 @@ require "delayer/version"
 require "delayer/error"
 require "delayer/extend"
 require "delayer/procedure"
+require "delayer/delayed_procedure"
 require "monitor"
 
 module Delayer
@@ -23,7 +24,7 @@ module Delayer
         include ::Delayer
         @expire = options[:expire] || 0
         if options.has_key?(:priority)
-          @priorities = options[:priority]
+          @priorities = options[:priority].to_a.freeze
           @default_priority = options[:default]
         else
           @priorities = [:normal]
@@ -32,8 +33,12 @@ module Delayer
       end
     end
 
-    def method_missing(*args, &proc)
-      (@default ||= generate_class).__send__(*args, &proc)
+    def method_missing(fn, *args, **kwrest, &proc)
+      if kwrest.empty?
+        (@default ||= generate_class).__send__(fn, *args, &proc)
+      else
+        (@default ||= generate_class).__send__(fn, *args, **kwrest, &proc)
+      end
     end
   end
 end

data/lib/delayer/delayed_procedure.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Delayer
+  class DelayedProcedure
+    include Comparable
+
+    attr_reader :state, :delayer, :reserve_at
+    def initialize(delayer, delay:, &proc)
+      @delayer = delayer
+      @proc = proc
+      case delay
+      when Time
+        @reserve_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay.to_f - Time.now.to_f
+      else
+        @reserve_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay.to_f
+      end
+      @cancel = false
+      @procedure = nil
+      @delayer.class.reserve(self)
+    end
+
+    def register
+      if !canceled?
+        @procedure = Procedure.new(@delayer, &@proc)
+      end
+      self
+    end
+
+    def <=>(other)
+      @reserve_at <=> other.reserve_at
+    end
+
+    # Cancel this job
+    # ==== Exception
+    # Delayer::TooLate :: if already called run()
+    # ==== Return
+    # self
+    def cancel
+      @procedure&.cancel
+      @cancel = true
+      self
+    end
+
+    # Return true if canceled this task
+    # ==== Return
+    # true if canceled this task
+    def canceled?
+      procedure = @procedure
+      if procedure
+        procedure.canceled?
+      else
+        @cancel
+      end
+    end
+  end
+end

data/lib/delayer/error.rb

@@ -20,6 +20,8 @@ module Delayer
       AlreadyExecutedError
     when :cancel
       AlreadyCanceledError
+    else
+      TooLate
     end
   end
 end

data/lib/delayer/extend.rb

@@ -3,10 +3,20 @@
 module Delayer
   attr_reader :priority
 
-  Bucket = Struct.new(:first, :last, :priority_of, :stashed) do
+  class Bucket
+    attr_accessor :first, :last, :priority_of, :stashed
+
+    def initialize(first, last, priority_of, stashed)
+      @first = first
+      @last = last
+      @priority_of = priority_of
+      @stashed = stashed
+    end
+
     def stash_size
-      if stashed
-        1 + stashed.stash_size
+      s = stashed
+      if s
+        1 + s.stash_size
       else
         0
       end
@@ -19,10 +29,14 @@ module Delayer
     end
   end
 
-  def initialize(priority = self.class.instance_eval { @default_priority }, *_args, &proc)
+  def initialize(priority = self.class.instance_eval { @default_priority }, *_args, delay: 0, &proc)
     self.class.validate_priority priority
     @priority = priority
-    @procedure = Procedure.new(self, &proc)
+    if delay == 0
+      @procedure = Procedure.new(self, &proc)
+    else
+      @procedure = DelayedProcedure.new(self, delay: delay, &proc)
+    end
   end
 
   # Cancel this job
@@ -46,8 +60,22 @@ module Delayer
         @remain_hook = nil
         @exception = nil
         @remain_received = false
-        @lock = Mutex.new
+        @lock = Monitor.new
         @bucket = Bucket.new(nil, nil, {}, nil)
+        @last_reserve = nil
+        @reserves = Set.new
+      end
+    end
+
+    def pop_reserve(start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC))
+      if @last_reserve&.reserve_at&.<=(start_time)
+        lock.synchronize do
+          while @last_reserve&.reserve_at&.<=(start_time)
+            @last_reserve.register
+            @last_reserve = @reserves.min
+            @reserves.delete(@last_reserve)
+          end
+        end
       end
     end
 
@@ -57,11 +85,13 @@ module Delayer
     # ==== Return
     # self
     def run(current_expire = @expire)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC).to_f
+      pop_reserve(start_time)
       if current_expire == 0
-        run_once until empty?
+        run_once_without_pop_reserve until empty?
       else
-        @end_time = Time.new.to_f + @expire
-        run_once while !empty? && (@end_time >= Time.new.to_f)
+        @end_time = end_time = start_time + @expire
+        run_once_without_pop_reserve while !empty? && (end_time >= Process.clock_gettime(Process::CLOCK_MONOTONIC))
         @end_time = nil
       end
       if @remain_hook
@@ -74,22 +104,25 @@ module Delayer
     end
 
     def expire?
-      if defined?(@end_time) && @end_time
-        @end_time < Time.new.to_f
-      else
-        false
-      end
+      !!@end_time&.<(Time.new.to_f)
     end
 
     # Run a job and forward pointer.
     # ==== Return
     # self
     def run_once
+      pop_reserve
+      run_once_without_pop_reserve
+    end
+
+    private def run_once_without_pop_reserve
       if @bucket.first
         @busy = true
         procedure = forward
-        procedure = forward while @bucket.first && procedure.canceled?
-        procedure.run unless procedure.canceled?
+        procedure = forward while @bucket.first && procedure&.canceled?
+        if procedure && !procedure.canceled?
+          procedure.run
+        end
       end
     ensure
       @busy = false
@@ -146,6 +179,29 @@ module Delayer
       self
     end
 
+    # Register reserved job.
+    # It does not execute immediately.
+    # it calls register() in _procedure.reserve_at_.
+    # ==== Args
+    # [procedure] job(Delayer::DelayedProcedure)
+    # ==== Return
+    # self
+    def reserve(procedure)
+      lock.synchronize do
+        if @last_reserve
+          if @last_reserve > procedure
+            @reserves.add(@last_reserve)
+            @last_reserve = procedure
+          else
+            @reserves.add(procedure)
+          end
+        else
+          @last_reserve = procedure
+        end
+      end
+      self
+    end
+
     def register_remain_hook(&proc)
       @remain_hook = proc
     end
@@ -154,8 +210,10 @@ module Delayer
       if @bucket.priority_of[priority]
         @bucket.priority_of[priority]
       else
-        next_index = @priorities.index(priority) - 1
-        get_prev_point @priorities[next_index] if next_index >= 0
+        @priorities.index(priority)&.yield_self do |index|
+          next_index = index - 1
+          get_prev_point @priorities[next_index] if next_index >= 0
+        end
       end
     end
 
@@ -178,10 +236,11 @@ module Delayer
     # [Delayer::NoLowerLevelError] stash_enter!が呼ばれていない時
     # [Delayer::RemainJobsError] ジョブが残っているのにこのメソッドを呼んだ時
     def stash_exit!
-      raise Delayer::NoLowerLevelError, 'stash_exit! called in level 0.' unless @bucket.stashed
+      stashed = @bucket.stashed
+      raise Delayer::NoLowerLevelError, 'stash_exit! called in level 0.' unless stashed
       raise Delayer::RemainJobsError, 'Current level has remain jobs. It must be empty current level jobs in call this method.' unless empty?
 
-      @bucket = @bucket.stashed
+      @bucket = stashed
     end
 
     # 現在のDelayer Stashレベルを返す。
@@ -194,10 +253,11 @@ module Delayer
     def forward
       lock.synchronize do
         prev = @bucket.first
-        @bucket.first = @bucket.first.next
-        @bucket.last = nil unless @bucket.first
+        raise 'Current bucket not found' unless prev
+        nex = @bucket.first = prev.next
+        @bucket.last = nil unless nex
         @bucket.priority_of.each do |priority, pointer|
-          @bucket.priority_of[priority] = @bucket.first if prev == pointer
+          @bucket.priority_of[priority] = nex if prev == pointer
         end
         prev.next = nil
         prev

data/lib/delayer/procedure.rb

@@ -23,7 +23,7 @@ module Delayer
       end
 
       @state = :run
-      @proc.call
+      @proc&.call
       @state = :done
       @proc = nil
     end

data/lib/delayer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayer
-  VERSION = '1.0.1'
+  VERSION = '1.2.0'
 end

data/sig/delayer.rbs

@@ -0,0 +1,150 @@
+# TypeProf 0.13.0
+
+# Classes
+module Delayer
+  type clock = Float | Integer | Rational
+
+  VERSION: String
+  extend Extend
+  extend Delayer
+  self.@expire: clock
+  self.@priorities: Array[Symbol]
+  self.@default_priority: Symbol
+  self.@default: singleton(Delayer)
+  @procedure: Procedure | DelayedProcedure
+  self.@busy: bool
+  self.@remain_hook: ^() -> void
+  self.@exception: Exception?
+  self.@remain_received: bool
+  self.@lock: Monitor
+  self.@bucket: Bucket
+  self.@last_reserve: nil
+  self.@reserves: untyped
+  @default_priority: Symbol
+  self.@end_time: clock?
+
+  class GeneratedDelayerAbstract
+    include ::Delayer
+  end
+
+  def self.generate_class: (?Hash[Symbol,Integer|Symbol|Enumerable[Symbol]] options) -> singleton(Delayer)
+  def self.method_missing: (Symbol, *untyped, **untyped) { (*untyped) -> untyped } -> untyped
+
+  def self.StateError: (:cancel) -> singleton(AlreadyCanceledError)
+                     | (:done) -> singleton(AlreadyExecutedError)
+                     | (:run) -> singleton(AlreadyRunningError)
+                     | (Symbol) -> singleton(TooLate)
+
+  attr_reader priority: Symbol
+  def self.included: (singleton(Delayer) klass) -> void
+  def initialize: (?untyped priority, *untyped _args, ?delay: Time | clock) -> void
+  def cancel: -> Delayer
+  def stash_size: -> (Integer)
+  def __send__: (Symbol, *untyped, **untyped) { (untyped) -> untyped } -> untyped
+
+  class DelayedProcedure
+    include Comparable
+    @proc: (^() -> void)
+    @cancel: bool
+    @procedure: Procedure?
+
+    attr_reader state: untyped
+    attr_reader delayer: Delayer
+    attr_reader reserve_at: clock
+    def initialize: (Delayer delayer, delay: Time | clock) { () -> void } -> void
+    def register: -> self
+    def <=>: (DelayedProcedure other) -> Integer?
+    def cancel: -> self
+    def canceled?: -> bool
+  end
+
+  class Error < StandardError
+  end
+
+  class TooLate < Error
+  end
+
+  class AlreadyExecutedError < TooLate
+  end
+
+  class AlreadyCanceledError < TooLate
+  end
+
+  class AlreadyRunningError < TooLate
+  end
+
+  class InvalidPriorityError < Error
+  end
+
+  class RecursiveError < Error
+  end
+
+  class NoLowerLevelError < RecursiveError
+  end
+
+  class RemainJobsError < RecursiveError
+  end
+
+  class Bucket
+    attr_accessor first(): Procedure?
+    attr_accessor last(): Procedure?
+    attr_accessor priority_of(): Hash[Symbol, Procedure?]
+    attr_accessor stashed(): Bucket?
+
+    def initialize: (Procedure?,Procedure?,Hash[Symbol, Procedure],Bucket?) -> void
+    def stash_size: () -> Integer
+  end
+
+  module Extend
+    @last_reserve: untyped
+    @lock: Monitor
+    @end_time: clock?
+    @bucket: Bucket
+    @remain_hook: ^() -> void
+    @remain_received: bool
+    @busy: bool
+    @priorities: Array[Symbol]
+    @reserves: Set[DelayedProcedure]
+
+    attr_accessor expire: clock
+    attr_reader exception: Exception?
+    def self.extended: (singleton(Delayer) klass) -> singleton(Delayer)
+    def pop_reserve: (?clock start_time) -> nil
+    def run: (?clock? current_expire) -> void
+    def expire?: -> bool
+    def run_once: -> void
+
+    private
+    def run_once_without_pop_reserve: -> void
+
+    public
+    def busy?: -> bool
+    def empty?: -> bool
+    def size: (?Delayer::Procedure? node) -> Integer
+    def register: (untyped procedure) -> Extend
+    def reserve: (untyped procedure) -> Extend
+    def register_remain_hook: () { () -> void } -> void
+    def get_prev_point: (Symbol) -> ::Delayer::Procedure?
+    def validate_priority: (Symbol) -> void
+    def stash_enter!: -> Extend
+    def stash_exit!: -> Bucket?
+    def stash_level: -> untyped
+
+    private
+    def forward: -> Procedure?
+    def lock: -> Monitor
+  end
+
+  class Procedure
+    @proc: (^() -> void)?
+
+    attr_reader state: :cancel | :done | :run | :stop
+    attr_reader delayer: untyped
+    attr_accessor next: Delayer::Procedure?
+    def initialize: (Delayer delayer) { () -> void } -> void
+    def run: -> void
+    def cancel: -> Procedure
+    def canceled?: -> bool
+    def break: (untyped node) -> untyped
+  end
+end

data/test/test_delayer.rb

@@ -353,4 +353,112 @@ class TestDelayer < Test::Unit::TestCase
     end
   end
 
+  def test_timer
+    delayer = Delayer.generate_class expire: 0.01
+    a = []
+    delayer.new(delay: 0.01) { a << 0 }
+    delayer.new { a << 1 }
+
+    delayer.run
+
+    delayer.new { a << 2 }
+    sleep 0.1
+
+    delayer.run
+
+    delayer.new { a << 3 }
+
+    delayer.run
+
+    assert_equal([1, 2, 0, 3], a)
+  end
+
+  def test_timer_give_time
+    delayer = Delayer.generate_class expire: 0.01
+    a = []
+    delayer.new(delay: Time.new) { a << 0 }
+
+    delayer.run
+
+    assert_equal([0], a)
+  end
+
+  def test_plural_timer
+    delayer = Delayer.generate_class expire: 0.01
+    a = []
+    delayer.new(delay: 0.01) { a << 0 }
+    delayer.new(delay: 0.11) { a << 1 }
+    delayer.new { a << 2 }
+
+    delayer.run
+
+    delayer.new { a << 3 }
+    sleep 0.1
+
+    delayer.run
+    sleep 0.1
+
+    delayer.new { a << 4 }
+
+    delayer.run
+
+    assert_equal([2, 3, 0, 4, 1], a)
+  end
+
+  def test_many_timer
+    delayer = Delayer.generate_class expire: 0.01
+    a = []
+    (0..10).to_a.shuffle.each do |i|
+      delayer.new(delay: i / 100.0) { a << i }
+    end
+
+    sleep 0.1
+
+    delayer.run
+
+    assert_equal((0..10).to_a, a)
+  end
+
+  def test_cancel_timer
+    delayer = Delayer.generate_class
+    a = 0
+    delayer.new(delay: 0.01) { a += 1 }
+    d = delayer.new(delay: 0.01) { a += 2 }
+    delayer.new(delay: 0.01) { a += 4 }
+
+    assert_equal(0, a)
+    d.cancel
+    sleep 0.1
+    delayer.run
+    assert_equal(5, a)
+  end
+
+  def test_cancel_timer_after_expire
+    delayer = Delayer.generate_class
+    a = 0
+    delayer.new(delay: 0.01) { a += 1 }
+    d = delayer.new(delay: 0.01) { a += 2 }
+    delayer.new{ d.cancel }
+    delayer.new(delay: 0.01) { a += 4 }
+
+    assert_equal(0, a)
+    sleep 0.1
+    delayer.run
+    assert_equal(5, a)
+  end
+
+  def test_reserve_new_timer_after_cancel
+    delayer = Delayer.generate_class
+    a = 0
+    delayer.new(delay: 0.01) { a += 1 }
+    d = delayer.new(delay: 0.02) { a += 2 }
+    d.cancel
+    delayer.new(delay: 0.03) { a += 4 }
+
+    assert_equal(0, a)
+    sleep 0.1
+    delayer.run
+    assert_equal(5, a)
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayer
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Toshiaki Asai
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-07 00:00:00.000000000 Z
+date: 2021-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,24 +65,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - delayer.gemspec
 - lib/delayer.rb
+- lib/delayer/delayed_procedure.rb
 - lib/delayer/error.rb
 - lib/delayer/extend.rb
 - lib/delayer/procedure.rb
 - lib/delayer/version.rb
+- sig/delayer.rbs
 - test/test_delayer.rb
 - test/test_priority.rb
 homepage: https://github.com/toshia/delayer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,15 +94,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.13
+signing_key:
 specification_version: 4
 summary: Delay the processing
 test_files: