core_ex 0.4.0 → 0.5.1.1

data/lib/d_time.rb

@@ -1,78 +1,196 @@
 # 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 $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/d_time.rb 21961 2006-02-19T19:47:14.158917Z pouillar  $
 
+class Numeric
 
+  def to_dtime
+    DTime.new self
+  end
+
+  alias_method :second,  :to_dtime
 
+end # class Numeric
 
 class DTime
-  have YamlExtension
+  include Comparable
+
+  have YamlExtension, :dtime, :d_time
 
   def initialize(delta)
-    @delta = delta.to_f.abs
-    @min, @sec = @delta.divmod(60)
-    @hour, @min = @min.floor.divmod(60)
-    @day, @hour = @hour.divmod(24)
+    @delta = delta.to_f
   end
 
-  attr_reader :delta, :sec, :min, :hour, :day
+  attr_reader :delta
 
-  def to_s
-    @delta.to_s.freeze
+  def coerce ( lhs )
+    [lhs.to_dtime, self]
   end
 
-  def inspect
-    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 ' '
+  def <=> ( rhs )
+    @delta <=> rhs.to_f
   end
 
-  def to_yaml_string
-    inspect
+  %w[ / * - + % ].each do |op|
+    class_eval "
+      def #{op} ( rhs )
+        DTime.new(@delta #{op} rhs.to_f)
+      end
+    "
   end
 
-  def to_a
-    [ @day, @hour, @min, @sec ].freeze
+  def -@
+    DTime.new(-@delta)
+  end
+
+  def +@
+    self
   end
 
+  alias_method :to_f, :delta
+
   def to_i
     @delta.to_i
   end
 
-  alias to_f delta
+  def floor
+    @delta.floor
+  end
+
+  def round
+    @delta.round
+  end
 
   def hash
     @delta.hash
   end
 
-  def to_hash
-    { :days => @day, :hours => @hour, :mins => @min, :secs => @sec }.freeze
+  class TimeUnit
+    def initialize ( unit_name, value_in_seconds )
+      @name = unit_name
+      @plural = unit_name.to_s.pluralize.to_sym
+      @value_in_seconds = value_in_seconds
+    end
+    attr_reader :name, :plural, :value_in_seconds
+  end # class TimeUnit
+
+  def self.time_unit ( unit_name, value_in_seconds )
+    value_in_seconds = value_in_seconds.to_f
+    unit = TimeUnit.new unit_name, value_in_seconds
+    @@time_units << unit
+    current_size = @@time_units.size
+    to_unit_name = "to_#{unit_name}"
+    to_unit_plural = "to_#{unit.plural}"
+
+    # Conversion method
+    unless method_defined? to_unit_name
+      define_method(to_unit_name) { delta / value_in_seconds }
+    end
+    unless method_defined? to_unit_plural
+      alias_method to_unit_plural, to_unit_name
+    end
+
+    # Component extraction method
+    unless method_defined? unit_name
+      define_method(unit_name) do
+        next_unit = @@time_units[current_size]
+        modulo = (next_unit.nil?)? 1 : next_unit.value_in_seconds
+        ((delta.abs % modulo) / value_in_seconds).to_i
+      end
+    end
+    unless method_defined? unit.plural
+      alias_method unit.plural, unit_name
+    end
+
+    # Numeric extension
+    unless Numeric.method_defined? unit_name
+      Numeric.send(:define_method, unit_name) { DTime.new(self * value_in_seconds) }
+    end
+    unless Numeric.method_defined? unit.plural
+      Numeric.send(:alias_method, unit.plural, unit_name)
+    end
   end
 
-  def floor
-    @delta.floor
+  def second
+    delta.abs % 60
+  end
+  alias_method :sec,        :second
+  alias_method :to_second,  :delta
+  alias_method :to_sec,     :delta
+
+  # Time units
+
+  @@time_units = []
+
+  time_unit :second,  1
+  time_unit :minute,  60.seconds
+  time_unit :hour,    60.minutes
+  time_unit :day,     24.hours
+  time_unit :week,    7.days
+  # time_unit :month,   30.days
+  time_unit :year,    365.25.days
+  # time_unit :...,     10.years
+  time_unit :century, 100.years
+
+  alias_method :min,        :minutes
+  alias_method :to_min,     :to_minutes
+
+  # Warning: Values are spawned from the largest unit to the finest
+  # (e.g. days, hours, minutes...).
+  # Warning: This method does not give you the sign of the DTime.
+  def each ( &block )
+    accu = @delta.abs
+    @@time_units.reverse_each do |unit|
+      if unit.name == :second
+        block[accu, unit]
+      else
+        x, accu = accu.divmod(unit.value_in_seconds)
+        next if x.zero? and accu == @delta.abs
+        block[x.to_i, unit]
+      end
+    end
   end
 
-  def round
-    @delta.round
+  # Warning: This method does not give you the sign of the DTime.
+  def to_a
+    result = []
+    each { |x, unit| result << x }
+    result
   end
 
-  def self.diff ( *args, &block )
-    start = Time.now
-    block[*args]
-    return Time.now - start
+  def to_s
+    result = []
+    each do |x, unit|
+      case x
+        when 0
+        when 1 then result << "1 #{unit.name}"
+        else result << "#{x} #{unit.plural}"
+      end
+    end
+    result << '0' if result.empty?
+    (((@delta < 0)? '-' : '') + result.join(' ')).freeze
+  end
+
+  def inspect
+    to_s + ':DTime'
+  end
+
+  def to_yaml_string
+    to_s
   end
 
-  def == ( rhs )
-    @delta == rhs.to_f
+  # Warning: This method does not give you the sign of the DTime.
+  def to_hash
+    result = {}
+    each { |x, unit| result[unit.name] = x }
+    result.freeze
   end
 
-  def method_missing ( *a, &b )
-    @delta.send(*a, &b)
+  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,
@@ -89,10 +207,19 @@ class DTimeTest < Test::Unit::TestCase
   def test_simple
     d = DTime.new(260.33)
     assert_equal(260, d.delta.floor)
+    assert_equal(20, d.seconds.floor)
+    assert_equal(20, d.second.floor)
     assert_equal(20, d.sec.floor)
+    assert_equal(4, d.minutes)
+    assert_equal(4, d.minute)
     assert_equal(4, d.min)
+    assert_equal(0, d.hours)
     assert_equal(0, d.hour)
+    assert_equal(0, d.days)
     assert_equal(0, d.day)
+    assert_equal(0, d.week)
+    assert_equal(0, d.year)
+    assert_equal(0, d.century)
   end
 
   def test_complex
@@ -102,19 +229,19 @@ class DTimeTest < Test::Unit::TestCase
     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)
+    assert_equal([ 3, 1, 47, 58 ], d.to_a.map { |x| x.to_i })
     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)
+    assert_equal(3, h[:day])
+    assert_equal(1, h[:hour])
+    assert_equal(47, h[:minute])
+    assert_equal(58, h[:second].floor)
   end
 
   def test_conversion
     d = DTime.new(260.75)
-    assert_equal('260.75', d.to_s)
-    assert_equal('4 mins 20.75 secs', d.inspect)
+    assert_equal('260.75', d.to_f.to_s)
+    assert_equal('4 minutes 20.75 seconds', d.to_s)
+    assert_equal('4 minutes 20.75 seconds:DTime', d.inspect)
     assert_equal(260, d.to_f.floor)
     assert_equal(260, d.to_i)
     assert_equal(260, d.floor)
@@ -123,7 +250,7 @@ class DTimeTest < Test::Unit::TestCase
 
   def test_negative
     d = DTime.new(-265678.42000)
-    assert_equal(265678, d.delta.floor)
+    assert_equal(-265679, d.delta.floor)
     assert_equal(58, d.sec.floor)
     assert_equal(47, d.min)
     assert_equal(1, d.hour)
@@ -137,13 +264,13 @@ class DTimeTest < Test::Unit::TestCase
 
   def test_to_yaml
     d = DTime.new(265678.42000)
-    assert_yaml_dump(d, '--- !dtime 3 days 1 hours 47 mins 58.4199999999837 secs')
+    assert_yaml_dump(d, '!dtime 3 days 1 hour 47 minutes 58.4199999999837 seconds')
     d = DTime.new(5678.42000)
-    assert_yaml_dump(d, '--- !dtime 1 hours 34 mins 38.4200000000001 secs')
+    assert_yaml_dump(d, '!dtime 1 hour 34 minutes 38.4200000000001 seconds')
     d = DTime.new(158.42000)
-    assert_yaml_dump(d, '--- !dtime 2 mins 38.42 secs')
+    assert_yaml_dump(d, '!dtime 2 minutes 38.42 seconds')
     d = DTime.new(58.42000)
-    assert_yaml_dump(d, '--- !dtime 58.42 secs')
+    assert_yaml_dump(d, '!dtime 58.42 seconds')
   end
 
   def test_diff
@@ -151,7 +278,7 @@ class DTimeTest < Test::Unit::TestCase
     d = DTime.diff(42, 43) do |*args|
       assert_equal([42, 43], args)
       @foo = 2
-      sleep 0.2
+      sleep 0.3
       @foo = 3
     end
     assert_kind_of(DTime, d)
@@ -170,10 +297,55 @@ 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 }
+  def test_stricly_greater
+    assert(DTime.new(4.5) > 2)
+  end
+
+  def test_stricly_lesser
+    assert(DTime.new(4.5) < 4.6)
+  end
+
+  def test_greater_or_equal
+    assert(DTime.new(4.5) >= 4.5)
+  end
+
+  def test_lesser_or_equal
+    assert(DTime.new(4.5) <= 4.5)
+  end
+
+  def test_equal
+    assert(DTime.new(4.5) == 4.5)
+  end
+
+  def test_divide
+    d = DTime.new(4.5)
+    assert_equal(2.25, d / 2)
+  end
+
+  def test_multiple
+    d = DTime.new(4.5)
+    assert_equal(9, d * 2)
+  end
+
+  def test_add
+    d = DTime.new(4.5)
+    assert_equal(6.5, d + 2)
+  end
+
+  def test_sub
+    d = DTime.new(4.5)
+    assert_kind_of(DTime, d - 2)
+    assert_equal(2.5, d - 2)
+  end
+
+  def test_uadd
+    d = DTime.new(4.5)
+    assert_equal(4.5, +d)
+  end
+
+  def test_usub
+    d = DTime.new(2.5)
+    assert_equal(-2.5, -d)
   end
 
 end # class DTimeTest

data/lib/dumpable_proc.rb

@@ -1,21 +1,12 @@
 # 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 362 2005-09-24 17:12:57Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/dumpable_proc.rb 8014 2005-10-26T12:35:42.562387Z ertai  $
 
 
 class DumpableProc < Proc
 
   def self.new ( str )
-    # FIXME imporve prevent from ruby injections
-    if str =~ /[{}]/
-      str = str.gsub(/[^{}]/, '')
-      while str.gsub!(/\{\}/, '')
-      end
-      unless str.empty?
-        raise ArgumentError, "Bad block: bad `{' `}' equilibration"
-      end
-    end
     pr = super(&eval("proc { #{str} }"))
     pr.instance_eval { @str = str.freeze }
     pr

data/lib/path_list.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: path_list.rb 336 2005-09-06 20:32:49Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/path_list.rb 21866 2006-02-18T17:15:58.449667Z pouillar  $
 #--
 # Copyright (c) 2003, 2004 Jim Weirich
 #
@@ -380,8 +380,10 @@ class PathList
 # <<<<
     pattern = pattern.to_s
     re = Regexp.quote(pattern)
-    re.gsub!(/\\\{([^}]+)\\\}/) do
-      '(?:' + $1.gsub(/,/, '|') + ')'
+    while re =~ /\\\{/
+      re.gsub!(/\\\{([^{}]+)\\\}/) do
+        '(?:' + $1.gsub(/,/, '|') + ')'
+      end
     end
     re.gsub!(/\\\*\\\*\//, '(?:.+/)?')
     re.gsub!(/\\\*/, '[^/]*')
@@ -495,31 +497,40 @@ test_section __FILE__ do
       @l = PathList[]
       @args = []
       @mo = lambda { |*a| @args << a }
-      %w[ foo barbar bazfoo foo/a foo/b ].each do |x|
+      %w[ foo barbar bazfoo foo/a foo/b bu bi ].each do |x|
         (@r/x).mkpath
         @l << @r/x
       end
       @l2 = PathList[@r/'(f?o)', @r/'b(a*)', @r/'fo,',
                      @r/'f.o', @r/'**/({a,b})']
       @l3 = PathList[@r/'ba{rbar,zfoo}']
+      @l4 = PathList[@r/'(b{a{rbar,zfoo},u,i})']
     end
 
     def test_each
       @l.each(&@mo)
       @l2.each(&@mo)
       @l3.each(&@mo)
+      @l4.each(&@mo)
       assert_equal([
         [@r/'foo'], [@r/'barbar'], [@r/'bazfoo'], [@r/'foo/a'], [@r/'foo/b'],
+        [@r/'bu'], [@r/'bi'],
+
         [@r/'foo', 'foo'], [@r/'barbar', 'arbar'], [@r/'bazfoo', 'azfoo'],
         [@r/'fo,'], [@r/'f.o'], [@r/'foo/a', 'a'], [@r/'foo/b', 'b'],
-        [@r/'barbar'], [@r/'bazfoo']
+
+        [@r/'barbar'], [@r/'bazfoo'],
+
+        [@r/'barbar', 'barbar'], [@r/'bazfoo', 'bazfoo'], [@r/'bu', 'bu'],
+        [@r/'bi', 'bi']
       ], @args)
     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
+      assert_yaml_load "!filelist #{ls}", PathList, PathList[ls]
+      assert_yaml_dump @val.to_a, /.*/     
+      assert_yaml_dump @val, @str
     end
 
   end # class PathListTest

data/lib/temp_path.rb

@@ -3,7 +3,7 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: temp_path.rb 351 2005-09-14 08:33:42Z ertai $
+# $Id: /w/fey/ruby_ex/trunk/core_ex/lib/temp_path.rb 8004 2005-10-09T19:51:28.097991Z ertai  $
 
 require 'tempfile'
 require 'tmpdir'
@@ -184,8 +184,8 @@ test_section __FILE__ do
     end
 
     def test_interface
-      assert_match(/\.#{$$}\/foo\.\d+$/, @foo.to_s)
-      assert_match(/\.#{$$}\/foo\.\d+\.bar$/, @foobar.to_s)
+      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
 

data/lib/test/unit/u_i/yaml/test_runner.rb

@@ -3,7 +3,7 @@
 # License:: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: test_runner.rb 351 2005-09-14 08:33:42Z ertai $
+# $Id: /w/fey/ruby_ex/trunk/core_ex/lib/test/unit/u_i/yaml/test_runner.rb 7956 2005-09-14T08:33:42.463064Z ertai  $
 
 
 require 'test/unit/autorunner'