quality_extensions 1.1.4 → 1.1.6

data/lib/quality_extensions/enumerable/select_with_index.rb

@@ -0,0 +1,145 @@
+#--
+# Author::    Tyler Rick
+# Inspired by: http://snippets.dzone.com/posts/show/3746 (ntk on Fri Mar 30 10:00:43 -0400 2007)
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# History::
+#++
+
+require 'facets/kernel/require_local'
+require_local 'select_bang'
+
+module Enumerable
+#   def reject!
+#     if self.is_a? Range
+#       to_a.reject! { yield }
+#     else
+#       raise NoMethodError
+#     end
+#   end
+
+   def select_with_index
+     index = -1
+     if block_given?
+       #select { |x| index += 1; yield(x, index) }  # not hash friendly?
+       select { |*args| index += 1; yield(*(args + [index])) }
+     else
+       self
+     end
+   end
+
+   def select_with_index!
+     index = -1
+     if block_given?
+       select! { |x| index += 1; yield(x, index) }
+     else
+       self
+     end
+   end
+
+   def reject_with_index
+     index = -1
+     if block_given?
+       reject { |x| index += 1; yield(x, index) }
+     else
+       self
+     end
+   end
+
+   def reject_with_index!
+     index = -1
+     if block_given?
+       reject! { |x| index += 1; yield(x, index) }
+     else
+       self
+     end
+   end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe 'Enumerable#select_with_index' do
+  it 'select_with_index without a block, return self' do
+    ('a'..'e').select_with_index.should == ('a'..'e')
+  end
+
+  it 'reject_with_index without a block, return self' do
+    ('a'..'n').reject_with_index.should == ('a'..'n')
+  end
+
+  it 'select_with_index with i % 2 == 0' do
+    ('a'..'e').select_with_index { |x, i| x if i % 2 == 0 }.should == ["a", "c", "e"]
+  end
+
+  it 'reject_with_index with i % 2 == 0' do
+    ('a'..'n').reject_with_index { |x, i| x if i % 2 == 0 }.should == ["b", "d", "f", "h", "j", "l", "n"]
+  end
+end
+
+describe 'Enumerable#select_with_index!' do
+  it 'reject!' do
+    a = %w[a b c d]
+    a.reject! {|e| e =~ /[ab]/}
+    a.should == %w[c d]
+  end
+
+  it 'select!' do
+    a = %w[a b c d]
+    a.select! {|e| e =~ /[ab]/}
+    a.should == %w[a b]
+  end
+
+  it 'select_with_index! modifies receiver' do
+    a = %w[a b c d]
+    a.select_with_index! { |x, i| x if i % 2 == 0 }.should == a
+    a.should == %w[a c]
+  end
+
+  it 'reject_with_index! modifies receiver' do
+    a = %w[a b c d]
+    a.reject_with_index! { |x, i| x if i % 2 == 0 }.should == a
+    a.should == %w[b d]
+  end
+end
+
+describe 'Enumerable#select_with_index! with hashes' do
+  it 'reject!' do
+    pending
+    a = %w[a b c d]
+    a.reject! {|e| e =~ /[ab]/}
+    a.should == %w[c d]
+  end
+
+  it 'select!' do
+    pending
+    a = %w[a b c d]
+    a.select! {|e| e =~ /[ab]/}
+    a.should == %w[a b]
+  end
+
+  it 'select_with_index! modifies receiver' do
+    pending
+    a = %w[a b c d]
+    a.select_with_index! { |x, i| x if i % 2 == 0 }.should == a
+    a.should == %w[a c]
+  end
+
+  it 'reject_with_index! modifies receiver' do
+    pending
+    a = %w[a b c d]
+    a.reject_with_index! { |x, i| x if i % 2 == 0 }.should == a
+    a.should == %w[b d]
+  end
+end
+=end

data/lib/quality_extensions/hash/hash_select.rb

@@ -2,11 +2,13 @@
 # Author::    Tyler Rick
 # Copyright:: Copyright (c) 2007 QualitySmith, Inc.
 # License::   Ruby License
-# Submit to Facets?:: Yes.
+# Submit to Facets?:: No.
+# Deprecated. Ruby 1.9 implements #select correctly.
 #++
 
 require "rubygems"
 
+if RUBY_VERSION < '1.9'
 class Hash
   # call-seq:
   #   hash.hash_select {| key, value | block }  -> hash
@@ -24,6 +26,7 @@ class Hash
   alias_method :hash_find_all, :hash_select
   alias_method :delete_unless, :hash_select
 end
+end
 
 #  _____         _
 # |_   _|__  ___| |_
@@ -34,7 +37,7 @@ end
 =begin test
 require 'test/unit'
 
-class TheTest < Test::Unit::TestCase
+class HashSelectTest < Test::Unit::TestCase
   def test_1
     hash_copy = hash = {:a => 1, :b => 2}
     assert_equal hash.reject      {|k,v| k != :b},

data/lib/quality_extensions/hash/merge_if.rb

@@ -0,0 +1,48 @@
+    duplicates = {}
+
+    people_by_name = {}
+    @people.each do |person|
+      people_by_name[person.name] ||= []
+      people_by_name[person.name] << person
+    end
+    people_by_name.reject! {|name, people| people.size < 2}
+    # Merge elements of this hash back into duplicates, unless it already contains a value (a duplicate) for that value (even if it's for a different key). We don't want to have duplicate duplicates!
+    #duplicates.merge_if(people_by_name) {|k, v| !duplicates.values.include?(v) }
+    require 'ruby-debug'; debugger
+    people_by_name.each {|k, v| duplicates[k] = v unless duplicates.values.include?(v) }
+
+    people_by_wwu_id = {}
+    @people.each do |person|
+      people_by_wwu_id[person.wwu_id] ||= []
+      people_by_wwu_id[person.wwu_id] << person
+    end
+    people_by_wwu_id.reject! {|wwu_id, people| people.size < 2}
+    people_by_name.each {|k, v|
+      duplicates[k] = v unless duplicates.values.include?(v)
+    }
+
+    people_by_email = {}
+    @people.each do |person|
+      people_by_wwu_id[person.email_address] ||= []
+      people_by_wwu_id[person.email_address] << person
+    end
+    people_by_email.reject! {|wwu_id, people| people.size < 2}
+    people_by_name.each {|k, v|
+      duplicates[k] = v unless duplicates.values.include?(v)
+    }
+
+    puts "These people have duplicates:"
+    duplicates.each do |key, people|
+      next if key.blank?
+      puts
+      puts key
+      people.each do |person|
+        puts "#{person.id} ('#{person.first_name}' '#{person.last_name}')".ljust(27) + ' ' +
+          (person.username || '').ljust(17) + ' ' +
+          (person.wwu_id || '').ljust(9) + ' ' +
+          person.created_at.strftime("%Y-%m-%d %H:%M") + ' ' +
+          (person.last_successful_login_at && person.last_successful_login_at.strftime("%Y-%m-%d %H:%M")).to_s.ljust(16) + ' ' +
+          'Profiles: ' + person.profiles.map {|p| "#{p.volume.name} (#{p.user_type.name}, #{p.photos.size} photos)"}.join(', ')
+      end
+    end
+

data/lib/quality_extensions/kernel/example_printer.rb

@@ -21,11 +21,12 @@ require 'quality_extensions/module/attribute_accessors'
 # alternative is dirt simple, and it still works.
 module ExamplePrinter
   # Prints the given statement (+code+ -- a string) before evaluating it.
-  # Same as xmp only it doesn't print the return value.
+  # Same as xmp only it doesn't print the return value. Is it instead of xmp when the return value isn't interesting or might even be distracting to the reader.
   #
   #   o = nil
-  #   xmp 'o = C.new', binding
-  #   # => o = C.new
+  #   put_statement 'o = C.new', binding
+  #   # Outputs:
+  #   # o = C.new
   def put_statement(code, binding = nil, file = __FILE__, line = __LINE__)
 
     # We'd like to be able to just use the binding of the caller without passing it in, but unfortunately I don't know how (yet)...
@@ -46,6 +47,12 @@ module ExamplePrinter
   # Pretty much compatible with irb/xmp. But you have currently have to pass
   # in the binding manually if you have any local variables/methods that xmp
   # should have access to.
+  #
+  #   o = nil
+  #   xmp '3 + x', binding
+  #   # Outputs:
+  #   # 3 + x
+  #   # => 4
   def xmp(code, binding = nil, options = {})
     result = put_statement(code, binding)
     puts "=> #{result}"

data/lib/quality_extensions/kernel/require_all.rb

@@ -38,8 +38,14 @@ module Kernel
       else
         raise ArgumentError.new("Expected a String or a FileList")
     end
-    files = files.exclude(*exclusions)                                       if (exclusions = options.delete(:exclude))
-    files = files.exclude(*exclusions.map {|a| File.exact_match_regexp(a) }) if (exclusions = options.delete(:exclude_files))
+    if (exclusions = options.delete(:exclude))
+      exclusions = [exclusions] if exclusions.is_a? String
+      files = files.exclude(*exclusions)
+    end
+    if (exclusions = options.delete(:exclude_files))
+      exclusions = [exclusions] if exclusions.is_a? String
+      files = files.exclude(*exclusions.map {|a| File.exact_match_regexp(a) })
+    end
 
     files.each do |filename|
       # puts "requiring #{filename}" if filename =~ /test/
@@ -106,12 +112,13 @@ class TheTest < Test::Unit::TestCase
     assert_equal ['moo.rb'], $loaded
 
     # But, we can still trick it!
-    $LOAD_PATH << @base_dir
-    require "moo"
-    assert_equal ['moo.rb', 'moo.rb'], $loaded
-
-    load "moo.rb"
-    assert_equal ['moo.rb', 'moo.rb', 'moo.rb'], $loaded
+    # Update: Apparently, in Ruby 1.9.1, this no longer works. moo.rb will only be required once.
+#    $LOAD_PATH << @base_dir
+#    require "moo"
+#    assert_equal ['moo.rb', 'moo.rb'], $loaded
+#
+#    load "moo.rb"
+#    assert_equal ['moo.rb', 'moo.rb', 'moo.rb'], $loaded
   end
 
   def test_deep_subdir
@@ -172,6 +179,15 @@ class TheTest < Test::Unit::TestCase
     assert_equal ['yes.rb'], $loaded
   end
 
+  def test_exclude_filename_string
+    create_ruby_file 'yes2.rb'
+    create_ruby_file 'all2.rb'
+
+    require_all File.dirname(@base_dir), :exclude_files => 'all2.rb'
+
+    assert_equal ['yes2.rb'], $loaded
+  end
+
   #-------------------------------------------------------------------------------------------------------------------------------
   # Helpers
 

data/lib/quality_extensions/kernel/sleep_loudly.rb

@@ -0,0 +1,108 @@
+module Kernel
+  
+  # Sleeps for integer +n+ number of seconds, by default counting down from +n+ (inclusive) to 0, with a +step+ size of -1, printing the value of the counter at each step (3, 2, 1, 0 (output 4 times) if +n+ is 3), each time separated by a ', '.
+  #
+  # In effect, it is a simple on-screen countdown (or count-up) timer.
+  #
+  # To change the step size, supply a value for +step+ other than -1 (the default). It will sleep for +step.abs+ seconds between each iteration, and at each iteration will either yield to the supplied block or (the default) output the current value of the counter).
+  #
+  # The value of +step+ also determines in which *direction* to count:
+  # If +step+ is negative (the default), it counts *down* from +n+ down to 0 (inclusive).
+  # If +step+ is positive, it counts *up* from 0 up to +n+ (inclusive).
+  #
+  # +step+ does not need to be an integer value.
+  #
+  # If +n+ is not evenly divisible by +step+ (that is, if step * floor(  /  ? ) > n), the final step size will be shorter to ensure that the total amount slept is +n+ seconds. More precisely, the amount of time it sleeps before the final iteration (during which it won't sleepat all) will 
+  #
+  # If a block is provided, all of the default output is overridden, and the block will be yielded with the value of the counter i once every second instead of the default behavior, allowing you to customize what gets output, if anything, or what else happens, every +n.abs+ seconds.
+  #
+  # Note that it produces output (or executes your block, if supplied) n+1 times, *not* n times. This allows you to output (or not) both when the timer is first started *and* when it finishes. But because it sleeps for 1 second after the first n iterations only and *not* after the last, the total delay is still only n seconds.
+  #
+  # Examples:
+  #
+  #   sleep_loudly(3) 
+  #     3<sleep 1>2, <sleep 1>1, <sleep 1>0
+  #
+  #   sleep_loudly(3) {|i| puts(i == 0 ? 'Done' : i)}
+  #   3<sleep 1>
+  #   2<sleep 1>
+  #   1<sleep 1>
+  #   Done
+  #
+  #   sleep_loudly(10*60, :up, 60) {|i| print i*60, ", "} # sleep for 10 minutes, outputting after every 60 seconds
+  #     0<sleep 60>2, <sleep 60>2, <sleep 60>3, 
+  #
+  #   sleep_loudly(3, :up) {|i| print i}
+  #     0<sleep 1>1<sleep 1>2<sleep 1>3
+  #
+  #   sleep_loudly(3, :up) {|i| print i+1 unless i==3}
+  #     1<sleep 1>2<sleep 1>3<sleep 1>
+  #
+  def sleep_loudly(n, step = -1, options = {}, &block)
+    debug = options[:debug] == true ? 1 : 0
+    #debug = 1
+
+    old_sync, STDOUT.sync = STDOUT.sync, true
+    if step < 0
+      starti, endi = n, 0
+    elsif step > 0
+      starti, endi = 0, n
+    else
+      raise ArgumentError, "step must be positive or negative, not 0"
+    end
+
+    puts "Counting from #{starti} to #{endi} in increments of #{step} (total time should be n=#{n})" if debug
+
+    i = starti
+    final = false
+    loop do
+      print 'final' if final
+      if block_given?
+        yield *[i, final][0..block.arity-1]
+      else
+        print "#{i}"
+      end
+
+      break if final
+
+      remaining = (i - endi).abs
+
+      # if n was a multiple of step, remaining will eventually be 0, telling us that there is one final iteration to go
+      # if n was not a multiple of step, use a different, smaller step as the final step; and we know that there is one final iteration to go
+      if remaining < step.abs
+        s = (step < 0 ? i-endi : endi-i)
+        print " (using smaller final step #{s}) " if debug
+        final = true # the next iteration is the final one
+      else
+        s = step
+      end
+      i += s
+      print " (+#{s}=#{i}) " if debug
+
+      print ", " unless block_given?
+      print " (sleeping for #{s.abs}) " if debug
+      sleep s.abs 
+    end
+
+    print "\n" unless block_given?
+    STDOUT.sync = old_sync
+  end
+end
+
+=begin tests
+# To do: convert to use test framework
+debug = 1
+require 'benchmark'
+def benchmark(&block)
+  puts(Benchmark.measure { yield })
+end
+benchmark { sleep_loudly(2, 1, :debug => true) }
+#benchmark { sleep_loudly(3, -1) }
+#benchmark { sleep_loudly(3.2) }
+#benchmark { sleep_loudly(3) {|i| print i}; puts }
+#benchmark { sleep_loudly(3) {|i| print i+1 unless i==3} }
+#benchmark { sleep_loudly(3) {|i| puts(i == 0 ? 'Done' : i)} }
+benchmark { sleep_loudly(n=4, 1.5) {|i| print i; print ", "}; puts }
+benchmark { sleep_loudly(n=5, 2) {|i, final| break if final; print i/2; print ", "}; puts }
+#benchmark { sleep_loudly(n=5, 2) }
+=end

data/lib/quality_extensions/kernel/uninterruptable.rb

@@ -0,0 +1,22 @@
+# Source: http://svn.idaemons.org/repos/inplace/trunk/inplace.rb
+
+$uninterruptible = false
+
+[:SIGINT, :SIGQUIT, :SIGTERM].each { |sig|
+  trap(sig) {
+    unless $uninterruptible
+      STDERR.puts "Interrupted."
+      exit 130
+    end
+  }
+}
+
+def uninterruptible
+  orig = $uninterruptible
+  $uninterruptible = true
+
+  yield
+ensure
+  $uninterruptible = orig
+end
+

data/lib/quality_extensions/matrix/indexable.rb

@@ -0,0 +1,68 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# History::
+#++
+
+require 'matrix'
+
+class Matrix
+  #
+  # Changes element (+i+,+j+) of the matrix. (That is: row +i+, column +j+.)
+  #
+  def []=(i, j, new)
+    @rows[i][j] = new
+  end
+end
+
+class Vector
+  #
+  # Changes element number +i+ (starting at zero) of the vector.
+  #
+  def []=(i, new)
+    @elements[i] = new
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe 'Matrix' do
+  it '#[]=' do
+    m = Matrix[['a', 'b'], ['c', 'd']]
+    m[0, 0] = 'new'
+    m.should == Matrix[['new', 'b'], ['c', 'd']]
+  end
+end
+
+describe 'Vector' do
+  it '#[]=' do
+    v = Vector[1, 2]
+    v[0] = 10
+    v.should == Vector[10, 2]
+  end
+
+  it 'Chanhing vector returned by Matrix#column by using Vector#[]= will not change the values in the Matrix' do
+    m = Matrix[['a', 'b'], ['c', 'd']]
+
+    v = m.column(0)
+    v[1] = 'new'
+    v.should           == Vector['a', 'new']
+    m.column(0).should == Vector['a', 'c']   # []= only changes the vector
+
+    m.column(0)[1].replace 'new'             # changes the string object itself, which both vector and matrix share
+    m.column(0).should == Vector['a', 'new']
+    m.column(0).should == Vector['a', 'new']
+  end
+end
+=end
+

data/lib/quality_extensions/matrix/linked_vectors.rb

@@ -0,0 +1,137 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# User notes:: Only changes done via []= are currenly propagated back to the parent matrix!
+# History::
+#++
+
+require 'matrix'
+require File.dirname(__FILE__) + "/indexable"
+
+# Idea: could also hide this functionality in a module which is then included as needed
+#class Matrix
+#  module VectorsLinkedToParentMatrix
+#  end
+#end
+
+#---------------------------------------------------------------------------------------------------
+class Matrix
+  MatrixDetails = Struct.new(:matrix, :i)
+
+  #
+  # Returns row vector number +i+ of the matrix as a Vector (starting at 0 like
+  # an array).  When a block is given, the elements of that vector are iterated.
+  #
+  def row(i) # :yield: e
+    if block_given?
+      for e in @rows[i]
+        yield e
+      end
+    else
+      # Because an array of rows happens to be the native internal format of a matrix, the only thing changed was passing copy = false instead of copy = true. Then the rows are passed by reference instead of dup'd and any changes made to them will automatically be made in the matrix as well.
+      Vector.elements(@rows[i], false)
+    end
+  end
+
+  #
+  # Returns column vector number +j+ of the matrix as a Vector (starting at 0
+  # like an array).  When a block is given, the elements of that vector are
+  # iterated.
+  #
+  def column(j) # :yield: e
+    if block_given?
+      0.upto(row_size - 1) do
+        |i|
+        yield @rows[i][j]
+      end
+    else
+      col = (0 .. row_size - 1).collect {
+        |i|
+        @rows[i][j]
+      }
+      # With column vectors, it's a bit trickier to link changes so they propagate to the matrix. The matrix doesn't natively store an array of column arrays. The column array constructed here is already a copy. So we pass the matrix by reference and the column number so that we can later use Matrix#[]= to propagate changes to the vector back to the matrix.
+      Vector.elements(col, false, MatrixDetails.new(self, j))
+    end
+  end
+end
+
+class Vector
+  #
+  # Creates a vector from an Array.  The optional second argument specifies
+  # whether the array itself or a copy is used internally.
+  #
+  def Vector.elements(array, copy = true, matrix_details = nil)
+    new(:init_elements, array, copy, matrix_details)
+  end
+  
+  #
+  # For internal use.
+  #
+  def initialize(method, array, copy, matrix_details = nil)
+    self.send(method, array, copy)
+    @matrix_details = matrix_details
+  end
+
+  #
+  # Updates element number +i+ (starting at zero) of the vector.
+  #
+  # If this vector is linked with (a row or column of) a matrix, it changes the corresponding element of that matrix too.
+  #
+  def []=(i, new)
+    @elements[i] = new
+
+    # Update linked matrix too
+    if @matrix_details.respond_to? :matrix
+      #puts "@matrix_details.matrix[#{i}, #{@matrix_details.i}] = #{new.inspect}"
+      @matrix_details.matrix[i, @matrix_details.i] = new
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe 'Matrix' do
+  it '#[]=' do
+    m = Matrix[['a', 'b'], ['c', 'd']]
+    m[0, 0] = 'new'
+    m.should == Matrix[['new', 'b'], ['c', 'd']]
+  end
+end
+
+describe 'Changing vector returned by Matrix#column/row by using Vector#[]=' do
+  it '#[]=' do
+    v = Vector[1, 2]
+    v[0] = 10
+    v.should == Vector[10, 2]
+  end
+
+  it '(column) *will* change the values in the linked Matrix' do
+    m = Matrix[['a', 'b'], ['c', 'd']]
+
+    v = m.column(0)
+    v[0] = 'new'
+    v.should           == Vector['new', 'c']
+    m.column(0).should == Vector['new', 'c']
+  end
+
+  it '(row) *will* change the values in the linked Matrix' do
+    m = Matrix[['a', 'b'], ['c', 'd']]
+
+    v = m.row(0)
+    v[0] = 'new'
+    v.should           == Vector['new', 'b']
+    m.row(0).should    == Vector['new', 'b']
+  end
+end
+=end
+

data/lib/quality_extensions/module/class_methods.rb

@@ -14,6 +14,8 @@ class Object
     (
         methods(include_super) \
       - instance_methods
+      #- Object.instance_methods ?
+      #- Module.methods
     ).
       sort
   end

data/lib/quality_extensions/object/non.rb

@@ -0,0 +1,12 @@
+class Object
+  def nonblank?
+    !blank?
+  end
+end
+
+class Object
+  def nonnil?
+    !nil?
+  end
+end
+