Skip to content
Browse files

Initial import

git-svn-id: http://evil-ruby.googlecode.com/svn/trunk@2 faa2aa60-282d-0410-b094-b58f524adde5
  • Loading branch information...
1 parent 1182daf commit 06f68fde1e6f1e9e4e3f8cf11caeb82eb82173f4 florgro committed Apr 2, 2007
Showing with 2,369 additions and 0 deletions.
  1. +56 −0 COPYING
  2. +7 −0 NEWS
  3. +15 −0 README
  4. +109 −0 Rakefile
  5. +691 −0 lib/evil.rb
  6. +1,360 −0 setup.rb
  7. +8 −0 test/tc_all.rb
  8. +11 −0 test/tc_inline.rb
  9. +112 −0 test/test-extract.rb
View
56 COPYING
@@ -0,0 +1,56 @@
+evil-ruby is copyrighted free software by Florian Gross <flgr@ccan.de>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see http://www.gnu.org/licenses/gpl.html), or the conditions below:
+
+ 1. You may make and give away verbatim copies of the source form of the
+ software without restriction, provided that you duplicate all of the
+ original copyright notices and associated disclaimers.
+
+ 2. You may modify your copy of the software in any way, provided that
+ you do at least ONE of the following:
+
+ a) place your modifications in the Public Domain or otherwise
+ make them Freely Available, such as by posting said
+ modifications to Usenet or an equivalent medium, or by allowing
+ the author to include your modifications in the software.
+
+ b) use the modified software only within your corporation or
+ organization.
+
+ c) give non-standard binaries non-standard names, with
+ instructions on where to get the original software distribution.
+
+ d) make other distribution arrangements with the author.
+
+ 3. You may distribute the software in object code or binary form,
+ provided that you do at least ONE of the following:
+
+ a) distribute the binaries and library files of the software,
+ together with instructions (in the manual page or equivalent)
+ on where to get the original distribution.
+
+ b) accompany the distribution with the machine-readable source of
+ the software.
+
+ c) give non-standard binaries non-standard names, with
+ instructions on where to get the original software distribution.
+
+ d) make other distribution arrangements with the author.
+
+ 4. You may modify and include the part of the software into any other
+ software (possibly commercial). But some files in the distribution
+ are not written by the author, so that they are not under these terms.
+
+ For the list of those files and their copying conditions, see the
+ file LEGAL.
+
+ 5. The scripts and library files supplied as input to or produced as
+ output from the software do not automatically fall under the
+ copyright of the software, but belong to whomever generated them,
+ and may be sold commercially, and may be aggregated with this
+ software.
+
+ 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE.
View
7 NEWS
@@ -0,0 +1,7 @@
+= NEWS
+
+This file sums up important changes that happened between releases.
+
+== evil-ruby 0.1.0
+* Fixed to work in Ruby 1.9 as well as 1.8
+* Removed features that caused crashs
View
15 README
@@ -0,0 +1,15 @@
+= README for evil-ruby
+
+Extends Ruby's semantics by accessing its internals from pure Ruby code.
+
+
+== Installation
+
+De-compress archive and enter its top directory. Then type:
+
+ ($ su)
+ # ruby setup.rb
+
+This simple step installs this program under the default location of Ruby
+libraries. You can also install files into your favorite directory by supplying
+setup.rb with some options. Try "ruby setup.rb --help".
View
109 Rakefile
@@ -0,0 +1,109 @@
+require 'rake'
+require 'rake/packagetask'
+require 'rake/rdoctask'
+require 'find'
+
+readme = File.read("README").gsub("\r\n", "\n")
+author_line = readme[/^\*\s*Author:.+$/].split(/\s+/, 2)[1] rescue nil
+
+# Manual globals
+
+PKG_AUTOREQUIRE = nil
+PKG_RUBY_VERSION = '>= 1.8.4'
+PKG_GEM_DEPENDENCIES = {}
+PKG_RDOC_FILES = ['README', 'NEWS']
+PKG_RDOC_OPTIONS = %w(--all --main README --title #{PKG_NAME})
+PKG_FILES = PKG_RDOC_FILES + ['COPYING', 'setup.rb', 'Rakefile']
+
+# Automatic globals
+
+PKG_NAME, PKG_VERSION = *File.read("NEWS")[/^==.+$/].split(/\s+/)[1..2]
+PKG_DESCRIPTION = readme.split(/\n{3,}/)[0].sub(/^=.+$\s*/, "") rescue nil
+PKG_SUMMARY = readme[/^=.+$/].split(/--/)[1].strip rescue PKG_DESCRIPTION
+PKG_HOMEPAGE = readme[/^\*\s*Homepage:.+$/].split(/\s+/, 2)[1] rescue nil
+PKG_EMAIL = author_line[/<(.+)>/, 1] rescue nil
+PKG_AUTHOR = author_line.sub(PKG_EMAIL, "").sub("<>", "").strip rescue nil
+
+Find.find('lib/', 'test/', 'bin/') do |file|
+ if FileTest.directory?(file) and file[/\.svn/i] then
+ Find.prune
+ elsif !file[/\.DS_Store/i] then
+ PKG_FILES << file
+ end
+end
+
+PKG_FILES.reject! { |file| !File.file?(file) }
+
+PKG_EXE_FILES, PKG_LIB_FILES = *%w(bin/ lib/).map do |dir|
+ PKG_FILES.grep(/#{dir}/i).reject { |f| File.directory?(f) }
+end
+
+PKG_EXE_FILES.map! { |exe| exe.sub(%r(^bin/), "") }
+
+# Tasks
+
+task :default => :test
+
+# Test task
+if File.exist?("test/") then
+ require 'rake/testtask'
+
+ Rake::TestTask.new do |test|
+ test.test_files = ['test/tc_all.rb']
+ end
+else
+ task :test do
+ puts "No tests to run"
+ end
+end
+
+# Doc task
+Rake::RDocTask.new do |rd|
+ rd.rdoc_files.include(PKG_LIB_FILES, PKG_RDOC_FILES)
+ rd.options += PKG_RDOC_OPTIONS
+end
+
+# Tar task
+Rake::PackageTask.new(PKG_NAME, PKG_VERSION) do |pkg|
+ pkg.need_tar = true
+ pkg.package_files = PKG_FILES
+end
+
+# Gem task
+begin
+ require 'rake/gempackagetask'
+
+ spec = Gem::Specification.new do |spec|
+ spec.name = PKG_NAME
+ spec.version = PKG_VERSION
+ spec.summary = PKG_SUMMARY
+ spec.description = PKG_DESCRIPTION
+
+ spec.homepage = PKG_HOMEPAGE
+ spec.email = PKG_EMAIL
+ spec.author = PKG_AUTHOR
+
+ spec.has_rdoc = true
+ spec.extra_rdoc_files = PKG_RDOC_FILES
+ spec.rdoc_options += PKG_RDOC_OPTIONS
+
+ if File.exist?("test/") then
+ spec.test_files = ['test/tc_all.rb']
+ end
+
+ spec.required_ruby_version = PKG_RUBY_VERSION
+ (PKG_GEM_DEPENDENCIES || {}).each do |name, version|
+ spec.add_dependency(name, version)
+ end
+
+ spec.files = PKG_FILES
+ spec.executables = PKG_EXE_FILES
+ spec.autorequire = PKG_AUTOREQUIRE
+ end
+
+ Rake::GemPackageTask.new(spec) do |pkg|
+ pkg.need_zip = true
+ pkg.need_tar = true
+ end
+rescue LoadError
+end
View
691 lib/evil.rb
@@ -0,0 +1,691 @@
+# vim:sw=2
+# Written in 2004 by Florian Gross <flgr@ccan.de> and
+# Mauricio Julio Fernández Pradier <batsman.geo@yahoo.com>
+#
+# This is licensed under the same license as Ruby.
+
+module RubyInternal
+ Is_1_8 = RUBY_VERSION[/\A1.[678]/]
+end
+
+require 'dl'
+unless RubyInternal::Is_1_8
+ require 'dl/value'
+ require 'dl/import'
+end
+require 'dl/struct'
+
+# Provides low-level access to Ruby's internals. Be
+# careful when using this directly, because you can
+# break Ruby with it.
+module RubyInternal
+ DL::CPtr = DL::PtrData if Is_1_8
+ DL::SIZEOF_LONG = DL.sizeof("l") if Is_1_8
+
+ unless Is_1_8
+ class ::DL::CPtr
+ alias :old_store :[]=
+ def []=(idx, *args)
+ if args.size == 1 and args[0].is_a?(String) then
+ args[0] = args[0].ord
+ end
+
+ old_store(idx, *args)
+ end
+ end
+ end
+
+ extend self
+ importer = Is_1_8 ? DL::Importable : DL::Importer
+ extend importer
+
+ dlload()
+
+ if Is_1_8
+ def typealias(new, old)
+ super(new, nil, nil, nil, old)
+ end
+ end
+
+ Qfalse = 0
+ Qtrue = 2
+ Qnil = 4
+ Qundef = 6
+
+ T_NONE = 0x00
+ T_NIL = 0x01
+ T_OBJECT = 0x02
+ T_CLASS = 0x03
+ T_ICLASS = 0x04
+ T_MODULE = 0x05
+ T_FLOAT = 0x06
+ T_STRING = 0x07
+ T_REGEXP = 0x08
+ T_ARRAY = 0x09
+ T_FIXNUM = 0x0a
+ T_HASH = 0x0b
+ T_STRUCT = 0x0c
+ T_BIGNUM = 0x0d
+ T_FILE = 0x0e
+
+ if Is_1_8
+ T_TRUE = 0x20
+ T_FALSE = 0x21
+ T_DATA = 0x22
+ T_MATCH = 0x23
+ T_SYMBOL = 0x24
+
+ T_BLOCK = 0x3b
+ T_UNDEF = 0x3c
+ T_VARMAP = 0x3d
+ T_SCOPE = 0x3e
+ T_NODE = 0x3f
+
+ T_MASK = 0x3f
+ else # 1.9 or higher
+ T_TRUE = 0x10
+ T_FALSE = 0x11
+ T_DATA = 0x12
+ T_MATCH = 0x13
+ T_SYMBOL = 0x14
+
+ T_BLOCK = 0x1b
+ T_UNDEF = 0x1c
+ T_VARMAP = 0x1d
+ T_SCOPE = 0x1e
+ T_NODE = 0x1f
+
+ T_MASK = 0x1f
+ end # constants
+
+ typealias "VALUE", "unsigned long"
+ typealias "ID", "unsigned long"
+ typealias "ulong", "unsigned long"
+ Basic = ["long flags", "VALUE klass"]
+
+ RBasic = struct Basic
+
+ RObject = struct(Basic + [
+ "st_table *iv_tbl"
+ ])
+
+ RClass = struct(Basic + [
+ "st_table *iv_tbl",
+ "st_table *m_tbl",
+ "VALUE super"
+ ])
+
+ RModule = RClass
+
+ RFloat = struct(Basic + [
+ "double value"
+ ])
+
+ RString = struct(Basic + [
+ "long len",
+ "char *ptr",
+ "long capa"
+ ])
+
+ RArray = struct(Basic + [
+ "long len",
+ "long capa",
+ "VALUE *ptr"
+ ])
+
+ RRegexp = struct(Basic + [
+ "re_pattern_buffer *ptr",
+ "long len",
+ "char *str"
+ ])
+
+ RHash = struct(Basic + [
+ "st_table *tbl",
+ "int iter_lev",
+ "VALUE ifnone"
+ ])
+
+ RFile = struct(Basic + [
+ "OpenFile *fptr"
+ ])
+
+ RData = struct(Basic + [
+ "void *dmark",
+ "void *dfree",
+ "void *data"
+ ])
+
+ RStruct = struct(Basic + [
+ "long len",
+ "VALUE *ptr"
+ ])
+
+ RBignum = struct(Basic + [
+ "char sign",
+ "long len",
+ "void *digits"
+ ])
+
+ DMethod = struct [
+ "VALUE klass",
+ "VALUE rklass",
+ "long id",
+ "long oid",
+ "void *body"
+ ]
+
+ FrameBase = [
+ "VALUE frame_self",
+ "int frame_argc",
+ "VALUE *frame_argv",
+ "ID frame_last_func",
+ "ID frame_orig_func",
+ "VALUE frame_last_class",
+ "FRAME *frame_prev",
+ "FRAME *frame_tmp",
+ "RNode *frame_node",
+ "int frame_iter",
+ "int frame_flags",
+ "ulong frame_uniq"
+ ]
+
+ Frame = struct FrameBase
+
+ Block = struct([
+ "NODE *var",
+ "NODE *body",
+ "VALUE self",
+ ] + FrameBase + [
+ "SCOPE *scope",
+ "VALUE klass",
+ "NODE *cref",
+ "int iter",
+ "int vmode",
+ "int flags",
+ "int uniq",
+ "RVarmap *dyna_vars",
+ "VALUE orig_thread",
+ "VALUE wrapper",
+ "VALUE block_obj",
+ "BLOCK *outer",
+ "BLOCK *prev"
+ ])
+
+ STD_HASH_TYPE = struct [
+ "void *compare",
+ "void *hash"
+ ]
+
+ typealias "ST_DATA_T", "unsigned long"
+
+ ST_TABLE_ENTRY = struct [
+ "int hash",
+ "ST_DATA_T key",
+ "ST_DATA_T record",
+ "ST_TABLE_ENTRY *next"
+ ]
+
+ ST_TABLE = struct [
+ "ST_HASH_TYPE *type",
+ "int num_bins",
+ "int num_entries",
+ "ST_TABLE_ENTRY **bins"
+ ]
+
+ FL_USHIFT = 11
+ FL_USER0 = 1 << (FL_USHIFT + 0)
+ FL_USER1 = 1 << (FL_USHIFT + 1)
+ FL_USER2 = 1 << (FL_USHIFT + 2)
+ FL_USER3 = 1 << (FL_USHIFT + 3)
+ FL_USER4 = 1 << (FL_USHIFT + 4)
+ FL_USER5 = 1 << (FL_USHIFT + 5)
+ FL_USER6 = 1 << (FL_USHIFT + 6)
+ FL_USER7 = 1 << (FL_USHIFT + 7)
+
+ FL_SINGLETON = FL_USER0
+ FL_MARK = 1 << 6
+ FL_FINALIZE = 1 << 7
+ FL_TAINT = 1 << 8
+ FL_EXIVAR = 1 << 9
+ FL_FREEZE = 1 << 10
+
+ # Executes a block of code that changes
+ # internal Ruby structures. This will
+ # make sure that neither the GC nor other
+ # Threads are run while the block is
+ # getting executed.
+ def critical
+ begin
+ if Is_1_8 then
+ old_critical = Thread.critical
+ Thread.critical = true
+ else
+ # Is it OK to do nothing on 1.9?
+ end
+
+ disabled_gc = !GC.disable
+
+ yield
+ ensure
+ GC.enable if disabled_gc
+ Thread.critical = old_critical if Is_1_8
+ end
+ end
+
+ module EmptyModule; end
+ def empty_iclass_ptr(force_new = false)
+ @empty_iclass_ptr ||= nil # avoid warning
+ return @empty_iclass_ptr if @empty_iclass_ptr and not force_new
+ result = Object.new
+ iptr = result.internal_ptr
+ ires = result.internal
+ newires = RClass.new(result.internal_ptr)
+ critical do
+ ires.flags &= ~T_MASK
+ ires.flags |= T_ICLASS
+ ires.klass = EmptyModule.internal_ptr.to_i
+ newires.m_tbl = EmptyModule.internal.m_tbl
+ end
+ @empty_iclass_ptr = iptr
+ return iptr
+ end
+end
+
+class Object
+ # Returns the singleton class of an Object.
+ # This is just a simple convenience method.
+ #
+ # obj = Object.new
+ # obj.singleton_class.class_eval do
+ # def x; end
+ # end
+ # obj.respond_to?(:x) # => true
+ def singleton_class
+ class << self; self; end
+ end
+ alias :meta_class :singleton_class
+
+ def internal_class
+ # we use this instead of a "cleaner" method (such as a
+ # hash with class => possible flags associations) because
+ # (1) the number of internal types won't change
+ # (2) it'd be slower
+ case internal_type
+ when RubyInternal::T_OBJECT
+ RubyInternal::RObject
+ when RubyInternal::T_CLASS, RubyInternal::T_ICLASS, RubyInternal::T_MODULE
+ RubyInternal::RModule
+ when RubyInternal::T_FLOAT
+ RubyInternal::RFloat
+ when RubyInternal::T_STRING
+ RubyInternal::RString
+ when RubyInternal::T_REGEXP
+ RubyInternal::RRegexp
+ when RubyInternal::T_ARRAY
+ RubyInternal::RArray
+ when RubyInternal::T_HASH
+ RubyInternal::RHash
+ when RubyInternal::T_STRUCT
+ RubyInternal::RStruct
+ when RubyInternal::T_BIGNUM
+ RubyInternal::RBignum
+ when RubyInternal::T_FILE
+ RubyInternal::RFile
+ when RubyInternal::T_DATA
+ RubyInternal::RData
+ else
+ raise "No internal class for #{self}"
+ end
+ end
+
+ def internal_type
+ case self
+ when Fixnum then RubyInternal::T_FIXNUM
+ when NilClass then RubyInternal::T_NIL
+ when FalseClass then RubyInternal::T_FALSE
+ when TrueClass then RubyInternal::T_TRUE
+ when Symbol then RubyInternal::T_SYMBOL
+ else
+ RubyInternal::RBasic.new(self.internal_ptr).flags & RubyInternal::T_MASK
+ end
+ end
+
+ def internal_ptr(*args)
+ raise(ArgumentError, "Can't get pointer to direct values.") \
+ if direct_value?
+ pos = self.object_id * 2
+ DL::CPtr.new(pos, *args)
+ end
+
+ def internal
+ raise(ArgumentError, "Can't get internal representation" +
+ " of direct values") \
+ if direct_value?
+
+ propagate_magic = nil # forward "declaration"
+ do_magic = lambda do |obj, id|
+ addr = obj.instance_eval { send(id) }
+ sklass = class << obj; self end
+ sklass.instance_eval do
+ define_method(id) do
+ case addr
+ when 0
+ return nil
+ else
+ begin
+ r = RubyInternal::RClass.new DL::CPtr.new(addr, 5 * DL::SIZEOF_LONG)
+ rescue RangeError
+ r = RubyInternal::RClass.new DL::CPtr.new(addr - 2**32, 5 * DL::SIZEOF_LONG)
+ end
+ propagate_magic.call r, true
+ end
+ class << r; self end.instance_eval { define_method(:to_i) { addr } }
+ r
+ end
+ end
+ end
+
+ propagate_magic = lambda do |obj, dosuper|
+ do_magic.call(obj, :klass)
+ do_magic.call(obj, :super) if dosuper
+ end
+
+ klass = internal_class
+ r = klass.new(internal_ptr)
+
+ case klass
+ when RubyInternal::RClass, RubyInternal::RModule
+ propagate_magic.call r, true
+ else
+ propagate_magic.call r, false
+ end
+ r
+ end
+
+ # Unfreeze a frozen Object. You will be able to make
+ # changes to the object again.
+ #
+ # obj = "Hello World".freeze
+ # obj.frozen? # => true
+ # obj.unfreeze
+ # obj.frozen? # => false
+ # obj.sub!("World", "You!")
+ # obj # => "Hello You!"
+ def unfreeze
+ if $SAFE > 0
+ raise(SecurityError, "Insecure operation `unfreeze' at level #{$SAFE}")
+ end
+
+ return self if direct_value?
+
+ self.internal.flags &= ~RubyInternal::FL_FREEZE
+ return self
+ end
+
+ # Returns true if the Object is one of the Objects which
+ # Ruby stores directly. Fixnums, Symbols, true, false and
+ # nil all are direct values.
+ #
+ # 5.direct_value? # => true
+ # :foo.direct_value? # => true
+ # "foo".direct_value? # => false
+ # 5.0.direct_value? # => false
+ def direct_value?
+ [Fixnum, Symbol, NilClass, TrueClass, FalseClass].any? do |klass|
+ klass === self
+ end
+ end
+
+ alias :immediate_value? :direct_value?
+
+ # Changes the class of an Object to a new one. This will
+ # change the methods available on the Object.
+ #
+ # foo_klass = Class.new {}
+ # obj = Object.new
+ # obj.class = foo_klass
+ # obj.class # => foo_klass
+ def class=(new_class)
+ raise(ArgumentError, "Can't change class of direct value.") \
+ if direct_value?
+ raise(ArgumentError, "Class has to be a Class.") \
+ unless new_class.is_a? Class
+ if self.class.to_internal_type and
+ new_class.to_internal_type and
+ self.class.to_internal_type != new_class.to_internal_type
+ msg = "Internal type of class isn't compatible with " +
+ "internal type of object."
+ raise(ArgumentError, msg)
+ end
+ if self.class.to_internal_type == RubyInternal::T_DATA
+ msg = "Internal type of class isn't compatible with " +
+ "internal type of object. (Both are T_DATA, but " +
+ "that doesn't imply that they're compatible.)"
+ raise(ArgumentError, msg)
+ end
+ self.internal.klass = new_class.internal_ptr.to_i
+ return self
+ end
+
+ # Shares the instance variables of two Objects with each
+ # other. If you make a change to such shared instance
+ # variables they will change at both Objects.
+ def share_instance_variables(from_obj)
+ raise(ArgumentError, "Can't share instance variables of" +
+ "direct values") \
+ if direct_value?
+ #FIXME: memleak (?)
+ self.internal.iv_tbl = from_obj.internal.iv_tbl
+ return instance_variables
+ end
+
+ # The Object will acquire a copy of +obj+'s singleton methods.
+ def grab_singleton_methods(obj)
+ original_sklass = class << obj; self end # make sure the singleton class is there
+ RubyInternal::critical do
+ original_sklass.internal.flags &= ~ RubyInternal::FL_SINGLETON
+ class << self; self end.module_eval{ include original_sklass.as_module }
+ original_sklass.internal.flags |= RubyInternal::FL_SINGLETON
+ end
+ end
+end
+
+class Class
+ # Changes the super class of a Class.
+ def superclass=(new_class)
+ k1 = superclass
+ if new_class.nil?
+ self.internal.super = RubyInternal.empty_iclass_ptr.to_i
+ else
+ raise(ArgumentError, "Value of class has to be a Class.") \
+ unless new_class.is_a?(Class)
+ raise(ArgumentError, "superclass= would create circular " +
+ "inheritance structure.") \
+ if new_class.ancestors.include?(self)
+ raise(ArgumentError, "Superclass type incompatible with own type.") \
+ if new_class.to_internal_type != self.to_internal_type
+ self.internal.super = new_class.internal_ptr.to_i
+ end
+ # invalidate the method cache
+ k1.instance_eval { public :__send__ rescue nil }
+ end
+
+ def to_internal_type
+ begin
+ self.allocate.internal.flags & RubyInternal::T_MASK
+ rescue
+ if self.superclass
+ self.superclass.to_internal_type
+ else
+ nil
+ end
+ end
+ end
+
+ # Will return the Class converted to a Module.
+ def as_module
+ result = nil
+ RubyInternal.critical do
+ fl_singleton = self.internal.flags & RubyInternal::FL_SINGLETON
+ begin
+ self.internal.flags &= ~ RubyInternal::FL_SINGLETON
+ result = self.clone
+ ensure
+ self.internal.flags |= fl_singleton
+ end
+ o = RubyInternal::RObject.new(result.internal_ptr)
+ o.flags &= ~ RubyInternal::T_MASK
+ o.flags |= RubyInternal::T_MODULE
+ o.klass = Module.internal_ptr.to_i
+ end
+ return result
+ end
+
+ # This will allow your Classes to inherit from multiple
+ # other Classes. If two Classes define the same method
+ # the last one will be used.
+ #
+ # bar_klass = Class.new { def bar; end }
+ # qux_klass = Class.new { def qux; end }
+ # foo_klass = Class.new do
+ # inherit bar_klass, qux_klass
+ # end
+ # foo = foo_klass.new
+ # foo.respond_to?(:bar) # => true
+ # foo.respond_to?(:qux) # => true
+ def inherit(*sources)
+ sources.each do |klass|
+ raise(ArgumentError, "Cyclic inherit detected.") \
+ if klass.ancestors.include?(self)
+ raise(ArgumentError, "Can only inherit from Classes.") \
+ unless klass.is_a?(Class)
+ # the following is needed cause otherwise we could end up inheriting
+ # e.g. a method from String that would assume the object has some
+ # internal structure (RString) and crash otherwise...
+ unless klass.to_internal_type == self.to_internal_type
+ raise(ArgumentError, "Inherit needs consistent internal types.")
+ end
+ include klass.as_module
+ extend klass.singleton_class.as_module
+ end
+ end
+ private :inherit
+end
+
+# Like Object, but this provides no methods at all.
+# You can derivate your own Classes from this Class
+# if you want them to have no preset methods.
+#
+# klass = Class.new(KernellessObject) { def inspect; end }
+# klass.new.methods # raises NoMethodError
+#
+# Classes that are derived from KernellessObject
+# won't call #initialize from .new by default.
+#
+# It is a good idea to define #inspect for subclasses,
+# because Ruby will go into an endless loop when trying
+# to create an exception message if it is not there.
+class KernellessObject
+ class << self
+ def to_internal_type; ::Object.to_internal_type; end
+
+ def allocate
+ obj = ::Object.allocate
+ obj.class = self
+ return obj
+ end
+
+ alias :new :allocate
+ end
+
+ self.superclass = nil
+end
+
+class UnboundMethod
+ # Like UnboundMethod#bind this will bind an UnboundMethod
+ # to an Object. However this variant doesn't enforce class
+ # compatibility when it isn't needed. (It still needs
+ # compatible internal types however.)
+ #
+ # Currently it's also generally impossible to force_bind a
+ # foreign method to immediate objects.
+ #
+ # Here's an example:
+ #
+ # foo_klass = Class.new do
+ # def greet; "#{self.inspect} says 'Hi!'"; end
+ # end
+ # obj = []
+ # greet = foo_klass.instance_method(:greet)
+ # greet.bind(obj).call # raises TypeError
+ # greet.force_bind(obj).call # => "[] says 'Hi!'"
+ def force_bind(obj)
+ data = self.internal.data
+ source_class_addr = RubyInternal::DMethod.new(data).klass
+ source_class = ObjectSpace._id2ref(source_class_addr / 2)
+
+ if [Fixnum, Symbol, NilClass, TrueClass, FalseClass].any? do |klass|
+ klass <= source_class
+ end then
+ if not obj.is_a?(source_class) then
+ msg = "Immediate source class and non-immediate new " +
+ "receiver are incompatible"
+ raise(ArgumentError, msg)
+ else
+ return self.bind(obj)
+ end
+ end
+
+ if source_class.to_internal_type and
+ source_class.to_internal_type != RubyInternal::T_OBJECT and
+ source_class.to_internal_type != obj.class.to_internal_type
+ msg = "Internal type of source class and new receiver " +
+ "are incompatible"
+ raise(ArgumentError, msg)
+ end
+
+ result = nil
+ RubyInternal.critical do
+ prev_class = obj.internal.klass.to_i
+ begin
+ internal_obj = obj.internal
+ begin
+ internal_obj.klass = source_class_addr
+ result = self.bind(obj)
+ ensure
+ internal_obj.klass = prev_class
+ end
+ rescue TypeError
+ result = self.bind(obj)
+ end
+ end
+
+ return result
+ end
+end
+
+class Proc
+ def self
+ eval "self", self
+ end
+
+ # FIXME: look into possible signedness issues for large Fixnums (2**30 and higher)
+ def self=(new_self)
+ new_self_ptr = new_self.object_id
+ unless new_self.direct_value?
+ new_self_ptr = new_klass_ptr * 2
+ # new_self_ptr += 2 ** 32 if new_klass_ptr < 0 # FIXME: needed?
+ end
+ new_klass_ptr = class << new_self; self; end.object_id * 2 rescue nil.object_id
+ data = RubyInternal::RData.new(internal_ptr).data
+ block = RubyInternal::Block.new(data)
+
+ RubyInternal.critical do
+ block.self = new_self_ptr
+ block.klass = new_klass_ptr
+ end
+
+ return new_self
+ end
+ alias :context= :self=
+end
View
1,360 setup.rb
@@ -0,0 +1,1360 @@
+#
+# setup.rb
+#
+# Copyright (c) 2000-2004 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+#
+
+unless Enumerable.method_defined?(:map) # Ruby 1.4.6
+ module Enumerable
+ alias map collect
+ end
+end
+
+unless File.respond_to?(:read) # Ruby 1.6
+ def File.read(fname)
+ open(fname) {|f|
+ return f.read
+ }
+ end
+end
+
+def File.binread(fname)
+ open(fname, 'rb') {|f|
+ return f.read
+ }
+end
+
+# for corrupted windows stat(2)
+def File.dir?(path)
+ File.directory?((path[-1,1] == '/') ? path : path + '/')
+end
+
+
+class SetupError < StandardError; end
+
+def setup_rb_error(msg)
+ raise SetupError, msg
+end
+
+#
+# Config
+#
+
+if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg }
+ ARGV.delete(arg)
+ require arg.split(/=/, 2)[1]
+ $".push 'rbconfig.rb'
+else
+ require 'rbconfig'
+end
+
+def multipackage_install?
+ FileTest.directory?(File.dirname($0) + '/packages')
+end
+
+
+class ConfigItem
+ def initialize(name, template, default, desc)
+ @name = name.freeze
+ @template = template
+ @value = default
+ @default = default.dup.freeze
+ @description = desc
+ end
+
+ attr_reader :name
+ attr_reader :description
+
+ attr_accessor :default
+ alias help_default default
+
+ def help_opt
+ "--#{@name}=#{@template}"
+ end
+
+ def value
+ @value
+ end
+
+ def eval(table)
+ @value.gsub(%r<\$([^/]+)>) { table[$1] }
+ end
+
+ def set(val)
+ @value = check(val)
+ end
+
+ private
+
+ def check(val)
+ setup_rb_error "config: --#{name} requires argument" unless val
+ val
+ end
+end
+
+class BoolItem < ConfigItem
+ def config_type
+ 'bool'
+ end
+
+ def help_opt
+ "--#{@name}"
+ end
+
+ private
+
+ def check(val)
+ return 'yes' unless val
+ unless /\A(y(es)?|n(o)?|t(rue)?|f(alse))\z/i =~ val
+ setup_rb_error "config: --#{@name} accepts only yes/no for argument"
+ end
+ (/\Ay(es)?|\At(rue)/i =~ value) ? 'yes' : 'no'
+ end
+end
+
+class PathItem < ConfigItem
+ def config_type
+ 'path'
+ end
+
+ private
+
+ def check(path)
+ setup_rb_error "config: --#{@name} requires argument" unless path
+ path[0,1] == '$' ? path : File.expand_path(path)
+ end
+end
+
+class ProgramItem < ConfigItem
+ def config_type
+ 'program'
+ end
+end
+
+class SelectItem < ConfigItem
+ def initialize(name, template, default, desc)
+ super
+ @ok = template.split('/')
+ end
+
+ def config_type
+ 'select'
+ end
+
+ private
+
+ def check(val)
+ unless @ok.include?(val.strip)
+ setup_rb_error "config: use --#{@name}=#{@template} (#{val})"
+ end
+ val.strip
+ end
+end
+
+class PackageSelectionItem < ConfigItem
+ def initialize(name, template, default, help_default, desc)
+ super name, template, default, desc
+ @help_default = help_default
+ end
+
+ attr_reader :help_default
+
+ def config_type
+ 'package'
+ end
+
+ private
+
+ def check(val)
+ unless File.dir?("packages/#{val}")
+ setup_rb_error "config: no such package: #{val}"
+ end
+ val
+ end
+end
+
+class ConfigTable_class
+
+ def initialize(items)
+ @items = items
+ @table = {}
+ items.each do |i|
+ @table[i.name] = i
+ end
+ ALIASES.each do |ali, name|
+ @table[ali] = @table[name]
+ end
+ end
+
+ include Enumerable
+
+ def each(&block)
+ @items.each(&block)
+ end
+
+ def key?(name)
+ @table.key?(name)
+ end
+
+ def lookup(name)
+ @table[name] or raise ArgumentError, "no such config item: #{name}"
+ end
+
+ def add(item)
+ @items.push item
+ @table[item.name] = item
+ end
+
+ def remove(name)
+ item = lookup(name)
+ @items.delete_if {|i| i.name == name }
+ @table.delete_if {|name, i| i.name == name }
+ item
+ end
+
+ def new
+ dup()
+ end
+
+ def savefile
+ '.config'
+ end
+
+ def load
+ begin
+ t = dup()
+ File.foreach(savefile()) do |line|
+ k, v = *line.split(/=/, 2)
+ t[k] = v.strip
+ end
+ t
+ rescue Errno::ENOENT
+ setup_rb_error $!.message + "#{File.basename($0)} config first"
+ end
+ end
+
+ def save
+ @items.each {|i| i.value }
+ File.open(savefile(), 'w') {|f|
+ @items.each do |i|
+ f.printf "%s=%s\n", i.name, i.value if i.value
+ end
+ }
+ end
+
+ def [](key)
+ lookup(key).eval(self)
+ end
+
+ def []=(key, val)
+ lookup(key).set val
+ end
+
+end
+
+c = ::Config::CONFIG
+
+rubypath = c['bindir'] + '/' + c['ruby_install_name']
+
+major = c['MAJOR'].to_i
+minor = c['MINOR'].to_i
+teeny = c['TEENY'].to_i
+version = "#{major}.#{minor}"
+
+# ruby ver. >= 1.4.4?
+newpath_p = ((major >= 2) or
+ ((major == 1) and
+ ((minor >= 5) or
+ ((minor == 4) and (teeny >= 4)))))
+
+if c['rubylibdir']
+ # V < 1.6.3
+ _stdruby = c['rubylibdir']
+ _siteruby = c['sitedir']
+ _siterubyver = c['sitelibdir']
+ _siterubyverarch = c['sitearchdir']
+elsif newpath_p
+ # 1.4.4 <= V <= 1.6.3
+ _stdruby = "$prefix/lib/ruby/#{version}"
+ _siteruby = c['sitedir']
+ _siterubyver = "$siteruby/#{version}"
+ _siterubyverarch = "$siterubyver/#{c['arch']}"
+else
+ # V < 1.4.4
+ _stdruby = "$prefix/lib/ruby/#{version}"
+ _siteruby = "$prefix/lib/ruby/#{version}/site_ruby"
+ _siterubyver = _siteruby
+ _siterubyverarch = "$siterubyver/#{c['arch']}"
+end
+libdir = '-* dummy libdir *-'
+stdruby = '-* dummy rubylibdir *-'
+siteruby = '-* dummy site_ruby *-'
+siterubyver = '-* dummy site_ruby version *-'
+parameterize = lambda {|path|
+ path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix')\
+ .sub(/\A#{Regexp.quote(libdir)}/, '$libdir')\
+ .sub(/\A#{Regexp.quote(stdruby)}/, '$stdruby')\
+ .sub(/\A#{Regexp.quote(siteruby)}/, '$siteruby')\
+ .sub(/\A#{Regexp.quote(siterubyver)}/, '$siterubyver')
+}
+libdir = parameterize.call(c['libdir'])
+stdruby = parameterize.call(_stdruby)
+siteruby = parameterize.call(_siteruby)
+siterubyver = parameterize.call(_siterubyver)
+siterubyverarch = parameterize.call(_siterubyverarch)
+
+if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg }
+ makeprog = arg.sub(/'/, '').split(/=/, 2)[1]
+else
+ makeprog = 'make'
+end
+
+common_conf = [
+ PathItem.new('prefix', 'path', c['prefix'],
+ 'path prefix of target environment'),
+ PathItem.new('bindir', 'path', parameterize.call(c['bindir']),
+ 'the directory for commands'),
+ PathItem.new('libdir', 'path', libdir,
+ 'the directory for libraries'),
+ PathItem.new('datadir', 'path', parameterize.call(c['datadir']),
+ 'the directory for shared data'),
+ PathItem.new('mandir', 'path', parameterize.call(c['mandir']),
+ 'the directory for man pages'),
+ PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']),
+ 'the directory for man pages'),
+ PathItem.new('stdruby', 'path', stdruby,
+ 'the directory for standard ruby libraries'),
+ PathItem.new('siteruby', 'path', siteruby,
+ 'the directory for version-independent aux ruby libraries'),
+ PathItem.new('siterubyver', 'path', siterubyver,
+ 'the directory for aux ruby libraries'),
+ PathItem.new('siterubyverarch', 'path', siterubyverarch,
+ 'the directory for aux ruby binaries'),
+ PathItem.new('rbdir', 'path', '$siterubyver',
+ 'the directory for ruby scripts'),
+ PathItem.new('sodir', 'path', '$siterubyverarch',
+ 'the directory for ruby extentions'),
+ PathItem.new('rubypath', 'path', rubypath,
+ 'the path to set to #! line'),
+ ProgramItem.new('rubyprog', 'name', rubypath,
+ 'the ruby program using for installation'),
+ ProgramItem.new('makeprog', 'name', makeprog,
+ 'the make program to compile ruby extentions'),
+ SelectItem.new('shebang', 'all/ruby/never', 'ruby',
+ 'shebang line (#!) editing mode'),
+ BoolItem.new('without-ext', 'yes/no', 'no',
+ 'does not compile/install ruby extentions')
+]
+class ConfigTable_class # open again
+ ALIASES = {
+ 'std-ruby' => 'stdruby',
+ 'site-ruby-common' => 'siteruby', # For backward compatibility
+ 'site-ruby' => 'siterubyver', # For backward compatibility
+ 'bin-dir' => 'bindir',
+ 'bin-dir' => 'bindir',
+ 'rb-dir' => 'rbdir',
+ 'so-dir' => 'sodir',
+ 'data-dir' => 'datadir',
+ 'ruby-path' => 'rubypath',
+ 'ruby-prog' => 'rubyprog',
+ 'ruby' => 'rubyprog',
+ 'make-prog' => 'makeprog',
+ 'make' => 'makeprog'
+ }
+end
+multipackage_conf = [
+ PackageSelectionItem.new('with', 'name,name...', '', 'ALL',
+ 'package names that you want to install'),
+ PackageSelectionItem.new('without', 'name,name...', '', 'NONE',
+ 'package names that you do not want to install')
+]
+if multipackage_install?
+ ConfigTable = ConfigTable_class.new(common_conf + multipackage_conf)
+else
+ ConfigTable = ConfigTable_class.new(common_conf)
+end
+
+
+module MetaConfigAPI
+
+ def eval_file_ifexist(fname)
+ instance_eval File.read(fname), fname, 1 if File.file?(fname)
+ end
+
+ def config_names
+ ConfigTable.map {|i| i.name }
+ end
+
+ def config?(name)
+ ConfigTable.key?(name)
+ end
+
+ def bool_config?(name)
+ ConfigTable.lookup(name).config_type == 'bool'
+ end
+
+ def path_config?(name)
+ ConfigTable.lookup(name).config_type == 'path'
+ end
+
+ def value_config?(name)
+ case ConfigTable.lookup(name).config_type
+ when 'bool', 'path'
+ true
+ else
+ false
+ end
+ end
+
+ def add_config(item)
+ ConfigTable.add item
+ end
+
+ def add_bool_config(name, default, desc)
+ ConfigTable.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc)
+ end
+
+ def add_path_config(name, default, desc)
+ ConfigTable.add PathItem.new(name, 'path', default, desc)
+ end
+
+ def set_config_default(name, default)
+ ConfigTable.lookup(name).default = default
+ end
+
+ def remove_config(name)
+ ConfigTable.remove(name)
+ end
+
+end
+
+
+#
+# File Operations
+#
+
+module FileOperations
+
+ def mkdir_p(dirname, prefix = nil)
+ dirname = prefix + File.expand_path(dirname) if prefix
+ $stderr.puts "mkdir -p #{dirname}" if verbose?
+ return if no_harm?
+
+ # does not check '/'... it's too abnormal case
+ dirs = File.expand_path(dirname).split(%r<(?=/)>)
+ if /\A[a-z]:\z/i =~ dirs[0]
+ disk = dirs.shift
+ dirs[0] = disk + dirs[0]
+ end
+ dirs.each_index do |idx|
+ path = dirs[0..idx].join('')
+ Dir.mkdir path unless File.dir?(path)
+ end
+ end
+
+ def rm_f(fname)
+ $stderr.puts "rm -f #{fname}" if verbose?
+ return if no_harm?
+
+ if File.exist?(fname) or File.symlink?(fname)
+ File.chmod 0777, fname
+ File.unlink fname
+ end
+ end
+
+ def rm_rf(dn)
+ $stderr.puts "rm -rf #{dn}" if verbose?
+ return if no_harm?
+
+ Dir.chdir dn
+ Dir.foreach('.') do |fn|
+ next if fn == '.'
+ next if fn == '..'
+ if File.dir?(fn)
+ verbose_off {
+ rm_rf fn
+ }
+ else
+ verbose_off {
+ rm_f fn
+ }
+ end
+ end
+ Dir.chdir '..'
+ Dir.rmdir dn
+ end
+
+ def move_file(src, dest)
+ File.unlink dest if File.exist?(dest)
+ begin
+ File.rename src, dest
+ rescue
+ File.open(dest, 'wb') {|f| f.write File.binread(src) }
+ File.chmod File.stat(src).mode, dest
+ File.unlink src
+ end
+ end
+
+ def install(from, dest, mode, prefix = nil)
+ $stderr.puts "install #{from} #{dest}" if verbose?
+ return if no_harm?
+
+ realdest = prefix ? prefix + File.expand_path(dest) : dest
+ realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest)
+ str = File.binread(from)
+ if diff?(str, realdest)
+ verbose_off {
+ rm_f realdest if File.exist?(realdest)
+ }
+ File.open(realdest, 'wb') {|f|
+ f.write str
+ }
+ File.chmod mode, realdest
+
+ File.open("#{objdir_root()}/InstalledFiles", 'a') {|f|
+ if prefix
+ f.puts realdest.sub(prefix, '')
+ else
+ f.puts realdest
+ end
+ }
+ end
+ end
+
+ def diff?(new_content, path)
+ return true unless File.exist?(path)
+ new_content != File.binread(path)
+ end
+
+ def command(str)
+ $stderr.puts str if verbose?
+ system str or raise RuntimeError, "'system #{str}' failed"
+ end
+
+ def ruby(str)
+ command config('rubyprog') + ' ' + str
+ end
+
+ def make(task = '')
+ command config('makeprog') + ' ' + task
+ end
+
+ def extdir?(dir)
+ File.exist?(dir + '/MANIFEST')
+ end
+
+ def all_files_in(dirname)
+ Dir.open(dirname) {|d|
+ return d.select {|ent| File.file?("#{dirname}/#{ent}") }
+ }
+ end
+
+ REJECT_DIRS = %w(
+ CVS SCCS RCS CVS.adm .svn
+ )
+
+ def all_dirs_in(dirname)
+ Dir.open(dirname) {|d|
+ return d.select {|n| File.dir?("#{dirname}/#{n}") } - %w(. ..) - REJECT_DIRS
+ }
+ end
+
+end
+
+
+#
+# Main Installer
+#
+
+module HookUtils
+
+ def run_hook(name)
+ try_run_hook "#{curr_srcdir()}/#{name}" or
+ try_run_hook "#{curr_srcdir()}/#{name}.rb"
+ end
+
+ def try_run_hook(fname)
+ return false unless File.file?(fname)
+ begin
+ instance_eval File.read(fname), fname, 1
+ rescue
+ setup_rb_error "hook #{fname} failed:\n" + $!.message
+ end
+ true
+ end
+
+end
+
+
+module HookScriptAPI
+
+ def get_config(key)
+ @config[key]
+ end
+
+ alias config get_config
+
+ def set_config(key, val)
+ @config[key] = val
+ end
+
+ #
+ # srcdir/objdir (works only in the package directory)
+ #
+
+ #abstract srcdir_root
+ #abstract objdir_root
+ #abstract relpath
+
+ def curr_srcdir
+ "#{srcdir_root()}/#{relpath()}"
+ end
+
+ def curr_objdir
+ "#{objdir_root()}/#{relpath()}"
+ end
+
+ def srcfile(path)
+ "#{curr_srcdir()}/#{path}"
+ end
+
+ def srcexist?(path)
+ File.exist?(srcfile(path))
+ end
+
+ def srcdirectory?(path)
+ File.dir?(srcfile(path))
+ end
+
+ def srcfile?(path)
+ File.file? srcfile(path)
+ end
+
+ def srcentries(path = '.')
+ Dir.open("#{curr_srcdir()}/#{path}") {|d|
+ return d.to_a - %w(. ..)
+ }
+ end
+
+ def srcfiles(path = '.')
+ srcentries(path).select {|fname|
+ File.file?(File.join(curr_srcdir(), path, fname))
+ }
+ end
+
+ def srcdirectories(path = '.')
+ srcentries(path).select {|fname|
+ File.dir?(File.join(curr_srcdir(), path, fname))
+ }
+ end
+
+end
+
+
+class ToplevelInstaller
+
+ Version = '3.3.1'
+ Copyright = 'Copyright (c) 2000-2004 Minero Aoki'
+
+ TASKS = [
+ [ 'all', 'do config, setup, then install' ],
+ [ 'config', 'saves your configurations' ],
+ [ 'show', 'shows current configuration' ],
+ [ 'setup', 'compiles ruby extentions and others' ],
+ [ 'install', 'installs files' ],
+ [ 'clean', "does `make clean' for each extention" ],
+ [ 'distclean',"does `make distclean' for each extention" ]
+ ]
+
+ def ToplevelInstaller.invoke
+ instance().invoke
+ end
+
+ @singleton = nil
+
+ def ToplevelInstaller.instance
+ @singleton ||= new(File.dirname($0))
+ @singleton
+ end
+
+ include MetaConfigAPI
+
+ def initialize(ardir_root)
+ @config = nil
+ @options = { 'verbose' => true }
+ @ardir = File.expand_path(ardir_root)
+ end
+
+ def inspect
+ "#<#{self.class} #{__id__()}>"
+ end
+
+ def invoke
+ run_metaconfigs
+ case task = parsearg_global()
+ when nil, 'all'
+ @config = load_config('config')
+ parsearg_config
+ init_installers
+ exec_config
+ exec_setup
+ exec_install
+ else
+ @config = load_config(task)
+ __send__ "parsearg_#{task}"
+ init_installers
+ __send__ "exec_#{task}"
+ end
+ end
+
+ def run_metaconfigs
+ eval_file_ifexist "#{@ardir}/metaconfig"
+ end
+
+ def load_config(task)
+ case task
+ when 'config'
+ ConfigTable.new
+ when 'clean', 'distclean'
+ if File.exist?(ConfigTable.savefile)
+ then ConfigTable.load
+ else ConfigTable.new
+ end
+ else
+ ConfigTable.load
+ end
+ end
+
+ def init_installers
+ @installer = Installer.new(@config, @options, @ardir, File.expand_path('.'))
+ end
+
+ #
+ # Hook Script API bases
+ #
+
+ def srcdir_root
+ @ardir
+ end
+
+ def objdir_root
+ '.'
+ end
+
+ def relpath
+ '.'
+ end
+
+ #
+ # Option Parsing
+ #
+
+ def parsearg_global
+ valid_task = /\A(?:#{TASKS.map {|task,desc| task }.join '|'})\z/
+
+ while arg = ARGV.shift
+ case arg
+ when /\A\w+\z/
+ setup_rb_error "invalid task: #{arg}" unless valid_task =~ arg
+ return arg
+
+ when '-q', '--quiet'
+ @options['verbose'] = false
+
+ when '--verbose'
+ @options['verbose'] = true
+
+ when '-h', '--help'
+ print_usage $stdout
+ exit 0
+
+ when '-v', '--version'
+ puts "#{File.basename($0)} version #{Version}"
+ exit 0
+
+ when '--copyright'
+ puts Copyright
+ exit 0
+
+ else
+ setup_rb_error "unknown global option '#{arg}'"
+ end
+ end
+
+ nil
+ end
+
+
+ def parsearg_no_options
+ unless ARGV.empty?
+ setup_rb_error "#{task}: unknown options: #{ARGV.join ' '}"
+ end
+ end
+
+ alias parsearg_show parsearg_no_options
+ alias parsearg_setup parsearg_no_options
+ alias parsearg_clean parsearg_no_options
+ alias parsearg_distclean parsearg_no_options
+
+ def parsearg_config
+ re = /\A--(#{ConfigTable.map {|i| i.name }.join('|')})(?:=(.*))?\z/
+ @options['config-opt'] = []
+
+ while i = ARGV.shift
+ if /\A--?\z/ =~ i
+ @options['config-opt'] = ARGV.dup
+ break
+ end
+ m = re.match(i) or setup_rb_error "config: unknown option #{i}"
+ name, value = *m.to_a[1,2]
+ @config[name] = value
+ end
+ end
+
+ def parsearg_install
+ @options['no-harm'] = false
+ @options['install-prefix'] = ''
+ while a = ARGV.shift
+ case a
+ when /\A--no-harm\z/
+ @options['no-harm'] = true
+ when /\A--prefix=(.*)\z/
+ path = $1
+ path = File.expand_path(path) unless path[0,1] == '/'
+ @options['install-prefix'] = path
+ else
+ setup_rb_error "install: unknown option #{a}"
+ end
+ end
+ end
+
+ def print_usage(out)
+ out.puts 'Typical Installation Procedure:'
+ out.puts " $ ruby #{File.basename $0} config"
+ out.puts " $ ruby #{File.basename $0} setup"
+ out.puts " # ruby #{File.basename $0} install (may require root privilege)"
+ out.puts
+ out.puts 'Detailed Usage:'
+ out.puts " ruby #{File.basename $0} <global option>"
+ out.puts " ruby #{File.basename $0} [<global options>] <task> [<task options>]"
+
+ fmt = " %-24s %s\n"
+ out.puts
+ out.puts 'Global options:'
+ out.printf fmt, '-q,--quiet', 'suppress message outputs'
+ out.printf fmt, ' --verbose', 'output messages verbosely'
+ out.printf fmt, '-h,--help', 'print this message'
+ out.printf fmt, '-v,--version', 'print version and quit'
+ out.printf fmt, ' --copyright', 'print copyright and quit'
+ out.puts
+ out.puts 'Tasks:'
+ TASKS.each do |name, desc|
+ out.printf fmt, name, desc
+ end
+
+ fmt = " %-24s %s [%s]\n"
+ out.puts
+ out.puts 'Options for CONFIG or ALL:'
+ ConfigTable.each do |item|
+ out.printf fmt, item.help_opt, item.description, item.help_default
+ end
+ out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's"
+ out.puts
+ out.puts 'Options for INSTALL:'
+ out.printf fmt, '--no-harm', 'only display what to do if given', 'off'
+ out.printf fmt, '--prefix=path', 'install path prefix', '$prefix'
+ out.puts
+ end
+
+ #
+ # Task Handlers
+ #
+
+ def exec_config
+ @installer.exec_config
+ @config.save # must be final
+ end
+
+ def exec_setup
+ @installer.exec_setup
+ end
+
+ def exec_install
+ @installer.exec_install
+ end
+
+ def exec_show
+ ConfigTable.each do |i|
+ printf "%-20s %s\n", i.name, i.value
+ end
+ end
+
+ def exec_clean
+ @installer.exec_clean
+ end
+
+ def exec_distclean
+ @installer.exec_distclean
+ end
+
+end
+
+
+class ToplevelInstallerMulti < ToplevelInstaller
+
+ include HookUtils
+ include HookScriptAPI
+ include FileOperations
+
+ def initialize(ardir)
+ super
+ @packages = all_dirs_in("#{@ardir}/packages")
+ raise 'no package exists' if @packages.empty?
+ end
+
+ def run_metaconfigs
+ eval_file_ifexist "#{@ardir}/metaconfig"
+ @packages.each do |name|
+ eval_file_ifexist "#{@ardir}/packages/#{name}/metaconfig"
+ end
+ end
+
+ def init_installers
+ @installers = {}
+ @packages.each do |pack|
+ @installers[pack] = Installer.new(@config, @options,
+ "#{@ardir}/packages/#{pack}",
+ "packages/#{pack}")
+ end
+
+ with = extract_selection(config('with'))
+ without = extract_selection(config('without'))
+ @selected = @installers.keys.select {|name|
+ (with.empty? or with.include?(name)) \
+ and not without.include?(name)
+ }
+ end
+
+ def extract_selection(list)
+ a = list.split(/,/)
+ a.each do |name|
+ setup_rb_error "no such package: #{name}" unless @installers.key?(name)
+ end
+ a
+ end
+
+ def print_usage(f)
+ super
+ f.puts 'Inluded packages:'
+ f.puts ' ' + @packages.sort.join(' ')
+ f.puts
+ end
+
+ #
+ # multi-package metaconfig API
+ #
+
+ attr_reader :packages
+
+ def declare_packages(list)
+ raise 'package list is empty' if list.empty?
+ list.each do |name|
+ raise "directory packages/#{name} does not exist"\
+ unless File.dir?("#{@ardir}/packages/#{name}")
+ end
+ @packages = list
+ end
+
+ #
+ # Task Handlers
+ #
+
+ def exec_config
+ run_hook 'pre-config'
+ each_selected_installers {|inst| inst.exec_config }
+ run_hook 'post-config'
+ @config.save # must be final
+ end
+
+ def exec_setup
+ run_hook 'pre-setup'
+ each_selected_installers {|inst| inst.exec_setup }
+ run_hook 'post-setup'
+ end
+
+ def exec_install
+ run_hook 'pre-install'
+ each_selected_installers {|inst| inst.exec_install }
+ run_hook 'post-install'
+ end
+
+ def exec_clean
+ rm_f ConfigTable.savefile
+ run_hook 'pre-clean'
+ each_selected_installers {|inst| inst.exec_clean }
+ run_hook 'post-clean'
+ end
+
+ def exec_distclean
+ rm_f ConfigTable.savefile
+ run_hook 'pre-distclean'
+ each_selected_installers {|inst| inst.exec_distclean }
+ run_hook 'post-distclean'
+ end
+
+ #
+ # lib
+ #
+
+ def each_selected_installers
+ Dir.mkdir 'packages' unless File.dir?('packages')
+ @selected.each do |pack|
+ $stderr.puts "Processing the package `#{pack}' ..." if @options['verbose']
+ Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}")
+ Dir.chdir "packages/#{pack}"
+ yield @installers[pack]
+ Dir.chdir '../..'
+ end
+ end
+
+ def verbose?
+ @options['verbose']
+ end
+
+ def no_harm?
+ @options['no-harm']
+ end
+
+end
+
+
+class Installer
+
+ FILETYPES = %w( bin lib ext data )
+
+ include HookScriptAPI
+ include HookUtils
+ include FileOperations
+
+ def initialize(config, opt, srcroot, objroot)
+ @config = config
+ @options = opt
+ @srcdir = File.expand_path(srcroot)
+ @objdir = File.expand_path(objroot)
+ @currdir = '.'
+ end
+
+ def inspect
+ "#<#{self.class} #{File.basename(@srcdir)}>"
+ end
+
+ #
+ # Hook Script API base methods
+ #
+
+ def srcdir_root
+ @srcdir
+ end
+
+ def objdir_root
+ @objdir
+ end
+
+ def relpath
+ @currdir
+ end
+
+ #
+ # configs/options
+ #
+
+ def no_harm?
+ @options['no-harm']
+ end
+
+ def verbose?
+ @options['verbose']
+ end
+
+ def verbose_off
+ begin
+ save, @options['verbose'] = @options['verbose'], false
+ yield
+ ensure
+ @options['verbose'] = save
+ end
+ end
+
+ #
+ # TASK config
+ #
+
+ def exec_config
+ exec_task_traverse 'config'
+ end
+
+ def config_dir_bin(rel)
+ end
+
+ def config_dir_lib(rel)
+ end
+
+ def config_dir_ext(rel)
+ extconf if extdir?(curr_srcdir())
+ end
+
+ def extconf
+ opt = @options['config-opt'].join(' ')
+ command "#{config('rubyprog')} #{curr_srcdir()}/extconf.rb #{opt}"
+ end
+
+ def config_dir_data(rel)
+ end
+
+ #
+ # TASK setup
+ #
+
+ def exec_setup
+ exec_task_traverse 'setup'
+ end
+
+ def setup_dir_bin(rel)
+ all_files_in(curr_srcdir()).each do |fname|
+ adjust_shebang "#{curr_srcdir()}/#{fname}"
+ end
+ end
+
+ def adjust_shebang(path)
+ return if no_harm?
+ tmpfile = File.basename(path) + '.tmp'
+ begin
+ File.open(path, 'rb') {|r|
+ first = r.gets
+ return unless File.basename(config('rubypath')) == 'ruby'
+ return unless File.basename(first.sub(/\A\#!/, '').split[0]) == 'ruby'
+ $stderr.puts "adjusting shebang: #{File.basename(path)}" if verbose?
+ File.open(tmpfile, 'wb') {|w|
+ w.print first.sub(/\A\#!\s*\S+/, '#! ' + config('rubypath'))
+ w.write r.read
+ }
+ move_file tmpfile, File.basename(path)
+ }
+ ensure
+ File.unlink tmpfile if File.exist?(tmpfile)
+ end
+ end
+
+ def setup_dir_lib(rel)
+ end
+
+ def setup_dir_ext(rel)
+ make if extdir?(curr_srcdir())
+ end
+
+ def setup_dir_data(rel)
+ end
+
+ #
+ # TASK install
+ #
+
+ def exec_install
+ rm_f 'InstalledFiles'
+ exec_task_traverse 'install'
+ end
+
+ def install_dir_bin(rel)
+ install_files collect_filenames_auto(), "#{config('bindir')}/#{rel}", 0755
+ end
+
+ def install_dir_lib(rel)
+ install_files ruby_scripts(), "#{config('rbdir')}/#{rel}", 0644
+ end
+
+ def install_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ install_files ruby_extentions('.'),
+ "#{config('sodir')}/#{File.dirname(rel)}",
+ 0555
+ end
+
+ def install_dir_data(rel)
+ install_files collect_filenames_auto(), "#{config('datadir')}/#{rel}", 0644
+ end
+
+ def install_files(list, dest, mode)
+ mkdir_p dest, @options['install-prefix']
+ list.each do |fname|
+ install fname, dest, mode, @options['install-prefix']
+ end
+ end
+
+ def ruby_scripts
+ collect_filenames_auto().select {|n| /\.rb\z/ =~ n }
+ end
+
+ # picked up many entries from cvs-1.11.1/src/ignore.c
+ reject_patterns = %w(
+ core RCSLOG tags TAGS .make.state
+ .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb
+ *~ *.old *.bak *.BAK *.orig *.rej _$* *$
+
+ *.org *.in .*
+ )
+ mapping = {
+ '.' => '\.',
+ '$' => '\$',
+ '#' => '\#',
+ '*' => '.*'
+ }
+ REJECT_PATTERNS = Regexp.new('\A(?:' +
+ reject_patterns.map {|pat|
+ pat.gsub(/[\.\$\#\*]/) {|ch| mapping[ch] }
+ }.join('|') +
+ ')\z')
+
+ def collect_filenames_auto
+ mapdir((existfiles() - hookfiles()).reject {|fname|
+ REJECT_PATTERNS =~ fname
+ })
+ end
+
+ def existfiles
+ all_files_in(curr_srcdir()) | all_files_in('.')
+ end
+
+ def hookfiles
+ %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt|
+ %w( config setup install clean ).map {|t| sprintf(fmt, t) }
+ }.flatten
+ end
+
+ def mapdir(filelist)
+ filelist.map {|fname|
+ if File.exist?(fname) # objdir
+ fname
+ else # srcdir
+ File.join(curr_srcdir(), fname)
+ end
+ }
+ end
+
+ def ruby_extentions(dir)
+ Dir.open(dir) {|d|
+ ents = d.select {|fname| /\.#{::Config::CONFIG['DLEXT']}\z/ =~ fname }
+ if ents.empty?
+ setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first"
+ end
+ return ents
+ }
+ end
+
+ #
+ # TASK clean
+ #
+
+ def exec_clean
+ exec_task_traverse 'clean'
+ rm_f ConfigTable.savefile
+ rm_f 'InstalledFiles'
+ end
+
+ def clean_dir_bin(rel)
+ end
+
+ def clean_dir_lib(rel)
+ end
+
+ def clean_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ make 'clean' if File.file?('Makefile')
+ end
+
+ def clean_dir_data(rel)
+ end
+
+ #
+ # TASK distclean
+ #
+
+ def exec_distclean
+ exec_task_traverse 'distclean'
+ rm_f ConfigTable.savefile
+ rm_f 'InstalledFiles'
+ end
+
+ def distclean_dir_bin(rel)
+ end
+
+ def distclean_dir_lib(rel)
+ end
+
+ def distclean_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ make 'distclean' if File.file?('Makefile')
+ end
+
+ #
+ # lib
+ #
+
+ def exec_task_traverse(task)
+ run_hook "pre-#{task}"
+ FILETYPES.each do |type|
+ if config('without-ext') == 'yes' and type == 'ext'
+ $stderr.puts 'skipping ext/* by user option' if verbose?
+ next
+ end
+ traverse task, type, "#{task}_dir_#{type}"
+ end
+ run_hook "post-#{task}"
+ end
+
+ def traverse(task, rel, mid)
+ dive_into(rel) {
+ run_hook "pre-#{task}"
+ __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '')
+ all_dirs_in(curr_srcdir()).each do |d|
+ traverse task, "#{rel}/#{d}", mid
+ end
+ run_hook "post-#{task}"
+ }
+ end
+
+ def dive_into(rel)
+ return unless File.dir?("#{@srcdir}/#{rel}")
+
+ dir = File.basename(rel)
+ Dir.mkdir dir unless File.dir?(dir)
+ prevdir = Dir.pwd
+ Dir.chdir dir
+ $stderr.puts '---> ' + rel if verbose?
+ @currdir = rel
+ yield
+ Dir.chdir prevdir
+ $stderr.puts '<--- ' + rel if verbose?
+ @currdir = File.dirname(rel)
+ end
+
+end
+
+
+if $0 == __FILE__
+ begin
+ if multipackage_install?
+ ToplevelInstallerMulti.invoke
+ else
+ ToplevelInstaller.invoke
+ end
+ rescue SetupError
+ raise if $DEBUG
+ $stderr.puts $!.message
+ $stderr.puts "Try 'ruby #{$0} --help' for detailed usage."
+ exit 1
+ end
+end
View
8 test/tc_all.rb
@@ -0,0 +1,8 @@
+# Runs all tests.
+
+$LOAD_PATH.unshift "lib"
+
+test_dir = File.split(Dir.pwd).last == "test" ? "." : "test"
+
+tests = Dir["#{test_dir}/**/*.rb"].reject { |file| file == "tc_all.rb" }
+tests.each { |test| require test }
View
11 test/tc_inline.rb
@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "../lib")
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require "test-extract"
+require "evil"
+
+glob = File.join(File.dirname(__FILE__), "../lib/*")
+Dir[glob].each do |file|
+ next unless File.file?(file)
+ Extracter.process(file)
+end
View
112 test/test-extract.rb
@@ -0,0 +1,112 @@
+require 'test/unit/testcase'
+require 'test/unit/ui/console/testrunner'
+
+class Extracter
+ def self.process(fn)
+ new(File.read(fn))
+ end
+
+ def initialize(content)
+ comment_block_re = /((?:^\s*?(?:#.*?)?\n)+)/m
+ component_re = /\s*(?:class|def|module|alias)\s+:?([^\s()]+)?/
+ blocks = content.scan(/#{comment_block_re}#{component_re}/)
+
+ test_suite = Class.new(Test::Unit::TestCase)
+
+ has_test = false
+ blocks.each do |(comment, component)|
+ code_in_doc_re = /^(\s*# +(?:.*?)$)/
+ tests = comment.scan(code_in_doc_re)
+ body = tests.map do |test|
+ test.map do |raw_line|
+ line = raw_line.sub(/^\s*#\s{0,3}/, "")
+ if md = /(.*?)#\s*(=>|~>|raises?)\s*(.*?)$/.match(line)
+ new_line, type, result = *md.captures
+ new_line.strip!
+ case type
+ when "=>"
+ ["begin",
+ " assert_equal(#{result}, #{new_line})",
+ "rescue => err",
+ " assert_equal(#{result.inspect}, (#{new_line}).inspect)",
+ "end"].join("\n")
+ when "~>", "raise", "raises"
+ "assert_raises(Object.const_get(#{result.inspect})) { #{new_line} }"
+ end
+ else
+ line
+ end
+ end.join("\n")
+ end.join("\n")
+
+ unless component
+ if $DEBUG
+ STDERR.puts "Can't get name for this code:",
+ body.gsub(/(?:\r?\n){2}/, "\n")
+ end
+ component = test.hash.abs
+ end
+
+ if body and not body.empty?
+ has_test = true
+ begin
+ test_suite.class_eval %{
+ def #{test_method_name(component)}
+ #{body}
+ end
+ }
+ rescue Object => err
+ STDERR.puts "Error in #{test_method_name(component)}: ",
+ err, "", "Code is: ", body, "" if $DEBUG
+ end
+ end
+ end
+
+ if not has_test
+ test_suite.class_eval do
+ def test_main; end
+ end
+ end
+
+ Test::Unit::UI::Console::TestRunner.new(test_suite).start
+ end
+
+ def test_method_name(component)
+ result = "test_#{component}"
+ {
+ "+" => "op_plus",
+ "-" => "op_minus",
+ "+@" => "op_plus_self",
+ "-@" => "op_minus_self",
+ "*" => "op_mul",
+ "**" => "op_pow",
+ "/" => "op_div",
+ "%" => "op_mod",
+ "<<" => "op_lshift",
+ ">>" => "op_rshift",
+ "~" => "op_tilde",
+ "<=>" => "op_cmp",
+ "<" => "op_lt",
+ ">" => "op_gt",
+ "==" => "op_equal",
+ "<=" => "op_lt_eq",
+ ">=" => "op_gt_eq",
+ "===" => "op_case_eq",
+ "=~" => "op_apply",
+ "|" => "op_or",
+ "&" => "op_and",
+ "^" => "op_xor",
+ "[]" => "op_fetch",
+ "[]=" => "op_store"
+ }.each do |(what, by)|
+ result.gsub!(what, by)
+ end
+ return result
+ end
+end
+
+if __FILE__ == $0
+ file = ARGV.shift
+ load(file)
+ Extracter.process(file)
+end

0 comments on commit 06f68fd

Please sign in to comment.
Something went wrong with that request. Please try again.