rextra 2.0.1 → 2.0.3

data/lib/rextra/bleeding.rb

@@ -12,222 +12,211 @@
 # == Licence
 # TBD
 
-
 #--
-# TODO doc this
 # TODO review this
-# TODO move to seperate project
 # TODO test test test
 #++
 
 require 'rextra/cutting'
 
-def ObjectSpace.make_proc str
-  eval "proc {#{str}}"
-end
-
-module Kernel
-  def call_stack
-    require 'ostruct'
-    caller.map do |c|
-      # TODO  rewrite this regexp
-      m = /^([\.a-zA-Z_0-9()\/]*):(\d*)(?::in `(\S*)')?$/.match c
-      OpenStruct.new(:file=>m[1],:line=>m[2],:call=>m[3]) rescue nil
-    end.compact
-  end
-  def caller_name deep = 1
-    /:in `(\S*)'$/.match( caller[deep] )[1]
-  end
-  def method_name() caller_name end
-end
-
-class Object
-  def this
-    require 'weakref'
-    WeakRef.new self
-  end
-  def destructor str
-    ObjectSpace.define_finalizer this, ObjectSpace.make_proc( str )
-  end
-end
-
-class Module
-  #def once_methods *meths
-  #  act_on_methods *meths do |meth|
-  #    alias_method "__rapid_#{meth}", meth if method_defined? meth
-  #    meta_eval { (@once ||= Set.new) << meth }
-  #    class_eval<<-HERE
-  #      def #{meth} *args, &block
-  #        __rapid_#{method} *args, &block
-  #      ensure # is this right?
-  #        undef_methods __rapid_#{meth}
-  #        empty_methods #{meth}
-  #      end
-  #    HERE
-  #  end
-  #end
-  def module () self end
-  def modules() [self] + modules_up end
-  def module_up() eval name.sub( /(::)?\w+$/, '' ) end
-  def modules_up result = []
-    (r = module_up) ? r.modules_up( result << r ) : result end
-  def def_advice meth, &block
-    prev = self.instance_method meth.
-      define_method( meth ) do |*args|
-        block.call( prev.bind(self), *args ) end end
-
-  # TODO fix #const to look in global module
-  class Const
-    def initialize mod
-      @mod = mod
-    end
-    def method_missing( sym, *args )
-      @mod.modules.each do |mod|
-        return mod.const_get( sym ) if mod.const_defined? sym.to_s
-      end
-      #raise NameError, "uninitialized constant #{sym}"
-      nil
-    end
-  end
-
-  def const
-    Const.new self.module
-  end
-
-  def consts *syms
-    start, inc = 0, 1
-    start = syms.shift if syms.first.kind_of? Integer
-    inc   = syms.pop   if syms.last.kind_of?  Integer
-    syms.each do |sym|
-      class_eval "#{sym.to_s.upcase} = #{start}"
-      start += inc
-    end
-  end
-
-end
-
-def parallel_each( *args )
-  args.shift.zip( *args ).each do |e|
-    yield( *e )
-  end
-end
-
-module Rapid
-
-  class ThreadPool
-    def initialize size = 10
-      @count, @max = 0, size
-      @mutex, @cond = Mutex.new, ConditionVariable.new
-    end
-    def thread *args, &block
-      @mutex.synchronize do
-        @cond.wait @mutex unless @count < @max
-        @count += 1
-        result = Thread.new(args,Thread.current,block) do |args,th,block|
-          begin
-            block.call *args
-          rescue => e
-            th.raise e
-          ensure
-            release
-          end end end
-    end
-    def max=(size) @mutex.synchronize { @max = size } end
-   private
-    def release
-      @mutex.synchronize do
-        @count -= 1
-        @cond.signal
-      end
-    end
-  end
-
-  VERSION = '0.0.2'
-
-  def self.tempfile name = nil
-    require 'tempfile'
-    tf = Tempfile.new name
-    yield tf
-  ensure
-    tf.close true
-  end
-
-  def self.start_daemon *args, &block
-    :$VERBOSE.temporary nil do
-      #EndData.close if $leftovers
-      Process.fork do
-        fork and exit
-        trap( 'INT' ) { Thread.current.kill }
-        $stderr = $stdout = $stdin = NullDevice.new
-        Process.setsid
-        block.call( *args )
-      end
-    end
-  end
-
-  def self.term_size
-    require 'curses'
-    Curses.init_screen
-    x, y = Curses.cols, Curses.lines
-    Curses.close_screen
-    [x, y]
-  ensure
-    Curses.close_screen
-  end
-
-  def self.filename
-    File.basename $0
-  end
-
-  def self.create_key size = 16 # copied from cgi/session.rb
-    require 'digest/md5'
-    md5 = Digest::MD5::new
-    md5.update(String(Time::now))
-    md5.update(String(rand(0)))
-    md5.update(String($$))
-    md5.hexdigest[0,size]
-  end
-
-module Kernel
-
-  def modules()    self.class.modules    end
-  def module()     self.class.module     end
-  def module_up()  self.class.module_up  end
-  def modules_up() self.class.modules_up end
-
-end
-
-def required
-  result = []
-  $".each do |file|
-    $:.each do |path|
-      if File.exists?( path + '/' + file )
-        result << (path + '/' + file)
-        next
-      end
-    end
-  end
-  result
-end
-
-def required? file
-  (el = required.grep( /#{file}(\.rb|\.so)?$/ ).to_el).empty? ? false : el
+def __TBD
+  raise 'TBD'
 end
 
-class Array
-   def to_el # TODO better name
-      size == 1 ? first : self
-   end
-end
-
-class Numeric
-  def commify
-    to_s.reverse.scan(/\d{3}|\d+/).join(',').reverse
-  end
-end
-
-class Float
-  def to_s_cut x = 3
-    to_s.scan(/\d*\.\d{0,#{x}}/)
-  end
-end
+#def ObjectSpace.make_proc str
+#  eval "proc {#{str}}"
+#end
+#
+#module Kernel
+#  def call_stack
+#    require 'ostruct'
+#    caller.map do |c|
+#      # TODO  rewrite this regexp
+#      m = /^([\.a-zA-Z_0-9()\/]*):(\d*)(?::in `(\S*)')?$/.match c
+#      OpenStruct.new(:file=>m[1],:line=>m[2],:call=>m[3]) rescue nil
+#    end.compact
+#  end
+#  def caller_name deep = 1
+#    /:in `(\S*)'$/.match( caller[deep] )[1]
+#  end
+#  def method_name() caller_name end
+#end
+#
+#class Object
+#  def this
+#    require 'weakref'
+#    WeakRef.new self
+#  end
+#  def destructor str
+#    ObjectSpace.define_finalizer this, ObjectSpace.make_proc( str )
+#  end
+#end
+#
+#class Module
+#  def module () self end
+#  def modules() [self] + modules_up end
+#  def module_up() eval name.sub( /(::)?\w+$/, '' ) end
+#  def modules_up result = []
+#    (r = module_up) ? r.modules_up( result << r ) : result end
+#  def def_advice meth, &block
+#    prev = self.instance_method meth.
+#      define_method( meth ) do |*args|
+#        block.call( prev.bind(self), *args )
+#      end
+#  end
+#
+#  # TODO fix #const to look in global module
+#  class Const
+#    def initialize mod
+#      @mod = mod
+#    end
+#    def method_missing( sym, *args )
+#      @mod.modules.each do |mod|
+#        return mod.const_get( sym ) if mod.const_defined? sym.to_s
+#      end
+#      #raise NameError, "uninitialized constant #{sym}"
+#      nil
+#    end
+#  end
+#
+#  def const
+#    Const.new self.module
+#  end
+#
+#  def consts *syms
+#    start, inc = 0, 1
+#    start = syms.shift if syms.first.kind_of? Integer
+#    inc   = syms.pop   if syms.last.kind_of?  Integer
+#    syms.each do |sym|
+#      class_eval "#{sym.to_s.upcase} = #{start}"
+#      start += inc
+#    end
+#  end
+#
+#end
+#
+#def parallel_each( *args )
+#  args.shift.zip( *args ).each do |e|
+#    yield( *e )
+#  end
+#end
+#
+#module Rapid
+#
+#  class ThreadPool
+#    def initialize size = 10
+#      @count, @max = 0, size
+#      @mutex, @cond = Mutex.new, ConditionVariable.new
+#    end
+#    def thread *args, &block
+#      @mutex.synchronize do
+#        @cond.wait @mutex unless @count < @max
+#        @count += 1
+#        result = Thread.new(args,Thread.current,block) do |args,th,block|
+#          begin
+#            block.call *args
+#          rescue => e
+#            th.raise e
+#          ensure
+#            release
+#          end end end
+#    end
+#    def max=(size) @mutex.synchronize { @max = size } end
+#   private
+#    def release
+#      @mutex.synchronize do
+#        @count -= 1
+#        @cond.signal
+#      end
+#    end
+#  end
+#
+#  VERSION = '0.0.2'
+#
+#  def self.tempfile name = nil
+#    require 'tempfile'
+#    tf = Tempfile.new name
+#    yield tf
+#  ensure
+#    tf.close true
+#  end
+#
+#  def self.start_daemon *args, &block
+#    :$VERBOSE.temporary nil do
+#      #EndData.close if $leftovers
+#      Process.fork do
+#        fork and exit
+#        trap( 'INT' ) { Thread.current.kill }
+#        $stderr = $stdout = $stdin = NullDevice.new
+#        Process.setsid
+#        block.call( *args )
+#      end
+#    end
+#  end
+#
+#  def self.term_size
+#    require 'curses'
+#    Curses.init_screen
+#    x, y = Curses.cols, Curses.lines
+#    Curses.close_screen
+#    [x, y]
+#  ensure
+#    Curses.close_screen
+#  end
+#
+#  def self.filename
+#    File.basename $0
+#  end
+#
+#  def self.create_key size = 16 # copied from cgi/session.rb
+#    require 'digest/md5'
+#    md5 = Digest::MD5::new
+#    md5.update(String(Time::now))
+#    md5.update(String(rand(0)))
+#    md5.update(String($$))
+#    md5.hexdigest[0,size]
+#  end
+#
+#module Kernel
+#
+#  def modules()    self.class.modules    end
+#  def module()     self.class.module     end
+#  def module_up()  self.class.module_up  end
+#  def modules_up() self.class.modules_up end
+#
+#end
+#
+#def required
+#  result = []
+#  $".each do |file|
+#    $:.each do |path|
+#      if File.exists?( path + '/' + file )
+#        result << (path + '/' + file)
+#        next
+#      end
+#    end
+#  end
+#  result
+#end
+#
+#def required? file
+#  (el = required.grep( /#{file}(\.rb|\.so)?$/ ).to_el).empty? ? false : el
+#end
+#
+#class Array
+#   def to_el # TODO better name
+#      size == 1 ? first : self
+#   end
+#end
+#
+#class Numeric
+#  def commify
+#    to_s.reverse.scan(/\d{3}|\d+/).join(',').reverse
+#  end
+#end
+#
+#class Float
+#  def to_s_cut x = 3
+#    to_s.scan(/\d*\.\d{0,#{x}}/)
+#  end
+#end

data/lib/rextra/cutting.rb

@@ -1,6 +1,6 @@
 class Object
-  def meta() class << self; self end end
-  def meta_eval(&blk) meta.instance_eval( &blk ) end
+  def __meta() class << self; self end end
+  def meta_eval(&blk) __meta.instance_eval( &blk ) end
   def meta_def(name, &blk) meta_eval { define_method name, &blk } end
   def class_def name, &blk
     self.class.class_eval { define_method name, &blk }
@@ -46,8 +46,7 @@ module Rextra
     end
     class Do < Base
       def method_missing( sym, *args )
-        @master.map! do |e| e.send sym, *args end
-        self
+        @master.map do |e| e.send sym, *args end
       end
       def end() @master end
     end

data/lib/rextra/enddata.rb

@@ -1,80 +0,0 @@
-#--
-# rextra/enddata.rb -
-# USE "rdoc rextra/enddata.rb" to build the docs for this file.
-#++
-#
-# == WARNING!
-# load'ing or require'ing this file will write over anything in your DATA area
-#
-# == Example Use
-# TBD
-#
-# == Credits
-# Michael Garriss
-#
-# == Licence
-# TBD
-#
-
-#--
-# TODO review this
-#++
-
-require 'rextra'
-
-module Rapid
-
-  class LEFTOVERS
-    class << self
-      strip_methods
-      def method_missing sym, *args
-         $leftovers.send sym, *args
-      end
-    end
-  end
-
-  module EndData
-    def self.add_tag
-      file = File.new $0, 'a+'
-      file << "\n__END__\n"
-      $_DATA = file # holy hack
-    end
-    if defined? DATA
-      $_DATA = DATA
-    else
-      self.add_tag
-    end
-    def self.make_writable( pos = $_DATA.pos )
-      $_DATA.reopen $0, 'a+'
-      $_DATA.pos = pos
-    end
-    def self.clear( pos = $_DATA.pos )
-      $_DATA.truncate pos
-    end
-    def self.write str
-      $_DATA.write str
-    end
-    def self.method_missing sym, *args
-      $_DATA.send sym, *args
-    end
-  end
-
-  pos = $_DATA.pos
-  if (m = $_DATA.read).size > 0
-    $leftovers = Marshal.load( m )
-  else
-    $leftovers = {}
-  end
-  begin
-    EndData.make_writable pos
-    at_exit do
-      unless EndData.closed?
-        EndData.clear pos
-        EndData.write Marshal.dump( $leftovers )
-      end
-    end
-  #rescue
-  end
-
-end
-

data/test/tc_object.rb

@@ -25,8 +25,8 @@ class ObjectTest < Test::Unit::TestCase
   end
 
   def test_meta
-    assert meta
-    assert_equal meta.class, Class
+    assert __meta
+    assert_equal __meta.class, Class
   end
 
   def test_meta_eval

metadata

@@ -3,13 +3,13 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rextra
 version: !ruby/object:Gem::Version 
-  version: 2.0.1
-date: 2006-10-30 00:00:00 -07:00
+  version: 2.0.3
+date: 2006-11-02 00:00:00 -07:00
 summary: Ruby extras.
 require_paths: 
 - lib
 email: mgarriss@gmail.com
-homepage: 
+homepage: http://crookedhideout.com
 rubyforge_project: 
 description: 
 autorequire: rextra
@@ -35,7 +35,6 @@ files:
 - test/ts_rextra.rb
 - lib/rextra
 - lib/rextra.rb
-- lib/rextra/binding_of_caller.rb
 - lib/rextra/bleeding.rb
 - lib/rextra/cutting.rb
 - lib/rextra/debug.rb

data/lib/rextra/binding_of_caller.rb

@@ -1,85 +0,0 @@
-begin
-  require 'simplecc'
-rescue LoadError
-  # to satisfy rdoc
-  class Continuation #:nodoc:
-  end
-  def Continuation.create(*args, &block) # :nodoc:
-    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-    result ||= args
-    return *[cc, *result]
-  end
-end
-
-class Binding; end # for RDoc
-# This method returns the binding of the method that called your
-# method. It will raise an Exception when you're not inside a method.
-#
-# It's used like this:
-#   def inc_counter(amount = 1)
-#     Binding.of_caller do |binding|
-#       # Create a lambda that will increase the variable 'counter'
-#       # in the caller of this method when called.
-#       inc = eval("lambda { |arg| counter += arg }", binding)
-#       # We can refer to amount from inside this block safely.
-#       inc.call(amount)
-#     end
-#     # No other statements can go here. Put them inside the block.
-#   end
-#   counter = 0
-#   2.times { inc_counter }
-#   counter # => 2
-#
-# Binding.of_caller must be the last statement in the method.
-# This means that you will have to put everything you want to
-# do after the call to Binding.of_caller into the block of it.
-# This should be no problem however, because Ruby has closures.
-# If you don't do this an Exception will be raised. Because of
-# the way that Binding.of_caller is implemented it has to be
-# done this way.
-def Binding.of_caller(&block)
-  old_critical = Thread.critical
-  Thread.critical = true
-  count = 0
-  cc, result, error, extra_data = Continuation.create(nil, nil)
-  error.call if error
-
-  tracer = lambda do |*args|
-    type, context, extra_data = args[0], args[4], args
-    if type == "return"
-      count += 1
-      # First this method and then calling one will return --
-      # the trace event of the second event gets the context
-      # of the method which called the method that called this
-      # method.
-      if count == 2
-        # It would be nice if we could restore the trace_func
-        # that was set before we swapped in our own one, but
-        # this is impossible without overloading set_trace_func
-        # in current Ruby.
-        set_trace_func(nil)
-        cc.call(eval("binding", context), nil, extra_data)
-      end
-    elsif type == "line" then
-      nil
-    elsif type == "c-return" and extra_data[3] == :set_trace_func then
-      nil
-    else
-      set_trace_func(nil)
-      error_msg = "Binding.of_caller used in non-method context or " +
-        "trailing statements of method using it aren't in the block."
-      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
-    end
-  end
-
-  unless result
-    set_trace_func(tracer)
-    return nil
-  else
-    Thread.critical = old_critical
-    case block.arity
-      when 1 then yield(result)
-      else yield(result, extra_data)        
-    end
-  end
-end