facets 1.7.46 → 1.8.0

data/lib/facets/more/autoscript.rb

@@ -0,0 +1,34 @@
+require 'script'
+
+class Module
+  alias const_missing_before_autoscript const_missing
+  
+  def const_missing(sym) # :nodoc:
+    filename = @autoscript && @autoscript[sym]
+    if filename
+      mod = Script.load(filename)
+      const_set sym, mod
+    else
+      const_missing_before_autoscript(sym)
+    end
+  end
+
+  # When the constant named by symbol +mod+ is referenced, loads the script
+  # in filename using Script.load and defines the constant to be equal to the
+  # resulting Script module.
+  #
+  # Use like Module#autoload--however, the underlying opertation is #load rather
+  # than #require, because scripts, unlike libraries, can be loaded more than
+  # once. See examples/autoscript-example.rb
+  
+  def autoscript mod, filename
+    (@autoscript ||= {})[mod] = filename
+  end
+end
+
+module Kernel
+  # Calls Object.autoscript.
+  def autoscript mod, filename
+    Object.autoscript mod, filename
+  end
+end

data/lib/facets/more/autovivify.rb

@@ -0,0 +1,16 @@
+# autovivify.rb
+
+require 'facets/more/openhash.rb'
+
+# AutoVivify module houses the +method_missing+ defintion.
+
+module AutoVivify
+  def method_missing( name, *args, &block )
+    oo = OpenHash.new
+    (class << self; self; end).send( :define_method, name ) { oo }
+  end
+end
+
+class Object
+  include AutoVivify
+end

data/lib/facets/more/basicobject.rb

@@ -30,7 +30,10 @@
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
 
-require 'facets/core/kernel/__class__'
+#require 'facets/core/kernel/__class__'
+
+require 'facets/core/kernel/object_class'
+require 'facets/core/kernel/as'
 
 # = BasicObject
 #
@@ -45,17 +48,21 @@ require 'facets/core/kernel/__class__'
 # The patterns used to reserve methods are:
 #
 #    /^__/, /^instance/, /^object/, /\?$/, /^\W$/,
-#    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null'
+#    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null', 'as'
 #
 # By default these are the reserved methods:
 #
-#   == __as__ __id__ __class__ __self__ __send__ clone dup eql? equal?
-#   frozen? initialize inspect instance_eval instance_of? instance_variable_get
-#   instance_variable_set instance_variables is_a? kind_of? nil? null
+#   == __id__ __self__ __send__ as clone dup eql? equal? frozen?
+#   initialize inspect instance_eval instance_of? instance_variable_get
+#   instance_variable_set instance_variables is_a? kind_of? nil? null object_class
 #   respond_to? tainted?
 #
-# The special method #__self__ allows access to the underlying object via a
-# specialized Functor-style class called, BasicObject::Self. This binds the
+# In practice only 'as', 'clone', 'dup' and 'null' have much chance of name clash.
+# So be especially aware of these four. All the rest either begin with a '__',
+# end in a '?' mark or start with the word 'instance' or 'object'.
+#
+# The special method #object_self allows access to the underlying object via a
+# specialized Functor-style class access via as(Object). This binds the
 # actual self to the subsequently called methods of Object instancea methods.
 # So even though a method may no longer be defined for BasicObject it can still
 # be called via this interface.
@@ -63,45 +70,49 @@ require 'facets/core/kernel/__class__'
 #   class A < BasicObject
 #   end
 #
-#   a.__self__.class  #=> A
-#   a.class           #=> NoMethodError
+#   a.object_self.class  #=> A
+#   a.class              #=> NoMethodError
 #
+# Note that #object_self used to be called __self__. Also provided is #object_class.
 
 class BasicObject
 
-  # The Self class allows one to get access the hidden Object/Kernel methods.
-  # It is essentially a specialized Functor which binds an Object/Kernel
-  # method to the current object for the current call.
-
-  class Self < self
-    def initialize(obj, as=nil)
-      @obj = obj
-      @as = as || ::Object
-    end
-    def method_missing(meth, *args, &blk)
-      @as.instance_method(meth).bind(@obj).call(*args, &blk)
-    end
-  end
-
   # Returns the Self functor class, which can then be used to
   # call Kernel/Object methods on the current object.
 
-  def __self__
-    @__self__ ||= Self.new( self )
+  def object_self
+    @__object_self__ ||= As.new(self, ::Object)
   end
+  alias :__self__ :object_self  # deprecate
+
+#--
+  # The Self class allows one to get access the hidden Object/Kernel methods.
+  # It is essentially a specialized Functor which binds an Object/Kernel
+  # method to the current object for the current call.
+
+  #class Self < self
+  #  def initialize(obj, as=nil)
+  #    @obj = obj
+  #    @as = as || ::Object
+  #  end
+  #  def method_missing(meth, *args, &blk)
+  #    @as.instance_method(meth).bind(@obj).call(*args, &blk)
+  #  end
+  #end
 
   # This method is like #__self__, but allows any ancestor
   # to act on behalf of self, not just Object.
-
-  def __as__( ancestor )
-    Self.new( self, ancestor )
-  end
+  #
+  #def __as__( ancestor )
+  #  Self.new( self, ancestor )
+  #end
   #alias_method :as, :__as__
 
   # Shadow some other important methods.
 
   #alias_method :__eval__, :eval
   #alias_method :__method__, :method
+#++
 
   # Methods not to get rid of as they are either too important, or
   # they are not likely to get in the way (such as methods ending in '?').
@@ -109,17 +120,17 @@ class BasicObject
   # In Ruby 1.9 BasicObject has only these methods:
   # [ /^__/, "funcall", "send", "respond_to?", "equal?", "==", "object_id" ]
   #
-  #--
-  # TODO In the furture it might be nice to allow some selectability
-  # in these via a factory method.
-  #
   # NOTE The absolute bare minimum is EXCLUDE = /^(__|instance_eval$)/.
   # But in most cases you'll want a few extra methods like #dup too.
+  #
+  #--
+  # TODO In the future it might be nice to allow some selectability
+  # in these via a factory method.
   #++
 
   EXCLUDE = [
     /^__/, /^instance_/, /^object_/, /\?$/, /^\W$/,
-    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null' #, 'as'
+    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null', 'as'
   ]
 
   # Undef unwanted method as long as it doesn't match anything in the EXCLUDE list.
@@ -146,17 +157,19 @@ class BasicObject
   private_instance_methods(true).each { |m| hide(m) }
   protected_instance_methods(true).each { |m| hide(m) }
 
+#--
   # If the method isn't defined and has the form '__method__'
   # then try sending 'method' to self-as-Object. Remember
   # this will not have any effect if you override it!
 
-  def method_missing( sym, *args, &blk )
-    if md = /^__(.+)__$/.match( sym.to_s )
-      __as__(Object).__send__( md[1], *args, &blk )
-    else
-      super
-    end
-  end
+  #def method_missing( sym, *args, &blk )
+  #  if md = /^__(.+)__$/.match( sym.to_s )
+  #    as(Object).__send__( md[1], *args, &blk )
+  #  else
+  #    super
+  #  end
+  #end
+#++
 
 end
 
@@ -236,41 +249,41 @@ end
     end
 
     def test_001
-      assert( ! @a.__class__.method_defined?( :id ) )
-      assert( ! @a.__class__.method_defined?( :class ) )
+      assert( ! @a.object_class.method_defined?( :id ) )
+      assert( ! @a.object_class.method_defined?( :class ) )
     end
 
     def test_002
-      assert( @a.__class__.method_defined?( :__id__ ) )
-      assert( @a.__class__.method_defined?( :__send__ ) )
-      assert( @a.__class__.method_defined?( :__self__ ) )
-      assert( @a.__class__.method_defined?( :dup ) )
-      #assert( @a.__class__.method_defined?( :as ) )
+      assert( @a.object_class.method_defined?( :__id__ ) )
+      assert( @a.object_class.method_defined?( :__send__ ) )
+      assert( @a.object_class.method_defined?( :object_self ) )
+      assert( @a.object_class.method_defined?( :dup ) )
+      assert( @a.object_class.method_defined?( :as ) )
     end
 
     def test_003
-      assert_equal( A, @a.__self__.class )
+      assert_equal( A, @a.object_self.class )
     end
 
     def test_004
       Kernel.module_eval { def xxx ; end }
-      assert( ! @a.__class__.method_defined?( :xxx ) )
+      assert( ! @a.object_class.method_defined?( :xxx ) )
     end
 
     def test_005
       Object.class_eval { def yyy ; end }
-      assert( ! @a.__class__.method_defined?( :yyy ) )
+      assert( ! @a.object_class.method_defined?( :yyy ) )
     end
 
     def test_006
       Object.class_eval { def yyy ; end }
-      assert( ! @a.__self__.methods.include?( 'yyy' ) )
+      assert( ! @a.object_self.methods.include?( 'yyy' ) )
     end
 
     def test_007
       Object.class_eval { def yyy ; end }
-      assert( ! @a.__class__.method_defined?( :methods ) )
-      assert( ! @a.__methods__.include?( :methods ) )
+      assert( ! @a.object_class.method_defined?( :methods ) )
+      assert( ! @a.object_self.methods.include?( :methods ) )
     end
 
   end

data/lib/facets/more/behvior.rb

@@ -0,0 +1,59 @@
+# = behavng.rb
+#
+# CREDIT Nobuyoshi Nakada
+
+class Behavior < Module
+    def define(behavior, &body)
+    if body
+      define_method(behavior, &body)
+    else
+      behavior.each do |behavior, body|
+        if body
+          define_method(behavior, &body)
+        elsif body.nil?
+          remove_method(behavior)
+        else
+          undef_method(behavior)
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+  def behaving(behavior, &body)
+    unless @_behaviors
+      extend(@_behaviors = Behavior.new)
+    end
+    @_behaviors.define(behavior, &body)
+  end
+end
+
+
+# OLD IMPLEMENTATION
+
+=begin
+class Behavior < Module
+    def initialize(behavior, &body)
+    if body
+      define_method(behavior, &body)
+    else
+      behavior.each do |behavior, body|
+        if body
+          define_method(behavior, &body)
+        elsif body.nil?
+          remove_method(behavior)
+        else
+          undef_method(behavior)
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+  def behaving(behavior, &body)
+    extend(Behavior.new(behavior, &body))
+  end
+end
+=end

data/lib/facets/more/buildingblock.rb

@@ -0,0 +1,192 @@
+# = buildingblock.rb
+#
+# == Copyright (c) 2006 Thomas Sawyer
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# == Authors and Contributors
+#
+# * Thomas Sawyer
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2007 Thomas Sawyer
+# License::   Ruby License
+
+# = BuildingBlock
+#
+# Build content programatically with Ruby and Ruby's blocks.
+#
+#   require 'facets'
+#   require 'xmlhelper'
+#
+#   build = BuildingBlocks.new(XMLHelper, :element)
+#
+#       doc = build.html do
+#
+#           head do
+#               title "Test"
+#           end
+#
+#           body do
+#               i "Hello"
+#               br
+#               _text "Test"
+#               _text "Hey"
+#           end
+#
+#       end
+#
+#   end
+#
+# _produces_
+#
+#   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
+#
+# All calls within the block are routed to the Helper Module's constructor method,
+# unless preceeded by an underscore, in which case they are passed to Helper Module.
+#
+# Sometimes keywords can get in the way of a construction. In these cases you can
+# ensure use of constructor method by suffixing an underscore '_' to the call.
+# All of Ruby's built-in keywords (eg. 'while', 'if', 'until', etc.) and the following
+# methods are treated as keywords.
+#
+#      singleton_method_undefined
+#      method_missing
+#      initialize
+#      inspect
+#      to_str
+#      to_s
+#      respond_to?
+#
+# This work was of course inspired by many great minds, and represents a concise and simple
+# means of accomplishing this pattern of design, which is unique to Ruby.
+
+class BuildingBlock
+
+  def initialize(helper_module, constructor_method)
+    @module = helper_module
+    @constructor = constructor_method
+    @instance_eval = method(:instance_eval)
+
+    @method = {}
+
+    meths = []
+    meths.concat singleton_methods
+    meths.concat public_methods
+    meths.concat protected_methods
+    meths.concat private_methods
+    meths.each do |m|
+      @method[m.to_sym] = method(m)
+    end
+
+    class << self
+      escape = []
+      #escape << 'p'
+      escape << 'singleton_method_undefined'
+      escape << 'method_missing'
+      escape << 'initialize'
+      escape << 'inspect'
+      escape << 'to_str'
+      escape << 'to_s'
+      #escape << 'to_ary'
+      escape << 'respond_to?'
+      meths = []
+      meths.concat singleton_methods
+      meths.concat public_instance_methods
+      meths.concat protected_instance_methods
+      meths.concat private_instance_methods
+      meths.each do |m|
+        undef_method(m) unless m =~ /^__/ or escape.include?(m)
+      end
+    end
+
+    @stack = []
+    @out = ''
+  end
+
+  def method_missing(o, *a, &b)
+    o = o.to_s
+
+    if b
+      @stack << @out
+      @out = ''
+      @instance_eval.call(&b)
+      s = @out
+      @out = @stack.pop
+      a.unshift(s)
+    end
+
+    if o[-1,1] == '_'
+      m = o[0..-2].to_sym
+      @out << @module.send(@constructor, m, *a).to_s
+    elsif o[0,1] == '_'
+      m = o[1..-1].to_sym
+      @out << @module.send(m, *a, &b).to_s
+    else
+      o = o.chomp('?') if o[-1,1] == '?'
+      @out << @module.send(@constructor, o, *a).to_s
+    end
+  end
+
+  def to_s() @out end
+  def to_str() @out end
+
+  # Could improve.
+
+  def inspect
+    r = super
+    i = r.index(',')
+    return r[0...i] + ">"
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  class TestBuildingBlock < Test::Unit::TestCase
+
+    module M
+      extend self
+      def m(n,*m) ; "#{n}{#{m}}"; end
+      def t(n) ; "#{n}"; end
+    end
+
+    def test_01
+      build = BuildingBlock.new(M, :m)
+
+      build.html do
+        head do
+          title "Test"
+        end
+
+        body do
+          i "Hello"
+          not_
+          _t "Test"
+          _t "Hey"
+        end
+      end
+
+      r = "html{head{title{Test}}body{i{Hello}not{}TestHey}}"
+
+      assert_equal( r, build.to_s )
+    end
+
+  end
+
+=end