jeremydurham-serviceproxy 0.0.1

data/LICENSE

@@ -0,0 +1,23 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2008 Jeremy Durham
+
+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,45 @@
+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

data/Rakefile

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require File.join(File.dirname(__FILE__), 'lib', 'service_proxy')
+
+NAME = "serviceproxy"
+AUTHOR = "Jeremy Durham"
+EMAIL = "jeremydurham@gmail.com"
+HOMEPAGE = ""
+SUMMARY = "Lightweight SOAP library for Ruby"
+
+# Used by release task
+GEM_NAME            = NAME
+PROJECT_URL         = HOMEPAGE
+PROJECT_SUMMARY     = SUMMARY
+PROJECT_DESCRIPTION = SUMMARY
+
+PKG_BUILD    = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION  = ServiceProxy::VERSION + PKG_BUILD
+RELEASE_NAME = "REL #{GEM_VERSION}"
+#
+# ==== Gemspec and installation
+#
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = ServiceProxy::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,spec}/**/*")
+  
+  s.add_dependency "nokogiri"
+  s.add_dependency "hpricot"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:clean, :package] do
+  sh %{sudo gem install pkg/#{NAME}-#{ServiceProxy::VERSION} --no-update-sources}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Run coverage suite"
+task :rcov do
+  require 'fileutils'
+  FileUtils.rm_rf("coverage") if File.directory?("coverage")
+  FileUtils.mkdir("coverage")
+  path = File.expand_path(Dir.pwd)
+  files = Dir["spec/**/*_spec.rb"]
+  files.each do |spec|
+    puts "Getting coverage for #{File.expand_path(spec)}"
+    command = %{rcov #{File.expand_path(spec)} --aggregate #{path}/coverage/data.data}
+    command += " --no-html" unless spec == files.last
+    `#{command} 2>&1`
+  end
+end
+
+file_list = FileList['spec/**/*_spec.rb']
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = file_list
+end
+
+namespace :spec do
+  desc "Run all examples with RCov"
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = file_list
+    t.rcov = true
+    t.rcov_dir = "doc/coverage"
+    t.rcov_opts = ['--exclude', 'spec']
+  end  
+end
+
+desc 'Default: run unit tests.'
+task :default => 'spec'

data/lib/service_proxy.rb

@@ -0,0 +1,111 @@
+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

data/spec/service_helper.rb

@@ -0,0 +1,50 @@
+require 'hpricot'
+
+# Service Endpoints
+class InstantMessageService < ServiceProxy
+  
+  def parse_get_version(response)
+    xml = Hpricot.XML(response.body)
+    xml.at("GetVersionResult").inner_text
+  end
+  
+  def build_login(options)
+    soap_envelope(options) do |xml|
+      xml.userId(options[:userId])
+      xml.password(options[:password])
+    end
+  end
+  
+  def parse_login(response)
+    'Invalid username/password' if response.code == "500"
+  end
+end
+
+class ISBNService < ServiceProxy  
+  
+  def build_is_valid_isbn13(options)
+    soap_envelope(options) do |xml|
+      xml.sISBN(options[:isbn])
+    end
+  end
+  
+  def parse_is_valid_isbn13(response)
+    xml = Hpricot.XML(response.body)
+    xml.at("m:IsValidISBN13Result").inner_text == 'true' ? true : false
+  end
+end
+
+class SHAGeneratorService < ServiceProxy
+  
+  def build_gen_ssha(options)
+    soap_envelope(options) do |xml|
+      xml.text(options[:text])
+      xml.hashtype(options[:hash_type])
+    end
+  end
+  
+  def parse_gen_ssha(response)
+    xml = Hpricot.XML(response.body)
+    xml.at("return").inner_text
+  end
+end

data/spec/service_proxy_spec.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/service_proxy.rb'
+require File.dirname(__FILE__) + '/service_helper.rb'
+
+describe ServiceProxy do  
+  it "should raise on an invalid URI" do
+    lambda { ServiceProxy.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)
+  end
+    
+  describe "connecting to an Instant Message Service" do
+    before do
+      @proxy = InstantMessageService.new('http://www.imcomponents.com/imsoap/?wsdl')
+    end
+    
+    describe "calling GetVersion" do
+      it "should return the version" do        
+        version = @proxy.GetVersion
+        version.should == 'v1.0.20080508'
+      end
+    end
+    
+    describe "calling Login" do
+      it "should return nil" do
+        result = @proxy.Login(:userId => 'test', :password => 'test')
+        result.should == 'Invalid username/password'
+      end
+    end
+  end
+  
+  describe "connecting to an ISBN validator" do
+    before do
+      @proxy = ISBNService.new('http://webservices.daehosting.com/services/isbnservice.wso?WSDL')
+    end
+    
+    describe "calling IsValidISBN13" do
+      it "should return true for a valid ISBN" do
+        @proxy.IsValidISBN13(:isbn => '978-0977616633').should == true
+      end
+      
+      it "should return false for an invalid ISBN" do
+        @proxy.IsValidISBN13(:isbn => '999-9999391939').should == false
+      end
+    end
+  end
+  
+  describe "connecting to the SHA hash generator Service" do
+    before do
+      @proxy = SHAGeneratorService.new('https://sec.neurofuzz-software.com/paos/genSSHA-SOAP.php?wsdl')
+    end
+    
+    it "should be SSL" do
+      @proxy.http.use_ssl.should be_true
+    end
+    
+    it "should generate a SSH hash" do
+      result = @proxy.genSSHA(:text => 'hello world', :hash_type => 'sha512')
+      result.should =~ /^[{SSHA512}]/
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: jeremydurham-serviceproxy
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jeremy Durham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-13 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Lightweight SOAP library for Ruby
+email: jeremydurham@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/service_proxy.rb
+- spec/service_helper.rb
+- spec/service_proxy_spec.rb
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Lightweight SOAP library for Ruby
+test_files: []
+