jruby-serviceproxy 0.1.4

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,27 @@
+ServiceProxy
+
+ServiceProxy is a lightweight SOAP library for Ruby. 
+
+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

@@ -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', 'base')
+
+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::Base::VERSION + PKG_BUILD
+RELEASE_NAME = "REL #{GEM_VERSION}"
+#
+# ==== Gemspec and installation
+#
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = ServiceProxy::Base::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.executables = ['wsdl2proxy']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,spec}/**/*")
+  
+  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::Base::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/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,156 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+begin
+  require 'hpricot'
+  require 'builder'
+rescue LoadError
+  puts "Could not load hpricot or builder. Please make sure they are installed and in your $LOAD_PATH."
+end
+
+module ServiceProxy
+  class Base
+    VERSION = '0.1.4'
+  
+    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 ||= self.respond_to?(:service_port) ? self.service_port : self.uri
+    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 = Hpricot.XML(response.body)
+    end
+  
+    def parse_wsdl
+      method_list = []
+      self.wsdl.search('//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.search('//port').each do |port|
+        name = underscore(port['name'])
+        location = port.search('/[@location]').first['location']
+        port_list[name] = location
+      end
+      self.service_ports = port_list
+    end
+  
+    def setup_namespace
+      namespace = self.wsdl.at("definitions")
+      namespace = self.wsdl.at("wsdl:definitions") if namespace.nil?
+      self.target_namespace = namespace.get_attribute("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/lib/templates/proxy.rbt

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'service_proxy/base'
+require 'hpricot'
+
+class %name% < ServiceProxy::Base
+%body%
+end

data/spec/service_helper.rb

@@ -0,0 +1,48 @@
+require 'hpricot'
+
+# Service Endpoints
+class ISBNService < ServiceProxy::Base  
+  
+  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
+  
+  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::Base
+  
+  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
+
+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

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'spec'
+require 'lib/service_proxy/base'
+require 'spec/service_helper'
+
+describe ServiceProxy do  
+  it "should raise on an invalid URI" do
+    lambda { ServiceProxy::Base.new('bacon') }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise on invalid WSDL" do
+    lambda { ServiceProxy::Base.new('http://www.yahoo.com') }.should raise_error(RuntimeError)
+  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
+  
+  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

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-serviceproxy
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 4
+  version: 0.1.4
+platform: ruby
+authors: 
+- Jeremy Durham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-13 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Lightweight SOAP library for Ruby
+email: jeremydurham@gmail.com
+executables: 
+- wsdl2proxy
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/service_proxy/base.rb
+- lib/templates/proxy.rbt
+- spec/service_helper.rb
+- spec/service_proxy_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: Lightweight SOAP library for Ruby
+test_files: []
+