glue 0.17.0 → 0.18.0

data/vendor/breakpoint_client.rb

@@ -1,196 +0,0 @@
-require 'breakpoint'
-require 'optparse'
-require 'timeout'
-
-Options = {
-  :ClientURI  => nil,
-  :ServerURI  => "druby://localhost:42531",
-  :RetryDelay => 2,
-  :Permanent  => true,
-  :Verbose    => false
-}
-
-ARGV.options do |opts|
-  script_name = File.basename($0)
-  opts.banner = [
-    "Usage: ruby #{script_name} [Options] [server uri]",
-    "",
-    "This tool lets you connect to a breakpoint service ",
-    "which was started via Breakpoint.activate_drb.",
-    "",
-    "The server uri defaults to druby://localhost:42531"
-  ].join("\n")
-
-  opts.separator ""
-
-  opts.on("-c", "--client-uri=uri",
-    "Run the client on the specified uri.",
-    "This can be used to specify the port",
-    "that the client uses to allow for back",
-    "connections from the server.",
-    "Default: Find a good URI automatically.",
-    "Example: -c druby://localhost:12345"
-  ) { |Options[:ClientURI]| }
-
-  opts.on("-s", "--server-uri=uri",
-    "Connect to the server specified at the",
-    "specified uri.",
-    "Default: druby://localhost:42531"
-  ) { |Options[:ServerURI]| }
-
-  opts.on("-R", "--retry-delay=delay", Integer,
-    "Automatically try to reconnect to the",
-    "server after delay seconds when the",
-    "connection failed or timed out.",
-    "A value of 0 disables automatical",
-    "reconnecting completely.",
-    "Default: 10"
-  ) { |Options[:RetryDelay]| }
-
-  opts.on("-P", "--[no-]permanent",
-    "Run the breakpoint client in permanent mode.",
-    "This means that the client will keep continue",
-    "running even after the server has closed the",
-    "connection. Useful for example in Rails."
-  ) { |Options[:Permanent]| }
-
-  opts.on("-V", "--[no-]verbose",
-    "Run the breakpoint client in verbose mode.",
-    "Will produce more messages, for example between",
-    "individual breakpoints. This might help in seeing",
-    "that the breakpoint client is still alive, but adds",
-    "quite a bit of clutter."
-  ) { |Options[:Verbose]| }
-
-  opts.separator ""
-
-  opts.on("-h", "--help",
-    "Show this help message."
-  ) { puts opts; exit }
-  opts.on("-v", "--version",
-    "Display the version information."
-  ) do
-    id = %q$Id: breakpoint_client.rb 1 2005-04-11 11:04:30Z gmosx $
-    puts id.sub("Id: ", "")
-    puts "(Breakpoint::Version = #{Breakpoint::Version})"
-    exit
-  end
-
-  opts.parse!
-end
-
-Options[:ServerURI] = ARGV[0] if ARGV[0]
-
-module Handlers
-  extend self
-
-  def breakpoint_handler(workspace, message)
-    puts message
-    IRB.start(nil, nil, workspace)
-
-    puts ""
-    if Options[:Verbose] then
-      puts "Resumed execution. Waiting for next breakpoint...", ""
-    end
-  end
-
-  def eval_handler(code)
-    result = eval(code, TOPLEVEL_BINDING)
-    if result then
-      DRbObject.new(result)
-    else
-      result
-    end
-  end
-
-  def collision_handler()
-    msg = [
-      "  *** Breakpoint service collision ***",
-      "  Another Breakpoint service tried to use the",
-      "  port already occupied by this one. It will",
-      "  keep waiting until this Breakpoint service",
-      "  is shut down.",
-      "  ",
-      "  If you are using the Breakpoint library for",
-      "  debugging a Rails or other CGI application",
-      "  this likely means that this Breakpoint",
-      "  session belongs to an earlier, outdated",
-      "  request and should be shut down via 'exit'."
-    ].join("\n")
-
-    if RUBY_PLATFORM["win"] then
-      # This sucks. Sorry, I'm not doing this because
-      # I like funky message boxes -- I need to do this
-      # because on Windows I have no way of displaying
-      # my notification via puts() when gets() is still
-      # being performed on STDIN. I have not found a
-      # better solution.
-      begin
-        require 'tk'
-        root = TkRoot.new { withdraw }
-        Tk.messageBox('message' => msg, 'type' => 'ok')
-        root.destroy
-      rescue Exception
-        puts "", msg, ""
-      end
-    else
-      puts "", msg, ""
-    end
-  end
-end
-
-# Used for checking whether we are currently in the reconnecting loop.
-reconnecting = false
-
-loop do
-  DRb.start_service(Options[:ClientURI])
-
-  begin
-    service = DRbObject.new(nil, Options[:ServerURI])
-
-    begin
-      ehandler = Handlers.method(:eval_handler)
-      chandler = Handlers.method(:collision_handler)
-      handler = Handlers.method(:breakpoint_handler)
-      service.eval_handler = ehandler
-      service.collision_handler = chandler
-      service.handler = handler
-
-      reconnecting = false
-      if Options[:Verbose] then
-        puts "Connection established. Waiting for breakpoint...", ""
-      end
-
-      loop do
-        begin
-          service.ping
-        rescue DRb::DRbConnError => error
-          puts "Server exited. Closing connection...", ""
-          exit! unless Options[:Permanent]
-          break
-        end
-
-        sleep(0.5)
-      end
-    ensure
-      service.eval_handler = nil
-      service.collision_handler = nil
-      service.handler = nil
-    end
-  rescue Exception => error
-    if Options[:RetryDelay] > 0 then
-      if not reconnecting then
-        reconnecting = true
-        puts "No connection to breakpoint service at #{Options[:ServerURI]} " +
-           "(#{error.class})"
-        puts error.backtrace if $DEBUG
-        puts "Tries to connect will be made every #{Options[:RetryDelay]} seconds..."
-      end
-
-      sleep Options[:RetryDelay]
-      retry
-    else
-      raise
-    end
-  end
-end

data/vendor/extensions/_base.rb

@@ -1,153 +0,0 @@
-
-#
-# This file is 'required' by all files that implement standard class
-# extensions as part of the "Ruby/Extensions" project.
-#
-# The "Extensions" project requires 1.8.0 or greater to run, as it is too
-# much hassle at the moment to consider supporting older versions.  That may
-# one day be implemented if demand is there.  One option would be to require
-# "shim", so that we can assume all 1.8 library methods are implemented.
-#
-# This file is only of interest to developers of the package, so no detailed
-# documentation is included here.  However, by way of introduction, this is what
-# it's all about.  Each method that is implemented as part of this package is
-# done so through a framework implemented in this file.  Take the following
-# simple example:
-#
-#   ExtensionsProject.implement(Integer, :even?, :instance) do
-#     class Integer
-#       #
-#       # RDoc comments.
-#       # 
-#       def even?
-#         self % 2 == 0
-#       end
-#     end
-#   end
-#
-# This purposes of this are as follows:
-# - if the intended method (in this case IO.write) is already defined,
-#   we don't want to overwrite it (we issue a warning and move on)
-# - if the intended method is _not_ implemented as a result of the block,
-#   we have not done as we said, and an error is raised
-# - the ExtensionsProject class gathers information on which methods have
-#   been implemented, making for a very handy command-line reference (+rbxtm+)
-#
-# The <tt>ExtensionsProject.implement</tt> method is responsible for ensuring
-# these are so.  It gives us documentation, and some assurance that the
-# extensions are doing what we say they are doing.
-#
-
-# :enddoc:
-
-#
-# For what reason does Ruby define Module#methods, Module#instance_methods,
-# and Module#method_defined?, but not Module#instance_method_defined? ?
-#
-# No matter, extending standard classes is the name of the game here.
-#
-class Module
-  if Module.method_defined?(:instance_method_defined?)
-    STDERR.puts "Warning: Module#instance_method_defined? already defined; not overwriting"
-  else
-    def instance_method_defined?(_method)
-      instance_methods(true).find { |m| m == _method.to_s }
-    end
-  end
-
-  if Module.method_defined?(:module_method_defined?)
-    STDERR.puts "Warning: Module#module_method_defined? already defined; not overwriting"
-  else
-    def module_method_defined?(_method)
-      singleton_methods(true).find { |m| m == _method.to_s }
-    end
-  end
-end
-
-
-class ExtensionsProject
-
-  class << ExtensionsProject
-    @@extension_methods = []
-
-    #
-    # The list of methods implemented in this project.
-    #
-    def extension_methods
-      @@extension_methods
-    end
-
-    #
-    # Return the name of the project.  To be used in error messages, etc., for
-    # consistency.
-    #
-    def project_name
-      "Ruby/Extensions"
-    end
-
-    #
-    # Wraps around the implementation of a method, emitting a warning if the
-    # method is already defined.  Returns true to indicate - false to indicate
-    # failure (i.e. method is already defined).  Raises an error if the
-    # specified method is not actually implemented by the block.
-    #
-    def implement(_module, _method, _type=:instance)
-      raise "Internal error: #{__FILE__}:#{__LINE__}" unless
-        _module.is_a? Module and
-        _method.is_a? Symbol and
-        _type == :instance or _type == :class or _type == :module
-
-      fullname = _module.to_s + string_rep(_type) + _method.to_s
-
-      if _defined?(_module, _method, _type)
-        STDERR.puts "#{project_name}: #{fullname} is already defined; not overwriting"
-        return false
-      else
-        yield # Perform the block; presumably a method implementation.
-        if _method == :initialize and _type == :instance
-          # Special case; we can't verify this.
-          @@extension_methods<< "#{_module}::new"
-        else
-          unless _defined?(_module, _method, _type)
-            raise "#{project_name}: internal error: was supposed to implement " +
-              "#{fullname}, but it didn't!"
-          end
-          @@extension_methods << fullname
-        end
-        return true
-      end
-    end
-
-
-    # See whether the given module implements the given method, taking account
-    # of the type (class/instance) required.
-    def _defined?(_module, _method, _type)
-      case _type
-      when :instance
-        _module.instance_method_defined?(_method) # See definition above.
-      when :class, :module
-        _module.module_method_defined?(_method)   # See definition above.
-      end
-    end
-    private :_defined?
-
-
-    # Return the string representation of the given method type.
-    def string_rep(method_type)
-      case method_type
-      when :instance then "#"
-      when :class    then "."
-      when :module   then "."
-      else
-        nil
-      end
-    end
-    private :string_rep
-  end
-end    # class ExtensionsProject
-
-
-if VERSION < "1.8.0"
-  raise "#{ExtensionsProject.project_name} requires Ruby 1.8.0 at least (for now)"
-end
-

data/vendor/extensions/_template.rb

@@ -1,36 +0,0 @@
-#!/usr/local/bin/ruby -w
-# A template for new files in the project; of no interest to end users.  An
-# error will be raised if you +require+ it.
-#--
-# :enddoc:
-#
-# == extensions/XXX.rb
-#
-# Adds methods to the builtin XXX class. 
-#
-
-raise "Do not load this file!"
-
-require "extensions/_base"
-
-#
-# * Enumerable#build_hash
-#
-ExtensionsProject.implement(Enumerable, :build_hash) do
-  module Enumerable
-    #
-    # Like #map/#collect, but it generates a Hash.
-    #
-    #   [1,5,11].build_hash { |x| [x, x**2] }
-    #      => { 1 => 2, 5 => 25, 11 => 121 }
-    #
-    def build_hash
-      result = {}
-      self.each do |elt|
-        key, value = yield elt
-        result[key] = value
-      end
-      result
-    end
-  end
-end

data/vendor/extensions/all.rb

@@ -1,21 +0,0 @@
-#
-# == extensions/all.rb
-#
-# Require this file in order to access all of the standard class extensions
-# available, or require individual extension files to narrow the selection.
-#
-
-require 'extensions/array.rb'
-require 'extensions/binding.rb'
-require 'extensions/class.rb'
-require 'extensions/continuation.rb'
-require 'extensions/enumerable.rb'
-require 'extensions/hash.rb'
-require 'extensions/io.rb'
-require 'extensions/kernel.rb'
-require 'extensions/module.rb'
-require 'extensions/numeric.rb'
-require 'extensions/object.rb'
-require 'extensions/ostruct.rb'
-require 'extensions/string.rb'
-require 'extensions/symbol.rb'

data/vendor/extensions/array.rb

@@ -1,68 +0,0 @@
-#!/usr/local/bin/ruby -w
-#
-# == extensions/array.rb
-#
-# Adds methods to the builtin Array class. 
-#
-
-require "extensions/_base"
-
-#
-# * Array#select!
-#
-ExtensionsProject.implement(Array, :select!) do
-  class Array
-    #
-    # In-place version of Array#select.  (Counterpart to, and opposite of, the
-    # built-in #reject!)
-    #
-    def select!
-      reject! { |e| not yield(e) }
-    end
-  end
-end
-
-
-#
-# * Array#only
-#
-ExtensionsProject.implement(Array, :only) do
-  class Array
-    #
-    # Returns the _only_ element in the array.  Raises an IndexError if the array's size is not
-    # 1.
-    #
-    #   [5].only      # -> 5
-    #   [1,2,3].only  # -> IndexError
-    #   [].only       # -> IndexError
-    #
-    def only
-      unless size == 1
-        raise IndexError, "Array#only called on non-single-element array"
-      end
-      first
-    end
-  end
-end
-
-#
-# * Array#rand
-#
-ExtensionsProject.implement(Array, :rand) do
-  class Array
-    #
-    # Return a randomly-chosen (using Kernel.rand) element from the array.
-    #
-    #   arr = [48, 71, 3, 39, 15]
-    #   arr.rand     # -> 71
-    #   arr.rand     # -> 39
-    #   arr.rand     # -> 48
-    #   # etc.
-    #
-    def rand
-      idx = Kernel.rand(size)
-      at(idx)
-    end
-  end
-end
-