eimxml 0.0.2 → 0.0.3.1

data/lib/eim_xml/formatter.rb

@@ -0,0 +1,123 @@
+require "eim_xml"
+
+module EimXML
+	class Formatter
+		attr_reader :out
+
+		def self.write(element, opt={})
+			opt = {:out=>""}.merge(opt)
+			new(opt).write(element)
+			opt[:out]
+		end
+
+		def initialize(opt)
+			@out = opt[:out]
+			@preservers = opt[:preservers]
+			@preserve_space = false
+			@indent_string = "  "
+			@indent_depth = 0
+			@option = opt.dup.tap{|h| [:out, :preservers].each{|k| h.delete(k)}}
+		end
+
+		def write(src)
+			case src
+			when ElementWrapper
+				write_wrapper(src)
+			when Comment
+				write_comment(src)
+			when Element
+				write_element(src)
+			when PCString
+				write_pcstring(src)
+			else
+				write_string(src.to_s)
+			end
+		end
+
+		def indent(&proc)
+			@indent_depth += 1
+			proc.call
+		ensure
+			@indent_depth -= 1
+		end
+
+		def preserve_space_element?(elm)
+			@preservers && @preservers.any? do |e|
+				case e
+				when Symbol
+					e==elm.name
+				when Class
+					e===elm
+				end
+			end
+		end
+
+		def write_indent
+			out << @indent_string*@indent_depth unless @preserve_space
+		end
+
+		def write_newline
+			out << "\n" unless @preserve_space
+		end
+
+		def write_comment(c)
+			write_indent
+			c.write_to(out)
+			write_newline
+		end
+
+		def write_contents_of(elm)
+			flag = @preserve_space
+			@preserve_space = true if preserve_space_element?(elm)
+			write_newline
+			indent do
+				elm.contents.each do |c|
+					write(c)
+				end
+			end
+			write_indent
+		ensure
+			@preserve_space = flag
+		end
+
+		def write_element(elm)
+			write_indent
+			out << "<"
+			elm.name_and_attributes(out)
+			case elm.contents.size
+			when 0
+				out << " />"
+				write_newline
+			else
+				out << ">"
+				write_contents_of(elm)
+				out << "</#{elm.name}>"
+				write_newline
+			end
+		end
+
+		def write_pcstring(pcs)
+			pcs.encoded_string.each_line do |l|
+				write_indent
+				out << l
+			end
+			write_newline
+		end
+
+		def write_string(str)
+			PCString.encode(str).each_line do |l|
+				write_indent
+				out << l
+			end
+			write_newline
+		end
+
+		def write_wrapper(wrapper)
+			wrapper.each(@option) do |i|
+				write(i)
+			end
+		end
+	end
+end
+
+require "eim_xml/formatter/element_wrapper"

data/lib/eim_xml/formatter/element_wrapper.rb

@@ -0,0 +1,7 @@
+class EimXML::Formatter
+	class ElementWrapper
+		def each(option, &proc)
+			contents(option).each(&proc)
+		end
+	end
+end

data/lib/eim_xml/parser.rb

@@ -16,32 +16,23 @@ module EimXML
 		module RE
 			EMPTY_ELEMENT = /<([^>]*?)\/>/
 			START_TAG = /<([^>]*?([^\/>]\s*))>/
-			END_TAG = /<\/(\S+)\s*>/
+			END_TAG = /<\/(\S+?)\s*>/
 			ATTRIBUTE = /\s+([^=\s]+)\s*=\s*('(.*?)'|"(.*?)")/m
 			STRING = /[^<]+/
 		end
 
-		def initialize(src, *space_holders)
+		def initialize(src)
 			@scanner = StringScanner.new(src)
-			@space_holders = []
-			@space_holder_res = []
-			space_holders.each do |i|
-				if i.is_a?(Regexp)
-					@space_holder_res << i
-				else
-					@space_holders << i.to_sym
-				end
-			end
+			@scanner.scan(/\s*<\?.*?\?>\s*/)
 		end
 
-		def parse(hold_space = false)
-			@scanner.scan(/\s+/) unless hold_space
+		def parse
 			if @scanner.scan(RE::EMPTY_ELEMENT)
-				parse_empty_element(hold_space)
+				parse_empty_element
 			elsif @scanner.scan(RE::START_TAG)
-				parse_start_tag(hold_space)
+				parse_start_tag
 			elsif @scanner.scan(RE::STRING)
-				parse_string(hold_space)
+				parse_string
 			else
 				nil
 			end
@@ -55,43 +46,26 @@ module EimXML
 		end
 		protected :parse_tag
 
-		def space_holder?(ename)
-			return true if @space_holders.include?(ename)
-			s = ename.to_s
-			@space_holder_res.each do |re|
-				return true if re=~s
-			end
-			false
-		end
-
-		def parse_empty_element(hold_space)
-			e = parse_tag
-			hold_space = space_holder?(e.name) unless hold_space
-			e.hold_space if hold_space
-			e
+		def parse_empty_element
+			parse_tag
 		end
 		protected :parse_empty_element
 
-		def parse_start_tag(hold_space)
+		def parse_start_tag
 			e = parse_tag
-			hold_space = space_holder?(e.name) unless hold_space
 
-			e.hold_space if hold_space
-			@scanner.scan(/\s*/) unless hold_space
 			until @scanner.scan(RE::END_TAG)
-				c = parse(hold_space)
+				c = parse
 				raise ParseError.new("Syntax error.") unless c
 				e << c
-				@scanner.scan(/\s*/) unless hold_space
 			end
 			raise ParseError.new("End tag mismatched.") unless @scanner[1].to_sym==e.name
 			e
 		end
 		protected :parse_start_tag
 
-		def parse_string(hold_space)
+		def parse_string
 			s = @scanner[0]
-			s = s.strip unless hold_space
 			s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
 				case $1
 				when "amp"
@@ -104,8 +78,6 @@ module EimXML
 					"<"
 				when "gt"
 					">"
-				else
-					raise "must not happen"
 				end
 			end
 			PCString.new(s)

data/lib/eim_xml/xhtml.rb

@@ -1,16 +1,11 @@
 require "eim_xml"
+require "eim_xml/formatter"
 
 module EimXML::XHTML
 	module DocType
 		XHTML_MATHML = %[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN" "http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd">]
 	end
 
-	class DSL < EimXML::BaseDSL
-	end
-
-	class OpenDSL < EimXML::OpenDSL
-	end
-
 	class Base_ < EimXML::Element
 	end
 
@@ -20,106 +15,139 @@ module EimXML::XHTML
 			XHTML = "http://www.w3.org/1999/xhtml"
 		end
 
-		def initialize(attributes=nil)
+		def initialize(attributes={})
 			super(:html, attributes)
 		end
 
-		def to_xml(s="")
-			s << @prefix << "\n" if @prefix
-			super(s)
+		def write_to(out="")
+			out << @prefix << "\n" if @prefix
+			super
 		end
 	end
 
 	class Simple_ < Base_
-		def initialize(attributes=nil)
+		def initialize(attributes={})
 			super(self.class.name[/.*::(.*)/, 1].downcase.to_sym, attributes)
 		end
 	end
 
+	class PreserveSpace_ < Base_
+		def initialize(name={}, attributes={})
+			if name.is_a?(Hash)
+				super(self.class.name[/.*::(.*)/, 1].downcase.to_sym, name)
+			else
+				super(name, attributes)
+			end
+		end
+	end
+
 	class HEAD < Simple_; end
 	class META < Simple_; end
 	class LINK < Simple_; end
-	class STYLE < Simple_; end
-	class SCRIPT < Simple_; end
+	class IMG < Simple_; end
+	class STYLE < PreserveSpace_; end
+	class SCRIPT < PreserveSpace_; end
 	class TITLE < Simple_; end
 	class BODY < Simple_; end
-	class PRE < Simple_
-		def initialize(attributes=nil)
+	class PRE < PreserveSpace_; end
+	class FORM < Simple_
+		def initialize(attributes={})
+			if attributes
+				if s = attributes.delete(:session)
+					name = attributes.delete(:session_name) || "token"
+					require "digest/sha1"
+					token = s[name] ||= Digest::SHA1.hexdigest("#{$$}#{Time.now}#{rand}")
+				end
+			end
 			super
-			hold_space
+			add(HIDDEN.new(:name=>name, :value=>token)) if token
 		end
 	end
-	class FORM < Simple_; end
-	class H1 < Simple_; end
-	class H2 < Simple_; end
-	class H3 < Simple_; end
-	class H4 < Simple_; end
-	class H5 < Simple_; end
-	class H6 < Simple_; end
-	class P < Simple_; end
-	class A < Simple_; end
-	class EM < Simple_; end
-	class STRONG < Simple_; end
+	class H1 < PreserveSpace_; end
+	class H2 < PreserveSpace_; end
+	class H3 < PreserveSpace_; end
+	class H4 < PreserveSpace_; end
+	class H5 < PreserveSpace_; end
+	class H6 < PreserveSpace_; end
+	class P < PreserveSpace_; end
+	class A < PreserveSpace_; end
+	class EM < PreserveSpace_; end
+	class STRONG < PreserveSpace_; end
 	class DIV < Simple_; end
+	class SPAN < PreserveSpace_; end
 	class UL < Simple_; end
 	class OL < Simple_; end
-	class LI < Simple_; end
+	class LI < PreserveSpace_; end
 	class DL < Simple_; end
-	class DT < Simple_; end
-	class DD < Simple_; end
+	class DT < PreserveSpace_; end
+	class DD < PreserveSpace_; end
 	class TABLE < Simple_; end
-	class CAPTION < Simple_; end
+	class CAPTION < PreserveSpace_; end
 	class TR < Simple_; end
-	class TH < Simple_; end
-	class TD < Simple_; end
+	class TH < PreserveSpace_; end
+	class TD < PreserveSpace_; end
+	class BR < Simple_; end
+	class HR < Simple_; end
+	class SELECT < Simple_; end
+	class OPTION < Simple_; end
+
 
 	module Hn
-		def self.new(level, attr=nil, &proc)
+		def self.new(level, attr={}, &proc)
 			raise ArgumentError unless 1<=level && level<=6
 			klass = EimXML::XHTML.const_get("H#{level}")
 			klass.new(attr, &proc)
 		end
 	end
 
-	class TEXTAREA < Base_
-		def initialize(name, opt={})
-			super(:textarea, {:name=>name}.merge(opt))
+	class TEXTAREA < PreserveSpace_; end
+
+	class INPUT < Base_
+		def initialize(opt={})
+			super(:input, opt)
 		end
 	end
 
-	class INPUT < Base_
-		def initialize(type, name, value, opt={})
-			attr = {:type=>type}
-			attr[:name]=name if name
-			attr[:value]=value if value
-			super(:input, attr.merge(opt))
+	class BUTTON < PreserveSpace_
+		def initialize(opt={})
+			super(:button, opt)
 		end
 	end
 
-	class HIDDEN < INPUT
-		def initialize(name, value, opt={})
-			super(:hidden, name, value, opt)
+	class SUBMIT < BUTTON
+		def initialize(opt={})
+			super(opt.merge(:type=>:submit))
 		end
 	end
 
-	class SUBMIT < INPUT
+	class HIDDEN < INPUT
 		def initialize(opt={})
-			opt = opt.dup
-			super(:submit, opt.delete(:name), opt.delete(:value), opt)
+			super(opt.merge(:type=>:hidden))
 		end
 	end
 
 	class TEXT < INPUT
-		def initialize(name, value=nil, opt={})
-			super(:text, name, value, opt)
+		def initialize(opt={})
+			super(opt.merge(:type=>:text))
+		end
+	end
+
+	class PASSWORD < INPUT
+		def initialize(opt={})
+			super(opt.merge(:type=>:password))
+		end
+	end
+
+	class FILE < INPUT
+		def initialize(opt={})
+			super(opt.merge(:type=>:file))
 		end
 	end
 
-	constants.each do |c|
-		v = const_get(c)
-		if v.is_a?(Class) && /_$/ !~ v.name
-			DSL.register v
-			OpenDSL.register v
+	PRESERVE_SPACES = [PreserveSpace_]
+	class Formatter < EimXML::Formatter
+		def self.write(element, opt={})
+			EimXML::Formatter.write(element, opt.merge(:preservers=>PRESERVE_SPACES))
 		end
 	end
 end

data/lib/eim_xml/xhtml/dsl.rb

@@ -0,0 +1,18 @@
+require "eim_xml/dsl"
+require "eim_xml/xhtml"
+
+module EimXML::XHTML
+	class DSL < EimXML::BaseDSL
+	end
+
+	class OpenDSL < EimXML::OpenDSL
+	end
+
+	constants.each do |c|
+		v = const_get(c)
+		if v.is_a?(Class) && /_$/ !~ v.name
+			DSL.register v
+			OpenDSL.register v
+		end
+	end
+end