rextra 2.0

data/lib/rextra/binding_of_caller.rb

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

data/lib/rextra/bleeding.rb

@@ -0,0 +1,233 @@
+#--
+# rapid/rextra.rb
+# USE "rdoc rapid/rextra.rb" to build the docs for this file.
+#++
+#
+# == Example Use
+# TBD
+#
+# == Credits
+# Michael Garriss
+#
+# == 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
+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

@@ -0,0 +1,66 @@
+class Object
+  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 }
+  end
+  def blank?
+    if    respond_to? :empty? then empty?
+    elsif respond_to? :zero?  then zero?
+    else !self
+    end
+  end
+end
+# -----------------------------------------------------------------------------
+class Module
+  def act_on_methods *meths
+    (meths.empty? ? instance_methods : meths).each do |meth|
+      yield meth unless %w{__id__ __send__}.include? meth
+    end
+  end
+  def undef_methods *meths
+    act_on_methods *meths do |meth|
+      undef_method meth
+    end
+  end
+  def empty_methods *meths
+    act_on_methods *meths do |meth|
+      class_def meth do nil end
+    end
+  end
+end
+class SimpleObject
+  undef_methods
+end
+# -----------------------------------------------------------------------------
+module Rextra
+  module Enumerable
+    class Base < SimpleObject
+      def initialize( master ) @master = master end
+    end
+    class All < Base
+      def method_missing( sym, *args )
+        @master.map do |e| e.send sym, *args end
+      end
+    end
+    class Do < Base
+      def method_missing( sym, *args )
+        @master.map! do |e| e.send sym, *args end
+        self
+      end
+      def end() @master end
+    end
+  end
+end
+module Enumerable
+  def all() Rextra::Enumerable::All.new self end
+  def do () Rextra::Enumerable::Do.new  self end
+end
+# -----------------------------------------------------------------------------
+#module Kernel
+#  def caller_name deep = 1
+#    /:in `(\S*)'$/.match(caller[deep])[1]
+#  end
+#  def method_name() caller_name end
+#end

data/lib/rextra/enddata.rb

@@ -0,0 +1,80 @@
+#--
+# 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/lib/rextra.rb

@@ -0,0 +1 @@
+require 'rextra/cutting'

data/test/tc_kernel.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require './lib/rextra/cutting'
+
+class KernelTest < Test::Unit::TestCase
+  def foo() bar end
+  def bar() baz end
+  def baz() caller_name end
+
+  def test_caller_name
+    assert_equal baz, 'test_caller_name'
+    assert_equal bar, 'bar'
+    assert_equal foo, 'bar'
+  end
+
+  def foo2() bar end
+  def bar2() baz end
+  def baz2() method_name end
+
+  def test_method_name
+    name = method_name
+    assert_equal name, 'test_method_name'
+    assert_equal baz2, 'baz2'
+    assert_equal bar2, 'baz2'
+    assert_equal foo2, 'baz2'
+  end
+end

data/test/tc_module.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require './lib/rextra/cutting'
+
+class ModuleTest < Test::Unit::TestCase
+  def test_act_on_methods
+    assert true
+  end
+end

data/test/tc_object.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require './lib/rextra/cutting'
+
+class ObjectTest < Test::Unit::TestCase
+  def test_blank?
+    assert nil.blank?
+    assert false.blank?
+    assert [].blank?
+    assert "".blank?
+    assert Hash.new.blank?
+    assert( !5.blank? )
+    assert( !true.blank? )
+    assert( ![1].blank? )
+    assert( !"1".blank? )
+  end
+
+  class Foo; end
+
+  def test_class_def
+    foo = Foo.new
+    assert_nothing_raised { foo.class_def(:foo) { 23 } }
+    assert_nothing_raised { foo.class_def(:bar) { "this" } }
+    assert_equal foo.foo, 23
+    assert_equal foo.bar, "this"
+  end
+
+  def test_meta
+    assert meta
+    assert_equal meta.class, Class
+  end
+
+  def test_meta_eval
+    assert_nothing_raised { meta_eval { } }
+    assert_equal meta_eval { @foo = 10 }, 10
+    assert_equal meta_eval { @foo }, 10
+    assert_equal( class << self; @foo end, 10 )
+  end
+
+  class Bar; end
+
+  def test_class_def
+    foo = Bar.new
+    assert_nothing_raised { foo.meta_def(:foo) { 23 } }
+    assert_nothing_raised { foo.meta_def(:bar) { "this" } }
+    assert_equal foo.foo, 23
+    assert_equal foo.bar, "this"
+    assert_equal meta_eval { foo.foo }, 23
+  end
+end

data/test/ts_rextra.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+
+# cutting
+require 'test/tc_object'
+require 'test/tc_module'
+#require 'test/tc_kernel'
+
+# bleeding
+#require 'test/bleeding/tc_kernel'

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: rextra
+version: !ruby/object:Gem::Version 
+  version: "2.0"
+date: 2006-10-24 00:00:00 -06:00
+summary: Ruby extras.
+require_paths: 
+- lib
+email: mgarriss@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: rextra
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Michael Garriss
+files: 
+- test/tc_kernel.rb
+- test/tc_module.rb
+- test/tc_object.rb
+- 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/enddata.rb
+- README
+test_files: 
+- test/ts_rextra.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+