RubyGems - eim_xml - Versions diffs - 0.0.3 - Mend

eim_xml 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

data/lib/eim_xml/xhtml.rb ADDED Viewed

@@ -0,0 +1,135 @@
+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 Base_ < EimXML::Element
+	end
+	class HTML < Base_
+		attr_accessor :prefix
+		module NameSpace
+			XHTML = "http://www.w3.org/1999/xhtml"
+		end
+		def initialize(attributes={})
+			super(:html, attributes)
+		end
+		def write_to(out="")
+			out << @prefix << "\n" if @prefix
+			super
+		end
+	end
+	class Simple_ < Base_
+		def initialize(attributes={})
+			super(self.class.name[/.*::(.*)/, 1].downcase.to_sym, attributes)
+		end
+	end
+	class PreserveSpace_ < Simple_; end
+	class HEAD < Simple_; end
+	class META < Simple_; end
+	class LINK < Simple_; end
+	class STYLE < PreserveSpace_; end
+	class SCRIPT < PreserveSpace_; end
+	class TITLE < Simple_; end
+	class BODY < Simple_; end
+	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
+			add(HIDDEN.new(:name=>name, :value=>token)) if token
+		end
+	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 < PreserveSpace_; end
+	class DL < Simple_; end
+	class DT < PreserveSpace_; end
+	class DD < PreserveSpace_; end
+	class TABLE < Simple_; end
+	class CAPTION < PreserveSpace_; end
+	class TR < Simple_; end
+	class TH < PreserveSpace_; end
+	class TD < PreserveSpace_; end
+	class BR < Simple_; end
+	class HR < Simple_; end
+	module Hn
+		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 < PreserveSpace_; end
+	class INPUT < Base_
+		def initialize(opt={})
+			super(:input, opt)
+		end
+	end
+	class BUTTON < Base_
+		def initialize(opt={})
+			super(:button, opt)
+		end
+	end
+	class SUBMIT < BUTTON
+		def initialize(opt={})
+			super(opt.merge(:type=>:submit))
+		end
+	end
+	class HIDDEN < INPUT
+		def initialize(opt={})
+			super(opt.merge(:type=>:hidden))
+		end
+	end
+	class TEXT < INPUT
+		def initialize(opt={})
+			super(opt.merge(:type=>:text))
+		end
+	end
+	class PASSWORD < INPUT
+		def initialize(opt={})
+			super(opt.merge(:type=>:password))
+		end
+	end
+	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.rb ADDED Viewed

@@ -0,0 +1,210 @@
+# Easy IMplementation of XML
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+#
+module EimXML
+	XML_DECLARATION = %[<?xml version="1.0"?>]
+	class PCString
+		attr_reader :encoded_string, :src
+		alias to_s encoded_string
+		def self.encode(s)
+			s.to_s.gsub(/[&\"\'<>]/) do |m|
+				case m
+				when "&"
+					"&amp;"
+				when '"'
+					"&quot;"
+				when "'"
+					"&apos;"
+				when "<"
+					"&lt;"
+				when ">"
+					"&gt;"
+				end
+			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 : self==PCString.new(other)
+		end
+		def write_to(out="")
+			out << encoded_string
+		end
+	end
+	class Comment
+		def initialize(text)
+			raise ArgumentError, "Can not include '--'" if text =~ /--/
+			@text = text
+		end
+		def write_to(out="")
+			out << "<!-- #{@text} -->"
+		end
+	end
+	class Element
+		attr_reader :name, :attributes, :contents
+		NEST = " "
+		def initialize(name, attributes={})
+			@name = name.to_sym
+			@attributes = Hash.new
+			@contents = Array.new
+			attributes.each do |k, v|
+				@attributes[k.to_sym] = v
+			end
+			yield(self) if block_given?
+		end
+		def name=(new_name)
+			@name = new_name.to_sym
+		end
+		protected :name=
+		def add(v)
+			case v
+			when nil
+			when Array
+				v.each{|i| self.add(i)}
+			else
+				@contents << v
+			end
+			self
+		end
+		alias << add
+		def name_and_attributes(out="")
+			out << "#{@name}"
+			@attributes.each do |k, v|
+				next unless v
+				out << " #{k}='#{PCString===v ? v : PCString.encode(v.to_s)}'"
+			end
+		end
+		def write_to(out = "")
+			out << "<"
+			name_and_attributes(out)
+			if @contents.empty?
+				out << " />"
+			else
+				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
+		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
+		end
+		def add_attribute(key, value)
+			@attributes[key.to_sym] = value
+		end
+		alias []= add_attribute
+		def [](key)
+			if key.is_a?(Fixnum)
+				@contents[key]
+			else
+				@attributes[key.to_sym]
+			end
+		end
+		def del_attribute(key)
+			@attributes.delete(key.to_sym)
+		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
+		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)
+			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
+		def has?(obj, attr=nil)
+			return has?(Element.new(obj, attr)) if attr
+			@contents.any? do |i|
+				if i.is_a?(Element)
+					i.match(obj) || i.has?(obj)
+				else
+					obj.is_a?(Module) && i.is_a?(obj)
+				end
+			end
+		end
+		alias has_element? has?
+		alias include? has?
+		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|
+				case
+				when i.is_a?(Element)
+					i.find(obj, dst)
+				when obj.is_a?(Module) && i.is_a?(obj)
+					dst << i
+				end
+			end
+			dst
+		end
+	end
+end

data/spec/assertions_spec.rb ADDED Viewed

@@ -0,0 +1,29 @@
+# Test for eim_xml/assertions.rb
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+require "test/unit"
+require "eim_xml/assertions"
+class EimXMLAssertionsTest < Test::Unit::TestCase
+	include EimXML
+	include EimXML::Assertions
+	def test_assert_has
+		e = Element.new(:tag) do |e|
+			e <<= Element.new(:sub)
+		end
+		assert_nothing_raised do
+			assert_has(:sub, e)
+		end
+		a = assert_raises(Test::Unit::AssertionFailedError) do
+			assert_has(:no, e)
+		end
+		assert(!a.backtrace.any?{ |i|
+				i=~/eim_xml\/assertions\.rb/
+			})
+	end
+end

data/spec/dsl_spec.rb ADDED Viewed

@@ -0,0 +1,217 @@
+require "eim_xml/dsl"
+module Module.new::M
+	include EimXML
+	EDSL = EimXML::DSL
+	describe EimXML::DSL do
+		it "scope is in instance of DSL" do
+			outer = inner = nil
+			e3 = e2 = nil
+			block_executed = false
+			e = EDSL.element(:out, :k1=>"v1") do
+				outer = self
+				e2 = element(:in, :k2=>"v2") do
+					block_executed = true
+					inner = self
+					e3 = element(:deep)
+				end
+			end
+			block_executed.should == true
+			outer.should be_kind_of(EDSL)
+			inner.should be_kind_of(EDSL)
+			outer.should be_equal(inner)
+			e.name.should == :out
+			e[:k1].should == "v1"
+			e[0].name.should == :in
+			e[0][:k2].should == "v2"
+			e[0][0].name.should == :deep
+			e2.should be_equal(e[0])
+			e3.should be_equal(e[0][0])
+		end
+		it "#comment" do
+			Comment.should_receive(:new).with("comment").and_return(:success)
+			EDSL.comment("comment").should == :success
+		end
+		it "#import_variables" do
+			d = EDSL.new
+			o = Object.new
+			o.instance_variable_set("@v1", 1)
+			o.instance_variable_set("@v2", "2")
+			o.instance_variable_set("@_v3", :t)
+			o.instance_variable_set("@__v4", 4)
+			o.instance_variable_set("@_container", :t)
+			orig_c = d.instance_variable_get("@_container")
+			d.import_variables(o).should be_equal(d)
+			d.instance_variable_get("@_container").should == orig_c
+			d.instance_variables.map(&:to_s).sort.should == ["@v1", "@v2", "@__v4"].sort
+			d.instance_variable_get("@v1").should == 1
+			d.instance_variable_get("@v2").should == "2"
+			d.instance_variable_get("@__v4").should == 4
+		end
+		describe "#_push" do
+			before do
+				m = Module.new
+				class m::D < EimXML::DSL
+					def call_push(c)
+						_push(c) do
+							element(:e)
+						end
+					end
+					def exec
+						element(:e) do
+							element(:f)
+						end
+					end
+				end
+				@D = m::D
+			end
+			it "should return given container" do
+				a = []
+				@D.new.call_push(a).should be_equal(a)
+				a.should == [EimXML::Element.new(:e)]
+				@D.new.exec.should == EimXML::Element.new(:e).add(EimXML::Element.new(:f))
+			end
+		end
+	end
+	describe "Subclass of BaseDSL" do
+		class DSL1 < EimXML::BaseDSL
+			register([EimXML::Element, "call"])
+			register(Hash)
+			register(String, Array, Object)
+		end
+		it "register" do
+			lambda{EDSL.call(:dummy)}.should raise_error(NoMethodError)
+			lambda{BaseDSL.call(:dummy)}.should raise_error(NoMethodError)
+			lambda{DSL1.element(:dummy)}.should raise_error(NoMethodError)
+			DSL1.call(:dummy).should be_kind_of(Element)
+			DSL1.hash.should be_kind_of(Hash)
+			DSL1.string.should be_kind_of(String)
+			DSL1.array.should be_kind_of(Array)
+			DSL1.object.should be_kind_of(Object)
+		end
+	end
+	describe EimXML::OpenDSL do
+		it "scope of block is one of outside" do
+			@scope_checker_variable = 1
+			block_executed = false
+			d = OpenDSL.new do |d|
+				block_executed = true
+				d.should be_kind_of(OpenDSL)
+				d.container.should be_nil
+				d.element(:base, :key1=>"v1") do
+					@scope_checker_variable.should == 1
+					self.should_not be_kind_of(Element)
+					d.container.should be_kind_of(Element)
+					d.container.should == Element.new(:base, :key1=>"v1")
+					d.element(:sub, :key2=>"v2") do
+						d.container.should be_kind_of(Element)
+						d.container.should == Element.new(:sub, :key2=>"v2")
+					end
+					d.element(:sub2).should == Element.new(:sub2)
+				end
+			end
+			block_executed.should be_true
+		end
+		it "DSL methods return element" do
+			d = OpenDSL.new
+			d.container.should be_nil
+			r = d.element(:base, :key1=>"v1") do
+				d.element(:sub, :key2=>"v2")
+			end
+			r.should == EDSL.element(:base, :key1=>"v1") do
+				element(:sub, :key2=>"v2")
+			end
+		end
+		it "DSL method's block given instance of OpenDSL" do
+			e = OpenDSL.new.element(:base) do |d|
+				d.should be_kind_of(OpenDSL)
+				d.container.name.should == :base
+				d.element(:sub) do |d2|
+					d2.should be_equal(d)
+				end
+			end
+			e.should == EDSL.element(:base) do
+				element(:sub)
+			end
+		end
+		it "ensure reset container when error raised" do
+			OpenDSL.new do |d|
+				begin
+					d.element(:base) do
+						begin
+							d.element(:sub) do
+								raise "OK"
+							end
+						rescue RuntimeError => e
+							raise unless e.message=="OK"
+							d.container.name.should == :base
+							raise
+						end
+					end
+				rescue RuntimeError => e
+					raise unless e.message=="OK"
+					d.container.should == nil
+				end
+			end
+		end
+		it "respond to add" do
+			r = OpenDSL.new.element(:base) do |d|
+				d.add "text"
+				d.element(:sub) do
+					s = Element.new(:sub)
+					s.add("sub text")
+					d.add("sub text").should == s
+				end
+			end
+			r.should == EDSL.element(:base) do
+				add "text"
+				element(:sub) do
+					add "sub text"
+				end
+			end
+		end
+		it "respond to <<" do
+			r = OpenDSL.new.element(:base) do |d|
+				b = Element.new(:base)
+				b << "text" << "next"
+				(d << "text" << "next").should == b
+			end
+			r.should == EDSL.element(:base) do
+				add "text"
+				add "next"
+			end
+		end
+		it "can call directly element method" do
+			r = OpenDSL.element(:base) do |d|
+				d.element(:sub)
+				d.element(:sub2)
+			end
+			r.should == EDSL.element(:base) do
+				element(:sub)
+				element(:sub2)
+			end
+		end
+	end
+end