tagz 0.0.4 → 1.0.0

data/install.rb

@@ -36,7 +36,11 @@ def install_rb(srcdir=nil, destdir=nil, mode=nil, bin=nil)
     next unless FileTest.file?(f)
     next if (f = f[srcdir.length+1..-1]) == nil
     next if (/CVS$/ =~ File.dirname(f))
+    next if (/\.svn/ =~ File.dirname(f))
     next if f =~ %r/\.lnk/
+    next if f =~ %r/\.svn/
+    next if f =~ %r/\.swp/
+    next if f =~ %r/\.svn/
     path.push f
     dir |= [File.dirname(f)]
   end

data/lib/tagz.rb

@@ -1,406 +1,201 @@
-module Tagz
-  Tagz::VERSION = '0.0.4' unless defined? Tagz::VERSION
-  def self.version() VERSION end
+unless defined? Tagz
 
-  class NotOpen < StandardError; end
-  class StillOpen < StandardError; end
+  require 'cgi'
 
-  class << self
-    def default_non_container_tag_list
-      # http://www.w3schools.com/xhtml/xhtml_ref_byfunc.asp
-      %w[
-        br hr input img area base basefont
-      ]
+  module Tagz
+    unless defined?(Tagz::VERSION)
+      Tagz::VERSION = [
+        Tagz::VERSION_MAJOR = 1,
+        Tagz::VERSION_MINOR = 0,
+        Tagz::VERSION_TEENY = 0 
+      ].join('.')
+      def Tagz.version() Tagz::VERSION end
     end
 
-    def non_container_tag_list *argv 
-      if argv.first
-        @non_container_tag_list = [argv.first].flatten.uniq.map{|arg| arg.to_s}
-        @non_container_tags = @non_container_tag_list.inject(Hash.new){|h,k| h.update k => true}
-        @non_container_tag_list
-      else
-        if defined?(@non_container_tag_list) and @non_container_tag_list
-          @non_container_tag_list
-        else
-          non_container_tag_list default_non_container_tag_list
-          @non_container_tag_list
-        end
+    class Fragment < ::String
+      def << other
+        super other.to_s
+        self
       end
-    end
 
-    def non_container_tags
-      if defined?(@non_container_tags) and @non_container_tags
-        @non_container_tags
-      else
-        non_container_tag_list
-        @non_container_tags
+      def + other
+        self.dup << other
       end
     end
 
-    def container? tag
-      not(non_container_tags[tag.to_s] or false)
-    end
-
-    def emtpy? tag
-      not container?(tag)
-    end
-  end
+    class Element < ::String
+      def Element.attributes options
+        unless options.empty?
+          ' ' << 
+            options.map do |key, value|
+              key = CGI.escapeHTML key.to_s
+              value = CGI.escapeHTML value.to_s
+              if value =~ %r/"/
+                raise ArgumentError, value if value =~ %r/'/
+                value = "'#{ value }'"
+              else
+                raise ArgumentError, value if value =~ %r/"/
+                value = "\"#{ value }\""
+              end
+              [key, value].join('=')
+            end.join(' ')
+        else
+          ''
+        end
+      end
 
-  module Fragment
-    attr_accessor 'tag' 
-    attr_accessor 'open' 
-    attr_accessor 'added' 
-    attr_accessor 'created_at'
-    alias_method 'open?', 'open'
+      attr 'name'
 
-    def self.new str='', tag='', options = {}
-      return str if Fragment === str
-      str.extend Fragment
-      str.tag = tag.to_s
-      str.stack << tag.to_s 
-      str.open = true 
-      str.added = { str.object_id => true }
-      options.each{|k,v| str.send "#{ k }=", v}
-      str.created_at = caller
-      str
-    end
+      def initialize name, *argv, &block
+        options = {}
+        content = []
 
-    def stack 
-      @stack ||= []
-    end
+        argv.each do |arg|
+          case arg
+            when Hash
+              options.update arg
+            else
+              content.push arg
+          end
+        end
 
-    def push fragment
-      if Fragment === fragment
-        stack.push fragment.tag
-      end
-    end
+        content.push block.call if block
+        content.compact!
 
-    def pop
-      stack.pop
-    end
+        @name = name.to_s
 
-    def closes? other
-      tag.to_s == other.tag.to_s
+        if content.empty?
+          replace "<#{ @name }#{ Element.attributes options }>"
+        else
+          replace "<#{ @name }#{ Element.attributes options }>#{ content.join }</#{ name }>"
+        end
+      end
     end
 
-    def << content
-      super content.to_s
+    def Tagz.export *methods 
+      methods.flatten.compact.uniq.each do |m|
+        module_function m
+      end
     end
 
-    def add fragment
-      push fragment
-      oid = fragment.object_id
-      self << fragment unless added[oid]
+    def Tagz.<< other
+      Tagz.tagz << other
       self
-    ensure
-      added[oid] = true
     end
-  end
 
-
-  module Abilities
   private
-    def tagz *argv, &block
-      stack = __tag_stack__
-      top = stack.last
-      size = stack.size
 
-      unless block
-        top ||= Fragment()
-        if argv.empty?
-          top
-        else
-          string = argv.join
-          top.add string 
-          string
+    def tagz &block
+      if block
+        if not defined?(@tagz) or @tagz.nil?
+          @tagz = Fragment.new
+          top = true
         end
-      else
-        obj = Tagz === self ? self : clone.instance_eval{ extend Tagz; self }
-        stack << (top=Fragment())
-        top = stack.last
-        tid = top.object_id
-
-        string = obj.instance_eval(&block)
-
-        until stack.last.object_id == tid
-          pop = stack.pop
-          last = stack.last
-          last.add pop 
+        begin
+          size = @tagz.size
+          value = instance_eval(&block)
+          @tagz << value unless(Fragment === value or @tagz.size > size)
+          @tagz
+        ensure
+          @tagz = nil if top
         end
-
-        top = stack.pop
-
-        content_was_added = top.size > 0
-        top.add string unless content_was_added
-
-        top
-      end
-    end
-
-    def method_missing m, *a, &b
-      case m.to_s
-        when %r/^(.*[^_])_(!)?$/o
-          m, bang = $1, $2
-          unless bang
-            __tag_start__ m, *a, &b
-          else
-            __tag_start__(m, *a){}
-          end
-        when %r/^_([^_].*)$/o
-          m = $1 
-          __tag_stop__ m, *a, &b
-        else
-          super
+      else
+        @tagz ||= Fragment.new
       end
     end
 
-    def __tag_stack__
-      @__tag_stack__ ||= []
-    end
+    def tagz__ name, *argv, &block
+      options = {}
+      content = []
 
-    def __tag_attrs__ attrs = {}
-      return nil if attrs.empty?
-      ( 42 - 10 ).chr <<
-        case attrs
+      argv.each do |arg|
+        case arg
           when Hash
-            attrs.map{|k,v| "#{ k }=#{ v.to_s.inspect }"}.join(" ")
+            options.update arg
           else
-            attrs.to_s
+            content.push arg
         end
-    end
-
-    def __tag_start__ *argv, &block
-      tag = argv.shift
-
-      case argv.size
-        when 0                      # no attrs, no content
-          attrs = {}
-          content = nil
-        when 1                      # string content
-          case argv.first
-            when Hash
-              attrs = argv.shift 
-              content = nil 
-            else
-              if block
-                attrs = argv.shift 
-                content = nil 
-              else
-                content = argv.shift 
-                attrs = {}
-              end
-          end
-        when 2                      # string attrs, string content OR string content, hash attrs
-          case argv.last
-            when Hash
-              attrs = argv.last
-              content = argv.first.to_s
-            else
-              attrs = argv.first
-              content = argv.last.to_s
-          end
-        else                       # string attrs, string content(s) OR string content(s), hash attrs
-          case argv.last
-            when Hash
-              attrs = argv.last
-              content = argv[0..-2].join
-            else
-              attrs = argv.first
-              content = argv[1..-1].join
-          end
-      end
-
-      if content and block
-        b = block and block = lambda{ "#{ content }#{ b.call }" }
       end
 
-      if content and block.nil?
-        #block = lambda{ content }
-      end
-
-      stack = __tag_stack__
-
-      if block.nil?
-        start = Fragment( "<#{ tag }#{ __tag_attrs__ attrs }  >#{ content }", tag )
-        stack << start 
-        start
+      unless options.empty?
+        attributes = ' ' << 
+          options.map do |key, value|
+            key = CGI.escapeHTML key.to_s
+            value = CGI.escapeHTML value.to_s
+            if value =~ %r/"/
+              raise ArgumentError, value if value =~ %r/'/
+              value = "'#{ value }'"
+            else
+              raise ArgumentError, value if value =~ %r/"/
+              value = "\"#{ value }\""
+            end
+            [key, value].join('=')
+          end.join(' ')
       else
-        ### we reserve two bytes ( 0.chr 0.chr ) to avoid massive data shift/copy
-        start = Fragment( "<#{ tag }#{ __tag_attrs__ attrs } #{ 0.chr }#{ 0.chr }", tag )
-        stack << start 
-        size = start.size
-        pos = ( (size - 2) .. (size - 1) )
-        top = stack.last
-        tid = top.object_id
-        ssize = stack.size
-        
-
-        content = block.call top
-        content_was_added = size < start.size
-
+        attributes = ''
+      end
 
-        ### handle dangling tags
-        if stack.size > ssize 
-          i = ssize
-          while((opentag = stack[i]))
-            top.add opentag
-            i += 1
-          end
-          stack.pop until stack.size == ssize
-        end
+      tagz << "<#{ name }#{ attributes }>"
 
-### TODO we could raise an error
-=begin
-        until stack.last.object_id == tid
-          begin
-            last = stack.last
-            ne = last.created_at[3] 
-            raise StillOpen, "<#{ last.tag }> @ '#{ ne }'"
-          ensure
-            stack.clear
+      if content.empty?
+        if block
+          size = tagz.size
+          value = block.call(tagz)
+          unless value
+            tagz[-1] = "/>"
+          else
+            tagz << value.to_s unless(Fragment === value or tagz.size > size)
+            tagz << "</#{ name }>"
           end
         end
-=end
-        
-        if content or Tagz.container?(tag)
-          top[pos] = ' >'
-          top.add content unless content_was_added
-          stop = Fragment( "</#{ tag }>", tag, :open => false )
-          top.add stop
-          top.open = false
-        else
-          top[pos] = '/>'
-          top.open = false
-        end
-
-        content = stack.pop
-
-        top = stack.last
-        if top and top.open?
-          top.add content
-        end
-
-        content
-      end
-    end
-
-    def __tag_stop__ tag
-      stack = __tag_stack__
-      top = stack.last
-      stop = Fragment( "</#{ tag }>", tag, :open => false )
-      if top
-        if stop.closes?(top)
-          top.add stop
-          top.open = false
-          content = stack.pop
-          top = stack.last
-          top.add content if top and top.open?
-          content
-        else
-          raise NotOpen, tag.to_s
-        end
       else
-        raise NotOpen, tag.to_s
+        content.each{|c| tagz << c.to_s unless Fragment === c}
+        if block
+          size = tagz.size
+          value = block.call(tagz)
+          tagz << value.to_s unless(Fragment === value or tagz.size > size)
+        end
+        tagz << "</#{ name }>"
       end
-    end
-
-    def Fragment(*a, &b) Fragment.new(*a, &b) end
-
-    def element tag, *a, &b
-      __tag_stack__ << (top=Fragment())
-      __tag_start__ tag, *a, &b
-      __tag_stack__.pop
-    end
-    alias_method "e", "element"
-
-    def element_ tag, *a, &b
-      __tag_stack__ << (top=Fragment())
-      __tag_start__ tag, *a, &b
-      __tag_stack__.pop
-    end
-    alias_method "e_", "element_"
 
-    def _element tag, *a, &b
-      __tag_stack__ << (top=Fragment())
-      __tag_stop__ tag, *a, &b
-      __tag_stack__.pop
+      tagz
     end
-    alias_method "_e", "_element"
 
-    def element! tag, *a, &b
-      b ||= lambda{}
-      __tag_stack__ << (top=Fragment())
-      __tag_start__ tag, *a, &b
-      __tag_stack__.pop
+    def __tagz tag, *a, &b
+      tagz << "</#{ tag }>"
     end
-    alias_method "e!", "element!"
 
-    def xhtml_ which = :transitional, *a, &b
-      decl = 
-%Q|<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-#{ which }.dtd'>|
-      attrs = {}
-      attrs.update 'xmlns' => 'http://www.w3.org/1999/xhtml',
-                   'xml:lang' => 'en'
-      decl << html_(attrs, &b)
-    end
-  end
-
-  def self.included other
-    other.module_eval{ include Abilities }
-  end
-
-  def self.extend_object other
-    other.extend Abilities 
-  end
-
-  class ::String
-    include Tagz 
-    def tag *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def tag_ *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def _tag *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def tag! *a
-      tagz{ __tag_start__(self, *a){} }
+    def method_missing m, *a, &b
+      return super unless @tagz
+      case m.to_s
+        when %r/^(.*[^_])_(!)?$/o
+          m, bang = $1, $2
+          unless bang
+            tagz__(m, *a, &b)
+          else
+            tagz__(m, *a){}
+          end
+        when %r/^_([^_].*)$/o
+          m = $1 
+          __tagz(m, *a, &b)
+        when 'e'
+          Element.new(*a, &b)
+        when '__'
+          tagz << "\n"
+        else
+          super
+      end
     end
-  end
 
-  class ::Symbol
-    include Tagz 
-    def tag *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def tag_ *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def _tag *a, &b
-      tagz{ __tag_start__ self, *a, &b }
-    end
-    def tag! *a
-      tagz{ __tag_start__(self, *a){} }
-    end
+    export %w( tagz tagz__ __tagz method_missing )
   end
-end
 
-class Object
-  def Tagz &block
-    const = Object.const_get :Tagz
-    if block
-      if const === self
-        this = self
-      else
-        this = eval('self', block).dup
-        this.send :extend, Tagz
-      end
-      this.send :tagz, &block
+  def Tagz *argv, &block
+    if argv.empty? and block.nil?
+      ::Tagz
     else
-      const
+      Tagz.tagz(*argv, &block)
     end
   end
-end
 
-require File.join(File.dirname(__FILE__), 'tagz', 'rails') if defined? Rails
+end