crypt-isaac 0.9.1

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2004 - 2005 Kirk Haines (khaines@enigo.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+For details about the ISAAC algorithm itself, see:
+
+http://burtleburtle.net/bob/rand/isaac.html
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,78 @@
+Crypt::ISAAC README
+============
+
+ISAAC is a cryptographically secure PRNG for generating high quality random
+numbers.  Detailed information about the algorithm can be found at:
+
+http://burtleburtle.net/bob/rand/isaac.html
+
+This is a pure Ruby implementation of the algorithm.  It is reasonably fast for
+a pure Ruby implementation.  On an 800Mhz PIII computer running Ruby 1.8.2,
+and while the machine is also serving as general desktop, the library seems to
+consistently generate between 15000 and 16000 random numbers per second.
+
+Ruby uses the Mersenne Twister as its PRNG, and while this the Twister is
+a fast PRNG that produces highly random numbers, it is not strong for
+cryptographic purposes, nor is it suitable when one needs multiple
+independent streams of random numbers.  Crypt::ISAAC is suitable for either
+purpose.
+
+
+Requirements
+------------
+
+  * Ruby 1.8 (should also run on 1.6.x)
+
+
+Install
+-------
+
+  If you have never installed Crypt::ISAAC, you may run the testsuite
+  to confirm that it works with:
+
+    # ruby setup.rb test
+
+  If you already have a version of Crypt::ISAAC installed, but want to
+  confirm this one before installing, run the test suite manually as
+  follows:
+
+    # ruby test/TC_ISAAC.rb local
+
+  When you are ready to install Crypt::ISAAC, type:
+
+    # ruby setup.rb install
+
+  This one step will install Crypt::ISAAC in your Ruby SITELIB.  To test
+  the library after installation:
+
+    # ruby setup.rb test
+
+Usage
+-----
+
+require 'crypt/ISAAC'
+
+rng = Crypt::ISAAC.new
+
+r1 = rng.rand() # returns a floating point between 0 and 1
+r2 = rnd.rand(1000) # returns an integer between 0 and 999
+
+rand() should work identically to the Kernel.rand().
+
+Enjoy it.  Let me know if you find anything that can be improved or that
+needs to be fixed.
+
+
+License
+-------
+
+The Crypt::ISAAC library is licensed with an MIT style licence.
+See the LICENSE file for details.  As for the ISAAC algorithm itself,
+see:
+
+http://burtleburtle.net/bob/rand/isaac.html
+
+
+
+Kirk Haines
+khaines@enigo.com

data/TODO

@@ -0,0 +1,3 @@
+*	Add a C version of the ISAAC algorithm and make it possible to install
+	the pure Ruby version and/or a version using a C extension for better
+	performance.

data/VERSIONS

@@ -0,0 +1,3 @@
+* 0.9		Initial public release.  Pure Ruby.
+* 0.9.1		Update to tweak a couple things and reorganize project struct.
+		Now uses a Package based installer, or can be installed as a gem.

data/crypt-isaac.gemspec

@@ -0,0 +1,39 @@
+#####
+# Crypt::ISAAC
+#   http://rubyforge.org/projects/crypt-isaac/
+#   Copyright 2004-2005 Kirk Haines
+#
+#   Licensed under the Ruby License.  See the README for details.
+#
+#####
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'crypt-isaac'
+  s.version           = '0.9.1'
+  s.summary           = %q(Ruby implementation of the ISAAC PRNG)
+  s.platform          = Gem::Platform::RUBY
+
+  s.has_rdoc          = true
+  s.rdoc_options      = %w(--title Crypt::ISAAC --main README --line-numbers)
+  s.extra_rdoc_files  = %w(README)
+
+  s.files = %w(README LICENSE TODO VERSIONS setup.rb crypt-isaac.gemspec test/TC_ISAAC.rb lib/crypt-isaac.rb)
+
+  s.test_files = ['test/TC_ISAAC.rb']
+
+  s.require_paths     = %w(lib)
+
+  s.author            = %q(Kirk Haines)
+  s.email             = %q(khaines@enigo.com)
+  s.rubyforge_project = %q(crypt-isaac)
+  s.homepage          = %q(http://rubyforge.org/projects/crypt-isaac)
+  description         = []
+  File.open("README") do |file|
+    file.each do |line|
+      line.chomp!
+      break if line.empty?
+      description << "#{line.gsub(/\[\d\]/, '')}"
+    end
+  end
+  s.description = description[1..-1].join(" ")
+end

data/lib/crypt-isaac.rb

@@ -0,0 +1,171 @@
+module Crypt
+
+	# ISAAC is a fast, strong random number generator.  Details on the
+	# algorithm can be found here: http://burtleburtle.net/bob/rand/isaac.html
+	# This provides a consistent and capable algorithm for producing
+	# independent streams of quality random numbers.
+
+	class ISAAC
+
+		attr_accessor :randrsl, :randcnt
+		attr_accessor :mm, :aa, :bb, :cc
+
+		# When a Crypt::ISAAC object is created, it needs to be seeded for
+		# random number generation.  If the system has a /dev/urandom file,
+		# that will be used to do the seeding by default.  If false is explictly
+		# passed when creating the object, it will instead use /dev/random to
+		# generate its seeds.  Be warned that this may make for SLOW
+		# initialization.
+		# If the requested source (/dev/urandom or /dev/random) do not exist,
+		# the system will fall back to a simplistic initialization mechanism
+		# using the builtin Mersenne Twister PRNG.
+
+		def initialize(noblock = true)
+			@mm = []
+			@randrsl = []
+			# Best initialization of the generator would be by pulling
+			# numbers from /dev/random.
+			rnd_source = noblock ? '/dev/urandom' : '/dev/random'
+			if (FileTest.exist? rnd_source)
+				File.open(rnd_source,'r') do |r|
+					256.times do |t|
+						z = r.read(4)
+						x = z.unpack('V')[0]
+						@randrsl[t] = x
+					end
+				end
+			else
+				# If urandom isn't available, the standard Ruby PRNG makes an
+				# adequate fallback.
+				256.times do |t|
+					@randrsl[t] = Kernel.rand(4294967295)
+				end
+			end
+			randinit(true)
+			nil
+		end
+
+		# Works just like the standard rand() function.  If called with an
+		# integer argument, rand() will return positive random number in
+		# the range of 0 to (argument - 1).  If called without an integer
+		# argument, rand() returns a positive floating point number less than 1.
+  
+		def rand(*num)
+			if (@randcnt == 1)
+				isaac
+				@randcnt = 256
+			end
+			@randcnt -= 1
+			if num[0].to_i > 0
+				@randrsl[@randcnt].modulo(num[0])
+			else
+				".#{@randrsl[@randcnt]}".to_f
+			end
+		end
+
+		def isaac
+			i = 0
+			x = 0
+			y = 0
+
+			@cc += 1
+			@bb += @cc
+			@bb & 0xffffffff
+
+			while (i < 256) do 
+				x = @mm[i]
+				@aa = (@mm[(i + 128) & 255] + (@aa^(@aa << 13)) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i+128)&255] + (@aa^(0x03ffffff & (@aa >> 6))) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i + 128)&255] + (@aa^(@aa << 2)) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i+128)&255] + (@aa^(0x0000ffff & (@aa >> 16))) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+			end
+		end
+
+		def randinit(flag)
+			i = 0
+			a = 0
+			b = 0
+			c = 0
+			d = 0
+			e = 0
+			f = 0
+			g = 0
+			@aa = @bb = @cc = 0
+			a = b = c = d = e = f = g = h = 0x9e3779b9
+
+			while (i < 4) do
+				a ^= b<<1; d += a; b += c
+				b ^= 0x3fffffff & (c>>2); e += b; c += d
+				c ^= d << 8; f += c; d += e
+				d ^= 0x0000ffff & (e >> 16); g += d; e += f
+				e ^= f << 10; h += e; f += g
+				f ^= 0x0fffffff & (g >> 4); a += f; g += h
+				g ^= h << 8; b += g; h += a
+				h ^= 0x007fffff & (a >> 9); c += h; a += b
+				i += 1
+			end
+
+			i = 0
+			while (i < 256) do
+				if (flag)
+					a+=@randrsl[i  ].to_i; b+=@randrsl[i+1].to_i;
+					c+=@randrsl[i+2]; d+=@randrsl[i+3];
+					e+=@randrsl[i+4]; f+=@randrsl[i+5];
+					g+=@randrsl[i+6]; h+=@randrsl[i+7];
+				end
+
+				a^=b<<11; d+=a; b+=c;
+				b^=0x3fffffff & (c>>2);  e+=b; c+=d;
+				c^=d<<8;  f+=c; d+=e;
+				d^=0x0000ffff & (e>>16); g+=d; e+=f;
+				e^=f<<10; h+=e; f+=g;
+				f^=0x0fffffff & (g>>4);  a+=f; g+=h;
+				g^=h<<8;  b+=g; h+=a;
+				h^=0x007fffff & (a>>9);  c+=h; a+=b;
+				@mm[i]=a;@mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
+				@mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
+				i += 8
+			end
+
+			if flag
+				i = 0
+				while (i < 256)
+					a+=@mm[i  ]; b+=@mm[i+1]; c+=@mm[i+2]; d+=@mm[i+3];
+					e+=@mm[i+4]; f+=@mm[i+5]; g+=@mm[i+6]; h+=@mm[i+7];
+					a^=b<<11; d+=a; b+=c;
+					b^=0x3fffffff & (c>>2);  e+=b; c+=d;
+					c^=d<<8;  f+=c; d+=e;
+					d^=0x0000ffff & (e>>16); g+=d; e+=f;
+					e^=f<<10; h+=e; f+=g;
+					f^=0x0fffffff & (g>>4);  a+=f; g+=h;
+					g^=h<<8;  b+=g; h+=a;
+					h^=0x007fffff & (a>>9);  c+=h; a+=b;
+					@mm[i  ]=a; @mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
+					@mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
+					i += 8
+				end
+			end
+
+  		isaac()
+   		@randcnt=256;        # /* prepare to use the first set of results */
+		end
+	end
+end

data/setup.rb

@@ -0,0 +1,596 @@
+require 'rbconfig'
+require 'fileutils'
+require 'pp'
+require 'optparse'
+require 'yaml'
+
+module Package
+
+class SpecificationError < StandardError; end
+# forward declaration of the specification classes so we can keep all
+# constants here
+class PackageSpecification_1_0; end
+# Default semantics
+PackageSpecification = PackageSpecification_1_0
+
+#TODO: could get this collected automatically with Class#inherited etc
+SEMANTICS = { "1.0" => PackageSpecification_1_0 }
+
+KINDS = [
+  :bin, :lib, :ext, :data, :conf, :doc
+]
+
+#{{{ list of files to be ignored stolen from setup.rb
+mapping = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*' }
+ignore_files = %w[core RCSLOG tags TAGS .make.state .nse_depinfo 
+      #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$
+      *.org *.in .* ] 
+#end of robbery
+IGNORE_FILES = ignore_files.map do |x|
+  Regexp.new('\A' + x.gsub(/[\.\$\#\*]/){|c| mapping[c]} + '\z')
+end
+
+def self.config(name)
+  # XXX use pathname
+  prefix = Regexp.quote(Config::CONFIG["prefix"])
+  exec_prefix = Regexp.quote(Config::CONFIG["exec_prefix"])
+  Config::CONFIG[name].gsub(/\A\/?(#{prefix}|#{exec_prefix})\/?/, '')
+end
+
+SITE_DIRS = {
+  :bin  => config("bindir"),
+  :lib  => config("sitelibdir"),
+  :ext  => config("sitearchdir"),
+  :data => config("datadir"),
+  :conf => config("sysconfdir"),
+  :doc  => File.join(config("datadir"), "doc"),
+}
+
+VENDOR_DIRS = {
+  :bin  => config("bindir"),
+  :lib  => config("rubylibdir"),
+  :ext  => config("archdir"),
+  :data => config("datadir"),
+  :conf => config("sysconfdir"),
+  :doc  => File.join(config("datadir"), "doc"),
+}
+
+MODES = {
+  :bin  => 0755,
+  :lib  => 0644,
+  :ext  => 0755,  # was: 0555,
+  :data => 0644,
+  :conf => 0644,
+  :doc  => 0644,
+}
+
+
+SETUP_OPTIONS = {:parse_cmdline => true, :load_conf => true, :run_tasks => true}
+
+def self.setup(version, options = {}, &instructions)
+  prefixes = dirs = nil
+  options = SETUP_OPTIONS.dup.update(options)
+
+  if options[:load_conf] && File.exist?("config.save")
+    config = YAML.load_file "config.save"
+    prefixes = config[:prefixes]
+    dirs = config[:dirs]
+  end
+
+  pkg = package_specification_with_semantics(version).new(prefixes, dirs)
+  pkg.parse_command_line if options[:parse_cmdline]
+  pkg.instance_eval(&instructions)
+
+  pkg.run_tasks if options[:run_tasks]
+
+#   pkg.install
+  pkg
+end
+
+def self.package_specification_with_semantics(version)
+  #XXX: implement the full x.y(.z)? semantics
+  r = SEMANTICS[version]
+  raise SpecificationError, "Unknown version #{version}." unless r
+  r
+end
+
+
+module Actions
+  
+  class InstallFile
+
+    attr_reader :source, :destination, :mode
+
+    def initialize(source, destination, mode, options)
+      @source = source
+      @destination = destination
+      @mode = mode
+      @options = options
+    end
+
+    def install
+      FileUtils.install @source, File.join(@options.destdir, @destination),
+                                 {:verbose => @options.verbose,
+                                  :noop => @options.noop, :mode => @mode }
+    end
+
+    def hash
+      [@source.hash, @destination.hash].hash
+    end
+
+    def eql?(other)
+      self.class == other.class && 
+        @source == other.source &&
+          @destination == other.destination &&
+            @mode == other.mode
+    end
+
+    def <=>(other)
+      FULL_ORDER[self, other] || self.destination <=> other.destination
+    end
+  end
+
+  class MkDir
+
+    attr_reader :directory
+
+    def initialize(directory, options)
+      @directory = directory
+      @options = options
+    end
+
+    def install
+      FileUtils.mkdir_p File.join(@options.destdir, @directory),
+                                  {:verbose => @options.verbose,
+                                   :noop => @options.noop }
+    end
+
+    def <=>(other)
+      FULL_ORDER[self, other] || self.directory <=> other.directory 
+    end
+  end
+
+  class FixShebang
+
+    attr_reader :destination
+
+    def initialize(destination, options)
+      @options = options
+      @destination = destination
+    end
+
+    def install
+      path = File.join(@options.destdir, @destination)
+      fix_shebang(path)
+    end
+
+    # taken from rpa-base, originally based on setup.rb's
+    # modify: #!/usr/bin/ruby
+    # modify: #! /usr/bin/ruby
+    # modify: #!ruby
+    # not modify: #!/usr/bin/env ruby
+    SHEBANG_RE = /\A\#!\s*\S*ruby\S*/
+
+    #TODO allow the ruby-prog to be placed in the shebang line to be passed as
+    # an option
+    def fix_shebang(path)
+      tmpfile = path + '.tmp'
+      begin
+        #XXX: needed at all?
+        # it seems that FileUtils doesn't expose its default output
+        #   @fileutils_output = $stderr
+        # we might want to allow this to be redirected.
+        $stderr.puts "shebang:open #{tmpfile}" if @options.verbose
+        unless @options.noop
+          File.open(path) do |r|
+            File.open(tmpfile, 'w', 0755) do |w|
+              first = r.gets
+              return unless SHEBANG_RE =~ first
+              w.print first.sub(SHEBANG_RE, '#!' + Config::CONFIG['ruby-prog'])
+              w.write r.read
+            end
+          end
+        end
+        FileUtils.mv(tmpfile, path, :verbose => @options.verbose,
+                     :noop => @options.noop)
+      ensure
+        FileUtils.rm_f(tmpfile, :verbose => @options.verbose,
+                       :noop => @options.noop)
+      end
+    end
+
+    def <=>(other)
+      FULL_ORDER[self, other] || self.destination <=> other.destination
+    end
+
+    def hash
+      @destination.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && self.destination == other.destination
+    end
+  end
+
+  order = [MkDir, InstallFile, FixShebang]
+  FULL_ORDER = lambda do |me, other|
+    a, b = order.index(me.class), order.index(other.class)
+    if a && b
+      (r = a - b) == 0 ? nil : r
+    else
+      -1 # arbitrary
+    end
+  end
+
+  class ActionList < Array
+
+    def directories!(options)
+      dirnames = []
+      map! { |d|
+        if d.kind_of?(InstallFile) && !dirnames.include?(File.dirname(d.destination))
+          dirnames << File.dirname(d.destination)
+          [MkDir.new(File.dirname(d.destination), options), d]
+        else
+          d
+        end
+      }
+      flatten!
+    end
+
+    def run(task)
+      each { |action| action.__send__ task }
+    end
+  end
+
+end # module Actions
+
+Options = Struct.new(:noop, :verbose, :destdir)
+
+class PackageSpecification_1_0
+
+  TASKS = %w[config setup install test show]
+  # default options for translate(foo => bar)
+  TRANSLATE_DEFAULT_OPTIONS = { :inherit => true }
+
+  def self.declare_file_type(args, &handle_arg)
+    str_arr_p = lambda{|x| Array === x && x.all?{|y| String === y}}
+    
+    # strict type checking --- we don't want this to be extended arbitrarily
+    unless args.size == 1 && Hash === args.first && 
+           args.first.all?{|f,r| [Proc, String, NilClass].include?(r.class) &&
+                                 (String === f || str_arr_p[f])} or
+           args.all?{|x| String === x || str_arr_p[x]}
+      raise SpecificationError, 
+        "Unspecified semantics for the given arguments: #{args.inspect}"
+    end
+
+    if args.size == 1 && Hash === args.first 
+      args.first.to_a.each do |file, rename_info|
+        if Array === file
+          # ignoring boring files
+          handle_arg.call(file, true, rename_info)
+        else
+          # we do want "boring" files given explicitly
+          handle_arg.call([file], false, rename_info)
+        end
+      end
+    else
+      args.each do |a|
+        if Array === a
+          a.each{|file| handle_arg.call(file, true, nil)}
+        else
+          handle_arg.call(a, false, nil)
+        end
+      end
+    end
+  end
+  
+  #{{{ define the file tagging methods
+  KINDS.each { |kind|
+    define_method(kind) { |*args| # if this were 1.9 we could also take a block
+      bin_callback = lambda do |kind_, type, dest, options|
+        next if kind_ != :bin || type == :dir
+        @actions << Actions::FixShebang.new(dest, options)
+      end
+      #TODO: refactor
+      self.class.declare_file_type(args) do |files, ignore_p, opt_rename_info|
+        files.each do |file|
+          next if ignore_p && IGNORE_FILES.any?{|re| re.match(file)}
+          add_file(kind, file, opt_rename_info, &bin_callback)
+        end
+      end
+    }
+  }
+
+  def unit_test(*files)
+    @unit_tests.concat files.flatten
+  end
+
+  attr_accessor :actions, :options
+
+  def self.metadata(name)
+    define_method(name) { |*args|
+      if args.size == 1
+        @metadata[name] = args.first
+      end
+      @metadata[name]
+    }
+  end
+
+  metadata :name
+  metadata :version
+  metadata :author
+
+
+  def translate_dir(kind, dir)
+    replaced_dir_parts = dir.split(%r{/})
+    kept_dir_parts = []
+    loop do
+      replaced_path = replaced_dir_parts.join("/")
+      target, options = @translate[kind][replaced_path]
+      options ||= TRANSLATE_DEFAULT_OPTIONS
+      if target && (replaced_path == dir || options[:inherit])
+        dir = (target != '' ? File.join(target, *kept_dir_parts) : 
+                              File.join(*kept_dir_parts))
+        break
+      end
+      break if replaced_dir_parts.empty?
+      kept_dir_parts.unshift replaced_dir_parts.pop
+    end
+    dir
+  end
+  
+  def add_file(kind, filename, new_filename_info, &callback)
+    #TODO: refactor!!!
+    if File.directory? filename #XXX setup.rb and rpa-base defined File.dir?
+                                #    to cope with some win32 issue
+      dir = filename.sub(/\A\.\//, "").sub(/\/\z/, "")
+      dest = File.join(@prefixes[kind], @dirs[kind], translate_dir(kind, dir))
+      @actions << Actions::MkDir.new(dest, @options)
+      callback.call(kind, :dir, dest, @options) if block_given?
+    else
+      if new_filename_info
+        case new_filename_info
+        when Proc
+          dest_name = new_filename_info.call(filename.dup)
+        else
+          dest_name = new_filename_info.dup
+        end
+      else
+        dest_name = filename.dup
+      end
+
+      dirname = File.dirname(dest_name)
+      dirname = "" if dirname == "."
+      dest_name = File.join(translate_dir(kind, dirname), File.basename(dest_name))
+
+      dest = File.join(@prefixes[kind], @dirs[kind], dest_name)
+      @actions << Actions::InstallFile.new(filename, dest, MODES[kind], @options)
+      callback.call(kind, :file, dest, @options) if block_given?
+    end
+  end
+
+  def initialize(prefixes = nil, dirs = nil)
+    @prefix = Config::CONFIG["prefix"].gsub(/\A\//, '')
+    @translate = {}
+    @prefixes = (prefixes || {}).dup
+    KINDS.each { |kind|
+      @prefixes[kind] = @prefix unless prefixes
+      @translate[kind] = {}
+    }
+
+    @dirs = (dirs || {}).dup
+    @dirs.update SITE_DIRS unless dirs
+
+    @actions = Actions::ActionList.new
+
+    @metadata = {}
+    @unit_tests = []
+
+    @options = Options.new
+    @options.verbose = true
+    @options.noop = false                # XXX for testing
+    @options.destdir = ''
+
+    @tasks = []
+  end
+
+  def aoki
+    (KINDS - [:ext]).each { |kind|
+      translate(kind, kind.to_s => "", :inherit => true)
+      __send__ kind, Dir["#{kind}/**/*"]
+    }
+    translate(:ext, "ext/*" => "", :inherit => true)
+    ext Dir["ext/**/*.#{Config::CONFIG['DLEXT']}"]
+  end
+
+  def install
+    puts "Installing #{name || "unknown package"} #{version}..."  if options.verbose
+
+    actions.uniq!
+    actions.sort!
+    actions.directories!(options)
+
+    #pp self
+
+    actions.run :install
+  end
+
+  def test
+    unless @unit_tests.empty?
+      puts "Testing #{name || "unknown package"} #{version}..."  if options.verbose
+      require 'test/unit'
+      unless options.noop
+        t = Test::Unit::AutoRunner.new(true)
+        t.process_args(@unit_tests)
+        t.run  
+      end
+    end
+  end
+
+  def config
+    File.open("config.save", "w") { |f|
+      YAML.dump({:prefixes => @prefixes, :dirs => @dirs}, f)
+    }
+  end
+
+  def show
+    KINDS.each { |kind|
+      puts "#{kind}\t#{File.join(options.destdir, @prefixes[kind], @dirs[kind])}"
+    }
+  end
+
+  def translate(kind, additional_translations)
+    default_opts = TRANSLATE_DEFAULT_OPTIONS.dup
+    key_val_pairs = additional_translations.to_a
+    option_pairs = key_val_pairs.select{|(k,v)| Symbol === k}
+    default_opts.update(Hash[*option_pairs.flatten])
+    
+    (key_val_pairs - option_pairs).each do |key, val|
+      add_translation(kind, key, val, default_opts)
+    end
+  end
+
+  def add_translation(kind, src, dest, options)
+    if is_glob?(src)
+      dirs = expand_dir_glob(src)
+    else
+      dirs = [src]
+    end
+    dirs.each do |dirname|
+      dirname = dirname.sub(%r{\A\./}, "").sub(%r{/\z}, "")
+      @translate[kind].update({dirname => [dest, options]})
+    end
+  end
+
+  def is_glob?(x)
+    /(^|[^\\])[*?{\[]/.match(x)
+  end
+
+  def expand_dir_glob(src)
+    Dir[src].select{|x| File.directory?(x)}
+  end
+
+  def clean_path(path)
+    path.gsub(/\A\//, '').gsub(/\/+\Z/, '').squeeze("/")
+  end
+
+  def parse_command_line
+    opts = OptionParser.new(nil, 24, ' ') { |opts|
+      opts.banner = "Usage: setup.rb [options] [task]"
+
+      opts.separator ""
+      opts.separator "Tasks:"
+      opts.separator "    config     configures paths"
+      opts.separator "    show       shows paths"
+      opts.separator "    setup      compiles ruby extentions and others XXX"
+      opts.separator "    install    installs files"
+      opts.separator "    test       runs unit tests"
+      
+
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      opts.on "--prefix=PREFIX",
+              "path prefix of target environment [#@prefix]" do |prefix|
+        @prefix.replace clean_path(prefix)  # Shared!
+      end
+
+      opts.separator ""
+
+      KINDS.each { |kind|
+        opts.on "--#{kind}prefix=PREFIX",
+                "path prefix for #{kind} files [#{@prefixes[kind]}]" do |prefix|
+          @prefixes[kind] = clean_path(prefix)
+        end
+      }
+
+      opts.separator ""
+
+      KINDS.each { |kind|
+        opts.on "--#{kind}dir=PREFIX",
+                "directory for #{kind} files [#{@dirs[kind]}]" do |prefix|
+          @dirs[kind] = clean_path(prefix)
+        end
+      }
+
+      opts.separator ""
+
+      KINDS.each { |kind|
+        opts.on "--#{kind}=PREFIX",
+                "absolute directory for #{kind} files [#{File.join(@prefixes[kind], @dirs[kind])}]" do |prefix|
+          @prefixes[kind] = clean_path(prefix)
+        end
+      }
+
+      opts.separator ""
+      opts.separator "Predefined path configurations:"
+      opts.on "--site", "install into site-local directories (default)" do
+        @dirs.update SITE_DIRS
+      end
+
+      opts.on "--vendor", "install into distribution directories (for packagers)" do
+        @dirs.update VENDOR_DIRS
+      end
+      
+      opts.separator ""
+      opts.separator "General options:"
+
+      opts.on "--destdir=DESTDIR",
+              "install all files relative to DESTDIR (/)" do |destdir|
+        @options.destdir = destdir
+      end
+
+      opts.on "--dry-run", "only display what to do if given [#{@options.noop}]" do
+        @options.noop = true
+      end
+
+      opts.on "--no-harm", "only display what to do if given" do
+        @options.noop = true
+      end
+
+      opts.on "--[no-]verbose", "output messages verbosely [#{@options.verbose}]" do |verbose|
+        @options.verbose = verbose
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    }
+
+    opts.parse! ARGV
+
+    if (ARGV - TASKS).empty?    # Only existing tasks?
+      @tasks = ARGV
+      @tasks = ["install"]  if @tasks.empty?
+    else
+      abort "Unknown task(s) #{(ARGV-TASKS).join ", "}."
+    end
+  end
+
+  def run_tasks
+    @tasks.each { |task| __send__ task }
+  end
+end
+
+end # module Package
+
+#XXX incomplete setup.rb support for the hooks
+require 'rbconfig'
+def config(x)
+  Config::CONFIG[x]
+end
+
+#{{{ small example
+if $0 == __FILE__
+Package.setup("1.0") {
+  name "crypt-isaac"
+
+  lib "lib/crypt-isaac.rb"
+
+  unit_test Dir["test/TC*.rb"]
+}
+end
+
+# vim: sw=2 sts=2 et ts=8

data/test/TC_ISAAC.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+if ARGV[0] == 'local'
+	begin
+		require '../lib/crypt-isaac.rb'
+	rescue Exception
+		require './lib/crypt-isaac.rb'
+	end
+else
+	begin
+		require 'crypt-isaac'
+	rescue Exception
+		require './lib/crypt-isaac.rb'
+	end
+end
+
+class TC_ISAAC < Test::Unit::TestCase
+	def setup
+		assert_nothing_raised("Failed to create a Crypt::ISAAC object.") do
+			@generator = Crypt::ISAAC.new
+		end
+	end
+
+	def testKind
+		assert_kind_of(Crypt::ISAAC,@generator,"The created object is not a Crypt::ISAAC or subclass thereof.") 
+	end
+
+	def testInteger
+		assert_nothing_raised("Failed while generating an integer random number.") do
+			mynum = @generator.rand(1000000)
+			assert_kind_of(Integer,mynum,"The generator failed to return an integer number in response to @generator.rand(1000000).")
+			assert((mynum >= 0),"The generator returned a number that is less than 0 (#{mynum}).")
+			assert((mynum < 1000000),"The generator returned a number that is greater than or equal to 1000000 (#{mynum}).")
+		end
+	end
+
+	def testFloat
+		assert_nothing_raised("Failed while generating a floating point random number.") do
+			mynum = @generator.rand()
+			assert_kind_of(Float,mynum,"The generator failed to return a floating point number in response to @generator.rand().")
+			assert((mynum >= 0),"The generator returned a number that is less than 0 (#{mynum}).")
+			assert((mynum < 1),"The generator returned a number that is greater than or equal to 1 (#{mynum}).")
+		end
+	end
+
+	def testIterations
+		puts
+		count = 0
+		assert_nothing_raised("Failed on iteration #{count} while trying to generate 100000 random numbers.") do
+			100000.times do
+				count += 1
+				x = @generator.rand(4294967295)
+				print [x].pack('V').unpack('H8') if count % 1000 == 0
+				if (count % 7000) == 0
+					print "\n"
+				else
+					print " " if count % 1000 == 0
+				end
+			end
+			puts "\n100000 numbers generated"
+		end
+	end
+
+	def testDualStreams
+		g1 = nil
+		g2 = nil
+		assert_nothing_raised("Failed to pull numbers from two independent streams.") do
+			g1 = Crypt::ISAAC.new
+			g2 = Crypt::ISAAC.new
+			assert((g1 != g2),"The generators are the same.  This should not happen.")
+			1000.times do
+				g1.rand(4294967295)
+				g2.rand(4294967295)
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: crypt-isaac
+version: !ruby/object:Gem::Version 
+  version: 0.9.1
+platform: ruby
+authors: 
+- Kirk Haines
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-26 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: ============
+email: khaines@enigo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- LICENSE
+- TODO
+- VERSIONS
+- setup.rb
+- crypt-isaac.gemspec
+- test/TC_ISAAC.rb
+- lib/crypt-isaac.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/crypt-isaac
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Crypt::ISAAC
+- --main
+- README
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: crypt-isaac
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of the ISAAC PRNG
+test_files: 
+- test/TC_ISAAC.rb