process_lock 0.0.1

data/.gitignore

@@ -0,0 +1,46 @@
+# Suggested by bundler
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+## RUBYMINE
+.idea/
+
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+*~
+
+## PROJECT::SPECIFIC
+tmp/example*
+,*
+
+# Local ruby version config
+.rbenv-version
+.ruby-version
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+# Just to override the --deployment default arg
+bundler_args: --no-color
+script: "bundle exec rake"
+
+notifications:
+  email:
+    on_success: change
+    on_failure: always
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx
+
+matrix:
+  allow_failures:
+    - rvm: rbx
+

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    process_lock (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  process_lock!
+  rake
+  rspec (~> 2.0)

data/README.md

@@ -0,0 +1,137 @@
+# ProcessLock
+
+A simple class to acquire and check process-id file based locks on a unix filesystem.
+
+[![Build Status](https://travis-ci.org/ianheggie/ruby-process-lock.png?branch=master)](https://travis-ci.org/ianheggie/ruby-process-lock)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'process_lock'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install process_lock
+
+## Usage
+
+Create an instance of ProcessLock with a filename as the lock.
+You may have more than one lock per process.
+
+Methods:
+* acquire - Acquires a lock if it can. Returns true (or value of block if block is passed) if a lock was acquired, otherwise false.
+* acquire! - Same as acquire except it throws an exception if a lock could not be obtained.
+* release - Releases the lock if we are the owner. Returns true if the lock was released.
+* release! - Same as release except it throws an exception if a lock was not released.
+* filename - the filename passed when the instance was created
+* read - the process id in the lock file, otherwise 0 (zero)
+
+Note:
+* locks don't stack - if we have already acquired the lock subsequent calls will reacquire the lock. releasing an already released lock will fail.
+
+To acquire a lock, do some work and then release it:
+
+    pl = ProcessLock.new('tmp/name_of_lock.pid')
+
+    acquired = pl.acquire do
+      puts "Do some work!"
+    end
+    puts "Unable to obtain a lock" unless acquired
+
+    # OR
+
+    while ! pl.acquire
+      puts "Trying to acquire a lock"
+      sleep(1)
+    end
+    puts "Do some work!"
+    pl.release
+
+
+Example:
+
+irb - run first
+
+    >> require 'process_lock'
+    => true
+    >> Process.pid
+    => 16568
+    >> p = ProcessLock.new('tmp/example.tmp')
+    => #<ProcessLock:0x00000001489c10 @filename="tmp/example.tmp">
+    >> p.alive?
+    => false
+    >> p.owner?
+    => false
+    >> p.read
+    => 0
+
+    >> p.acquire!
+    => true
+
+    >> p.alive?
+    => true
+    >> p.owner?
+    => true
+    >> p.read
+    => 16568
+    >> sleep(10)
+    => 10
+    >> p.release!
+    => true
+    >> p.alive?
+    => false
+    >> p.owner?
+    => false
+    >> p.read
+    => 0
+
+2nd irb, run after first has acquired the lock
+
+    >> require 'process_lock'
+    => true
+    >> Process.pid
+    => 16569
+    >> q = ProcessLock.new('tmp/example.tmp')
+    => #<ProcessLock:0x000000026e4090 @filename="tmp/example.tmp">
+    >> q.alive?
+    => true
+    >> q.owner?
+    => false
+    >> q.read
+    => 16568
+
+    >> q.acquire!
+    ProcessLock::AlreadyLocked: Unable to acquire lock
+            from /home/ianh/Projects/Github/ruby-process-lock/lib/process_lock.rb:28:in `acquire!'
+            from (irb):7
+            from /home/ianh/.rbenv/versions/1.9.3-p484/bin/irb:12:in `<main>'
+
+    >> q.alive?
+    => true
+    >> q.owner?
+    => false
+    >> q.read
+    => 16568
+    >>
+
+example.tmp will contain the pid of the running process
+
+## 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
+
+## License and contributions
+
+* Based on work Copyright (c) 2008 Simon Engledew, released under the MIT license.
+* Subsequent work by Ian Heggie: packaged into a gem, added tests and acquire method, fixed acquire so it didn't overwrite locks by other processes.
+* See git log for other contributers
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/lib/process_lock/version.rb

@@ -0,0 +1,3 @@
+class ProcessLock
+  VERSION = "0.0.1"
+end

data/lib/process_lock.rb

@@ -0,0 +1,116 @@
+require 'process_lock/version'
+require 'fileutils'
+
+class ProcessLock
+
+  attr_reader :filename
+
+  class AlreadyLocked < StandardError
+  end
+
+  class NotLocked < StandardError
+  end
+
+  def initialize(filename)
+    @filename = filename
+    FileUtils.touch(@filename)
+  end
+  
+  def acquire!
+    result = acquired = acquire_without_block
+    if acquired and block_given?
+      begin
+        result = yield
+      ensure
+        release
+      end
+    end
+    raise(AlreadyLocked.new('Unable to acquire lock')) unless acquired
+    result
+  end
+
+  def acquire
+    result = acquire_without_block
+    if result and block_given?
+      begin
+        result = yield
+      ensure
+        release
+      end
+    end
+    result
+  end
+
+  def release!
+    unless release
+      raise NotLocked.new('Unable to release lock (probably did not own it)')
+    end
+    true
+  end
+
+  def release
+    acquired = false
+    open_and_lock do |f|
+      acquired = owner?
+      if acquired
+        f.truncate(f.write(''))
+      end
+    end
+    acquired
+  end
+  
+  def alive?
+    pid = read
+    return pid > 0 ? Process.kill(0, pid) > 0 : false
+  rescue
+    return false
+  end
+  
+  def owner?
+    pid = read
+    pid and pid > 0 and pid == Process.pid
+  end
+  
+  def read
+    open_and_lock{|f| f.read.to_i}
+  end
+  
+  private
+
+  def acquire_without_block
+    result = false
+    open_and_lock do |f|
+      result = owner? || ! alive?
+      if result
+        f.rewind
+        f.truncate(f.write(Process.pid))
+      end
+    end
+    result
+  end
+
+  def open_and_lock
+    old_locked_file = @locked_file
+    if @locked_file
+      @locked_file.rewind
+      return yield @locked_file
+    else
+      File.open(@filename, 'r+') do |f|
+        lock(f) do
+          @locked_file = f
+          return yield f
+        end
+      end
+    end
+  ensure
+    @locked_file = old_locked_file
+  end
+
+  def lock(file, blocking = true)
+    file.flock(blocking ? File::LOCK_EX : File::LOCK_EX | File::LOCK_NB)
+    return yield
+  ensure
+    file.flock(File::LOCK_UN)
+  end
+
+end

data/process_lock.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'process_lock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "process_lock"
+  spec.version       = ProcessLock::VERSION
+  spec.authors       = ["Simon Engledew", "Ian Heggie"]
+  spec.email         = ["ian@heggie.biz"]
+  spec.description   = %q{A simple class to aquire and check process-id file based locks on a unix filesystem.}
+  spec.summary       = %q{Use process lock to see if a process is already running or designate a master process when running concurrent applications.}
+  spec.homepage      = "https://github.com/ianheggie/ruby-process-lock"
+  spec.license       = "MIT"
+
+  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"
+  spec.add_development_dependency "rspec", '~> 2.0'
+end

data/spec/other_process.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+#
+# For testing with jruby because it doesnt have fork
+# and it was a pain getting the script right from ruby system call.
+
+file=${1:-/dev/null}
+secs=${2:-0}
+(
+sleep ${secs} <&- >&- 2>&- &
+echo $! > "$file"
+echo "Background process: sleep $secs & echo $! > $file"
+) &
+wait
+exit 0

data/spec/process_lock_spec.rb

@@ -0,0 +1,231 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'fileutils'
+
+describe 'ProcessLock' do
+
+  before(:all) do
+    FileUtils.mkdir_p('tmp')
+    FileUtils.rm_f Dir.glob('tmp/example*.tmp')
+  end
+
+  describe '#acquire' do
+
+    it 'should acquire a lock when called without a block' do
+      p = ProcessLock.new('tmp/example1.txt')
+      p.should_not be_owner
+      p.acquire.should be_true
+      p.should be_owner
+      p.should be_alive
+      p.release.should be_true
+      p.should_not be_owner
+      p.should_not be_alive
+    end
+
+    it 'should acquire a lock when called with a block and then release it' do
+      p = ProcessLock.new('tmp/example2.txt')
+      p.should_not be_owner
+      did_something = false
+      p.acquire do
+        did_something = true
+        p.should be_owner
+        p.should be_alive
+        'value from block'
+      end.should  == 'value from block'
+      did_something.should be_true
+      p.should_not be_owner
+      p.should_not be_alive
+    end
+
+    def acquire_and_then_return_block_value(pl)
+      pl.acquire do
+        @acquired_lock = true
+        pl.should be_owner
+        pl.should be_alive
+        return yield
+      end
+    end
+
+    it 'should acquire a lock when called with a block containing a return and then release it' do
+      p = ProcessLock.new('tmp/example3.txt')
+      p.should_not be_owner
+      acquire_and_then_return_block_value(p) do
+        'value returned by block'
+      end.should == 'value returned by block'
+      p.should_not be_owner
+      p.should_not be_alive
+    end
+
+    it 'should not acquire a lock if some other process has the lock' do
+      fn = 'tmp/example4.txt'
+      system('bash spec/other_process.sh "%s" 100' % fn)
+      p = ProcessLock.new(fn)
+      200.times do |i|
+        break if p.read > 0
+        sleep(0.5)
+        puts "waited #{i+1} times" if i > 2
+      end
+      pid = p.read
+      puts "+ps -fp %d" % pid
+      system "ps -fp %d" % pid
+      # other process should have acquired the lock
+      p.should_not be_owner
+      p.should be_alive
+      p.acquire.should be_false
+      p.should_not be_owner
+      p.should be_alive
+      # also try block
+      did_something = false
+      p.acquire do
+        did_something = true
+        'Some value'
+      end.should be_false
+      did_something.should be_false
+      p.should_not be_owner
+      p.should be_alive
+      Process.kill(9, pid) if pid> 0
+    end
+
+    it 'should acquire a lock if an completed process has the lock' do
+      fn = 'tmp/example5.txt'
+      system('bash spec/other_process.sh "%s" 0' % fn)
+      p = ProcessLock.new(fn)
+      200.times do |i|
+        break if p.read > 0 && ! p.alive?
+        sleep(0.5)
+        puts "waited #{i+1} times" if i > 2
+      end
+
+      p = ProcessLock.new(fn)
+      p.should_not be_owner
+      p.should_not be_alive
+      p.acquire.should be_true
+      p.should be_owner
+      p.should be_alive
+      p.release
+    end
+
+    it 'should allow multiple sequential locked sections' do
+      3.times do
+        p = ProcessLock.new('tmp/example6.txt')
+        p.should_not be_owner
+        did_something = false
+        p.acquire do
+          did_something = true
+          p.should be_owner
+          p.should be_alive
+        end.should be_true
+        p.should_not be_owner
+        p.should_not be_alive
+        did_something.should be_true
+      end
+    end
+
+    it 'should allow multiple parallel but differently named locked sections' do
+      ps = 3.times.collect { |i| ProcessLock.new('tmp/example7-%d.txt' % i) }
+      did_something = 0
+      ps.each do |p|
+        p.should_not be_owner
+        p.acquire
+        p.should be_owner
+        p.should be_alive
+      end
+      ps.each do |p|
+        p.should be_owner
+        p.should be_alive
+        p.release
+        p.should_not be_owner
+        p.should_not be_alive
+      end
+    end
+
+  end
+
+  describe '#acquire!' do
+
+    it 'should call acquire and expect true' do
+      p = ProcessLock.new('tmp/example8.txt')
+      p.stub(:acquire_without_block).and_return(true)
+      p.acquire!.should be_true
+    end
+
+    it 'throw an error if acquire returns false' do
+      p = ProcessLock.new('tmp/example9.txt')
+      p.stub(:acquire_without_block).and_return(false)
+      expect { p.acquire! }.to raise_error(ProcessLock::AlreadyLocked)
+    end
+
+    it 'should acquire a lock when called with a block and then release it' do
+      p = ProcessLock.new('tmp/example2.txt')
+      p.should_not be_owner
+      did_something = false
+      p.acquire! do
+        did_something = true
+        p.should be_owner
+        p.should be_alive
+        'some value'
+      end.should == 'some value'
+      did_something.should be_true
+      p.should_not be_owner
+      p.should_not be_alive
+    end
+
+  end
+
+  describe '#release!' do
+
+    it 'should call release and expect true' do
+      p = ProcessLock.new('tmp/example10.txt')
+      p.stub(:release).and_return(true)
+      p.release!.should be_true
+    end
+
+    it 'throw an error if release returns false' do
+      p = ProcessLock.new('tmp/example11.txt')
+      p.stub(:release).and_return(false)
+      expect { p.release! }.to raise_error(ProcessLock::NotLocked)
+    end
+  end
+
+
+  describe '#read' do
+
+    it 'should return the current PID if the lock was acquired' do
+      p = ProcessLock.new('tmp/example12.txt')
+      p.acquire do
+        p.read.should == Process.pid
+        p.should be_alive
+      end
+      p.should_not be_alive
+    end
+
+    it 'should return whatever number is in the file' do
+      p = ProcessLock.new('tmp/example13.txt')
+      File.open(p.filename, 'w') do |f|
+        f.puts('314152653')
+      end
+      p.read.should == 314152653
+    end
+
+  end
+
+  describe '#filename' do
+
+    it 'should return the filename' do
+      fn = 'tmp/example14.txt'
+      p = ProcessLock.new(fn)
+      p.filename.should == fn
+    end
+  end
+
+  it 'should use a string for the current PID in filename' do
+    p = ProcessLock.new('tmp/example15.txt')
+    p.acquire do
+      File.open(p.filename, 'r') do |f|
+        contents = f.read
+        contents.should == Process.pid.to_s
+      end
+    end
+  end
+
+end

data/spec/run_example.sh

@@ -0,0 +1,404 @@
+irb='irb -f --inspect -I lib --prompt simple '
+rm -f tmp/example.tmp
+set -x
+(
+$irb > ,irb1.out <<EOF
+require 'process_lock'
+Process.pid
+p = ProcessLock.new('tmp/example.tmp')
+p.alive?
+p.owner?
+p.read
+p.acquire!
+p.alive?
+p.owner?
+p.read
+sleep(10)
+p.release!
+p.alive?
+p.owner?
+p.read
+EOF
+) &
+
+(
+sleep 2
+$irb <<EOF
+require 'process_lock'
+Process.pid
+q = ProcessLock.new('tmp/example.tmp')
+q.alive?
+q.owner?
+q.read
+q.acquire!
+q.alive?
+q.owner?
+q.read
+EOF
+) | tee ,irb2.out 
+
+wait
+
+exit
+
+IRB1.9(1)                   General Commands Manual                  IRB1.9(1)
+
+
+
+NAME
+       irb1.9.1 - interactive ruby
+
+SYNOPSIS
+       irb [options]
+
+DESCRIPTION
+       irb  stands  for  `interactive ruby'. irb is a tool to execute interac‐
+       tively ruby expressions read from stdin.  Use of irb  is  easy  if  you
+       know  ruby.   Executing  irb,  prompts  are displayed as follows. Then,
+       enter expression of ruby. A input is executed when it  is  syntacticaly
+       completed.
+
+           $ irb1.9.1
+           irb(main):001:0> 1+2
+           3
+           irb(main):002:0> class Foo
+           irb(main):003:1>  def foo
+           irb(main):004:2>    print 1
+           irb(main):005:2>  end
+           irb(main):006:1> end
+           nil
+           irb(main):007:0>
+
+       And,  Readline  extesion module can be used with irb. Using Readline is
+       the standard default action if Readline is installed.
+
+OPTIONS
+       -f     suppress read ~/.irbrc
+
+       -m     bc mode (fraction or matrix are available)
+
+       -d     set $DEBUG  to true (same as `ruby -d')
+
+       -r load-module
+              same as `ruby -r'
+
+       --inspect
+              uses `inspect' for output (the default except bc mode)
+
+       --noinspect
+              doesn't uses inspect for output
+
+       --readline
+              uses Readline extension module
+
+       --noreadline
+              doesn't use Readline extension module
+
+       --prompt prompt-mode
+
+       --prompt-mode prompt-mode
+              switches prompt mode. Pre-defined prompt  modes  are  `default',
+              `simple', `xmp' and `inf-ruby'
+
+       --inf-ruby-mode
+              uses  prompt  appreciate for inf-ruby-mode on emacs.  Suppresses
+              --readline.
+
+       --simple-prompt
+              simple prompt mode
+
+       --noprompt
+              no prompt
+
+       --tracer
+              display trace for each execution of commands.
+
+       --back-trace-limit n
+              displayes backtrace top n and tail n. The default value is 16.
+
+       --irb_debug n
+              sets internal debug level to n (It shouldn't be used)
+
+       -v, --version
+              prints the version of irb
+
+CONFIGURATIONS
+       irb reads `~/.irbrc' when it is invoked. If  `~/.irbrb'  doesn't  exist
+       irb  try  to  read  in  the  order  `.irbrc',  `irb.rc',  `_irbrc' then
+       `$irbrc'.  The following is altanative to the command line  option.  To
+       use them type as follows in an irb session.
+
+           IRB.conf[:IRB_NAME]="irb"
+           IRB.conf[:MATH_MODE]=false
+           IRB.conf[:USE_TRACER]=false
+           IRB.conf[:USE_LOADER]=false
+           IRB.conf[:IGNORE_SIGINT]=true
+           IRB.conf[:IGNORE_EOF]=false
+           IRB.conf[:INSPECT_MODE]=nil
+           IRB.conf[:IRB_RC] = nil
+           IRB.conf[:BACK_TRACE_LIMIT]=16
+           IRB.conf[:USE_LOADER] = false
+           IRB.conf[:USE_READLINE] = nil
+           IRB.conf[:USE_TRACER] = false
+           IRB.conf[:IGNORE_SIGINT] = true
+           IRB.conf[:IGNORE_EOF] = false
+           IRB.conf[:PROMPT_MODE] = :DEFALUT
+           IRB.conf[:PROMPT] = {...}
+           IRB.conf[:DEBUG_LEVEL]=0
+           IRB.conf[:VERBOSE]=true
+
+Customizing prompt
+       To costomize the prompt you set a variable
+
+           IRB.conf[:PROMPT]
+
+       For example, describe as follows in `.irbrc'.
+
+           IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode
+             :PROMPT_I => nil,         # normal prompt
+             :PROMPT_S => nil,         # prompt for continuated strings
+             :PROMPT_C => nil,         # prompt for continuated statement
+             :RETURN => "    ==>%s\n"       # format to return value
+           }
+
+       Then, invoke irb with the above prompt mode by
+
+           $ irb1.9.1 --prompt my-prompt
+
+       Or add the following in `.irbrc'.
+
+           IRB.conf[:PROMPT_MODE] = :MY_PROMPT
+
+       Constants PROMPT_I, PROMPT_S and PROMPT_C specifies the format.  In the
+       prompt specification, some special strings are available.
+
+           %N    command name which is running
+           %m    to_s of main object (self)
+           %M    inspect of main object (self)
+           %l    type of string(", ', /, ]), `]' is inner %w[...]
+           %NNi  indent level. NN is degits and means as same as printf("%NNd").
+                 It can be ommited
+           %NNn  line number.
+           %%    %
+       For  instance,  the  default  prompt  mode  is  defined   as   follows:
+       IRB.conf[:PROMPT_MODE][:DEFAULT] = {
+
+       PROMPT_I => "%N(%m):%03n:%i> ",
+
+       PROMPT_S => "%N(%m):%03n:%i%l ",
+
+       PROMPT_C => "%N(%m):%03n:%i* ",
+
+       RETURN => "%s\n"}
+              RETURN is used to printf.
+
+Configurating subirb
+       The  command  line  option  or IRB.conf specify the default behavior of
+       (sub)irb. On the other hand, each conf of in the next sction  `6.  Com‐
+       mand'  is used to individually configurate (sub)irb.  If proc is set to
+       IRB.conf[:IRB_RC], its subirb will be invoked after execution  of  that
+       proc  under  giving the context of irb as its aregument. By this mecha‐
+       nism each subirb can be configurated.
+
+Command
+       For irb commands, both simple name and `irb_'-prefixed  name  are  pre‐
+       pared.
+
+       exit, quit, irb_exit
+              Quits  (sub)irb.   if  you've done cb (see below), exit from the
+              binding mode.
+
+
+       conf, irb_context
+              Displays current configuration. Modifing  the  configuration  is
+              achieved by sending message to `conf'.
+
+       conf.back_trace_limit
+              Sets  display  lines  of  backtrace  as  top  n and tail n.  The
+              default value is 16.
+
+       conf.debug_level = N
+              Sets debug level of irb.
+
+       conf.ignore_eof = true/false
+              Whether ^D (control-d) will be ignored or not.  If false is set,
+              ^D means quit.
+
+       conf.ignore_sigint= true/false
+              Whether ^C (control-c) will be ignored or not.  If false is set,
+              ^D means quit.  If true,
+                  during input:   cancel inputing then return to top level.
+                  during execute: abondon current execution.
+
+       conf.inf_ruby_mode = true/false
+              Whether inf-ruby-mode or not. The default value is false.
+
+       conf.inspect_mode = true/false/nil
+              Specifies inspect mode.  true:  display inspect  false:  display
+              to_s nil:   inspect mode in non math mode,
+                  non inspect mode in math mode.
+
+       conf.irb_level
+              The level of cb.
+
+       conf.math_mode
+              Whether bc mode or not.
+
+       conf.use_loader = true/false
+              Whether  irb's  own file reader method is used when load/require
+              or not.  This mode is globaly affected (irb wide).
+
+       conf.prompt_c
+              prompt for a continuating statement (e.g, immediately  after  of
+              `if')
+
+       conf.prompt_i
+              standard prompt
+
+       conf.prompt_s
+              prompt for a continuating string
+
+       conf.rc
+              Whether ~/.irbrc is read or not.
+
+       conf.use_prompt = true/false
+              Prompting or not.
+
+       conf.use_readline = true/false/nil
+              Whether  readline  is used or not.  true: uses false: doen't use
+              nil: intends to use readline except for inf-reuby-mode (default)
+
+       conf.verbose=T/F
+              Whether verbose messages are display or not.
+
+       cb, irb_change_binding [obj]
+              Enter new binding which has a distinct scope of local variables.
+              If obj is given, obj will be self.
+
+       irb [obj]
+              Invoke subirb. If obj is given, obj will be self.
+
+       jobs, irb_jobs
+              List of subirb
+
+       fg n, irb_fg n
+              Switch into specified subirb. The following is candidates of n:
+                  irb number
+                  thhread
+                  irb object
+                  self(obj which is specified of irb obj)
+
+       kill n, irb_kill n
+              Kill subirb. The means of n is as same as the case of irb_fg.
+
+System variable
+       _      The latest value of evaluation (it is local)
+
+Session Example
+           $ irb1.9.1
+           irb(main):001:0> irb                        # invoke subirb
+           irb#1(main):001:0> jobs                     # list of subirbs
+           #0->irb on main (#<Thread:0x400fb7e4> : stop)
+           #1->irb#1 on main (#<Thread:0x40125d64> : running)
+           nil
+           irb#1(main):002:0> fg 0                     # switch job
+           nil
+           irb(main):002:0> class Foo;end
+           nil
+           irb(main):003:0> irb Foo                    # invoke subirb which has the
+           #              context of Foo
+           irb#2(Foo):001:0> def foo                   # define Foo#foo
+           irb#2(Foo):002:1>   print 1
+           irb#2(Foo):003:1> end
+           nil
+           irb#2(Foo):004:0> fg 0                      # switch job
+           nil
+           irb(main):004:0> jobs                       # list of job
+           #0->irb on main (#<Thread:0x400fb7e4> : running)
+           #1->irb#1 on main (#<Thread:0x40125d64> : stop)
+           #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop)
+           nil
+           irb(main):005:0> Foo.instance_methods       # Foo#foo is defined asurely
+           ["foo"]
+           irb(main):006:0> fg 2                       # switch job
+           nil
+           irb#2(Foo):005:0> def bar                   # define Foo#bar
+           irb#2(Foo):006:1>  print "bar"
+           irb#2(Foo):007:1> end
+           nil
+           irb#2(Foo):010:0>  Foo.instance_methods
+           ["bar", "foo"]
+           irb#2(Foo):011:0> fg 0
+           nil
+           irb(main):007:0> f = Foo.new
+           #<Foo:0x4010af3c>
+           irb(main):008:0> irb f                      # invoke subirb which has the
+           #  context of f (instance of Foo)
+           irb#3(#<Foo:0x4010af3c>):001:0> jobs
+           #0->irb on main (#<Thread:0x400fb7e4> : stop)
+           #1->irb#1 on main (#<Thread:0x40125d64> : stop)
+           #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop)
+           #3->irb#3 on #<Foo:0x4010af3c> (#<Thread:0x4010a1e0> : running)
+           nil
+           irb#3(#<Foo:0x4010af3c>):002:0> foo         # evaluate f.foo
+           1nil
+           irb#3(#<Foo:0x4010af3c>):003:0> bar         # evaluate f.bar
+           barnil
+           irb#3(#<Foo:0x4010af3c>):004:0> kill 1, 2, 3# kill job
+           nil
+           irb(main):009:0> jobs
+           #0->irb on main (#<Thread:0x400fb7e4> : running)
+           nil
+           irb(main):010:0> exit                       # exit
+
+Restrictions
+       Because irb evaluates the inputs immediately after the imput is syntac‐
+       tically completed, irb gives slight different result than directly  use
+       ruby. Known difference is pointed out here.
+
+Declaration of the local variable
+       The following causes an error in ruby:
+
+           eval "foo = 0"
+           foo
+           --
+           -:2: undefined local variable or method `foo' for #<Object:0x40283118> (NameError)
+           ---
+           NameError
+
+       Though, the above will successfully done by irb.
+
+           >> eval "foo = 0"
+           => 0
+           >> foo
+           => 0
+
+       Ruby evaluates a code after reading entire of code and determination of
+       the scope of local variables. On the other hand,  irb  do  immediately.
+       More precisely, irb evaluate at first
+
+           evel "foo = 0"
+
+       then foo is defined on this timing. It is because of this incompatibil‐
+       ity.  If you'd like to detect those  differences,  begin...end  can  be
+       used:
+
+           >> begin
+           ?>   eval "foo = 0"
+           >>   foo
+           >> end
+           NameError: undefined local variable or method `foo' for #<Object:0x4013d0f0>
+           (irb):3
+           (irb_local_binding):1:in `eval'
+
+Here-document
+       Implementation of Here-document is incomplete.
+
+Symbol
+       Irb  can  not always recognize a symbol as to be Symbol. Concretely, an
+       expression have completed, however Irb regard it as continuation line.
+
+
+
+
+                                 December 2002                       IRB1.9(1)

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'process_lock'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: process_lock
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Simon Engledew
+- Ian Heggie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A simple class to aquire and check process-id file based locks on a unix
+  filesystem.
+email:
+- ian@heggie.biz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/process_lock.rb
+- lib/process_lock/version.rb
+- process_lock.gemspec
+- spec/other_process.sh
+- spec/process_lock_spec.rb
+- spec/run_example.sh
+- spec/spec_helper.rb
+homepage: https://github.com/ianheggie/ruby-process-lock
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Use process lock to see if a process is already running or designate a master
+  process when running concurrent applications.
+test_files:
+- spec/other_process.sh
+- spec/process_lock_spec.rb
+- spec/run_example.sh
+- spec/spec_helper.rb