quality_extensions 1.1.4 → 1.1.6

data/lib/quality_extensions/range_list.rb

@@ -0,0 +1,222 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+require 'delegate'
+require 'facets/kernel/silence'
+
+module Kernel
+  def RangeList(*args)
+    RangeList.new(*args)
+  end
+end
+
+# A RangeList is a mixed array of numbers and ranges.
+#
+# It can be used to to represent "discontiguous ranges" (something a single Range object cannot do, unfortunately), for example [1..3, 5, 7..9],
+#
+#   RangeList([1..3, 5, 7..9]).to_a
+#   => [1, 2, 3, 5, 6, 7]
+#
+# A RangeList acts like a range:
+# * iterators like each will yield each element from a range (expanding them to the array of elements they represent) rather than the range itself
+#   RangeList([1..2, 4]).map {|e| e} # => [1, 2, 4]
+# * to_a expands any ranges in the RangeList using expand_ranges and returns a simple array composed of its atomic elements and elements from the expanded ranges
+#
+# In every other respect, however, a RangeList behaves like a range.
+#
+class RangeList < DelegateClass(::Array)
+  include Enumerable
+
+  class FormatError < StandardError; end
+
+  def initialize(*args)
+    if args.size == 1 and args[0].is_a?(Range)
+      super(@array = [args[0]])
+    else
+      super(@array = Array.new(*args))
+    end
+  end
+
+  def self.superclass; Array; end
+#  def ===(a)
+#    p a.class
+#  end
+
+  def to_range_list
+    self
+  end
+
+  # Converts to a normal array, expanding all Ranges contained in this array, replacing the range with the list of *elements* that the range represents (range.+to_a+) .
+  #
+  def expand_ranges
+    new_array = []
+    @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
+  alias_method :to_a, :expand_ranges
+
+  def each
+    expand_ranges.each { |element| yield element }
+  end
+end
+
+
+class String
+
+  #Range_list_item_format = /(\d+)(-(\d+))?/  # if only - is allowed as delimiter within a range
+  Range_list_item_format = /(\d+)((-|\.\.|\.\.\.)(\d+))?/
+  Range_list_format = /^#{Range_list_item_format}(,#{Range_list_item_format})*$/
+
+  # A "range list" is an array of numbers and ranges, for example [1..3, 5, 7..9], and is a way to represent "discontiguous ranges" (something a single Range object cannot do, unfortunately).
+  #
+  # See also: Array#expand_ranges
+  #
+  # Name: to_range_list? parse_range_list?
+  #
+  # To do:
+  # * Allow other format styles besides a-b and a..b and a...b : (a,b), [a,b], [a,b)
+  # * Allow indeterminate ranges like '7-' (7 to infinity)?
+  #
+  def to_range_list
+    raise RangeList::FormatError unless match(Range_list_format)
+    array = split(',')
+    array.map! {|e|
+      md = e.match(/^#{Range_list_item_format}$/)
+      range_type = md[3]
+      points = [md[1], md[4]].compact.map(&:to_i)
+      case points.size
+      when 1
+        points[0]
+      when 2
+        case range_type
+        when '...'
+          points[0] ... points[1]
+        when '-', '..'
+          points[0] .. points[1]
+        else
+          raise "Unexpected range_type #{range_type}"
+        end
+      end
+    }
+    array.to_range_list
+  end
+end
+
+
+class Array
+  def to_range_list
+    RangeList.new(self)
+  end
+
+  # Converts array to a RangeList and expands all Ranges contained in this array, replacing the range with the list of *elements* that the range represents (range.+to_a+) .
+  #
+  def expand_ranges
+    to_range_list.expand_ranges
+  end
+
+#  def self.===(other)
+#    other.is_a?(RangeList) || super
+#  end
+end
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe RangeList do
+  it 'thinks it is a subclass of Array' do
+    RangeList.superclass.should == Array
+    #(Array === RangeList.new).should == true
+  end
+
+  it 'you can use RangeList() as an alias for RangeList.new()' do
+    RangeList([1,2..3]).to_a.should == [1,2,3]
+  end
+
+  it '#to_a expands ranges to their respective elements' do
+    RangeList.new([1,2..3]). to_a.should == [1,2,3]
+    RangeList.new([1,2...3]).to_a.should == [1,2]
+  end
+
+  it 'behaves like an Array: <<, concat, ...' do
+    array = RangeList.new
+    array << (1..2)
+    array.concat [3..4]
+    array.push 9
+    array.should == [1..2, 3..4, 9]
+  end
+
+  it 'behaves like a Range: iterators yield elements from expanded ranges rather than ranges themselves' do
+    RangeList(1..2).enum_for(:each).to_a.should == [1,2]
+
+    RangeList([1..3, 5, 7..9]).enum_for(:each).to_a.should ==
+    RangeList([1..3, 5, 7..9]).to_a
+
+    RangeList(1..2).enum_for(:each).to_a.should == [1,2]
+
+    RangeList([1..2, 4]).map {|e| e}.should == [1, 2, 4]
+  end
+end
+
+describe 'String#to_range_list' do
+  it 'works when you simply have a number' do
+    "1".to_range_list.should == [1]
+  end
+
+  it 'works when you simply have a list of numbers' do
+    "1,2".to_range_list.should == [1,2]
+  end
+
+  it 'works when you throw in a range' do
+    "1,2-3".  to_range_list.should == [1,2..3]
+    "1,2..3". to_range_list.should == [1,2..3]
+    "1,2...3".to_range_list.should == [1,2...3]
+  end
+
+  it 'works even for the complicatedest range list you can think up' do
+    "1..3,5,7...9,11-12".  to_range_list.should == [1..3,5,7...9,11..12]
+  end
+end
+
+describe 'Array#to_range_list' do
+  it 'works' do
+    [].to_range_list.should be_instance_of(RangeList)
+    [1..3,5,7...9,11..12].  to_range_list.should == [1..3,5,7...9,11..12]
+    [1..3,5,7...9,11..12].  to_range_list.should be_instance_of RangeList
+  end
+end
+
+describe 'Array#expand_ranges' do
+  it 'works' do
+    [].expand_ranges.should be_instance_of(Array)
+    [1, 2, 3].     expand_ranges.should == [1, 2, 3]
+    [1..3].        expand_ranges.should == [1, 2, 3]
+    [1..3, 5..7].  expand_ranges.should == [1, 2, 3, 5, 6, 7]
+  end
+end
+
+=end
+

data/lib/quality_extensions/safe_nil.rb

@@ -12,7 +12,9 @@
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 require 'singleton'
 require 'rubygems'
-require 'facets/basicobject'
+require 'builder/blankslate'
+#require 'facets/basicobject'
+#puts Object.methods.include?(:blank_slate_method_added) # not there?
 
 
 class Object
@@ -50,8 +52,8 @@ end
 
 # Extending BasicObject because it provides us with a clean slate. It is similar to Object except it has almost all the standard methods stripped away so that
 # we will hit method_missing for almost all method routing.
-class SafeNil < BasicObject
-  include Singleton   # I assume this is because it's faster than instantiating a new object each time.
+class SafeNil < BlankSlate
+  include ::Singleton   # I assume this is because it's faster than instantiating a new object each time.
 
   #undef inspect   # Use nil's version of inspect... although I wonder whether it would be better to have it return "SafeNil" so you know it's different than a normal nil.
   def inspect

data/lib/quality_extensions/string/each_char_with_index.rb

@@ -8,7 +8,6 @@
 
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 require 'rubygems'
-require 'quality_extensions/enumerable/enum'
 
 class String
   def each_char_with_index
@@ -34,7 +33,7 @@ require 'test/unit'
 class TheTest < Test::Unit::TestCase
   def test_1
     assert_equal [[0, "a"], [1, "b"], [2, "c"]],
-                 'abc'.enum(:each_char_with_index).to_a
+                 'abc'.to_enum(:each_char_with_index).to_a
   end
 end
 =end

data/lib/quality_extensions/string/integer_eh.rb

@@ -0,0 +1,3 @@
+# Alias for:
+require 'facets/kernel/require_local'
+require_local 'numeric_eh'

data/lib/quality_extensions/string/numeric_eh.rb

@@ -0,0 +1,74 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick and others
+# Credits:: 
+# - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/14518
+# - http://www.ruby-forum.com/topic/123422
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+class String
+  # returns true if the string is a valid number (which can be converted to an actual number using the Float() or String#to_f methods); otherwise returns false
+  def numeric?
+    !self.empty? && !!Float(self) rescue false
+  end
+
+  # returns true if the string is a valid integer (which can be converted to an Integer using the Integer() or String#to_i methods); otherwise returns false
+  def integer?
+    # not the empty string and containing only 1 or more digits
+    !self.empty? && !!(self =~ /\A[-+]?\d+\Z/)
+  end
+  #def integer?
+  #  !!Integer(self) rescue false
+  #end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe 'String#numeric?' do
+  it 'returns true for valid numbers' do
+    '3'.numeric?.should     == true
+    '+3'.numeric?.should    == true
+    '-3'.numeric?.should    == true
+    '3.14'.numeric?.should  == true
+    '-3.14'.numeric?.should == true
+  end
+
+  it 'returns false for invalid numbers' do
+    '3.14.1'.numeric?.should == false
+    '1,2'.numeric?.should    == false
+    'a'.numeric?.should      == false
+    '3a'.numeric?.should     == false
+  end
+end
+
+describe 'String#integer?' do
+  it 'returns true for valid numbers' do
+    '3'.integer?.should     == true
+    '+3'.integer?.should    == true
+    '-3'.integer?.should    == true
+  end
+
+  it 'returns false for non-integer strings' do
+    '3.14'.integer?.should  == false
+    '-3.14'.integer?.should == false
+  end
+
+  it 'returns false for invalid numbers' do
+    '3.14.1'.integer?.should == false
+    '1,2'.integer?.should    == false
+    'a'.integer?.should      == false
+    '3a'.integer?.should     == false
+  end
+end
+=end

data/lib/quality_extensions/string/safe_in_comment.rb

@@ -0,0 +1,38 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+
+
+class String
+  def safe_in_comment
+    gsub('-', '-')
+  end
+end
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe 'safe_in_comment' do
+  it 'works' do
+    '1-2'.safe_in_comment.should == '1-2'
+  end
+end
+=end
+

data/lib/quality_extensions/string/safe_numeric_conversion.rb

@@ -0,0 +1,102 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2001, Leo [ slonika AT yahoo DOT com ], Tyler Rick
+# Credits:: 
+# - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/14518
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+
+# Conversion from a String to Numbers should raise an exception if the string has
+# an improper format. Strangely enough, Ruby's standard conversion functions do not
+# provide for any kind of error handling and return number '0' on failure.
+# Therefore, in Ruby one cannot possibly distinguish between these two cases:
+#       "0".to_i             # -> 0
+#       "not-a-number".to_i  # -> 0
+
+# The following code augments standard conversion functions String#to_i and
+# String#to_f with the error handling code so that an attempt to convert a
+# string not suited for numeric conversion will raise NumericError exception.
+
+class NumericError < RuntimeError
+end
+
+require 'facets/kernel/require_local'
+require_local 'numeric_eh'
+
+
+class String
+  alias __std__to_i to_i   if ! method_defined? :__std__to_i
+  alias __std__to_f to_f   if ! method_defined? :__std__to_f
+  alias __std__hex  hex    if ! method_defined? :__std__hex
+  alias __std__oct  oct    if ! method_defined? :__std__oct
+  
+  def to_i()
+    case self 
+    when /^[-+]?0\d/         then  __std__oct
+    when /^[-+]?0x[a-f\d]/i  then  __std__hex
+    when /^[-+]?\d/          then  __std__to_i
+    else raise NumericError, "Cannot convert string to Integer!"
+    end
+  end
+
+  def to_f()
+    case self
+    when /^[-+]?\d/          then  __std__to_f
+    else raise NumericError, "Cannot convert string to Float!"
+    end
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+
+describe 'String#numeric?' do
+  it 'returns true for valid numbers' do
+    '3'.to_f.should     == 3
+    '+3'.to_f.should    == 3
+    '-3'.to_f.should    == -3
+    '3.14'.to_f.should  == 3.14
+    '-3.14'.to_f.should == -3.14
+
+    # Debatable!: Should also work for strings that are not valid floats but can still be converted
+    '3.14.1'.to_f.should == 3.14
+    '1,2'.to_f.should    == 1
+    '3a'.to_f.should     == 3
+  end
+
+  it 'returns raises an Exception for non-convertable strings' do
+    lambda { 'garbage'.to_f }.should raise_error(NumericError)
+  end
+end
+
+describe 'String#to_i' do
+  it 'returns works for valid numbers' do
+    '3'.to_i.should     == 3
+    '+3'.to_i.should    == 3
+    '-3'.to_i.should    == -3
+
+    # Debatable!: Should also work for strings that are not valid integers but can still be converted
+    # Question: should we make it raise NumericError in these cases? and require a .to_f.to_i if they want to convert strings to floats to integers?
+    '3.14'.to_i.should  == 3
+    '-3.14'.to_i.should == -3
+    '3.14.1'.to_i.should == 3
+    '1,2'.to_i.should    == 1
+    '3a'.to_i.should     == 3
+  end
+
+  it 'returns raises an Exception for non-convertable strings' do
+    lambda { 'garbage'.to_i }.should raise_error(NumericError)
+  end
+end
+=end

data/lib/quality_extensions/string/shell_escape.rb

@@ -43,10 +43,10 @@ class TheTest < Test::Unit::TestCase
   end
 
   # Escape has changed its behavior in newer versions. It wants to return it as type Escape::ShellEscaped.
-  def test_type
-    assert_equal Escape::ShellEscaped, 'a'.shell_escape.class
-    assert_equal 'a', 'a'.shell_escape.to_s
-  end
+#  def test_type
+#    assert_equal Escape::ShellEscaped, 'a'.shell_escape.class
+#    assert_equal 'a', 'a'.shell_escape.to_s
+#  end
 end
 =end
 

data/lib/quality_extensions/string/with_knowledge_of_color.rb

@@ -55,23 +55,31 @@ gem 'colored'
 require 'colored'
 
 class TheTest < Test::Unit::TestCase
+
   def test_strip_color
     assert       "abc" != "abc".blue
     assert_equal "abc",   "abc".blue.strip_color
+
+    assert       "abc" != "abc".underline
+    assert_equal "abc",   "a#{'b'.underline}c".strip_color
   end
+
   def test_length_without_color
     assert_equal 12, "abc".blue.length
     assert_equal 3,  "abc".blue.length_without_color
   end
+
   def test_nonprinting_characters_used_for_color
     assert_equal "\e[34m\e[0m", 'abc'.blue.nonprinting_characters_used_for_color
   end
+
   def test_ljust_with_color
     assert_equal "abc  ", 'abc'.     ljust(              5)
     assert_equal "abc  ", 'abc'.blue.ljust_with_color(5).strip_color
     assert_equal "\e[34mabc\e[0m  ", 'abc'.blue.ljust_with_color(5)
     assert_equal "\e[34mabc\e[0m\e[44m \e[0m\e[44m \e[0m", 'abc'.blue.ljust_with_color(5, ' '.on_blue)
   end
+
   def test_rjust_with_color
     assert_equal "  abc", 'abc'.     rjust(              5)
     assert_equal "  abc", 'abc'.blue.rjust_with_color(5).strip_color

data/lib/quality_extensions/table.rb

@@ -0,0 +1,116 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby license
+# Submit to Facets?::
+# Developer notes::
+#   This was started back when I was under the impression that Matrix wouldn't work with 
+#   non-numerical elements. I was prepared to fork Matrix to make it work better with
+#   strings and such. But it seems like Matrix works fine with string elements.
+#
+#   I added matrix/indexable.rb and matrix/linked_vectors.rb to make working with Matrixes
+#   more enjoyable. And now it looks like I won't have to create a Table class to compete
+#   with Matrix after all!
+# Changes::
+#++
+
+=begin notes
+ > Matrix[['a', 'b'], ['c', 'd']].column(0)
+=> Vector["a", "c"]
+
+ > Matrix[['a', 'b'], ['c', 'd']].t.row(0)
+=> Vector["a", "c"]
+
+ > Matrix[['a', 'b'], ['c', 'd']].row(0)
+=> Vector["a", "b"]
+
+
+
+NArray has nice slice and pretty print features that are worth copying.
+
+ > NArray[['a', 'b'], ['c', 'd']][0..1,0..1]
+=> NArray.object(2,2): 
+[ [ "a", "b" ], 
+  [ "c", "d" ] ]
+
+ > NArray[['a', 'b'], ['c', 'd']][0..1,1]
+=> NArray.object(2): 
+[ "c", "d" ]
+
+ > NArray[['a', 'b'], ['c', 'd']].transpose
+=> NArray.object(2,2): 
+[ [ "a", "b" ], 
+  [ "c", "d" ] ]
+=end
+
+
+require 'delegate'
+
+# A table is...
+class Table < DelegateClass(::Array)
+  include Enumerable
+
+  def self.[](*args)
+    Table.new(*args)
+  end
+
+  # See /usr/lib/ruby/1.8/matrix.rb
+  # Creates a table using rows as an array of row arrays. 
+  def self.rows(rows)
+  end
+
+  # Creates a table using columns as an array of column arrays. 
+  def self.columns(columns)
+  end
+
+  def self.superclass; Array; end
+
+  def initialize(*args)
+    pp args
+    @rows = super(args)
+    #super(@rows = Array.new(*args))
+  end
+
+  def +(other)
+    # should work for tables of strings too
+  end
+
+end
+
+#module Kernel
+#  def Table(*args)
+#    Table.new(*args)
+#  end
+#end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec'
+require 'pp'
+
+describe Table do
+  it 'thinks it is a subclass of Array' do
+    Table.superclass.should == Array
+    #(Array === Table.new).should == true
+  end
+
+  describe 'initialization' do
+    it '' do
+      Table[[1,2],[3,4]].to_a.should == [[1,2],[3,4]]
+    end
+    it '' do
+      Table.new([1,2],[3,4]).to_a.should == [[1,2],[3,4]]
+      #Table.new([[1,2],[3,4]]).to_a.should == [[1,2],[3,4]]
+    end
+  end
+
+end
+=end
+
+

data/lib/quality_extensions/template.rb

@@ -4,7 +4,7 @@
 # License::   Ruby License
 # Submit to Facets?::
 # Developer notes::
-# Changes::
+# History::
 #++
 
 
@@ -22,12 +22,11 @@
 #   |_|\___||___/\__|
 #
 =begin test
-require 'test/unit'
+require 'spec'
 
-class TheTest < Test::Unit::TestCase
-  def test_1
+describe '' do
+  it '' do
   end
-
 end
 =end
 

data/lib/quality_extensions/template.rb_test_unit.rb

@@ -0,0 +1,33 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+
+end
+=end
+