quality_extensions 0.1.1

data/lib/qualitysmith_extensions/object/default.rb

@@ -0,0 +1,69 @@
+# Rationale:
+# The ||= "operator" is often used to set a default value.
+#   var ||= 'default'
+# Unfortunately, it does not give the desired behavior for when you want to give a default value to a *boolean* (which might have been already initialized to false).
+# When setting a variable to a default value, we actually only want to set it to the default if it's currently set to *nil*!
+# This was an attempt to supply that missing method...
+
+module Kernel
+  def default!(object, default_value)
+    case object
+    when NilClass
+      #object.become default_value
+      #object.replace default_value
+    else
+    end
+  end
+
+end
+
+
+class NilClass
+  def default!(default_value)
+    #self.become default_value
+    #self.replace default_value
+    #self = default_value
+
+    # Not sure how to implemnet this! ... without writing/using a C extension that lets me turn a NilClass object into another object.
+  end
+end
+class Object
+  def default!(default_value)
+    # This should have no effect on any objects other than instances of NilClass.
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class Foo
+  def do_it(options = {})
+    options[:how_many_times] ||= 3
+    #options[:actually_do_it]  ||= true     # Doesn't work! What if they explicitly set it to false? We would unconditionally be overriding it with true. We only want to set it to true if it's "not set yet" (if it's nil).
+    options[:actually_do_it].default! true  # This is how I'd like to do it. It makes it clear what we're doing (setting a default value).
+    options[:actually_do_it] = true if options[:actually_do_it].nil?   # This works, but you have to duplicate the variable name in two places. Plus it's not explicitly clear that true is being used as a *default* value.
+
+    options[:actually_do_it] ? "We did it #{options[:how_many_times]} times" : "We didn't actually do it"
+  end
+end
+
+class TheTest < Test::Unit::TestCase
+  def test_false
+    assert_equal "We didn't actually do it", Foo.new.do_it(:actually_do_it => false)
+  end
+  def test_true
+    assert_equal "We did it 3 times", Foo.new.do_it()
+  end
+
+end
+=end
+

data/lib/qualitysmith_extensions/object/if_else.rb

@@ -0,0 +1,157 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+
+class Object
+  # Returns +self+ if +condition+; otherwise, returns +else_value+.
+  #
+  # Example:
+  #   "Average: #{array.average}". if_else array.size >= 3, ''
+  # That is another way to say this:
+  #   array.size >= 3 ? "Average: #{array.average}" : '' )
+  #
+  # Sometimes you want to do 'something unless condition' and you want that whole expression to return '' (or some other value)
+  # if the condition is false, rather than nil, which is what it currently returns.
+  #
+  # *Important*: "+self+" will always be "evaluated". So if the receiver of this message is some _dangerous_ call (has side 
+  # effects), then you would be advised to use the normal if/then/else or ?/: constructs instead.
+  #
+  # For example, +method_with_adverse_side_effects+ will be called unconditionally in this case (whether or not +ready?+ returns +false+):
+  #   obj.method_with_adverse_side_effects.   if_else ready?, NotReady
+  # But it will not be called in this case if +ready?+ returns +false+:
+  #   ready? ? obj.method_with_adverse_side_effects : NotReady)
+  #
+  # "Isn't this method useless?" ... Yes, basically. Its main advantage is that it lets you put the condition _after_ the normal
+  # value, which may make it easier to follow the normal execution flow when reading the source.
+  #
+  # This is similar to something I saw in another language (Python?) where a similar syntax is built right into the language. Something like this:
+  #   normal_value if condition else else_value
+  #
+  # I thought that was a neat idea so I implemented it as best I could in Ruby.
+  #
+  # This might also be interesting for folks coming from Smalltalk, where +if+ really _is_ just a message that you pass to an
+  # object along with a block (?) to be executed if +condition+ is +true+ and a block to be executed if +condition+ is +false+.
+  #
+  def if(condition, else_value = nil)
+    condition ?
+      self :
+      else_value
+  end
+  alias_method :if_else, :if
+
+  def unless(condition, else_value)
+    !condition ?
+      self :
+      else_value
+  end
+  alias_method :unless_else, :unless
+end
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+require 'rubygems'
+require 'qualitysmith_extensions/array/average'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    array = [1, 2]
+    assert_equal 'not enough values', average(array)
+    assert_equal 'not enough values', average_the_normal_way(array)
+
+    array = [1, 2, 3]
+    assert_equal 'average = 2.0', average(array)
+    assert_equal 'average = 2.0', average_the_normal_way(array)
+  end
+
+  # This way is actually easier to read, so you'd be pretty silly to use if_else in this case!
+  def average_the_normal_way(array)
+    array.size >= 3 ?
+      "average = #{array.average}" :
+      'not enough values'
+  end
+
+  def average(array)
+    "average = #{array.average}".if_else( array.size >= 3, 'not enough values' )
+  end
+
+
+
+
+
+  def test_2
+    # Sometimes you want to do 'something unless condition' and you want that whole expression to return '' (or some other value)
+    # if the condition is false, rather than nil, which is what it currently returns.
+    assert_equal nil, render_list_the_naive_way([])
+    assert_equal '',  render_list_the_long_way([])
+    assert_equal '',  render_list([])
+
+    list = ['Alice', 'Malory']
+
+    [
+      render_list_the_naive_way(list),
+      render_list_the_long_way(list),
+      render_list(list),
+    ].each {|a|
+      assert_equal '<ul><li>Alice</li><li>Malory</li></ul>', a
+    }
+
+  end
+
+  def render_list_the_naive_way(list)
+    content_tag(:ul,
+      list.map { |item|
+        content_tag(:li,
+          item
+        )
+      }
+    ) unless list.empty?
+  end
+  def render_list_the_long_way(list)
+    unless list.empty?
+      content_tag(:ul,
+        list.map { |item|
+          content_tag(:li,
+            item
+          )
+        }
+      )
+    else
+      ''
+    end
+  end
+  def render_list(list)
+    content_tag(:ul,
+      list.map { |item|
+        content_tag(:li,
+          item
+        )
+      }
+    ).   unless_else list.empty?, ''
+  end
+
+  def content_tag(tag, contents)
+    "<#{tag}>#{contents}</#{tag}>"
+  end
+end
+=end
+
+

data/lib/qualitysmith_extensions/object/ignore_access.rb

@@ -0,0 +1,84 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+# Developer notes:
+# * Come up with a shorter/better name than ignore_access?
+# * Other name ideas:
+#   * ignore_private
+#   * access_everything
+#   * access
+#   * sneaky
+#   * rude
+#   * all_public
+#   * public!
+#   * all (like rdoc's --all -- it's too generic for a method name though)
+#   * promiscuous (like rdoc's --promiscuous -- different semantics though)
+#++
+
+require 'rubygems'
+require 'facets/more/functor'
+
+class Object
+
+  # Sends all messages to receiver, bypassing access restrictions, allowing you to call private methods (like class_variable_get) without having to write ugly send() calls.
+  #
+  #   o.class.ignore_access.class_variable_set(:@@v, 'new value')
+  # is equivalent to:
+  #   o.class.send(:class_variable_set, :@@v, 'new value')
+  #
+  # If you tried to just call the method directly, like this:
+  #   o.class.class_variable_set(:@@v, 'new value')
+  # you would get a NoMethodError:
+  #   NoMethodError: private method `class_variable_set' called for Klass:Class
+  #
+  def ignore_access
+    @_ignore_access_functor ||= Functor.new do |op,*args|
+      self.send(op,*args)
+    end
+  end
+  alias_method :access, :ignore_access
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+
+  # It's not identical to Kernel#meta, as this test proves! (Must run it singly, without other tests.)
+#  def test_meta
+#    require 'rubygems'; require 'facets/core/kernel/meta'
+#    o = Object.new
+#    o.class.meta.class_variable_set(:@@v, 'old value')
+#    assert_equal 'old value', o.class.meta.class_variable_get(:@@v)
+#
+#    #assert_nothing_raised { o.class.send(:class_variable_get, :@@v) }    # Fails!
+#
+#    assert_equal Object, o.class
+#    o.class.send(:class_variable_set, :@@v, 'new value')
+#    assert_equal 'new value', o.class.send(:class_variable_get, :@@v)
+#    assert_equal 'new value', o.class.meta.class_variable_get(:@@v)       # Fails! Still has 'old value'!
+#  end
+
+  def test_1
+    o = Object.new
+    o.class.ignore_access.class_variable_set(:@@v, 'old value')
+    assert_nothing_raised { o.class.send(:class_variable_get, :@@v) }
+    o.class.send(:class_variable_set, :@@v, 'new value')
+    assert_equal 'new value', o.class.ignore_access.class_variable_get(:@@v)
+    assert_equal 'new value', o.class.send(:class_variable_get, :@@v) 
+  end
+
+end
+
+=end
+

data/lib/qualitysmith_extensions/object/mcall.rb

@@ -0,0 +1,92 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Maybe.
+# Developer notes::
+#++
+
+class Object
+  # Calls the method implementation from the module of your choice (+moduule+) on the object of your choice (+self+).
+  #
+  # The only (huge) catch is that +self+ must either be an instance of +moduule+ or have +moduule+ as an ancestor... which severely limits its usefullness. (Compare with singleton_send.)
+  #
+  # It is still useful, though, if you want to call some "original" implementation provided by Kernel (or some other base module) and the people that overrode it didn't play nice and use +alias_method_chain+.
+  #
+  # No matter! If the class of the object you are calling this on has Kernel as an ancestor, then you can call any method from Kernel on this object!
+  #
+  # This implementation is gratefully owed to the folks who wrote PP (/usr/lib/ruby/1.8/pp.rb)
+  def mcall(moduule, message, *args, &block)
+    moduule.instance_method(message).bind(self).call(*args, &block)
+  end
+  alias_method :msend, :mcall
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'rubygems'
+require 'qualitysmith_extensions/test/assert_exception'
+require 'qualitysmith_extensions/test/assert_includes'
+require 'facets/core/module/alias_method_chain'
+
+
+module MyColorizer
+  def colorize(color = nil)
+    self + " (colorized in #{color})"
+  end
+end
+class String
+  def class()
+    'classy'
+  end
+end
+
+class TheTest < Test::Unit::TestCase
+  def test_doesnt_work_like_singleton_send
+    # This doesn't quite work the same as singleton_send ...
+    assert_exception(TypeError, lambda { |exception|
+      assert_equal 'bind argument must be an instance of MyColorizer', exception.message
+    }) do
+      "whatever".mcall(MyColorizer, :colorize, :blue)
+    end
+    # self actually has to *be* a MyColorizer for this to work... which severely limits the usefulness of mcall...
+    # Since the whole reason we want this is because we don't want to simply mix in MyColorizer into the base class...
+  end
+
+  module ClassSystem
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :class, :class_system
+      end
+    end
+    def class_with_class_system()
+      1<2 ? 'lower' : 'middle'
+    end
+  end
+
+  def test_1
+    assert_equal "classy", "me".class
+    # The main use for this would be to call "original" implementations provided by Kernel or some other base module that you can be pretty sure is an ancestor of self...
+    assert_contains String.ancestors, Kernel
+    assert_equal String,  "me".mcall(Kernel, :class)
+  end
+
+  def test_2_after_doing_alias_method_chain
+    String.class_eval do
+      #remove_method :to_s
+      include ClassSystem
+    end
+    assert_equal "lower",  "me".class                       # Version 3
+    assert_equal "classy", "me".class_without_class_system  # Version 2
+    assert_equal String,   "me".mcall(Kernel, :class)       # Version 1
+  end
+
+end
+=end
+

data/lib/qualitysmith_extensions/object/methods.rb

@@ -0,0 +1,63 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes. Actually, Facets already has one, which takes a symbol (:inherited, :local, :public, etc.). Possibly merge with that one. Accept symbol *or* boolean as arg?
+# Developer notes::
+#++
+
+require 'rubygems'
+require 'facets/core/module/alias_method_chain'
+require 'facets/core/symbol/to_proc'
+
+class Object
+
+  # Ruby's built-in Object#methods says:
+  #   Returns a list of the names of methods publicly accessible in obj. This will include all the methods accessible in obj's ancestors.
+  #
+  # But sometimes you don't _want_ all of obj's ancestors!
+  #
+  # This <tt>Object#methods</tt> adds the following features to the built-in <tt>Object#methods</tt>:
+  # * Provides the same +include_super+ option that Module#instance_methods has (Backwards compatible, because default is +true+)
+  # * Returns an array of symbols rather than strings (Not backwards compatible)
+  # * Sorts the array for you so you don't have to! (Not backwards compatible)
+  def methods_with_sorting_and_include_super(include_super = true)
+    if include_super
+      methods_without_sorting_and_include_super
+    else
+      (methods_without_sorting_and_include_super - Object.methods_without_sorting_and_include_super)
+    end.sort.map(&:to_sym)
+  end
+  alias_method_chain :methods, :sorting_and_include_super
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_equal [:[]], Array.methods(false)
+    assert       Array.methods.size > Array.methods(false).size
+
+    assert       !Object.methods(true).include?(:[])
+    assert        Array. methods(true).include?(:[])
+  end
+end
+=end
+
+# Old idea:
+#
+# class Object
+#   def own_methods  # (or Object#my_methods)
+#     ((methods - Object.methods).sort)
+#       # Could just use self.class.instance_methods(false) but what if we also want class/module methods to be included?
+#   end
+# end