jcarley-simplews 1.11.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Miguel Vazquez
+
+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/README.rdoc

@@ -0,0 +1,22 @@
+= simplews
+
+This library simplifies the creation of SOAP web services. It is based on
+soap4r, and adds a DSL for serving methods that create automatically the WSDL.
+Additionally, it offers support for asynchronous jobs.
+
+Documentation and detailed examples available at http://bioinfovm05.dacya.ucm.es/simplews/index.html
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Miguel Vazquez. See LICENSE for details.

data/bin/start_jobs_ws

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'simplews'
+require "optparse"
+require 'simplews/rake'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{ $_ } [options] <config_file>"
+
+  opts.on("-h", "--host HOST", String, "Select host interface, localhost by default") do |host|
+    options[:host] = host
+  end
+
+  opts.on("-p", "--port PORT", Integer, "Select interface port, 1984 by default") do |port|
+    options[:port] = port
+  end
+
+  opts.on("-n", "--name NAME", String, "Select the name of the web server interface, SimpleWS by default") do |name|
+    options[:name] = name
+  end
+
+  opts.on("-d", "--description DESCRIPTION", String, "Description of the service") do |description|
+    options[:description] = description
+  end
+
+  opts.on("-w", "--wsdl FILENAME", String, "Save the WSDL file") do |filename|
+    options[:wsdl] = filename
+  end
+   
+  opts.on("-t", "--path PATH", String, "Work directory for the WS") do |filename|
+    options[:directory] = filename
+  end
+  
+end.parse!
+
+filename = ARGV[0]
+
+server = SimpleWS::Jobs.new(options[:name], options[:description], options[:host], options[:port], options[:directory]) do
+  actions = File.open(filename)do |f| f.read end
+  eval actions
+end
+
+server.wsdl(options[:wsdl]) if options[:wsdl]
+
+trap('INT'){
+  puts "Stopping server"
+  server.shutdown
+}
+
+server.start
+
+

data/bin/start_ws

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'simplews'
+require "optparse"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{ $_ } [options] <config_file>"
+
+  opts.on("-h", "--host HOST", String, "Select host interface, localhost by default") do |host|
+    options[:host] = host
+  end
+
+  opts.on("-p", "--port PORT", Integer, "Select interface port, 1984 by default") do |port|
+    options[:port] = port
+  end
+
+  opts.on("-n", "--name NAME", String, "Select the name of the web server interface, SimpleWS by default") do |name|
+    options[:name] = name
+  end
+
+  opts.on("-d", "--description DESCRIPTION", String, "Description of the service") do |description|
+    options[:description] = description
+  end
+
+  opts.on("-w", "--wsdl FILENAME", String, "Save the WSDL file") do |filename|
+    options[:wsdl] = filename
+  end
+  
+end.parse!
+
+filename = ARGV[0]
+
+server = SimpleWS.new(options[:name], options[:description], options[:host], options[:port]) do
+  actions = File.open(filename)do |f| f.read end
+  eval actions
+end
+
+server.wsdl(options[:wsdl]) if options[:wsdl]
+
+trap('INT'){
+  puts "Stopping server"
+  server.shutdown
+}
+
+server.start
+
+

data/lib/rake_pipeline.rb

@@ -0,0 +1,237 @@
+require 'rake'
+
+# Include the step_dependencies and step_def methods to simplify Pipelines. Steps depend on
+# the step strictly above by default. The output of the step is save marshaled,
+# except for Strings which are save as text. The input of the step, the output
+# of the previous step if availabe is accessed with the input method
+#
+# Example::
+#
+#     step_def :text do 
+#       "Text to revert"
+#     end
+#
+#     step_def :revert do
+#       text = input
+#       text.reverse
+#     end
+#
+module Rake::Pipeline
+
+  module Rake::Pipeline::Step
+
+    class << self
+
+      @@step_descriptions = {}
+      def step_descriptions
+        @@step_descriptions
+      end
+
+      def add_description(re, step, message)
+        @@step_descriptions[re] = "#{ step }: #{ message }"                       
+      end
+
+      @@last_step = nil
+      def step_dependencies(name, dependencies = nil)
+
+        re = Regexp.new(/(?:^|\/)#{name}\/.*$/)
+
+        # Take the last_description and associate it with the name
+        if Rake.application.last_description
+          add_description(re, name, Rake.application.last_description)
+        end
+
+        if dependencies.nil? && ! @@last_step.nil?
+          dependencies = @@last_step
+        end
+        @@last_step = name
+
+        # Generate the Hash definition
+        case 
+        when dependencies.nil?
+          re
+        when String === dependencies || Symbol === dependencies
+          {re => lambda{|filename| filename.sub(name.to_s,dependencies.to_s) }}
+        when Array === dependencies
+          {re => lambda{|filename| dependencies.collect{|dep| filename.sub(name.to_s, dep.to_s) } }}
+        when Proc === dependencies
+          {re => dependencies}
+        end
+
+      end
+
+      def parse_filename(filename)
+        filename.match(/^(.*?)([^\/]*)\/([^\/]*)$/)
+        {
+          :prefix => $1 == "" ? "." : $1,
+          :step => $2,
+          :job => $3,
+        }
+      end
+    end
+  end
+
+  module Rake::Pipeline::Info
+
+    def self.info_file(filename)
+      info = Rake::Pipeline::Step.parse_filename(filename)
+      "#{info[:prefix]}/.info/#{info[:job]}.yaml"
+    end
+
+    def self.load_info(t)
+      filename = t.name
+      info_filename = info_file(filename)
+
+      if File.exists? info_filename
+        YAML.load(File.open(info_filename))
+      else
+        {}
+      end
+    end
+
+    def self.save_info(t, info = {})
+      filename = t.name
+      info_filename = info_file(filename)
+
+      FileUtils.mkdir_p File.dirname(info_filename) unless File.exists? File.dirname(info_filename)
+      File.open(info_filename,'w'){|file|
+        file.write YAML.dump info
+      }
+    end
+  end
+
+  @@steps = []
+
+  def steps
+    @@steps
+  end
+
+
+  NON_ASCII_PRINTABLE = /[^\x20-\x7e\s]/
+  def is_binary?(file)
+    binary = file.read(1024) =~ NON_ASCII_PRINTABLE
+    file.rewind
+    binary
+  end
+
+  def step_descriptions
+    Rake::Pipeline::Step.step_descriptions
+  end
+
+  def step_dependencies(*args)
+    Rake::Pipeline::Step.step_dependencies(*args)
+  end
+
+  def step_dir(step = nil, filename = nil)
+    filename ||= @@current_task.name
+    info = Rake::Pipeline::Step.parse_filename(filename)
+    "%s/%s" % [info[:prefix], step || info[:step]]
+  end
+
+  def input_filename(task = nil, step = nil)
+    task ||= @@current_task
+    if step.nil?
+      task.prerequisites.first
+    else
+      File.join(step_dir(step, task.name), job_name)
+    end
+  end
+
+  def output_filename(task = nil)
+    task ||= @@current_task
+    task.name
+  end
+
+
+  def infile(task, step = nil,  &block)
+    filename = input_filename(task, step)
+    File.open(filename) do |f|
+      block.call(f)
+    end
+  end
+
+  def outfile(task, &block)
+    filename = output_filename(task)
+    File.open(filename, 'w') do |f|
+      block.call(f)
+    end
+  end
+
+  def load_input(task, step = nil)
+    infile(task, step) do |f|
+      if is_binary?(f)
+        Marshal.load(f) 
+      else
+        f.read
+      end
+    end
+  end
+     
+
+  def save_output(task, output)
+    case 
+    when output.nil?
+      nil
+    when String === output
+      outfile(task){|f| f.write output } 
+    else
+      outfile(task){|f| f.write Marshal.dump(output) } 
+    end
+  end
+
+  # We cannot load the input variable before the block.call, so we need another method
+
+  # Load the input data from the previous step
+  def input(step = nil)
+    load_input(@@current_task, step) if @@current_task
+  end
+
+  if defined? SimpleWS::Jobs
+    def method_missing(symbol, *args)
+      if $_current_job.methods.include? symbol.to_s
+        $_current_job.send(symbol, *args)
+      else
+        raise "Method #{ symbol } not found"
+      end
+    end
+  else
+    # Announce steps
+    def step(state, message ="")
+      puts "#{ state }: #{ message }"
+    end
+
+    # Add values to the info file
+    def info(values = {})
+      info = Rake::Pipeline::Info.load_info(@@current_task)
+      info = info.merge values
+      Rake::Pipeline::Info.save_info(@@current_task, info)
+      info
+    end
+
+    def job_name
+      File.basename(@@current_task.name)
+    end
+  end
+
+  # Define a new step, it depends on the previously defined by default. It
+  # saves the output of the block so it can be loaded by the input method of
+  # the next step
+  def step_def(name, dependencies = nil, &block)
+    @@steps << name
+    rule step_dependencies(name, dependencies) do |t| 
+
+      # Save the task object to be able to load the input
+      @@current_task = t
+      
+      output = block.call(t)
+      
+      save_output(t, output)
+    end
+
+  end
+end
+
+if __FILE__ == $0
+
+  p Rake::Pipeline::Info.info_file('work/diseases/t')
+end

data/lib/simplews.rb

@@ -0,0 +1,425 @@
+require 'rubygems'
+#gem 'soap4r'
+gem 'soap4r-ruby1.9'
+require 'soap/rpc/standaloneServer'
+require 'builder'
+
+
+# SimpleWS is a class that wraps SOAP::RPC::StandaloneServer to ease the
+# implementation of Web Services, specifically the generation of the
+# +WSDL+ file. It provides a particular syntax that allows to specify
+# the methods that are going to be served along with the types of the
+# parameters and of the response so that the +WSDL+ can be generated
+# accordingly. Actual Servers can be instances of this class where
+# methods are assigned dynamically or of classes that extend SimpleWS.
+#   class TestWS < SimpleWS
+#    def hi(name)
+#      "Hi #{name}, how are you?"
+#    end
+#
+#    def initialize(*args)
+#      super(*args)
+#      serve :hi, %w(name), :name => :string, :return => :string
+#
+#      serve :bye, %w(name), :name => :string, :return => :string do |name|
+#          "Bye bye #{name}. See you soon."
+#      end
+#
+#    end
+#  end
+#
+#  # Creating a server and starting it
+#  
+#  server = TestWS.new("TestWS", "Greeting Services", 'localhost', '1984') 
+#  server.wsdl("TestWS.wsdl")
+#
+#  Thread.new do
+#     server.start
+#  end
+#
+#  # Client code. This could be run in another process.
+#
+#  driver = SimpleWS::get_driver('http://localhost:1984', "TestWS")
+#  puts driver.hi('Gladis')  #=> "Hi Gladis, how are you?"
+#  puts driver.bye('Gladis') #=> "Bye bye Gladis. See you soon."
+#
+
+
+
+class SimpleWS <  SOAP::RPC::StandaloneServer
+  # Saves method defined in the class to be served by the instances
+  INHERITED_METHODS    = {} unless defined? INHERITED_METHODS
+
+  # This is a helper function for clients. Given the +url+ where the
+  # server is listening, as well as the name of the server, it can
+  # manually access the +wsdl+ function and retrieve the complete +WSDL+
+  # file. This works *only* in web servers of class SimpleWS, not on
+  # the general SOAP::RPC::StandaloneServer or any other type of web
+  # server.
+  def self.get_wsdl(url, name)
+     require 'soap/rpc/driver'
+     driver = SOAP::RPC::Driver.new(url, "urn:#{ name }")
+     driver.add_method('wsdl')
+     driver.wsdl
+  end
+
+  # Builds on the get_wsdl function to provide the client with a
+  # reference to the driver. Again, only works with SimpleWS servers.
+  def self.get_driver(url, name)
+    require 'soap/wsdlDriver'
+    require 'fileutils'
+
+    tmp = File.open("/tmp/simpleWS.wsdl",'w')
+    tmp.write SimpleWS::get_wsdl(url, name)
+    tmp.close
+    driver = SOAP::WSDLDriverFactory.new("/tmp/simpleWS.wsdl").create_rpc_driver
+    FileUtils.rm "/tmp/simpleWS.wsdl"
+
+    driver
+  end
+
+  attr_accessor :description
+
+  # Creates an instance of a Server. The parameter +name+ specifies the
+  # +namespace+ used in the +WSDL+, +description+ is the description
+  # also included in the +WSDL+. The parameters +host+ and +port+,
+  # specify where the server will be listening, they are parameters of
+  # the +super+ class SOAP::RPC::StandaloneServer, they are made
+  # explicit here because they are included in the +WSDL+ as well.
+  def initialize(name=nil, description=nil, host=nil, port=nil, *args, &block)
+    name ||= self.class.to_s
+    description ||= "Web Server for #{ name }"
+    host ||= "localhost"
+    port ||= "1984"
+
+    super(description, "urn:#{ name }", host, port, *args)
+
+    @host        = host
+    @port        = port
+    @name        = name
+    @description = description
+    @messages    = []
+    @operations  = []
+    @bindings    = []
+    @method_descriptions = {}
+    @method_order        = []
+
+    if block_given?
+      instance_eval &block
+    end
+
+    puts "Server #{ name } at #{ host }:#{ port }"
+    
+ 
+    desc "Return the WSDL describing the web server"
+    param_desc :return => "WSDL description"
+    serve :wsdl, %w(),  :return => :string
+
+    desc "Return HMLT table with documentation for the web service"
+    param_desc :return => "HTML table with documentation"
+    serve :documentation, %w(),  :return => :string
+
+    INHERITED_METHODS.each{|name, info|
+      @@last_description = info[:description]
+      @@last_param_description = info[:param_descriptions]
+      serve name, info[:args], info[:types], &info[:block]
+    }
+  end
+
+  def name=(name)
+    @name = name
+    appname = name
+    default_namespace = "urn:#{name}"
+  end
+
+  # Add a description for the next method served.
+  @@last_description = nil
+  @@last_param_description = nil
+  def desc(text = "")
+    @@last_description = text
+  end
+
+  # Add descriptions for the parameters of the next method served
+  def param_desc(param_descriptions = {})
+    @@last_param_description = {} 
+    param_descriptions.each{|param, description| @@last_param_description[param.to_s] = description}
+  end
+
+  # Add a description for the next method served defined in at the class level
+  def self.desc(text = "")
+    @@last_description = text
+  end
+
+  # Add descriptions for the parameters of the next method served at the class
+  # level
+  def self.param_desc(param_descriptions = {})
+    @@last_param_description = {} 
+    param_descriptions.each{|param, description| @@last_param_description[param.to_s] = description}
+  end
+
+  # This method tells the server to provide a method named by the +name+
+  # parameter, with arguments listed in the +args+ parameter. The
+  # +types+ parameter specifies the types of the arguments as will be
+  # described in the +WSDL+ file (see the TYPES2WSDL constant). The
+  # actual method called will be the one with the same name. Optionally
+  # a block can be provided, this block will be used to define a
+  # function named as in name.
+  #
+  # If the method returns something, then the type of the return value
+  # must be specified in the +types+ parameter as :return. If not value
+  # for :return parameter is specified in the +types+ parameter the
+  # method is taken to return no value. Other than that, if a parameter
+  # type is omitted it is taken to be :string.
+  def serve(name, args=[], types={}, &block)
+
+    @method_descriptions[name] = {:args => args, :types => types, :block => block, 
+      :description => @@last_description, :param_descriptions => @@last_param_description}
+    
+    @@last_description = nil
+    @@last_param_description = nil
+
+    @method_order << name
+    if block
+      inline_name = "_inline_" + name.to_s
+      add_to_ruby(inline_name, &block)
+      add_method_as(self,inline_name, name.to_s,*args)
+    else
+      add_method(self,name.to_s,*args)
+    end
+
+    add_to_wsdl(name, args, types)
+
+    nil
+  end
+
+  # Saves the method to be served by the instances. The initialization of an
+  # instance check if there where any methods declared to be served in the class
+  # and add them.
+  def self.serve(name, args=[], types={}, &block)
+    INHERITED_METHODS[name] = {:args => args, :types => types, :block => block, 
+      :description => @@last_description, :param_descriptions => @@last_param_description}
+    @@last_description = nil
+    @@last_param_description = nil
+  end
+
+  # If +filename+ is specified it saves the +WSDL+ file in that file. If
+  # no +filename+ is specified it returns a string containing  the
+  # +WSDL+. The no parameter version is served by default, so that
+  # clients can use this method to access the complete +WSDL+ file, as
+  # used in get_wsdl and get_driver.
+  def wsdl(filename = nil)
+    wsdl = WSDL_STUB.dup
+    wsdl.gsub!(/\$\{MESSAGES\}/m,@messages.join("\n"))
+    wsdl.gsub!(/\$\{OPERATIONS\}/m,@operations.join("\n"))
+    wsdl.gsub!(/\$\{BINDINGS\}/m,@bindings.join("\n"))
+    wsdl.gsub!(/\$\{NAME\}/,@name)
+    wsdl.gsub!(/\$\{DESCRIPTION\}/,@description)
+    wsdl.gsub!(/\$\{LOCATION\}/,"http://#{ @host }:#{ @port }")
+    
+    if filename
+      directory = File.dirname(File.expand_path(filename))
+      FileUtils.mkdir_p directory unless File.exists? directory
+      File.open(filename,'w') {|f| f.write wsdl }
+      nil
+    else
+      wsdl
+    end
+  end
+
+  def documentation(filename = nil)
+    html_table =  Builder::XmlMarkup.new(:indent => 2).table :class => "WS_documentation" do |xml|
+      xml.thead do 
+        xml.tr do
+          xml.th "Operation", :class => "WS_operation" 
+          xml.th "Parameters", :class => "WS_parameters"
+          xml.th "Documentation", :class => "WS_documentation" 
+        end
+      end
+      xml.tbody do
+        @method_order.each do |method|
+          desc = @method_descriptions[method][:description] || ""
+          case
+          when method.to_s == 'wsdl' || method.to_s == 'documentation'
+            type = 'WS_documentation'
+          when desc =~ /^Job management:/
+            type = 'WS_job_management'
+          when @method_descriptions[method][:args].include?( :sugested_name )
+            type = 'WS_task'
+          else
+            type = 'WS_normal'
+          end
+          xml.tr :class => type, :id => "WS_method_#{method}" do
+            xml.td method.to_s, :class => "WS_operation" 
+
+            xml.td :class => "WS_parameters" do
+              description = @method_descriptions[method]
+              method_parameters = description[:args]
+              method_parameters += ['return'] unless  description[:types][:return] == false || description[:types]['return'] == false
+              if method_parameters.any?
+                xml.dl :class => "WS_parameter_documentation" do
+                  method_parameters.each do |param|
+                    if param.to_s == 'return'
+                      xml.dt param, :class => 'WS_return' 
+                    else
+                      xml.dt param
+                    end
+                    
+                    if description[:param_descriptions]
+                      xml.dd description[:param_descriptions][param.to_s] || "" 
+                    else
+                      xml.dd
+                    end
+                  end
+                end
+              end
+            end
+            xml.td desc, :class => "WS_documentation" 
+          end
+        end
+      end
+    end
+
+    if filename
+      directory = File.dirname(File.expand_path(filename))
+      FileUtils.mkdir_p directory unless File.exists? directory
+      File.open(filename,'w') {|f| f.write html_table }
+      nil
+    else
+      html_table
+    end
+  end
+
+  private
+
+  def add_to_ruby(name, &block)
+    self.class.send(:define_method, name, block)
+  end
+
+  def add_to_wsdl(name, args, types)
+    description = @method_descriptions[name]
+    message =  Builder::XmlMarkup.new(:indent => 2).message :name => "#{ name }Request" do |xml|
+      
+      args.each do |param|
+        type = types[param.to_s] || types[param.to_sym] || :string
+        type = type.to_sym
+
+        xml.part :name => param, :type => TYPES2WSDL[type] do
+          param_descriptions = description[:param_descriptions]
+
+          if param_descriptions && param_descriptions[param.to_s]
+            xml.documentation  param_descriptions[param.to_s]
+          end
+        end
+
+      end
+    end
+    @messages << message
+
+    message =  Builder::XmlMarkup.new(:indent => 2).message :name => "#{ name }Response" do |xml|
+      type = [types[:return], types["return"]].compact.first 
+      type = :string if type.nil? 
+      if type
+        type = type.to_sym
+        xml.part :name => 'result', :type => TYPES2WSDL[type] do
+          param_descriptions = description[:param_descriptions]
+
+          if param_descriptions && param_descriptions['return']
+            xml.documentation  param_descriptions['return']
+          end
+        end
+      end
+    end
+    @messages << message
+
+    operation = Builder::XmlMarkup.new(:indent => 2).operation :name => "#{ name }" do |xml|
+      xml.documentation description[:description]  if description[:description]
+      xml.input :message => "tns:#{ name }Request"
+      xml.output :message => "tns:#{ name }Response"
+    end
+
+    @operations << operation
+
+    binding = Builder::XmlMarkup.new(:indent => 2).operation :name => "#{ name }" do |xml|
+      xml.tag! 'soap:operation'.to_sym, :soapAction => "urn:${NAME}##{name}", :style => 'rpc'
+      xml.input do |xml|
+        xml.tag! 'soap:body'.to_sym, :namespace => "urn:${NAME}", :encodingStyle => "http://schemas.xmlsoap.org/soap/encoding/", :use => "encoded"
+      end                                                                                                                                         
+      xml.output do |xml|                                                                                                                         
+        xml.tag! 'soap:body'.to_sym, :namespace => "urn:${NAME}", :encodingStyle => "http://schemas.xmlsoap.org/soap/encoding/", :use => "encoded"
+      end
+    end
+
+    @bindings << binding
+  end
+
+
+  if ! defined? WSDL_STUB
+  WSDL_STUB =<<EOT
+<?xml version="1.0"?>
+<definitions xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" 
+xmlns:tns="${NAME}-NS"
+xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" 
+xmlns:si="http://soapinterop.org/xsd" 
+xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" 
+xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+xmlns="http://schemas.xmlsoap.org/wsdl/" 
+targetNamespace="${NAME}-NS">
+
+
+   <types>
+      <schema xmlns="http://www.w3.org/2001/XMLSchema"
+         targetNamespace="${NAME}-NS"
+         xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+         xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/">
+         <complexType name="ArrayOfString">
+            <complexContent>
+               <restriction base="soapenc:Array">
+                  <attribute ref="soapenc:arrayType" 
+                  wsdl:arrayType="string[]"/>
+               </restriction>
+            </complexContent>
+         </complexType>
+       </schema>
+   </types>
+
+${MESSAGES}
+<portType name="${NAME}">
+${OPERATIONS}
+</portType>
+
+<binding name="${NAME}Binding" type="tns:${NAME}">
+   <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
+${BINDINGS}
+</binding>
+<service name="${NAME}">
+    <documentation>${DESCRIPTION}</documentation>
+ 
+    <port name="${NAME}" binding="tns:${NAME}Binding">
+       <soap:address location="${LOCATION}"/>
+    </port>
+</service>
+
+</definitions>
+EOT
+  end
+
+  if ! defined? TYPES2WSDL
+    TYPES2WSDL = {
+      :boolean => 'xsd:boolean',
+      :string  => 'xsd:string',
+      :text    => 'xsd:string',
+      :tsv     => 'xsd:string',
+      :yaml    => 'xsd:string',
+      :integer => 'xsd:integer',
+      :float   => 'xsd:float',
+      :array   => 'tns:ArrayOfString',
+      :binary  => 'xsd:base64Binary',
+    }
+  end
+
+
+end
+
+