ontomde-core 1.0.2

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-10-27
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,37 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/ontomde-core
+lib/ontomde-core.rb
+lib/ontomde-core/version.rb
+lib/ontomde-core/context.rb
+lib/ontomde-core/loader.rb
+lib/ontomde-core/bootstrap_rdfs.rb
+lib/ontomde-core/delayed.rb
+lib/ontomde-core/profil.rb
+lib/ontomde-core/resource.rb
+lib/ontomde-core/helper.rb
+lib/ontomde-core/meta.rb
+lib/ontomde-core/exceptions.rb
+lib/ontomde-core/demoInstaller.rb
+lib/ontomde-core/customERB.rb
+lib/ontomde-core/triplet.rb
+lib/ontomde-core/log.rb
+lib/ontomde-core/fileTypes.rb
+lib/ontomde-core/fileLoader.rb
+lib/ontomde-core/custom_method_missing.rb
+lib/ontomde-core/resourceSet.rb
+lib/ontomde-core/clone.rb
+test/test_uri.rb
+test/test_ontomde-core.rb
+test/protege/etatCivil.rdfs
+test/protege/etatCivil.rdf
+test/protege/test_demo.rb
+test/protege/demo.sh
+test/protege/etatCivil.pprj
+test/test_protected.rb
+test/unit_test_protected_sample
+test/unit_test_crash.rb
+test/test_context.rb
+test/unit_test_protected_wrongEnd

data/README.txt

@@ -0,0 +1,48 @@
+ontomde-core
+    by FIX (your name)
+    FIX (url)
+
+== DESCRIPTION:
+  
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+  
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/ontomde-core/version.rb'
+
+Hoe.new('ontomde-core', Ontomde::Core::VERSION) do |p|
+  p.rubyforge_name = 'ontomde'
+  p.author = 'Stephane (Pierre) Carrie'
+  p.email = 'stephanepierre.carrie@orange-ftgroup.com'
+  p.summary = 'OntoMDE core cartridge (RDF/RDFS handling,helpers)'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.spec_extras[:required_ruby_version] = '>= 1.8.4'
+  p.extra_deps=[ ['ontomde-redland-win','= 1.0.3'] ]
+end
+
+# vim: syntax=Ruby

data/lib/ontomde-core.rb

@@ -0,0 +1,35 @@
+# In order to use ontomde-core just include this file
+# 
+# include 'ontomde-core'
+#
+# NOTE: cf demo/etatCivil for sample raw use of ontomde-core.
+#
+#:include: shared/license.rdoc
+
+require "#{__FILE__[0..-4]}/version.rb"
+
+require 'set'
+require 'ontomde-redland-win'
+
+here="#{File.dirname(__FILE__)}/ontomde-core"
+
+require "#{here}/log.rb"
+require "#{here}/fileLoader.rb"
+require "#{here}/custom_method_missing"
+require "#{here}/triplet.rb"
+require "#{here}/exceptions.rb"
+require "#{here}/meta.rb"
+require "#{here}/resource.rb"
+require "#{here}/resourceSet.rb"
+require "#{here}/bootstrap_rdfs.rb"
+require "#{here}/clone.rb"
+require "#{here}/fileTypes.rb"
+require "#{here}/helper.rb"
+require "#{here}/context.rb"
+require "#{here}/delayed.rb"
+
+#MTKRunner.rb 
+require "#{here}/loader.rb"
+#require "#{here}/profil.rb"
+require "#{here}/customERB.rb"
+

data/lib/ontomde-core/bootstrap_rdfs.rb

@@ -0,0 +1,37 @@
+# Bootstrap of rdfs metamodel
+#:include: ../shared/license.rdoc
+
+module Mrdfs_Resource
+end
+
+module Mrdfs_Class
+end
+
+class Crdfs_Class < Crdf_Resource
+  include Mrdfs_Class
+  attr_reader :ClassGenerated
+  attr_writer :ClassGenerated
+  def initialize(model,uri)
+    super(model,uri)
+    @mtk_rubyClassGenerated=false
+  end
+end
+module Mrdf_Property
+end
+
+class Crdf_Property < Crdf_Resource
+  include Mrdf_Property
+  attr_reader :rdfs_domain, :rdfs_range
+  attr_reader :sys_inverseProperty
+  @rdfs_domain=ArrayOrSingleElement.new()
+  #attr_writer :rdfs_domain, :rdfs_range
+end
+
+module Mrdfs_Literal
+end
+
+class Crdfs_Literal < Crdf_Resource
+  include Mrdfs_Literal
+  attr_reader :rdfs_domain, :rdfs_range
+  #attr_writer :rdfs_domain, :rdfs_range
+end

data/lib/ontomde-core/clone.rb

@@ -0,0 +1,73 @@
+#Model transformation methods
+#:include: ../shared/license.rdoc
+
+class String
+	# Clones a string
+	# return self by default.(String are not cloned)
+	def rdfx_clone
+		return self
+	end
+end
+
+module Mrdf_Resource
+	# Clones a uml resource.
+	# Referenced objects are cloned if rdfx_copyOnClone says so.
+	def rdfx_clone
+		c=self.clone
+		c.rdf_uri="_transient_#{c.object_id}"
+		c.rdf_model[c.rdf_uri]=c
+
+		instance_variables.each { |v| 
+			ivg=instance_variable_get(v)
+			next if (!ivg.kind_of?(ArrayOrSingleElement)) ||
+				(!isResetable?(v)) || 
+				(!rdfx_copyOnClone?(v)) 
+
+			newVal=createEmptyAttributeValue
+			#puts "clone v=#{v}"
+			self.instance_variable_get(v).each { | res|
+				newVal.push(res.rdfx_clone)
+				c.instance_variable_set(v,newVal)
+				}
+			}
+		return c	
+	end
+	
+	# Returns true if object should be copied on clone for this property.
+	# NOTE:
+	#   returns true if property name contains "_owned". (works for UML)
+	def rdfx_copyOnClone?(prop)
+		return prop.include?('_owned')
+		#copyOrClone=copyOnCloneProperties[prop]
+		#if copyOrClone.nil?
+			#puts "WARNING: unspecified copy on clone for #{prop} on #{self.class.name}"
+		#end
+		#return copyOrClone 
+	end
+end
+#module Mrdf_Resource
+#	#CopyOnCloneProperties={ }
+#	def copyOnCloneProperties
+#		#CopyOnCloneProperties
+#	end
+#end
+#module Muml_Class
+#	CopyOnCloneProperties={ '@uml_packageableElement_packageableElement_visibility' => true,
+#		'@uml_structuredClassifier_ownedAttribute' => true,
+#		'@mtk_rubyClassGenerated' => true,
+#		'@uml_classifier_generalization' => true,
+#		'@uml_namedElement_visibility' => true,
+#		'@uml_namedElement_clientDependency' => true,
+#		'@umlx_packageableElement_owner' => true,
+#		'@ext_isReferencedBy' => true,
+#		'@uml_class_ownedOperation' => true,
+#		'@uml_behavioredClassifier_implementation' => true,
+#		'@uml_namedElement_name' => true }
+#	#def copyOnCloneProperties
+#	#	CopyOnCloneProperties #_class
+#	#end
+#end
+
+
+
+

data/lib/ontomde-core/context.rb

@@ -0,0 +1,115 @@
+# Context management
+#:include: ../shared/license.rdoc
+
+require 'fileutils'
+#require 'ontomde-core/exceptions.rb'
+
+#Internal use.
+# 
+#Used for storing context.
+class WarningHash < Hash
+
+#Returns context value associated to key.
+#Raises an error if key is not found.
+	# Returns default, when context is undefined for key, and a default value is provided.
+	def [](key,default=Object.class)
+		val=super(key)
+		return val unless val.nil?
+		#Note: Object.class is used as a magic number.
+		return default unless default==Object.class
+		raise Warning.new(), <<FINCODE
+Evaluation interrompue:
+La session ne contient pas la variable :#{key}.
+L'exemple de code suivant permet de definir une variable de contexte:
+
+  votre code
+  mtk_context(:#{key}=>'valeur'){
+     votre code
+     puts context[:#{key}]
+     votre code
+     }
+FINCODE
+	end
+	def get(key)
+		return self[key] if self.include?(key)
+		return nil
+	end
+end
+
+module Mrdf_Model
+@@context=WarningHash.new()
+
+def context
+	return @@context
+end
+
+# Similar to mtk_context but preserves already defined context.
+# Used to provide a default context.
+def mtk_default_context(*additional_context,&block)
+	filtered_context=Array.new
+	additional_context.each { |item| item.each { |k,v|
+		next if @@context.include?(k)
+		filtered_context << item
+	}}
+	mtk_context(*filtered_context,&block)
+end
+
+#Defines context variables for use in block passed as parameter.
+#Existing context variable are redefined. (cf. mtk_default_context )
+#When exiting block, previously defined context variables are restored.
+#
+#Example 1:
+#  mtk_context( :build => "build\", :option => true) {
+#     your-code
+#     puts context[:build]
+#     your-code
+#     puts context[:option]
+#     your-code
+#  }
+#
+#Example 2:
+#  mtk_context( :build => "BUILD_ONE\") {
+#       your-code
+#       puts context[:build] # BUILD_ONE
+#    mtk_context( :build => "NEW_DIR", :option => true) {
+#       your-code
+#       puts context[:build] # NEW_DIR\ 
+#       your-code
+#       puts context[:option]
+#       your-code
+#    }
+#    puts context[:build] # BUILD_ONE 
+#  }
+def mtk_context(*additional_context,&block)
+	context_save=@@context
+	@@context=context_save.clone
+	additional_context.each { |item| item.each { |k,v|
+		@@context[k]=v
+		}}
+	yield
+	@@context=context_save
+	return nil
+end
+
+end
+
+module Mrdf_Resource
+
+# returns current context
+def context
+	return @rdf_model.context
+end
+
+# cf: Mrdf_Model::mtk_context
+def mtk_context(*args,&block)
+	return @rdf_model.mtk_context(*args,&block)
+end
+#
+# cf: Mrdf_Model::mtk_default_context
+def mtk_default_context(*args,&block)
+	return @rdf_model.mtk_default_context(*args,&block)
+end
+
+end
+
+

data/lib/ontomde-core/customERB.rb

@@ -0,0 +1,842 @@
+
+class Crdf_Ressource
+def loadTPL(name)
+	tpl=""
+	File.open(name) { |f|
+		f.each { |l|
+			tpl=tpl+l
+			}
+	}
+	return CustomERB.new(tpl)
+end
+end
+
+
+
+# = CustomERB -- Ruby Templating
+#
+# Author:: Masatoshi SEKI
+# Documentation:: James Edward Gray II and Gavin Sinclair
+#
+# See CustomERB for primary documentation and CustomERB::Util for a couple of utility
+# routines.
+#
+# Copyright (c) 1999-2000,2002,2003 Masatoshi SEKI
+#
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+#
+# = CustomERB -- Ruby Templating
+#
+# == Introduction
+#
+# CustomERB provides an easy to use but powerful templating system for Ruby.  Using
+# CustomERB, actual Ruby code can be added to any plain text document for the
+# purposes of generating document information details and/or flow control.
+#
+# A very simple example is this:
+# 
+#   require 'erb'
+#
+#   x = 42
+#   template = CustomERB.new <<-EOF
+#     The value of x is: <@= x @>
+#   EOF
+#   puts template.result(binding)
+#
+# <em>Prints:</em> The value of x is: 42
+#
+# More complex examples are given below.
+#
+#
+# == Recognized Tags
+#
+# CustomERB recognizes certain tags in the provided template and converts them based
+# on the rules below:
+#
+#   <@ Ruby code -- inline with output @>
+#   <@= Ruby expression -- replace with result @>
+#   <@# comment -- ignored -- useful in testing @>
+#   @ a line of Ruby code -- treated as <@ line @> (optional -- see CustomERB.new)
+#   @@ replaced with @ if first thing on a line and @ processing is used
+#   <@@ or @@> -- replace with <@ or @> respectively
+#
+# All other text is passed through CustomERB filtering unchanged.
+#
+#
+# == Options
+#
+# There are several settings you can change when you use CustomERB:
+# * the nature of the tags that are recognized;
+# * the value of <tt>$SAFE</tt> under which the template is run;
+# * the binding used to resolve local variables in the template.
+#
+# See the CustomERB.new and CustomERB#result methods for more detail.
+#
+#
+# == Examples
+#
+# === Plain Text
+#
+# CustomERB is useful for any generic templating situation.  Note that in this example, we use the
+# convenient "@ at start of line" tag, and we quote the template literally with
+# <tt>@q{...}</tt> to avoid trouble with the backslash.
+#
+#   require "erb"
+#   
+#   # Create template.
+#   template = @q{
+#     From:  James Edward Gray II <james@grayproductions.net>
+#     To:  <@= to @>
+#     Subject:  Addressing Needs
+#   
+#     <@= to[/\w+/] @>:
+#   
+#     Just wanted to send a quick note assuring that your needs are being
+#     addressed.
+#   
+#     I want you to know that my team will keep working on the issues,
+#     especially:
+#   
+#     <@# ignore numerous minor requests -- focus on priorities @>
+#     @ priorities.each do |priority|
+#       * <@= priority @>
+#     @ end
+#   
+#     Thanks for your patience.
+#   
+#     James Edward Gray II
+#   }.gsub(/^  /, '')
+#   
+#   message = CustomERB.new(template, 0, "@<>")
+#   
+#   # Set up template data.
+#   to = "Community Spokesman <spokesman@ruby_community.org>"
+#   priorities = [ "Run Ruby Quiz",
+#                  "Document Modules",
+#                  "Answer Questions on Ruby Talk" ]
+#   
+#   # Produce result.
+#   email = message.result
+#   puts email
+#
+# <i>Generates:</i>
+#
+#   From:  James Edward Gray II <james@grayproductions.net>
+#   To:  Community Spokesman <spokesman@ruby_community.org>
+#   Subject:  Addressing Needs
+#   
+#   Community:
+#   
+#   Just wanted to send a quick note assuring that your needs are being addressed.
+#   
+#   I want you to know that my team will keep working on the issues, especially:
+#   
+#       * Run Ruby Quiz
+#       * Document Modules
+#       * Answer Questions on Ruby Talk
+#   
+#   Thanks for your patience.
+#   
+#   James Edward Gray II
+#
+# === Ruby in HTML
+#
+# CustomERB is often used in <tt>.rhtml</tt> files (HTML with embedded Ruby).  Notice the need in
+# this example to provide a special binding when the template is run, so that the instance
+# variables in the Product object can be resolved.
+#
+#   require "erb"
+#   
+#   # Build template data class.
+#   class Product
+#     def initialize( code, name, desc, cost )
+#       @code = code
+#       @name = name
+#       @desc = desc
+#       @cost = cost
+#        	
+#       @features = [ ]
+#     end
+#   
+#     def add_feature( feature )
+#       @features << feature
+#     end
+#   
+#     # Support templating of member data.
+#     def get_binding
+#       binding
+#     end
+#   
+#     # ...
+#   end
+#   
+#   # Create template.
+#   template = @{
+#     <html>
+#       <head><title>Ruby Toys -- <@= @name @></title></head>
+#       <body>
+#   
+#         <h1><@= @name @> (<@= @code @>)</h1>
+#         <p><@= @desc @></p>
+#   
+#         <ul>
+#           <@ @features.each do |f| @>
+#             <li><b><@= f @></b></li>
+#           <@ end @>
+#         </ul>
+#   
+#         <p>
+#           <@ if @cost < 10 @>
+#             <b>Only <@= @cost @>!!!</b>
+#           <@ else @>
+#              Call for a price, today!
+#           <@ end @>
+#         </p>
+#    
+#       </body>
+#     </html>
+#   }.gsub(/^  /, '')
+#   
+#   rhtml = CustomERB.new(template)
+#   
+#   # Set up template data.
+#   toy = Product.new( "TZ-1002",
+#                      "Rubysapien",
+#                      "Geek's Best Friend!  Responds to Ruby commands...",
+#                      999.95 )
+#   toy.add_feature("Listens for verbal commands in the Ruby language!")
+#   toy.add_feature("Ignores Perl, Java, and all C variants.")
+#   toy.add_feature("Karate-Chop Action!!!")
+#   toy.add_feature("Matz signature on left leg.")
+#   toy.add_feature("Gem studded eyes... Rubies, of course!")
+#   
+#   # Produce result.
+#   rhtml.run(toy.get_binding)
+#
+# <i>Generates (some blank lines removed):</i>
+#
+#    <html>
+#      <head><title>Ruby Toys -- Rubysapien</title></head>
+#      <body>
+#    
+#        <h1>Rubysapien (TZ-1002)</h1>
+#        <p>Geek's Best Friend!  Responds to Ruby commands...</p>
+#    
+#        <ul>
+#            <li><b>Listens for verbal commands in the Ruby language!</b></li>
+#            <li><b>Ignores Perl, Java, and all C variants.</b></li>
+#            <li><b>Karate-Chop Action!!!</b></li>
+#            <li><b>Matz signature on left leg.</b></li>
+#            <li><b>Gem studded eyes... Rubies, of course!</b></li>
+#        </ul>
+#    
+#        <p>
+#             Call for a price, today!
+#        </p>
+#    
+#      </body>
+#    </html>
+#
+# 
+# == Notes
+#
+# There are a variety of templating solutions available in various Ruby projects:
+# * CustomERB's big brother, eRuby, works the same but is written in C for speed;
+# * Amrita (smart at producing HTML/XML);
+# * cs/Template (written in C for speed);
+# * RDoc, distributed with Ruby, uses its own template engine, which can be reused elsewhere;
+# * and others; search the RAA.
+#
+# Rails, the web application framework, uses CustomERB to create views.
+#
+class CustomERB
+  Revision = '$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $' 	#'
+
+  # Returns revision information for the erb.rb module.
+  def self.version
+    "erb.rb [2.0.4 #{CustomERB::Revision.split[1]}]"
+  end
+end
+
+#--
+# CustomERB::Compiler
+class CustomERB
+  class Compiler # :nodoc:
+    class PercentLine # :nodoc:
+      def initialize(str)
+        @value = str
+      end
+      attr_reader :value
+      alias :to_s :value
+    end
+
+    class Scanner # :nodoc:
+      SplitRegexp = /(<@@)|(@@>)|(<@=)|(<@#)|(<@)|(@>)|(\n)/
+
+      @scanner_map = {}
+      def self.regist_scanner(klass, trim_mode, percent)
+	@scanner_map[[trim_mode, percent]] = klass
+      end
+
+      def self.default_scanner=(klass)
+	@default_scanner = klass
+      end
+
+      def self.make_scanner(src, trim_mode, percent)
+	klass = @scanner_map.fetch([trim_mode, percent], @default_scanner)
+	klass.new(src, trim_mode, percent)
+      end
+
+      def initialize(src, trim_mode, percent)
+	@src = src
+	@stag = nil
+      end
+      attr_accessor :stag
+
+      def scan; end
+    end
+
+    class TrimScanner < Scanner # :nodoc:
+      TrimSplitRegexp = /(<@@)|(@@>)|(<@=)|(<@#)|(<@)|(@>\n)|(@>)|(\n)/
+
+      def initialize(src, trim_mode, percent)
+	super
+	@trim_mode = trim_mode
+	@percent = percent
+	if @trim_mode == '>'
+	  @scan_line = self.method(:trim_line1)
+	elsif @trim_mode == '<>'
+	  @scan_line = self.method(:trim_line2)
+	elsif @trim_mode == '-'
+	  @scan_line = self.method(:explicit_trim_line)
+	else
+	  @scan_line = self.method(:scan_line)
+	end
+      end
+      attr_accessor :stag
+      
+      def scan(&block)
+	@stag = nil
+	if @percent
+	  @src.each do |line|
+	    percent_line(line, &block)
+	  end
+	else
+	  @src.each do |line|
+	    @scan_line.call(line, &block)
+	  end
+	end
+	nil
+      end
+
+      def percent_line(line, &block)
+	if @stag || line[0] != ?@
+	  return @scan_line.call(line, &block)
+	end
+
+	line[0] = ''
+	if line[0] == ?@
+	  @scan_line.call(line, &block)
+	else
+          yield(PercentLine.new(line.chomp))
+	end
+      end
+
+      def scan_line(line)
+	line.split(SplitRegexp).each do |token|
+	  next if token.empty?
+	  yield(token)
+	end
+      end
+
+      def trim_line1(line)
+	line.split(TrimSplitRegexp).each do |token|
+	  next if token.empty?
+	  if token == "@>\n"
+	    yield('@>')
+	    yield(:cr)
+	    break
+	  end
+	  yield(token)
+	end
+      end
+
+      def trim_line2(line)
+	head = nil
+	line.split(TrimSplitRegexp).each do |token|
+	  next if token.empty?
+	  head = token unless head
+	  if token == "@>\n"
+	    yield('@>')
+	    if  is_erb_stag?(head)
+	      yield(:cr)
+	    else
+	      yield("\n")
+	    end
+	    break
+	  end
+	  yield(token)
+	end
+      end
+
+      ExplicitTrimRegexp = /(^[ \t]*<@-)|(-@>\n?\z)|(<@-)|(-@>)|(<@@)|(@@>)|(<@=)|(<@#)|(<@)|(@>)|(\n)/
+      def explicit_trim_line(line)
+	line.split(ExplicitTrimRegexp).each do |token|
+	  next if token.empty?
+	  if @stag.nil? && /[ \t]*<@-/ =~ token
+	    yield('<@')
+	  elsif @stag && /-@>\n/ =~ token
+	    yield('@>')
+	    yield(:cr)
+	  elsif @stag && token == '-@>'
+	    yield('@>')
+	  else
+	    yield(token)
+	  end
+	end
+      end
+
+      CustomERB_STAG = %w(<@= <@# <@)
+      def is_erb_stag?(s)
+	CustomERB_STAG.member?(s)
+      end
+    end
+
+    Scanner.default_scanner = TrimScanner
+
+    class SimpleScanner < Scanner # :nodoc:
+      def scan
+	@src.each do |line|
+	  line.split(SplitRegexp).each do |token|
+	    next if token.empty?
+	    yield(token)
+	  end
+	end
+      end
+    end
+    
+    Scanner.regist_scanner(SimpleScanner, nil, false)
+
+    begin
+      require 'strscan'
+      class SimpleScanner2 < Scanner # :nodoc:
+        def scan
+          stag_reg = /(.*?)(<@@|<@=|<@#|<@|\n|\z)/
+          etag_reg = /(.*?)(@@>|@>|\n|\z)/
+          scanner = StringScanner.new(@src)
+          while ! scanner.eos?
+            scanner.scan(@stag ? etag_reg : stag_reg)
+            text = scanner[1]
+            elem = scanner[2]
+            yield(text) unless text.empty?
+            yield(elem) unless elem.empty?
+          end
+        end
+      end
+      Scanner.regist_scanner(SimpleScanner2, nil, false)
+
+      class PercentScanner < Scanner # :nodoc:
+	def scan
+	  new_line = true
+          stag_reg = /(.*?)(<@@|<@=|<@#|<@|\n|\z)/
+          etag_reg = /(.*?)(@@>|@>|\n|\z)/
+          scanner = StringScanner.new(@src)
+          while ! scanner.eos?
+	    if new_line && @stag.nil?
+	      if scanner.scan(/@@/)
+		yield('@')
+		new_line = false
+		next
+	      elsif scanner.scan(/@/)
+		yield(PercentLine.new(scanner.scan(/.*?(\n|\z)/).chomp))
+		next
+	      end
+	    end
+	    scanner.scan(@stag ? etag_reg : stag_reg)
+            text = scanner[1]
+            elem = scanner[2]
+            yield(text) unless text.empty?
+            yield(elem) unless elem.empty?
+	    new_line = (elem == "\n")
+          end
+        end
+      end
+      Scanner.regist_scanner(PercentScanner, nil, true)
+
+      class ExplicitScanner < Scanner # :nodoc:
+	def scan
+	  new_line = true
+          stag_reg = /(.*?)(<@@|<@=|<@#|<@-|<@|\n|\z)/
+          etag_reg = /(.*?)(@@>|-@>|@>|\n|\z)/
+          scanner = StringScanner.new(@src)
+          while ! scanner.eos?
+	    if new_line && @stag.nil? && scanner.scan(/[ \t]*<@-/)
+	      yield('<@')
+	      new_line = false
+	      next
+	    end
+	    scanner.scan(@stag ? etag_reg : stag_reg)
+            text = scanner[1]
+            elem = scanner[2]
+	    new_line = (elem == "\n")
+            yield(text) unless text.empty?
+	    if elem == '-@>'
+	      yield('@>')
+	      if scanner.scan(/(\n|\z)/)
+		yield(:cr)
+		new_line = true
+	      end
+	    elsif elem == '<@-'
+	      yield('<@')
+	    else
+	      yield(elem) unless elem.empty?
+	    end
+          end
+        end
+      end
+      Scanner.regist_scanner(ExplicitScanner, '-', false)
+
+    rescue LoadError
+    end
+
+    class Buffer # :nodoc:
+      def initialize(compiler)
+	@compiler = compiler
+	@line = []
+	@script = ""
+	@compiler.pre_cmd.each do |x|
+	  push(x)
+	end
+      end
+      attr_reader :script
+
+      def push(cmd)
+	@line << cmd
+      end
+      
+      def cr
+	@script << (@line.join('; '))
+	@line = []
+	@script << "\n"
+      end
+      
+      def close
+	return unless @line
+	@compiler.post_cmd.each do |x|
+	  push(x)
+	end
+	@script << (@line.join('; '))
+	@line = nil
+      end
+    end
+
+    def compile(s)
+      out = Buffer.new(self)
+
+      content = ''
+      scanner = make_scanner(s)
+      scanner.scan do |token|
+	if scanner.stag.nil?
+	  case token
+          when PercentLine
+	    out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+	    content = ''
+            out.push(token.to_s)
+            out.cr
+	  when :cr
+	    out.cr
+	  when '<@', '<@=', '<@#'
+	    scanner.stag = token
+	    out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+	    content = ''
+	  when "\n"
+	    content << "\n"
+	    out.push("#{@put_cmd} #{content.dump}")
+	    out.cr
+	    content = ''
+	  when '<@@'
+	    content << '<@'
+	  else
+	    content << token
+	  end
+	else
+	  case token
+	  when '@>'
+	    case scanner.stag
+	    when '<@'
+	      if content[-1] == ?\n
+		content.chop!
+		out.push(content)
+		out.cr
+	      else
+		out.push(content)
+	      end
+	    when '<@='
+	      out.push("#{@insert_cmd}((#{content}).to_s)")
+	    when '<@#'
+	      # out.push("# #{content.dump}")
+	    end
+	    scanner.stag = nil
+	    content = ''
+	  when '@@>'
+	    content << '@>'
+	  else
+	    content << token
+	  end
+	end
+      end
+      out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+      out.close
+      out.script
+    end
+
+    def prepare_trim_mode(mode)
+      case mode
+      when 1
+	return [false, '>']
+      when 2
+	return [false, '<>']
+      when 0
+	return [false, nil]
+      when String
+	perc = mode.include?('@')
+	if mode.include?('-')
+	  return [perc, '-']
+	elsif mode.include?('<>')
+	  return [perc, '<>']
+	elsif mode.include?('>')
+	  return [perc, '>']
+	else
+	  [perc, nil]
+	end
+      else
+	return [false, nil]
+      end
+    end
+
+    def make_scanner(src)
+      Scanner.make_scanner(src, @trim_mode, @percent)
+    end
+
+    def initialize(trim_mode)
+      @percent, @trim_mode = prepare_trim_mode(trim_mode)
+      @put_cmd = 'print'
+      @insert_cmd = @put_cmd
+      @pre_cmd = []
+      @post_cmd = []
+    end
+    attr_reader :percent, :trim_mode
+    attr_accessor :put_cmd, :insert_cmd, :pre_cmd, :post_cmd
+  end
+end
+
+#--
+# CustomERB
+class CustomERB
+  #
+  # Constructs a new CustomERB object with the template specified in _str_.
+  # 
+  # An CustomERB object works by building a chunk of Ruby code that will output
+  # the completed template when run. If _safe_level_ is set to a non-nil value,
+  # CustomERB code will be run in a separate thread with <b>$SAFE</b> set to the
+  # provided level.
+  # 
+  # If _trim_mode_ is passed a String containing one or more of the following
+  # modifiers, CustomERB will adjust its code generation as listed:
+  # 
+  # 	@  enables Ruby code processing for lines beginning with @
+  # 	<> omit newline for lines starting with <@ and ending in @>
+  # 	>  omit newline for lines ending in @>
+  # 
+  # _eoutvar_ can be used to set the name of the variable CustomERB will build up
+  # its output in.  This is useful when you need to run multiple CustomERB
+  # templates through the same binding and/or when you want to control where
+  # output ends up.  Pass the name of the variable to be used inside a String.
+  #
+  # === Example
+  #
+  #  require "erb"
+  #  
+  #  # build data class
+  #  class Listings
+  #    PRODUCT = { :name => "Chicken Fried Steak",
+  #                :desc => "A well messages pattie, breaded and fried.",
+  #                :cost => 9.95 }
+  #  
+  #    attr_reader :product, :price
+  #    
+  #    def initialize( product = "", price = "" )
+  #      @product = product
+  #      @price = price
+  #    end
+  #    
+  #    def build
+  #      b = binding
+  #      # create and run templates, filling member data variebles
+  #      CustomERB.new(<<-'END_PRODUCT'.gsub(/^\s+/, ""), 0, "", "@product").result b
+  #        <@= PRODUCT[:name] @>
+  #        <@= PRODUCT[:desc] @>
+  #      END_PRODUCT
+  #      CustomERB.new(<<-'END_PRICE'.gsub(/^\s+/, ""), 0, "", "@price").result b
+  #        <@= PRODUCT[:name] @> -- <@= PRODUCT[:cost] @>
+  #        <@= PRODUCT[:desc] @>
+  #      END_PRICE
+  #    end
+  #  end
+  #  
+  #  # setup template data
+  #  listings = Listings.new
+  #  listings.build
+  #  
+  #  puts listings.product + "\n" + listings.price
+  #
+  # _Generates_
+  #
+  #  Chicken Fried Steak
+  #  A well messages pattie, breaded and fried.
+  #  
+  #  Chicken Fried Steak -- 9.95
+  #  A well messages pattie, breaded and fried.
+  #  
+  def initialize(str, safe_level=nil, trim_mode=nil, eoutvar='_erbout')
+    @safe_level = safe_level
+    compiler = CustomERB::Compiler.new(trim_mode)
+    set_eoutvar(compiler, eoutvar)
+    @src = compiler.compile(str)
+    @filename = nil
+  end
+
+  # The Ruby code generated by CustomERB
+  attr_reader :src
+
+  # The optional _filename_ argument passed to Kernel#eval when the CustomERB code
+  # is run
+  attr_accessor :filename
+
+  #
+  # Can be used to set _eoutvar_ as described in CustomERB#new.  It's probably easier
+  # to just use the constructor though, since calling this method requires the
+  # setup of an CustomERB _compiler_ object.
+  #
+  def set_eoutvar(compiler, eoutvar = '_erbout')
+    compiler.put_cmd = "#{eoutvar}.concat"
+    compiler.insert_cmd = "#{eoutvar}.concat"
+
+    cmd = []
+    cmd.push "#{eoutvar} = ''"
+    
+    compiler.pre_cmd = cmd
+
+    cmd = []
+    cmd.push(eoutvar)
+
+    compiler.post_cmd = cmd
+  end
+
+  # Generate results and print them. (see CustomERB#result)
+  def run(b=TOPLEVEL_BINDING)
+    print self.result(b)
+  end
+
+  #
+  # Executes the generated CustomERB code to produce a completed template, returning
+  # the results of that code.  (See CustomERB#new for details on how this process can
+  # be affected by _safe_level_.)
+  # 
+  # _b_ accepts a Binding or Proc object which is used to set the context of
+  # code evaluation.
+  #
+  def result(b=TOPLEVEL_BINDING)
+    if @safe_level
+      th = Thread.start { 
+	$SAFE = @safe_level
+	eval(@src, b, (@filename || '(erb)'), 1)
+      }
+      return th.value
+    else
+      return eval(@src, b, (@filename || '(erb)'), 1)
+    end
+  end
+
+  def def_method(mod, methodname, fname='(CustomERB)')  # :nodoc:
+    mod.module_eval("def #{methodname}\n" + self.src + "\nend\n", fname, 0)
+  end
+
+  def def_module(methodname='erb')  # :nodoc:
+    mod = Module.new
+    def_method(mod, methodname)
+    mod
+  end
+
+  def def_class(superklass=Object, methodname='result')  # :nodoc:
+    cls = Class.new(superklass)
+    def_method(cls, methodname)
+    cls
+  end
+end
+
+#--
+# CustomERB::Util
+class CustomERB
+  # A utility module for conversion routines, often handy in HTML generation.
+  module Util
+    public
+    #
+    # A utility method for escaping HTML tag characters in _s_.
+    # 
+    # 	require "erb"
+    # 	include CustomERB::Util
+    # 	
+    # 	puts html_escape("is a > 0 & a < 10?")
+    # 
+    # _Generates_
+    # 
+    # 	is a &gt; 0 &amp; a &lt; 10?
+    #
+    def html_escape(s)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    alias h html_escape
+    module_function :h
+    module_function :html_escape
+    
+    #
+    # A utility method for encoding the String _s_ as a URL.
+    # 
+    # 	require "erb"
+    # 	include CustomERB::Util
+    # 	
+    # 	puts url_encode("Programming Ruby:  The Pragmatic Programmer's Guide")
+    # 
+    # _Generates_
+    # 
+    # 	Programming@20Ruby@3A@20@20The@20Pragmatic@20Programmer@27s@20Guide
+    #
+    def url_encode(s)
+      s.to_s.gsub(/[^a-zA-Z0-9_\-.]/n){ sprintf("@@@02X", $&.unpack("C")[0]) }
+    end
+    alias u url_encode
+    module_function :u
+    module_function :url_encode
+  end
+end
+
+#--
+# CustomERB::DefMethod
+class CustomERB
+  module DefMethod  # :nodoc:
+    public
+    def def_erb_method(methodname, erb)
+      if erb.kind_of? String
+	fname = erb
+	File.open(fname) {|f| erb = CustomERB.new(f.read) }
+	erb.def_method(self, methodname, fname)
+      else
+	erb.def_method(self, methodname)
+      end
+    end
+    module_function :def_erb_method
+  end
+end
+