quality_extensions 0.1.4 → 1.0.0

data/lib/quality_extensions/kernel/remove_const.rb

@@ -6,11 +6,12 @@
 # Developer notes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 require 'quality_extensions/object/ignore_access'
 require 'quality_extensions/module/split'
-require 'facets/core/module/by_name'
-require 'facets/core/module/modspace'
+require 'quality_extensions/module/by_name'
+require 'facets/module/modspace'
 
 class Module
   alias_method :remove_const_before_was_added_to_Kernel, :remove_const

data/lib/quality_extensions/kernel/remove_module.rb

@@ -7,11 +7,12 @@
 # * Deprecated by quality_extensions/module/remove.rb
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 require 'quality_extensions/object/ignore_access'
 require 'quality_extensions/module/split'
-require 'facets/core/module/by_name'
-require 'facets/core/module/modspace'
+require 'quality_extensions/module/by_name'
+require 'facets/module/modspace'
 
 module Kernel
   # This is similar to +remove_const+, but it _only_ works for modules/classes.

data/lib/quality_extensions/kernel/require_all.rb

@@ -5,10 +5,11 @@
 # Submit to Facets?:: Yes
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/more/filelist'
+require 'facets/filelist'
 
-require 'facets/core/kernel/require_local'
+require 'facets/kernel/load'
 require_local '../file/exact_match_regexp'
 
 module Kernel
@@ -71,6 +72,7 @@ end
 #   |_|\___||___/\__|
 #
 =begin test
+require 'test/unit'
 require 'tmpdir'
 require 'fileutils'
 require 'English'
@@ -117,7 +119,7 @@ class TheTest < Test::Unit::TestCase
     create_ruby_file @deep_dir + "/flop.rb"
 
     require_all File.dirname(@base_dir)
-    assert_equal ['flip.rb', @deep_dir + "/flop.rb"], $loaded
+    assert_equal [@deep_dir + "/flop.rb", 'flip.rb'], $loaded
   end
 
   def test_exclude_pattern

data/lib/quality_extensions/kernel/require_once.rb

@@ -5,6 +5,7 @@
 # Submit to Facets?:: No, not yet
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 
 module Kernel

data/lib/quality_extensions/kernel/simulate_input.rb

@@ -6,6 +6,7 @@
 # Developer notes:
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'stringio'
 require 'rubygems'
 

data/lib/quality_extensions/kernel/trap_chain.rb

@@ -5,6 +5,8 @@
 # Submit to Facets?:: Yes!
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
+
 module Kernel
   # Calling <tt>Kernel#trap()</tt> by itself will _replace_ any previously registered handler code.
   # <tt>Kernel#trap_chain()</tt>, on the other hand, will _add_ the block you supply to the existing "list" of registered handler blocks.
@@ -26,6 +28,7 @@ end
 #   |_|\___||___/\__|
 #
 =begin test
+require 'test/unit'
 require 'rubygems'
 require 'quality_extensions/kernel/capture_output'
 require 'fileutils'

data/lib/quality_extensions/module/alias_method_chain.rb

@@ -7,25 +7,13 @@
 # Changes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 gem 'facets'
-#require 'facets/core/module/alias_method_chain'    # Doesn't support blocks or I'd use it.
-require 'facets/core/kernel/singleton_class'
+require 'facets/module/alias'
+require 'facets/kernel/singleton_class'
 
 
-# /usr/lib/ruby/gems/1.8/gems/activesupport-1.4.2/lib/active_support/core_ext/module/aliasing.rb
-class Module
-  def alias_method_chain(target, feature)
-    # Strip out punctuation on predicates or bang methods since
-    # e.g. target?_without_feature is not a valid method name.
-    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-    yield(aliased_target, punctuation) if block_given?
-    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
-    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
-  end
-end
-# end /usr/lib/ruby/gems/1.8/gems/activesupport-1.4.2/lib/active_support/core_ext/module/aliasing.rb
-
 class Module
 
   def alias_method_chain_with_prevent_repeat_aliasing(target, feature, &block)

data/lib/quality_extensions/module/ancestry_of_instance_method.rb

@@ -41,3 +41,22 @@ class Module
   end
 
 end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+  end
+
+end
+=end
+

data/lib/quality_extensions/module/basename.rb

@@ -7,17 +7,16 @@
 # Changes::
 #++
 
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/core/module/basename'
-require 'facets/core/string/basename'
+require 'facets/module/basename'
 require 'quality_extensions/module/namespace'
 
 class Module
   # Gets the basename of a "module path" (the name of the module without any of the namespace modules that it is contained in), 
   # in the same sense that <tt>File.basename</tt> returns the basename of a _filesystem_ path.
   #
-  # This is identical to Facets' String#basename ('facets/core/string/basename') except that:
+  # This is identical to Facets' String#basename ('facets/string/basename') except that:
   # * it is a class method instead of an instance method of String,
   # * it accepts modules, strings, and symbols.
   #
@@ -30,10 +29,8 @@ class Module
     case module_or_name
       when Module
         module_or_name.basename
-      when Symbol
-        module_or_name.to_s.basename
-      when String
-        module_or_name.basename
+      when Symbol,String
+        module_or_name.to_s.gsub(/^.*::/, '')
       else
         raise ArgumentError
     end

data/lib/quality_extensions/module/bool_attr_accessor.rb

@@ -4,7 +4,7 @@
 # License::   Ruby License
 # Submit to Facets?:: Yes
 # Developer notes::
-# * Based on /usr/lib/ruby/gems/1.8/gems/facets-1.8.54/lib/facets/core/module/attr_tester.rb
+# * Based on /usr/lib/ruby/gems/1.8/gems/facets-1.8.54/lib/facets/module/attr_tester.rb
 # * Hey Thomas, don't you think Module#attr_tester should only create the read-only a? method and have another method that creates the writer (like there how we have attr_reader, _writer, and _accessor?) ? "tester" does not imply "setter" in my mind...
 # * I'm going to rename this one to bool_attr_accessor, which calls both bool_attr_reader and bool_attr_writer
 # * Then you also have the option to use bool_attr_reader and bool_attr_writer separately if you so desire.
@@ -12,6 +12,8 @@
 #   * Changed it so that if you call a!(false) it would actually set @a to false rather than leaving it unchanged. (I assume that was a bug.)
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
+
 # bool_attr_accessor
 
 class Module

data/lib/quality_extensions/module/by_name.rb

@@ -0,0 +1,76 @@
+#--
+# Author::    Gavin Sinclair
+# Copyright:: Copyright (c) Gavin Sinclair
+# License::   Ruby License
+# Submit to Facets?:: No. Copied from facets-1.8.54/lib/facets/core/module/by_name.rb. No longer exists in 2.4.1.
+# Developer notes::
+#++
+
+require 'rubygems'
+require 'facets/kernel/constant'
+
+class Module
+
+  # <em>Note: the following documentation uses "class" because it's more common, but it
+  # applies to modules as well.</em>
+  #
+  # Given the _name_ of a class, returns the class itself (i.e. instance of Class).  The
+  # dereferencing starts at Object.  That is,
+  #
+  #   Class.by_name("String")
+  #
+  # is equivalent to
+  #
+  #   Object.const_get("String")
+  #
+  # The parameter _name_ is expected to be a Symbol or String, or at least to respond to
+  # <tt>to_str</tt>.
+  #
+  # An ArgumentError is raised if _name_ does not correspond to an existing class.  If _name_
+  # is not even a valid class name, the error you'll get is not defined.
+  #
+  # Examples:
+  #
+  #   Class.by_name("String")             # -> String
+  #   Class.by_name("::String")           # -> String
+  #   Class.by_name("Process::Sys")       # -> Process::Sys
+  #   Class.by_name("GorillaZ")           # -> (ArgumentError)
+  #
+  #   Class.by_name("Enumerable")         # -> Enumerable
+  #   Module.by_name("Enumerable")        # -> Enumerable
+  #
+  #--
+  # Credit for this goes to Gavin Sinclair
+  #++
+  def by_name(name)
+    result = Object.constant(name)
+    return result if result.kind_of?( Module )
+    raise ArgumentError, "#{name} is not a module or class"
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    def test_by_name
+      c = ::Test::Unit::TestCase.name
+      assert_equal( ::Test::Unit::TestCase, Module.by_name(c) )
+      c = "Test::Unit::TestCase"
+      assert_equal( ::Test::Unit::TestCase, Class.by_name(c) )
+    end
+
+  end
+
+=end

data/lib/quality_extensions/module/class_methods.rb

@@ -6,6 +6,8 @@
 # Developer notes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
+
 class Object
 
   def class_methods(include_super = true)

data/lib/quality_extensions/module/create.rb

@@ -23,11 +23,12 @@
 #   * Added __FILE__, __LINE__ to class_eval so that error messages would be more helpful.
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/core/hash/assert_has_only_keys'
-require 'facets/core/hash/reverse_merge'
-require 'facets/core/kernel/constant'
-require 'facets/core/symbol/to_proc'
+require 'quality_extensions/hash/assert_has_only_keys'
+require 'facets/hash/reverse_merge'
+require 'facets/kernel/constant'
+require 'facets/ruby' # to_proc
 require 'quality_extensions/module/split'
 require 'quality_extensions/module/basename'
 require 'quality_extensions/module/dirname'
@@ -139,7 +140,7 @@ require 'rubygems'
 require 'quality_extensions/module/attribute_accessors'
 require 'quality_extensions/module/namespace'
 require 'quality_extensions/symbol/constantize'
-require 'facets/core/module/basename'
+require 'facets/module/basename'
 
 module Namespace
 end

data/lib/quality_extensions/module/guard_method.rb

@@ -11,9 +11,12 @@
 #   possible to make it thread-safe?
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
+puts '1'
 require 'quality_extensions/module/attribute_accessors'
-require 'facets/core/kernel/require_local'
+puts '2'
+require 'facets/kernel/load'
 require_local 'bool_attr_accessor'
 #require 'quality_extensions/module/bool_attr_accessor'
 require 'quality_extensions/symbol/match'

data/lib/quality_extensions/module/join.rb

@@ -7,9 +7,9 @@
 # Changes::
 #++
 
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/core/symbol/to_proc'
+require 'facets/ruby' # to_proc
 require 'quality_extensions/symbol/constantize'
 require 'quality_extensions/module/namespace'  # dirname
 require 'quality_extensions/module/basename'

data/lib/quality_extensions/module/malias_method_chain.rb

@@ -7,10 +7,11 @@
 # Changes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 gem 'facets'
-require 'facets/core/kernel/singleton_class'
-require 'quality_extensions/module/alias_method_chain'
+require 'facets/kernel/singleton_class'
+require 'facets/module/alias'
 
 class Module
 

data/lib/quality_extensions/module/namespace.rb

@@ -8,7 +8,7 @@
 # * 0.0.52: Renamed namespace to namespace_module to avoid conflicting with Facets' Module#namespace and Rake's namespace
 #++
 
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 require 'quality_extensions/symbol/constantize'
 require 'quality_extensions/module/split'

data/lib/quality_extensions/module/parents.rb

@@ -9,9 +9,9 @@
 # * Copied from ActiveSupport.
 #++
 
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/core/kernel/constant'
+require 'facets/kernel/constant'
 
 
 class Module

data/lib/quality_extensions/module/remove_const.rb

@@ -6,11 +6,12 @@
 # Developer notes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
 require 'quality_extensions/object/ignore_access'
 require 'quality_extensions/module/split'
-require 'facets/core/module/by_name'
-require 'facets/core/module/modspace'
+require 'facets/module/by_name'
+require 'facets/module/modspace'
 
 module Kernel
   # This is similar to +Kernel#remove_const+, but it _only_ works for modules/classes.

data/lib/quality_extensions/module/split.rb

@@ -6,8 +6,9 @@
 # Developer notes::
 #++
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..')
 require 'rubygems'
-require 'facets/core/symbol/to_proc'
+require 'facets/ruby' # to_proc
 
 class Module
   # Very similar to Facets' +Module#nesting+, but, whereas +nesting+ will break <tt>A::B</tt> into an array of _constants_ represting nesting

data/lib/quality_extensions/month.rb

@@ -46,6 +46,8 @@ end
 #   |_|\___||___/\__|
 #
 =begin test
+require 'test/unit'
+
 class TheTest < Test::Unit::TestCase
   def test_months_range
     range = Month.new(2006, 6)..Month.new(2006, 9)

data/lib/quality_extensions/mutex/if_available.rb

@@ -42,6 +42,8 @@ end
 #   |_|\___||___/\__|
 #
 =begin test
+require 'test/unit'
+
 class TheTest < Test::Unit::TestCase
   def setup
     @semaphore = Mutex.new

data/lib/quality_extensions/nil_method_missing.rb

@@ -0,0 +1,227 @@
+#--
+# Credits::
+# * Daniel Lucraft (http://www.daniellucraft.com/blog/2007/08/null-objects/) -- for the idea
+# * Tyler Rick -- Re-wrote it more simply so that the method_missing was in NilClass directly; packaged it, added some documention, and added some tests
+# Copyright:: Tyler Rick
+# License::   Ruby License
+# Submit to Facets?:: No
+# Developer notes::
+#++
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..')
+
+class NilClass
+  # This allows you to call undefined methods on nil without an exception being raised.
+  #
+  # This gives us a much conciser alternative to this common pattern:
+  #   might_be_nil ? might_be_nil.some_method : nil
+  # or
+  #   (might_be_nil && might_be_nil.some_method)
+  #
+  # ... where might_be_nil is something that you hope is not nil most of the time, but which may on accosion be nil (and when it is, you don't want an exception
+  # to be raised!).
+  #
+  # For example, accessing a key from a hash:
+  #   (hash[:a] && hash[:a][:b] && hash[:a][:b].some_method)
+  #
+  # With NilClass#method_missing, that simply becomes
+  #   hash[:a][:b].some_method)
+  #
+  # The caveat with this approach is that it requires changing the behavior of a core class, NilClass, which could potentially have undesirable effects on
+  # code that expects the original behavior. Don't require this file unless you are sure that you want *all* nils everywhere to have this behavior.
+  #
+  # For a safer alternative that doesn't require monkey-patching NilClass, consider using the _? method.
+  #
+  def method_missing(*args)
+    nil
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+
+  def test_simple__nil
+    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_chaining
+    hash = {}
+
+    assert_equal nil, hash[:a].length * 4
+    assert_equal nil, hash[:a][:b][:c]
+    assert_equal nil, hash[:a][:b][:c].some_method
+  end
+
+end
+=end
+
+
+# Alternative version #1:
+# (See note in safe_nil.rb -- this version fails the test_does_not_permanently_modify_nil_class test)
+=begin
+class NilClass
+  def __?
+    n = nil
+    def n.method_missing(*args)
+      __?
+    end
+    n
+  end
+end
+=end
+
+
+# Alternative version #2:
+# Another attempt, which doesn't require modifying NilClass ... but I found it didn't work as well as one might hope... :
+=begin
+# The __? method just returns the object itself for all objects except for nil. For nil, __? will return a special version of nil that lets you call undefined
+# methods.
+#
+# If you call an undefined method on nil._?, you will get back an instance of ChainableSafeNil -- 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:
+#   might_be_nil ? might_be_nil.some_method : nil
+# or
+#   (might_be_nil && might_be_nil.some_method)
+#
+# ... where might_be_nil is something that you hope is not nil most of the time, but which may on accosion be nil (and when it is, you don't want an exception
+# to be raised!).
+#
+# For example, accessing a key from a hash:
+#   (hash[:a] && hash[:a][:b] && hash[:a][:b].some_method)
+#
+# With __?, that simply becomes
+#   hash[:a].__?[:b].some_method)
+#
+# Unfortunately, this idea fails in two ways:
+# * nil.__?.whatever will return an instance of ChainableSafeNil, which means you may end up with ChainableSafeNil objects as values of variables and arguments
+#   in your code... which seems messy, undesirable, and undefined (Should ChainableSafeNil act like nil? Should it evaluate to false like nil does? Good luck
+#   with that...)
+# * If something evaluates to nil further on down the chain, after the __?, then all method calls to that nil will be unsafe. For example:
+#   hash = { :a => {} }
+#   hash[:a].__?[:b][:c]) => NoMethodError
+#
+# Conclusion: Chaining is impossible -- Just use _? on any object that might return nil (on which you want to call a method).
+
+
+require 'singleton'
+require 'rubygems'
+require 'facets/more/basicobject'
+
+
+class Object
+  def __?
+    self
+  end
+end
+
+class NilClass
+  def __?
+    ChainableSafeNil.instance
+  end
+end
+
+class ChainableSafeNil < BasicObject
+  include Singleton
+
+  def inspect
+    "ChainableSafeNil"
+  end
+
+  def method_missing(method, *args, &block)
+    #puts "nil.respond_to?(method)=#{nil.respond_to?(method)}"
+    return ChainableSafeNil.instance  unless nil.respond_to?(method)
+    nil.send(method, *args, &block) rescue ChainableSafeNil.instance
+  end
+
+  def ==(other)
+    #other.nil?
+    raise "Why on earth is this line never getting executed?? And yet if I remove this method entirely, equality breaks"
+  end
+
+  def nil?; true; end
+end
+
+
+
+
+
+class TheTest < Test::Unit::TestCase
+
+  def test_simple__nil
+    hash = {}
+    assert_equal ChainableSafeNil.instance, hash[:a].__?.length
+  end
+  def test_simple__normal_objects
+    hash = {:a => 'abc'}
+    assert_equal 3,        hash[:a].__?.length
+  end
+
+  def test_chaining
+    hash = {}
+
+    assert_raise(NoMethodError)           { hash[:a]    .length * 4          }
+    assert_raise(NoMethodError)           { hash[:a]    [:b][:c]             }
+    assert_raise(NoMethodError)           { hash[:a]    [:b][:c].some_method }
+
+    assert_equal ChainableSafeNil.instance, hash[:a].__?.length * 4
+    assert_equal ChainableSafeNil.instance, hash[:a].__?[:b][:c]
+    assert_equal ChainableSafeNil.instance, hash[:a].__?[:b][:c].some_method
+
+    # But it needs to be chainable even if the *receiver* of __? isn't nil but something *later* down the chain is nil...
+    # (in this example, hash[:a] isn't nil, but hash[:a][:b] is, making it unsafe to evaluate hash[:a][:b][:c])
+    hash = { :a => {} }
+    assert_raise(NoMethodError)           { hash[:a]    [:b]    [:c] }
+    # Unfortunately, I don't know any way to make that possible!!!
+    assert_raise(NoMethodError)           { hash[:a].__?[:b]    [:c] }
+    # So one is left with calling __? for *anything* that might be nil...
+    assert_equal ChainableSafeNil.instance, hash[:a].__?[:b].__?[:c]
+    # ... which is what we were trying to avoid having to do! This means __? is *not* chainable and we may as well use the plain old _? / SafeNil.
+    # We have failed as programmers and may as well go home in shame.
+  end
+
+
+  def test_inspect
+    assert_equal 'ChainableSafeNil', nil.__?.inspect
+  end
+
+  def test_nil?
+    assert ChainableSafeNil.instance.nil?
+  end
+
+  def test_equality
+    assert_equal ChainableSafeNil.instance, ChainableSafeNil.instance
+    assert       ChainableSafeNil.instance.eql?( nil.__?.length )
+    assert       ChainableSafeNil.instance == nil.__?.length
+
+    assert ChainableSafeNil.instance == nil
+    # But:
+    assert nil != ChainableSafeNil.instance
+
+    # Why isn't this true?? Which == is getting called here?
+    #assert ChainableSafeNil.instance.send(:==, ChainableSafeNil.instance)
+  end
+
+  def test_does_not_permanently_modify_nil_class
+    assert_raise(NoMethodError) { nil.foo }
+    nil.__?
+    assert_raise(NoMethodError) { nil.foo }
+  end
+end
+=end
+