quality_extensions 0.1.1

data/lib/qualitysmith_extensions/kernel/example_printer.rb

@@ -0,0 +1,81 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# * Can anyone think of a better name than put_statement?
+#   * Something more like xmp? sp? stp? xm? putst? -- Too cryptic?
+#   * verbose? -- too ambiguous (that could be the name for xmp, for example)
+# * xmp: Do the set_trace_func trick that irb_xmp/of_caller both use... so that the user doesn't have to pass in the local binding manually...
+# * Add class method for ExamplePrinter to set a template for use by xmp? So if you don't like the default ("=> #{result}"), you can specify your own...
+#++
+
+require 'rubygems'
+#require 'facets/core/binding/self/of_caller'
+
+# This was written because the irb/xmp that was already available seemed to be
+# needlessly complex and needlessly dependent upon "irb" stuff. This
+# alternative is dirt simple, and it still works.
+module ExamplePrinter
+  # Prints the given statement (+code+ -- a string) before evaluating it.
+  # Same as xmp only it doesn't print the return value.
+  #
+  #   o = nil
+  #   xmp 'o = C.new', binding
+  #   # => o = C.new
+  def put_statement(code, binding = nil, file = __FILE__, line = __LINE__)
+#    # This didn't work. Still got this error: undefined local variable or method `x' for #<TheTest:0xb7dbc358> (NameError)
+#    Binding.of_caller do |caller_binding|
+#      #puts caller_binding
+#      puts code
+#      eval code, caller_binding
+#    end
+    puts code
+    eval code, binding, file, line
+  end
+  alias_method :stp, :put_statement
+
+  # Prints the given statement (+code+ -- a string) before evaluating it. Then prints its return value.
+  # Pretty much compatible with irb/xmp. But you have currently have to pass
+  # in the binding manually if you have any local variables/methods that xmp
+  # should have access to.
+  def xmp(code, binding = nil)
+    result = put_statement(code, binding)
+    puts "=> #{result}"
+  end
+end
+
+include ExamplePrinter
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'rubygems'
+gem     'qualitysmith_extensions'
+require 'qualitysmith_extensions/kernel/capture_output'
+require 'facets/core/string/margin'
+
+class TheTest < Test::Unit::TestCase
+  def test_puts_statement
+    result = nil
+    x = 1
+    output = capture_output { result = put_statement("3 + x", binding) }
+    assert_equal 4, result
+    assert_equal "3 + x", output.chomp
+  end
+  def test_xmp
+    x = 1
+    output = capture_output { xmp("3 + x", binding) }
+    assert_equal <<-End.margin, output.chomp
+      |3 + x
+      |=> 4
+    End
+  end
+end
+=end

data/lib/qualitysmith_extensions/kernel/filter_output.rb

@@ -0,0 +1,108 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes:
+#++
+
+require 'stringio'
+
+# Applies +filter+ to any $stderr output that +block+ tries to generate.
+#
+# +filter+ should be a Proc that accepts +attempted_output+ as its parameter and returns the string that should _actually_ be output.
+#
+#   filter_stderr(lambda{''}) do
+#     noisy_command
+#   end
+def filter_stderr(filter, &block)
+  old_stderr = $stderr
+  $stderr = StringIO.new
+  begin
+    yield
+  ensure
+    what_they_tried_to_output = $stderr.string
+    $stderr = old_stderr
+    $stderr.print filter.call(what_they_tried_to_output)
+  end
+end
+def filter_stdout(filter, &block)
+  old_stderr = $stdout
+  $stdout = StringIO.new
+  begin
+    yield
+  ensure
+    what_they_tried_to_output = $stdout.string
+    $stdout = old_stderr
+    $stdout.print filter.call(what_they_tried_to_output)
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+# Not sure whether it's better to duplicate for increased readability here or metaprogram for decreased duplication...
+
+# Duplicate for increased readability:
+  def noisy_command
+    $stderr.puts "Some annoying error message"
+    $stderr.puts "Some error message that we actually care to see"
+  end
+  class TheTest < Test::Unit::TestCase
+    def setup
+      $stderr = StringIO.new
+    end
+    def test_simple_filter
+      filter_stderr(lambda{|input| ''}) do
+        noisy_command
+      end
+      assert_equal '', $stderr.string
+    end
+    def test_sub_filter
+      filter_stderr(Proc.new { |attempted_output|
+          attempted_output.sub(/^Some annoying error message\n/, '')
+        }
+      ) do
+        noisy_command
+      end
+      assert_equal "Some error message that we actually care to see\n", $stderr.string
+    end
+  end
+
+# Metaprogram for decreased duplication...
+  ['stdout', 'stderr'].each do |stream_name|
+    eval <<-End, binding, __FILE__, __LINE__+1
+    def noisy_command_#{stream_name}
+      $#{stream_name}.puts "Some annoying error message"
+      $#{stream_name}.puts "Some error message that we actually care to see"
+    end
+
+    class TheTest#{stream_name} < Test::Unit::TestCase
+      def setup
+        $#{stream_name} = StringIO.new
+      end
+      def test_simple_filter
+        filter_#{stream_name}(lambda{|input| ''}) do
+          noisy_command_#{stream_name}
+        end
+        assert_equal '', $#{stream_name}.string
+      end
+      def test_sub_filter
+        filter_#{stream_name}(Proc.new { |attempted_output|
+            attempted_output.sub(/^Some annoying error message\n/, '')
+          }
+        ) do
+          noisy_command_#{stream_name}
+        end
+        assert_equal "Some error message that we actually care to see\n", $#{stream_name}.string
+      end
+    end
+    End
+  end
+=end

data/lib/qualitysmith_extensions/kernel/remove_const.rb

@@ -0,0 +1,178 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+# Developer notes::
+#++
+
+require 'rubygems'
+require 'qualitysmith_extensions/object/ignore_access'
+require 'qualitysmith_extensions/module/split'
+require 'facets/core/module/by_name'
+require 'facets/core/module/modspace'
+
+class Module
+  alias_method :remove_const_before_was_added_to_Kernel, :remove_const
+end
+module Kernel
+  # This is similar to the built-in <tt>Module#remove_const</tt>, but it is accessible from all "levels" (because it is defined
+  # in +Kernel+) and can handle hierarchy.
+  #
+  # Makes it possible to write simply:
+  #   remove_const(A::B::C.name)
+  # rather than having to think about which module the constant is actually defined in and calling +remove_const+ on that module.
+  #
+  # This is how you would otherwise have to do it:
+  #   A::B.send(:remove_const, :C)
+  #
+  # +const_name+ must be an object that responds to +to_s+.
+  #
+  # +const_name+ must be a <i>fully qualified name</i>. For example, this will not work as expected:
+  #
+  #   module Mod
+  #     Foo = 'foo'
+  #     remove_const(:Foo)
+  #   end
+  #
+  # because it will try to remove ::Foo instead of Mod::Foo. Fortunately, however, this will work as expected:
+  #
+  #   module Mod
+  #     Foo = 'foo'
+  #     remove_const(Foo.name)
+  #   end
+  #
+  # This method is partially inspired by Facets' Kernel#constant method, which provided a more user-friendly alternative to const_get.
+  #
+  def remove_const(const_name)
+    #require 'pp'
+    #puts "remove_const(#{const_name})"
+    raise ArgumentError unless const_name.respond_to?(:to_s)
+    nesting = const_name.to_s.split(/::/).map(&:to_sym)
+    if nesting.size > 1
+      parent_module = constant(nesting[0..-2].join('::')) # For example, would be A::B for A::B::C
+      const_to_remove = nesting[-1]                       # For example, would be :C   for A::B::C
+      parent_module.ignore_access.remove_const_before_was_added_to_Kernel(const_to_remove)
+    else
+      ignore_access.remove_const_before_was_added_to_Kernel(const_name)
+    end
+  end
+end
+
+#p Module.private_instance_methods.grep(/remove_const/) # Lists it
+Module.send(:remove_method, :remove_const)
+#p Module.instance_methods.grep(/remove_const/)         # Does list it, because inherits *public* remove_const from Kernel
+#p Module.private_instance_methods.grep(/remove_const/) # Does not list it, because it's no longer private
+Module.send(:define_method, :remove_const, Kernel.method(:remove_const))
+#p Module.private_instance_methods.grep(/remove_const/) # Lists it
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+# Important regression test. This was failing at one point.
+module A
+  B = nil
+  remove_const :B
+end
+
+# How it would be done *without* this extension:
+module TestRemoveABC_TheOldWay
+  module A
+    module B
+      C = 'foo'
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      A::B.send(:remove_const, :C)
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+# How it would be done *with* this extension (all tests that follow):
+
+module TestRemoveABC_CIsString
+  module A
+    module B
+      C = 'foo'
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      assert_raise(NoMethodError) { remove_const(A::B::C.name) } # Because C is a *string*, not a *module*
+      assert_nothing_raised   { remove_const A::B.name + '::C' }
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+module TestRemoveAB_UsingName
+  module A
+    module B
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      remove_const(A::B.name)
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol
+  module A
+    module B
+      Foo = :Foo
+    end
+  end
+
+  remove_const(:'A::B::Foo')      # This tests that Module#remove_const was overriden as well.
+                                  # If we hadn't also overriden Module#remove_const, then this would have caused this error:
+                                  #   in `remove_const': `A::B::Foo' is not allowed as a constant name (NameError)
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+
+      assert_equal 'TestRemoveAB_Symbol::A', A.name
+      assert_raise(NameError) { remove_const(:'A::B') }   # This doesn't work because A, when evaluated in this context, 
+                                                          # is TestRemoveAB_Symbol::TheTest::A, which is *not* defined.
+ 
+      remove_const(:'TestRemoveAB_Symbol::A::B')
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol2
+  class TheTest < Test::Unit::TestCase
+    module A
+      module B
+      end
+    end
+    def test_1
+      assert_nothing_raised   { A::B }
+
+      assert_equal 'TestRemoveAB_Symbol2::TheTest::A', A.name
+      remove_const(:'A::B')        # Does work, because A is defined *within* TheTest this time.
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+=end
+
+

data/lib/qualitysmith_extensions/kernel/remove_module.rb

@@ -0,0 +1,127 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No.
+# Developer notes::
+# * Deprecated by qualitysmith_extensions/module/remove.rb
+#++
+
+require 'rubygems'
+require 'qualitysmith_extensions/object/ignore_access'
+require 'qualitysmith_extensions/module/split'
+require 'facets/core/module/by_name'
+require 'facets/core/module/modspace'
+
+module Kernel
+  # This is similar to +remove_const+, but it _only_ works for modules/classes.
+  #
+  # This is similar to the built-in <tt>Module#remove_module</tt>, but it is accessible from all "levels" (because it is defined
+  # in +Kernel+) and can handle hierarchy.
+  #
+  # Makes it possible to write simply:
+  #   remove_module(A::B::C)
+  # rather than having to think about which module the constant is actually defined in and calling +remove_const+ on that module.
+  # This is how you would have to otherwise do it:
+  #   A::B.send(:remove_const, :C)
+  #
+  # You can pass in either a constant or a symbol. Passing in a constant is preferred
+  #
+  # This method is partially inspired by Facets' Kernel#constant method, which provided a more user-friendly alternative to const_get.
+  #
+  def remove_module(const)
+    const = Module.by_name(const.to_s) if const.is_a?(Symbol)
+    if const.split.size > 1
+      parent_module = const.modspace      # For example, would be A::B for A::B::C
+      const_to_remove = const.split.last  # For example, would be :C   for A::B::C
+      parent_module.ignore_access.remove_const(const_to_remove)
+    else
+      Object.ignore_access.remove_const(const.name)
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'qualitysmith_extensions/kernel/remove_const'     # Test for compatibility. Just in case the remove_const_before_was_added_to_Kernel alias might have thrown something off.
+
+# How it would be done *without* this extension:
+module TestRemoveABC_TheOldWay
+  module A
+    module B
+      class C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      A::B.send(:remove_const, :C)
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+# How it would be done *with* this extension:
+module TestRemoveABC
+  module A
+    module B
+      class C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B::C }
+      remove_module(A::B::C)
+      assert_raise(NameError) { A::B::C }
+    end
+  end
+end
+
+module TestRemoveAB
+  module A
+    module B
+      module C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      remove_module(A::B)
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+module TestRemoveAB_Symbol
+  module A
+    module B
+      module C
+      end
+    end
+  end
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+      assert_nothing_raised   { A::B }
+      assert_raise(NameError) { remove_module(:'A::B') }   # This is why passing in the module itself is preferred.
+      remove_module(:'TestRemoveAB_Symbol::A::B')
+      assert_raise(NameError) { A::B }
+    end
+  end
+end
+
+=end
+
+