rubysl-monitor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0611fdd2b6a1443e13577664e38ea505b906bfab
+  data.tar.gz: fcf2eaf0f16be03c284b10166cc33c658922d93e
+SHA512:
+  metadata.gz: 942b331aab1098f3a7de9f8e3295bbec7e550507473f941861e37766ae2a699a428e25011a7aef8e51e52db7653a5d0bd9382315e1ec9e279990f8d93233e910
+  data.tar.gz: ad8e8567390e5a64d68ddeeeccad617e77a66cd540f13d33eb9a3aad4546da8d60aa2f5946bcd9b56e3c9d2fe2ec92db5185b8bb41ed1be632584123f6e226a9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+env:
+  - RUBYLIB=lib
+script: bundle exec mspec
+rvm:
+  - 1.8.7
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-monitor.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,29 @@
+# Rubysl::Monitor
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-monitor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-monitor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/monitor.rb

@@ -0,0 +1 @@
+require "rubysl/monitor"

data/lib/rubysl/monitor.rb

@@ -0,0 +1,2 @@
+require "rubysl/monitor/version"
+require "rubysl/monitor/monitor"

data/lib/rubysl/monitor/monitor.rb

@@ -0,0 +1,341 @@
+=begin
+
+= monitor.rb
+
+Copyright (C) 2001  Shugo Maeda <shugo@ruby-lang.org>
+Copyright (C) 2008  MenTaLguY <mental@rydia.net>
+
+This library is distributed under the terms of the Ruby license.
+You can freely distribute/modify this library.
+
+== example
+
+This is a simple example.
+
+  require 'monitor.rb'
+  
+  buf = []
+  buf.extend(MonitorMixin)
+  empty_cond = buf.new_cond
+  
+  # consumer
+  Thread.start do
+    loop do
+      buf.synchronize do
+        empty_cond.wait_while { buf.empty? }
+        print buf.shift
+      end
+    end
+  end
+  
+  # producer
+  while line = ARGF.gets
+    buf.synchronize do
+      buf.push(line)
+      empty_cond.signal
+    end
+  end
+
+The consumer thread waits for the producer thread to push a line
+to buf while buf.empty?, and the producer thread (main thread)
+reads a line from ARGF and push it to buf, then call
+empty_cond.signal.
+
+=end
+  
+require 'thread'
+
+#
+# Adds monitor functionality to an arbitrary object by mixing the module with
+# +include+.  For example:
+#
+#    require 'monitor.rb'
+#    
+#    buf = []
+#    buf.extend(MonitorMixin)
+#    empty_cond = buf.new_cond
+#    
+#    # consumer
+#    Thread.start do
+#      loop do
+#        buf.synchronize do
+#          empty_cond.wait_while { buf.empty? }
+#          print buf.shift
+#        end
+#      end
+#    end
+#    
+#    # producer
+#    while line = ARGF.gets
+#      buf.synchronize do
+#        buf.push(line)
+#        empty_cond.signal
+#      end
+#    end
+# 
+# The consumer thread waits for the producer thread to push a line
+# to buf while buf.empty?, and the producer thread (main thread)
+# reads a line from ARGF and push it to buf, then call
+# empty_cond.signal.
+#
+module MonitorMixin
+  #
+  # FIXME: This isn't documented in Nutshell.
+  #
+  # Since MonitorMixin.new_cond returns a ConditionVariable, and the example
+  # above calls while_wait and signal, this class should be documented.
+  #
+  class ConditionVariable
+    # Create a new timer with the argument timeout, and add the
+    # current thread to the list of waiters.  Then the thread is
+    # stopped.  It will be resumed when a corresponding #signal 
+    # occurs.
+    def wait(timeout = nil)
+      condition = @condition
+      @monitor.instance_eval { mon_wait_for_cond(condition, timeout) }
+    end
+
+    # call #wait while the supplied block returns +true+.
+    def wait_while
+      while yield
+	wait
+      end
+    end
+    
+    # call #wait until the supplied block returns +true+.
+    def wait_until
+      until yield
+	wait
+      end
+    end
+    
+    # Wake up and run the next waiter
+    def signal
+      condition = @condition
+      @monitor.instance_eval { mon_signal_cond(condition) }
+      nil
+    end
+    
+    # Wake up all the waiters.
+    def broadcast
+      condition = @condition
+      @monitor.instance_eval { mon_broadcast_cond(condition) }
+      nil
+    end
+    
+    def count_waiters
+      condition = @condition
+      @monitor.instance_eval { mon_count_cond_waiters(condition) }
+    end
+    
+    private
+
+    def initialize(monitor, condition)
+      @monitor = monitor
+      @condition = condition
+    end
+  end
+  
+  def self.extend_object(obj)
+    super(obj)
+    obj.instance_eval {mon_initialize()}
+  end
+  
+  #
+  # Attempts to enter exclusive section.  Returns +false+ if lock fails.
+  #
+  def mon_try_enter
+    @mon_mutex.synchronize do
+      @mon_owner = Thread.current unless @mon_owner
+      if @mon_owner == Thread.current
+        @mon_count += 1
+        true
+      else
+        false
+      end
+    end
+  end
+  # For backward compatibility
+  alias try_mon_enter mon_try_enter
+
+  #
+  # Enters exclusive section.
+  #
+  def mon_enter
+    @mon_mutex.synchronize do
+      mon_acquire(@mon_entering_cond)
+      @mon_count += 1
+    end
+  end
+  
+  #
+  # Leaves exclusive section.
+  #
+  def mon_exit
+    @mon_mutex.synchronize do
+      mon_check_owner
+      @mon_count -= 1
+      mon_release if @mon_count.zero?
+      nil
+    end
+  end
+
+  #
+  # Enters exclusive section and executes the block.  Leaves the exclusive
+  # section automatically when the block exits.  See example under
+  # +MonitorMixin+.
+  #
+  def mon_synchronize
+    mon_enter
+    begin
+      yield
+    ensure
+      mon_exit
+    end
+  end
+  alias synchronize mon_synchronize
+  
+  #
+  # FIXME: This isn't documented in Nutshell.
+  # 
+  # Create a new condition variable for this monitor.
+  # This facilitates control of the monitor with #signal and #wait.
+  #
+  def new_cond
+    condition = ::ConditionVariable.new
+    condition.instance_eval { @mon_n_waiters = 0 }
+    return ConditionVariable.new(self, condition)
+  end
+
+  private
+
+  def initialize(*args)
+    super
+    mon_initialize
+  end
+
+  # called by initialize method to set defaults for instance variables.
+  def mon_initialize
+    @mon_mutex = Mutex.new
+    @mon_owner = nil
+    @mon_count = 0
+    @mon_total_waiting = 0
+    @mon_entering_cond = ::ConditionVariable.new
+    @mon_waiting_cond = ::ConditionVariable.new
+    self
+  end
+
+  # Throw a ThreadError exception if the current thread
+  # does't own the monitor
+  def mon_check_owner
+    # called with @mon_mutex held
+    if @mon_owner != Thread.current
+      raise ThreadError, "current thread not owner"
+    end
+  end
+
+  def mon_acquire(condition)
+    # called with @mon_mutex held
+    while @mon_owner && @mon_owner != Thread.current
+      condition.wait @mon_mutex
+    end
+    @mon_owner = Thread.current
+  end
+
+  def mon_release
+    # called with @mon_mutex held
+    @mon_owner = nil
+    if @mon_total_waiting.nonzero?
+      @mon_waiting_cond.signal
+    else
+      @mon_entering_cond.signal
+    end
+  end
+
+  def mon_wait_for_cond(condition, timeout)
+    @mon_mutex.synchronize do
+      mon_check_owner
+      count = @mon_count
+      @mon_count = 0
+      condition.instance_eval { @mon_n_waiters += 1 }
+      begin
+        mon_release
+        if timeout
+          condition.wait(@mon_mutex, timeout)
+        else
+          condition.wait(@mon_mutex)
+          true
+        end
+      ensure
+        @mon_total_waiting += 1
+        # TODO: not interrupt-safe
+        mon_acquire(@mon_waiting_cond)
+        @mon_total_waiting -= 1
+        @mon_count = count
+        condition.instance_eval { @mon_n_waiters -= 1 }
+      end
+    end
+  end
+
+  def mon_signal_cond(condition)
+    @mon_mutex.synchronize do
+      mon_check_owner
+      condition.signal
+    end
+  end
+
+  def mon_broadcast_cond(condition)
+    @mon_mutex.synchronize do
+      mon_check_owner
+      condition.broadcast
+    end
+  end
+
+  def mon_count_cond_waiters(condition)
+    @mon_mutex.synchronize do
+      condition.instance_eval { @mon_n_waiters }
+    end
+  end
+end
+
+# Monitors provide means of mutual exclusion for Thread programming.
+# A critical region is created by means of the synchronize method,
+# which takes a block.
+# The condition variables (created with #new_cond) may be used 
+# to control the execution of a monitor with #signal and #wait.
+#
+# the Monitor class wraps MonitorMixin, and provides aliases
+#  alias try_enter try_mon_enter
+#  alias enter mon_enter
+#  alias exit mon_exit
+# to access its methods more concisely.
+class Monitor
+  include MonitorMixin
+  alias try_enter try_mon_enter
+  alias enter mon_enter
+  alias exit mon_exit
+end
+
+
+# Documentation comments:
+#  - All documentation comes from Nutshell.
+#  - MonitorMixin.new_cond appears in the example, but is not documented in
+#    Nutshell.
+#  - All the internals (internal modules Accessible and Initializable, class
+#    ConditionVariable) appear in RDoc.  It might be good to hide them, by
+#    making them private, or marking them :nodoc:, etc.
+#  - The entire example from the RD section at the top is replicated in the RDoc
+#    comment for MonitorMixin.  Does the RD section need to remain?
+#  - RDoc doesn't recognise aliases, so we have mon_synchronize documented, but
+#    not synchronize.
+#  - mon_owner is in Nutshell, but appears as an accessor in a separate module
+#    here, so is hard/impossible to RDoc.  Some other useful accessors
+#    (mon_count and some queue stuff) are also in this module, and don't appear
+#    directly in the RDoc output.
+#  - in short, it may be worth changing the code layout in this file to make the
+#    documentation easier
+
+# Local variables:
+# mode: Ruby
+# tab-width: 8
+# End:

data/lib/rubysl/monitor/version.rb

@@ -0,0 +1,5 @@
+module RubySL
+  module Monitor
+    VERSION = "1.0.0"
+  end
+end

data/rubysl-monitor.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+require './lib/rubysl/monitor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-monitor"
+  spec.version       = RubySL::Monitor::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Ruby standard library Monitor.}
+  spec.summary       = %q{Ruby standard library Monitor.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-monitor"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rubysl-monitor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: mspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Ruby standard library Monitor.
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/monitor.rb
+- lib/rubysl/monitor.rb
+- lib/rubysl/monitor/monitor.rb
+- lib/rubysl/monitor/version.rb
+- rubysl-monitor.gemspec
+homepage: https://github.com/rubysl/rubysl-monitor
+licenses:
+- BSD
+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.0.7
+signing_key: 
+specification_version: 4
+summary: Ruby standard library Monitor.
+test_files: []