deepsecurity 0.0.19 → 0.0.20

data/lib/savon_helper/soap_interface.rb

@@ -0,0 +1,77 @@
+# @author Udo Schneider <Udo.Schneider@homeaddress.de>
+
+module SavonHelper
+
+  class SOAPInterface
+
+    def initialize(wsdl_url, logger = Logger.new(STDOUT), log_level = nil, options = {})
+      @client = Savon.client(options.merge({:wsdl => wsdl_url,
+                                            :logger => logger,
+                                            :log_level => log_level,
+                                            :log => (!log_level.nil?),
+                                            :ssl_verify_mode => :none}))
+      @logger = logger
+    end
+
+    def logger
+      @logger
+    end
+
+    # @!group Request Helper
+
+    # Send a Request to the SOAP API for method with arguments and unwrap the response
+    # @param method [Symbol] The SOAP method to call.
+    # @param arguments [Hash] The method arguments
+    # @return [Hash] The result hash.
+    def send_soap(method, arguments = {})
+      logger.debug { "#{self.class}\##{__method__}(#{method.inspect}, #{arguments.inspect})" }
+      retryable(:tries => 5, :on => Errno::ECONNRESET) do
+        response = @client.call method, :message => arguments
+        return response.to_hash[(method.to_s+"_response").to_sym][(method.to_s+"_return").to_sym]
+      end
+    end
+
+    # Helper Method deserializing the SOAP response into an object
+    # @param method_name [Symbol] The SOAP method to call.
+    # @param object_class [MappingObject] The class to typecast the result to.
+    # @param arguments [Hash] The method arguments
+    # @return [object_class] The object filled from the response.
+    def request_object(method_name, object_class, arguments={})
+      data = send_soap(method_name, arguments)
+      # ObjectMapping.to_native(object_class, data, self)
+      object_class.from_savon(data, self)
+      # raise "Halt"
+    end
+
+    # Helper Method deserializing the SOAP response into an array of objects.
+    # @param method_name [Symbol] The SOAP method to call.
+    # @param object_class [MappingObject] The element class to typecast the result elements to.
+    # @param collection_name [Symbol] The name of the reply parameter.
+    # @param arguments [Hash] The method arguments
+    # @return [Array<object_class>] The object filled from the response.
+    def request_array(method_name, object_class, collection_name = nil, arguments={})
+      data = send_soap(method_name, arguments)
+      data = data[collection_name] unless collection_name.blank?
+      ArrayMapping.to_native(ObjectMapping.new(object_class), data, self)
+      # SavonHelper::ArrayMapping.new(SavonHelper::ObjectMapping.new(object_class)).from_savon_data(data)
+    end
+
+    # @!endgroup
+
+    def retryable(options = {}, &block)
+      opts = {:tries => 1, :on => Exception}.merge(options)
+
+      retry_exception, retries = opts[:on], opts[:tries]
+
+      begin
+        return yield
+      rescue retry_exception
+        retry if (retries -= 1) > 0
+      end
+
+      yield
+    end
+
+  end
+
+end

data/lib/savon_helper/type_mappings.rb

@@ -2,11 +2,11 @@
 
 module SavonHelper
 
-  # A TypeMappng class is responsible for converting between Savon primitive types and compound Ruby Types
+  # A TypeMapping class is responsible for converting between Savon primitive types and Ruby Types
   class TypeMapping
 
     # A new instance of TypeMapping with description
-    # @param [String] description
+    # @param description [String] A String describing the mapping.
     # @return [TypeMapping]
     def initialize(description='')
       @description = description
@@ -14,18 +14,18 @@ module SavonHelper
 
     # @!group Converting
 
-    # Convert from Savon data to Ruby value
-    # @param [Hash] data Savon data
+    # @abstract Convert from Savon data to Ruby value
+    # @param data [Hash, Object] Source Savon data
     # @return [Object]
-    def from_savon_data(data)
-      logger.error { "#{self.class}##{__method__}(#{data.inspect}) not implemented!" }
+    def to_native(data)
+      raise "#{self.class}##{__method__}(#{data.inspect}) not implemented!"
     end
 
-    # Convert from Ruby value type to Savon data
-    # @param [Object] value Ruby value
+    # @abstract Convert from Ruby value type to Savon data
+    # @param value [Object] Source Ruby value
     # @return [Object]
-    def to_savon_data(value)
-      logger.error { "#{self.class}##{__method__}(#{value.inspect}) not implemented!" }
+    def to_savon(value)
+      raise "#{self.class}##{__method__}(#{value.inspect}) not implemented!"
     end
 
     # @!endgroup
@@ -36,278 +36,405 @@ module SavonHelper
       @description
     end
 
-    # Return the class represented by the mapping.
+    # @abstract Return the class represented by the mapping.
     # @return [Class]
     def object_klass
-      logger.error { "#{self.class}##{__method__}() not implemented!" }
+      raise "#{self.class}##{__method__}() not implemented!"
     end
 
-    # Return the class description represented by the mapping.
+    # @abstract Return the class description represented by the mapping.
     # @return [String]
     def type_string
-      logger.error { "#{self.class}##{__method__}() not implemented!" }
-    end
-
-    # The current logger
-    # @return [Logger]
-    def logger
-      DeepSecurity::logger
+      raise "#{self.class}##{__method__}() not implemented!"
     end
 
   end
 
-  # ArrayMapping maps Savon data to Ruby Arrays
-  class ArrayMapping < TypeMapping
-
+  # BooleanMapping maps Savon data to Ruby Booleans.
+  class BooleanMapping < TypeMapping
 
-    # Convert the given Savon data to an Array consisting of elements of class klass
-    # @param [TypeMapping] element_mapping TypeMapping for elements
-    # @param [Hash,Array] data Savon Data
-    # @return [Array<Object>]
-    def self.from_savon_data(element_mapping, data)
-      return [] if data.blank?
-      result = []
-      if data.is_a?(Array)
-        data.each do |element|
-          result << element_mapping.from_savon_data(element)
-        end
-      elsif data.is_a?(Hash)
-        item = data[:item]
-        if item.nil?
-          result << element_mapping.from_savon_data(data)
-        else
-          result = from_savon_data(element_mapping, item)
-        end
-      else
-        raise "Unknown Array mapping"
-      end
-      result
-    end
+    # @!group Converting
 
-    # A new instance of TypeMapping with description
-    # @param [TypeMapping] element_mapping A TypeMapping for elements
-    # @param [String] description
-    # @return [ArrayMapping]
-    def initialize(element_mapping, description='')
-      super(description)
-      @element_mapping = element_mapping
+    # Convert from Savon data to Ruby Boolean
+    # @param data [Hash, Boolean, String] Source Savon data
+    # @return [Boolean]
+    def to_native(data, interface)
+      data.to_s == "true"
     end
 
-    # @!group Converting
-
-    # Convert from Savon data to Ruby value
-    # @param [Hash] data Savon data
-    # @return [Array]
-    def from_savon_data(data)
-      self.class.from_savon_data(@element_mapping, data)
+    # Convert from Ruby Boolean type to Savon data
+    # @param value [Boolean] Source Ruby data
+    # @return [String]
+    def to_savon(value)
+      value.to_s
     end
 
     # @!endgroup
 
+
     # Return the class represented by the mapping.
-    # @return [Class]
+    # @return [TrueClass] Return TrueClass as Ruby as no common Boolan class
     def object_klass
-      @element_mapping.object_klass
+      TrueClass
     end
 
     # Return the class description represented by the mapping.
     # @return [String]
     def type_string
-      "Array<#{@element_mapping.type_string}>"
+      "bool"
     end
 
   end
 
-    # BooleanMapping maps Savon data to Ruby Booleans.
-  class BooleanMapping < TypeMapping
+  # IntegerMapping maps Savon data to Ruby integers.
+  class IntegerMapping < TypeMapping
 
     # @!group Converting
 
-    # Convert from Savon data to Ruby Boolean
-    # @param [Hash] data Savon data
-    # @return [Boolean]
-    def from_savon_data(data)
-      data.to_s == "true"
+    # Convert from Savon data to Ruby integers
+    # @param data [Hash, String] Source Savon data
+    # @return [Integer]
+    def to_native(data, interface)
+      Integer(data.to_s)
     end
 
-    # Convert from Ruby Boolean type to Savon data
-    # @param [Object] value Boolean
-    # @return [Hash]
-    def to_savon_data(value)
+    # Convert from Ruby float type to Savon data
+    # @param value [Integer] Source Ruby data
+    # @return [String]
+    def to_savon(value)
       value.to_s
     end
 
     # @!endgroup
 
+    # Return the class represented by the mapping.
+    # @return [Integer]
+    def object_klass
+      Integer
+    end
+
     # Return the class description represented by the mapping.
     # @return [String]
     def type_string
-      "bool"
+      "int"
     end
-
   end
 
-  class DatetimeMapping < TypeMapping
+  # FloatMapping maps Savon data to Ruby floats.
+  class FloatMapping < TypeMapping
 
-    def from_savon_data(data)
-      DateTime.parse(data.to_s)
+    # @!group Converting
+
+    # Convert from Savon data to Ruby floats
+    # @param data [Hash, String] Source Savon data
+    # @return [Float]
+    def to_native(data)
+      data.to_f
     end
 
-    def to_savon_data(value)
-      value.to_datetime.to_s
+    # Convert from Ruby float type to Savon data
+    # @param value [Float] Source Ruby data
+    # @return [String]
+    def to_savon(value)
+      value.to_s
+    end
+
+    # @!endgroup
+
+    # Return the class represented by the mapping.
+    # @return [Float]
+    def object_klass
+      Float
     end
 
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "datetime"
+      "float"
     end
 
   end
 
-  class EnumMapping < TypeMapping
+  # StringMapping maps Savon data to Ruby strings.
+  class StringMapping < TypeMapping
 
-    def initialize(enum, description='')
-      super(description)
-      @enum = enum
+    # @!group Converting
+
+    # Convert from Savon data to Ruby strings
+    # @param data [Hash, String] Source Savon data
+    # @return [String]
+    def to_native(data, interface)
+      data.to_s
     end
 
-    def from_savon_data(data)
-      @enum[data]
+    # Convert from Ruby string type to Savon data
+    # @param value [String] Source Ruby data
+    # @return [String]
+    def to_savon(value)
+      value.to_s
     end
 
-    def to_savon_data(value)
-      @enum.key(value)
+    # @!endgroup
+
+    # @abstract Return the class represented by the mapping.
+    # @todo Is this really neccessary?
+    # @return [Class]
+    def object_klass
+      String
     end
 
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "enum<#{@enum.values.join(', ')}>"
+      "String"
     end
 
   end
 
-  class FloatMapping < TypeMapping
-
-    def from_savon_data(data)
-      data.to_f
-    end
-
-    def to_savon_data(value)
-      value.to_s
-    end
+  # IPAddressMapping maps Savon data to Ruby IP Address String.
+  # @note Currently IPAddressMapping only does a from/to String mapping. The IP Address is not parsed in any way!
+  class IPAddressMapping < StringMapping
 
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "float"
+      "IPAddress"
     end
 
   end
 
-  class IntegerMapping < TypeMapping
+  # DatetimeMapping maps Savon data to Ruby DateTimes.
+  class DatetimeMapping < TypeMapping
 
-    def from_savon_data(data)
-      Integer(data.to_s)
+    # @!group Converting
+
+    # Convert from Savon data to Ruby datetime
+    # @param data [Hash, String] Source Savon data
+    # @return [DateTime]
+    def to_native(data, interface)
+      DateTime.parse(data.to_s)
     end
 
-    def to_savon_data(value)
-      value.to_s
+    # Convert from Ruby DateTime type to Savon data
+    # @param value [DateTime] Source Ruby data
+    # @return [String]
+    def to_savon(value)
+      value.to_datetime.to_s
     end
 
+    # @!endgroup
+
+    # Return the class represented by the mapping.
+    # @return [DateTime]
+    def object_klass
+      DateTime
+    end
+
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "int"
+      "datetime"
     end
+
   end
 
-  class IPAddressMapping < TypeMapping
+  # EnumMapping maps Savon integers to Ruby symbols.
+  class EnumMapping < TypeMapping
 
-    def from_savon_data(data)
-      data.to_s
+    # A new instance of EnumMapping with description and enum hash enum.
+    # @param enum [Hash{String => Symbol}] Mapping between Savon Strings and Ruby Symbols.
+    # @param description [String]
+    # @return [ArrayMapping]
+    def initialize(enum, description='')
+      super(description)
+      @enum = enum
     end
 
-    def to_savon_data(value)
-      value.to_s
+    # @!group Converting
+
+    # Convert from Savon enum-String to Ruby Symbol
+    # @param data [String] Source Savon data
+    # @return [Symbol, nil]
+    def to_native(data, interface)
+      @enum[data]
     end
 
+    # Convert from Ruby DateTime Symbol to  Savon enum-String
+    # @param value [Symbol] Source Ruby data
+    # @return [String]
+    def to_savon(value)
+      @enum.key(value)
+    end
+
+    # @!endgroup
+
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "IPAddress"
+      "enum<#{@enum.values.join(', ')}>"
     end
 
   end
 
-  class ObjectMapping < TypeMapping
+  # HintMapping maps Savon data to Ruby objects of type klass (r/o).
+  class HintMapping < TypeMapping
 
+    # A new instance of ObjectMapping with description for class klass.
+    # @param klass [Class] A class returned by the hint accessor
+    # @param description [String]
+    # @return [HintMapping]
     def initialize(klass, description='')
       super(description)
       @klass = klass
     end
 
-    def from_savon_data(data)
-      @klass.from_savon_data(data)
-    end
+    # @!endgroup
 
+    # @abstract Return the class represented by the mapping.
+    # @return [Class]
     def object_klass
       @klass
     end
 
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "#{@klass}"
+      "HINT<#{@klass.name_without_namespace}>"
     end
 
   end
 
-  class StringMapping < TypeMapping
+  # ObjectMapping maps Savon data to Ruby Objects.
+  class ObjectMapping < HintMapping
 
-    def from_savon_data(data)
-      data.to_s
+    # Convert from Savon data to Ruby Object.
+    # @param data [Hash, String] Source Savon data
+    # @param klass [Class, #to_native] A class which can create instances from Savon data and provide Savon data for export.
+    # @return [SavonHelper::MappingObject, #to_native]
+    def self.to_native(klass, data, interface)
+      klass.from_savon(data, interface)
     end
 
-    def to_savon_data(value)
-      value.to_s
+    # A new instance of ObjectMapping with description for class klass.
+    # @param klass [Class, #to_native] A class which can create instances from Savon data and provide Savon data for export.
+    # @param description [String]
+    # @return [ObjectMapping]
+    def initialize(klass, description='')
+      super(klass, description)
     end
 
-    def object_klass
-      String
-    end
+    # @!group Converting
 
-    def type_string
-      "String"
+    # Convert from Savon data to Ruby Object.
+    # @param data [Hash, String] Source Savon data
+    # @return [SavonHelper::MappingObject, #to_native]
+    def to_native(data, interface)
+      self.class.to_native(@klass, data, interface)
     end
 
+    # @!endgroup
+
   end
 
-  class MissingMapping < TypeMapping
+  # ArrayMapping maps Savon data to Ruby Arrays
+  class ArrayMapping < TypeMapping
 
-    def from_savon_data(data)
-      data
+    # Convert the given Savon data to an Array consisting of elements described by element_mapping
+    # @param element_mapping [TypeMapping] TypeMapping for elements
+    # @param data [Hash,Array] Source Savon Data
+    # @return [Array<element_mapping>]
+    def self.to_native(element_mapping, data, interface)
+      return [] if data.blank?
+      result = []
+      if data.is_a?(Array)
+        data.each do |element|
+          result << element_mapping.to_native(element, interface)
+        end
+      elsif data.is_a?(Hash)
+        item = data[:item]
+        if item.nil?
+          result << element_mapping.to_native(data, interface)
+        else
+          result = to_native(element_mapping, item, interface)
+        end
+      else
+        raise "Unknown Array mapping"
+      end
+      result
     end
 
-    def to_savon_data(value)
-      value
+    # A new instance of TypeMapping with description
+    # @param element_mapping [TypeMapping]  A TypeMapping for elements
+    # @param description [String]
+    # @return [ArrayMapping]
+    def initialize(element_mapping, description='')
+      super(description)
+      @element_mapping = element_mapping
+    end
+
+    # @!group Converting
+
+    # Convert from Savon data to Ruby value
+    # @param data [Hash, Hash] Source Savon data
+    # @return [Array<@element_mapping>]
+    def to_native(data, interface)
+      self.class.to_native(@element_mapping, data, interface)
     end
 
+    # @!endgroup
+
+    # Return the class represented by the mapping.
+    # @return [Class]
+    def object_klass
+      @element_mapping.object_klass
+    end
+
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "MISSING"
+      "Array<#{@element_mapping.type_string}>"
     end
 
   end
 
-  class HintMapping < TypeMapping
+  # MissingMapping maps Savon data to itself (no conversion).
+  class MissingMapping < TypeMapping
 
-    def initialize(klass, description='')
-      super(description)
-      @klass = klass
+    # @!group Converting
+
+    # Convert from Savon data to itself.
+    # @param data [Object] Source Savon data
+    # @return [Object]
+    def to_native(data, interface)
+      data
     end
 
-    def object_klass
-      @klass
+    # Convert from itself (no conversion) to Savon data.
+    # @param value [Object] Source Ruby data
+    # @return [Object]
+    def to_savon(value)
+      value
     end
 
+    # @!endgroup
+
+    # Return the class description represented by the mapping.
+    # @return [String]
     def type_string
-      "HINT"
+      "UNDEFINED"
     end
 
   end
 
-  def self.define_missing_type_mapping(klass, ivar_name, value, mappings)
+  # Define a MissingMapping for the given options
+  # @todo Check if mappings can be derived from klass
+  # @param klass [Class] The class to define the mapping for.
+  # @param ivar_name [Symbol] The name of the ivar/accessor to hold/access the value
+  # @param value [Object] The value to set the ivar to.
+  # @param mappings [Hash{Symbol=>TypeMapping}] The mappings hash to add the HintMapping to.
+  def self.define_missing_type_mapping(klass, ivar_name, value, mappings, interface)
     message = "No type mapping for #{klass}@#{ivar_name} = #{value}!"
-    DeepSecurity::Manager.current.logger.warn(message)
+    interface.logger.warn(message)
     mappings[ivar_name] = MissingMapping.new(message)
   end