comp_tree 0.5.2 → 0.7.0

data/contrib/quix/lib/quix/subpackager.rb

@@ -1,52 +0,0 @@
-
-require 'quix/hash_struct'
-
-module Quix
-  module Subpackager
-    WARNING = %q{
-
-
-      ######################################################
-      # 
-      # **** DO NOT EDIT ****
-      # 
-      # **** THIS IS A GENERATED FILE *****
-      # 
-      ######################################################
-
-
-    }.gsub(%r!^ +!, "")
-  
-    def self.run(packages)
-      HashStruct.recursive_new(packages).each_pair { |pkg, pkg_spec|
-        pkg_spec.subpackages.each_pair { |subpkg, subpkg_spec|
-          process_path = lambda { |path|
-            source = "#{subpkg_spec.lib_dir}/#{path}.rb"
-            dest = "#{pkg_spec.lib_dir}/#{pkg}/#{path}.rb"
-    
-            contents =
-              WARNING +
-              File.read(source).gsub(%r!require [\'\"]#{subpkg}!) {
-                |match|
-                match.sub(%r!#{subpkg}\Z!, "#{pkg}/#{subpkg}")
-              }.gsub(subpkg_spec.name_in_ruby) {
-                "#{pkg_spec.name_in_ruby}::#{subpkg_spec.name_in_ruby}"
-              } +
-              WARNING
-            
-            mkdir_p(File.dirname(dest))
-            puts "#{source} --> #{dest}"
-            File.open(dest, "w") { |t| t.print(contents) }
-          }
-
-          unless subpkg_spec.ignore_root_rb
-            process_path.call(subpkg)
-          end
-          subpkg_spec.sources.each { |path|
-            process_path.call("#{subpkg}/#{path}")
-          }
-        }
-      }
-    end
-  end
-end

data/contrib/quix/lib/quix/thread_local.rb

@@ -1,32 +0,0 @@
-
-require 'thread'
-require 'quix/kernel'
-
-module CompTree
-  class ThreadLocal
-    include Misc
-
-    def initialize(prefix = nil, &default)
-      @name = gensym(prefix)
-      @accessed = gensym(prefix)
-      @default = default
-    end
-    
-    def value
-      t = Thread.current
-      unless t[@accessed]
-        if @default
-          t[@name] = @default.call
-        end
-        t[@accessed] = true
-      end
-      t[@name]
-    end
-    
-    def value=(value)
-      t = Thread.current
-      t[@accessed] = true
-      t[@name] = value
-    end
-  end
-end

data/contrib/quix/lib/quix/vars.rb

@@ -1,138 +0,0 @@
-
-require 'quix/kernel'
-require 'quix/thread_local'
-require 'quix/builtin/kernel/tap'
-require 'ostruct'
-
-module CompTree
-  module Vars
-    include CompTree::Misc
-
-    def eval_locals(code_with_locals, &block)
-      code_with_locals.call.split(",").map { |name|
-        # trim
-        name.sub(%r!\A\s+!, "").sub(%r!\s+\Z!, "")
-      }.each { |name|
-        block.call(name, eval(name, code_with_locals.binding))
-      }
-    end
-
-    def hash_to_locals(&block)
-      if hash = block.call
-        hash.each_pair { |name, value|
-          Vars.argument_cache.value = value
-          eval("#{name} = #{Vars.name}.argument_cache.value", block.binding)
-        }
-      end
-    end
-
-    def locals_to_hash(&block)
-      Hash.new.tap { |hash|
-        eval_locals(block) { |name, value|
-          hash[name.to_sym] = value
-        }
-      }
-    end
-
-    def config_to_hash(code)
-      Hash.new.tap { |hash|
-        each_config_pair(code) { |name, value|
-          hash[name] = value
-        }
-      }
-    end
-    
-    def each_config_pair(code, &block)
-      Vars.argument_cache.value = code
-      vars, bind = private__eval_config_code
-      vars.each { |var|
-        yield(var.to_sym, eval(var, bind))
-      }
-    end
-
-    def hash_to_ivs(opts = nil, &block)
-      if hash = block.call
-        private__hash_to_ivs(
-          hash,
-          eval("self", block.binding),
-          opts && opts[:force])
-      end
-    end
-
-    def locals_to_ivs(opts = nil, &block)
-      hash = Hash.new
-      eval_locals(block) { |name, value|
-        hash[name] = value
-      }
-      private__hash_to_ivs(
-        hash,
-        eval("self", block.binding), 
-        opts && opts[:force])
-    end
-
-    def with_readers(hash, *args, &block)
-      caller_self = eval("self", block.binding)
-      readers =
-        if args.empty?
-          hash.keys
-        else
-          args
-        end
-      singleton_class.instance_eval {
-        added = Array.new
-        begin
-          readers.each { |reader|
-            if caller_self.respond_to?(reader)
-              raise(
-                "Reader '#{reader}' already exists in #{caller_self.inspect}")
-            end
-            define_method(reader) {
-              hash[reader]
-            }
-            added << reader
-          }
-          block.call
-        ensure
-          added.each { |reader|
-            remove_method(reader)
-          }
-        end
-      }
-    end
-
-    private
-
-    class << self
-      attr_accessor :argument_cache
-    end
-    @argument_cache = ThreadLocal.new
-
-    def private__eval_config_code
-      eval %Q{
-        #{Vars.argument_cache.value}
-
-        [local_variables, binding]
-      }
-    end
-
-    def private__hash_to_ivs(hash, target, force)
-      target.instance_eval {
-        hash.each_pair { |name, value|
-          ivar = "@#{name}"
-          unless force
-            existing_value = no_warnings {
-              instance_variable_get(ivar)
-            }
-            unless existing_value.nil?
-              raise "instance variable already set: #{name}"
-            end
-          end
-          instance_variable_set(ivar, value)
-        }
-      }
-    end
-
-    extend self
-  end
-end
-

data/contrib/quix/lib/quix.rb

@@ -1,32 +0,0 @@
-#
-# Convience only -- include most everything
-#
-
-root = File.dirname(__FILE__)
-pkgname = File.basename(__FILE__).sub(%r!\.rb\Z!, "")
- 
-Dir["#{root}/#{pkgname}/**/*.rb"].map { |file|
-  # change to relative paths
-  file.sub(%r!\A#{root}/!, "").sub(%r!\.rb\Z!, "")
-}.reject { |file|
-  (file =~ %r!cygwin! and RUBY_PLATFORM !~ %r!cygwin!) or
-  file =~ %r!builtin!
-}.each { |file|
-  require file
-}
-
-require 'quix/builtin/kernel/tap'
-
-%w(Config Enumerable FileUtils String).each { |name|
-  Kernel.const_get(name).module_eval {
-    include Quix.const_get(name)
-  }
-}
-
-Config.extend(Quix::Config)
-
-class Object
-  include Quix::Kernel
-end
-
-include Quix

data/contrib/quix/test/all.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'quix/config'
-
-#
-# Run in separate exec to check for missing dependencies.
-#
-Dir["#{File.dirname(__FILE__)}/test_*.rb"].each { |test|
-  unless system(Quix::Config.ruby_executable, test)
-    raise "test failed: #{test}"
-  end
-}

data/contrib/quix/test/test_deps.rb

@@ -1,25 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-require 'quix/config'
-
-class TestDeps < Test::Unit::TestCase
-  include Quix::Config
-  def test_deps
-    ruby = ruby_executable
-    root = File.expand_path("#{File.dirname(__FILE__)}/../lib")
-    Dir["#{root}/**/*.rb"].map { |file|
-      file.
-      sub(%r!\A#{root}/!, "").
-      sub(%r!\.rb\Z!, "")
-    }.each { |file|
-      unless file =~ %r!cygwin! and RUBY_PLATFORM !~ %r!cygwin!
-        Dir.chdir(root) {
-          assert(
-            system(ruby, "-r", file, "-e", ""),
-            "error requiring: '#{file}'")
-        }
-      end
-    }
-  end
-end

data/contrib/quix/test/test_include.rb

@@ -1,47 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-require 'open3'
-require 'quix/config'
-
-class TestInclude < Test::Unit::TestCase
-  include Quix::Config
-
-  def test_include
-    Dir.chdir(File.dirname(__FILE__)) {
-      code = %q{
-        $LOAD_PATH.unshift "../lib"
-        require 'quix/builtin/module/include'
-
-        module A
-          def f ; end
-        end
-  
-        module B
-          def f ; end
-        end
-
-        module C
-          include A
-          include B
-        end
-
-        class D
-          include B
-          include A
-        end
-      }
-      ruby = ruby_executable
-      begin
-        stdin, stdout, stderr = Open3.popen3("#{ruby} -d -")
-        stdin.puts(code)
-        stdin.close_write
-        assert_equal(stderr.readlines,
-          ["Note: replacing C#f with B#f\n",
-           "Note: replacing D#f with A#f\n"])
-      rescue NotImplementedError
-        puts "Skipping #{File.basename(__FILE__)}."
-      end
-    }
-  end
-end

data/contrib/quix/test/test_private.rb

@@ -1,86 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-require 'quix/config'
-require 'quix/kernel'
-
-if Quix::Config.version_ge("1.8.7")
-  require 'test/unit'
-  require 'quix/builtin/module/private'
-
-  class TestPrivate < Test::Unit::TestCase
-    BODY = %{
-      def f ; end
-      
-      private {
-        def g ; end
-        def h ; end
-      }
-      
-      def i ; end
-  
-      private {
-        def j ; end
-      }
-        
-      def k ; end
-  
-      private {
-      }
-  
-      def l ; end
-  
-      def m ; end
-      def n ; end
-      private :m, :n
-  
-      def o ; end
-    }
-  
-    class A
-      eval(BODY)
-    end
-
-    module B
-      eval(BODY)
-    end
-
-    class C
-      include B
-    end
-
-    def test_1
-      [A, C].map { |klass| klass.new }.each { |t|
-        assert_nothing_raised { t.f }
-        assert_raises(NoMethodError) { t.g }
-        assert_raises(NoMethodError) { t.h }
-        assert_nothing_raised { t.i }
-        assert_raises(NoMethodError) { t.j }
-        assert_nothing_raised { t.k }
-        assert_nothing_raised { t.l }
-        assert_raises(NoMethodError) { t.m }
-        assert_raises(NoMethodError) { t.n }
-        assert_nothing_raised { t.o }
-      }
-    end
-
-    def test_2
-      added = []
-      Class.new {
-        extend(Quix::Kernel).singleton_class.instance_eval {
-          define_method(:method_added) { |name|
-            added << name
-          }
-        }
-        
-        private {
-          def f ; end
-        }
-        
-        def g ; end
-      }
-      assert_equal([:f, :g], added)
-    end
-  end
-end
-  

data/contrib/quix/test/test_root.rb

@@ -1,19 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'quix'
-require 'test/unit'
-
-class TestRoot < Test::Unit::TestCase
-  def test_1
-    assert_equal(class << self ; self ; end, singleton_class)
-    assert_equal("moo", "moo".tap { |t| t*2 })
-    assert_equal("moomoo", "moo".let { |t| t*2 })
-    assert_equal("zzz", " zzz     ".trim)
-    assert_nothing_raised {
-      ThreadLocal.new
-      LazyStruct.new
-      HashStruct.new
-      Config.ruby_executable
-    }
-  end
-end

data/contrib/quix/test/test_struct.rb

@@ -1,48 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-require 'quix/lazy_struct'
-require 'quix/hash_struct'
-
-class TestLazyStruct < Test::Unit::TestCase
-  def common(s)
-    s.f = 33
-    assert_equal(33, s.f)
-
-    n = 0
-    s.attribute(:f) {
-      n += 1
-      44
-    }
-    
-    3.times {
-      assert_equal(44, s.f)
-    }
-    assert_equal(1, n)
-  end
-
-  def test_1
-    common(Quix::LazyStruct.new)
-  end
-
-  def test_2
-    s = OpenStruct.new
-    class << s
-      include Quix::LazyStruct::Mixin
-    end
-    common(s)
-  end
-
-  def test_3
-    s = Quix::HashStruct.new
-    class << s
-      include Quix::LazyStruct::Mixin
-    end
-    common(s)
-    s[:g] = 55
-    assert_equal(
-      { :f => 33, :g => 55 },
-      s.keys.inject(Hash.new) { |acc, e| acc.merge(e => s[e]) })
-  end
-end
-

data/contrib/quix/test/test_vars.rb

@@ -1,187 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-require 'quix/vars'
-require 'quix/hash_struct'
-
-class TestVars < Test::Unit::TestCase
-  include Quix::Vars
-
-  def test_locals_to_hash
-    a = 33
-    b = Object.new
-    c = lambda { a + 11 }
-
-    hash = locals_to_hash {%{a, b, c}}
-
-    assert_equal(a.object_id, hash[:a].object_id)
-    assert_equal(b.object_id, hash[:b].object_id)
-    assert_equal(c.object_id, hash[:c].object_id)
-
-    assert_equal(hash[:c].call, 44)
-  end
-
-  def test_hash_to_locals
-    a = nil
-    b = nil
-    c = nil
-    
-    hash = {
-      :a => 33,
-      :b => Object.new,
-      :c => lambda { hash[:a] + 11 },
-    }
-
-    hash_to_locals { hash }
-
-    assert_equal(a.object_id, hash[:a].object_id)
-    assert_equal(b.object_id, hash[:b].object_id)
-    assert_equal(c.object_id, hash[:c].object_id)
-
-    assert_equal(hash[:c].call, 44)
-    assert_nothing_raised { hash_to_locals { nil } }
-  end
-
-  def test_with_readers
-    hash = {
-      :a => 33,
-      :b => Object.new,
-      :c => lambda { hash[:a] + 11 },
-    }
-
-    assert_raise(NameError) { a }
-    assert_raise(NameError) { b }
-    assert_raise(NameError) { c }
-
-    with_readers(hash) {
-      assert_equal(a.object_id, hash[:a].object_id)
-      assert_equal(b.object_id, hash[:b].object_id)
-      assert_equal(c.object_id, hash[:c].object_id)
-    }
-
-    assert_raise(NameError) { a }
-    assert_raise(NameError) { b }
-    assert_raise(NameError) { c }
-
-    with_readers(hash, :a, :b) {
-      assert_equal(a.object_id, hash[:a].object_id)
-      assert_equal(b.object_id, hash[:b].object_id)
-      assert_raise(NameError) { c }
-    }
-  end
-
-  def test_locals_to_ivs
-    a = 33
-    b = Object.new
-    c = lambda { a + 11 }
-
-    assert(!defined?(@a))
-    assert(!defined?(@b))
-    assert(!defined?(@c))
-    
-    locals_to_ivs {%{a, b, c}}
-
-    assert_equal(a.object_id, @a.object_id)
-    assert_equal(b.object_id, @b.object_id)
-    assert_equal(c.object_id, @c.object_id)
-
-    assert_equal(@c.call, 44)
-  end
-
-  def test_hash_to_ivs
-    hash = {
-      :d => 33,
-      :e => Object.new,
-      :f => lambda { hash[:d] + 11 },
-    }
-
-    assert(!defined?(@d))
-    assert(!defined?(@e))
-    assert(!defined?(@f))
-    
-    hash_to_ivs { hash }
-
-    assert_equal(hash[:d].object_id, @d.object_id)
-    assert_equal(hash[:e].object_id, @e.object_id)
-    assert_equal(hash[:f].object_id, @f.object_id)
-
-    assert_equal(hash[:f].call, 44)
-    assert_nothing_raised { hash_to_ivs { nil } }
-  end
-
-  def test_config_to_hash
-    config = %q{
-      a = 33
-      b = a + 11
-      c = 5*(a - 22)
-      d = (1..3).map { |n| n*n }
-      e = "moo"
-      f = lambda { a + 66 }
-
-      a_object_id = a.object_id
-      b_object_id = b.object_id
-      c_object_id = c.object_id
-      d_object_id = d.object_id
-      e_object_id = e.object_id
-      f_object_id = f.object_id
-    }
-
-    hash = config_to_hash(config)
-
-    assert_equal(hash[:a], 33)
-    assert_equal(hash[:b], 44)
-    assert_equal(hash[:c], 55)
-    assert_equal(hash[:d], [1, 4, 9])
-    assert_equal(hash[:e], "moo")
-    assert_equal(hash[:f].call, 99)
-
-    assert_equal(hash[:a].object_id, hash[:a_object_id])
-    assert_equal(hash[:b].object_id, hash[:b_object_id])
-    assert_equal(hash[:c].object_id, hash[:c_object_id])
-    assert_equal(hash[:d].object_id, hash[:d_object_id])
-    assert_equal(hash[:e].object_id, hash[:e_object_id])
-    assert_equal(hash[:f].object_id, hash[:f_object_id])
-  end
-
-  def test_hash_struct
-    hash = {
-      :a => {
-        :b => :c,
-        :d => :e,
-        :f => {
-          :g => :h,
-          :i => :j,
-        },
-      },
-      :k => :l,
-      :m => [ :n, :o, :p ],
-      :q => {
-        :r => {},
-        :s => [],
-      },
-      :t => [
-        {
-          :u => :v,       
-          :w => :x,       
-        },
-      ],
-      :w => {
-        :x => {
-          :y => :z,
-        },
-      },
-    }
-    
-    s = Quix::HashStruct.recursive_new(hash)
-    assert_equal(s.a.b, :c)
-    assert_equal(s.a.d, :e)
-    assert_equal(s.a.f.g, :h)
-    assert_equal(s.a.f.i, :j)
-    assert_equal(s.k, :l)
-    assert_equal(s.m, [:n, :o, :p])
-    assert_equal(s.q.r, OpenStruct.new)
-    assert_equal(s.q.s, [])
-    assert_equal(s.t, [{ :u => :v, :w => :x }])
-    assert_equal(s.w.x.y, :z)
-  end
-end