ap4r 0.3.2 → 0.3.3

data/{CHANGELOG → History.txt}

@@ -1,5 +1,10 @@
 == 0.3.x
 
+=== 0.3.3 (June ?, 2007)
+* Added: Support with hoe.
+* Added: Support PostgreSQL as reliable RDBMS persistence.
+* Added: Test supports, stub of queueing and service controls.
+
 === 0.3.2 (June 7th, 2007)
 * Fixed: util/loc.rb doesn't work.
 * Changed: Argument order of async_dispatch has changed, backward INCOMPATIBLE.

data/Manifest.txt

@@ -0,0 +1,48 @@
+History.txt
+MIT-LICENSE
+Manifest.txt
+README.txt
+Rakefile
+bin/ap4r_setup
+config/ap4r_settings.rb
+config/log4r.yaml
+config/queues.cfg
+config/queues_disk.cfg
+config/queues_mysql.cfg
+config/queues_pgsql.cfg
+lib/ap4r.rb
+lib/ap4r/carrier.rb
+lib/ap4r/dispatcher.rb
+lib/ap4r/message_store_ext.rb
+lib/ap4r/mongrel.rb
+lib/ap4r/mongrel_ap4r.rb
+lib/ap4r/multi_queue.rb
+lib/ap4r/postgresql.sql
+lib/ap4r/queue_manager_ext.rb
+lib/ap4r/queue_manager_ext_debug.rb
+lib/ap4r/retention_history.rb
+lib/ap4r/script/base.rb
+lib/ap4r/script/queue_manager_control.rb
+lib/ap4r/script/setup.rb
+lib/ap4r/script/workspace_generator.rb
+lib/ap4r/start_with_log4r.rb
+lib/ap4r/store_and_forward.rb
+lib/ap4r/stored_message.rb
+lib/ap4r/util/irm.rb
+lib/ap4r/util/queue_client.rb
+lib/ap4r/version.rb
+lib/ap4r/xxx_create_table_for_saf.rb
+lib/ap4r/xxx_create_table_for_saf_to_postgresql.rb
+rails_plugin/ap4r/init.rb
+rails_plugin/ap4r/lib/ap4r/queue_put_stub.rb
+rails_plugin/ap4r/lib/ap4r/service_handler.rb
+rails_plugin/ap4r/lib/ap4r_client.rb
+rails_plugin/ap4r/lib/async_helper.rb
+rails_plugin/ap4r/lib/message_builder.rb
+rails_plugin/ap4r/tasks/ap4r.rake
+script/irm
+script/mongrel_ap4r
+script/start
+script/stop
+spec/local/dispatcher_base_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,82 @@
+Ap4r
+* by Kiwamu Kato, Shun'ichi Shinohara
+* http://ap4r.rubyforge.org/wiki/wiki.pl?HomePage
+* ap4r-user@rubyforge.org
+
+== DESCRIPTION:
+  
+AP4R, Asynchronous Processing for Ruby, is the implementation of reliable asynchronous message processing. It provides message queuing, and message dispatching.
+Using asynchronous processing, we can cut down turn-around-time of web applications by queuing, or can utilize more machine power by load-balancing.
+Also AP4R nicely ties with your Ruby on Rails applications. See Hello World sample application from rubyforge.
+
+For more information, please step in AP4R homepage!
+
+
+== FEATURES / PROBLEMS TO SOLVE:
+  
+* Business logics can be implemented as simple Web applications, or ruby code, whether it's called asynchronously or synchronously.
+* Asynchronous messaging is reliable by RDBMS persistence (now MySQL only) or file persistence, under the favor of reliable-msg.
+* Load balancing over multiple AP4R processes on single/multiple servers is supported.
+* Asynchronous logics are called via various protocols, such as XML-RPC, SOAP, HTTP POST, and more.
+* Using store and forward function, at-least-once QoS level is provided.
+
+== TYPICAL PROCESS FLOW:
+
+1. A client (e.g. a web browser) makes a request to a web server (Apache, Lighttpd, etc...).
+1. A rails application (a synchronous logic) is executed on mongrel via mod_proxy or something.
+1. At the last of the synchronous logic, message(s) are put to AP4R (AP4R provides a helper).
+1. Once the synchronous logic is done, the clients receives a response immediately.
+1. AP4R queues the message, and requests it to the web server asynchronously.
+1. An asynchronous logic, implemented as usual rails action, is executed. 
+
+
+== SYNOPSIS:
+
+* FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+Use RubyGems command.
+
+  $ sudo gem install ap4r --include-dependencies
+
+	
+== REFERENCES:
+
+* Ruby Homepage
+  * http://www.ruby-lang.org/ 
+* Ruby on Rails tutorial
+  * http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html 
+* MySQL tutorial
+  * http://dev.mysql.com/doc/refman/5.0/en/index.html 
+* reliable-msg
+  * http://trac.labnotes.org/cgi-bin/trac.cgi/wiki/Ruby/ReliableMessaging 
+
+
+== LICENSE:
+
+* This software is licensed under the MIT license.
+* Copyright(c) 2007 Future Architect Inc.
+
+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

@@ -1,101 +1,87 @@
-# Author:: Kiwamu Kato
-# Copyright:: Copyright (c) 2007 Future Architect Inc.
-# Licence:: MIT Licence
+require 'rubygems'
+require 'hoe'
+require File.join(File.dirname(__FILE__), 'lib/ap4r', 'version')
 
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
+HelloWorld = '../samples/HelloWorld'
 
-require 'date'
-require 'find'
-require 'rbconfig'
+# AP4R release tasks --------------------------------------------------------
 
-require File.join(File.dirname(__FILE__), 'lib/ap4r', 'version')
+# copy rails plugin from sample before gem build
+FileUtils.mkdir_p('./rails_plugin/ap4r/lib')
+FileUtils.cp(HelloWorld + '/db/migrate/001_create_table_for_saf.rb', './lib/ap4r/xxx_create_table_for_saf.rb')
+FileUtils.cp_r(Dir.glob(HelloWorld + '/vendor/plugins/ap4r/*').reject{|f| f =~ /tmp$|CVS|\.svn/}, './rails_plugin/ap4r')
 
-PKG_VERSION = Ap4r::VERSION::STRING
-
-TEMP_DIR = './temp'
-PKG_DIR = './pkg'
-RELEASE_DIR = './release'
-HELLO_WORLD_DIR = '../samples/HelloWorld'
-
-# Generate GEM ----------------------------------------------------------------------------
-
-
-PKG_FILES = FileList[
-  '[a-zA-Z]*',
-  'bin/**/*', 
-  'config/**/*',
-  'rails_plugin/**/*',
-  'script/**/*',
-  'lib/**/*'
-]
-
-HELLO_WORLD_SAMPLE_FILES = FileList[
-  '[a-zA-Z]*',
-  'app/**/*', 
-  'components/**/*',
-  'config/**/*',
-  'db/**/*',
-  'doc/**/*',
-  'lib/**/*', 
-  'log/**/*',
-  'public/**/*',
-  'script/**/*',
-  'test/**/*',
-  'tmp/**/*', 
-  'vendor/**/*',
-]
-
-
-spec = Gem::Specification.new do |s|
-  s.name = 'ap4r'
-  s.version = PKG_VERSION
-  s.summary = "Asynchronous Processing for Ruby."
-  s.description = <<-EOF
+Hoe.new('ap4r', Ap4r::VERSION::STRING) do |p|
+  p.author = ["Shunichi Shinohara", "Kiwamu Kato"]
+  p.changes = p.paragraphs_of('History.txt', 1..2).join("\n\n")
+  #p.clean_globs = 
+  p.description = <<-EOF
     Asynchronous Processing for Ruby.
   EOF
+  p.email = %q{shinohara.shunichi@future.co.jp, kato.kiwamu@future.co.jp}
+
+  p.extra_deps << ['reliable-msg', '=1.1.0']
+  p.extra_deps << ['activesupport']
+  p.extra_deps << ['mongrel']
+  p.extra_deps << ['rake']
+  p.extra_deps << ['hoe']
+
+  p.name = 'ap4r'
+  p.need_tar = false
+  p.need_zip = false
+  #p.rdoc_pattern =
+  #p.remote_rdoc_dir = 
+  #p.rsync = 
+  p.rubyforge_name = 'ap4r'
+  #p.spec_extra = 
+  p.summary = 'Asynchronous Processing for Ruby.'
+  p.test_globs = 'spec/**/*_spec.rb'
+  p.url = 'http://ap4r.rubyforge.org/wiki/wiki.pl?HomePage'
+  p.version = Ap4r::VERSION::STRING
+end.spec.dependencies.delete_if {|dep| dep.name == "hoe"}
+
+
+desc 'Create Manifest.txt'
+task :create_manifest do
+
+  path_list = []
+  Find.find('.') do |path|
+    next unless File.file? path
+    next if path =~ /\.svn|tmp$|CVS|.rb\~/
+    path_list << path
+  end
 
-  s.add_dependency(%q<reliable-msg>, ["= 1.1.0"])
-	s.add_dependency(%q<rake>)
-	s.add_dependency(%q<activesupport>)
-	s.add_dependency(%q<mongrel>)
-
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "CHANGELOG", 'rails_plugin']
-  s.rdoc_options << "--main" << "README"
-  s.rdoc_options << "--title" << "Asynchronous Processing for Ruby" 
-  s.rdoc_options << "--line-numbers"
-
+  File.open('Manifest.txt', 'w') do |manifest|
+    path_list.sort.each do |path|
+      /.\// =~ path
+      manifest.puts($~.post_match)
+    end
+  end
+  
+end
 
-  s.files = PKG_FILES.to_a.delete_if {|f| f.include?('.svn')}
-  s.require_path = 'lib'
-  s.autorequire = %q{ap4r.rb}
 
-  s.bindir = "bin"                               # Use these for applications.
-  s.executables = ["ap4r_setup"]
-  s.default_executable = "ap4r_setup"
 
-  s.authors = ["Shunichi Shinohara", "Kiwamu Kato"]
-  s.email = %q{shinohara.shunichi@future.co.jp, kato.kiwamu@future.co.jp}
-  s.homepage = %q{http://rubyforge.org/projects/ap4r/}
-  s.rubyforge_project = "ap4r"
-end
+# Sample release tasks ------------------------------------------------------
+desc 'Make samle tarball (Now only HelloWorld sample).'
+task :sample do
+  FileUtils.mkdir_p('./pkg/samples')
+  FileUtils.rm_rf('./pkg/samples/HelloWorld')
+  
+  FileUtils.cp_r(HelloWorld, './pkg/samples/')
+  Find.find('./pkg/samples') do |path|
+    next unless File.file? path
+    FileUtils.rm_rf(path) if path =~ /\.svn|tmp$|CVS|.rb\~/
+  end
 
-Rake::GemPackageTask.new(spec) do |pkg|
+  Dir.chdir('./pkg/samples/HelloWorld')
+  `rake db:migrate`
+  Dir.chdir('../../')
+  
+  `tar czvf HelloWorld-#{Ap4r::VERSION::STRING}.tar.gz ./samples/HelloWorld/`
+  Dir.chdir('../')
 end
 
-# Generate documentation ------------------------------------------------------------------
-
-Rake::RDocTask.new { |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.options << '--line-numbers' << '--inline-source' << '--accessor' << 'cattr_accessor=rw'
-  rdoc.rdoc_files.include('README', 'CHANGELOG')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.rdoc_files.include('rails_plugin/**/*.rb')
-}
 
 # Spec tasks ----------------------------------------------------------------
 require 'spec/rake/spectask'
@@ -123,70 +109,6 @@ namespace :spec do
   end
 end
 
-# AP4R release ----------------------------------------------------------------
-
-desc "Make gem"
-task :gem_release => [ :make_release_dir, :copy_to_ap4r_from_sample, :gem]
-
-task :copy_to_ap4r_from_sample do
-  FileUtils.cp(HELLO_WORLD_DIR + '/db/migrate/001_create_table_for_saf.rb', './lib/ap4r/xxx_create_table_for_saf.rb')
-
-  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/init.rb', './rails_plugin/ap4r/init.rb')
-  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/async_helper.rb', './rails_plugin/ap4r/lib/async_helper.rb')
-  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/ap4r_client.rb', './rails_plugin/ap4r/lib/ap4r_client.rb')
-  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/message_builder.rb', './rails_plugin/ap4r/lib/message_builder.rb')
-end
-
-desc "Make sample tgz"
-task :sample_release => [ :make_release_dir, :make_sample_tgz, :copy_to_release_dir ]
-
-task :make_sample_tgz => [ :make_temp_dir, :copy_sample, :execute_migration, :make_tgz ]
-
-task :make_release_dir do
-  make_dir RELEASE_DIR
-end
-
-task :make_temp_dir do
-  make_dir TEMP_DIR
-end
-
-def make_dir(path)
-  if(File.exist?(path))
-    FileUtils.remove_entry(path, true)
-  end
-  FileUtils.mkdir_p(path)
-end
-
-
-task :copy_sample do  
-  FileUtils.cp_r(HELLO_WORLD_DIR, TEMP_DIR)
-  Find.find(TEMP_DIR) {|f|
-    if f.include?('.svn')
-      FileUtils.rm_rf(f)
-    end
-  }
-end
-
-task :execute_migration do
-  Dir.chdir('temp/HelloWorld')
-  `rake db:migrate`
-  Dir.chdir('../../')
-end
-
-task :make_tgz do
-  Dir.chdir('temp/')
-  `tar czvf HelloWorld.tar.gz HelloWorld/`
-  Dir.chdir('../')
-end
-
-task :copy_to_release_dir do
-  Dir.foreach(PKG_DIR) {|f|
-    FileUtils.cp(PKG_DIR + '/' + f, RELEASE_DIR) if File.fnmatch("*.gem", f)
-  }
-  Dir.foreach(TEMP_DIR) {|f|
-    FileUtils.cp(TEMP_DIR + '/' + f, RELEASE_DIR) if File.fnmatch("*.tar.gz", f)
-  }
-end
 
 # AP4R misc tools ----------------------------------------------------------------
 

data/config/queues_mysql.cfg

@@ -8,7 +8,7 @@ store:
 drb: 
   host: 
   port: 6438
-  acl: allow 127.0.0.1 allow 10.0.0.0/8
+  acl: allow 127.0.0.1 allow ::1 allow 10.0.0.0/8
 dispatchers:
   -
     targets: queue.*
@@ -16,4 +16,4 @@ dispatchers:
 #carriers:
 #  - 
 #    source_uri: druby://another.host.local:6438
-#    threads: 1
+#    threads: 1

data/config/queues_pgsql.cfg

@@ -0,0 +1,19 @@
+--- 
+store: 
+  type: postgresql
+  uri: # default is tcp://localhost:5432
+  database: ap4r
+  username: ap4r
+  password: ap4r
+drb: 
+  host: 
+  port: 6438
+  acl: allow 127.0.0.1 allow ::1 allow 10.0.0.0/8
+dispatchers:
+  -
+    targets: queue.*
+    threads: 1
+#carriers:
+#  - 
+#    source_uri: druby://another.host.local:6438
+#    threads: 1

data/lib/ap4r.rb

@@ -3,7 +3,6 @@
 # Licence:: MIT Licence
 
 require 'rubygems'
-gem 'reliable-msg'
 require 'reliable-msg'
 
 hack = true

data/lib/ap4r/message_store_ext.rb

@@ -33,6 +33,236 @@ module ReliableMsg #:nodoc:
 
     end
 
+    begin
+
+      # Make sure we have a PostgreSQL library before creating this class,
+      # worst case we end up with a disk-based message store. Try the
+      # native PostgreSQL library, followed by the pure Ruby PostgreSQL library.
+      begin
+        require 'postgres'
+      rescue LoadError
+        require 'postgres-pr/connection'
+      end
+      
+      require 'base64'
+
+      class PostgreSQL < Base #:nodoc:
+
+        TYPE = self.name.split('::').last.downcase
+
+        @@stores[TYPE] = self
+
+        # Default prefix for tables in the database.
+        DEFAULT_PREFIX = 'reliable_msg_';
+
+        # Reference to an open PostgreSQL connection held in the current thread.
+        THREAD_CURRENT_PGSQL = :reliable_msg_pgsql #:nodoc:
+
+        def initialize config, logger
+          super logger
+          @config = { :host=>config['host'], :username=>config['username'], :password=>config['password'],
+            :database=>config['database'], :port=>config['port'], :socket=>config['socket'] }
+          @prefix = config['prefix'] || DEFAULT_PREFIX
+          @queues_table = "#{@prefix}queues"
+          @topics_table = "#{@prefix}topics"
+        end
+
+        def type
+          TYPE
+        end
+
+        def setup
+          pgsql = connection
+          requires = 2 # Number of tables used by reliable-msg.
+          pgsql.query "\dt" do |result|
+            while row = result.fetch_row
+              requires -= 1 if row[0] == @queues_table || row[0] == @topics_table
+            end
+          end
+          if requires > 0
+            sql = File.open File.join(File.dirname(__FILE__), "postgresql.sql"), "r" do |input|
+              input.readlines.join
+            end
+            sql.gsub! DEFAULT_PREFIX, @prefix
+            pgsql.query sql
+            true
+          end
+        end
+
+
+        def configuration
+          config = { "type"=>TYPE, "host"=>@config[:host], "username"=>@config[:username],
+            "password"=>@config[:password], "database"=>@config[:database] }
+          config["port"] = @config[:port] if @config[:port]
+          config["socket"] = @config[:socket] if @config[:socket]
+          config["prefix"] = @config[:prefix] if @config[:prefix]
+          config
+        end
+
+
+        def activate
+          super
+          load_index
+        end
+
+
+        def deactivate
+          Thread.list.each do |thread|
+            if conn = thread[THREAD_CURRENT_PGSQL]
+              thread[THREAD_CURRENT_PGSQL] = nil
+              conn.close
+            end
+          end
+          super
+        end
+
+
+        protected
+
+        def update inserts, deletes, dlqs
+          pgsql = connection
+          pgsql.query "BEGIN"
+          begin
+            inserts.each do |insert|
+              if insert[:queue]
+                pgsql.query "INSERT INTO #{@queues_table} (id,queue,headers,object) VALUES('#{connection.quote  insert[:id]}', '#{connection.quote insert[:queue]}', '#{connection.quote YAML.dump(insert[:headers])}', '#{connection.quote Base64.encode64(insert[:message])}')"
+              else
+                pgsql.query "REPLACE #{@topics_table} (topic,headers,object) VALUES('#{connection.quote insert[:topic]}','#{connection.quote YAML.dump(insert[:headers])}','#{connection.quote insert[:message]}')"
+              end
+            end
+            ids = deletes.inject([]) do |array, delete|
+              delete[:queue] ? array << "'#{delete[:id]}'" : array
+            end
+            if !ids.empty?
+              pgsql.query "DELETE FROM #{@queues_table} WHERE id IN (#{ids.join ','})"
+            end
+            dlqs.each do |dlq|
+              pgsql.query "UPDATE #{@queues_table} SET queue='#{Queue::DLQ}' WHERE id='#{connection.quote dlq[:id]}'"
+            end
+            pgsql.query "COMMIT"
+          rescue Exception=>error
+            pgsql.query "ROLLBACK"
+            raise error
+          end
+          super
+        end
+
+
+        def load_index
+          connection.query "SELECT id,queue,headers FROM #{@queues_table}" do |result|
+            result.each do |tuple|
+              queue = @queues[tuple[1]] ||= []
+              headers = YAML.load tuple[2]
+              # Add element based on priority, higher priority comes first.
+              priority = headers[:priority]
+              added = false
+              queue.each_index do |idx|
+                if queue[idx][:priority] < priority
+                  queue[idx, 0] = headers
+                  added = true
+                  break
+                end
+              end
+              queue << headers unless added
+            end
+          end
+          connection.query "SELECT topic,headers FROM #{@topics_table}" do |result|
+            result.each do |tuple|
+              @topics[tuple[0]] = YAML.load tuple[1]
+            end
+          end
+        end
+
+
+        def load id, type, queue_or_topic
+          message = nil
+          if type == :queue
+            connection.query "SELECT object FROM #{@queues_table} WHERE id='#{id}'" do |result|
+              message = Base64.decode64(result[0][0]) if result[0]
+            end
+          else
+            connection.query "SELECT object FROM #{@topics_table} WHERE topic='#{queue_or_topic}'" do |result|
+              message = Base64.decode64(result[0][0]) if result[0]
+            end
+          end
+          message
+        end
+
+        def connection
+          Thread.current[THREAD_CURRENT_PGSQL] ||= 
+            # PGconn is overriding in this file, so is defined regardless of 'postgres' LoadError.
+            if Object.const_defined? :PGError
+              ::PGconn.connect @config[:host], @config[:port], @config[:options], @config[:tty], @config[:database], @config[:username], @config[:password]              
+            elsif Object.const_defined? :PostgresPR
+              ::PostgresPR::Connection.new @config[:database], @config[:username], @config[:password], @config[:uri]
+            end
+
+        end
+
+      end
+
+    rescue LoadError
+      # do nothing
+    end
+    
+  end
+end
+
+if Object.const_defined? :PGError
+  class PGconn
+    alias original_query query
+
+    def query(q, *bind_values, &block)
+      # In PGconn, +query+ method does NOT care about a given block.
+      # To deal with a given block, this method adds iteration
+      # over query results.
+      maybe_result = exec(q, *bind_values)
+      puts "PGconn: query called by #{q}" if $DEBUG
+      puts "PGconn#query returns #{maybe_result}(class: #{maybe_result.class})." if $DEBUG
+      return maybe_result unless block && maybe_result.kind_of?(PGresult)
+      begin
+        puts "PGconn extention: about to yield result." if $DEBUG
+        block.call(maybe_result)
+      ensure
+        maybe_result.clear
+      end
+    end
+    
+    def quote str
+      # do nothing
+      str
+    end
+
+  end
+end
+
+if Object.const_defined? :PostgresPR
+  module PostgresPR
+    class Connection
+      alias original_query query
+
+      def query(q, &block)
+        # In PostgresPR, +query+ method does NOT care about a given block.
+        # To deal with a given block, this method adds iteration
+        # over query results.
+        maybe_result = original_query(q, &block)
+        puts "PostgresPR: query called by #{q}" if $DEBUG
+        puts "PostgresPR::Connenction#query returns #{maybe_result}(class: #{maybe_result.class})." if $DEBUG
+        return maybe_result.rows unless block && maybe_result.kind_of?(PostgresPR::Connection::Result)
+        begin
+          puts "PostgresPR extention: about to yield result." if $DEBUG
+          block.call(maybe_result.rows)
+        ensure
+          maybe_result = nil
+        end
+      end
+
+      def quote(str)
+        # do nothing
+        str
+      end
+      
+    end   
   end
 end