fiber_scheduler 0.0.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd5761664b48ce8937367c38ae5424c2aad1ffcbac56fac2c002de020f08b6fc
-  data.tar.gz: 426a54cbbd96a1b5eb54794b2a6b295be2af98413cbfb7978780ca57ff8347f7
+  metadata.gz: e6bff2da15e7d0b5295c4e97e86c55377ce126173aeeb8ef81cade98f2a3bd1b
+  data.tar.gz: aac48ee81381541a770722eb369c7d8f90415caba4f796e7c830b35cb53fd10b
 SHA512:
-  metadata.gz: 9cdf31791771ecd2fec6fee05a7849954e71a2d6596ea429ec99300a558bd8c129a8e402e7bcae6c1c093765ac9738b4944e70de26a423ae62c440f4c9d10e18
-  data.tar.gz: 4cf8d6bd02b7a51ef03e902da0bb25bbd5fae16ebf82c1b5aa7cf68d84b723b458be1b9106258fff527e17704ffba3850a0b377b735bf21c0638b62c7930d20d
+  metadata.gz: 5b83d8d5a5f1a7503de979bdd7f60025b9ada9d63d98166a61516c3da82ec6b1e1a385579acc5c05764cc0ac838671757e53ee980180c5bf38625bc2b7f157ea
+  data.tar.gz: 1c2026341f79c0d98131f04c8d51b3be410b2fef6d732e8181a2024e149f08c02bebd5a9bc8272956396dd182451395c84a36b088f811f17b7deb96eb7983830

data/lib/fiber_scheduler/compatibility.rb

@@ -0,0 +1,96 @@
+class FiberScheduler
+  module Compatibility
+    Close = Class.new(RuntimeError)
+
+    def fiber(*args, **opts, &block)
+      return super unless Compatibility.internal?
+
+      # This is `Fiber.schedule` call inside `FiberScheduler { ... }` block.
+      type = args.first
+      case type
+      when :blocking
+        Fiber.new(blocking: true) {
+          Compatibility.set_internal!
+          yield
+        }.tap(&:resume)
+
+      when :waiting
+        parent = Fiber.current
+        finished = false # prevents races
+        blocking = false # prevents #unblock-ing a fiber that never blocked
+
+        # Don't pass *args and **opts to an unknown fiber scheduler class.
+        fiber = super() do
+          Compatibility.set_internal!
+          yield
+        ensure
+          finished = true
+          unblock(nil, parent) if blocking
+        end
+
+        unless finished
+          blocking = true
+          block(nil, nil)
+        end
+
+        fiber
+
+      when :fleeting
+        # Transfer to current fiber some time after a fleeting fiber yields.
+        unblock(nil, Fiber.current)
+        # Alternative to #unblock: Fiber.scheduler.push(Fiber.current)
+
+        fiber = Fiber.new(blocking: false) do
+          Compatibility.set_internal!
+          yield
+        rescue Close
+          # Fiber scheduler is closing.
+        ensure
+          _fleeting.delete(Fiber.current)
+        end
+        _fleeting[fiber] = nil
+        fiber.tap(&:transfer)
+
+      when nil
+        # Don't pass *args and **opts to an unknown fiber scheduler class.
+        super() do
+          Compatibility.set_internal!
+          yield
+        end
+
+      else
+        raise "Unknown type"
+      end
+    end
+
+    # #close and #_fleeting handle a complexity in Async::Scheduler#close, more
+    # specifically this line:
+    # https://github.com/socketry/async/blob/456df488d801572821eaf5ec2fda10e3b9744a5f/lib/async/scheduler.rb#L55
+    def close
+      super
+    rescue
+      if _fleeting.empty?
+        Kernel.raise
+      else
+        # #dup is used because #_fleeting is modified during iteration.
+        _fleeting.dup.each do |fiber, _|
+          fiber.raise(Close)
+        end
+
+        super # retry
+      end
+    end
+
+    def _fleeting
+      @_fleeting ||= {}
+    end
+
+    def self.set_internal!
+      Thread.current[:_fiber_scheduler] = true # Sets a FIBER local var!
+    end
+
+    def self.internal?
+      Thread.current[:_fiber_scheduler]
+    end
+  end
+end

data/lib/fiber_scheduler/selector.rb

@@ -0,0 +1,230 @@
+# Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# 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.
+
+# The code in this class has been taken from io-event gem. It has been cleaned
+# up and appropriated for use in this gem.
+
+class FiberScheduler
+  class Selector
+    EAGAIN = Errno::EAGAIN::Errno
+
+    class Waiter
+      def initialize(fiber, events, tail)
+        @fiber = fiber
+        @events = events
+        @tail = tail
+      end
+
+      def alive?
+        @fiber&.alive?
+      end
+
+      def transfer(events)
+        if (fiber = @fiber)
+          @fiber = nil
+
+          fiber.transfer(events & @events) if fiber.alive?
+        end
+
+        @tail&.transfer(events)
+      end
+
+      def invalidate
+        @fiber = nil
+      end
+
+      def each(&block)
+        if (fiber = @fiber)
+          yield fiber, @events
+        end
+
+        @tail&.each(&block)
+      end
+    end
+
+    def initialize(fiber)
+      @fiber = fiber
+
+      @waiting = {}.compare_by_identity
+      @ready = []
+    end
+
+    def close
+      @fiber = nil
+      @waiting = nil
+      @ready = nil
+    end
+
+    def transfer
+      @fiber.transfer
+    end
+
+    def push(fiber)
+      @ready.push(fiber)
+    end
+
+    def io_wait(fiber, io, events)
+      waiter = @waiting[io] = Waiter.new(fiber, events, @waiting[io])
+
+      @fiber.transfer
+    ensure
+      waiter&.invalidate
+    end
+
+    def io_read(fiber, io, buffer, length)
+      offset = 0
+
+      loop do
+        maximum_size = buffer.size - offset
+
+        result = Fiber.new(blocking: true) {
+          io.read_nonblock(maximum_size, exception: false)
+        }.resume
+
+        case result
+        when :wait_readable
+          if length > 0
+            io_wait(fiber, io, IO::READABLE)
+          else
+            return -EAGAIN
+          end
+        when :wait_writable
+          if length > 0
+            io_wait(fiber, io, IO::WRITABLE)
+          else
+            return -EAGAIN
+          end
+        when nil
+          break
+        else
+          buffer.set_string(result, offset)
+
+          size = result.bytesize
+          offset += size
+          break if size >= length
+          length -= size
+        end
+      end
+
+      offset
+    end
+
+    def io_write(fiber, io, buffer, length)
+      offset = 0
+
+      loop do
+        maximum_size = buffer.size - offset
+
+        chunk = buffer.get_string(offset, maximum_size)
+        result = Fiber.new(blocking: true) {
+          io.write_nonblock(chunk, exception: false)
+        }.resume
+
+        case result
+        when :wait_readable
+          if length > 0
+            io_wait(fiber, io, IO::READABLE)
+          else
+            return -EAGAIN
+          end
+        when :wait_writable
+          if length > 0
+            io_wait(fiber, io, IO::WRITABLE)
+          else
+            return -EAGAIN
+          end
+        else
+          offset += result
+          break if result >= length
+          length -= result
+        end
+      end
+
+      offset
+    end
+
+    def process_wait(fiber, pid, flags)
+      reader, writer = IO.pipe
+
+      thread = Thread.new do
+        Process::Status.wait(pid, flags)
+      ensure
+        writer.close
+      end
+
+      io_wait(fiber, reader, IO::READABLE)
+
+      thread.value
+    ensure
+      reader.close
+      writer.close
+      thread&.kill
+    end
+
+    def select(duration = nil)
+      if @ready.any?
+        # If we have popped items from the ready list, they may influence the
+        # duration calculation, so we don't delay the event loop:
+        duration = 0
+
+        count = @ready.size
+        count.times do
+          fiber = @ready.shift
+          fiber.transfer if fiber.alive?
+        end
+      end
+
+      readable = []
+      writable = []
+
+      @waiting.each do |io, waiter|
+        waiter.each do |fiber, events|
+          if (events & IO::READABLE) > 0
+            readable << io
+          end
+
+          if (events & IO::WRITABLE) > 0
+            writable << io
+          end
+        end
+      end
+
+      duration = 0 if @ready.any?
+      readable, writable, _ = IO.select(readable, writable, nil, duration)
+
+      ready = Hash.new(0)
+
+      readable&.each do |io|
+        ready[io] |= IO::READABLE
+      end
+
+      writable&.each do |io|
+        ready[io] |= IO::WRITABLE
+      end
+
+      ready.each do |io, events|
+        waiter = @waiting.delete(io)
+        waiter.transfer(events)
+      end
+
+      ready.size
+    end
+  end
+end

data/lib/fiber_scheduler/{trigger.rb → timeout.rb}

@@ -1,12 +1,18 @@
 class FiberScheduler
-  class Trigger
+  Error = Class.new(RuntimeError)
+
+  class Timeout
     include Comparable
 
+    Error = Class.new(FiberScheduler::Error)
+
     attr_reader :time
 
-    def initialize(duration, &block)
+    def initialize(duration, fiber, method, *args)
       @time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + duration
-      @block = block
+      @fiber = fiber
+      @method = method
+      @args = args
 
       @disabled = nil
     end
@@ -18,7 +24,9 @@ class FiberScheduler
     end
 
     def call
-      @block.call
+      return unless @fiber.alive?
+
+      @fiber.public_send(@method, *@args)
     end
 
     def interval

data/lib/fiber_scheduler/timeouts.rb

@@ -0,0 +1,79 @@
+require_relative "timeout"
+
+class FiberScheduler
+  class Timeouts
+    attr_reader :timeouts
+
+    def initialize
+      # Array is sorted by Timeout#time
+      @timeouts = []
+    end
+
+    def call
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      while @timeouts.any? && @timeouts.first.time <= now
+        timeout = @timeouts.shift
+        unless timeout.disabled?
+          timeout.call
+        end
+      end
+    end
+
+    def timeout(duration, *args, method: :raise, fiber: Fiber.current, &block)
+      timeout = Timeout.new(duration, fiber, method, *args)
+
+      if @timeouts.empty?
+        @timeouts << timeout
+      else
+        # binary search
+        min = 0
+        max = @timeouts.size - 1
+        while min <= max
+          index = (min + max) / 2
+          t = @timeouts[index]
+
+          if t > timeout
+            if index.zero? || @timeouts[index - 1] <= timeout
+              # found it
+              break
+            else
+              # @timeouts[index - 1] > timeout
+              max = index - 1
+            end
+          else
+            # t <= timeout
+            index += 1
+            min = index
+          end
+        end
+
+        @timeouts.insert(index, timeout)
+      end
+
+      begin
+        block.call
+      ensure
+        # Timeout is disabled if the block finishes earlier.
+        timeout.disable
+      end
+    end
+
+    def interval
+      # Prune disabled timeouts
+      while @timeouts.first&.disabled?
+        @timeouts.shift
+      end
+
+      return if @timeouts.empty?
+
+      interval = @timeouts.first.interval
+
+      interval >= 0 ? interval : 0
+    end
+
+    def inspect
+      @timeouts.inspect
+    end
+  end
+end

data/lib/fiber_scheduler/version.rb

@@ -1,3 +1,3 @@
 class FiberScheduler
-  VERSION = "0.0.1".freeze
+  VERSION = "0.12.0".freeze
 end

data/lib/fiber_scheduler.rb

@@ -1,33 +1,111 @@
-require "io/event"
 require "resolv"
-require_relative "fiber_scheduler/triggers"
+require_relative "fiber_scheduler/compatibility"
+require_relative "fiber_scheduler/selector"
+require_relative "fiber_scheduler/timeouts"
+
+begin
+  # Use io/event selector if available
+  require "io/event"
+rescue LoadError
+end
 
 module Kernel
-  def FiberScheduler(&block)
+  def FiberScheduler(type = nil, &block)
     if Fiber.scheduler.nil?
-      scheduler = FiberScheduler.new
-      Fiber.set_scheduler(scheduler)
+      Fiber.set_scheduler(FiberScheduler.new)
 
       begin
         yield
-        scheduler.close
       ensure
         Fiber.set_scheduler(nil)
       end
+
     else
-      # Fiber.scheduler already set, just schedule a task.
-      Fiber.schedule(&block)
+      scheduler = Fiber.scheduler
+      # Fiber.scheduler already set, just schedule a fiber.
+      if scheduler.is_a?(FiberScheduler)
+        # The default waiting is 'true' as that is the most intuitive behavior
+        # for a nested FiberScheduler call.
+        Fiber.schedule(type, &block)
+
+        # Unknown fiber scheduler class; can't just pass options to
+        # Fiber.schedule, handle each option separately.
+      else
+        scheduler.singleton_class.prepend(FiberScheduler::Compatibility)
+
+        case type
+        when :blocking
+          fiber = Fiber.new(blocking: true) do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          end
+          fiber.tap(&:resume)
+
+        when :waiting
+          parent = Fiber.current
+          finished = false # prevents races
+          blocking = false # prevents #unblock-ing a fiber that never blocked
+
+          fiber = Fiber.schedule do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          ensure
+            finished = true
+            scheduler.unblock(nil, parent) if blocking
+          end
+
+          if Fiber.blocking?
+            # In a blocking fiber, which is potentially also a loop fiber so
+            # there's nothing we can transfer to. Run other fibers (or just
+            # block) until waiting fiber finishes.
+            until finished
+              scheduler.run_once
+            end
+          elsif !finished
+            blocking = true
+            scheduler.block(nil, nil)
+          end
+
+          fiber
+
+        when :fleeting
+          scheduler.unblock(nil, Fiber.current)
+
+          fiber = Fiber.new(blocking: false) do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          rescue FiberScheduler::Compatibility::Close
+            # Fiber scheduler is closing.
+          ensure
+            scheduler._fleeting.delete(Fiber.current)
+          end
+          scheduler._fleeting[fiber] = nil
+          fiber.tap(&:transfer)
+
+        when nil
+          Fiber.schedule do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          end
+
+        else
+          raise "Unknown type"
+        end
+      end
     end
   end
 end
 
 class FiberScheduler
-  TimeoutError = Class.new(RuntimeError)
-  IOWaitTimeout = Class.new(TimeoutError)
-
   def initialize
-    @selector = IO::Event::Selector.new(Fiber.current)
-    @triggers = Triggers.new
+    @fiber = Fiber.current
+    @selector =
+      if defined?(IO::Event)
+        IO::Event::Selector.new(@fiber)
+      else
+        Selector.new(@fiber)
+      end
+    @timeouts = Timeouts.new
 
     @count = 0
     @nested = []
@@ -35,14 +113,18 @@ class FiberScheduler
 
   def run
     while @count > 0
-      if @nested.empty?
-        @selector.select(@triggers.interval)
-        @triggers.call
-      else
-        while @nested.any?
-          fiber = @nested.pop
-          fiber.transfer
-        end
+      run_once
+    end
+  end
+
+  def run_once
+    if @nested.empty?
+      @selector.select(@timeouts.interval)
+      @timeouts.call
+    else
+      while @nested.any?
+        fiber = @nested.pop
+        fiber.transfer
       end
     end
   end
@@ -60,18 +142,11 @@ class FiberScheduler
     end
   end
 
-  def block(blocker, timeout)
-    return @selector.transfer unless timeout
-
-    fiber = Fiber.current
-    trigger = @triggers.add(timeout) do
-      fiber.transfer if fiber.alive?
-    end
+  def block(blocker, duration = nil)
+    return @selector.transfer unless duration
 
-    begin
+    @timeouts.timeout(duration, method: :transfer) do
       @selector.transfer
-    ensure
-      trigger.disable
     end
   end
 
@@ -89,21 +164,11 @@ class FiberScheduler
     Resolv.getaddresses(hostname)
   end
 
-  def io_wait(io, events, timeout = nil)
-    fiber = Fiber.current
-    return @selector.io_wait(fiber, io, events) unless timeout
-
-    trigger = @triggers.raise_in(timeout, IOWaitTimeout)
-    # trigger = @triggers.add(timeout) do
-    #   fiber.raise(IOWaitTimeout) if fiber.alive?
-    # end
+  def io_wait(io, events, duration = nil)
+    return @selector.io_wait(Fiber.current, io, events) unless duration
 
-    begin
-      @selector.io_wait(fiber, io, events)
-    rescue IOWaitTimeout
-      false
-    ensure
-      trigger.disable
+    @timeouts.timeout(duration, method: :transfer) do
+      @selector.io_wait(Fiber.current, io, events)
     end
   end
 
@@ -119,32 +184,67 @@ class FiberScheduler
     @selector.process_wait(Fiber.current, pid, flags)
   end
 
-  def timeout_after(duration, exception = TimeoutError, message = "timeout")
-    fiber = Fiber.current
-    trigger = @triggers.add(duration) do
-      fiber.raise(exception, message) if fiber.alive?
-    end
-
-    begin
-      yield duration
-    ensure
-      trigger.disable
-    end
+  def timeout_after(duration, exception = Timeout::Error, message = "timeout", &block)
+    @timeouts.timeout(duration, exception, message, &block)
   end
 
-  def fiber(&block)
-    unless Fiber.blocking?
-      # nested Fiber.schedule
-      @nested << Fiber.current
-    end
+  def fiber(type = nil, &block)
+    current = Fiber.current
 
-    fiber = Fiber.new(blocking: false) do
-      @count += 1
-      block.call
-    ensure
-      @count -= 1
-    end
+    case type
+    when :blocking
+      Fiber.new(blocking: true, &block).tap(&:resume)
+
+    when :waiting
+      finished = false # prevents races
+      fiber = Fiber.new(blocking: false) do
+        @count += 1
+        block.call
+      ensure
+        @count -= 1
+        finished = true
+        # Resume waiting parent fiber
+        current.transfer
+      end
+      fiber.transfer
+
+      # Current fiber is waiting until waiting fiber finishes.
+      if current == @fiber
+        # In a top-level fiber, there's nothing we can transfer to, so run
+        # other fibers (or just block) until waiting fiber finishes.
+        until finished
+          run_once
+        end
+      elsif !finished
+        @selector.transfer
+      end
 
-    fiber.tap(&:transfer)
+      fiber
+
+    when :fleeting
+      if current != @fiber
+        # nested Fiber.schedule
+        @nested << current
+      end
+
+      Fiber.new(blocking: false, &block).tap(&:transfer)
+
+    when nil
+      if current != @fiber
+        # nested Fiber.schedule
+        @nested << current
+      end
+
+      fiber = Fiber.new(blocking: false) do
+        @count += 1
+        block.call
+      ensure
+        @count -= 1
+      end
+      fiber.tap(&:transfer)
+
+    else
+      raise "Unknown type"
+    end
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: fiber_scheduler
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Bruno Sutic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2022-02-16 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: io-event
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: fiber_scheduler_spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.11'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.11'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '3.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '3.11'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -86,10 +72,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/fiber/scheduler.rb
 - lib/fiber_scheduler.rb
-- lib/fiber_scheduler/trigger.rb
-- lib/fiber_scheduler/triggers.rb
+- lib/fiber_scheduler/compatibility.rb
+- lib/fiber_scheduler/selector.rb
+- lib/fiber_scheduler/timeout.rb
+- lib/fiber_scheduler/timeouts.rb
 - lib/fiber_scheduler/version.rb
 homepage: https://github.com/bruno-/fiber_scheduler
 licenses:

data/lib/fiber/scheduler.rb

@@ -1 +0,0 @@
-require_relative "../fiber_scheduler"

data/lib/fiber_scheduler/triggers.rb

@@ -1,72 +0,0 @@
-require_relative "trigger"
-
-class FiberScheduler
-  class Triggers
-    def initialize
-      # Array is sorted by Trigger#time
-      @triggers = []
-    end
-
-    def call
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      while @triggers.any? && @triggers.first.time <= now
-        trigger = @triggers.shift
-        unless trigger.disabled?
-          trigger.call
-        end
-      end
-    end
-
-    def add(duration, &block)
-      trigger = Trigger.new(duration, &block)
-
-      if @triggers.empty?
-        @triggers << trigger
-        return trigger
-      end
-
-      # binary search
-      min = 0
-      max = @triggers.size - 1
-      while min <= max
-        index = (min + max) / 2
-        t = @triggers[index]
-
-        if t > trigger
-          if index.zero? || @triggers[index - 1] <= trigger
-            # found it
-            break
-          else
-            # @triggers[index - 1] > trigger
-            max = index - 1
-          end
-        else
-          # t <= trigger
-          index += 1
-          min = index
-        end
-      end
-
-      @triggers.insert(index, trigger)
-      trigger
-    end
-
-    def interval
-      # Prune disabled triggers
-      while @triggers.first&.disabled?
-        @triggers.shift
-      end
-
-      return if @triggers.empty?
-
-      interval = @triggers.first.interval
-
-      interval >= 0 ? interval : 0
-    end
-
-    def inspect
-      @triggers.inspect
-    end
-  end
-end