facets 1.7.46 → 1.8.0

data/lib/facets/core/kernel/silence_stream.rb

@@ -0,0 +1,22 @@
+# CREDIT David Heinemeier Hansson
+
+module Kernel
+
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+end

data/lib/facets/core/kernel/singleton.rb

@@ -2,14 +2,13 @@
 module Kernel
 
   # Access to an object's "special" class, otherwise
-  # known as it's eigenclass or metaclass or own, etc.
+  # known as it's eigenclass or metaclass, etc.
   #
   # One day these names must be reconciled!
 
   def singleton
     (class << self; self; end)
   end
-  alias_method :__singleton__, :singleton
 
 end
 

data/lib/facets/core/kernel/{superior.rb → super_at.rb}

@@ -17,7 +17,7 @@ class Object
   #
   #   C.new.x  #=> 1
   #
-  def superior(klass=self.class.superclass, *args, &blk)
+  def super_at(klass=self.class.superclass, *args, &blk)
     unless self.class.ancestors.include?(klass)
       raise ArgumentError
     end
@@ -25,6 +25,9 @@ class Object
     klass.instance_method(called).bind(self).call(*args,&blk)
   end
 
+  # TODO DEPRECATE
+  alias superior super_at
+
 end
 
 

data/lib/facets/core/kernel/supermethod.rb

@@ -10,7 +10,7 @@ module Kernel
     klass.instance_method(meth).bind(self)
   end
 
-  # deprecated
+  # Deprecate?
   alias_method :super_method, :supermethod
 
 end

data/lib/facets/core/kernel/supress.rb

@@ -0,0 +1,15 @@
+# CREDIT David Heinemeier Hansson
+
+module Kernel
+
+  # Supress errors while executing a block,
+  # with execptions.
+
+  def suppress(*exception_classes)
+    begin yield
+    rescue Exception => e
+      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
+    end
+  end
+
+end

data/lib/facets/core/kernel/with.rb

@@ -0,0 +1,57 @@
+#--
+# CREDIT Mikael Brockman
+#++
+
+module Kernel
+
+  # A Ruby-ized realization of the K combinator.
+  #
+  #   with Book.new do |book|
+  #     book.title = "Imperium"
+  #     book.author = "Ulick Varange"
+  #   end
+  #
+  # Also aliased as #returning for readability.
+  #
+  #   def foo
+  #     returning values = [] do
+  #       values << 'bar'
+  #       values << 'baz'
+  #     end
+  #   end
+  #
+  #   foo # => ['bar', 'baz']
+
+  def with(obj=self)
+    yield obj
+    obj
+  end
+
+  alias :returning :with
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_returning
+      foo = returning( values = [] ) do
+        values << 'bar'
+        values << 'baz'
+      end
+      assert_equal( ['bar', 'baz'], foo )
+    end
+
+  end
+
+=end

data/lib/facets/core/kernel/yaml.rb

@@ -0,0 +1,7 @@
+require 'yaml'
+
+class Object
+  def yaml(*args,&blk)
+    YAML.load(*args,&blk)
+  end
+end

data/lib/facets/core/module/alias_accessor.rb

@@ -0,0 +1,19 @@
+
+class Module
+
+  # As with alias_method, but alias both reader and writer.
+  #
+  #   attr_accessor :x
+  #   self.x = 1
+  #   alias_accessor :y, :x
+  #   y #=> 1
+  #   self.y = 2   
+  #   x #=> 2
+
+  def alias_accessor( name, target )
+    alias_method( name, target )
+    alias_method( "#{name}=", "#{target}=" )
+  end
+                      
+end
+

data/lib/facets/core/module/alias_method_chain.rb

@@ -35,3 +35,36 @@ class Module
   end
 
 end
+
+
+=begin test
+
+  class TestAliasChain < Test::Unit::TestCase
+
+    module X
+      def self.included(base)
+        base.module_eval {
+          alias_method_chain :foo, :feature
+        }
+      end
+      def foo_with_feature
+        foo_without_feature + '!'
+      end
+    end
+
+    class Y
+      def foo
+        "FOO"
+      end
+      include X
+      #alias_method_chain :foo, :feature
+    end
+
+    def test_001
+      y = Y.new
+      assert_equal( "FOO!", y.foo )
+    end
+
+  end
+
+=end

data/lib/facets/core/module/class_extension.rb

@@ -45,7 +45,7 @@ class Module
   #       puts 'inst_meth'
   #     end
   #
-  #     class_methods do
+  #     class_extension do
   #       def class_meth
   #         "Class Method!"
   #       end

data/lib/facets/core/module/include_and_extend.rb

@@ -0,0 +1,10 @@
+class Module
+
+  # Both includes and extends a module.
+
+  def include_and_extend(*mods)
+    include *mods
+    extend *mods
+  end
+
+end

data/lib/facets/core/module/include_as.rb

@@ -1,5 +1,5 @@
 
-require 'delegate'
+require 'facets/core/module/namespace'
 
 class Module
 
@@ -16,19 +16,9 @@ class Module
   #
   #   X.new.t  #=> "HERE"
   #
+
   def include_as( h )
-    h.each{ |name, mod|
-      s = self
-      c = Class.new(SimpleDelegator) {
-        include mod
-        define_method(:initialize) { |s| super(s) }
-      }
-      class_eval {
-        define_method( name ) {
-          instance_variable_set( "@#{name}", instance_variable_get( "@#{name}" ) || c.new(s) )
-        }
-      }
-    }
+    h.each { |name, mod| namespace(name, mod) }
   end
 
 end
@@ -48,16 +38,26 @@ end
   class TCModule < Test::Unit::TestCase
 
     module MockModule
-      def mm; 77; end
+      def x; "X"; end
+      def y; @y; end
     end
 
     class MockObject
       include_as :mod => MockModule
+
+      def initialize
+        @y = "Y"
+      end
+    end
+
+    def test_01
+      m = MockObject.new
+      assert_equal( "X", m.mod.x )
     end
 
-    def test_include_as
+    def test_02
       m = MockObject.new
-      assert_equal( 77, m.mod.mm )
+      assert_equal( "Y", m.mod.y )
     end
 
   end
@@ -65,6 +65,7 @@ end
 =end
 
 
+
 # devlopment testing
 
 =begin

data/lib/facets/core/module/include_function_module.rb

@@ -0,0 +1,13 @@
+
+class Module
+
+  # Include module and apply module_fuction to the 
+  # included methods.
+
+  def include_function_module *mod
+    include *mod
+    module_function *mod.collect{|m| m.private_instance_methods & m.methods(false)}.flatten
+  end
+
+end
+

data/lib/facets/core/module/inject.rb

@@ -1,3 +1,4 @@
+# TODO What is this?
 
 class Module
 

data/lib/facets/core/module/memoize.rb

@@ -45,9 +45,10 @@ end
 #--
 # Would this be good to have? Will need to modify for instance level, if so.
 #++
-#def memoize(*args)
-#  self.class.memoize(*args)
-#end
+
+def memoize(*args)
+  Object.memoize(*args)
+end
 
 
 #  _____         _

data/lib/facets/core/module/module_load.rb

@@ -0,0 +1,51 @@
+class Module
+
+  # Load file into module/class namespace.
+
+  def module_load( path )
+    if path =~ /^[\/~.]/
+      file = File.expand_path(path)
+    else
+      $LOAD_PATH.each do |lp|
+        file = File.join(lp,path)
+        break if File.exist?(file)
+        file = nil
+      end
+    end
+
+    module_eval(File.read(file))
+  end
+
+  # Require file into module/class namespace.
+
+  def module_require( path )
+    if path =~ /^[\/~.]/
+      file = File.expand_path(path)
+    else
+      $LOAD_PATH.each do |lp|
+        file = File.join(lp,path)
+        break if File.exist?(file)
+        file += '.rb'
+        break if File.exist?(file)
+        file = nil
+      end
+    end
+
+    @loaded ||= {}
+    if @loaded.key?(file)
+      false
+    else
+      @loaded[file] = true
+      module_eval(File.read(file))
+      true
+    end
+  end
+
+end
+
+
+class Class
+  alias class_load module_load
+  alias class_require module_require
+end
+

data/lib/facets/core/module/module_method.rb

@@ -0,0 +1,13 @@
+
+class Module
+
+  # Like module_funtion but makes the instance method
+  # public rather than private.
+
+  def module_method *meth
+    module_function *meth
+    public *meth
+  end
+
+end
+

data/lib/facets/core/module/module_require.rb

@@ -0,0 +1,3 @@
+# stub
+require 'facets/core/module/module_load.rb'
+

data/lib/facets/core/module/namespace.rb

@@ -1,59 +1,119 @@
+#--
+# CREDIT Pit Captain (for delegation fix)
+#++
 
-require 'delegate'
+require 'facets/more/functor'
+require 'facets/core/module/basename'
 
 class Module
 
-  # Create a seperated method namespace.
+  # Define a simple method namespace.
   #
-  #   module T
-  #     def t ; "HERE" ; end
+  #   class A
+  #     attr_writer :x
+  #     namespace :inside do
+  #       def x; @x; end
+  #     end
   #   end
   #
-  #   class X
-  #     namespace :test { include T }
-  #     def t ; test.t ; end
-  #   end
-  #
-  #   X.new.t  #=> "HERE"
+  #   a = A.new
+  #   a.x = 10
+  #   a.inside.x #=> 10
+  #   a.x  # no method error
   #
-  # NOTE: This is not as functional as it ought be in that
-  # the instance variables of the object are not accessible
-  # within the namespace.
-  def namespace( name, &blk )
-    s = self
-    c = Class.new(SimpleDelegator, &blk)
-    c.class_eval { define_method(:initialize) { |s| super(s) } }
-    self.class_eval {
-      define_method( name ) {
-        instance_variable_set( "@#{name}",  instance_variable_get( "@#{name}" ) || c.new(s) )
-      }
-    }
+
+  def namespace( name, mod=nil, &blk )
+
+    # If block is given then create a module, otherwise
+    # get the name of the module.
+    if block_given?
+      name = name.to_s
+      raise ArgumentError if mod
+      mod  = Module.new(&blk)
+    else
+      if Module === name
+        mod = name
+        name = mod.basename.downcase
+      end
+      mod  = mod.dup
+    end
+
+    # Include the module. This is neccessary, otherwise
+    # Ruby won't let us bind the instance methods.
+    include mod
+
+    # Save the instance methods of the module and
+    # replace them with a "transparent" version.
+    methods = {}
+    mod.instance_methods(false).each do |m|
+      methods[m.to_sym] = mod.instance_method(m)
+      mod.instance_eval do
+        define_method(m) do
+          super
+        end
+      end
+    end
+
+    # Add a method for the namespace that delegates
+    # via the Functor to the saved instance methods.
+    define_method(name) do
+      Functor.new(methods) do |op, mtab, *args|
+        mtab[op].bind(self).call(*args)
+      end
+    end
   end
 
 end
 
 
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
 =begin test
 
   require 'test/unit'
 
-  class TCModule < Test::Unit::TestCase
+  class TestNamespace1 < Test::Unit::TestCase
+
+    module M
+      def x; "x"; end
+    end
+
+    class C
+      namespace M
+    end
+
+    def test_01
+      c = C.new
+      assert_equal('x', c.m.x)
+    end
+
+    def test_02
+      c = C.new
+      assert_raises(NoMethodError){ c.x }
+    end
+
+  end
+
+
+  class TestNamespace2 < Test::Unit::TestCase
+
+    class B
+      def x; 1; end
+    end
+
+    class C < B
+      def x; super; end
+      namespace :m do
+        def x; "x"; end
+      end
+    end
 
-    class MockObject
-      namespace(:hope) {
-        def watch ; 'watch' ; end
-      }
+    def test_01
+      c = C.new
+      assert_equal('x', c.m.x)
     end
 
-    def test_namespace
-      m = MockObject.new
-      assert_equal( 'watch', m.hope.watch )
+    def test_02
+      c = C.new
+      assert_equal(1, c.x)
     end
 
   end