utilrb 1.0 → 1.1

data/Changes.txt

@@ -1,74 +1,90 @@
+=== Version 1.1
+
+* changes and fixes:
+  - fix documentation here and there
+  - make sure all defined #to_s methods handle recursion
+  - defined Module#cached_enum: returns an Enumerator method for
+    a "each_" method, cachin the enumerator object. Works also
+    for iteration with one argument (caching one Enumerator by
+    argument)
+  - fix Time.from_hms when the millisecond field has leading zeroes
+  - optimizations here and there:
+    * Array#to_value_set does not rely on rb_iterate
+    * specific implementation of ValueSet#dup
+    * more generally, avoid object allocation where possible
+  - ColumnFormatter object: formats CSV output for display
+
 === Version 1.0
 Bumped version number because of incompatible changes. Make it 1.0 since
 having 0. version numbers for this kind of library is completely meaningless
 
- * incompatible changes:
-    - Enumerable#+ acts on too many objects. Define it only on Enumerable::Enumerator
-    - remove automatic convertion into ValueSet for methods which were doing it
-    - removed Queue#get: fastthread is now the preferred threading library in
-      Ruby 1.8.6, so Queue#get cannot be implemented anymore
-
- * new features:
-    - PkgConfig class
-    - define Proc#same_body?, Proc#file and Proc#line
-    - Module#attr_predicate
-    - 'since', 'until' and block parameters for Exception#full_message
-    - ValueSet#intersects? (more efficient than checking that the intersection
-      is empty)
-
- * changes and fixes:
-    - properly handle singleton classes in has_ancestor?
-    - properly handle recursion in ValueSet#to_s and Array#to_s
-    - add the 'setup' task on the Rakefile to build the C extension
-    - make Module#has_ancestor? work event if the C extension is not built
+* incompatible changes:
+  - Enumerable#+ acts on too many objects. Define it only on Enumerable::Enumerator
+  - remove automatic convertion into ValueSet for methods which were doing it
+  - removed Queue#get: fastthread is now the preferred threading library in
+    Ruby 1.8.6, so Queue#get cannot be implemented anymore
+
+* new features:
+  - PkgConfig class
+  - define Proc#same_body?, Proc#file and Proc#line
+  - Module#attr_predicate
+  - 'since', 'until' and block parameters for Exception#full_message
+  - ValueSet#intersects? (more efficient than checking that the intersection
+    is empty)
+
+* changes and fixes:
+  - properly handle singleton classes in has_ancestor?
+  - properly handle recursion in ValueSet#to_s and Array#to_s
+  - add the 'setup' task on the Rakefile to build the C extension
+  - make Module#has_ancestor? work event if the C extension is not built
 
 === Version 0.2.3
 
- * new features:
-    - BenchmarkAllocation, a Benchmark-like interface to benchmark object
-      allocation
-    - ValueSet#delete_if
-    - Time#from_hms takes a time as "h:m:s.ms" and builds the corresponding
-      Time object. Note that "s", "s.ms", "m:s", "m:s.ms", ... are accepted
-      formats
-
- * changes and fixes:
-    - define Queue#get only if we are using Ruby's core Queue. The current
-      implementation is incompatible with fastthread for instance (and 
-      fastthhread's maintainer does not want #get on its Queue). Included
-      a patch to define Queue#get on fastthread
-    - fix ValueSet#== raising if the argument is not a ValueSet
-    - fix brain-dead SequenceEnumerator#+, which was changing its receiver
+* new features:
+  - BenchmarkAllocation, a Benchmark-like interface to benchmark object
+    allocation
+  - ValueSet#delete_if
+  - Time#from_hms takes a time as "h:m:s.ms" and builds the corresponding
+    Time object. Note that "s", "s.ms", "m:s", "m:s.ms", ... are accepted
+    formats
+
+* changes and fixes:
+  - define Queue#get only if we are using Ruby's core Queue. The current
+    implementation is incompatible with fastthread for instance (and 
+    fastthhread's maintainer does not want #get on its Queue). Included
+    a patch to define Queue#get on fastthread
+  - fix ValueSet#== raising if the argument is not a ValueSet
+  - fix brain-dead SequenceEnumerator#+, which was changing its receiver
 
 === Version 0.2.2
 The "don't forget to bump version number" release. 0.2 was supposed to be 0.2.1
 
- * new features:
-    - Queue#get: waits for the queue to be not empty and returns all elements at 
-      once. A non_block parameter is given which makes get() return [] if the
-      queue is empty
+* new features:
+  - Queue#get: waits for the queue to be not empty and returns all elements at 
+    once. A non_block parameter is given which makes get() return [] if the
+    queue is empty
 
- * changes:
-    - Array#to_s and Hash#to_s now enclose the result in [] and {}. The difference
-      with #inspect is that we call #to_s on the elements.
+* changes:
+  - Array#to_s and Hash#to_s now enclose the result in [] and {}. The difference
+    with #inspect is that we call #to_s on the elements.
 
 === Version 0.2.1
- * new features:
-    - Kernel#is_singleton?
-    - Module#inherited_enumerable (class_inherited_enumerable on steroids)
-    - Module#attribute() can be used in singleton classes (previously we had to 
-      call class_attribute() in the class itself)
-    - UnboundMethod#call(obj, *args, &block) calls the method on obj with 
-      the provided arguments (does m.bind(obj).call(*args, &block))
-
- * changes:
-    - changed semantics of Module::include for inclusion of modules in modules:
-      the source_module::ClassExtension gets included in
-      target_module::ClassExtension.  Previously, it was extending the target's
-      singleton class. This way, Module really acts as a mixin for both class
-      methods and instance methods
+* new features:
+  - Kernel#is_singleton?
+  - Module#inherited_enumerable (class_inherited_enumerable on steroids)
+  - Module#attribute() can be used in singleton classes (previously we had to 
+    call class_attribute() in the class itself)
+  - UnboundMethod#call(obj, *args, &block) calls the method on obj with 
+    the provided arguments (does m.bind(obj).call(*args, &block))
+
+* changes:
+  - changed semantics of Module::include for inclusion of modules in modules:
+    the source_module::ClassExtension gets included in
+    target_module::ClassExtension.  Previously, it was extending the target's
+    singleton class. This way, Module really acts as a mixin for both class
+    methods and instance methods
 
 === Version 0.1
- * Initial release
+* Initial release
 
 

data/Manifest.txt

@@ -13,11 +13,13 @@ ext/value_set.cc
 lib/utilrb.rb
 lib/utilrb/array.rb
 lib/utilrb/array/to_s.rb
+lib/utilrb/column_formatter.rb
 lib/utilrb/common.rb
 lib/utilrb/enumerable.rb
 lib/utilrb/enumerable/null.rb
 lib/utilrb/enumerable/random_element.rb
 lib/utilrb/enumerable/sequence.rb
+lib/utilrb/enumerable/to_s_helper.rb
 lib/utilrb/enumerable/uniq.rb
 lib/utilrb/exception.rb
 lib/utilrb/exception/full_message.rb
@@ -40,6 +42,7 @@ lib/utilrb/module.rb
 lib/utilrb/module/ancestor_p.rb
 lib/utilrb/module/attr_enumerable.rb
 lib/utilrb/module/attr_predicate.rb
+lib/utilrb/module/cached_enum.rb
 lib/utilrb/module/define_method.rb
 lib/utilrb/module/include.rb
 lib/utilrb/module/inherited_enumerable.rb
@@ -70,5 +73,6 @@ test/test_object.rb
 test/test_objectstats.rb
 test/test_pkgconfig.rb
 test/test_proc.rb
+test/test_set.rb
 test/test_time.rb
 test/test_unbound_method.rb

data/Rakefile

@@ -20,7 +20,7 @@ Hoe.new('utilrb', Utilrb::VERSION) do |p|
     p.summary = 'Yet another Ruby toolkit'
     p.description = p.paragraphs_of('README.txt', 3..6).join("\n\n")
     p.url         = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-    p.changes     = p.paragraphs_of('Changes.txt', 0..3).join("\n\n")
+    p.changes     = p.paragraphs_of('Changes.txt', 0..1).join("\n\n")
 
     p.extra_deps << 'facets'
     p.rdoc_pattern = /(ext\/.*cc$|lib)|txt/

data/ext/faster.cc

@@ -76,7 +76,7 @@ static VALUE proc_file(VALUE self)
 }
 
 /* call-seq:
- *  proc.file
+ *  proc.line
  *
  * Returns the line at which the proc body is defined, or nil
  */

data/ext/value_set.cc

@@ -101,6 +101,22 @@ static VALUE value_set_include_p(VALUE vself, VALUE vother)
  */
 static VALUE value_set_to_value_set(VALUE self) { return self; }
 
+/* call-seq:
+ *  set.dup => other_set
+ *
+ * Duplicates this set, without duplicating the pointed-to objects
+ */
+static VALUE value_set_dup(VALUE vself, VALUE vother)
+{
+    ValueSet const& self  = get_wrapped_set(vself);
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    ValueSet& result = get_wrapped_set(vresult);
+    for (ValueSet::const_iterator it = self.begin(); it != self.end(); ++it)
+	result.insert(result.end(), *it);
+
+    return vresult;
+}
+
 /* call-seq:
  *  set.include_all?(other)		=> true or false
  *
@@ -302,6 +318,24 @@ static VALUE enumerable_to_value_set_i(VALUE i, VALUE* memo)
     return Qnil;
 }
 
+/* call-seq:
+ *  to_value_set    => value_set
+ *
+ * Converts this array into a ValueSet object
+ */
+static VALUE array_to_value_set(VALUE self)
+{
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    ValueSet& result = get_wrapped_set(vresult);
+
+    VALUE* ptr = RARRAY(self)->ptr;
+    long size  = RARRAY(self)->len;
+    for (int i = 0; i < size; ++i)
+	result.insert(ptr[i]);
+
+    return vresult;
+}
+
 /* call-seq:
  *  enum.to_value_set		=> value_set
  *
@@ -328,6 +362,7 @@ static VALUE enumerable_to_value_set(VALUE self)
 extern "C" void Init_value_set()
 {
     rb_define_method(rb_mEnumerable, "to_value_set", RUBY_METHOD_FUNC(enumerable_to_value_set), 0);
+    rb_define_method(rb_cArray, "to_value_set", RUBY_METHOD_FUNC(array_to_value_set), 0);
 
     cValueSet = rb_define_class("ValueSet", rb_cObject);
     id_new = rb_intern("new");
@@ -344,6 +379,7 @@ extern "C" void Init_value_set()
     rb_define_method(cValueSet, "delete", RUBY_METHOD_FUNC(value_set_delete), 1);
     rb_define_method(cValueSet, "==", RUBY_METHOD_FUNC(value_set_equal), 1);
     rb_define_method(cValueSet, "to_value_set", RUBY_METHOD_FUNC(value_set_to_value_set), 0);
+    rb_define_method(cValueSet, "dup", RUBY_METHOD_FUNC(value_set_dup), 0);
     rb_define_method(cValueSet, "empty?", RUBY_METHOD_FUNC(value_set_empty_p), 0);
     rb_define_method(cValueSet, "size", RUBY_METHOD_FUNC(value_set_size), 0);
     rb_define_method(cValueSet, "clear", RUBY_METHOD_FUNC(value_set_clear), 0);

data/lib/utilrb/array/to_s.rb

@@ -1,17 +1,10 @@
+require 'utilrb/enumerable/to_s_helper'
 class Array
     # Displays arrays as [ a, b, [c, d], ... ] instead of the standard #join
     # Unlike #inspect, it calls #to_s on the elements too
     def to_s
-	stack = (Thread.current[:array_to_s] ||= [])
-	if stack.include?(object_id)
-	    "..."
-	else
-	    begin
-		stack.push object_id
-		"[" << map { |obj| obj.to_s }.join(", ") << "]"
-	    ensure
-		stack.pop
-	    end
+	EnumerableToString.to_s_helper(self, '[', ']') do |obj|
+	    obj.to_s
 	end
     end
 end

data/lib/utilrb/column_formatter.rb

@@ -0,0 +1,73 @@
+# Displays a set of data into a column-formatted table
+class ColumnFormatter
+    MARGIN       = 3
+    SCREEN_WIDTH = 90
+
+    # data is an array of hashes. Each line of the array is a line to display,
+    # a hash being a column_name => value data set. The special 'label' column
+    # name is used to give a name to each line.
+    #
+    # If a block is given, the method yields the column names and the block must
+    # return the array of columns to be displayed, sorted into the order of
+    # the columns.
+    def self.from_hashes(data, io = STDOUT, margin = MARGIN, screen_width = SCREEN_WIDTH)
+	width = Hash.new
+
+	# First, determine the columns width and height, and
+	# convert data into strings
+	data = data.map do |line_data|
+	    line_data = line_data.inject({}) do |h, (label, data)|
+		h[label.to_s] = data.to_s
+		h
+	    end
+		
+	    line_data.each do |label, data|
+		unless width.has_key?(label)
+		    width[label] = label.length
+		end
+
+		if width[label] < data.length
+		    width[label] = data.length
+		end
+	    end
+	end
+
+	# Then ask the user to sort the keys for us
+	names = width.keys.dup
+	names.delete('label')
+	names = if block_given? then yield(names)
+		else names.sort
+		end
+
+	# Finally, format and display
+	while !names.empty?
+	    # we determine the set of columns to display
+	    if width.has_key?('label')
+		line_n = ['label']
+		line_w = width['label']
+		format = ["% #{line_w}s"]
+	    else
+		line_n = []
+		line_w = 0
+		format = []
+	    end
+	    
+	    while !names.empty? && (line_w < screen_width)
+		col_n = names.shift
+		col_w = width[col_n]
+		line_n << col_n
+		line_w += col_w
+		format << "% #{col_w}s"
+	    end
+
+	    format = format.join(" " * margin)
+	    io.puts format % line_n
+	    data.each do |line_data|
+		line_data = line_data.values_at(*line_n)
+		line_data.map! { |v| v || '-' }
+		io.puts format % line_data
+	    end
+	end
+    end
+end
+

data/lib/utilrb/common.rb

@@ -1,5 +1,5 @@
 module Utilrb
-    VERSION = "1.0" unless defined? Utilrb::VERSION
+    VERSION = "1.1" unless defined? Utilrb::VERSION
 
     unless defined? UTILRB_FASTER_MODE
 	if ENV['UTILRB_FASTER_MODE'] == 'no'

data/lib/utilrb/enumerable/sequence.rb

@@ -2,9 +2,9 @@ require 'enumerator'
 
 # An enumerator which iterates on multiple iterators in sequence
 #
-#   ([1, 2].enum_for + [2, 3].enum_for).each => 1, 2, 2, 3
+#   ([1, 2].enum_for + [2, 3].enum_for).to_a # => [1, 2, 2, 3]
 #
-# See also Enumerator#+
+# See also Enumerable::Enumerator#+
 class SequenceEnumerator
     def initialize; @sequence = Array.new end
 
@@ -22,7 +22,7 @@ end
 
 class Enumerable::Enumerator # :nodoc
     # Builds a sequence of enumeration object.
-    #	([1, 2].enum_for + [2, 3]).each		=> 1, 2, 2, 3
+    #	([1, 2].enum_for + [2, 3].enum_for).to_a # => [1, 2, 2, 3]
     def +(other_enumerator) # :nodoc
 	SequenceEnumerator.new << self << other_enumerator
     end

data/lib/utilrb/enumerable/to_s_helper.rb

@@ -0,0 +1,17 @@
+module EnumerableToString
+    # This method is a generic implementaion of #to_s on enumerables.
+    def self.to_s_helper(enumerable, start, stop)
+	stack = (Thread.current[:to_s_helper] ||= [])
+	if stack.include?(enumerable.object_id)
+	    "..."
+	else
+	    begin
+		stack.push enumerable.object_id
+		start.dup << enumerable.map { |el| yield(el) }.join(", ") << stop
+	    ensure
+		stack.pop
+	    end
+	end
+    end
+end
+

data/lib/utilrb/enumerable/uniq.rb

@@ -2,11 +2,19 @@ require 'utilrb/common'
 require 'enumerator'
 require 'set'
 
-# Enumerator object which removes duplicate entries. See
-# Kernel#each_uniq
+# Enumerator object which removes duplicate entries. 
+# See also Object#enum_uniq and Enumerable#each_uniq
 class UniqEnumerator < Enumerable::Enumerator
-    def initialize(root, enum_with, args, key = nil)
-	super(root, enum_with, *args)
+    # Creates the enumerator on +obj+ using the method +enum_with+ to
+    # enumerate. The method will be called with the arguments in +args+.
+    #
+    # If +key+ is given, it is a proc object which should return the key on
+    # which we base ourselves to compare two objects. If it is not given,
+    # UniqEnumerator uses the object itself
+    #
+    # See also Object#enum_uniq and Enumerable#each_uniq
+    def initialize(obj, enum_with, args, key = nil)
+	super(obj, enum_with, *args)
 	@key = key
 	@result = Hash.new
     end
@@ -29,12 +37,12 @@ class UniqEnumerator < Enumerable::Enumerator
 	    self
 	end
     end
-
-    include Enumerable
 end
 
 class Object
-    # Enumerate removing the duplicate entries
+    # Enumerate using the <tt>each(*args)</tt> method, removing the duplicate
+    # entries. If +filter+ is given, it should return an object the enumerator
+    # will compare for equality (instead of using the objects themselves)
     def enum_uniq(enum_with = :each, *args, &filter)
 	UniqEnumerator.new(self, enum_with, args, filter)
     end
@@ -43,10 +51,9 @@ end
 Utilrb.unless_faster do
     module Enumerable
 	# call-seq:
-	#  enum.each_uniq { |obj| ... }
+	#  each_uniq { |obj| ... }
 	# 
 	# Yields all unique values found in +enum+
-	# 
 	def each_uniq(&iterator)
 	    seen = Set.new
 	    each do |obj|