core_ex 0.2.0 → 0.3.1

data/lib/core_ex/require.rb

@@ -1,387 +1,46 @@
 # 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 297 2005-06-18 21:51:39Z 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
-    self.class.enable
-    Kernel.kernel_require_system = self
-    Module.module_require_system = self
-    adds = []
-    $".each do |file|
-      feature = file.to_path.expand_path_with($:, EXTENSIONS)
-      raise "file not found #{file}" if feature.nil?
-      adds << feature.to_s unless feature.to_s == file
-    end
-    feature = $0.to_path.expand_path_with($:, EXTENSIONS)
-    adds << feature.to_s unless feature.nil?
-    $".replace(($" + adds).uniq)
-  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 add_to_required ( aString )
-    return if $".include? aString
-    $" << aString
-  end
-
-
-  def required_include? ( aString )
-    $".include? aString
-  end
-
-
-  def load ( aPathname )
-    check_pathname(aPathname)
-    abs = aPathname.expand_path_with($:, EXTENSIONS + [aPathname.extname])
-    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 required_include? feature or required_include? abs.to_s
-      return false
-    else
-      if abs.extname =~ /^(\.rb)?$/
-        add_to_required feature
-        add_to_required abs.to_s
-        res = Kernel.__load__(abs)
-      else
-        res = Kernel.__require__(abs.extsplit.first.to_s)
-        add_to_required feature
-        add_to_required abs.to_s
-      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 required_include?(feature)
-  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_rb ] # FIXME @p_so on mac
-      @l = @ls + @lp
-      $:.replace @@save_dirs.dup
-      @mr = MockRequirable
-    end
-
-    def teardown
-      $".delete_if { |x| x =~ /test_require/ }
-    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
-      @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
+# Revision::  $Id: require.rb 334 2005-09-04 14:29:40Z ertai $
+
+# FIXME This autoload didn'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.
+module CoreEx
+
+  module Require
+  end # module Require
+
+end # module CoreEx

data/lib/core_ex/string.rb

@@ -3,45 +3,56 @@
 # 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
+
+module CoreEx
+
+  module 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 import
+      to_path.import
+    end
+
+    def to_path
+      ::Pathname.new(self)
+    end
+
+    def rec_fold ( init, &block )
+      if include? "\n"
+        super
+      else
+        block[init, self]
+      end
+    end
+
+    def width
+      size + count("\t") * 7 # TABWIDTH(8) - 1
+    end
+
+    # XXX
+    # Do not implement to_io.
+    # It breaks File.exists?
+    # def to_io
+    # end
+    # XXX
+  end # module String
+
+end # module CoreEx
 

data/lib/core_ex/time.rb

@@ -1,65 +1,48 @@
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
 # License::   GNU General Public License (GPL).
-# Revision::  $Id: time.rb 281 2005-06-05 21:39:51Z ertai $
+# Revision::  $Id: time.rb 336 2005-09-06 20:32:49Z ertai $
 
-require 'core_ex'
-require 'time'
 
-class Time
+module CoreEx
 
-  PRECISION = 1e-016
+  module Time
 
-  def float_minus ( rhs )
-    diff = to_f - rhs.to_f
-    (diff / PRECISION).to_i * PRECISION
-  end
-  private :float_minus
-
-
-  undef :-
-  undef :+
-
-
-  def - ( rhs )
-    case rhs
-    when Time
-      DTime.new(float_minus(rhs))
-    when 0
-      self
-    when Numeric
-      Time.at(float_minus(rhs)).utc
-    when DTime
-      Time.at(float_minus(rhs)).utc
-    else
-      raise TypeError, rhs
+    setup do
+      alias_method :minus_without_d_time, :-
+      remove_method :-
     end
-  end
-
 
-  def + ( rhs )
-    if rhs.is_a? Numeric or rhs.is_a? DTime
-      Time.at(to_f + rhs.to_f).utc
-    else
-      raise TypeError, rhs
+    def - ( rhs )
+      diff = minus_without_d_time(rhs)
+      (defined? DTime and rhs.is_a? Time)? DTime.new(diff) : diff
     end
-  end
 
+    module ClassMethods
 
-  def self.diff ( *args, &block )
-    DTime.diff(*args, &block)
-  end
+      def diff ( *args, &block )
+        DTime.diff(*args, &block)
+      end
 
-end # class Time
+    end # module ClassMethods
 
+  end # module Time
+
+end # module CoreEx
 
 
 test_section __FILE__ do
 
+  DTime.import!
+
   class TimeExTest < Test::Unit::TestCase
 
     def setup
-      @t1, @t2 = Time.now, Time.now
+      @t1, @t2 = Time.at(1125583814.373), Time.at(1125583801.445)
+    end
+
+    def test_mixed
+      assert ::Time.include?(CoreEx::Time)
     end
 
     def test_minus
@@ -83,6 +66,8 @@ test_section __FILE__ do
       d1 = @t1 - @t2
       assert_raise(TypeError) { @t1 + @t2 }
       assert_kind_of(Time, @t1 + d1)
+      assert_kind_of(Time, @t2 + d1)
+      assert_in_delta(@t1.utc.to_f, (@t2 + d1).to_f, 1e-06)
     end
 
   end # TimeExTest

data/lib/core_ex/try_dup.rb

@@ -0,0 +1,68 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: try_dup.rb 334 2005-09-04 14:29:40Z ertai $
+
+
+module CoreEx
+
+  # Some objects are dupable, some are not.  So we define a version of
+  # dup (called try_dup) that returns self on the handful of classes
+  # that are not dupable. (imported from rake (rake_dup))
+  module TryDup
+
+    # Duplicate an object if it can be duplicated.  If it can not be
+    # cloned or duplicated, then just return the original object.
+    def try_dup
+      self
+    end
+
+  end # module TryDup
+
+end # module CoreEx
+
+
+class Object
+
+  # Duplicate an object if it can be duplicated.  If it can not be
+  # cloned or duplicated, then just return the original object.
+  def try_dup
+    dup
+  end
+
+end # class Object
+
+
+[NilClass, FalseClass, TrueClass, Fixnum, Symbol, Fixnum, Float].each do |aClass|
+  aClass.class_eval do
+    include CoreEx::TryDup
+  end
+end
+
+
+
+test_section __FILE__ do
+  class TestTryDup < ::Test::Unit::TestCase
+
+    def setup
+      @s = "a simple string"
+    end
+
+    def teardown
+    end
+
+    def test_simple
+      assert_nothing_raised do
+        assert_equal nil, nil.try_dup
+        assert_equal true, true.try_dup
+        assert_equal false, false.try_dup
+        assert_equal 4, 4.try_dup
+        assert_equal 5.5, 5.5.try_dup
+        assert_equal :foo, :foo.try_dup
+        assert_equal @s, @s.try_dup
+        assert_not_equal @s.object_id, @s.try_dup
+      end
+    end
+
+  end # class TestTryDup
+end