quality_extensions 1.1.6 → 1.3.0

data/lib/quality_extensions/safe_nil.rb

@@ -1,5 +1,5 @@
 #--
-# Credits::    
+# Credits::
 # * Tom Locke (http://hobocentral.net/blog/2007/08/25/quiz/) -- original version
 # * coderrr (http://coderrr.wordpress.com/2007/09/15/the-ternary-destroyer/) -- some optimizations
 # * Tyler Rick -- packaged it, added some documention, and added some tests
@@ -12,22 +12,30 @@
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 require 'singleton'
 require 'rubygems'
+#require 'facets/functor'
+gem 'builder'
 require 'builder/blankslate'
 #require 'facets/basicobject'
 #puts Object.methods.include?(:blank_slate_method_added) # not there?
 
 
 class Object
+  # If you are not sure if the receiver is nil?, you can prefix a method call / operation with _? to be safe. If the receiver is not nil, it will behave as if you'd called your method on the receiver directly.
+  # If on the other hand the receiver is nil (see NilClass#_?), calling _? will cause an instance of SafeNil to be the *real* receiver, which will returns nil when you actually call whatever real method you are calling.
   def _?
     self
   end
+
+  #def unless_blank?
+  #  self
+  #end
 end
 
 class NilClass
-  # The _? method just returns the object itself for all objects except for nil. For nil, _? will return a special version of nil (actually, an instance of 
+  # The _? method just returns the object itself for all objects except for nil. For nil, _? will return a special version of nil (actually, an instance of
   # SafeNil) that lets you call undefined methods.
   #
-  # If you call an undefined method on nil._?, you will get back nil -- rather than raising an exception, which is what would happen if you called the same 
+  # If you call an undefined method on nil._?, you will get back nil -- rather than raising an exception, which is what would happen if you called the same
   # method on a _plain_ old nil!
   #
   # _? gives us a much conciser alternative to this common pattern:
@@ -49,23 +57,27 @@ class NilClass
   end
 end
 
+# http://railstips.org/blog/archives/2009/08/07/patterns-are-not-scary-method-missing-proxy/
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
+end unless defined?(BasicObject)
 
 # 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 < BlankSlate
+#
+# See NilClass#_?/Object#_?
+class SafeNil < BasicObject
   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
-    'SafeNil'
-  end
-
+  # See NilClass#_?/Object#_?
   def method_missing(method, *args, &block)
     return nil  unless nil.respond_to?(method)      # A much faster alternative to 'rescue nil' that can be used most of the time to speed things up.
     nil.send(method, *args, &block) rescue nil
   end
 
+  # See NilClass#_?/Object#_?
   def nil?; true; end
+  def blank?; true; end
 end
 
 
@@ -81,7 +93,7 @@ end
 =begin test
 require 'test/unit'
 
-class TheTest < Test::Unit::TestCase
+class SafeNilTest < Test::Unit::TestCase
   def test_simple__nil
     hash = {}
     assert_equal nil,      hash[:a]._?.length
@@ -91,6 +103,12 @@ class TheTest < Test::Unit::TestCase
     assert_equal 3,        hash[:a]._?.length
   end
 
+  def test_to_s
+    assert_equal '', nil._?.to_s
+    assert_equal( {}.to_s, {}._?.to_s ) # this is '' in 1.8, '{}' in 1.9
+    assert_equal [].to_s, []._?.to_s
+  end
+
   def test_chaining
     hash = {}
     assert_equal nil, hash[:a]._?.foo
@@ -98,19 +116,77 @@ class TheTest < Test::Unit::TestCase
     assert_equal nil, hash[:a]._?[:b]._?[:c]._?.some_method
   end
 
+  # As far as I know, this is impossible to get to pass, since by design an object in Ruby is *always* truthy unless it is false or nil
+  #def test_or_ing
+  #  assert_equal 'else', nil._? || 'else'
+  #end
+
   def test_inspect
-    assert_equal 'SafeNil', nil._?.inspect
+    assert_equal 'nil', nil._?.inspect
+  end
+
+  def test_does_not_permanently_modify_nil_class
+    assert_raise(NoMethodError) { nil.foo }
+    nil._?
+    assert_raise(NoMethodError) { nil.foo }
   end
 
   def test_nil?
     assert SafeNil.instance.nil?
   end
 
+  def test_blank?
+    require 'facets/blank'
+    assert nil.blank?
+    assert SafeNil.instance.blank?
+    assert ({1=>'a', 2=>'b'})[3]._?.blank?
+  end
+end
+
+class UnlessBlankTest < Test::Unit::TestCase
+  def test_simple__blank
+    hash = {}
+    assert_equal nil,      hash[:a]._?.length
+  end
+  def test_simple__normal_objects
+    hash = {:a => 'abc'}
+    assert_equal 3,        hash[:a]._?.length
+  end
+
+  def test_to_s
+    assert_equal '', nil._?.to_s
+    assert_equal( {}.to_s, {}._?.to_s ) # this is '' in 1.8, '{}' in 1.9
+    assert_equal [].to_s, []._?.to_s
+  end
+
+  def test_chaining
+    hash = {}
+    assert_equal nil, hash[:a]._?.foo
+    assert_equal nil, hash[:a]._?[:b]._?[:c]
+    assert_equal nil, hash[:a]._?[:b]._?[:c]._?.some_method
+  end
+
+  def test_inspect
+    assert_equal 'nil', nil._?.inspect
+  end
+
   def test_does_not_permanently_modify_nil_class
     assert_raise(NoMethodError) { nil.foo }
     nil._?
     assert_raise(NoMethodError) { nil.foo }
   end
+
+  def test_nil?
+    assert SafeNil.instance.nil?
+  end
+
+  def test_blank?
+    require 'facets/blank'
+    assert nil.blank?
+    assert SafeNil.instance.blank?
+    assert ({1=>'a', 2=>'b'})[3]._?.blank?
+  end
+
 end
 =end
 

data/lib/quality_extensions/string/integer_eh.rb

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

data/lib/quality_extensions/string/prefix.rb

@@ -0,0 +1,120 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2009, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+class String
+  def prefix(prefix)
+    sub(/^/, prefix)
+  end
+
+  def unprefix(prefix)
+    sub(/^#{Regexp.escape(prefix)}/, "")
+  end
+
+  def suffix(suffix)
+    sub(/$/, suffix)
+  end
+
+  def unsuffix(suffix)
+    sub(/#{Regexp.escape(suffix)}$/, "")
+  end
+
+  #----------------------------------------------------------------------------------------------------
+
+  def prefix_lines(prefix)
+    gsub(/^/, prefix)
+  end
+
+  def unprefix_lines(prefix)
+    gsub(/^#{Regexp.escape(prefix)}/, "")
+  end
+
+  def suffix_lines(suffix)
+    gsub(/$/, suffix)
+  end
+
+  def unsuffix_lines(suffix)
+    gsub(/#{Regexp.escape(suffix)}$/, "")
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe "String#prefix_lines" do
+  it "lets you indent lines, similar to Facets' String#indent(n)" do
+    "abc".  prefix_lines('    ').should == '    abc'
+    "  abc".prefix_lines('  ').  should == '    abc'
+
+    ("abc\n"   +
+     "xyz"     ).prefix_lines('  ').should ==
+    ("  abc\n" +
+     "  xyz")
+  end
+
+  it "lets you comment lines" do
+    "abc".  prefix_lines('# ').should == '# abc'
+    "  abc".prefix_lines('# ').should == '#   abc'
+
+    ("line 1\n"   +
+     "line 2"     ).prefix_lines('# ').should ==
+    ("# line 1\n" +
+     "# line 2")
+  end
+
+  it "lets you uncomment lines" do
+    "# abc".  unprefix_lines('# ').should == 'abc'
+    "#   abc".unprefix_lines('# ').should == '  abc'
+
+    ("# line 1\n"   +
+     "# line 2"     ).unprefix_lines('# ').should ==
+    ("line 1\n" +
+     "line 2")
+  end
+end
+
+describe "String#suffix_lines" do
+  it "lets you indent lines, similar to Facets' String#indent(n)" do
+    "abc".  suffix_lines('    ').should == 'abc    '
+    "abc  ".suffix_lines('  ').  should == 'abc    '
+
+    ("abc\n"   +
+     "xyz"     ).suffix_lines('  ').should ==
+    ("abc  \n" +
+     "xyz  ")
+  end
+
+  it "lets you add something to the end of each line" do
+    "abc". suffix_lines(' \\').should == 'abc \\'
+    "abc ".suffix_lines(' \\').should == 'abc  \\'
+
+    ("line 1\n"   +
+     "line 2"     ).suffix_lines(' \\').should ==
+    ("line 1 \\\n" +
+     "line 2 \\")
+  end
+
+  it "lets you uncomment lines" do
+    "abc \\". unsuffix_lines(' \\').should == 'abc'
+    "abc  \\".unsuffix_lines(' \\').should == 'abc '
+
+    ("line 1 \\\n"   +
+     "line 2 \\"     ).unsuffix_lines(' \\').should ==
+    ("line 1\n" +
+     "line 2")
+  end
+end
+=end

data/lib/quality_extensions/string/prefix_lines.rb

@@ -1,69 +1,4 @@
-#--
-# Author::    Tyler Rick
-# Copyright:: Copyright (c) 2009, Tyler Rick
-# License::   Ruby License
-# Submit to Facets?::
-# Developer notes::
-# Changes::
-#++
-
-class String
-
-  def prefix_lines(prefix)
-    gsub(/^/, prefix)
-  end
-
-  def unprefix_lines(prefix)
-    gsub(/^#{Regexp.escape(prefix)}/, "")
-  end
-
-  # TODO:
-  #def suffix_lines(suffix)
-  #def unsuffix_lines(suffix)
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-require 'spec'
-
-describe "String#prefix_lines" do
-
-  it "lets you indent lines, similar to Facets' String#indent(n)" do
-    "abc".  prefix_lines('    ').should == '    abc'
-    "  abc".prefix_lines('  ').  should == '    abc'
-
-    ("abc\n"   +
-     "xyz"     ).prefix_lines('  ').should ==
-    ("  abc\n" +
-     "  xyz")
-  end
-
-  it "lets you comment lines" do
-    "abc".  prefix_lines('# ').should == '# abc'
-    "  abc".prefix_lines('# ').should == '#   abc'
-
-    ("line 1\n"   +
-     "line 2"     ).prefix_lines('# ').should ==
-    ("# line 1\n" +
-     "# line 2")
-  end
-
-  it "lets you uncomment lines" do
-    "# abc".  unprefix_lines('# ').should == 'abc'
-    "#   abc".unprefix_lines('# ').should == '  abc'
-
-    ("# line 1\n"   +
-     "# line 2"     ).unprefix_lines('# ').should ==
-    ("line 1\n" +
-     "line 2")
-  end
-
-end
-=end
+gem 'facets'
+require 'facets/kernel/require_relative'
+# Alias for:
+require_relative 'prefix'

data/lib/quality_extensions/string/safe_numeric_conversion.rb

@@ -1,7 +1,7 @@
 #--
 # Author::    Tyler Rick
 # Copyright:: Copyright (c) 2001, Leo [ slonika AT yahoo DOT com ], Tyler Rick
-# Credits:: 
+# Credits::
 # - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/14518
 # License::   Ruby License
 # Submit to Facets?::
@@ -24,8 +24,8 @@
 class NumericError < RuntimeError
 end
 
-require 'facets/kernel/require_local'
-require_local 'numeric_eh'
+require 'facets/kernel/require_relative'
+require_relative 'numeric_eh'
 
 
 class String
@@ -33,9 +33,9 @@ class String
   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 
+    case self
     when /^[-+]?0\d/         then  __std__oct
     when /^[-+]?0x[a-f\d]/i  then  __std__hex
     when /^[-+]?\d/          then  __std__to_i

data/lib/quality_extensions/string/shell_escape.rb

@@ -9,7 +9,7 @@ $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 require 'rubygems'
 require 'escape'    # http://www.a-k-r.org/escape/
 require 'facets/symbol/to_proc'
-require 'facets/kernel/require_local'
+require 'facets/kernel/require_relative'
 
 class String
   def shell_escape
@@ -34,11 +34,11 @@ class TheTest < Test::Unit::TestCase
     assert_equal input, output
   end
   def test_using_echo_1
-    assert_that_echo_gives_back_what_we_put_in( 
+    assert_that_echo_gives_back_what_we_put_in(
       %q{!&'"`$0 |()<>} )
   end
   def test_using_echo_2
-    assert_that_echo_gives_back_what_we_put_in( 
+    assert_that_echo_gives_back_what_we_put_in(
       %q{'an arg that's got "quotes"} )
   end
 

data/lib/quality_extensions/string/to_proc.rb

@@ -0,0 +1,119 @@
+# String#to_proc
+#
+# See http://weblog.raganwald.com/2007/10/stringtoproc.html ( Subscribe in a reader)
+#
+# Ported from the String Lambdas in Oliver Steele's Functional Javascript
+# http://osteele.com/sources/javascript/functional/
+#
+# This work is licensed under the MIT License:
+#
+# (c) 2007 Reginald Braithwaite
+# Portions Copyright (c) 2006 Oliver Steele
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class String
+  unless ''.respond_to?(:to_proc)
+    def to_proc &block
+      params = []
+      expr = self
+      sections = expr.split(/\s*->\s*/m)
+      if sections.length > 1 then
+          eval sections.reverse!.inject { |e, p| "(Proc.new { |#{p.split(/\s/).join(', ')}| #{e} })" }, block && block.binding
+      elsif expr.match(/\b_\b/)
+          eval "Proc.new { |_| #{expr} }", block && block.binding
+      else
+          leftSection = expr.match(/^\s*(?:[+*\/%&|\^\.=<>\[]|!=)/m)
+          rightSection = expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m)
+          if leftSection || rightSection then
+              if (leftSection) then
+                  params.push('$left')
+                  expr = '$left' + expr
+              end
+              if (rightSection) then
+                  params.push('$right')
+                  expr = expr + '$right'
+              end
+          else
+              self.gsub(
+                  /(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|self|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/, ''
+              ).scan(
+                /([a-z_$][a-z_$\d]*)/i
+              ) do |v|
+                params.push(v) unless params.include?(v)
+              end
+          end
+          eval "Proc.new { |#{params.join(', ')}| #{expr} }", block && block.binding
+      end
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe "String to Proc" do
+
+  before(:all) do
+    @one2five = 1..5
+  end
+
+  it "should handle simple arrow notation" do
+    @one2five.map(&'x -> x + 1').should eql(@one2five.map { |x| x + 1 })
+    @one2five.map(&'x -> x*x').should eql(@one2five.map { |x| x*x })
+    @one2five.inject(&'x y -> x*y').should eql(@one2five.inject { |x,y| x*y })
+    'x y -> x**y'.to_proc()[2,3].should eql(lambda { |x,y| x**y }[2,3])
+    'y x -> x**y'.to_proc()[2,3].should eql(lambda { |y,x| x**y }[2,3])
+  end
+
+  it "should handle chained arrows" do
+    'x -> y -> x**y'.to_proc()[2][3].should eql(lambda { |x| lambda { |y| x**y } }[2][3])
+    'x -> y z -> y**(z-x)'.to_proc()[1][2,3].should eql(lambda { |x| lambda { |y,z| y**(z-x) } }[1][2,3])
+  end
+
+  it "should handle the default parameter" do
+    @one2five.map(&'2**_/2').should eql(@one2five.map { |x| 2**x/2 })
+    @one2five.select(&'_%2==0').should eql(@one2five.select { |x| x%2==0 })
+  end
+
+  it "should handle point-free notation" do
+    @one2five.inject(&'*').should eql(@one2five.inject { |mem, var| mem * var })
+    @one2five.select(&'>2').should eql(@one2five.select { |x| x>2 })
+    @one2five.select(&'2<').should eql(@one2five.select { |x| 2<x })
+    @one2five.map(&'2*').should eql(@one2five.map { |x| 2*x })
+    (-3..3).map(&'.abs').should eql((-3..3).map { |x| x.abs })
+  end
+
+  it "should handle implied parameters as best it can" do
+    @one2five.inject(&'x*y').should eql(@one2five.inject(&'*'))
+    'x**y'.to_proc()[2,3].should eql(8)
+    'y**x'.to_proc()[2,3].should eql(8)
+  end
+
+end
+=end
+