glue 0.13.0 → 0.14.0

data/vendor/breakpoint_client.rb

@@ -0,0 +1,196 @@
+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 91 2005-02-04 22:34:08Z flgr $
+    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

@@ -0,0 +1,153 @@
+
+#
+# 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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,21 @@
+#
+# == 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

@@ -0,0 +1,68 @@
+#!/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
+