eim_xml 0.0.4 → 1.0.0

data/Rakefile.utirake

@@ -1,374 +0,0 @@
-# Utility for Rake
-#
-# Copyright (C) 2008, KURODA Hiraku <hiraku@hinet.mydns.jp>
-# You can redistribute it and/or modify it under GPL3.
-
-require "rake/clean"
-require "rake/testtask"
-require "rdoc/task"
-require "rake/contrib/rubyforgepublisher"
-require "rubygems/package_task"
-
-class UtiRake
-	include Rake::DSL
-
-	def self.setup(opt={}, &proc)
-		ur = new
-		ur.setup(opt, &proc)
-	rescue
-		puts $!.class, $!.message, $!.backtrace
-	end
-
-	attr_reader :opt, :spec_proc, :cucumber_proc, :rdoc_proc, :gemspec_proc, :package_proc, :rcov_spec_proc
-
-	def setup(opt={}, &proc)
-		@opt = opt
-		directory "external"
-		CLEAN << "coverage" << "coverage.spec" << "coverage.cuke" << "doc"
-		CLOBBER << "external"
-
-		instance_eval(&proc) if proc
-
-		if need_spec?
-			begin
-				@rspec2_flg = false
-				require "rspec/core/rake_task"
-				@rspec2_flg = true
-			rescue LoadError
-				require "spec/rake/spectask"
-			end
-			define_spec_task
-		end
-
-		if need_cucumber?
-			require "cucumber/rake/task"
-			define_cucumber_task
-		end
-
-		define_rdoc_task
-		define_rcov_task
-		define_package_task
-		define_here_dependency
-		define_alias_task if @alias_task
-	end
-
-	def rspec2?; @rspec2_flg; end
-
-	def spec_task
-		rspec2? ? RSpec::Core::RakeTask : Spec::Rake::SpecTask
-	end
-
-	def need_spec?
-		File.directory?("spec")
-	end
-
-	def need_cucumber?
-		File.directory?("features")
-	end
-
-	def spec(&proc)
-		@spec_proc = proc
-	end
-
-	def cucumber(&proc)
-		@cucumber_proc = proc
-	end
-
-	def rdoc(&proc)
-		@rdoc_proc = proc
-	end
-
-	def gemspec(&proc)
-		@gemspec_proc = proc
-	end
-
-	def rcov_spec(&proc)
-		@rcov_spec_proc = proc
-	end
-
-	def package(&proc)
-		@package_proc = proc
-	end
-
-	def no_here(task)
-		@no_here_task = task
-	end
-
-	def no_here_task
-		@no_here_task || "spec:lump"
-	end
-
-	def alias_task
-		@alias_task = true
-	end
-
-	def hg(cmd)
-		sh "hg #{cmd.to_s}"
-	end
-
-	def external(base_url, *libs)
-		libs = libs.first if libs.first.is_a?(Array)
-		namespace :external do
-			directory "external/lib"
-			libs.each do |lib|
-				libdir = "external/#{lib}"
-				file libdir => "external/lib" do
-					if File.exist?("../#{lib}")
-						Dir.chdir("external") do
-							ln_s "../../#{lib}", "./", :force=>true
-						end
-					end
-					hg "clone #{File.join(base_url, lib)} #{libdir}" unless File.exist?(libdir)
-					Dir["#{libdir}/lib/*"].each do |f|
-						base = File.basename(f)
-						cd "external/lib" do
-							ln_s "../#{lib}/lib/#{base}", "./"
-						end
-					end
-				end
-
-				if File.exist?(libdir)
-					Dir["#{libdir}/lib/*"].each do |f|
-						base = File.basename(f)
-						file "external/lib/#{base}" => "external/lib" do
-							cd "external/lib" do
-								ln_s "../#{lib}/lib/#{base}", "./"
-							end
-						end
-						task :setup => "external/lib/#{base}"
-					end
-				end
-
-				desc "Setup external libraries"
-				task :setup=>libdir
-			end
-
-			task :rake => :setup do
-				libs.each do |lib|
-					Dir.chdir "external/#{lib}" do
-						sh "rake"
-					end
-				end
-			end
-		end
-		@external = true
-	end
-
-	def external?; @external; end
-
-	def define_rdoc_task
-		Rake::RDocTask.new(:rdoc) do |rdoc|
-			rdoc.options << "-S"
-			rdoc.options << "-w" << "3"
-			rdoc.options << "-c" << "UTF-8"
-			rdoc.rdoc_files.include("lib/**/*.rb")
-			rdoc_proc.call(rdoc) if rdoc_proc
-		end
-		task :doc do
-			remove_entry_secure "doc" if File.directory?("doc")
-			sh "rdoc -S -w 3 -c UTF-8 -d -x external"
-		end
-	end
-
-	def define_package_task
-		spec = Gem::Specification.new do |s|
-			s.platform = Gem::Platform::RUBY
-			s.files = FileList["Rakefile*", "lib/**/*", "spec/**/*"]
-			s.version = "0.0.0.noversion"
-			gemspec_proc.call(s) if gemspec_proc
-		end
-
-		gem = Gem::PackageTask.new(spec) do |t|
-			t.need_tar_gz = true
-			package_proc.call(t) if package_proc
-		end
-
-		task "utirake:copy_for_package" do
-			mv "Rakefile.utirake", "Rakefile.utirake_#{$$}"
-			cp "external/utirake/utirake.rb", "Rakefile.utirake"
-		end
-
-		file gem.package_dir_path => "utirake:copy_for_package"
-
-		task :gem do
-			rm "Rakefile.utirake"
-			mv "Rakefile.utirake_#{$$}", "Rakefile.utirake"
-		end
-	end
-
-	def publish(project_name, user_id)
-		task :publish => "rdoc" do
-			yield if block_given?
-			Rake::RubyForgePublisher.new(project_name, user_id).upload
-		end
-	end
-
-	FILE_SORT = lambda{|a, b| File.mtime(a)<=>File.mtime(b)}
-
-	def spec_files
-		@spec_files ||= FileList["./spec/**/*_spec.rb"].sort(&FILE_SORT).reverse
-	end
-
-	def set_spec_opts(spec)
-		spec.verbose = false
-		if rspec2?
-			spec.rspec_opts ||= []
-			spec.rspec_opts << "-c"
-			spec.rspec_opts << "-I" << "." << "-I" << "./lib" << "-I" << "./external/lib"
-		else
-			spec.spec_opts << "-c"
-			spec.libs << "." << "./lib" << "./external/lib"
-		end
-	end
-
-	def define_spec_task
-		task :spec => "spec:apart"
-		namespace :spec do
-			spec_files.each do |f|
-				desc ""
-				spec_task.new(:apart) do |s|
-					if rspec2?
-						s.pattern = f
-					else
-						s.spec_files = FileList[f]
-					end
-					set_spec_opts(s)
-					spec_proc.call(s) if spec_proc
-				end
-			end
-			task(:apart).comment = "Run all specs separately"
-
-			desc "Run all specs in a lump"
-			spec_task.new(:lump) do |s|
-				s.spec_files = spec_files unless rspec2?
-				set_spec_opts(s)
-				spec_proc.call(s) if spec_proc
-			end
-
-			desc "Run all specs to profile"
-			spec_task.new(:profile) do |s|
-				set_spec_opts(s)
-				if rspec2?
-					s.rspec_opts << "-p"
-				else
-					s.spec_opts << "-f" << "profile"
-				end
-			end
-
-			`grep -sRn '#[[:space:]]*here\\([[:space:]]\\|$\\)' --include='*.rb' spec`.split(/\n/).map{|l|
-				next nil unless l=~/\A(.*?):(\d+):/
-				[$1, $2.to_i]
-			}.compact.sort{|a, b| FILE_SORT.call(a[0], b[0])}.reverse.each do |file, line|
-				desc ""
-				spec_task.new(:here) do |s|
-					set_spec_opts(s)
-					if rspec2?
-						s.pattern = file
-						s.rspec_opts << "-l#{line}"
-					else
-						s.spec_files = [file]
-						s.spec_opts << "-l#{line}"
-					end
-					spec_proc.call(s) if spec_proc
-				end
-			end
-			task :no_here => no_here_task
-		end
-	end
-
-	def set_cucumber_opts(task)
-		task.libs << "."
-		cucumber_proc.call(task) if cucumber_proc
-	end
-
-	def define_cucumber_task
-		Cucumber::Rake::Task.new do |t|
-			set_cucumber_opts(t)
-		end
-
-		unless `grep -sRn '^[[:space:]]*@here$' features`.empty?
-			Cucumber::Rake::Task.new("cucumber:here") do |t|
-				t.cucumber_opts = %w[--tags @here]
-				set_cucumber_opts(t)
-			end
-		end
-		task "cucumber:no_here" => :cucumber
-	end
-
-	def define_here_dependency
-		unless Rake::Task.task_defined?("spec:here") || Rake::Task.task_defined?("cucumber:here")
-			task "spec:here" => "spec:no_here" if need_spec? && !Rake::Task.task_defined?("spec:here")
-			task "cucumber:here" => "cucumber:no_here" if need_cucumber? && !Rake::Task.task_defined?("cucumber:here")
-		end
-
-		task("spec:here").comment = "Run spec only marked '# here'"
-		task("cucumber:here").comment = "only tagged '@here'"
-	end
-
-	def rcov_opts(t, aggregation)
-		t.rcov_opts ||= []
-		t.rcov_opts << "-I" << "./spec:./lib:./external/lib"
-		t.rcov_opts << "--exclude" << "gems\/,features\/,external\/"
-		t.rcov_opts << "--aggregate" << "coverage.data" if aggregation
-		t.rcov = true
-	end
-
-	def define_rcov_each_task(aggregation)
-		if need_spec?
-			spec_task.new do |t|
-				t.verbose = false
-				rcov_opts(t, aggregation)
-				if rspec2?
-					t.rcov_opts << "-o" << "coverage.spec" unless aggregation
-				else
-					set_spec_opts(t)
-					t.spec_files = spec_files
-					t.rcov_dir = "coverage.spec" unless aggregation
-				end
-				rcov_spec_proc.call(t) if rcov_spec_proc
-			end
-		else
-			task "spec"
-		end
-
-		if need_cucumber?
-			Cucumber::Rake::Task.new do |t|
-				set_cucumber_opts(t)
-				rcov_opts(t, aggregation)
-				t.rcov_opts << "-o" << "coverage.cuke" unless aggregation
-			end
-		else
-			task "cucumber"
-		end
-	end
-
-	def define_rcov_task
-		namespace :rcov do
-			define_rcov_each_task(false)
-		end
-
-		desc "Run specs and Cucumber using RCov"
-		task "rcov:lump" do
-			rm "coverage.data" if File.exist?("coverage.data")
-			ns = namespace do
-				define_rcov_each_task(true)
-			end
-			ns.tasks.each do |t|
-				t.invoke
-			end
-			rm "coverage.data"
-		end
-
-		task "rcov:all" => %w[rcov:spec rcov:cucumber rcov:lump]
-	end
-
-	def define_alias_task
-		if Rake::Task.task_defined?("spec:apart")
-			task :apart => "spec:apart"
-			task :lump => "spec:lump"
-			task :here => "spec:here"
-			task :profile => "spec:profile"
-		end
-		task :here => "cucumber:here" if Rake::Task.task_defined?("cucumber:here")
-	end
-end

data/spec/assertions_test.rb

@@ -1,30 +0,0 @@
-# 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.
-
-$:.unshift "#{File.dirname(File.dirname(File.expand_path(__FILE__)))}/lib"
-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

@@ -1,217 +0,0 @@
-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