tictoc-savon 0.7.9

data/lib/savon/core_ext.rb

@@ -0,0 +1,8 @@
+require "savon/core_ext/object"
+require "savon/core_ext/string"
+require "savon/core_ext/symbol"
+require "savon/core_ext/datetime"
+require "savon/core_ext/array"
+require "savon/core_ext/hash"
+require "savon/core_ext/uri"
+require "savon/core_ext/net_http"

data/lib/savon/core_ext/array.rb

@@ -0,0 +1,31 @@
+class Array
+
+  # Translates the Array into SOAP compatible XML. See: Hash.to_soap_xml.
+  def to_soap_xml(key, escape_xml = true, attributes = {})
+    xml = Builder::XmlMarkup.new
+
+    each_with_index do |item, index|
+      attrs = tag_attributes attributes, index
+      case item
+        when Hash then xml.tag!(key, attrs) { xml << item.to_soap_xml }
+        else           xml.tag!(key, attrs) { xml << (escape_xml ? item.to_soap_value : item.to_soap_value!) }
+      end
+    end
+
+    xml.target!
+  end
+
+private
+
+  # Takes a Hash of +attributes+ and the +index+ for which to return attributes
+  # for duplicate tags.
+  def tag_attributes(attributes, index)
+    return {} if attributes.empty?
+
+    attributes.inject({}) do |hash, (key, value)|
+      value = value[index] if value.kind_of? Array
+      hash.merge key => value
+    end
+  end
+
+end

data/lib/savon/core_ext/datetime.rb

@@ -0,0 +1,10 @@
+class DateTime
+
+  # Returns the DateTime as an xs:dateTime formatted String.
+  def to_soap_value
+    strftime Savon::SOAP::DateTimeFormat
+  end
+
+  alias_method :to_soap_value!, :to_soap_value
+
+end

data/lib/savon/core_ext/hash.rb

@@ -0,0 +1,107 @@
+class Hash
+
+  # Returns the values from the soap:Body element or an empty Hash in case the soap:Body tag could
+  # not be found.
+  def find_soap_body
+    envelope = self[keys.first] || {}
+    body_key = envelope.keys.find { |key| /.+:Body/ =~ key } rescue nil
+    body_key ? envelope[body_key].map_soap_response : {}
+  end
+
+  # Translates the Hash into SOAP request compatible XML.
+  #
+  #   { :find_user => { :id => 123, "wsdl:Key" => "api" } }.to_soap_xml
+  #   # => "<findUser><id>123</id><wsdl:Key>api</wsdl:Key></findUser>"
+  #
+  # ==== Mapping
+  #
+  # * Hash keys specified as Symbols are converted to lowerCamelCase Strings
+  # * Hash keys specified as Strings are not converted and may contain namespaces
+  # * DateTime values are converted to xs:dateTime Strings
+  # * Objects responding to to_datetime (except Strings) are converted to xs:dateTime Strings
+  # * TrueClass and FalseClass objects are converted to "true" and "false" Strings
+  # * All other objects are expected to be converted to Strings using to_s
+  #
+  # An example:
+  #
+  #   { :magic_request => {
+  #       :perform_move => true,
+  #       "perform_at" => DateTime.new(2010, 11, 22, 11, 22, 33)
+  #     }
+  #   }.to_soap_xml
+  #
+  #   <magicRequest>
+  #     <performMove>true</performMove>
+  #     <perform_at>2012-06-11T10:42:21</perform_at>
+  #   </magicRequest>
+  #
+  # ==== Escaped XML values
+  #
+  # By default, special characters in XML String values are escaped.
+  #
+  # ==== Fixed order of XML tags
+  #
+  # In case your service requires the tags to be in a specific order (parameterOrder), you have two
+  # options. The first is to specify your body as an XML string. The second is to specify the order
+  # through an additional array stored under the +:order!+ key.
+  #
+  #   { :name => "Eve", :id => 123, :order! => [:id, :name] }.to_soap_xml
+  #   # => "<id>123</id><name>Eve</name>"
+  #
+  # ==== XML attributes
+  #
+  # If you need attributes, you could either go with an XML string or add another hash under the
+  # +:attributes!+ key.
+  #
+  #   { :person => "Eve", :attributes! => { :person => { :id => 666 } } }.to_soap_xml
+  #   # => '<person id="666">Eve</person>'
+  def to_soap_xml
+    xml = Builder::XmlMarkup.new
+    attributes = delete(:attributes!) || {}
+
+    order.each do |key|
+      attrs = attributes[key] || {}
+      value = self[key]
+      escape_xml = key.to_s[-1, 1] != "!"
+      key = key.to_soap_key
+
+      case value
+        when Array then xml << value.to_soap_xml(key, escape_xml, attrs)
+        when Hash  then xml.tag!(key, attrs) { xml << value.to_soap_xml }
+        else            xml.tag!(key, attrs) { xml << (escape_xml ? value.to_soap_value : value.to_soap_value!) }
+      end
+    end
+
+    xml.target!
+  end
+
+  # Maps keys and values of a Hash created from SOAP response XML to more convenient Ruby Objects.
+  def map_soap_response
+    inject({}) do |hash, (key, value)|
+      value = case value
+        when Hash   then value["xsi:nil"] ? nil : value.map_soap_response
+        when Array  then value.map { |val| val.map_soap_response rescue val }
+        when String then value.map_soap_response
+      end
+
+      hash.merge key.strip_namespace.snakecase.to_sym => value
+    end
+  end
+
+private
+
+  # Deletes and returns an Array of keys stored under the :order! key. Defaults to return the actual
+  # keys of this Hash if no :order! key could be found. Raises an ArgumentError in case the :order!
+  # Array does not match the Hash keys.
+  def order
+    order = delete :order!
+    order = keys unless order.kind_of? Array
+
+    missing, spurious = keys - order, order - keys
+    raise ArgumentError, "Missing elements in :order! #{missing.inspect}" unless missing.empty?
+    raise ArgumentError, "Spurious elements in :order! #{spurious.inspect}" unless spurious.empty?
+
+    order
+  end
+
+end

data/lib/savon/core_ext/net_http.rb

@@ -0,0 +1,19 @@
+module Net
+  class HTTP
+
+    # Sets the endpoint +address+ and +port+.
+    def endpoint(address, port)
+      @address, @port = address, port
+    end
+
+    # Convenience method for setting SSL client authentication through a Hash of +options+.
+    def ssl_client_auth(options)
+      self.use_ssl = true
+      self.cert = options[:cert] if options[:cert]
+      self.key = options[:key] if options[:key]
+      self.ca_file = options[:ca_file] if options[:ca_file]
+      self.verify_mode = options[:verify_mode] if options[:verify_mode]
+    end
+
+  end
+end

data/lib/savon/core_ext/object.rb

@@ -0,0 +1,16 @@
+class Object
+
+  # Returns +true+ if the Object is nil, false or empty. Implementation from ActiveSupport.
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end unless defined? blank?
+
+  # Returns the Object as a SOAP request compliant value.
+  def to_soap_value
+    return to_s unless respond_to? :to_datetime
+    to_datetime.to_soap_value
+  end
+
+  alias_method :to_soap_value!, :to_soap_value
+
+end

data/lib/savon/core_ext/string.rb

@@ -0,0 +1,69 @@
+class String
+
+  # Returns a random String of a given +length+.
+  def self.random(length = 100)
+    (0...length).map { ("a".."z").to_a[rand(26)] }.join
+  end
+
+  # Returns the String in snake_case.
+  def snakecase
+    str = dup
+    str.gsub! /::/, '/'
+    str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+    str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+    str.tr! ".", "_"
+    str.tr! "-", "_"
+    str.downcase!
+    str
+  end
+
+  # Returns the String in lowerCamelCase.
+  def lower_camelcase
+    str = dup
+    str.gsub!(/\/(.?)/) { "::#{$1.upcase}" }
+    str.gsub!(/(?:_+|-+)([a-z])/) { $1.upcase }
+    str.gsub!(/(\A|\s)([A-Z])/) { $1 + $2.downcase }
+    str
+  end
+
+  # Returns whether the String starts with a given +prefix+.
+  def starts_with?(prefix)
+    prefix = prefix.to_s
+    self[0, prefix.length] == prefix
+  end unless defined? starts_with?
+
+  # Returns whether the String ends with a given +suffix+.
+  def ends_with?(suffix)
+    suffix = suffix.to_s
+    self[-suffix.length, suffix.length] == suffix
+  end unless defined? ends_with?
+
+  # Returns the String without namespace.
+  def strip_namespace
+    split(":").last
+  end
+
+  # Translates SOAP response values to Ruby Objects.
+  def map_soap_response
+    return DateTime.parse(self) if Savon::SOAP::DateTimeRegexp === self
+    return true if self.strip.downcase == "true"
+    return false if self.strip.downcase == "false"
+    self
+  end
+
+  # Returns the Object as a SOAP request compliant key.
+  def to_soap_key
+    self[-1, 1] == "!" ? chop : self
+  end
+
+  # Returns the String as a SOAP value. Escapes special characters for XML.
+  def to_soap_value
+    CGI.escapeHTML self
+  end
+
+  # Convert the String into a SOAP value without escaping special characters.
+  def to_soap_value!
+    self
+  end
+
+end

data/lib/savon/core_ext/symbol.rb

@@ -0,0 +1,8 @@
+class Symbol
+
+  # Returns the Symbol as a lowerCamelCase String.
+  def to_soap_key
+    to_s.to_soap_key.lower_camelcase
+  end
+
+end

data/lib/savon/core_ext/uri.rb

@@ -0,0 +1,10 @@
+module URI
+  class Generic
+
+    # Returns whether the URI hints to SSL.
+    def ssl?
+      !@scheme ? nil : @scheme.starts_with?("https")
+    end
+
+  end
+end

data/lib/savon/logger.rb

@@ -0,0 +1,56 @@
+module Savon
+
+  # = Savon::Logger
+  #
+  # Savon::Logger can be mixed into classes to provide logging behavior.
+  #
+  # By default, the Logger mixin uses {Ruby's Logger}[http://ruby-doc.org/stdlib/libdoc/logger/rdoc/]
+  # from the standard library, a log level of :debug and is pointing to STDOUT.
+  module Logger
+
+    module ClassMethods
+
+      # Sets whether to log.
+      def log=(log)
+        @log = log
+      end
+
+      # Returns whether to log. Defaults to +true+.
+      def log?
+        @log != false
+      end
+
+      # Sets the logger.
+      def logger=(logger)
+        @logger = logger
+      end
+
+      # Returns the logger. Defaults to an instance of +Logger+ writing to STDOUT.
+      def logger
+        @logger ||= ActiveRecord::Base.logger rescue ::Logger.new STDOUT
+      end
+
+      # Sets the log level.
+      def log_level=(log_level)
+        @log_level = log_level
+      end
+
+      # Returns the log level. Defaults to +debug+.
+      def log_level
+        @log_level ||= :debug
+      end
+
+    end
+
+    # Extends the class including this module with its ClassMethods.
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Logs a given +message+.
+    def log(message)
+      self.class.logger.send self.class.log_level, message if self.class.log?
+    end
+
+  end
+end

data/lib/savon/request.rb

@@ -0,0 +1,138 @@
+module Savon
+
+  # = Savon::Request
+  #
+  # Savon::Request handles both WSDL and SOAP requests.
+  #
+  # == The Net::HTTP object
+  #
+  # You can access the Net::HTTP object used for both WSDL and SOAP requests via:
+  #
+  #   client.request.http
+  #
+  # Here's an example of how to set open and read timeouts on the Net::HTTP object.
+  #
+  #   client.request.http.open_timeout = 30
+  #   client.request.http.read_timeout = 30
+  #
+  # Please refer to the {Net::HTTP documentation}[http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/]
+  # for more information.
+  #
+  # == HTTP basic authentication
+  #
+  # Setting credentials for HTTP basic authentication:
+  #
+  #   client.request.basic_auth "username", "password"
+  #
+  # == SSL client authentication
+  #
+  # You can use the methods provided by Net::HTTP to set SSL client authentication or use a shortcut:
+  #
+  #   client.request.http.ssl_client_auth(
+  #     :cert => OpenSSL::X509::Certificate.new(File.read("client_cert.pem")),
+  #     :key => OpenSSL::PKey::RSA.new(File.read("client_key.pem"), "password if one exists"),
+  #     :ca_file => "cacert.pem",
+  #     :verify_mode => OpenSSL::SSL::VERIFY_PEER
+  #   )
+  #
+  # == HTTP headers
+  #
+  # There's an accessor for the Hash of HTTP headers sent with any SOAP call:
+  #
+  #   client.request.headers["custom"] = "header"
+  class Request
+    include Logger
+
+    # Content-Types by SOAP version.
+    ContentType = { 1 => "text/xml;charset=UTF-8", 2 => "application/soap+xml;charset=UTF-8" }
+
+    # Expects a WSDL or SOAP +endpoint+ and accepts a custom +proxy+ address.
+    def initialize(endpoint, options = {})
+      @endpoint = URI endpoint
+      @proxy = URI options[:proxy] || ""
+      headers["Accept-encoding"] = "gzip,deflate" if options[:gzip]
+    end
+
+    # Returns the endpoint URI.
+    attr_reader :endpoint
+
+    # Returns the proxy URI.
+    attr_reader :proxy
+
+    # Returns the HTTP headers for a SOAP request.
+    def headers
+      @headers ||= {}
+    end
+
+    # Sets the HTTP headers for a SOAP request.
+    def headers=(headers)
+      @headers = headers if headers.kind_of? Hash
+    end
+
+    # Sets the +username+ and +password+ for HTTP basic authentication.
+    def basic_auth(username, password)
+      @basic_auth = [username, password]
+    end
+
+    # Retrieves WSDL document and returns the Net::HTTP response.
+    def wsdl
+      log "Retrieving WSDL from: #{@endpoint}"
+      http.endpoint @endpoint.host, @endpoint.port
+      http.use_ssl = @endpoint.ssl?
+      http.start { |h| h.request request(:wsdl) }
+    end
+
+    # Executes a SOAP request using a given Savon::SOAP instance and returns the Net::HTTP response.
+    def soap(soap)
+      @soap = soap
+      http.endpoint @soap.endpoint.host, @soap.endpoint.port
+      http.use_ssl = @soap.endpoint.ssl?
+
+      log_request
+      @response = http.start do |h|
+        h.request request(:soap) { |request| request.body = @soap.to_xml }
+      end
+      log_response
+      @response
+    end
+
+    # Returns the Net::HTTP object.
+    def http
+      @http ||= Net::HTTP::Proxy(@proxy.host, @proxy.port).new @endpoint.host, @endpoint.port
+    end
+
+  private
+
+    # Logs the SOAP request.
+    def log_request
+      log "SOAP request: #{@soap.endpoint}"
+      log soap_headers.merge(headers).map { |key, value| "#{key}: #{value}" }.join(", ")
+      log @soap.to_xml
+    end
+
+    # Logs the SOAP response.
+    def log_response
+      log "SOAP response (status #{@response.code}):"
+      log @response.body
+    end
+
+    # Returns a Net::HTTP request for a given +type+. Yields the request to an optional block.
+    def request(type)
+      request = case type
+        when :wsdl then Net::HTTP::Get.new @endpoint.request_uri
+        when :soap then Net::HTTP::Post.new @soap.endpoint.request_uri, soap_headers.merge(headers)
+      end
+
+      request.basic_auth(*@basic_auth) if @basic_auth
+      yield request if block_given?
+      request
+    end
+
+    # Returns a Hash containing the SOAP headers for an HTTP request.
+    def soap_headers
+      { "Content-Type" => ContentType[@soap.version], "SOAPAction" => @soap.action }
+    end
+
+  end
+end
+