jeremydurham-serviceproxy 0.0.1 → 0.1.0

data/README

@@ -2,44 +2,26 @@ ServiceProxy
 
 ServiceProxy is a lightweight SOAP library for Ruby. 
 
-How it works
-
-Unlike SOAP4R, this library takes a very different approach to building 
-requests and parsing responses. There is little magic and no code 
-generation with this library. 
-
-You will need to understand some simple things about SOAP before you
-can use this library. Using a tool like SOAPUI or SoapClient, you can
-easily get enough information to use this library with existing SOAP
-services.
-
-For each service endpoint you want to connect to, you will need to 
-subclass ServiceProxy.
-
-Let's say you want to call the method cool1 on a service:
-
-First, you create a subclass:
-
-class SuperCoolService < ServiceProxy
-  
-  def build_cool1(options)
-    # This will generate a simple SOAP envelope. Using the xml block local, you 
-    # can inject XML into the body of the envelope.
-    soap_envelope(options) do |xml|
-      # your XML here
-    end
-  end
-  
-  def parse_cool1(response)
-    # The response parameter is a simple Net::HTTP response
-    # here, we use Hpricot to parse it, but you could use
-    # Nokogiri, REXML, etc
-    xml = Hpricot.XML(response.body)
-    xml.at("cool1Result").inner_text
-  end
-end
-
-Next, you can attempt to call the service:
-
-service = SuperCoolService.new(url_to_wsdl)
-service.cool1
+HOW IT WORKS
+
+Loading the library:
+
+require 'rubygems'
+require 'service_proxy/base'
+
+GENERATING A PROXY
+
+ServiceProxy comes with a simple generator to get started. It can be invoked
+as follows:
+
+wsdl2proxy [wsdl]
+
+This will generate a file named default.rb, in the current directory. The class
+will be named GeneratedService, and will define build and parse methods for all
+of the available service methods.
+
+Please refer to the specs for extended usage examples.
+
+CONTRIBUTORS
+
+Rich Cavanaugh

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 require 'rubygems/specification'
 require 'rake/rdoctask'
 require 'spec/rake/spectask'
-require File.join(File.dirname(__FILE__), 'lib', 'service_proxy')
+require File.join(File.dirname(__FILE__), 'lib', 'service_proxy', 'base')
 
 NAME = "serviceproxy"
 AUTHOR = "Jeremy Durham"
@@ -18,7 +18,7 @@ PROJECT_SUMMARY     = SUMMARY
 PROJECT_DESCRIPTION = SUMMARY
 
 PKG_BUILD    = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
-GEM_VERSION  = ServiceProxy::VERSION + PKG_BUILD
+GEM_VERSION  = ServiceProxy::Base::VERSION + PKG_BUILD
 RELEASE_NAME = "REL #{GEM_VERSION}"
 #
 # ==== Gemspec and installation
@@ -26,7 +26,7 @@ RELEASE_NAME = "REL #{GEM_VERSION}"
 
 spec = Gem::Specification.new do |s|
   s.name = NAME
-  s.version = ServiceProxy::VERSION
+  s.version = ServiceProxy::Base::VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "LICENSE"]
@@ -36,6 +36,7 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
   s.require_path = 'lib'
+  s.executables = ['wsdl2proxy']
   s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,spec}/**/*")
   
   s.add_dependency "nokogiri"
@@ -48,7 +49,7 @@ end
 
 desc "install the gem locally"
 task :install => [:clean, :package] do
-  sh %{sudo gem install pkg/#{NAME}-#{ServiceProxy::VERSION} --no-update-sources}
+  sh %{sudo gem install pkg/#{NAME}-#{ServiceProxy::Base::VERSION} --no-update-sources}
 end
 
 desc "create a gemspec file"
@@ -91,4 +92,4 @@ namespace :spec do
 end
 
 desc 'Default: run unit tests.'
-task :default => 'spec'
+task :default => 'spec'

data/bin/wsdl2proxy

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'service_proxy/base'
+
+def underscore(camel_cased_word)
+  camel_cased_word.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+end
+
+unless ARGV.size > 0
+  puts "Usage: #{$0} [endpoint]"
+  exit!
+end
+
+template_filename = File.dirname(__FILE__) + '/../lib/templates/proxy.rbt'
+proxy = ServiceProxy::Base.new(ARGV[0])
+output_filename = 'default.rb'
+output_klass_name = 'GeneratedService'
+output = ''
+proxy.service_methods.each do |service_method|
+  output << <<-EOS  
+
+  def build_#{underscore(service_method)}(options)
+    soap_envelope(options) do |xml|
+    end
+  end
+  
+  def parse_#{underscore(service_method)}(response)
+    Hpricot.XML(response.body)
+  end  
+  EOS
+end
+template = File.read(template_filename)
+template.gsub!(/%name%/, output_klass_name)
+template.gsub!(/%body%/, output)
+File.open(output_filename, 'w') { |f| f.puts template }
+puts "Generated proxy #{output_filename} - You can use the proxy by executing #{output_klass_name}.new('#{ARGV[0]}')"

data/lib/service_proxy/base.rb

@@ -0,0 +1,154 @@
+require 'rubygems'
+require 'nokogiri'
+require 'net/http'
+require 'net/https'
+require 'builder'
+require 'uri'
+
+module ServiceProxy
+  class Base
+    VERSION = '0.1.0'
+  
+    attr_accessor :endpoint, :service_methods, :soap_actions, :service_uri, :http, :service_http, :uri, :debug, :wsdl, :target_namespace, :service_ports
+
+    def initialize(endpoint)
+      self.endpoint = endpoint
+      self.setup
+    end
+  
+    def call_service(options)
+      method   = options[:method]
+      headers  = { 'content-type' => 'text/xml; charset=utf-8', 'SOAPAction' => self.soap_actions[method] }
+      body     = build_request(method, options)
+      response = self.service_http.request_post(self.service_uri.path, body, headers)    
+      parse_response(method, response)
+    end  
+
+  protected
+
+    def setup
+      self.soap_actions = {}
+      self.service_methods = []
+      setup_uri
+      self.http = setup_http(self.uri)
+      get_wsdl
+      parse_wsdl
+      setup_namespace
+    end
+  
+    def service_uri
+      @service_uri ||= if self.respond_to?(:service_port)
+        self.service_port
+      else
+        self.uri
+      end
+    end
+  
+    def service_http
+      @service_http ||= unless self.service_uri == self.uri
+        local_http = self.setup_http(self.service_uri)
+        setup_https(local_http) if self.service_uri.scheme == 'https'
+        local_http
+      else
+        self.http
+      end
+    end
+  
+    def setup_http(local_uri)
+      raise ArgumentError, "Endpoint URI must be valid" unless local_uri.scheme    
+      local_http = Net::HTTP.new(local_uri.host, local_uri.port)
+      setup_https(local_http) if local_uri.scheme == 'https'
+      local_http.set_debug_output(STDOUT) if self.debug
+      local_http.read_timeout = 5
+      local_http
+    end
+
+    def setup_https(local_http)
+      local_http.use_ssl = true
+      local_http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+  
+  private
+  
+    def setup_uri
+      self.uri = URI.parse(self.endpoint)
+    end
+    
+    def get_wsdl
+      response = self.http.get("#{self.uri.path}?#{self.uri.query}")
+      self.wsdl = Nokogiri.XML(response.body)    
+    end
+  
+    def parse_wsdl
+      method_list = []    
+      self.wsdl.xpath('//*[name()="soap:operation"]').each do |operation|
+        operation_name = operation.parent.get_attribute('name')
+        method_list << operation_name
+        self.soap_actions[operation_name] = operation.get_attribute('soapAction')
+      end
+      raise RuntimeError, "Could not parse WSDL" if method_list.empty?
+      self.service_methods = method_list.sort
+    
+      port_list = {}
+      self.wsdl.xpath('//wsdl:port', {"xmlns:wsdl" => 'http://schemas.xmlsoap.org/wsdl/'}).each do |port|
+        name = underscore(port['name'])
+        location = port.xpath('./*[@location]').first['location']
+        port_list[name] = location
+      end
+      self.service_ports = port_list
+    end
+  
+    def setup_namespace
+      self.target_namespace = self.wsdl.namespaces['xmlns:tns']
+    end
+
+    def build_request(method, options)
+      builder  = underscore("build_#{method}")    
+      self.respond_to?(builder) ? self.send(builder, options).target! : 
+                                  soap_envelope(options).target!
+    end
+  
+    def parse_response(method, response)
+      parser = underscore("parse_#{method}")
+      self.respond_to?(parser) ? self.send(parser, response) : 
+                                 raise(NoMethodError, "You must define the parse method: #{parser}")
+    end
+  
+    def soap_envelope(options, &block)
+      xsd = 'http://www.w3.org/2001/XMLSchema'
+      env = 'http://schemas.xmlsoap.org/soap/envelope/'
+      xsi = 'http://www.w3.org/2001/XMLSchema-instance'
+      xml = Builder::XmlMarkup.new
+      xml.env(:Envelope, 'xmlns:xsd' => xsd, 'xmlns:env' => env, 'xmlns:xsi' => xsi) do
+        xml.env(:Body) do
+          xml.__send__(options[:method].to_sym, "xmlns" => self.target_namespace) do        
+            yield xml if block_given?
+          end
+        end
+      end
+      xml
+    end
+      
+    def method_missing(method, *args)
+      method_name = method.to_s
+      case method_name
+      when /_uri$/
+        sp_name = method_name.gsub(/_uri$/, '')
+        super unless self.service_ports.has_key?(sp_name)
+        URI.parse(self.service_ports[sp_name])
+      else
+        options = args.pop || {}
+        super unless self.service_methods.include?(method_name)
+        call_service(options.update(:method => method_name))
+      end
+    end
+  
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end  
+  end
+end

data/spec/service_helper.rb

@@ -1,7 +1,7 @@
 require 'hpricot'
 
 # Service Endpoints
-class InstantMessageService < ServiceProxy
+class InstantMessageService < ServiceProxy::Base
   
   def parse_get_version(response)
     xml = Hpricot.XML(response.body)
@@ -20,7 +20,7 @@ class InstantMessageService < ServiceProxy
   end
 end
 
-class ISBNService < ServiceProxy  
+class ISBNService < ServiceProxy::Base  
   
   def build_is_valid_isbn13(options)
     soap_envelope(options) do |xml|
@@ -32,9 +32,15 @@ class ISBNService < ServiceProxy
     xml = Hpricot.XML(response.body)
     xml.at("m:IsValidISBN13Result").inner_text == 'true' ? true : false
   end
+  
+  def service_port
+    local_uri = URI.parse(self.isbn_service_soap_uri.to_s)
+    local_uri.path << "?dummy=1"
+    local_uri
+  end
 end
 
-class SHAGeneratorService < ServiceProxy
+class SHAGeneratorService < ServiceProxy::Base
   
   def build_gen_ssha(options)
     soap_envelope(options) do |xml|
@@ -47,4 +53,15 @@ class SHAGeneratorService < ServiceProxy
     xml = Hpricot.XML(response.body)
     xml.at("return").inner_text
   end
+end
+
+class InvalidSHAGeneratorService < ServiceProxy::Base
+  
+  def build_gen_ssha(options)
+    soap_envelope(options) do |xml|
+      xml.text(options[:text])
+      xml.hashtype(options[:hash_type])
+    end
+  end
+  
 end

data/spec/service_proxy_spec.rb

@@ -1,15 +1,15 @@
 require 'rubygems'
 require 'spec'
-require File.dirname(__FILE__) + '/../lib/service_proxy.rb'
-require File.dirname(__FILE__) + '/service_helper.rb'
+require File.dirname(__FILE__) + '/../lib/service_proxy/base'
+require File.dirname(__FILE__) + '/service_helper'
 
 describe ServiceProxy do  
   it "should raise on an invalid URI" do
-    lambda { ServiceProxy.new('bacon') }.should raise_error(ArgumentError)
+    lambda { ServiceProxy::Base.new('bacon') }.should raise_error(ArgumentError)
   end
   
   it "should raise on invalid WSDL" do
-    lambda { ServiceProxy.new('http://www.jeremydurham.com') }.should raise_error(RuntimeError)
+    lambda { ServiceProxy::Base.new('http://www.yahoo.com') }.should raise_error(RuntimeError)
   end
     
   describe "connecting to an Instant Message Service" do
@@ -62,4 +62,24 @@ describe ServiceProxy do
       result.should =~ /^[{SSHA512}]/
     end
   end
+  
+  describe "making a service call without a parse method" do
+    before do
+      @proxy = InvalidSHAGeneratorService.new('https://sec.neurofuzz-software.com/paos/genSSHA-SOAP.php?wsdl')
+    end
+  
+    it "should raise a no method error" do
+      lambda { result = @proxy.genSSHA(:text => 'hello world', :hash_type => 'sha512') }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe "using the #service_port hook" do
+    before do
+      @proxy = ISBNService.new('http://webservices.daehosting.com/services/isbnservice.wso?WSDL')
+    end
+    
+    it "should have the dummy query argument" do
+      @proxy.send(:service_uri).path.should match(/\?dummy=1/)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jeremydurham-serviceproxy
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Jeremy Durham
@@ -32,8 +32,8 @@ dependencies:
     version: 
 description: Lightweight SOAP library for Ruby
 email: jeremydurham@gmail.com
-executables: []
-
+executables: 
+- wsdl2proxy
 extensions: []
 
 extra_rdoc_files: 
@@ -43,7 +43,7 @@ files:
 - LICENSE
 - README
 - Rakefile
-- lib/service_proxy.rb
+- lib/service_proxy/base.rb
 - spec/service_helper.rb
 - spec/service_proxy_spec.rb
 has_rdoc: true

data/lib/service_proxy.rb

@@ -1,111 +0,0 @@
-require 'rubygems'
-require 'nokogiri'
-require 'net/http'
-require 'net/https'
-require 'builder'
-require 'uri'
-
-class ServiceProxy
-  VERSION = '0.0.1'
-  
-  attr_accessor :endpoint, :service_methods, :soap_actions, :service_uri, :http, :uri, :debug, :wsdl, :target_namespace
-
-  def initialize(endpoint)
-    self.endpoint = endpoint
-    self.setup
-  end
-  
-  def call_service(options)
-    method   = options[:method]
-    headers  = { 'content-type' => 'text/xml; charset=utf-8', 'SOAPAction' => self.soap_actions[method] }
-    body     = build_request(method, options)
-    response = self.http.request_post(self.uri.path, body, headers)    
-    parse_response(method, response)
-  end  
-
-protected
-
-  def setup
-    self.soap_actions = {}
-    self.service_methods = []
-    setup_http
-    get_wsdl
-    parse_wsdl
-    setup_namespace
-  end
-  
-private
-  
-  def setup_http
-    self.uri = URI.parse(self.endpoint)
-    raise ArgumentError, "Endpoint URI must be valid" unless self.uri.scheme
-    self.http = Net::HTTP.new(self.uri.host, self.uri.port)
-    setup_https if self.uri.scheme == 'https'
-    self.http.set_debug_output(STDOUT) if self.debug
-  end
-
-  def setup_https
-    self.http.use_ssl = true
-    self.http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-  end
-  
-  def get_wsdl
-    response = self.http.get("#{self.uri.path}?#{self.uri.query}")
-    self.wsdl = Nokogiri.XML(response.body)    
-  end
-  
-  def parse_wsdl
-    method_list = []    
-    self.wsdl.xpath('//*[name()="soap:operation"]').each do |operation|
-      operation_name = operation.parent.get_attribute('name')
-      method_list << operation_name
-      self.soap_actions[operation_name] = operation.get_attribute('soapAction')
-    end
-    raise RuntimeError, "Could not parse WSDL" if method_list.empty?
-    self.service_methods = method_list.sort
-  end
-  
-  def setup_namespace
-    self.target_namespace = self.wsdl.namespaces['xmlns:tns']
-  end
-
-  def build_request(method, options)
-    builder  = underscore("build_#{method}")    
-    self.respond_to?(builder) ? self.send(builder, options).target! : soap_envelope(options).target!
-  end
-  
-  def parse_response(method, response)
-    parser = underscore("parse_#{method}")
-    self.respond_to?(parser) ? self.send(parser, response) : 
-                               raise(NoMethodError, "You must define the parse method: #{parser}")
-  end
-  
-  def soap_envelope(options, &block)
-    xsd = 'http://www.w3.org/2001/XMLSchema'
-    env = 'http://schemas.xmlsoap.org/soap/envelope/'
-    xsi = 'http://www.w3.org/2001/XMLSchema-instance'
-    xml = Builder::XmlMarkup.new
-    xml.env(:Envelope, 'xmlns:xsd' => xsd, 'xmlns:env' => env, 'xmlns:xsi' => xsi) do
-      xml.env(:Body) do
-        xml.__send__(options[:method].to_sym, "xmlns" => self.target_namespace) do        
-          yield xml if block_given?
-        end
-      end
-    end
-    xml
-  end
-  
-  def method_missing(method, *args)
-    options = args.pop || {}
-    super unless self.service_methods.include?(method.to_s)
-    call_service(options.update(:method => method.to_s))
-  end
-  
-  def underscore(camel_cased_word)
-    camel_cased_word.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end  
-end