eimxml 0.0.2 → 0.0.3.1

data/lib/eim_xml.rb

@@ -4,99 +4,21 @@
 # You can redistribute it and/or modify it under GPL2.
 #
 
+warn "*"*60 << "\n" << <<EOT << "*"*60
+[DEPRECATION]
+"eimxml" gem is deprecated.
+Please use "eim_xml" gem instead.
+EOT
+
 module EimXML
 	XML_DECLARATION = %[<?xml version="1.0"?>]
 
-	class BaseDSL
-		def initialize
-			@container = nil
-			yield(self) if block_given?
-		end
-
-		def add(v)
-			@container.add(v)
-		end
-		alias << add
-
-		def self.register(*args)
-			args.each do |klass, name|
-				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
-				l = __LINE__+1
-				src = "def #{name}(*arg, &proc)\n" <<
-					"e = #{klass}.new(*arg)\n" <<
-					"@container << e if @container\n" <<
-					"if proc\n" <<
-					"oc = @container\n" <<
-					"@container = e\n" <<
-					"begin\n" <<
-					"instance_eval(&proc)\n" <<
-					"ensure\n" <<
-					"@container = oc\n" <<
-					"end\n" <<
-					"end\n" <<
-					"e\n" <<
-					"end"
-				eval(src, binding, __FILE__, l)
-
-				l = __LINE__+1
-				src = "def self.#{name}(*arg, &proc)\n" <<
-					"new.#{name}(*arg, &proc)\n" <<
-					"end"
-				eval(src, binding, __FILE__, l)
-			end
-		end
-	end
-
-	class DSL < BaseDSL
-	end
-
-	class OpenDSL
-		def self.register_base(dsl, binding, *args)
-			args.each do |klass, name|
-				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
-				src = "def #{name}(*arg)\n" <<
-					"e=#{klass}.new(*arg)\n" <<
-					"oc=@container\n" <<
-					"oc << e if oc.is_a?(Element)\n" <<
-					"@container = e\n" <<
-					"begin\n" <<
-					"yield(self) if block_given?\n" <<
-					"e\n" <<
-					"ensure\n" <<
-					"@container = oc\n" <<
-					"end\n" <<
-					"end\n"
-				eval(src, binding, __FILE__, __LINE__-12)
-
-				src = "def self.#{name}(*arg, &proc)\n" <<
-					"self.new.#{name}(*arg, &proc)\n" <<
-					"end"
-				eval(src, binding, __FILE__, __LINE__-3)
-			end
-		end
-
-		def self.register(*args)
-			register_base(self, binding, *args)
-		end
-
-		attr_reader :container
-		def initialize
-			@container = nil
-			yield(self) if block_given?
-		end
-
-		def add(v)
-			@container.add(v)
-		end
-		alias :<< :add
-	end
-
 	class PCString
-		attr_reader :encoded_string
+		attr_reader :encoded_string, :src
 		alias to_s encoded_string
 
 		def self.encode(s)
-			s.gsub(/[&\"\'<>]/) do |m|
+			s.to_s.gsub(/[&\"\'<>]/) do |m|
 				case m
 				when "&"
 					"&amp;"
@@ -112,46 +34,33 @@ module EimXML
 			end
 		end
 
+		def self.[](obj)
+			obj.is_a?(PCString) ? obj : PCString.new(obj)
+		end
+
 		def initialize(s, encoded=false)
+			@src = s
 			@encoded_string = encoded ? s : PCString.encode(s)
 		end
 
 		def ==(other)
-			other.is_a?(PCString) ? @encoded_string==other.encoded_string : false
+			other.is_a?(PCString) ? @encoded_string==other.encoded_string : self==PCString.new(other)
 		end
 
-		def to_xml(dst=String.new)
-			dst << encoded_string
+		def write_to(out="")
+			out << encoded_string
 		end
 	end
 
-	class SymbolKeyHash < Hash
-		def initialize(src=nil)
-			case src
-			when self.class
-				super(src)
-			when Hash
-				src.each_key do |k|
-					store(k, src[k])
-				end
-			end
-		end
-
-		def update(src)
-			src = self.class.new(src) unless src.is_a?(self.class)
-			super(src)
-		end
-		alias :merge! :update
-
-		def merge(src)
-			super(self.class.new(src))
+	class Comment
+		def initialize(text)
+			raise ArgumentError, "Can not include '--'" if text =~ /--/
+			@text = text
 		end
 
-		def store(k, v)
-			super(k.to_sym, v)
+		def write_to(out="")
+			out << "<!-- #{@text} -->"
 		end
-
-		alias :[]= :store
 	end
 
 	class Element
@@ -159,13 +68,14 @@ module EimXML
 
 		NEST = " "
 
-		def initialize(name, attributes=nil)
+		def initialize(name, attributes={})
 			@name = name.to_sym
-			@attributes = SymbolKeyHash.new
+			@attributes = Hash.new
 			@contents = Array.new
-			@hold_space = false
 
-			@attributes.update(attributes) if attributes
+			attributes.each do |k, v|
+				@attributes[k.to_sym] = v
+			end
 
 			yield(self) if block_given?
 		end
@@ -175,20 +85,6 @@ module EimXML
 		end
 		protected :name=
 
-		def hold_space
-			@hold_space = true
-			self
-		end
-
-		def unhold_space
-			@hold_space = false
-			self
-		end
-
-		def hold_space?
-			@hold_space
-		end
-
 		def add(v)
 			case v
 			when nil
@@ -201,58 +97,42 @@ module EimXML
 		end
 		alias << add
 
-		def to_xml_with_indent(dst=String.new, nest_level=0, is_head=true)
-			nest_level = -1 if @hold_space
-			hold_space = @hold_space || (nest_level<0)
-			nest = nest_level<0 ? "" : NEST*nest_level
-			head = is_head ? nest : ""
-			lf = hold_space ? "" : "\n"
-
-			attributes = ""
+		def name_and_attributes(out="")
+			out << "#{@name}"
 			@attributes.each do |k, v|
-				v = k.to_s unless v
-				attributes << " #{k}='#{PCString===v ? v : PCString.encode(v.to_s)}'"
-			end
-
-			case @contents.size
-			when 0
-				dst << "#{head}<#{@name}#{attributes} />"
-			when 1
-				dst << "#{head}<#{@name}#{attributes}>"
-				content_to_xml(dst, @contents[0], nest_level, false)
-				dst << "</#{@name}>"
-			else
-				dst << "#{head}<#{@name}#{attributes}>#{lf}"
-				@contents.each {|i| content_to_xml(dst, i, nest_level<0 ? -1 : nest_level+1, !hold_space) << lf}
-				dst << "#{@hold_space ? "" : nest}</#{@name}>"
+				next unless v
+				out << " #{k}='#{PCString===v ? v : PCString.encode(v.to_s)}'"
 			end
 		end
 
-		def to_xml(dst=String.new)
-			to_xml_with_indent(dst)
-		end
+		def write_to(out = "")
+			out << "<"
+			name_and_attributes(out)
 
-		def to_s
-			to_xml
-		end
-		alias :inspect :to_s
-
-		def content_to_xml(dst, c, nest_level, is_head)
-			case
-			when c.respond_to?(:to_xml_with_indent)
-				c.to_xml_with_indent(dst, nest_level, is_head)
-			when c.respond_to?(:to_xml)
-				dst << (is_head && nest_level>=0 ? NEST*nest_level : "")
-				c.to_xml(dst)
+			if @contents.empty?
+				out << " />"
 			else
-				dst << (is_head && nest_level>=0 ? NEST*nest_level : "") << PCString.encode(c.to_s)
+				out << ">"
+				@contents.each do |c|
+					case c
+					when Element
+						c.write_to(out)
+					when PCString
+						out << c.to_s
+					else
+						out << PCString.encode(c.to_s)
+					end
+				end
+				out << "</#{@name}>"
 			end
+			out
 		end
-		private :content_to_xml
+		alias :to_s :write_to
+		alias :inspect :to_s
 
 		def ==(xml)
 			return false unless xml.is_a?(Element)
-			(@name==xml.name && @attributes==xml.attributes && @contents==xml.contents && @hold_space==xml.hold_space?)
+			@name==xml.name && @attributes==xml.attributes && @contents==xml.contents
 		end
 
 		def add_attribute(key, value)
@@ -272,70 +152,65 @@ module EimXML
 			@attributes.delete(key.to_sym)
 		end
 
-		def match?(name, attrs=nil)
-			case name
-			when Module
-				return is_a?(name)
-			when Element
-				return match?(name.name, name.attributes)
-			when Array
-				return match?(name[0], name[1])
-			end
+		def pcstring_contents
+			@contents.select{|c| c.is_a?(String)||c.is_a?(PCString)}.map{|c| c.is_a?(String) ? PCString.new(c) : c}
+		end
 
-			if name.is_a?(Regexp)
-				return false unless name=~@name.to_s
-			else
-				return false unless @name==name
-			end
+		def match(obj, attr=nil)
+			return match(Element.new(obj, attr)) if attr
+			return obj=~@name.to_s if obj.is_a?(Regexp)
+			return @name==obj if obj.is_a?(Symbol)
+			return is_a?(obj) if obj.is_a?(Module)
 
-			(attrs||[]).all? do |k, v|
-				if k.is_a?(Regexp)
-					@attributes.any? do |sk, sv|
-						next false unless k===sk.to_s
-						v===sv
-					end
-				else
-					ak = @attributes[k]
-					if (ak.is_a?(String) or ak.is_a?(Symbol)) and (v.is_a?(String) or v.is_a?(Symbol))
-						ak.to_s == v.to_s
-					else
-						v===@attributes[k]
-					end
-				end
+			raise ArgumentError unless obj.is_a?(Element)
+
+			return false unless @name==obj.name
+
+			obj.attributes.all? do |k, v|
+				(v.nil? && !@attributes.include?(k)) ||
+					(@attributes.include?(k) && (v.is_a?(Regexp) ? v =~ @attributes[k] : PCString[v] == PCString[@attributes[k]]))
+			end and obj.contents.all? do |i|
+				case i
+				when Element
+					has_element?(i)
+				when String
+					pcstring_contents.include?(PCString.new(i))
+				when PCString
+					pcstring_contents.include?(i)
+				when Regexp
+					@contents.any?{|c| c.is_a?(String) and i=~c}
+				end					
 			end
 		end
-		alias :=~ :match?
+		alias :=~ :match
+
+		def has?(obj, attr=nil)
+			return has?(Element.new(obj, attr)) if attr
 
-		def has?(name, attrs=nil, find_deep=true)
-			return true if match?(name, attrs)
 			@contents.any? do |i|
 				if i.is_a?(Element)
-					if find_deep
-						i=~[name, attrs] || i.has?(name, attrs, find_deep)
-					else
-						i=~[name, attrs]
-					end
+					i.match(obj) || i.has?(obj)
 				else
-					name.is_a?(Module) && i.is_a?(name)
+					obj.is_a?(Module) && i.is_a?(obj)
 				end
 			end
 		end
 		alias has_element? has?
+		alias include? has?
 
-		def find(name, attrs=nil)
-			r = []
-			r << self if match?(name, attrs)
+		def find(obj, dst=Element.new(:found))
+			return find(Element.new(obj, dst)) if dst.is_a?(Hash)
+
+			dst << self if match(obj)
 			@contents.each do |i|
-				if i.is_a?(Element)
-					r.concat(i.find(name, attrs))
-				else
-					r << i if name.is_a?(Module) && i.is_a?(name)
+				case
+				when i.is_a?(Element)
+					i.find(obj, dst)
+				when obj.is_a?(Module) && i.is_a?(obj)
+					dst << i
 				end
 			end
-			r
+			dst
 		end
 	end
-
-	DSL.register Element
-	OpenDSL.register Element
 end

data/lib/eim_xml/dsl.rb

@@ -0,0 +1,105 @@
+# Easy IMplementation of XML
+#
+# Copyright (C) 2006,2008, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+#
+
+require "eim_xml"
+
+module EimXML
+	class BaseDSL
+		def add(v)
+			@_container << v
+		end
+		alias << add
+
+		def import_variables(src)
+			src.instance_variables.each do |v|
+				instance_variable_set(v, src.instance_variable_get(v)) unless v=~/\A@_[^_]/
+			end
+			self
+		end
+
+		def _build(klass, *arg, &proc)
+			e = klass.new(*arg)
+			@_container << e if @_container
+			if proc
+				oc = @_container
+				@_container = e
+				begin
+					instance_eval(&proc)
+				ensure
+					@_container = oc
+				end
+			end
+			e
+		end
+		private :_build
+
+		def _push(container)
+			oc = @_container
+			@_container = container
+			begin
+				yield if block_given?
+				container
+			ensure
+				@_container = oc
+			end
+		end
+		private :_push
+
+		def self.register(*args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				eval("def #{name}(*a, &p);_build(#{klass}, *a, &p);end", binding)
+				eval("def self.#{name}(*a, &p);new.#{name}(*a, &p);end", binding)
+			end
+		end
+	end
+
+	class DSL < BaseDSL
+	end
+
+	class OpenDSL
+		def _build(klass, *arg, &proc)
+			e = klass.new(*arg)
+			oc = @_container
+			oc << e if oc.is_a?(Element)
+			@_container = e
+			begin
+				proc.call(self) if proc
+				e
+			ensure
+				@_container = oc
+			end
+		end
+		private :_build
+
+		def self.register_base(dsl, binding, *args)
+			args.each do |klass, name|
+				name ||= klass.name.downcase[/(?:.*\:\:)?(.*)$/, 1]
+				eval("def #{name}(*a, &p);_build(#{klass}, *a, &p);end", binding)
+				eval("def self.#{name}(*a, &p);self.new.#{name}(*a, &p);end", binding)
+			end
+		end
+
+		def self.register(*args)
+			register_base(self, binding, *args)
+		end
+
+		def initialize
+			@_container = nil
+			yield(self) if block_given?
+		end
+
+		def add(v)
+			@_container.add(v)
+		end
+		alias :<< :add
+
+		def container; @_container; end
+	end
+
+	DSL.register Element, Comment
+	OpenDSL.register Element, Comment
+end