core_ex 0.1.0

data/lib/core_ex/require.rb

@@ -0,0 +1,378 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: require.rb 252 2005-05-31 23:41:42Z ertai $
+
+require 'core_ex/pathname'
+require 'set'
+
+module Kernel
+  class << self
+    alias :__require__ :require
+    alias :__load__ :load
+  end
+end # module Kernel
+
+
+class RequireSystem
+
+
+  EXTENSIONS = %w[ .rb .so .bundle .o .dll ] << ''
+
+
+  attr_reader :include_dirs, :loaded, :required
+
+  def initialize
+    @include_dirs = Set.new
+    @loaded = Set.new
+    # @autoloads = {} FIXME AUTOLOAD
+    @required = Set.new
+    self.class.enable
+    Kernel.kernel_require_system = self
+    Module.module_require_system = self
+    $".each do |file|
+      feature = file.to_path.expand_path_with($:, EXTENSIONS)
+      raise "file not found #{file}" if feature.nil?
+      @required << feature
+    end
+    feature = $0.to_path.expand_path_with($:, EXTENSIONS)
+    @required << feature unless feature.nil?
+  end
+
+
+  def check_pathname ( aPathname )
+    unless aPathname.is_a? Pathname
+      raise LoadError, "need a Pathname not a #{aPathname.class}"
+    end
+  end
+  protected :check_pathname
+
+
+  def cannot_found ( aPathname )
+    raise LoadError, "CoreEx: Cannot found #{aPathname} in $:"
+  end
+  private :cannot_found
+
+
+  def load ( aPathname )
+    check_pathname(aPathname)
+    abs = aPathname.expand_path_with($:, EXTENSIONS)
+    cannot_found(aPathname) if abs.nil?
+    @loaded << abs
+    Kernel.__load__(abs)
+  end
+
+
+  # FIXME This autoload doesn't work for these reasons:
+  # - |
+  #      # file1.rb
+  #      module B
+  #        class A
+  #        end
+  #      end
+  #
+  #      # file2.rb
+  #      class A # where ::A != B::A
+  #      end
+  #
+  #      module B
+  #        autoload :A, 'file1'
+  #        A # this doesn't work because ::A exists so no const_missing is reached
+  #      end
+  #
+  # - |
+  #      # file1.rb
+  #      module B
+  #        class A
+  #        end
+  #      end
+  #
+  #      # file2.rb
+  #      module B
+  #        autoload :A, 'file1'
+  #        class ::C
+  #          A # this doesn't work because A is search in ::C which is not
+  #            # included in B.
+  #        end
+  #      end
+  # etc.
+  # Const missing was (it's obvious now) a very bad idea to make an autoload.
+  # We need to hook a const_get which is call every time.
+  def autoload ( aModule, aConst, aPathname )
+    raise ArgumentError, "need a module not #{cst}" unless aModule.is_a? Module
+    raise ArgumentError, "need a symbol not #{cst}" unless aConst.is_a? Symbol
+    raise if aConst.to_s =~ /::/
+    abs = aPathname.expand_path_with($:, EXTENSIONS)
+    abs = aPathname if abs.nil? # FIXME
+    # cannot_found(aPathname) if abs.nil?
+    aModule.__autoload__(aConst, abs.to_s)
+    # @autoloads[aModule] ||= {}
+    # @autoloads[aModule][aConst] ||= []
+    # @autoloads[aModule][aConst] << aPathname
+    self
+  end
+
+
+  # def const_missing ( aModule, aConst )
+    # raise ArgumentError, "need a module not #{cst}" unless aModule.is_a? Module
+    # raise ArgumentError, "need a symbol not #{cst}" unless aConst.is_a? Symbol
+    # raise if aConst.to_s =~ /::/
+    # @autoloads[aModule] ||= {}
+    # if @autoloads[aModule][aConst].nil?
+      # mods = aModule.to_s.split(/::/)
+      # if mods.size == 1
+        # p "CONSTMISSING"
+        # aModule.__const_missing__(aConst)
+      # end
+      # return const_missing(eval(mods[0..-2].join('::')), aConst)
+    # end
+    # @autoloads[aModule][aConst] ||= []
+    # @autoloads[aModule][aConst].each do |req|
+      # req.require
+    # end
+    # @autoloads[aModule].delete aConst
+    # if aModule.const_defined?(aConst)
+      # aModule.const_get(aConst)
+    # else
+      # p "CONSTMISSING"
+      # aModule.__const_missing__(aConst)
+    # end
+  # end
+
+  def require ( aPathname )
+    check_pathname(aPathname)
+    abs = aPathname.expand_path_with($:, EXTENSIONS)
+    cannot_found(aPathname) if abs.nil?
+    feature = aPathname.to_s
+    feature += abs.extname if aPathname.extname.empty?
+    if $".include? feature or @required.include? abs
+      return false
+    else
+      @required << abs
+      if abs.extname =~ /^(\.rb)?$/
+        $" << feature
+        res = Kernel.__load__(abs)
+      else
+        res = Kernel.__require__(abs.extsplit.first.to_s)
+        $" << feature unless $".include? feature
+      end
+      return true
+    end
+  end
+
+
+  def include_dir ( aPathname )
+    unless abs = include_dir?(aPathname)
+      $: << aPathname.to_s
+      $: << abs.to_s
+      @include_dirs << abs
+    end
+    self
+  end
+
+
+  def include_dir? ( aPathname )
+    check_pathname(aPathname)
+    abs = aPathname.expand_path.cleanpath
+    return ($:.include?(aPathname.to_s) ||
+            $:.include?(abs.to_s) ||
+            @include_dirs.include?(abs))? abs : nil
+  end
+
+
+  def required? ( aPathname )
+    check_pathname(aPathname)
+    abs = aPathname.expand_path_with($:, EXTENSIONS)
+    cannot_found(aPathname) if abs.nil?
+    feature = aPathname.to_s
+    feature += abs.extname if aPathname.extname.empty?
+    return $".include?(feature) || @required.include?(abs)
+  end
+
+
+  def self.instance
+    @@instance = new
+    class << self
+      undef :instance
+      def instance
+        @@instance
+      end
+    end
+    @@instance
+  end
+
+  def self.enable
+    class << self
+      module ::Kernel
+        def kernel_require_system= ( arg )
+          @@require_system = arg
+        end
+        alias :__require__ :require
+        def require ( aString )
+          @@require_system.require(aString.to_path)
+        end
+        alias :__load__ :load
+        def load ( aString )
+          @@require_system.load(aString.to_path)
+        end
+      end # module ::Kernel
+      class ::Module
+        def module_require_system= ( arg )
+          @@require_system = arg
+        end
+        alias :__autoload__ :autoload
+        def autoload ( aConst, anObject )
+          @@require_system.autoload(self, aConst, anObject.to_path)
+        end
+        # alias :__const_missing__ :const_missing
+        # def const_missing ( aConst )
+          # @@require_system.const_missing(self, aConst)
+        # end
+      end # module ::Module
+      undef :enable
+      def enable
+      end
+    end
+  end
+
+end # class RequireSystem
+
+
+
+test_section __FILE__ do
+
+  class RequireSystemTest < Test::Unit::TestCase
+
+    class MockRequirable < Pathname
+      @@requires = []
+      def initialize ( name, url )
+        @name, @url = name, url
+      end
+      def require ( *a )
+        @url.require
+        @@requires << @name
+      end
+      def self.requires
+        @@requires
+      end
+      def inspect
+        "#<#{self.class}: url=#@url, name=#@name>"
+      end
+      def self.[] ( name, url )
+        new(name, url)
+      end
+    end
+
+    @@save_dirs = $:.dup
+    @@save_files = $".dup
+
+    def setup
+      @rs = RequireSystem.new
+      @test = __FILE__.to_path.dirname.parent.parent + 'test'
+      @res  = @test + 'resources'
+      @req  = @res + 'require'
+      @s = 'test_require'
+      @s_dne = 'test_require_dne'
+      @s_so = 'test_require_so.so'
+      @s_rb = 'test_require_rb.rb'
+      @p = @s.to_path
+      @p_dne = @s_dne.to_path
+      @p_so = @s_so.to_path
+      @p_rb = @s_rb.to_path
+      @ls = [ @s, @s_dne, @s_so, @s_rb ]
+      @lp = [ @p, @p_dne, @p_so, @p_rb ]
+      @l = @ls + @lp
+      $:.replace @@save_dirs.dup
+      $".replace @@save_files.dup
+      @mr = MockRequirable
+    end
+
+    def test_0_initialize
+      %w[
+        load require
+        include_dir include_dirs
+        loaded required
+      ].each do |m|
+        assert_respond_to(@rs, m, m)
+      end
+    end
+
+    def assert_search ( inp, ref )
+      assert_nothing_raised do
+        @my = inp.expand_path_with($:, RequireSystem::EXTENSIONS)
+        ref = ref.expand_path.cleanpath unless ref.nil?
+        assert_equal(ref, @my, inp)
+      end
+      unless ref.nil?
+        assert_kind_of(Pathname, @my)
+        assert(@my.exist?)
+      end
+    end
+
+    def test_1_search
+      @ls.each do |x|
+        assert_raise(LoadError) do
+          x.expand_path_with($:, RequireSystem::EXTENSIONS)
+        end
+      end
+      @lp.each { |x| assert_search(x, nil) }
+    end
+
+    def test_2_include_dir
+      assert(! @rs.include_dir?(@test))
+      assert_nothing_raised do
+        assert_equal(@rs, @rs.include_dir(@test))
+      end
+      assert(@rs.include_dir?(@test))
+      $: << @res.to_s
+      assert(@rs.include_dir?(@res))
+    end
+
+    def test_2_search
+      @rs.include_dir(@req)
+      @lp.delete(@p_dne)
+      @lp.each { |x| assert_search(x, @req + x) }
+      @lp.each { |x| assert_search(@req + x, @req + x) }
+      assert_search(@p_dne, nil)
+    end
+
+    def test_load
+    end
+
+    def assert_require ( aPathname, ref_bool, ref_cst )
+      $REQUIRE_SYSTEM_TEST_COUNTER = 0
+      assert_nothing_raised { @my = aPathname.require }
+      assert_equal(ref_bool, @my)
+      assert_equal(ref_cst, $REQUIRE_SYSTEM_TEST_COUNTER)
+    end
+
+    def test_require
+      @lp.each do |x|
+        assert_raise(LoadError) { x.require }
+      end
+      @rs.include_dir(@req)
+      @lp.delete(@p_dne)
+      @lp.each { |x| assert_require(x, true, 1) }
+      assert_raise(LoadError) { @p_dne.require }
+    end
+
+    module ::AutoloadTree
+    end
+
+    def t_e_s_t_autoload # FIXME AUTOLOAD
+      @rs.include_dir(@res + 'autoload_tree')
+      [[:A,'A'], [:B,'B'], [:Foo, 'foo/C']].each do |cst,url|
+        assert_nothing_raised { AutoloadTree.autoload cst, @mr[cst,url] }
+      end
+      assert_nothing_raised do
+        assert(AutoloadTree)
+        assert_equal('AutoloadTree::A', ::AutoloadTree::A.name)
+        assert_equal('AutoloadTree::B', ::AutoloadTree::B.name)
+        assert_equal('AutoloadTree::Foo::C', ::AutoloadTree::Foo::C.name)
+      end
+      assert_equal([:A, :B, :Foo], @mr.requires)
+    end
+
+  end # RequireSystemTest
+end
+

data/lib/core_ex/string.rb

@@ -0,0 +1,47 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Nicolas Pouillard. All rights reserved.
+# License::   GNU General Public License (GPL).
+# Revision::  $Id$
+
+class String
+
+  #
+  # Provide an helper to cut strings.
+  #
+  # Example:
+  #
+  #  puts "
+  #    |        A very complex
+  #    |            string
+  #    |  with a specific indentation.
+  #    |
+  #    |I prefer that instead of a HERE doc
+  #    |  because I keep my indentation.
+  #    |".head_cut!
+  #
+  def head_cut! ( sep='\|' )
+    gsub!(/^\s*#{sep}/, '')
+    self
+  end
+
+  def require
+    to_path.require
+  end
+
+  def to_path
+    Pathname.new(self)
+  end
+
+  def autoload ( aConst )
+    to_path.autoload(aConst)
+  end
+
+  # XXX
+  # Do not implement to_io.
+  # It breaks File.exists?
+  # def to_io
+  # end
+  # XXX
+
+end # class String
+

data/lib/core_ex/temp_path.rb

@@ -0,0 +1,194 @@
+# Copyright: Copyright (c) 2004  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: temp_path.rb 252 2005-05-31 23:41:42Z ertai $
+
+require 'core_ex'
+require 'tempfile'
+require 'tmpdir'
+require 'set'
+require 'thread'
+
+class TempPath < Pathname
+
+  @@tmps = Set.new
+  @@mutex = Mutex.new
+  @@progname = Pathname.new($0).basename
+  @@tmpdir = Pathname.new(Dir.tmpdir) + "#{@@progname}.#{$$}"
+  @@tmpdir.freeze
+  @@initialized = false
+  @@clean_planned = false
+  @@auto_clean = true
+
+  # You can use a temporary pathname like that:
+  #
+  #  - # No argument are mandatory.
+  #    tmp = TempPath.new
+  #    tmp.open('w') { |f| f << 'foo' }
+  #    tmp.clean
+  #
+  #  - # You can choose the basename and an extension.
+  #    TmpPath.new('the_base_file_name', 'rb')
+  #
+  #  - # You can supply a block (recomended).
+  #    TmpPath.new('foo') do |tmp|
+  #      tmp.open('w') { |f| << 'foo' }
+  #      tmp.exist? == true
+  #      $tmp = tmp
+  #    end
+  #    $tmp.exist? == false
+  #
+  #  - # You can make a temporary directory.
+  #    TmpPath.new('adirectory') do |tmpdir|
+  #      tmpdir.mkpath
+  #      $file = tmpdir + 'foo'
+  #      $file.open('w') { |f| f << 'foo' }
+  #    end
+  #    $file.exist? == false
+  #
+  # The file name follow this scheme:
+  #
+  # TempPath.new('foo', 'rb')
+  #   => 'foo.111811.432.rb'
+  # TempPath.new('bar')
+  #   => 'bar.111811.134'
+  #
+  # which follow this format:
+  #   => 'base.pid.uniq.ext
+  #
+  def initialize ( base=@@progname, ext='', &block )
+    if base.to_s =~ /\//
+      raise ArgumentError, "bad basename, you give me a pathname #{base}"
+    end
+    self.class.init
+    ext = ".#{ext}" unless ext.empty? or ext[0] == ?.
+    res = nil
+    @@mutex.synchronize do
+      id_tmp = object_id
+      while (res = @@tmpdir + "#{base}.#{id_tmp}#{ext}").exist? \
+        and not @@tmps.include? res
+        id_tmp += 1
+      end
+      super(res)
+      @@tmps << self
+    end
+    if block_given?
+      begin
+        block[self.dup]
+      ensure
+        clean
+      end
+    end
+  end
+
+  # This method remove your temporary pathname.
+  # You do not need to call this method if you provide
+  # a block when you create a tempfile.
+  def clean
+    if exist?
+      if directory?
+        rmtree
+      else
+        unlink
+      end
+    end
+  end
+
+  def temp?
+    true
+  end
+
+  def self.init #:nodoc:
+    return if @@initialized
+    @@mutex.synchronize do
+      return if @@initialized
+      @@tmpdir.mkpath
+      @@initialized = true
+      at_exit { clean if @@auto_clean }
+    end
+  end
+
+  # By default the autoclean is on.
+  # But in some case (if you use your temppaths in at_exit)
+  # You must disable the autoclean.
+  # And manually call TempPath.clean at the very of the program.
+  def self.clean ( &block )
+    @@mutex.synchronize do
+      return if @@clean_planned
+      @@clean_planned = true
+    end
+    begin
+      block[] if block_given?
+    ensure
+      if @@tmpdir.exist?
+        @@tmpdir.rmtree 
+        @@initialized = false
+      end
+    end
+  end
+
+  def self.auto_clean= ( aBool )
+    @@auto_clean = aBool
+  end
+
+  def self.tmpdir
+    init
+    @@tmpdir
+  end
+
+end # class TempPath
+
+
+class Pathname
+
+  def temp?
+    false
+  end
+
+end # class Pathname
+
+
+
+test_section __FILE__ do
+
+  class MkTempTest < Test::Unit::TestCase
+
+    def setup
+      assert_nothing_raised { @foo = TempPath.new('foo') }
+      assert_nothing_raised { @foobar = TempPath.new('foo', 'bar') }
+      @list = []
+    end
+
+    def teardown
+      @list.each { |l| l.clean }
+      [@foo, @foobar].each { |l| l.clean }
+    end
+
+    def test_interface
+      assert_match(/\.#{$$}\/foo\.\d+$/, @foo.to_s)
+      assert_match(/\.#{$$}\/foo\.\d+\.bar$/, @foobar.to_s)
+      assert_nothing_raised { @foo.open('w') { |f| f.puts 'FooFoo'  }  }
+    end
+
+    def test_many
+      (0 .. 100).each do |i|
+        tmp = TempPath.new('many')
+        tmp.open('w') { |f| f.puts "i: #{i}" }
+        assert(tmp.exist?)
+        assert_equal("i: #{i}\n", tmp.readlines.join)
+        @list << tmp
+      end
+    end
+
+    def test_temp?
+      assert(@foo.temp?, 'not tmp.temp?')
+      assert_nothing_raised do
+        assert(!Pathname.new(@foo.to_s).temp?)
+      end
+    end
+
+  end # class MkTempTest
+
+end