comp_tree 0.5.0

data/contrib/quix/lib/quix/kernel.rb

@@ -0,0 +1,61 @@
+
+require 'thread'
+
+module Quix
+  module Kernel
+    def let
+      yield self
+    end
+
+    def singleton_class
+      class << self
+        self
+      end
+    end
+
+    module Gensym
+      @mutex = Mutex.new
+      @count = 0
+
+      def gensym(prefix = nil)
+        count = Gensym.module_eval {
+          @mutex.synchronize {
+            @count += 1
+          }
+        }
+        "#{prefix || :G}_#{count}_#{rand}".to_sym
+      end
+    end
+    include Gensym
+
+    def call_private(method, *args, &block)
+      instance_eval { send(method, *args, &block) }
+    end
+
+    def with_warnings(value = true)
+      previous = $VERBOSE
+      $VERBOSE = value
+      begin
+        yield
+      ensure
+        $VERBOSE = previous
+      end
+    end
+
+    def no_warnings(&block)
+      with_warnings(false, &block)
+    end
+
+    def abort_on_exception(value = true)
+      previous = Thread.abort_on_exception
+      Thread.abort_on_exception = value
+      begin
+        yield
+      ensure
+        Thread.abort_on_exception = previous
+      end
+    end
+
+    extend self
+  end
+end

data/contrib/quix/lib/quix/lazy_struct.rb

@@ -0,0 +1,55 @@
+
+require 'ostruct'
+require 'quix/builtin/kernel/tap'
+
+module Quix
+  #
+  # An OpenStruct with the ability to define lazily-evaluated fields.
+  #
+  class LazyStruct < OpenStruct
+    #
+    # For mixing into an existing OpenStruct instance singleton class.
+    #
+    module Mixin
+      #
+      # &block is evaluated when this attribute is requested.  The
+      # same result is returned for subsquent calls, until the field
+      # is assigned a different value.
+      #
+      def attribute(reader, &block)
+        singleton = (class << self ; self ; end)
+        singleton.instance_eval {
+          #
+          # Define a special reader method in the singleton class.
+          #
+          define_method(reader) {
+            block.call.tap { |value|
+              #
+              # The value has been computed.  Replace this method with a
+              # one-liner giving the value.
+              #
+              singleton.instance_eval {
+                remove_method(reader)
+                define_method(reader) { value }
+              }
+            }
+          }
+          
+          #
+          # Revert to the old OpenStruct behavior when the writer is called.
+          #
+          writer = "#{reader}=".to_sym
+          define_method(writer) { |value|
+            singleton.instance_eval {
+              remove_method(reader)
+              remove_method(writer)
+            }
+            method_missing(writer, value)
+          }
+        }
+      end
+    end
+    
+    include Mixin
+  end
+end

data/contrib/quix/lib/quix/simple_installer.rb

@@ -0,0 +1,87 @@
+
+require 'rbconfig'
+require 'fileutils'
+require 'find'
+require 'fileutils'
+require 'quix/vars'
+  
+module Quix
+  class SimpleInstaller
+    include Quix::Vars
+
+    def initialize
+      dest_root = Config::CONFIG["sitelibdir"]
+      sources = []
+      Find.find("./lib") { |source|
+        if install_file?(source)
+          sources << source
+        end
+      }
+      @spec = sources.inject(Array.new) { |acc, source|
+        if source == "./lib"
+          acc
+        else
+          dest = File.join(dest_root, source.sub(%r!\A\./lib!, ""))
+  
+          install = lambda {
+            if File.directory?(source)
+              unless File.directory?(dest)
+                puts "mkdir #{dest}"
+                FileUtils.mkdir(dest)
+              end
+            else
+              puts "install #{source} --> #{dest}"
+              FileUtils.install(source, dest)
+            end
+          }
+            
+          uninstall = lambda {
+            if File.directory?(source)
+              if File.directory?(dest)
+                puts "rmdir #{dest}"
+                FileUtils.rmdir(dest)
+              end
+            else
+              if File.file?(dest)
+                puts "rm #{dest}"
+                FileUtils.rm(dest)
+              end
+            end
+          }
+  
+          acc << locals_to_hash {%{source, dest, install, uninstall}}
+        end
+      }
+    end
+  
+    def install_file?(source)
+      !File.symlink?(source) and
+        (File.directory?(source) or
+          (File.file?(source) and File.extname(source) == ".rb"))
+    end
+
+    attr_accessor :spec
+
+    def install
+      @spec.each { |entry|
+        entry[:install].call
+      }
+    end
+  
+    def uninstall
+      @spec.reverse.each { |entry|
+        entry[:uninstall].call
+      }
+    end
+
+    def run(args = ARGV)
+      if args.empty? or (args.size == 1 and args.first == "install")
+        install
+      elsif args.size == 1 and args.first == "--uninstall"
+        uninstall
+      else
+        raise "unrecognized arguments: #{args.inspect}"
+      end
+    end
+  end
+end

data/contrib/quix/lib/quix/string.rb

@@ -0,0 +1,38 @@
+
+require 'quix/builtin/kernel/tap'
+
+module Quix
+  module String
+    def trim_left!
+      sub!(%r!\A\s+!, "")
+    end
+
+    def trim_right!
+      sub!(%r!\s+\Z!, "")
+    end
+
+    def trim!
+      result_left = trim_left!
+      result_right = trim_right!
+      result_left || result_right
+    end
+
+    def trim_left
+      clone.tap { |result|
+        result.trim_left!
+      }
+    end
+
+    def trim_right
+      clone.tap { |result|
+        result.trim_right!
+      }
+    end
+
+    def trim
+      clone.tap { |result|
+        result.trim!
+      }
+    end
+  end
+end

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

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

@@ -0,0 +1,32 @@
+
+require 'thread'
+require 'quix/kernel'
+
+module Quix
+  class ThreadLocal
+    include Quix::Kernel
+
+    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

@@ -0,0 +1,138 @@
+
+require 'quix/kernel'
+require 'quix/thread_local'
+require 'quix/builtin/kernel/tap'
+require 'ostruct'
+
+module Quix
+  module Vars
+    include Quix::Kernel
+
+    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

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

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

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

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

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

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