quality_extensions 0.1.1

data/lib/qualitysmith_extensions/kernel/require_all.rb

@@ -0,0 +1,186 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+require 'rubygems'
+require 'facets/more/filelist'
+
+require 'facets/core/kernel/require_local'
+require_local '../file/exact_match_regexp'
+
+module Kernel
+
+  # <tt>require</tt>s all Ruby files specified by <tt>what</tt>, but not matching any of the exclude filters.
+  # * If <tt>what</tt> is a string, recursively <tt>require</tt>s all Ruby files in the directory named <tt>what</tt> or any of its subdirectories.
+  # * If <tt>what</tt> is a FileList, <tt>require</tt>s all Ruby files that match the <tt>what</tt> FileList.
+  #
+  # Options:
+  # <tt>:exclude</tt>:       An array of regular expressions or glob patterns that will be passed to FileList#exclude. If you specify this option, a file will not be included if it matches *any* of these patterns.
+  # <tt>:exclude_files</tt>: An array of filenames to exclude. These will be matched exactly, so if you tell it to exclude 'bar.rb', 'foobar.rb' will _not_ be excluded.
+  #
+  # Examples:
+  #   require_all 'lib/', :exclude => [/ignore/, /bogus/]   # will require 'lib/a.rb', 'lib/long/path/b.rb', but not 'lib/ignore/c.rb'
+  #   require_all File.dirname(__FILE__), :exclude_files => ['blow_up_stuff.rb']
+  def require_all(what, options = {})
+    files, exclusions = [nil]*2
+
+    case what
+      when String
+        base_dir = what
+        base_dir += '/' unless base_dir[-1].chr == '/'
+        files = FileList[base_dir + "**/*.rb"]
+      when FileList
+        files = what
+      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))
+
+    files.each do |filename|
+      # puts "requiring #{filename}" if filename =~ /test/
+      require filename
+    end
+  end
+
+  # <tt>require</tt>s all Ruby files in +dir+ (relative to <tt>File.dirname(__FILE__)</tt>) or any of its subdirectories.
+  #
+  # This is just a shortcut for this:
+  #   require_all File.join(File.dirname(__FILE__), dir)
+  #
+  # All of the +options+ available for +require_all+ are still available here.
+  #
+  def require_local_all(dir = './', options = {})
+    raise ArgumentError.new("dir must be a String") unless dir.is_a?(String)
+    local_dir = File.dirname( caller[0] )
+    require_all(
+      File.join(local_dir, dir),
+      options
+    )
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'tmpdir'
+require 'fileutils'
+require 'English'
+
+class TheTest < Test::Unit::TestCase
+  def setup
+    @base_dir = "#{Dir.tmpdir}/require_all_test"
+    @base_local_dir = File.dirname(__FILE__) # To allow testing of require_local_all. But tests should put everything in "#{@base_local_dir}/require_all_test" to avoid clutter or name conflicts with other files!
+    FileUtils.mkdir              @base_dir
+    @deep_dir = "really/really/deep/subdir"
+    $loaded = []
+
+  end
+  def teardown
+    FileUtils.rm_rf @base_dir
+    FileUtils.rm_rf "#{@base_local_dir}/require_all_test"
+  end
+
+
+  def test_repeat_requires
+    create_ruby_file 'moo.rb'
+
+    require_all File.dirname(@base_dir)
+    assert_equal ['moo.rb'], $loaded
+
+    require "#{@base_dir}/moo.rb"
+    assert_equal ['moo.rb'], $loaded
+
+    # Good! It refuses to load it again, even if we drop the ".rb" part!
+    require "#{@base_dir}/moo"
+    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
+  end
+
+  def test_deep_subdir
+    create_ruby_file 'flip.rb'
+    create_ruby_file @deep_dir + "/flop.rb"
+
+    require_all File.dirname(@base_dir)
+    assert_equal ['flip.rb', @deep_dir + "/flop.rb"], $loaded
+  end
+
+  def test_exclude_pattern
+    create_ruby_file 'require_me.rb'
+    create_ruby_file 'please_ignore_me.rb'
+
+    require_all File.dirname(@base_dir), :exclude => [/ignore/]
+    assert_equal ['require_me.rb'], $loaded
+  end
+
+  def test_require_local_all
+    create_ruby_file 'require_all_test/lib/require_me.rb', @base_local_dir
+    create_ruby_file 'require_all_test/lib/please_ignore_me.rb', @base_local_dir
+
+    require_local_all 'require_all_test/lib', :exclude => [/ignore/]
+    assert_equal ['require_all_test/lib/require_me.rb'], $loaded
+  end
+
+  def test_exclude_pattern_with_directory
+    create_ruby_file 'subdir/test/assert_even.rb'
+    create_ruby_file 'subdir/test/assert_odd.rb'
+
+    require_all File.dirname(@base_dir), :exclude => [/(^|\/)test/]
+    assert_equal [], $loaded
+  end
+
+  def test_passing_a_FileList
+    create_ruby_file 'subdir/junk/pretty_much_useless.rb'
+    create_ruby_file 'subdir/not_junk/good_stuff.rb'
+
+    require_all FileList[File.dirname(@base_dir) + "/**/*.rb"], :exclude => [/(^|\/)junk/]
+    assert_equal ['subdir/not_junk/good_stuff.rb'], $loaded
+  end
+
+  def test_exclude_filename
+    create_ruby_file 'yes.rb'
+    create_ruby_file 'all.rb'
+
+    # :todo: Interesting how none of these patterns work. I would have expected them to. Is there a bug in FileList? Find out...
+    #   /usr/lib/ruby/gems/1.8/gems/facets-1.8.51/lib/facets/more/filelist.rb
+    #require_all File.dirname(@base_dir), :exclude => ['all.rb']
+    #require_all File.dirname(@base_dir), :exclude => ['**/all']
+    #require_all File.dirname(@base_dir), :exclude => [/^all\.rb$/]
+    # This works, but it's too much to expect users to type out!:
+    #require_all File.dirname(@base_dir), :exclude => [/(\/|^)all\.rb$/]
+    
+    # So...... I added an :exclude_files option so that people wouldn't have to!
+    require_all File.dirname(@base_dir), :exclude_files => ['all.rb']
+
+    assert_equal ['yes.rb'], $loaded
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------------------
+  # Helpers
+
+  def create_ruby_file(file_name, base_dir = @base_dir)
+    # use dirname instead?
+    if file_name =~ /(.*)\//
+      FileUtils.mkdir_p base_dir + '/' + $1
+    end
+    path = base_dir + '/' + file_name
+    File.open(path, "w") {|f| f.puts "$loaded << '#{file_name}'"}
+  end
+
+end
+=end

data/lib/qualitysmith_extensions/kernel/require_local_all.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/kernel/require_all'
+

data/lib/qualitysmith_extensions/kernel/require_once.rb

@@ -0,0 +1,18 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No, not yet
+#++
+
+require 'rubygems'
+
+module Kernel
+  # Fixes bug in Ruby (1.8, at least -- not sure if 2.0 fixes it) where a file can be required twice if the path is spelled differently.
+  def require_once(name)
+    raise NotImplementedError
+    # store expand_path(name) in an array ($required_files or something)
+    # only do the require if it wasn't already in the array
+  end
+end
+

data/lib/qualitysmith_extensions/kernel/simulate_input.rb

@@ -0,0 +1,52 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes:
+#++
+
+require 'stringio'
+require 'rubygems'
+
+# Simulates a user typing in +input_string+ on the keyboard.
+#
+# Useful for testing console apps that are ordinarily (they prompt the user for input).
+#
+#   output = simulate_inpute('foo') do
+#     input = $stdin.gets
+#     capture_output { do_stuff() }
+#   end
+#
+def simulate_input(input_string, &block)
+
+  original_stdin = $stdin
+  $stdin = StringIO.new(input_string, 'r')
+
+  begin
+    yield
+  rescue Exception
+    raise
+  ensure
+    $stdin = original_stdin
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    input_received = nil
+    simulate_input('foo') { input_received = $stdin.getc.chr }
+    assert_equal 'f', input_received
+  end
+end
+=end

data/lib/qualitysmith_extensions/kernel/trap_chain.rb

@@ -0,0 +1,61 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+#++
+
+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.
+  # Similar to the way <tt>Kernel#at_exit()</tt> works, <tt>Kernel#trap_chain()</tt> will _prepend_ the given +block+ to the call chain for the given +signal_name+.
+  # When the signal occurs, your block will be executed first and then the previously registered handler will be invoked. This can be called repeatedly to create a "chain" of handlers.
+  def trap_chain(signal_name, *args, &block)
+    previous_interrupt_handler = trap(signal_name, *args) {}
+    trap(signal_name, *args) do
+      block.call
+      previous_interrupt_handler.call unless previous_interrupt_handler == "DEFAULT"
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'rubygems'
+require 'qualitysmith_extensions/kernel/capture_output'
+require 'fileutils'
+
+class TheTest < Test::Unit::TestCase
+  def setup
+    FileUtils.touch('trap_chain_test_output')
+  end
+  def teardown
+    FileUtils.remove_entry_secure 'trap_chain_test_output'
+  end
+
+  def test_1
+    output = capture_output do    # For some reason, this wasn't capturing the output from the child process when I did plain puts, so I changed it to write to a file instead...
+
+      pid = fork do
+        trap_chain("INT") { File.open('trap_chain_test_output', 'a') {|file| file.puts "Handler 1" } }
+        trap_chain("INT") { File.open('trap_chain_test_output', 'a') {|file| file.puts "Handler 2"; file.puts "Exiting..."; }; exit }
+        trap_chain("INT") { File.open('trap_chain_test_output', 'a') {|file| file.puts "Handler 3" } }
+        puts 'Hello world'
+        sleep 5
+      end
+      Process.kill "INT", pid
+      Process.wait
+
+    end
+
+    assert_equal "Handler 3\nHandler 2\nExiting...\n", File.read('trap_chain_test_output')
+  end
+
+end
+=end
+

data/lib/qualitysmith_extensions/kernel/windows_platform.rb

@@ -0,0 +1,46 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# Changes::
+#++
+
+
+module Kernel
+  def windows_platform?
+    RUBY_PLATFORM =~ /mswin32/
+    
+    # What about mingw32 or cygwin32?
+    #RUBY_PLATFORM =~ /(win|w)32$/
+     
+    # What about 64-bit Windows?
+  end
+end
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    # Impossible to test, unless your platform is Windows.
+    assert true
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/module/alias_method.rb

@@ -0,0 +1,6 @@
+# Idea:
+#   Allow using hashes:
+#     alias_method :code_review => :view_commits 
+#     instead of 
+#     alias_method :code_review, :view_commits
+#   because I always forget which argument becomes the argument for which

data/lib/qualitysmith_extensions/module/alias_method_chain.rb

@@ -0,0 +1,165 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 the Rails people; QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+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'
+
+
+# /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)
+    # 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
+    target_without_feature = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    #puts "#{target} is #{method_defined?(target)}"
+    alias_method_chain_without_prevent_repeat_aliasing(target, feature, &block) unless method_defined?(target_without_feature)
+  end
+  alias_method_chain :alias_method_chain, :prevent_repeat_aliasing
+
+  # If you pass <tt>:create_target => true</tt> as one of the +options+:
+  # * Guarantees that <tt>alias_method_chain target, feature</tt> will work even if the target method has not been defined yet.
+  #   If the target method doesn't exist yet, an empty (no-op) target method will be created.
+  # * This could come in handy for callback methods (method_added, method_missing, etc.), for instane, when you don't know if that
+  #   particular callback method has been defined or not.
+  # * You want your alias_method_chain to wrap the existing method if there *is* an existing method, but to <b>not break</b> in 
+  #   the case that the method _doesn't_ exist.
+  def alias_method_chain_with_target_need_not_exist(target, feature, options = {}, &block)
+    create_target = options.delete(:create_target)
+    
+    if create_target && true #!self.methods.include?(target)
+      self.send :define_method, target do |*args|
+        # Intentionally empty
+      end
+    end
+
+    alias_method_chain_without_target_need_not_exist(target, feature, &block)
+  end
+  alias_method_chain :alias_method_chain, :target_need_not_exist
+end
+
+
+
+=begin test
+require 'test/unit'
+
+class Test_alias_method_chain_basic < Test::Unit::TestCase
+
+  class X
+    def foo?
+      'foo?'
+    end
+    def foo_with_feature?
+      foo_without_feature? + '_with_feature'
+    end
+  end
+
+  def test_question_mark
+    name, punctuation = nil, nil
+    X.instance_eval do
+      alias_method_chain :foo?, :feature do |a, b|
+        name, punctuation = a, b
+      end
+    end
+
+    assert_equal 'foo?_with_feature', X.new.foo?
+    assert_equal 'foo', name
+    assert_equal '?', punctuation
+  end
+
+  class Y
+    def foo!
+      'foo!'
+    end
+    def foo_with_feature!
+      foo_without_feature! + '_with_feature'
+    end
+  end
+
+  def test_exclamation_mark
+    name, punctuation = nil, nil
+    Y.instance_eval do
+      alias_method_chain :foo!, :feature do |a, b|
+        name, punctuation = a, b
+      end
+    end
+
+    assert_equal 'foo!_with_feature', Y.new.foo!
+    assert_equal 'foo', name
+    assert_equal '!', punctuation
+  end
+
+end
+
+class Test_alias_method_chain_with_prevent_repeat_aliasing < Test::Unit::TestCase
+
+  class X
+    def foo
+      'foo'
+    end
+    def foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    alias_method_chain :foo, :feature
+    alias_method_chain :foo, :feature   # We want to test that this won't cause an infinite recursion (stack overflow).
+  end
+
+  def test_1
+    assert_equal 'foo_with_feature', X.new.foo
+  end
+
+end
+
+
+class Test_alias_method_chain_with_target_need_not_exist < Test::Unit::TestCase
+
+  # Let's assume that we are *re*-opening X here, and at this point we *don't know* if it has a foo method or not.
+  # Also, we *don't want to care*. We just want to add to the chain if the method exists, or *create* the chain
+  # if it does not yet.
+  class X
+    def foo_with_feature
+      # *Don't* do this if you're using :create_target => true:
+      #   foo_without_feature + '_with_feature'
+      # If you're using :create_target => true, then you are pretty much saying "I don't know anything about thhe target method".
+      # Yet the previous statement shows that you expect it to return a String. You can't do that. You can't pretend to know
+      # anything about it's return value. It will always be nil if alias_method_chain created an empty method for you.
+      # But, it may be something else if it already existed and alias_method_chain did *not* create an empty method for you.
+
+      # The safest thing to do is to just call it and pay not attention to its return value. (Or at least *consider* the
+      # possibility that it may be nil.)
+
+      foo_without_feature
+      'feature was successfully added'
+    end
+    alias_method_chain :foo, :feature, :create_target => true
+  end
+
+  def test_1
+    assert_equal 'feature was successfully added', X.new.foo
+    assert_equal 'feature was successfully added', X.new.foo { 'test that it works with a block' }
+  end
+end
+=end