soapex 0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 YOUR NAME
+
+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

@@ -0,0 +1,4 @@
+templates
+=================
+
+A plugin for the Merb framework that provides ....

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+GEM = "soapex"
+VERSION = "0.1"
+AUTHOR = "Brian Hawthorne"
+EMAIL = "brian.lee.hawthorne at gmail dot com"
+HOMEPAGE = "http://example.com"
+SUMMARY = "A gem that provides extended functionality to the soap4r package"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+  s.requirements << 'soap4r v 1.5.6 or greater'
+  s.requirements << 'soapex v 0.1 or greater'
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{VERSION}}
+end

data/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/lib/soapex/client.rb

@@ -0,0 +1,95 @@
+require 'soap/soap'
+require 'soapex/error'
+require 'soapex/services'
+
+def atsym(name)
+  ("@"+(name.to_s)).to_sym
+end
+
+def fix_case_up(name)
+  (newname = name.dup)[0] = name[0,1].upcase # upper first character
+    newname
+  end
+
+module SOAP::MultiService
+
+  class Client
+
+    class Config
+
+      def initialize(options={})
+        @sandbox = false
+        IO.foreach(filename) do |line|
+          next if line =~ /^#/
+          name, value = line.split('=')
+          value = (options[name] || value.strip)
+          instance_variable_set(atsym(name), value)
+        end
+        @sandbox = ['True', 'true', '1'].include?(@sandbox.strip)
+      end
+
+      def filename
+        raise NotImplementedError.new(
+          'method filename must be implemented by a subclass')
+      end
+    end
+
+    attr_reader :config, :drivers
+
+    def initialize(options={})
+      @methodMap = Hash.new
+      prepareDrivers
+    end
+        
+    def method_missing(m, *args)
+      methodName = m.id2name
+      requestName = fix_case_up(methodName) # upper first character
+
+      if driver = getMethodDriver(methodName)
+        serviceName = driver.class.name.split("::").last
+        req = getRequestClass(serviceName, requestName).new(*args)
+        return driver.method(methodName).call(req)
+      else
+        raise(SOAP::MultiService::UnknownAPICall,
+          "Unknown API Call: #{requestName}", caller)
+      end
+
+      # Handle application level error
+      rescue SOAP::FaultError => fault
+        raise(SOAP::MultiService::ApiError.new(fault),
+          "#{methodName} Call Failed: #{fault.faultstring.to_s}", caller)
+    end
+        
+    private
+
+    def modulePrefix
+      raise NotImplementedError.new('method modulePrefix')
+    end
+
+    def prepareDrivers
+      raise NotImplementedError.new(
+        'method prepareDrivers must be implemented by a subclass')
+    end
+
+    def updateMethodMap
+      @methodMap.update(
+        SOAP::MultiService::Services.makeMethodMap(@drivers.values))
+    end
+
+    def getMethodDriver(methodName)
+      @methodMap[methodName]
+    end       
+     
+    def getRequestClass(serviceName, requestName)
+      eval "#{modulePrefix}::#{serviceName}::#{requestName}"
+    end
+
+    def makeDriver(name, location=nil)
+      driver = eval("#{modulePrefix}::#{name}Service::#{name}Service").new
+      driver.prepare(@headers, location)
+      driver
+    end
+  end
+end
+
+

data/lib/soapex/driver.rb

@@ -0,0 +1,37 @@
+require 'soap/rpc/driver'
+require 'soap/header/simplehandler'
+
+module SOAP::MultiService
+
+  class Driver < SOAP::RPC::Driver
+
+    class HeaderHandler < SOAP::Header::SimpleHandler
+      def initialize(tag, value)
+        super(XSD::QName.new(nil, tag))
+        @tag = tag
+        @value = value
+      end
+    
+      # The initial handler from the sample was wrong,
+      # it generated 2 level of tags
+      def on_simple_outbound
+        @value
+      end
+    end
+
+    def setHeaders(header_hash)
+      header_hash.map do |key, value|
+        self.headerhandler << \
+          SOAP::MultiService::Driver::HeaderHandler.new(key.to_s, value)
+      end
+    end
+
+    def prepare(headers, endpoint=nil)
+      self.proxy.endpoint_url = endpoint if endpoint
+      setHeaders(headers)
+      (self.wiredump_dev = STDOUT) if $DEBUG
+      self.options['protocol.http.ssl_config.verify_mode'] = nil
+      (self.wiredump_file_base = "debug") if $DEBUG
+    end
+  end
+end

data/lib/soapex/error.rb

@@ -0,0 +1,60 @@
+def atsym(name)
+  ("@"+(name.to_s)).to_sym
+end
+
+module SOAP::MultiService
+
+  # Generic error provides base class for more specific errors
+  # while still allowing a blanket rescue for any multiservice error.
+  class Error < StandardError; end
+
+  # Raised if a call is made to a method that does not exist in the multiservice API
+  class UnknownAPICall < Error; end
+        
+  # Raised if an attempt is made to instantiate a type that does not exist in
+  # the multiservice SOAP API
+  class UnknownType < Error; end
+        
+  # Raised if a call returns with a SOAP error
+  class ApiError < Error
+    (Attrs = [
+      :soap_faultcode,
+      :soap_faultstring,
+      :code,
+      :internal,
+      :message,
+      :trigger,
+      :violations
+    ]).each {|a|attr(a)}
+    
+    def initialize(fault)
+      @soap_faultcode = getOrNil(fault, 'faultcode')
+      @soap_faultstring = getOrNil(fault, 'faultstring')
+      @code = getOrNil(fault.detail, 'code')
+      @internal = getOrNil(fault.detail,'internal')
+      @message = getOrNil(fault.detail,'message')
+      @trigger = getOrNil(fault.detail,'trigger')
+      @violations = getOrNil(fault.detail,'violations')
+    end
+
+    def inspect
+      "#<SOAP::MultiService::ApiError: #{message}>"
+    end
+
+    def message
+      Attrs.map{|a| [a, instance_variable_get(atsym(a))] }.
+         select{|p| p[1] }.
+            map{|p| "#{p[0]}: #{p[1].inspect}" }.join(', ')
+    end
+
+    def to_s
+      message
+    end
+      
+    private
+    def getOrNil(obj, meth)
+        obj.respond_to?(meth) ? eval("obj.#{meth}") : nil
+    end
+  end
+end
+

data/lib/soapex/mapping.rb

@@ -0,0 +1,31 @@
+require 'soap/mapping/mapping'
+require 'soap/mapping/registry'
+
+def needspatch
+  SOAP::Mapping.set_attributes(a=[], :x=>10)
+  a != [10]
+rescue Exception => e
+  true
+end
+  
+if needspatch
+
+  # Apply mapping patch only if it has not already been applied.
+  class << SOAP::Mapping
+    alias set_attributes_old set_attributes
+    def set_attributes(obj, values)
+      if not obj.is_a?(::SOAP::Mapping::Object) and obj.kind_of?(Array)
+        values.each do |key, value|
+          if value.kind_of?(Array)
+            obj.concat(value)
+          else
+            obj << value
+          end
+        end
+      else
+        set_attributes_old(obj, values)
+      end
+    end
+  end
+
+end

data/lib/soapex/services.rb

@@ -0,0 +1,33 @@
+module SOAP::MultiService
+
+  class Services
+    @version_services = {}
+
+    def self.getVersions
+      @version_services.keys
+    end
+
+    def self.getServices(version)
+      @version_services[version]
+    end
+
+    def self.requireDrivers(version, options={})
+      getServices(version).each do |servicename|
+        requireDriver(servicename, version, options)
+      end
+    end
+
+    def self.requireDriver(service, version, options={})
+      raise NotImplementedError.new(
+        'method requireDriver must be implemented by a subclass')
+    end
+
+    def self.makeMethodMap(drivers)
+      methodMap = Hash.new
+      drivers.each do |d|
+        d.class::Methods.each {|m| methodMap[m[1]] = d}
+      end
+      methodMap
+    end
+  end
+end

data/lib/soapex/wsdl2ruby.rb

@@ -0,0 +1,168 @@
+# WSDL4R - WSDL to ruby mapping library.
+# Copyright (C) 2002-2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'logger'
+require 'xsd/qname'
+require 'wsdl/importer'
+require 'wsdl/soap/classDefCreator'
+require 'wsdl/soap/servantSkeltonCreator'
+require 'wsdl/soap/driverCreator'
+require 'wsdl/soap/clientSkeltonCreator'
+require 'wsdl/soap/standaloneServerStubCreator'
+require 'wsdl/soap/cgiStubCreator'
+require 'wsdl/soap/classNameCreator'
+
+
+module SOAP
+module MultiService
+
+class WSDL2Ruby
+  attr_reader :options, :logger, :basedir
+
+  Options = [:classdef, :mapping_registry, :driver, :client_skelton, :servant_skelton,
+    :standalone_server_stub, :cgi_stub]
+
+  def initialize(basedir, force=false, logger=nil)
+    @basedir = basedir
+    @force = force
+    @logger ||= Logger.new(STDERR)
+    @namecreator = WSDL::SOAP::ClassNameCreator.new
+  end
+
+  def run(location, options={})
+    @modulepath = (options[:modulepath] || "")
+    @wsdl = import(location)
+    @servicename = @wsdl.services[0].name.name
+    Options.each do |optname|
+      if options.key?(optname)
+        servicename = (options[optname] || @servicename)
+        method("create_#{optname.to_s}".to_sym).call(servicename)
+      end
+    end
+  end
+
+private
+
+  def create_classdef(servicename)
+    @logger.info { "Creating class definition." }
+    @classdef_filename = servicename + '.rb'
+    write_file(@classdef_filename) do |f|
+      f << WSDL::SOAP::ClassDefCreator.new(@wsdl, @namecreator, @modulepath).dump
+    end
+  end
+
+  def create_mapping_registry(servicename)
+    @logger.info { "Creating mapping registry." }
+    @mapping_registry_filename = servicename + 'MappingRegistry.rb'
+    write_file(@mapping_registry_filename) do |f|
+      f << "require '#{@classdef_filename}'\n" if @classdef_filename
+      f << WSDL::SOAP::MappingRegistryCreator.new(@wsdl, @namecreator, @modulepath).dump
+    end
+  end
+
+  def create_driver(servicename)
+    @logger.info { "Creating driver." }
+    @driver_filename = servicename + 'Driver.rb'
+    write_file(@driver_filename) do |f|
+      f << "require '#{@classdef_filename}'\n\n" if @classdef_filename
+      f << WSDL::SOAP::DriverCreator.new(@wsdl, @namecreator, @modulepath).dump(create_name(servicename))
+    end
+  end
+
+  def create_client_skelton(servicename)
+    @logger.info { "Creating client skelton." }
+    @client_skelton_filename = servicename + 'Client.rb'
+    write_file(@client_skelton_filename) do |f|
+      f << shbang << "\n"
+      f << "require '#{@driver_filename}'\n\n" if @driver_filename
+      f << WSDL::SOAP::ClientSkeltonCreator.new(@wsdl, @namecreator, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def create_servant_skelton(servicename)
+    @logger.info { "Creating servant skelton." }
+    @servant_skelton_filename = servicename + 'Servant' + '.rb'
+    write_file(@servant_skelton_filename) do |f|
+      f << "require '#{@classdef_filename}'\n\n" if @classdef_filename
+      f << WSDL::SOAP::ServantSkeltonCreator.new(@wsdl, @namecreator, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def create_cgi_stub(servicename=nil)
+    @logger.info { "Creating CGI stub." }
+    @cgi_stubFilename = servicename + '.cgi'
+    write_file(@cgi_stubFilename) do |f|
+      f << shbang << "\n"
+      if @servant_skelton_filename
+	f << "require '#{@servant_skelton_filename}'\n\n"
+      end
+      f << WSDL::SOAP::CGIStubCreator.new(@wsdl, @namecreator, @modulepath).dump(create_name(servicename))
+    end
+  end
+
+  def create_standalone_server_stub(servicename=nil)
+    @logger.info { "Creating standalone stub." }
+    @standalone_server_stub_filename = servicename + '.rb'
+    write_file(@standalone_server_stub_filename) do |f|
+      f << shbang << "\n"
+      f << "require '#{@servant_skelton_filename}'\n\n" if @servant_skelton_filename
+      f << WSDL::SOAP::StandaloneServerStubCreator.new(@wsdl, @namecreator, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def write_file(filename)
+    check_file(filename) or return
+
+    if @basedir
+      filename = File.join(basedir, filename)
+    end
+    File.open(filename, "w") do |f|
+      yield f
+    end
+  end
+
+  def check_file(filename)
+    if @basedir
+      filename = File.join(basedir, filename)
+    end
+    if FileTest.exist?(filename)
+      if @force
+	@logger.warn {
+	  "File '#{filename}' exists but overrides it."
+	}
+	true
+      else
+	@logger.warn {
+	  "File '#{filename}' exists.  #{$0} did not override it."
+	}
+	false
+      end
+    else
+      @logger.info { "Creates file '#{filename}'." }
+      true
+    end
+  end
+
+  def shbang
+    "#!/usr/bin/env ruby"
+  end
+
+  def create_name(name)
+    name ? XSD::QName.new(@wsdl.targetnamespace, name) : nil
+  end
+
+  def import(location)
+    WSDL::Importer.import(location)
+  end
+end
+
+end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: soapex
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-01-20 00:00:00 -08:00
+summary: A gem that provides extended functionality to the soap4r package
+require_paths: 
+- lib
+email: brian.lee.hawthorne at gmail dot com
+homepage: http://example.com
+rubyforge_project: 
+description: A gem that provides extended functionality to the soap4r package
+autorequire: soapex
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Brian Hawthorne
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/soapex.rb
+- lib/soapex
+- lib/soapex/wsdl2ruby.rb
+- lib/soapex/error.rb
+- lib/soapex/mapping.rb
+- lib/soapex/driver.rb
+- lib/soapex/services.rb
+- lib/soapex/client.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+executables: []
+
+extensions: []
+
+requirements: 
+- soap4r v 1.5.6 or greater
+- soapex v 0.1 or greater
+dependencies: []
+