quality_extensions 1.1.4 → 1.1.6

data/lib/Xfind_bug_test.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby
+
+require 'find'
+require 'pathname'
+require 'tempfile'
+
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+
+  def test_basic
+    Find.find('.') do |path|
+        puts path
+        sleep 1
+        redo
+    end
+  end
+
+#  def test_pathname
+#    Pathname.new('.').find do |path|
+#      catch :something do
+#        puts path
+#        throw :something
+#      end
+#    end
+#  end
+
+end

data/lib/quality_extensions/array/all_same.rb

@@ -0,0 +1,40 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+module Enumerable
+  def all_same?
+    all? {|a| a == first}
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe 'Enumerable#all_same?' do
+  it 'works with arrays' do
+    [1, 2].all_same?.should == false
+    [1, 1].all_same?.should == true
+  end
+
+  it 'works with Enumerators' do
+    'a b'.chars.all_same?.should == false
+    'aaa'.chars.all_same?.should == true
+  end
+end
+=end
+

data/lib/quality_extensions/array/delete_if_bang.rb

@@ -0,0 +1,145 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# Changes::
+#++
+
+require 'facets/array/delete_values'
+
+class Array
+  # Like partition, in that it creates two arrays, the first containing the elements of
+  # <i>enum</i> for which the block evaluates to false, the second
+  # containing the rest, only instead of returning both arrays, it changes +self+ for the first array (those for which the block evaluates to false)
+  # and thus only needs to return the second array (those for which the block evaluates to true)
+  #
+  # this is analagous to what shift (or pop) does: it shifts (or pops) an element off of a collection and simultaneously returns that element which was shifted (or popped) off
+  #
+  # Example:
+  #
+  #   orig_a = a = (1..6).to_a
+  #   b = a.select_if! {|i| i % 3 == 0}   # => [1, 2, 4, 5] 
+  #   a                                   # => [3, 6]
+  #
+  # This is identical to doing this:
+  #   orig_a = a = (1..6).to_a
+  #   a, b = a.partition {|i| i % 3 == 0}
+  #   a                                   # => [3, 6]
+  #   b                                   # => [1, 2, 4, 5] 
+  #
+  # except that in the case of partition, orig_a and a are now to different objects, whereas with select_if, a remains the same object and is modified in place.
+  #
+  # name?:
+  #   modify!
+  #   select_if_returning_deleted
+  #   shift_if :)
+  #
+  def select_if!(&block)
+    d = []
+    each{ |v| d << v unless yield v}
+    delete_values(*d)
+    d
+  end
+
+  #
+  # Note that self is not modified (the values are not deleted) until it has finished iterating through elements and has given a chance for you to decide the fate of each element.
+  # (So if, for instance, you want to refer to the previous value, you can do that with select_if_with_index! by using array[i-1], even if array[i-1] is "scheduled for deletion", because it will not have been deleted yet.)
+  #
+  # Example:
+  # args_for_vim = ARGV.delete_if! {|arg, i|
+  #   arg =~ /^-c/ || ARGV[i-1] =~ /^-c/ \
+  #     || arg =~ /^\+/
+  # }
+  # 
+  def select_if_with_index!(&block)
+    d = []
+    each_with_index{ |v,i| d << v unless yield v,i}
+    delete_values(*d)
+    d
+  end
+
+  # Like partition, in that it creates two arrays, the first containing the elements of
+  # <i>enum</i> for which the block evaluates to false, the second
+  # containing the rest, only instead of returning both arrays, it changes +self+ for the first array (those for which the block evaluates to false)
+  # and thus only needs to return the second array (those for which the block evaluates to true)
+  #   (1..6).partition {|i| i % 3 == 0} # => [[3, 6], [1, 2, 4, 5]]
+  #
+  #   a = (1..6).to_a
+  #   a.delete_if! {|i| i % 3 == 0}     # => [3, 6]
+  #   a                                 # => [1, 2, 4, 5]
+  #
+  # similar to delete_if / reject!, but modifies self in place (removes elements from self) and rather than simply discarding the deleted elements, it returns an array containing those elements removed (similar to partition)
+  #
+  # a more generic version of Facets' delete_values; that can only be used to delete if a value matches exactly; this can use any arbitrary comparison to determine whether or not to delete element
+  #
+  # name?:
+  #   modify!
+  #   delete_if_returning_deleted
+  #   shift_unless :)
+  #
+  def delete_if!(&block)
+    d = []
+    #each{ |v| d << delete(v) if yield v; puts "yield #{v} returned #{yield v}"}  # didn't work because the deleting messed up the each and not all elements were visited
+    each{ |v| d << v if yield v}
+    delete_values(*d)
+    d
+  end
+end
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe '' do
+  it "delete_if! { el == 'a'}" do
+    orig = %w[a b c]
+    deleted = orig.delete_if! {|el| el == 'a'}
+
+    deleted.should == %w[a]
+    orig   .should == %w[b c]
+  end
+
+  it "delete_if! { ... == el.upcase}" do
+    orig = %w[a b A B]
+    deleted = orig.delete_if! {|el| el.upcase == el}
+
+    deleted.should == %w[A B]
+    orig   .should == %w[a b]
+  end
+
+  it "delete_if! { ... == i % 3 == 0}" do
+    a = (1..6).to_a
+   (d = a.delete_if! {|i| i % 3 == 0}).should == [3, 6]
+    a                                 .should == [1, 2, 4, 5]
+  end
+
+  it "select_if! { ... == i % 3 == 0}" do
+    orig_a = a = (1..6).to_a
+   (d = a.select_if! {|i| i % 3 == 0}).should == [1, 2, 4, 5] 
+    a                                 .should == [3, 6]
+    a.object_id.should == orig_a.object_id
+  end
+
+  it "unlike when using partition, keeps its identity" do
+    orig_a = a = (1..6).to_a
+    a, b = a.partition {|i| i % 3 == 0}
+    a.should == [3, 6]
+    b.should == [1, 2, 4, 5]
+    a.object_id.should_not == orig_a.object_id
+  end
+
+end
+=end

data/lib/quality_extensions/array/expand_ranges.rb

@@ -1,54 +1,4 @@
-#--
-# Author::    Tyler Rick
-# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
-# License::   Ruby License
-# Submit to Facets?:: Yes.
-#++
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
-require 'rubygems'
-require 'facets/kernel/silence'
-
-class Array
-  # Expands (calls +to_a+ on) all Ranges contained in this array, replacing the range with the list of *elements* that the range represents.
-  #
-  # This is especially useful when you want to have "discontiguous ranges" like [1..3, 5..7]...
-  #
-  #   [1..3, 5..7].expand_ranges
-  #   => [1, 2, 3, 5, 6, 7]
-  #
-  def expand_ranges
-    new_array = []
-    each do |item|
-      silence_warnings do             # Object.to_a: warning: default `to_a' will be obsolete
-        if item.respond_to?(:to_a)
-          new_array.concat item.to_a
-        else
-          new_array.concat [item]
-        end
-      end
-    end
-    new_array
-  end
-end
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-require 'test/unit'
-
-class TheTest < Test::Unit::TestCase
-  def test_1
-    assert_equal [1, 2, 3], [1, 2, 3].expand_ranges
-  end
-  def test_2
-    assert_equal [1, 2, 3], [1..3].expand_ranges
-    assert_equal [1, 2, 3, 5, 6, 7], [1..3, 5..7].expand_ranges
-  end
-end
-=end
+# Alias for:
+require 'facets/kernel/require_local'
+require_local '../range_list'
 

data/lib/quality_extensions/array/include_any_of.rb

@@ -0,0 +1,23 @@
+Welcome!
+irb -> [1,2,5].include_any_of? [3,5]
+NoMethodError: undefined method `include_any_of?' for [1, 2, 5]:Array
+  from (irb):1
+  from /usr/local/bin/irb:12:in `<main>'
+irb -> [1,2,5] & [3,5]
+    => [5]
+
+irb -> !!([1,2,5] & [3,5])
+    => true
+
+irb -> [1,2,5] & [3,4]
+    => []
+
+irb -> !!([1,2,5] & [3,4])
+    => true
+
+irb -> ([1,2,5] & [3,4]).any?
+    => false
+
+irb -> ([1,2,5] & [3,5]).any?
+    => true
+

data/lib/quality_extensions/array/justify.rb

@@ -0,0 +1,305 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+# To do::
+#++
+
+require 'rubygems'
+require 'facets/kernel/deep_copy'
+require File.dirname(__FILE__) + '/../vector/enumerable'
+require File.dirname(__FILE__) + '/../matrix/linked_vectors'
+
+class Array
+  # In each column of a table (2-dimensional array) of strings, pads the string with +padstr+ (using ljust) so that all strings in that column have the same length.
+  #
+  #    [['a',   'bb'],
+  #     ['aaa', 'b' ]].ljust_columns
+  # => [['a  ', 'bb'],
+  #     ['aaa', 'b ']]
+  #
+  # The new values in the table will be strings even if they were not originally (1 might turn into '1 ', for example).
+  #
+  def ljust_columns(padstr = ' ')
+    new = self.deep_copy
+    new.ljust_columns!(padstr)
+    new
+  end
+
+  # Original version without using Matrix:
+#  def ljust_columns!(padstr = ' ')
+#    self[0].each_index do |c| 
+#      max_length_in_col = max_by { |row|
+#        row[c].to_s.length 
+#      }[c].to_s.length
+#      each { |row| 
+#        row[c] = row[c].to_s.ljust(max_length_in_col, padstr)
+#      }
+#    end
+#    self
+#  end
+
+  # In-place version of ljust_columns.
+  #
+  def ljust_columns!(padstr = ' ')
+    matrix = Matrix[*self]
+    matrix.column_vectors.each do |column| 
+      max_length_in_col = column.max_by { |el|
+        el.to_s.length 
+      }.to_s.length
+      column.each_with_index { |el, i| 
+        column[i] = el.to_s.ljust(max_length_in_col, padstr)
+      }
+    end
+    self
+  end
+
+  # In each row of a table (2-dimensional array) of strings, pads the string with +padstr+ (using ljust) so that all strings in that row have the same length.
+  #
+  #    [['a'  , 'aa' , 'a'  ],
+  #     ['bbb', 'b'  , 'b'  ]].ljust_rows
+  # => [['a ' , 'aa' , 'a ' ],
+  #     ['bbb', 'b  ', 'b  ']]
+  #
+  # The new values in the table will be strings even if they were not originally (1 might turn into '1 ', for example).
+  #
+  def ljust_rows(padstr = ' ')
+    new = self.deep_copy
+    new.ljust_rows!(padstr)
+    new
+  end
+
+  # Original version without using Matrix:
+#  def ljust_rows!(padstr = ' ')
+#    c_count = self[0].size  # We assume all rows have the same number of columns
+#    self.each_index do |r|
+#      max_length_in_row = 0.upto(c_count - 1).inject(0) { |memo, c|
+#        [self[r][c].to_s.length, memo].max
+#      }
+#      0.upto(c_count - 1).each { |c| 
+#        self[r][c] = self[r][c].to_s.ljust(max_length_in_row, padstr)
+#      }
+#    end
+#    self
+#  end
+
+  # In-place version of ljust_rows.
+  #
+  def ljust_rows!(padstr = ' ')
+    matrix = Matrix[*self]
+    matrix.row_vectors.each do |row| 
+      max_length_in_row = row.max_by { |el|
+        el.to_s.length 
+      }.to_s.length
+      row.each_with_index { |el, i| 
+        row[i] = el.to_s.ljust(max_length_in_row, padstr)
+      }
+    end
+    self
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  # Maintenance note: rjust versions are simply copied and pasted with the substitution s/ljust/rjust/g applied and the descriptions and examples changed.
+
+  # In each column of a table (2-dimensional array) of strings, pads the string with +padstr+ (using rjust) so that all strings in that column have the same length.
+  #
+  #    [[  'a', 'bb'],
+  #     ['aaa',  'b']].rjust_columns
+  # => [['  a', 'bb'],
+  #     ['aaa', ' b']]
+  #
+  # The new values in the table will be strings even if they were not originally (1 might turn into '1 ', for example).
+  #
+  def rjust_columns(padstr = ' ')
+    new = self.deep_copy
+    new.rjust_columns!(padstr)
+    new
+  end
+
+  # In-place version of rjust_columns.
+  #
+  def rjust_columns!(padstr = ' ')
+    matrix = Matrix[*self]
+    matrix.column_vectors.each do |column| 
+      max_length_in_col = column.max_by { |el|
+        el.to_s.length 
+      }.to_s.length
+      column.each_with_index { |el, i| 
+        column[i] = el.to_s.rjust(max_length_in_col, padstr)
+      }
+    end
+    self
+  end
+
+  # In each row of a table (2-dimensional array) of strings, pads the string with +padstr+ (using rjust) so that all strings in that row have the same length.
+  #
+  #    [[  'a',  'aa',   'a'],
+  #     ['bbb',   'b',   'b']].rjust_rows
+  # => [[ ' a',  'aa',  ' a'],
+  #     ['bbb', '  b', '  b']]
+  #
+  # The new values in the table will be strings even if they were not originally (1 might turn into '1 ', for example).
+  #
+  def rjust_rows(padstr = ' ')
+    new = self.deep_copy
+    new.rjust_rows!(padstr)
+    new
+  end
+
+  # In-place version of rjust_rows.
+  #
+  def rjust_rows!(padstr = ' ')
+    matrix = Matrix[*self]
+    matrix.row_vectors.each do |row| 
+      max_length_in_row = row.max_by { |el|
+        el.to_s.length 
+      }.to_s.length
+      row.each_with_index { |el, i| 
+        row[i] = el.to_s.rjust(max_length_in_row, padstr)
+      }
+    end
+    self
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+require 'pp'
+
+describe 'Array.ljust_columns!' do
+  before do
+    @array =  [['a',   'bb', 'c'],
+               ['aaa', 'b',  'c']]
+    @array2 = [['a',   'bb'],
+               ['aaa', 'b' ],
+               ['a',   'b' ]]
+  end
+
+  it 'basic' do
+    @array.ljust_columns!
+    @array.should == [['a  ', 'bb', 'c'],
+                      ['aaa', 'b ', 'c']]
+  end
+
+  it 'rotated' do
+    @array2.ljust_columns!
+    @array2.should == [['a  ', 'bb'],
+                      ['aaa', 'b ' ],
+                      ['a  ', 'b ' ]]
+  end
+
+  it 'with non-string receiver array' do
+    @array = [[1, 2], [1, 22]]
+    @array.ljust_columns!
+    @array.should == [['1', '2 '], ['1', '22']]
+  end
+
+  it 'with different padding character' do
+    @array.ljust_columns!('_')
+    @array.should == [['a__', 'bb', 'c'],
+                      ['aaa', 'b_', 'c']]
+  end
+end
+
+describe 'Array.ljust_columns' do
+  before do
+    @array = [['a',   'bb', 'c'],
+              ['aaa', 'b',  'c' ]]
+  end
+
+  it 'should not modify receiver array' do
+    @array.should == [['a'  , 'bb', 'c'],
+                      ['aaa', 'b' , 'c']]
+    ret = @array.ljust_columns
+    ret.should ==    [['a  ', 'bb', 'c'],
+                      ['aaa', 'b ', 'c']]
+    # Should not have modified @array
+    @array.should == [['a'  , 'bb', 'c'],
+                      ['aaa', 'b' , 'c']]
+  end
+end
+
+describe 'Array.ljust_rows!' do
+  before do
+    @array =  [['a'  , 'aa', 'a'],
+               ['bbb', 'b' , 'b']]
+    @array2 = [['a'  , 'aa'],
+               ['bbb', 'b' ],
+               ['c'  , 'c' ]]
+  end
+
+  it 'basic' do
+    @array.ljust_rows!
+    @array.should == [['a ',  'aa',  'a ' ],
+                      ['bbb', 'b  ', 'b  ']]
+  end
+
+  it 'rotated' do
+    @array2.ljust_rows!
+    @array2.should == [['a ' , 'aa' ],
+                       ['bbb', 'b  '],
+                       ['c'  , 'c'  ]]
+  end
+
+  it 'with non-string receiver array' do
+    @array = [[1, 1], [2, 22]]
+    @array.ljust_rows!
+    @array.should == [['1', '1'], ['2 ', '22']]
+  end
+
+  it 'with different padding character' do
+    @array.ljust_rows!('_')
+    @array.should == [['a_',  'aa',  'a_' ],
+                      ['bbb', 'b__', 'b__']]
+  end
+end
+
+describe 'Array.ljust_rows' do
+  before do
+    @array =  [['a'  , 'aa', 'a'],
+               ['bbb', 'b' , 'b']]
+  end
+
+  it 'should not modify receiver array' do
+    @array.should ==  [['a'  , 'aa' , 'a'  ],
+                       ['bbb', 'b'  , 'b'  ]]
+    ret = @array.ljust_rows
+    ret.should ==     [['a ' , 'aa' , 'a ' ],
+                       ['bbb', 'b  ', 'b  ']]
+    # Should not have modified @array
+    @array.should ==  [['a'  , 'aa', 'a'],
+                       ['bbb', 'b' , 'b']]
+  end
+end
+
+#---------------------------------------------------------------------------------------------------
+
+describe 'Array.rjust_rows' do
+  before do
+    @array =          [[  'a',  'aa',   'a'],
+                       ['bbb',   'b',   'b']]
+  end
+
+  it 'should not modify receiver array' do
+    @array.should ==  [[  'a',  'aa',   'a'],
+                       ['bbb',   'b',   'b']]
+    ret = @array.rjust_rows
+    ret.should ==     [[ ' a',  'aa',  ' a'],
+                       ['bbb', '  b', '  b']]
+    # Should not have modified @array
+    @array.should ==  [[  'a',  'aa',   'a'],
+                       ['bbb',   'b',   'b']]
+  end
+end
+=end
+

data/lib/quality_extensions/array/{average.rb → mean.rb}

@@ -11,7 +11,7 @@ class Array
   # Calculates the arithmetic average (mean) of the elements in the array as a <tt>Float</tt>.
   #   irb -> [1, 3, 3].average
   #       => 2.33333333333333
-  def average
+  def mean
     if self.size == 0
       raise ZeroDivisionError
     end

data/lib/quality_extensions/array/sum.rb

@@ -0,0 +1,30 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+#   Wait, so Facets has mode (http://facets.rubyforge.org/src/doc/rdoc/classes/Enumerable.html#M001253) but it doesn't have mean/average?
+#   Whether or not this Array#average is included, Facets ought to have an Enumerable#mean/average similar to mode that uses each iterator rather than Array#size. (Still might want to keep this version if it's more efficient for Arrays?)
+#++
+
+class Array
+  def sum
+    inject( nil ) { |sum,x| sum ? sum+x : x }
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_sum
+    assert_equal 5, [2, 3].sum
+  end
+end
+=end

data/lib/quality_extensions/enumerable/all_same.rb

@@ -0,0 +1,43 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# History::
+#++
+
+module Enumerable
+  def all_same?
+    all? {|a| a == first}
+  end
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe 'Enumerable#all_same?' do
+  it 'works with arrays' do
+    [1, 2].all_same?.should == false
+    [1, 1].all_same?.should == true
+
+    (1 == '1').should == false
+    [1, '1'].all_same?.should == false
+  end
+
+  it 'works with Enumerators' do
+    'a b'.chars.all_same?.should == false
+    'aaa'.chars.all_same?.should == true
+  end
+end
+=end
+