core_ex 0.2.0 → 0.3.1

data/lib/core_ex/object/instance_eval_with_args.rb

@@ -0,0 +1,56 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: instance_eval_with_args.rb 355 2005-09-15 23:18:43Z ertai $
+
+
+module CoreEx
+
+  module Object
+
+    module InstanceEvalWithArgs
+
+      @@seed ||= 0
+
+      def instance_eval_with_args ( *args, &block )
+        raise ArgumentError, "no block given" if block.nil?
+        method_name = :"instance_eval_temporary_method#{object_id}.#{@@seed}"
+        @@seed += 1
+        define_singleton_method(method_name, &block)
+        begin
+          result = __send__(method_name, *args)
+        ensure
+          undef_singleton_method(method_name)
+        end
+        result
+      end
+
+    end # module InstanceEvalWithArgs
+
+  end # module Object
+
+end # module CoreEx
+
+
+test_section __FILE__ do
+
+  class TestInstanceEvalWithArgs < ::Test::Unit::TestCase
+
+    def setup
+    end
+
+    def teardown
+    end
+
+    def test_instance_eval
+      assert_nothing_raised do
+        @res = "foo".instance_eval_with_args(42) do |x|
+          x + 1
+        end
+      end
+      assert_equal 43, @res
+    end
+
+  end # class TestInstanceEvalWithArgs
+
+end

data/lib/core_ex/object/singleton_class.rb

@@ -0,0 +1,78 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: singleton_class.rb 332 2005-09-04 14:01:01Z ertai $
+
+
+module CoreEx
+
+  module Object
+
+    module SingletonClass
+
+      def singleton_class
+        class << self
+          self
+        end
+      end
+
+      def define_singleton_method ( method_name, *a, &b )
+        singleton_class.send(:define_method, method_name, *a, &b)
+      end
+      private :define_singleton_method
+
+      def undef_singleton_method ( method_name )
+        singleton_class.send(:undef_method, method_name)
+      end
+      private :undef_singleton_method
+
+      def singleton_class_eval ( *args, &block )
+        if block.nil? or args.empty?
+          singleton_class.class_eval(*args, &block)
+        else
+          singleton_class.instance_eval(*args, &block)
+        end
+      end
+
+    end # module SingletonClass
+
+
+    test_section __FILE__ do
+
+      class TestSingletonClass < ::Test::Unit::TestCase
+
+        def setup
+          @string = 'foo'
+        end
+
+        def teardown
+        end
+
+        def test_singleton_class
+          assert_nothing_raised do
+            assert_kind_of Class, @string.singleton_class, 'not a class'
+          end
+          assert_equal @string.singleton_class.object_id,
+                       @string.singleton_class.object_id, 'not the same object id'
+          assert_equal ::String, @string.singleton_class.superclass, 'bad super class'
+        end
+
+        def test_define_and_undef_singleton_method
+          assert_nothing_raised do
+            @string.send(:define_singleton_method, :foo) { 42 }
+          end
+          assert_equal 42, @string.foo
+          assert_raise(NoMethodError) { @string.dup.foo }
+          assert_nothing_raised do
+            @string.send(:undef_singleton_method, :foo)
+          end
+          assert_raise(NoMethodError) { @string.foo }
+        end
+
+      end # class TestSingletonClass
+
+    end
+
+  end # module Object
+
+end # module CoreEx

data/lib/core_ex/object/the_first_time.rb

@@ -0,0 +1,32 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: the_first_time.rb 332 2005-09-04 14:01:01Z ertai $
+
+
+module CoreEx
+
+  module Object
+
+    module TheFirstTime
+
+      @@set = Set.new
+
+      def the_first_time ( &block )
+        id = block.source_file
+        return if @@set.include? id
+        @@set << id
+        block[]
+      end
+
+      alias_method :just_one_time, :the_first_time
+
+    end # module TheFirstTime
+
+  end # module Object
+
+end # module CoreEx
+
+test_section __FILE__ do
+
+end

data/lib/core_ex/pathname.rb

@@ -3,145 +3,211 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: pathname.rb 272 2005-06-02 23:47:29Z ertai $
+# $Id: pathname.rb 351 2005-09-14 08:33:42Z ertai $
 
 
-require 'pathname'
-require 'core_ex/embedded_tests'
-require 'core_ex/string'
-
-
-class Pathname
-
-  def ensure_mkdir
-    (mkdir) rescue Errno::EEXIST
-  end
-
-  def ensure_mkpath
-    (mkpath) rescue Errno::EEXIST
-  end
-
-  def extsplit ( aChar='.' )
-    raise ArgumentError, "#{aChar} is not just a char" if aChar.size != 1
-    aChar = Regexp.escape(aChar)
-    to_s =~ /^(.*?)(#{aChar}[^#{aChar}]*)?$/
-    [Pathname.new($1), $2 || '']
-  end
-
-  def cp ( aPath )
-    FileUtils.cp self.to_s, aPath.to_s
-  end
-
-  def mv ( aPath )
-    FileUtils.mv self.to_s, aPath.to_s
-  end
-
-  def cp_r ( aPath )
-    FileUtils.cp_r self.to_s, aPath.to_s
-  end
-
-  def rm
-    FileUtils.rm self.to_s
-  end
-
-  def rm_r
-    FileUtils.rm_r self.to_s
-  end
-
-  def rm_rf
-    FileUtils.rm_rf self.to_s
-  end
-
-  def rm_f
-    FileUtils.rm_f self.to_s
-  end
-
-  # The current ruby's unlink implementation has a bug.
-  def unlink()
-    if FileTest.directory? @path and not FileTest.symlink? @path
-      Dir.unlink @path
-    else
-      File.unlink @path
-    end
-  end
-
-  # Allow this kind of things:
-  #
-  #  root = Pathname.new('/tmp/test')
-  #  foo, bar = 'foo', 'bar'
-  #
-  #  ...
-  #
-  #  (root/foo/bar).each_line do |line|
-  #    ...
-  #  end
-  alias :/ :+
-
-  def to_io
-    @open_mode ||= 'r'
-    open(@open_mode)
-  end
-
-  def to_path
-    self
-  end
-
-  attr_accessor :open_mode
-
-  def require ( *a )
-    if a.empty?
-      RequireSystem.instance.require(self)
-    else
-      Kernel.__require__(*a)
-    end
-  end
-
-  def load ( *a )
-    if a.empty?
-      RequireSystem.instance.load(self)
-    else
-      Kernel.__load__(*a)
-    end
-  end
-
-  def expand_path_with ( directories, extensions=nil )
-    ext = extname
-    exts, dirs = [''], ['']
-    unless extensions.nil?
-      if ext.empty?
-        exts = extensions
+
+
+module CoreEx
+
+  module Pathname
+
+    setup do
+      have YamlExtension, :path
+      alias_method :split_no_args, :split
+    end
+
+    # Allow this kind of things:
+    #
+    #  root = Pathname.new('/tmp/test')
+    #  foo, bar = 'foo', 'bar'
+    #
+    #  ...
+    #
+    #  (root/foo/bar).each_line do |line|
+    #    ...
+    #  end
+    def / ( rhs )
+      self + rhs
+    end
+
+    def ensure_mkdir
+      (mkdir) rescue Errno::EEXIST
+    end
+
+    def ensure_mkpath
+      (mkpath) rescue Errno::EEXIST
+    end
+
+    def extsplit ( aChar='.' )
+      raise ArgumentError, "#{aChar} is not just a char" if aChar.size != 1
+      aChar = Regexp.escape(aChar)
+      to_s =~ /^(.*?)(#{aChar}[^#{aChar}]*)?$/
+      [::Pathname.new($1), $2 || '']
+    end
+
+    # Replace the file extension with +newext+.  If there is no
+    # extenson on the string, append the new extension to the end.  If
+    # the new extension is not given, or is the empty string, remove
+    # any existing extension.
+    #
+    # +ext+ is a user added method for the String class.
+    def ext(newext='')
+      str = self.to_s
+      return self if ['.', '..'].include? str
+      if newext != ''
+        newext = (newext =~ /^\./) ? newext : ("." + newext)
+      end
+      (str.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || str + newext).to_path
+    end
+
+    def split ( *args )
+      args.shift if args.first == '/'
+      split_no_args(*args)
+    end
+
+    def cp ( aPath )
+      ::FileUtils.cp self.to_s, aPath.to_s
+    end
+
+    def mv ( aPath )
+      ::FileUtils.mv self.to_s, aPath.to_s
+    end
+
+    def cp_r ( aPath )
+      ::FileUtils.cp_r self.to_s, aPath.to_s
+    end
+
+    def rm
+      ::FileUtils.rm self.to_s
+    end
+
+    def rm_r
+      ::FileUtils.rm_r self.to_s
+    end
+
+    def rm_rf
+      ::FileUtils.rm_rf self.to_s
+    end
+
+    def rm_f
+      ::FileUtils.rm_f self.to_s
+    end
+
+    # The current ruby's unlink implementation has a bug.
+    def unlink()
+      if FileTest.directory? @path and not FileTest.symlink? @path
+        Dir.unlink @path
       else
-        unless extensions.include? ext
-          raise ArgumentError, "bad extension `#{ext}' for #{self}"
+        File.unlink @path
+      end
+    end
+
+    def to_io
+      @open_mode ||= :r
+      open(@open_mode.to_s)
+    end
+
+    def to_path
+      self
+    end
+
+    def to_yaml_string
+      to_s
+    end
+
+    attr_accessor :open_mode
+
+    def split_with_load_path ( load_paths=Controllers.load_paths )
+      str = to_s
+      load_paths = load_paths.sort { |x, y| y.to_path.to_s.size <=> x.to_path.to_s.size }
+      load_paths.each do |load_path|
+        if str =~ /^#{Regexp.quote(load_path.to_path)}\/*(.*)/
+          return [load_path.to_path, Regexp.last_match[1].to_path]
         end
       end
+      return nil
+    end
+
+    def import!
+      base_path = expand_path.cleanpath.to_s.gsub(/\/+/, '/').to_path.split_with_load_path.last
+      Dependencies.depend_on to_s unless base_path.ext.to_s.camelize.constantize
+    end
+
+    def load_path!
+      string = expand_path.cleanpath.to_s
+      raise "bad path name `#{string}' need a directory" unless directory?
+      raise 'bad Controllers' unless Controllers.is_a? Dependencies::RootLoadingModule
+      path = string.to_path
+      return false if Controllers.load_paths.any? { |c| c.to_path == path }
+      Controllers.load_paths.unshift Dependencies::ConstantLoadPath.new(string)
+      $LOAD_PATH.unshift string
     end
-   
-    dirs = directories unless absolute?
-      
-    exts.each do |ext|
-      dirs.each do |dir|
-        dir = dir.to_path
-        file = dir + "#{self}#{ext}"
-        return file.expand_path.cleanpath if file.exist?
+
+    def expand_path_with ( directories, extensions=nil )
+      ext = extname
+      exts, dirs = [''], ['']
+      unless extensions.nil?
+        if ext.empty?
+          exts = extensions
+        else
+          unless extensions.include? ext
+            raise ArgumentError, "bad extension `#{ext}' for #{self}"
+          end
+        end
+      end
+
+      dirs = directories unless absolute?
+
+      exts.each do |ext|
+        dirs.each do |dir|
+          dir = dir.to_path
+          file = dir + "#{self}#{ext}"
+          return file.expand_path.cleanpath if file.exist?
+        end
       end
+      return nil
     end
-    return nil
-  end
 
-  module ShortCut
+    module ShortCut
 
-    # Allow to use this sort of constructions:
-    #
-    #  `/path/to/a/file`.open do |f|
-    #    ...
-    #  end
-    def ` ( path )
-      Pathname.new(path)
+      # Allow to use this sort of constructions:
+      #
+      #  `/path/to/a/file`.open do |f|
+      #    ...
+      #  end
+      def ` ( path )
+        ::Pathname.new(path)
+      end
     end
-  end
 
-end # class Pathname
+    module ClassMethods
+
+      def yaml_load ( val )
+        new(val.to_s)
+      end
+
+    end # module ClassMethods
+
+    module Assertions
+
+      def assert_expand_path_with ( inp, ref, load_path=(@load_path || $LOAD_PATH) )
+        assert_nothing_raised do
+          @my = inp.expand_path_with(load_path, %w[ .rb .so .bundle .o .dll ] << '')
+          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
+
+    end # module Assertions
+
+  end # module Pathname
+
+end # module CoreEx
 
 
 
@@ -150,51 +216,89 @@ end # class Pathname
 #
 test_section __FILE__ do
 
+  require 'tempfile'
+
+  module CoreEx
+
+    class PathnameExTest < Test::Unit::TestCase
+      include YamlExtension::Assertions
+      include CoreEx::Pathname::Assertions
+
+      def setup
+       @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
+       @load_path = $LOAD_PATH
+      end
 
-require 'tempfile'
+      #
+      # Tests
+      #
+      def test_ensure_dir
+        p = nil
+        begin
+          name = Tempfile.new('pathname')
+          p = name.path.to_path
+          name.delete
+          assert(! p.directory?, 'no directory')
+          assert_nothing_raised { p.ensure_mkdir }
+          assert(p.directory?, 'directory')
+          assert_nothing_raised { p.ensure_mkdir }
+          assert(p.directory?, 'still directory')
+        ensure
+          p.rmdir unless p.nil?
+        end
+      end
 
+      include Pathname::ShortCut
 
-class PathnameExTest < Test::Unit::TestCase
+      def test_simple
+        assert_equal([`path.ext1`, '.ext2'], `path.ext1.ext2`.extsplit)
+        assert_equal([`path`, ''], `path`.extsplit)
+        assert_equal([`path`, '.'], `path.`.extsplit)
+        assert_equal([`path`, '-ext'], `path-ext`.extsplit('-'))
+        assert_equal([`path-ext1`, '-ext2'], `path-ext1-ext2`.extsplit('-'))
+      end
 
-  #
-  # Tests
-  #
-  def test_ensure_dir
-    p = nil
-    begin
-      name = Tempfile.new('pathname')
-      p = Pathname.new(name.path)
-      name.delete
-      assert(! p.directory?, 'no directory')
-      assert_nothing_raised { p.ensure_mkdir }
-      assert(p.directory?, 'directory')
-      assert_nothing_raised { p.ensure_mkdir }
-      assert(p.directory?, 'still directory')
-    ensure
-      p.rmdir unless p.nil?
-    end
-  end
+      def test_slash
+        assert_equal(`path/to/a/file`, `path`/'to'/'a'/'file')
+        path, to, a, file = `/path`, 'to', 'a', 'file'
+        assert_equal(`/path/to/a/file`, path/to/a/file)
+      end
 
-  include Pathname::ShortCut
+      def test_1_expand_path_with
+        @lp.each { |x| assert_expand_path_with(x, nil) }
+      end
 
-  def test_simple
-    assert_equal([`path.ext1`, '.ext2'], `path.ext1.ext2`.extsplit)
-    assert_equal([`path`, ''], `path`.extsplit)
-    assert_equal([`path`, '.'], `path.`.extsplit)
-    assert_equal([`path`, '-ext'], `path-ext`.extsplit('-'))
-    assert_equal([`path-ext1`, '-ext2'], `path-ext1-ext2`.extsplit('-'))
-  end
+      def test_2_expand_path_with
+        @load_path << @req
+        @lp.delete(@p_dne)
+        @lp.each { |x| assert_expand_path_with(x, @req + x) }
+        @lp.each { |x| assert_expand_path_with(@req + x, @req + x) }
+        assert_expand_path_with(@p_dne, nil)
+      end
 
-  def test_slash
-    assert_equal(`path/to/a/file`, `path`/'to'/'a'/'file')
-    path, to, a, file = `/path`, 'to', 'a', 'file'
-    assert_equal(`/path/to/a/file`, path/to/a/file)
-  end
+      def test_yaml
+        str = 'foo/bar/baz.rb'
+        assert_yaml_load "--- !path #{str}", ::Pathname, str.to_path
+        assert_equal('baz.rb', @val.basename.to_s)
+        assert_equal(str, @val.to_s)
+        assert_yaml_dump str.to_path, @ref
+      end
 
-  # def test_expand_path_with
-  #   See core_ex/require RequireSystemTest#test_*_search
-  # end
+    end # class PathnameExTest
 
-end # class PathnameExTest
+  end # module CoreEx
 
 end