facets 1.7.46 → 1.8.0

data/lib/facets/{more → yore}/annattr.rb

@@ -20,7 +20,7 @@
 # License::   Ruby License
 
 require 'facets/more/inheritor.rb'
-require 'facets/more/annotation.rb'
+require 'facets/yore/annotation.rb'
 
 # = Annotated Attributes
 #

data/lib/facets/{more → yore}/annotation.rb

@@ -20,8 +20,9 @@
 # License::   Ruby License
 
 require 'facets/core/hash/to_h'
-require 'facets/more/openobject'
-require 'facets/more/nullclass'
+require 'facets/core/kernel/object_class'
+require 'facets/more/openhash'
+#require 'facets/more/nullclass'
 
 # = Annotation
 #
@@ -30,7 +31,7 @@ require 'facets/more/nullclass'
 # merely comments. But you can put them to use. For instance an attribute
 # validator might check for an annotation called :valid and test against it.
 #
-# Annotation is an OpenObject, and is used across the board for keeping annotations.
+# Annotation is an OpenHash, and is used across the board for keeping annotations.
 #
 # Annotation class serves for both simple and inherited cases depending on whether
 # a base class is given.
@@ -60,20 +61,21 @@ class Annotations
     @base, @ann = base, {}
   end
 
-  def [](name)
-    @ann[name] ||= Annotation.new(@base, name)
+  def [](key)
+    key = :self if key == @base
+    @ann[key] ||= Annotation.new(@base, key)
   end
 
-  def []=(name, note)
+  def []=(key, note)
     raise ArgumentError unless Annotation === note
-    @ann[name] = note
+    @ann[key] = note
   end
 
   def ==(other) @ann == other.to_h end
 
   def to_h() @ann end
 
-  def key?(name) @ann.key?(name) end
+  def key?(key) @ann.key?(key) end
 
   def each(&yld)
     @ann.each(&yld)
@@ -85,6 +87,10 @@ class Annotations
   end
   private :update
 
+  def self
+    self[:self]
+  end
+
 #   def inheritance
 #     anns = Annotations.new(@base)
 #     @base.ancestors.each do |anc|
@@ -101,12 +107,12 @@ class Annotations
 
   def annotated_base() @base end
 
-  def method_missing( name, *args, &blk )
-    if key?(name)
-      self[name] #.heritage
+  def method_missing( key, *args, &blk )
+    if key?(key)
+      self[key] #.heritage
     else
-      if @base.ancestors.any?{|anc| anc.annotations.key?(name)}
-        return self[name].heritage
+      if @base.ancestors.any?{|anc| anc.annotations.key?(key)}
+        return self[key].heritage
         #ann[name].heritage
       end
       super
@@ -117,11 +123,11 @@ end
 
 #
 
-class Annotation < OpenObject
+class Annotation < OpenHash
 
-  def initialize( base, name, orig=nil )
+  def initialize( base, key, orig=nil )
     @base = base
-    @name = name
+    @key  = key
     @orig = orig || self
     super()
   end
@@ -135,18 +141,18 @@ class Annotation < OpenObject
   #end
 
   def inspect
-    "#<#{object_class.name}(#{@base}##{@name}) #{super}>"
+    "#<#{object_class.name}(#{@base}##{@key}) #{super}>"
   end
 
-  def annotation_name
-    @name
+  def annotation_key
+    @key
   end
 
   def heritage( orig=nil )
     ah = {}
     @base.ancestors.reverse_each do |anc|
-      if anc.annotations.key?(@name)
-        anc.annotations[@name].each { |k,v|
+      if anc.annotations.key?(@key)
+        anc.annotations[@key].each { |k,v|
           case v
           when Module
             ah[k] = v
@@ -156,7 +162,7 @@ class Annotation < OpenObject
         }
       end
     end
-    a = Annotation.new( @base, @name, orig || @orig )
+    a = Annotation.new( @base, @key, orig || @orig )
     a.send(:replace, ah)
     a
   end
@@ -170,7 +176,7 @@ class Annotation < OpenObject
       @orig[key] = args[0] #, *args, &blk )
     when '!'
       #r = super( key, *args, &blk )
-      if self.key?(key)
+      if key?(key)
         self[key]
       else
         self[key] = heritage(self)[key]
@@ -190,22 +196,22 @@ class Module
     @annotations ||= Annotations.new(self)
   end
 
-  def ann( name=nil, *options )
-    return annotations unless name
-    return name.each{|k,v| ann k,*v} if Hash === name
-    return annotations[(name == :self ? self : name)] if options.empty?
+  def ann( key=nil, *options )
+    return annotations unless key
+    return name.collect{|k,v| ann k,*v} if Hash === key
+    return annotations[key] if options.empty?
     opt = {}
     opt.update options.pop if Hash === options.last
     opt[:class] = options.pop if Class === options.last
-    names = [name].concat options
-    names.each do |name|
-      note = annotations[name]
+    keys = [key].concat options
+    keys.each do |key|
+      note = annotations[key]
       #unless options.empty?
       #  (hopt[:tags] ||= []) << options
       #end
       note.send(:update,opt)
-    end 
-    names
+    end
+    keys
   end
 
 end

data/lib/facets/yore/builderobject.rb

@@ -0,0 +1,222 @@
+# = builderobject.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) 2006 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/more/functor'
+require 'facets/core/kernel/object_class'
+
+# = BuilderObject
+#
+# Build content programatically with Ruby and Ruby's blocks.
+#
+# Builders can use either an implict or explicit receiver.
+# Explicit is the default. To use implicit pass the :implicit
+# option to the constructor.
+#
+# Implict building is more elegant in form, but it is not as
+# functional because it makes it more difficult to refer to
+# external references.
+#
+# BuilderObject avoides method name clashes by using
+# Functor redirection. Unlike other implementations of
+# the Builder patterns which append '!' to builder methods
+# or simply use odd names to avoid clashes, BuilderObject
+# routes all builder method vis the #out method.
+
+class BuilderObject
+
+  private *public_instance_methods
+
+  def self.builder
+    @builder ||= Class.new
+  end
+
+  def self.builder_include( mod )
+    builder.class_eval { include mod }
+  end
+
+  def initialize(explicit=true)
+    @explicit = explicit
+    @stack = []
+    @buffer = ''
+  end
+
+  #def builder
+  #  @builder ||= object_class.builder.new
+  #end
+
+  def out( str=nil )
+    if str
+      @buffer << str
+    else
+      @builder_functor ||= Functor.new( &send(:method,:+) )
+    end
+  end
+
+  def +( op, *args, &blk )
+    @builder ||= object_class.builder.new
+    @buffer << @builder.send( op, *args, &blk )
+  end
+
+  def to_s
+    @buffer
+  end
+
+  def method_missing( op, *a, &b )
+    if b
+      @stack << @buffer
+      @buffer = ''
+      @explict ? b.call : instance_eval(&b)
+      r = @buffer
+      @buffer = @stack.pop
+      @buffer << builder_call(op, r, *a, &b)
+    else
+      @buffer << builder_call(op, *a, &b)
+    end
+  end
+
+end
+
+
+class BuildingBlocks
+
+  def initialize(mod, constructor)
+    @module = mod
+    @constructor = constructor
+    @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[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
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+require 'facets/more/xmlhelper.rb'
+
+      build = BuildingBlocks.new(XMLHelper, :element)
+
+      doc = build.html do
+
+          head do
+            title "Test"
+          end
+
+          body do
+            i "Hello"
+            br
+            _text "Test"
+            _text "Hey"
+            _p "Output, Baby!"
+          end
+
+      end
+
+puts doc
+p build
+puts build
+
+
+      r = "<html><head><title>Test</title></head><body><p>Hello</p>Test</body></html>"
+      #assert_equal( r, doc )
+      #assert_equal( r, x.to_s )
+    #end
+
+
+
+#=begin
+
+
+
+#=end
+

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

@@ -0,0 +1,9 @@
+# TODO What is this?
+
+class Module
+
+  def inject( base, &block )
+    base.module_eval &block
+  end
+
+end

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

@@ -0,0 +1,62 @@
+
+require 'delegate'
+
+class Module
+
+  # Create a seperated method namespace.
+  #
+  #   module T
+  #     def t ; "HERE" ; end
+  #   end
+  #
+  #   class X
+  #     namespace :test { include T }
+  #     def t ; test.t ; end
+  #   end
+  #
+  #   X.new.t  #=> "HERE"
+  #
+  # 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) )
+      }
+    }
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    class MockObject
+      namespace(:hope) {
+        def watch ; 'watch' ; end
+      }
+    end
+
+    def test_namespace
+      m = MockObject.new
+      assert_equal( 'watch', m.hope.watch )
+    end
+
+  end
+
+=end