rb2exe 0.1.58 → 0.1.60

data/bin/traveling-ruby-2.2.2/win/lib/ruby/2.2.0/timeout.rb

@@ -0,0 +1,130 @@
+# Timeout long-running blocks
+#
+# == Synopsis
+#
+#   require 'timeout'
+#   status = Timeout::timeout(5) {
+#     # Something that should be interrupted if it takes more than 5 seconds...
+#   }
+#
+# == Description
+#
+# Timeout provides a way to auto-terminate a potentially long-running
+# operation if it hasn't finished in a fixed amount of time.
+#
+# Previous versions didn't use a module for namespacing, however
+# #timeout is provided for backwards compatibility.  You
+# should prefer Timeout#timeout instead.
+#
+# == Copyright
+#
+# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
+
+module Timeout
+  # Raised by Timeout#timeout when the block times out.
+  class Error < RuntimeError
+  end
+  class ExitException < ::Exception # :nodoc:
+    attr_reader :thread
+
+    def self.catch(*args)
+      exc = new(*args)
+      exc.instance_variable_set(:@thread, Thread.current)
+      ::Kernel.catch(exc) {yield exc}
+    end
+
+    def exception(*)
+      # TODO: use Fiber.current to see if self can be thrown
+      if self.thread == Thread.current
+        bt = caller
+        begin
+          throw(self, bt)
+        rescue UncaughtThrowError
+        end
+      end
+      self
+    end
+  end
+
+  # :stopdoc:
+  THIS_FILE = /\A#{Regexp.quote(__FILE__)}:/o
+  CALLER_OFFSET = ((c = caller[0]) && THIS_FILE =~ c) ? 1 : 0
+  # :startdoc:
+
+  # Perform an operation in a block, raising an error if it takes longer than
+  # +sec+ seconds to complete.
+  #
+  # +sec+:: Number of seconds to wait for the block to terminate. Any number
+  #         may be used, including Floats to specify fractional seconds. A
+  #         value of 0 or +nil+ will execute the block without any timeout.
+  # +klass+:: Exception Class to raise if the block fails to terminate
+  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error
+  #
+  # Returns the result of the block *if* the block completed before
+  # +sec+ seconds, otherwise throws an exception, based on the value of +klass+.
+  #
+  # The exception thrown to terminate the given block cannot be rescued inside
+  # the block unless +klass+ is given explicitly.
+  #
+  # Note that this is both a method of module Timeout, so you can <tt>include
+  # Timeout</tt> into your classes so they have a #timeout method, as well as
+  # a module method, so you can call it directly as Timeout.timeout().
+  def timeout(sec, klass = nil)   #:yield: +sec+
+    return yield(sec) if sec == nil or sec.zero?
+    message = "execution expired"
+    e = Error
+    bl = proc do |exception|
+      begin
+        x = Thread.current
+        y = Thread.start {
+          begin
+            sleep sec
+          rescue => e
+            x.raise e
+          else
+            x.raise exception, message
+          end
+        }
+        return yield(sec)
+      ensure
+        if y
+          y.kill
+          y.join # make sure y is dead.
+        end
+      end
+    end
+    if klass
+      begin
+        bl.call(klass)
+      rescue klass => e
+        bt = e.backtrace
+      end
+    else
+      bt = ExitException.catch(message, &bl)
+    end
+    rej = /\A#{Regexp.quote(__FILE__)}:#{__LINE__-4}\z/o
+    bt.reject! {|m| rej =~ m}
+    level = -caller(CALLER_OFFSET).size
+    while THIS_FILE =~ bt[level]
+      bt.delete_at(level)
+    end
+    raise(e, message, bt)
+  end
+
+  module_function :timeout
+end
+
+# Identical to:
+#
+#   Timeout::timeout(n, e, &block).
+#
+# This method is deprecated and provided only for backwards compatibility.
+# You should use Timeout#timeout instead.
+def timeout(n, e = nil, &block)
+  Timeout::timeout(n, e, &block)
+end
+
+# Another name for Timeout::Error, defined for backwards compatibility with
+# earlier versions of timeout.rb.
+TimeoutError = Timeout::Error

data/bin/traveling-ruby-2.2.2/win/lib/ruby/2.2.0/tmpdir.rb

@@ -0,0 +1,139 @@
+#
+# tmpdir - retrieve temporary directory path
+#
+# $Id: tmpdir.rb 48905 2014-12-20 08:58:07Z akr $
+#
+
+require 'fileutils'
+begin
+  require 'etc.so'
+rescue LoadError # rescue LoadError for miniruby
+end
+
+class Dir
+
+  @@systmpdir ||= defined?(Etc.systmpdir) ? Etc.systmpdir : '/tmp'
+
+  ##
+  # Returns the operating system's temporary file path.
+
+  def self.tmpdir
+    if $SAFE > 0
+      @@systmpdir
+    else
+      tmp = nil
+      [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], @@systmpdir, '/tmp', '.'].each do |dir|
+        next if !dir
+        dir = File.expand_path(dir)
+        if stat = File.stat(dir) and stat.directory? and stat.writable? and
+            (!stat.world_writable? or stat.sticky?)
+          tmp = dir
+          break
+        end rescue nil
+      end
+      raise ArgumentError, "could not find a temporary directory" unless tmp
+      tmp
+    end
+  end
+
+  # Dir.mktmpdir creates a temporary directory.
+  #
+  # The directory is created with 0700 permission.
+  # Application should not change the permission to make the temporary directory accessible from other users.
+  #
+  # The prefix and suffix of the name of the directory is specified by
+  # the optional first argument, <i>prefix_suffix</i>.
+  # - If it is not specified or nil, "d" is used as the prefix and no suffix is used.
+  # - If it is a string, it is used as the prefix and no suffix is used.
+  # - If it is an array, first element is used as the prefix and second element is used as a suffix.
+  #
+  #  Dir.mktmpdir {|dir| dir is ".../d..." }
+  #  Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
+  #  Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }
+  #
+  # The directory is created under Dir.tmpdir or
+  # the optional second argument <i>tmpdir</i> if non-nil value is given.
+  #
+  #  Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
+  #  Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }
+  #
+  # If a block is given,
+  # it is yielded with the path of the directory.
+  # The directory and its contents are removed
+  # using FileUtils.remove_entry before Dir.mktmpdir returns.
+  # The value of the block is returned.
+  #
+  #  Dir.mktmpdir {|dir|
+  #    # use the directory...
+  #    open("#{dir}/foo", "w") { ... }
+  #  }
+  #
+  # If a block is not given,
+  # The path of the directory is returned.
+  # In this case, Dir.mktmpdir doesn't remove the directory.
+  #
+  #  dir = Dir.mktmpdir
+  #  begin
+  #    # use the directory...
+  #    open("#{dir}/foo", "w") { ... }
+  #  ensure
+  #    # remove the directory.
+  #    FileUtils.remove_entry dir
+  #  end
+  #
+  def Dir.mktmpdir(prefix_suffix=nil, *rest)
+    path = Tmpname.create(prefix_suffix || "d", *rest) {|n| mkdir(n, 0700)}
+    if block_given?
+      begin
+        yield path
+      ensure
+        stat = File.stat(File.dirname(path))
+        if stat.world_writable? and !stat.sticky?
+          raise ArgumentError, "parent directory is world writable but not sticky"
+        end
+        FileUtils.remove_entry path
+      end
+    else
+      path
+    end
+  end
+
+  module Tmpname # :nodoc:
+    module_function
+
+    def tmpdir
+      Dir.tmpdir
+    end
+
+    def make_tmpname((prefix, suffix), n)
+      prefix = (String.try_convert(prefix) or
+                raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
+      suffix &&= (String.try_convert(suffix) or
+                  raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
+      t = Time.now.strftime("%Y%m%d")
+      path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix if suffix
+      path
+    end
+
+    def create(basename, tmpdir=nil, max_try: nil, **opts)
+      if $SAFE > 0 and tmpdir.tainted?
+        tmpdir = '/tmp'
+      else
+        tmpdir ||= tmpdir()
+      end
+      n = nil
+      begin
+        path = File.join(tmpdir, make_tmpname(basename, n))
+        yield(path, n, opts)
+      rescue Errno::EEXIST
+        n ||= 0
+        n += 1
+        retry if !max_try or n < max_try
+        raise "cannot generate temporary name using `#{basename}' under `#{tmpdir}'"
+      end
+      path
+    end
+  end
+end

data/bin/traveling-ruby-2.2.2/win/lib/ruby/2.2.0/tracer.rb

@@ -0,0 +1,286 @@
+#--
+# $Release Version: 0.3$
+# $Revision: 1.12 $
+require "thread"
+
+##
+# Outputs a source level execution trace of a Ruby program.
+#
+# It does this by registering an event handler with Kernel#set_trace_func for
+# processing incoming events.  It also provides methods for filtering unwanted
+# trace output (see Tracer.add_filter, Tracer.on, and Tracer.off).
+#
+# == Example
+#
+# Consider the following Ruby script
+#
+#   class A
+#     def square(a)
+#       return a*a
+#     end
+#   end
+#
+#   a = A.new
+#   a.square(5)
+#
+# Running the above script using <code>ruby -r tracer example.rb</code> will
+# output the following trace to STDOUT (Note you can also explicitly
+# <code>require 'tracer'</code>)
+#
+#   #0:<internal:lib/rubygems/custom_require>:38:Kernel:<: -
+#   #0:example.rb:3::-: class A
+#   #0:example.rb:3::C: class A
+#   #0:example.rb:4::-:   def square(a)
+#   #0:example.rb:7::E: end
+#   #0:example.rb:9::-: a = A.new
+#   #0:example.rb:10::-: a.square(5)
+#   #0:example.rb:4:A:>:   def square(a)
+#   #0:example.rb:5:A:-:     return a*a
+#   #0:example.rb:6:A:<:   end
+#    |  |         | |  |
+#    |  |         | |   ---------------------+ event
+#    |  |         |  ------------------------+ class
+#    |  |          --------------------------+ line
+#    |   ------------------------------------+ filename
+#     ---------------------------------------+ thread
+#
+# Symbol table used for displaying incoming events:
+#
+# +}+:: call a C-language routine
+# +{+:: return from a C-language routine
+# +>+:: call a Ruby method
+# +C+:: start a class or module definition
+# +E+:: finish a class or module definition
+# +-+:: execute code on a new line
+# +^+:: raise an exception
+# +<+:: return from a Ruby method
+#
+# == Copyright
+#
+# by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+class Tracer
+  class << self
+    # display additional debug information (defaults to false)
+    attr_accessor :verbose
+    alias verbose? verbose
+
+    # output stream used to output trace (defaults to STDOUT)
+    attr_accessor :stdout
+
+    # mutex lock used by tracer for displaying trace output
+    attr_reader :stdout_mutex
+
+    # display process id in trace output (defaults to false)
+    attr_accessor :display_process_id
+    alias display_process_id? display_process_id
+
+    # display thread id in trace output (defaults to true)
+    attr_accessor :display_thread_id
+    alias display_thread_id? display_thread_id
+
+    # display C-routine calls in trace output (defaults to false)
+    attr_accessor :display_c_call
+    alias display_c_call? display_c_call
+  end
+
+  Tracer::stdout = STDOUT
+  Tracer::verbose = false
+  Tracer::display_process_id = false
+  Tracer::display_thread_id = true
+  Tracer::display_c_call = false
+
+  @stdout_mutex = Mutex.new
+
+  # Symbol table used for displaying trace information
+  EVENT_SYMBOL = {
+    "line" => "-",
+    "call" => ">",
+    "return" => "<",
+    "class" => "C",
+    "end" => "E",
+    "raise" => "^",
+    "c-call" => "}",
+    "c-return" => "{",
+    "unknown" => "?"
+  }
+
+  def initialize # :nodoc:
+    @threads = Hash.new
+    if defined? Thread.main
+      @threads[Thread.main.object_id] = 0
+    else
+      @threads[Thread.current.object_id] = 0
+    end
+
+    @get_line_procs = {}
+
+    @filters = []
+  end
+
+  def stdout # :nodoc:
+    Tracer.stdout
+  end
+
+  def on # :nodoc:
+    if block_given?
+      on
+      begin
+        yield
+      ensure
+        off
+      end
+    else
+      set_trace_func method(:trace_func).to_proc
+      stdout.print "Trace on\n" if Tracer.verbose?
+    end
+  end
+
+  def off # :nodoc:
+    set_trace_func nil
+    stdout.print "Trace off\n" if Tracer.verbose?
+  end
+
+  def add_filter(p = proc) # :nodoc:
+    @filters.push p
+  end
+
+  def set_get_line_procs(file, p = proc) # :nodoc:
+    @get_line_procs[file] = p
+  end
+
+  def get_line(file, line) # :nodoc:
+    if p = @get_line_procs[file]
+      return p.call(line)
+    end
+
+    unless list = SCRIPT_LINES__[file]
+      list = File.readlines(file) rescue []
+      SCRIPT_LINES__[file] = list
+    end
+
+    if l = list[line - 1]
+      l
+    else
+      "-\n"
+    end
+  end
+
+  def get_thread_no # :nodoc:
+    if no = @threads[Thread.current.object_id]
+      no
+    else
+      @threads[Thread.current.object_id] = @threads.size
+    end
+  end
+
+  def trace_func(event, file, line, id, binding, klass, *) # :nodoc:
+    return if file == __FILE__
+
+    for p in @filters
+      return unless p.call event, file, line, id, binding, klass
+    end
+
+    return unless Tracer::display_c_call? or
+      event != "c-call" && event != "c-return"
+
+    Tracer::stdout_mutex.synchronize do
+      if EVENT_SYMBOL[event]
+        stdout.printf("<%d>", $$) if Tracer::display_process_id?
+        stdout.printf("#%d:", get_thread_no) if Tracer::display_thread_id?
+        if line == 0
+          source = "?\n"
+        else
+          source = get_line(file, line)
+        end
+        stdout.printf("%s:%d:%s:%s: %s",
+               file,
+               line,
+               klass || '',
+               EVENT_SYMBOL[event],
+               source)
+      end
+    end
+
+  end
+
+  # Reference to singleton instance of Tracer
+  Single = new
+
+  ##
+  # Start tracing
+  #
+  # === Example
+  #
+  #   Tracer.on
+  #   # code to trace here
+  #   Tracer.off
+  #
+  # You can also pass a block:
+  #
+  #   Tracer.on {
+  #     # trace everything in this block
+  #   }
+
+  def Tracer.on
+    if block_given?
+      Single.on{yield}
+    else
+      Single.on
+    end
+  end
+
+  ##
+  # Disable tracing
+
+  def Tracer.off
+    Single.off
+  end
+
+  ##
+  # Register an event handler <code>p</code> which is called everytime a line
+  # in +file_name+ is executed.
+  #
+  # Example:
+  #
+  #   Tracer.set_get_line_procs("example.rb", lambda { |line|
+  #     puts "line number executed is #{line}"
+  #   })
+
+  def Tracer.set_get_line_procs(file_name, p = proc)
+    Single.set_get_line_procs(file_name, p)
+  end
+
+  ##
+  # Used to filter unwanted trace output
+  #
+  # Example which only outputs lines of code executed within the Kernel class:
+  #
+  #   Tracer.add_filter do |event, file, line, id, binding, klass, *rest|
+  #     "Kernel" == klass.to_s
+  #   end
+
+  def Tracer.add_filter(p = proc)
+    Single.add_filter(p)
+  end
+end
+
+# :stopdoc:
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+if $0 == __FILE__
+  # direct call
+
+  $0 = ARGV[0]
+  ARGV.shift
+  Tracer.on
+  require $0
+else
+  # call Tracer.on only if required by -r command-line option
+  count = caller.count {|bt| %r%/rubygems/core_ext/kernel_require\.rb:% !~ bt}
+  if (defined?(Gem) and count == 0) or
+     (!defined?(Gem) and count <= 1)
+    Tracer.on
+  end
+end
+# :startdoc: