core_ex 0.2.0 → 0.3.1

data/lib/core_ex/yaml.rb

@@ -1,54 +1,18 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: yaml.rb 300 2005-06-23 20:45:47Z ertai $
-
-require 'yaml'
-require 'core_ex'
-
-
-class Class
-  
-  def yaml_extension ( theYamlType=nil )
-    case theYamlType
-    when NilClass
-      theYamlType = "!#{self.name.downcase}"
-    when String
-      theYamlType = theYamlType
-    when Symbol
-      theYamlType = "!#{theYamlType}"
-    else
-      raise ArgumentError, "Expect a symbol or a string not: #{theYamlType}"
-    end
+# Revision::  $Id: yaml.rb 342 2005-09-08 01:12:48Z ertai $
 
-    class_eval do
-      undef to_yaml_type
-      undef to_yaml
-      def to_yaml ( opts={} )
-        YAML::quick_emit(self.object_id, opts) do |out|
-          out << "#{to_yaml_type} #{to_yaml_string}"
-        end
-      end
-    end
 
-    class_eval %{
-      def to_yaml_type
-        '#{theYamlType}'
-      end
-    }
-
-    theClass = self
-    YAML.add_builtin_type(theYamlType) do |type, val|
-      theClass.yaml_load val
-    end
-  end
-
-end # class Class
+module CoreEx
 
+  module Yaml
+  end # module Yaml
 
+end # module CoreEx
 
 class Regexp
-  yaml_extension :re
+  have YamlExtension, :re
 
   def to_yaml_string
     source
@@ -78,7 +42,7 @@ end # class Regexp
 
 
 class Range
-  yaml_extension
+  have YamlExtension
 
   def to_yaml_string
     to_s
@@ -94,48 +58,77 @@ end # class Range
 
 
 
-class Proc
-  yaml_extension
+class Array
 
-  def self.yaml_load ( val )
-    DumpableProc.new(val.to_s)
+  alias_method :old_to_yaml, :to_yaml
+
+  def to_yaml ( opts={} )
+    em = opts[:Emitter]
+    if (opts[:Inline] or (em and em.options[:Inline])) and not is_complex_yaml?
+      YAML::quick_emit(self.object_id, opts) do |out|
+        out << '['
+        first = true
+        each do |x|
+          if first
+            first = false
+          else
+            out << ', '
+          end
+          x.to_yaml(:Emitter => out)
+        end
+        out << ']'
+      end
+    else
+      old_to_yaml(opts)
+    end
   end
 
-  def to_yaml_string
-    to_s
+
+  undef_method :is_complex_yaml?
+
+  def is_complex_yaml?
+    any? { |x| x.is_complex_yaml? } or inspect.size > 80
   end
 
-end # class Proc
+end # class Array
 
 
 
-class PathList
-  yaml_extension :filelist
+class Hash
 
-  def self.yaml_load ( val )
-    new(val)
-  end
+  alias_method :old_to_yaml, :to_yaml
 
-  undef to_yaml
   def to_yaml ( opts={} )
-    to_a.to_yaml(opts)
+    em = opts[:Emitter]
+    if (opts[:Inline] or (em and em.options[:Inline])) and not is_complex_yaml?
+      YAML::quick_emit(self.object_id, opts) do |out|
+        out << '{'
+        first = true
+        each do |k, v|
+          if first
+            first = false
+          else
+            out << ', '
+          end
+          k.to_yaml(:Emitter => out)
+          out << ': '
+          v.to_yaml(:Emitter => out)
+        end
+        out << '}'
+      end
+    else
+      old_to_yaml(opts)
+    end
   end
 
-end # class PathList
-
 
-class Pathname
-  yaml_extension :path
-
-  def to_yaml_string
-    to_s
-  end
+  undef_method :is_complex_yaml?
 
-  def self.yaml_load ( val )
-    new(val.to_s)
+  def is_complex_yaml?
+    any? { |x| x.is_complex_yaml? } or inspect.size > 80
   end
 
-end # class Pathname
+end # class Hash
 
 
 
@@ -148,19 +141,7 @@ end
 test_section __FILE__ do
 
   class YamlExTest < Test::Unit::TestCase
-
-    def assert_yaml_load ( aString, aClass, anObject=nil ) 
-      assert_nothing_raised { @val = YAML::load(aString) }
-      assert_kind_of(aClass, @val)
-      assert_equal(anObject, @val) unless anObject.nil?
-      @ref = aString
-    end
-
-    def assert_yaml_dump ( anObject, aString ) 
-      assert_nothing_raised { @str = anObject.to_yaml }
-      assert_equal(aString, @str)
-    end
-
+    include YamlExtension::Assertions
 
 
     def test_regexp
@@ -179,14 +160,6 @@ test_section __FILE__ do
       assert_match(@val, "af\nffb")
     end
 
-    def test_pathname
-      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_range
       assert_yaml_load "--- !range 0..10", Range, 0..10
       assert_yaml_dump @val, @ref
@@ -194,21 +167,51 @@ test_section __FILE__ do
       assert_yaml_dump @val, @ref
     end
 
-    def test_proc
-      assert_yaml_load "--- !proc 3 + 7", Proc
-      assert_yaml_dump @val, @ref
-      assert_equal(10, @val[])
+    def test_ruby
+      assert_yaml_load "--- !ruby 2 + 4", Integer, 6
+      assert_yaml_load "--- !ruby '[2, 4]'", Array, [2, 4]
     end
 
-    def test_pathlist
-      ls = __FILE__.to_path.dirname + '*.rb'
-      assert_yaml_load "--- !filelist #{ls}", PathList, PathList[ls]
-      assert_yaml_dump @val, @val.to_a.to_yaml
+    def test_array
+      opts = { :Inline => true }
+      assert_yaml_load '--- [2, "4"]', Array, [2, '4']
+      assert_yaml_dump @val, @ref, opts
+      assert_yaml_load '--- [2, "4"]', Array, [2, '4']
+      assert_yaml_dump @val, "--- \n- 2\n- \"4\""
+      assert_yaml_load "--- [2, [!range 1..4]]", Array, [2, [1..4]]
+      assert_yaml_dump @val, "--- \n- 2\n- \n  - !range 1..4", opts
+      arr = (0 .. 25).to_a
+      str = arr.join(', ')
+      str2 = arr.join("\n- ")
+      assert_yaml_load "--- [#{str}]", Array, arr
+      assert_yaml_dump @val, "--- \n- #{str2}", opts
+      assert_yaml_load '--- [2, {a: 4}]', Array, [2, {'a' => 4}]
+      assert_yaml_dump @val, @ref, opts
     end
 
-    def test_ruby
-      assert_yaml_load "--- !ruby 2 + 4", Integer, 6
-      assert_yaml_load "--- !ruby '[2, 4]'", Array, [2, 4]
+    def test_hash
+      opts = { :Inline => true }
+      assert_yaml_load '--- {a: "4"}', Hash, { 'a' => '4' }
+      assert_yaml_dump @val, @ref, opts
+      assert_yaml_load '--- {a: "4"}', Hash, { 'a' => '4' }
+      assert_yaml_dump @val, "--- \na: \"4\""
+      assert_yaml_load "--- {a: [4]}", Hash, { 'a' => [4] }
+      assert_yaml_dump @val, @ref, opts
+      hash = Hash[*(0 .. 23).to_a]
+      arr = hash.map{|k,v| "#{k}: #{v}"}.sort
+      str = arr.join(', ')
+      str2 = arr.join('|')
+      assert_yaml_load "--- {#{str}}", Hash, hash
+      assert_yaml_dump @val, /\A--- \n(?:(?:#{str2})\n)*(?:#{str2})\Z/, opts
+    end
+
+    def test_no_inline
+      opts = { :Inline => false }
+      hash = Hash[*(0 .. 3).to_a]
+      tree = [hash.dup, hash.dup, hash.dup, hash.dup]
+      @no_inline = "--- \n- \n  0: 1\n  2: 3\n- \n  0: 1\n  2: 3\n- \n  0: 1\n  2: 3\n- \n  0: 1\n  2: 3"
+      assert_yaml_dump tree, @no_inline, opts
+      assert_yaml_dump tree, @no_inline
     end
 
   end # class YamlExTest

data/lib/core_ex.rb

@@ -1,56 +1,267 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: core_ex.rb 301 2005-06-23 20:57:05Z ertai $
+# Revision::  $Id: core_ex.rb 352 2005-09-15 01:43:03Z ertai $
 
-require 'pathname'
+unless defined? CORE_EX_LOADED and CORE_EX_LOADED
+  CORE_EX_LOADED = true
+  $LOADED_FEATURES << 'core_ex.rb' unless $LOADED_FEATURES.include? 'core_ex.rb'
 
-module CoreEx
-  @@dir = Pathname.new(__FILE__).dirname.expand_path
-  $: << @@dir.to_s
-  $" << 'core_ex.rb' unless $".include? 'core_ex.rb'
+  require 'pathname'
+  require 'set'
+
+  CORE_EX_DIR = Pathname.new(__FILE__).dirname.expand_path.cleanpath
+
+  core_ex_long = (CORE_EX_DIR + 'core_ex.rb').to_s
+  $LOADED_FEATURES << core_ex_long unless $LOADED_FEATURES.include? core_ex_long
+
+  CORE_EX_VENDORS = [] unless defined? CORE_EX_VENDORS
+  CORE_EX_VENDORS << CORE_EX_DIR.parent + 'vendor'
 
-  @@core_ex = @@dir + 'core_ex'
+  def core_ex_debug ( &block )
+    # STDERR.puts block[].inspect
+  end
 
-  %w[ embedded_tests pathname require ].each do |aPath|
-    require "core_ex/#{aPath}"
+  def core_ex_vendor_require ( dir_name, dir_version='*' )
+    if CORE_EX_VENDORS.any? { |dir| dir.exist? }
+      dir = Pathname.glob("{#{CORE_EX_VENDORS.join(',')}}/#{dir_name}#{dir_version}/{lib,}").first
+      if dir and dir.directory?
+        if defined? CoreEx::Pathname and Pathname.include? CoreEx::Pathname
+          dir.load_path!
+        else
+          $LOAD_PATH << dir.to_s
+        end
+        core_ex_debug { [:vendor, dir_name, dir_version] }
+      else
+        raise LoadError, "no vendor dir #{dir}"
+      end
+    else
+      core_ex_debug { :novendor }
+    end
   end
-  RequireSystem.instance
-  %w[ attr_once enumerable exception
-      string fileutils pathlist yaml ].each do |aPath|
-    (@@core_ex + aPath).require
+
+  def core_ex_register_vendor ( dir )
+    CORE_EX_VENDORS << dir unless CORE_EX_VENDORS.include? dir
   end
 
-  def self.each ( &block )
-    @@core_list ||= PathList[@@core_ex + '**/*.rb']
-    @@core_list.each(&block)
+  begin
+    require 'rubygems'
+    def core_ex_gem_require ( gem_name, gem_version='> 0' )
+      require_gem gem_name, gem_version
+      core_ex_debug { [:require_gem, gem_name, gem_version] }
+    end
+  rescue LoadError => ex
+    def core_ex_gem_require ( *a, &b )
+      core_ex_debug { :nogem }
+    end
   end
 
-  def self.require
-    @@core_list ||= PathList[@@core_ex + '**/*.rb']
-    @@core_list.require
+  def core_ex_require ( name, gem_name=name, dir_name=name, gem_version='> 0', dir_version='*' )
+    begin
+      core_ex_vendor_require(dir_name, dir_version)
+    rescue LoadError => ex
+      begin
+        core_ex_gem_require(gem_name, gem_version)
+      rescue LoadError
+      end
+    end
+    require name
   end
 
-  def self.dir
-    @@dir
+  verbose = $VERBOSE
+  $VERBOSE = false
+  core_ex_require 'active_support', 'activesupport', 'activesupport', '~> 1.1.1', '-1.1.1'
+
+# <<< little active_support patch
+module Inflector
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z])/,'_\1').gsub(/(^|\/)_/, '\1').downcase
+  end
+  def constantize(camel_cased_word, start=Object)
+    camel_cased_word.split("::").inject(start) do |final_type, part|
+      return nil unless final_type.const_defined? part
+      final_type.const_get(part)
+    end
+  end
+end # module Inflector
+module Dependencies
+  class LoadingModule
+    def const_load!(name, file_name = nil)
+      file_name ||= 'application' if root? && name.to_s == 'ApplicationController'
+      path = self.path + [file_name || name]
+
+      load_paths.each do |load_path|
+        fs_path = load_path.filesystem_path(path)
+        next unless fs_path
+
+        case
+        when File.directory?(fs_path)
+          new_module = LoadingModule.new(self.root, self.path + [name])
+          self.const_set name, new_module
+          if self.root?
+            if Object.const_defined?(name)
+              msg = "Cannot load module #{name}: Object::#{name} is set to #{Object.const_get(name).inspect}"
+              raise NameError, msg
+            end
+            Object.const_set(name, new_module)
+          end
+          # <<<
+          module_fs_path = fs_path + '.rb'
+          self.root.load_file!(module_fs_path) if File.exist?(module_fs_path)
+          # >>>
+          break
+        when File.file?(fs_path)
+          self.root.load_file!(fs_path)
+
+          # Import the loaded constant from Object provided we are the root node.
+          self.const_set(name, Object.const_get(name)) if self.root? && Object.const_defined?(name)
+          break
+        end
+      end
+
+      self.const_defined?(name)
+    end
+  end # class LoadingModule
+end # module Dependencies
+# >>>
+
+$VERBOSE = verbose
+
+DEPENDENCIES_MECHANISM = :require unless defined? DEPENDENCIES_MECHANISM
+Dependencies.mechanism = DEPENDENCIES_MECHANISM
+
+if Object.const_defined? :Controllers
+  # Perhaps a rails environement
+  raise 'bad Controllers' unless Controllers.is_a? Dependencies::RootLoadingModule
+  Controllers.load_paths << Dependencies::ConstantLoadPath.new(CORE_EX_DIR.to_s)
+else
+  Controllers = Dependencies::LoadingModule.root(CORE_EX_DIR.to_s)
+end
+Controllers::CoreEx.name # .import! is not yet defined
+Controllers::Test::Unit::UI::Yaml.name
+
+module CoreEx
+
+  module_function
+
+  def dir
+    CORE_EX_DIR
+  end
+
+  def core_ex
+    dir + 'core_ex'
   end
 
 end # module CoreEx
 
-core_ex = CoreEx.dir + 'core_ex'
-{
-  :Time         => 'time',
-  :DTime        => 'dtime',
-  :DumpableProc => 'dumpable_proc',
-  :Version      => 'version',
-  :Test         => 'test/unit/ui/yaml/testrunner',
-  :TempPath     => 'temp_path'
-}.each do |k, v|
-  k = [k] unless k.is_a? Enumerable
-  v = [v] unless v.is_a? Enumerable
-  k.each do |aConst|
-    v.each do |aPath|
-      Kernel.autoload(aConst, (core_ex + aPath).to_s)
+class Object
+  include CoreEx::EmbeddedTests
+end # class Object
+if defined? EMBEDDED_TEST_MODE
+  embedded_test_mode EMBEDDED_TEST_MODE
+end
+
+class String
+  include CoreEx::String
+end # class String
+
+class Module
+  include CoreEx::Module::MixInWithArgs
+  include CoreEx::Module::AttrOnce
+  include CoreEx::Module::Import
+end # class Module
+
+class Object
+  include CoreEx::Object::TheFirstTime
+  include CoreEx::Object::SingletonClass
+  include CoreEx::Object::InstanceEvalWithArgs
+end # class Object
+
+class Proc
+  include CoreEx::Proc
+end # class Proc
+
+module Dependencies
+  class ConstantLoadPath
+    include CoreEx::DependenciesExt::ConstantLoadPath
+  end # class ConstantLoadPath
+end # module Dependencies
+
+class Pathname
+  include CoreEx::Pathname
+end # class Pathname
+
+$LOADED_FEATURES.dup.each do |feature|
+  if (path = Pathname.new(feature)).absolute?
+    load_path, base_path = path.split_with_load_path($LOAD_PATH)
+    unless load_path.nil?
+      new_feature = base_path.to_s
+      next if $LOADED_FEATURES.include? new_feature
+      $LOADED_FEATURES << new_feature
+    end
+  end
+end
+
+module Kernel
+
+  alias_method :require_without_unification, :require
+  def require ( file, *a )
+    if (path = Pathname.new(file)).absolute?
+      load_path, base_path = path.split_with_load_path
+      unless load_path.nil?
+        feature = base_path.to_s
+        return false if $LOADED_FEATURES.include? feature
+        $LOADED_FEATURES << feature
+      end
     end
+    require_without_unification(file, *a)
   end
+
+end # module Kernel
+
+module Enumerable
+  include CoreEx::Enumerable
+end # module Enumerable
+
+class Exception
+  include CoreEx::Exception
+end # class Exception
+
+require 'fileutils'
+module FileUtils
+  include CoreEx::FileUtils::RemoveDir
+end # module FileUtils
+
+require 'time'
+class Time
+  include CoreEx::Time
+end # class Time
+
+CoreEx::Yaml.import!
+CoreEx::TryDup.import!
+
+
+require 'pp'
+silence_warnings { require 'active_support/breakpoint' }
+
+test_section __FILE__ do
+
+  class TestCoreEx < ::Test::Unit::TestCase
+
+    def setup
+    end
+
+    def teardown
+    end
+
+    def test_simple
+      assert_kind_of Dependencies::LoadingModule, Controllers::CoreEx
+      assert_raise(NameError) { EmbeddedTests }
+      assert_kind_of Module, CoreEx::EmbeddedTests
+    end
+
+  end # class TestCoreEx
+
+end
+
 end

data/lib/{core_ex/dtime.rb → d_time.rb}

@@ -1,16 +1,13 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
+# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: d_time.rb 334 2005-09-04 14:29:40Z ertai $
 
-# $LastChangedBy: ertai $
-# $Id: dtime.rb 252 2005-05-31 23:41:42Z ertai $
 
 
-require 'core_ex'
-require 'core_ex/time'
-
 
 class DTime
+  have YamlExtension
 
   def initialize(delta)
     @delta = delta.to_f.abs
@@ -26,7 +23,16 @@ class DTime
   end
 
   def inspect
-    "#@day days #@hour hours #@min mins #@sec secs".freeze
+    res = []
+    res << "#@day days" unless @day.zero?
+    res << "#@hour hours" unless @hour.zero?
+    res << "#@min mins" unless @min.zero?
+    res << "#@sec secs" if res.empty? or not @sec.zero?
+    res.join ' '
+  end
+
+  def to_yaml_string
+    inspect
   end
 
   def to_a
@@ -55,21 +61,22 @@ class DTime
     @delta.round
   end
 
-  def to_yaml(opts={})
-    ((@day != 0 ? "#@day days " : '') +
-     (@hour != 0 ? "#@hour hours " : '') +
-     (@min != 0 ? "#@min mins " : '') +
-     "#@sec secs").to_yaml(opts)
-  end
-
   def self.diff ( *args, &block )
     start = Time.now
     block[*args]
     return Time.now - start
   end
 
+  def == ( rhs )
+    @delta == rhs.to_f
+  end
+
+  def method_missing ( *a, &b )
+    @delta.send(*a, &b)
+  end
+
   attr_once :to_s, :inspect, :to_a, :to_i, :hash, :to_hash, :floor,
-            :round, :to_yaml
+            :round
 
 end # class DTime
 
@@ -77,6 +84,7 @@ end # class DTime
 test_section __FILE__ do
 
 class DTimeTest < Test::Unit::TestCase
+  include YamlExtension::Assertions
 
   def test_simple
     d = DTime.new(260.33)
@@ -106,7 +114,7 @@ class DTimeTest < Test::Unit::TestCase
   def test_conversion
     d = DTime.new(260.75)
     assert_equal('260.75', d.to_s)
-    assert_equal('0 days 0 hours 4 mins 20.75 secs', d.inspect)
+    assert_equal('4 mins 20.75 secs', d.inspect)
     assert_equal(260, d.to_f.floor)
     assert_equal(260, d.to_i)
     assert_equal(260, d.floor)
@@ -129,13 +137,13 @@ class DTimeTest < Test::Unit::TestCase
 
   def test_to_yaml
     d = DTime.new(265678.42000)
-    assert_equal('--- 3 days 1 hours 47 mins 58.4199999999837 secs', d.to_yaml)
+    assert_yaml_dump(d, '--- !dtime 3 days 1 hours 47 mins 58.4199999999837 secs')
     d = DTime.new(5678.42000)
-    assert_equal('--- 1 hours 34 mins 38.4200000000001 secs', d.to_yaml)
+    assert_yaml_dump(d, '--- !dtime 1 hours 34 mins 38.4200000000001 secs')
     d = DTime.new(158.42000)
-    assert_equal('--- 2 mins 38.42 secs', d.to_yaml)
+    assert_yaml_dump(d, '--- !dtime 2 mins 38.42 secs')
     d = DTime.new(58.42000)
-    assert_equal('--- 58.42 secs', d.to_yaml)
+    assert_yaml_dump(d, '--- !dtime 58.42 secs')
   end
 
   def test_diff
@@ -162,6 +170,12 @@ class DTimeTest < Test::Unit::TestCase
     assert_equal(0, d.day)
   end
 
+  def test_method_missing
+    c = DTime.new 260.33
+    assert_nothing_raised { c /= 2 }
+    assert_nothing_raised { c > 3 }
+  end
+
 end # class DTimeTest
 
 

data/lib/{core_ex/dumpable_proc.rb → dumpable_proc.rb}

@@ -1,9 +1,8 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: dumpable_proc.rb 299 2005-06-19 10:47:10Z ertai $
+# Revision::  $Id: dumpable_proc.rb 334 2005-09-04 14:29:40Z ertai $
 
-require 'core_ex'
 
 class DumpableProc < Proc