core_ex 0.1.0

data/AUTHORS

@@ -0,0 +1,26 @@
+---
+CoreEx was written by and with the assistance of:
+
+  - Nicolas Despr�s <nicolas.despres@gmail.com>:
+      - Maintenance
+      - Module#attr_once
+      - DTime
+      - Exception extension
+      - Version
+
+  - Nicolas Pouillard <ertai@feydakins.org>:
+      - Maintenance
+      - Current repository administration
+
+      - Enumerable extension
+      - FileList extension
+      - FileUtils extension
+      - Pathname extension
+      - String extension
+      - Time extension
+      - YAML extension
+
+      - embedded_tests
+      - rakefile_base.rf
+      - RequireSystem
+      - TempPath

data/NEWS

@@ -0,0 +1,8 @@
+= New in 0.1, 2005-05-31:
+
+  CoreEx  is  designed  to provides a simple but quite useful extension of the
+  standard  library  of  Ruby. So some classes and modules like Pathname, Time,
+  Enumerable,  Exception,  FileUtils,  String,  and YAML are extended. There is
+  also   some   new   features   like   attr_once,  DTime,  TempPath,  Version,
+  embedded_tests,  filelist  (almost  from  rake),  a  common  Rakefile, and an
+  extension of the require system.

data/README

@@ -0,0 +1 @@
+Coming Soon.

data/Rakefile

@@ -0,0 +1,7 @@
+# Author::    The TTK Team.                                        -*- ruby -*-
+# Copyright:: Copyright (c) 2005 TTK team. All rights reserved.
+# License::   Ruby License
+# Revision::  $Id$
+
+$: << 'lib'
+load 'core_ex/rakefile_base.rf'

data/SPEC.dyn.yml

@@ -0,0 +1,8 @@
+--- !ruby/object:OpenStruct 
+table: 
+  :date: "Tue, 31 May 2005"
+  :version: !ruby/object:Version 
+    build: 0
+    major: 0
+    minor: 1
+    revision: 250

data/SPEC.yml

@@ -0,0 +1,37 @@
+---
+Author: The TTK Team.
+License: Ruby License
+Revision: '$Id$'
+
+name: core_ex
+
+title: CoreEx -- A proposal for a standard library extension.
+summary: CoreEx is a proposal for a standard library extension.
+description: >
+  CoreEx  is  designed  to provides a simple but quite useful extension of the
+  standard  library  of  Ruby. So some classes and modules like Pathname, Time,
+  Enumerable,  Exception,  FileUtils,  String,  and YAML are extended. There is
+  also   some   new   features   like   attr_once,  DTime,  TempPath,  Version,
+  embedded_tests,  filelist  (almost  from  rake),  a  common  Rakefile, and an
+  extension of the require system.
+homepage: http://api.feydakins.org/core_ex
+rubyforge_project: ttk
+
+root_test_suite: test/check-pkg-core_ex.yml
+rdoc_dir: doc/html
+tags_dir: ../../tags
+
+rdoc_files: !filelist
+  - README
+  - AUTHORS
+  - NEWS
+  - lib/core_ex.rb
+  - lib/core_ex/**/*.rb
+
+pkg_files: !filelist
+  - lib/**/*.rb
+  - test/**/*
+  - '[A-Z]*'
+
+#dependencies:
+#  ttk:           ~> 0.2.0

data/lib/core_ex/attr_once.rb

@@ -0,0 +1,36 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: attr_once.rb 249 2005-05-31 13:23:42Z ertai $
+
+
+class Module
+
+  # You can use this method as you use attr_reader. Must be used only with
+  # immutable object.
+  #
+  # This method is imported from the Date implementation. It provides a way
+  # to compute only once the value of getter. Basically, the first time, the
+  # getter is used, its result is computed and stored in an attribute with the
+  # same name. The second times only the attribute is returned.
+  def attr_once(*ids)
+    for id in ids
+      module_eval <<-"end;", __FILE__, __LINE__
+        alias_method :__#{id.to_i}__, :#{id.to_s}
+        private :__#{id.to_i}__
+        def #{id.to_s}(*args, &block)
+        if defined? @__#{id.to_i}__
+            @__#{id.to_i}__
+          elsif ! self.frozen?
+            @__#{id.to_i}__ ||= __#{id.to_i}__(*args, &block)
+          else
+            __#{id.to_i}__(*args, &block)
+          end
+        end
+      end;
+    end
+  end
+
+end # class Module

data/lib/core_ex/dtime.rb

@@ -0,0 +1,169 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: dtime.rb 252 2005-05-31 23:41:42Z ertai $
+
+
+require 'core_ex'
+require 'core_ex/time'
+
+
+class DTime
+
+  def initialize(delta)
+    @delta = delta.to_f.abs
+    @min, @sec = @delta.divmod(60)
+    @hour, @min = @min.floor.divmod(60)
+    @day, @hour = @hour.divmod(24)
+  end
+
+  attr_reader :delta, :sec, :min, :hour, :day
+
+  def to_s
+    @delta.to_s.freeze
+  end
+
+  def inspect
+    "#@day days #@hour hours #@min mins #@sec secs".freeze
+  end
+
+  def to_a
+    [ @day, @hour, @min, @sec ].freeze
+  end
+
+  def to_i
+    @delta.to_i
+  end
+
+  alias to_f delta
+
+  def hash
+    @delta.hash
+  end
+
+  def to_hash
+    { :days => @day, :hours => @hour, :mins => @min, :secs => @sec }.freeze
+  end
+
+  def floor
+    @delta.floor
+  end
+
+  def round
+    @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
+
+  attr_once :to_s, :inspect, :to_a, :to_i, :hash, :to_hash, :floor,
+            :round, :to_yaml
+
+end # class DTime
+
+
+test_section __FILE__ do
+
+class DTimeTest < Test::Unit::TestCase
+
+  def test_simple
+    d = DTime.new(260.33)
+    assert_equal(260, d.delta.floor)
+    assert_equal(20, d.sec.floor)
+    assert_equal(4, d.min)
+    assert_equal(0, d.hour)
+    assert_equal(0, d.day)
+  end
+
+  def test_complex
+    d = DTime.new(265678.42000)
+    assert_equal(265678, d.delta.floor)
+    assert_equal(58, d.sec.floor)
+    assert_equal(47, d.min)
+    assert_equal(1, d.hour)
+    assert_equal(3, d.day)
+    assert_equal([ 3, 1, 47 ], d.to_a[0..2])
+    assert_equal(58, d.to_a[3].floor)
+    h = d.to_hash
+    assert_equal(3, h[:days])
+    assert_equal(1, h[:hours])
+    assert_equal(47, h[:mins])
+    assert_equal(58, h[:secs].floor)
+  end
+
+  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(260, d.to_f.floor)
+    assert_equal(260, d.to_i)
+    assert_equal(260, d.floor)
+    assert_equal(261, d.round)
+  end
+
+  def test_negative
+    d = DTime.new(-265678.42000)
+    assert_equal(265678, d.delta.floor)
+    assert_equal(58, d.sec.floor)
+    assert_equal(47, d.min)
+    assert_equal(1, d.hour)
+    assert_equal(3, d.day)
+  end
+
+  def test_marshal
+    d = DTime.new(-265678.42000)
+    assert_equal(d.floor, Marshal.load(Marshal.dump(d)).floor)
+  end
+
+  def test_to_yaml
+    d = DTime.new(265678.42000)
+    assert_equal('--- 3 days 1 hours 47 mins 58.4199999999837 secs', d.to_yaml)
+    d = DTime.new(5678.42000)
+    assert_equal('--- 1 hours 34 mins 38.4200000000001 secs', d.to_yaml)
+    d = DTime.new(158.42000)
+    assert_equal('--- 2 mins 38.42 secs', d.to_yaml)
+    d = DTime.new(58.42000)
+    assert_equal('--- 58.42 secs', d.to_yaml)
+  end
+
+  def test_diff
+    @foo = 1
+    d = DTime.diff(42, 43) do |*args|
+      assert_equal([42, 43], args)
+      @foo = 2
+      sleep 0.2
+      @foo = 3
+    end
+    assert_kind_of(DTime, d)
+    assert_equal(3, @foo)
+    assert(d.to_f > 0.2)
+    assert(d.sec > 0.2)
+  end
+
+  def test_init_from_dtime
+    c = DTime.new(260.33)
+    d = DTime.new(c)
+    assert_equal(260, d.delta.floor)
+    assert_equal(20, d.sec.floor)
+    assert_equal(4, d.min)
+    assert_equal(0, d.hour)
+    assert_equal(0, d.day)
+  end
+
+end # class DTimeTest
+
+
+end
+

data/lib/core_ex/embedded_tests.rb

@@ -0,0 +1,33 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: embedded_tests.rb 249 2005-05-31 13:23:42Z ertai $
+
+require 'set'
+
+module Kernel
+
+  @@test_mode = nil
+  @@files = Set.new
+
+  def test_mode ( aRegexp )
+    raise 'No block needed' if block_given?
+    require 'test/unit'
+    @@test_mode = aRegexp
+  end
+
+  def test_mode?
+    !! @@test_mode
+  end
+
+  def test_section ( __file__, &block )
+    __file__ = Pathname.new(__file__).expand_path
+    if block_given? and __file__.to_s =~ @@test_mode
+      unless @@files.include?(__file__)
+        Kernel.instance_eval(&block)
+        @@files << __file__
+      end
+    end
+  end
+
+end # module Kernel

data/lib/core_ex/enumerable.rb

@@ -0,0 +1,173 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: enumerable.rb 252 2005-05-31 23:41:42Z ertai $
+
+require 'core_ex'
+
+module Enumerable
+
+  # See also Enumerable#inject
+  def fold ( init, each_method=:each, &block )
+    accu = init
+    send(each_method) do |*a|
+      accu = block[accu, *a]
+    end
+    accu
+  end
+
+
+  def foldi ( init, &block )
+    fold(init, :each_with_index, &block)
+  end
+
+
+  def sum
+    fold(0) { |accu, x| accu + x }
+  end 
+
+
+  def prod
+    fold(1) { |accu, x| accu * x }
+  end 
+
+
+  # Basically, do the same as each_with_index but yield the arguments in
+  # reverse order. Thus an array can be assume in certain cases to a hash.
+  def each_pair ( &block )
+    each_with_index { |x, i| block[i, x] }
+  end
+
+
+  def rec_fold ( init, &block )
+    fold(init) do |accu1, *a1|
+      a1.fold(accu1) { |accu2, a2| a2.rec_fold(accu2, &block) }
+    end
+  end
+
+end # module Enumerable
+
+
+
+class Object
+
+  def rec_fold ( init, &block )
+    block[init, self]
+  end
+
+end # class Object
+
+
+
+class String
+
+  def rec_fold ( init, &block )
+    if include? "\n"
+      super
+    else
+      block[init, self]
+    end
+  end
+
+end # class String
+
+
+
+test_section __FILE__ do
+
+  require 'set'
+  require 'generator'
+
+  class EnumerableTest < Test::Unit::TestCase
+
+    def setup
+      @r = 0 .. 10
+      @a = @r.to_a
+      @s = @a.to_set
+      @ak = 'a' .. 'k'
+      @h = Hash[*(@r.zip(@ak).flatten)]
+    end
+
+    def test_fold
+      [[@r, @a], [@a, @a], [@s, @s.to_a]].each do |enum, ref|
+        y = enum.fold([]) { |accu, x| accu << x }
+        assert_equal(ref, y, enum.class)
+        y = enum.fold([]) { |accu, x| [x] + accu }
+        assert_equal(ref.reverse, y, enum.class)
+        y = enum.fold([]) { |accu, x| accu << x ; 42 }
+        assert_equal(42, y, enum.class)
+      end
+
+      y = @h.fold([[], []]) do |accu, x|
+        [ [x.first] + accu.first, [x.last] + accu.last ]
+      end
+      assert_equal(@h.keys.reverse, y.first)
+      assert_equal(@h.values.reverse, y.last)
+    end
+
+    def test_foldi
+      [@r, @a, @s, @h].each do |enum|
+        ref = @a
+        y = enum.foldi([]) { |accu, x, i| accu << i }
+        assert_equal(ref, y, enum.class)
+        y = enum.foldi([]) { |accu, x, i| [i] + accu }
+        assert_equal(ref.reverse, y, enum.class)
+        y = enum.foldi([]) { |accu, x, i| accu << i ; 42 }
+        assert_equal(42, y, enum.class)
+      end
+    end
+
+    def test_sum
+      assert_equal(55, @a.sum)
+      assert_equal(55, @r.sum)
+      assert_equal(55, @s.sum)
+      assert_equal(55, @h.keys.sum)
+    end
+
+    def test_prod
+      @r = 1 .. 10
+      @a = @r.to_a
+      @s = @a.to_set
+      @ak = 'a' .. 'k'
+      @h = Hash[*(@r.zip(@ak).flatten)]
+      assert_equal(3628800, @a.prod)
+      assert_equal(3628800, @r.prod)
+      assert_equal(3628800, @s.prod)
+      assert_equal(3628800, @h.keys.prod)
+    end
+
+    def each_pair_checker ( enum, ref )
+      j = 0
+      enum.each_pair do |i, x|
+        assert_equal(j, i)
+        j += 1
+        assert_equal(ref.next, x)
+      end
+    end
+
+    def test_each_pair
+      each_pair_checker(@a, Generator.new(@a))
+      each_pair_checker(@s, Generator.new(@s))
+      each_pair_checker(@r, Generator.new(@r))
+      y = @h.fold([], :each_pair) { |accu, x| [x] + accu }
+      assert_equal(@h.keys.reverse, y)
+    end
+
+    def test_rec_fold
+      h = { 1 => { 2 => 3 }, 4 => { 5 => 6 } }
+      y = h.rec_fold([]) { |accu, *a| [a] + accu }
+      assert_equal([[6], [5], [4], [3], [2], [1]], y)
+      y = @h.rec_fold([]) { |accu, *a| [a] + accu }
+      assert_equal([["k"], [10], ["e"], [4], ["j"], [9], ["d"], [3], ["i"],
+                    [8], ["c"], [2], ["h"], [7], ["b"], [1], ["g"], [6], ["a"],
+                    [0], ["f"], [5]], y)
+
+      a = [1, [2,3], [[[4], 5]]]
+      y = a.rec_fold(0) { |accu, x| accu + x }
+      assert_equal(a.flatten.sum, y)
+    end
+
+
+  end # EnumerableTest
+
+end

data/lib/core_ex/exception.rb

@@ -0,0 +1,32 @@
+# Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: exception.rb 249 2005-05-31 13:23:42Z ertai $
+
+
+class Exception
+
+  #FIXME: write a ruby_pp which print exception backtrace exactly as ruby does
+  #       by cuting long and repetitive backtrace.
+
+  def long_pp
+    str = short_pp + "\n"
+    backtrace[1..-1].each { |x| str += "  from #{x}\n" } if backtrace
+    str.chomp!
+    str
+  end
+
+  def short_pp
+    if backtrace.nil?
+      tiny_pp
+    else
+      "#{backtrace[0]}: #{tiny_pp}"
+    end
+  end
+
+  def tiny_pp
+    exc_name = inspect.sub(/^#<(\w+):.+$/, '\1')
+    "#{self} (#{exc_name})"
+  end
+
+end # class Exception