google-ads-common 0.6.4 → 0.7.0

data/lib/ads_common/build/savon_service_generator.rb

@@ -25,6 +25,7 @@ require 'ads_common/build/savon_abstract_generator'
 module AdsCommon
   module Build
     class SavonServiceGenerator < SavonAbstractGenerator
+
       SERVICE_TEMPLATE = %q{<% %>
       # Encoding: utf-8
       #
@@ -37,16 +38,13 @@ module AdsCommon
 
       require 'ads_common/savon_service'
       require '<%= @require_path %>/<%= @service_name.to_s.snakecase %>_registry'
-      <% unless @extensions.empty? %>
-      require '<%= @api_name.snakecase %>/extensions'
-      <% end %>
 
       <%= @modules_open_string %>
 
         class <%= @service_name %> < AdsCommon::SavonService
-          def initialize(api, endpoint)
+          def initialize(config, endpoint)
             namespace = '<%= @namespace %>'
-            super(api, endpoint, namespace, :<%= @version %>)
+            super(config, endpoint, namespace, :<%= @version %>)
           end
           <% @actions.each do |action| %>
 
@@ -54,12 +52,6 @@ module AdsCommon
             return execute_action('<%= action %>', args, &block)
           end
           <% end %>
-          <% @extensions.each do |extention| %>
-
-          def <%= extention %>(*args)
-            return <%= @api_name %>::Extensions.<%= extention %>(self, args)
-          end
-          <% end %>
 
           private
 
@@ -78,17 +70,12 @@ module AdsCommon
       def initialize(args)
         super(args)
         @actions = []
-        @extensions = []
       end
 
       def add_actions(actions)
         @actions += actions
       end
 
-      def add_extensions(extensions)
-        @extensions += extensions
-      end
-
       def get_code_template()
         SERVICE_TEMPLATE
       end

data/lib/ads_common/credential_handler.rb

@@ -21,15 +21,23 @@
 
 module AdsCommon
   class CredentialHandler
-    attr_reader :credentials
 
+    # Initializes CredentialHandler.
     def initialize(config)
       @config = config
-      load_from_config
+      load_from_config(config)
+    end
+
+    # Returns credentials set for the next call.
+    def credentials(credentials_override = nil)
+      credentials = @credentials.dup()
+      credentials.merge!(credentials_override) unless credentials_override.nil?
+      return credentials
     end
 
     # Set the credentials hash to a new one. Calculate difference, and call the
     # AuthHandler callback appropriately.
+    # TODO(dklimkin): re-write this with inject.
     def credentials=(new_credentials)
       # Find new and changed properties.
       diff = new_credentials.select do |key, value|
@@ -55,21 +63,35 @@ module AdsCommon
     # appropriately.
     def set_credential(credential, value)
       @credentials[credential] = value
+      # TODO(dklimkin): @auth_handler is never defined.
       @auth_handler.property_changed(credential, value) if @auth_handler
     end
 
-    # Returns current configuration.
-    # TODO: we need better way to access config widely,
-    #       remove after refactoring.
-    def get_config()
-      return @config
+    # Generates string for UserAgent to put into HTTP headers.
+    def generate_http_user_agent()
+      agent_data = []
+      agent_data << HTTPI::Adapter.use.to_s
+      ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+      agent_data << [ruby_engine, RUBY_VERSION].join('/')
+      agent_data << (credentials[:user_agent] || $0)
+      user_agent = "HTTPI/%s (%s)" % [HTTPI::VERSION, agent_data.join(', ')]
+      return user_agent
+    end
+
+    # Generates string for UserAgent to put into SOAP headers.
+    def generate_soap_user_agent(extra_ids = [])
+      agent_data = extra_ids
+      agent_data << "Common-Ruby-%s" % AdsCommon::ApiConfig::CLIENT_LIB_VERSION
+      agent_data << (@credentials[:user_agent] || $0)
+      user_agent = "Savon/%s (%s)" % [Savon::Version, agent_data.join(', ')]
+      return user_agent
     end
 
     private
 
     # Loads the credentials from the config data.
-    def load_from_config
-      @credentials = @config.read('authentication')
+    def load_from_config(config)
+      @credentials = config.read('authentication')
     end
   end
 end

data/lib/ads_common/http.rb

@@ -25,14 +25,15 @@ require 'httpi'
 require 'ads_common/errors'
 
 module AdsCommon
-  module Http
+  class Http
+
     # HTTP read and open timeouts in seconds.
     HTTP_READ_TIMEOUT = 15 * 60
     HTTP_OPEN_TIMEOUT = 5 * 60
 
     # Performs a get on a URL, using all of the connection options in the
     # client library, returning a HTTPI::Response.
-    def self.get_response(url, config = nil, headers = nil)
+    def self.get_response(url, config, headers = nil)
       request = prepare_request(url, config, headers)
       response = HTTPI.get(request)
       return response
@@ -40,20 +41,20 @@ module AdsCommon
 
     # Performs a get on a URL, using all of the connection options in the
     # client library, returning the response body as a string.
-    def self.get(url, config = nil, headers = nil)
+    def self.get(url, config, headers = nil)
       return get_response(url, config, headers).body
     end
 
     # Performs a post on a URL, using all of the connection options in the
     # client library, returning a HTTPI::Response.
-    def self.post_response(url, data, config = nil, headers = nil)
+    def self.post_response(url, data, config, headers = nil)
       request = prepare_request(url, config, headers, data)
       return HTTPI.post(request)
     end
 
     # Performs a post on a URL, using all of the connection options in the
     # client library, returning the response body as a string.
-    def self.post(url, data, config = nil, headers = nil)
+    def self.post(url, data, config, headers = nil)
       return post_response(url, data, config, headers).body
     end
 
@@ -61,7 +62,7 @@ module AdsCommon
 
     # Returns a suitably configured request object for a given URL and options.
     # Defaulting to stricter :peer validation.
-    def self.prepare_request(url, config = nil, headers = nil, data = nil)
+    def self.prepare_request(url, config, headers = nil, data = nil)
       request = HTTPI::Request.new(url)
       request.headers = headers if headers
       request.body = data if data
@@ -71,24 +72,22 @@ module AdsCommon
 
     # Configures HTTPI request according to the config provided.
     def self.configure_httpi(config, httpi)
-      if config
-        adapter = config.read('connection.adapter')
-        HTTPI.adapter = adapter if adapter
-        proxy = config.read('connection.proxy')
-        httpi.proxy = proxy if proxy
-        enable_gzip = config.read('connection.enable_gzip', false)
-        httpi.gzip if enable_gzip
-        logger = config.read('library.logger')
-        if logger
-          HTTPI.logger = logger
-          HTTPI.log_level = :debug
-        end
+      adapter = config.read('connection.adapter')
+      HTTPI.adapter = adapter if adapter
+      proxy = config.read('connection.proxy')
+      httpi.proxy = proxy if proxy
+      enable_gzip = config.read('connection.enable_gzip', false)
+      httpi.gzip if enable_gzip
+      logger = config.read('library.logger')
+      if logger
+        HTTPI.logger = logger
+        HTTPI.log_level = :debug
       end
-      httpi.read_timeout = (config.nil?) ? HTTP_READ_TIMEOUT :
+      httpi.read_timeout =
           config.read('connection.read_timeout', HTTP_READ_TIMEOUT)
-      httpi.open_timeout = (config.nil?) ? HTTP_OPEN_TIMEOUT :
+      httpi.open_timeout =
           config.read('connection.open_timeout', HTTP_OPEN_TIMEOUT)
-      strict_ssl = config.nil? or
+      strict_ssl =
           config.read('connection.strict_ssl_verification', true)
       httpi.auth.ssl.verify_mode = strict_ssl ? :peer : :none
     end

data/lib/ads_common/parameters_validator.rb

@@ -30,7 +30,8 @@ module AdsCommon
     # Instance initializer.
     #
     # Args:
-    #  - service: instance of savon_service to validate for
+    #  - registry: a registry that defines service
+    #
     def initialize(registry)
       @registry = registry
       @extra_namespaces = {}

data/lib/ads_common/results_extractor.rb

@@ -0,0 +1,183 @@
+# Encoding: utf-8
+#
+# Author:: api.dklimkin@gmail.com (Danial Klimkin)
+#
+# Copyright:: Copyright 2012, Google Inc. All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+# This class extracts data received from Savon and enriches it.
+
+module AdsCommon
+  class ResultsExtractor
+
+    # Instance initializer.
+    #
+    # Args:
+    #  - registry: a registry that defines service
+    #
+    def initialize(registry)
+      @registry = registry
+    end
+
+    # Extracts the finest results possible for the given result. Returns the
+    # response itself in worst case (contents unknown).
+    def extract_result(response, action_name)
+      method = @registry.get_method_signature(action_name)
+      action = method[:output][:name].to_sym
+      result = response.to_hash
+      result = result[action] if result.include?(action)
+      result = normalize_output(result, method)
+      return result[:rval] || result
+      return result
+    end
+
+    private
+
+    # Extracts misc data from response header.
+    def extract_header_data(response)
+      header_type = get_full_type_signature(:SoapResponseHeader)
+      headers = response.header[:response_header].dup
+      process_attributes(headers, false)
+      result = headers.inject({}) do |result, (key, v)|
+        normalize_output_field(headers, header_type[:fields], key)
+        result[key] = headers[key]
+        result
+      end
+      return result
+    end
+
+    # Normalizes output starting with root output node.
+    def normalize_output(output_data, method_definition)
+      fields = method_definition[:output][:fields]
+      result = normalize_fields(output_data, fields)
+    end
+
+    # Normalizes all fields for the given data based on the fields list
+    # provided.
+    def normalize_fields(data, fields)
+      fields.each do |field|
+        field_name = field[:name]
+        if data.include?(field_name)
+          field_data = data[field_name]
+          field_data = normalize_output_field(field_data, field)
+          field_data = check_array_collapse(field_data, field)
+          data[field_name] = field_data unless field_data.nil?
+        end
+      end
+      return data
+    end
+
+    # Normalizes one field of a given data recursively.
+    #
+    # Args:
+    #  - field_data: XML data to normalize
+    #  - field_def: field type definition for the data
+    #
+    def normalize_output_field(field_data, field_def)
+      return case field_data
+        when Array
+          normalize_array_field(field_data, field_def)
+        when Hash
+          normalize_hash_field(field_data, field_def)
+        else
+          normalize_item(field_data, field_def)
+      end
+    end
+
+    # Normalizes every item of an Array.
+    def normalize_array_field(data, field_def)
+      return data.map {|item| normalize_output_field(item, field_def)}
+    end
+
+    # Normalizes every item of a Hash.
+    def normalize_hash_field(field, field_def)
+      process_attributes(field, true)
+      field_type = determine_type(field, field_def[:type])
+      type_signature = get_full_type_signature(field_type)
+      # If we don't know the type, pass as-is.
+      return (type_signature.nil?) ?
+          field : normalize_fields(field, type_signature[:fields])
+    end
+
+    # Returns field type based on the field structure. Allows to override the
+    # type with custom xsi:type.
+    def determine_type(field_data, field_type)
+      if field_data.kind_of?(Hash) and field_data.include?(:xsi_type)
+        field_type = field_data[:xsi_type]
+      end
+      return field_type
+    end
+
+    # Converts one leaf item to a built-in type.
+    def normalize_item(item, field_def)
+      return case field_def[:type]
+        when 'long', 'int' then Integer(item)
+        when 'double', 'float' then Float(item)
+        when 'boolean' then item.kind_of?(String) ?
+            item.casecmp('true') == 0 : item
+        else item
+      end
+    end
+
+    # Checks if the field signature allows an array and forces array structure
+    # even for a signle item.
+    def check_array_collapse(data, field_def)
+      result = data
+      if !field_def[:min_occurs].nil? and
+          (field_def[:max_occurs] == :unbounded ||
+              (!field_def[:max_occurs].nil? and field_def[:max_occurs] > 1))
+        result = arrayize(result)
+      end
+      return result
+    end
+
+    # Makes sure object is an array.
+    def arrayize(object)
+      return [] if object.nil?
+      return object.is_a?(Array) ? object : [object]
+    end
+
+    # Returns all inherited fields of superclasses for given type.
+    def implode_parent(data_type)
+      result = []
+      if data_type[:base]
+        parent_type = @registry.get_type_signature(data_type[:base])
+        result += implode_parent(parent_type)
+      end
+      data_type[:fields].each do |field|
+        # If the parent type includes a field with the same name, overwrite it.
+        result.reject! {|parent_field| parent_field[:name].eql?(field[:name])}
+        result << field
+      end
+      return result
+    end
+
+    # Returns type signature with all inherited fields.
+    def get_full_type_signature(type_name)
+      result = (type_name.nil?) ? nil : @registry.get_type_signature(type_name)
+      result[:fields] = implode_parent(result) if result and result[:base]
+      return result
+    end
+
+    # Handles attributes received from Savon.
+    def process_attributes(data, keep_xsi_type = false)
+      if keep_xsi_type
+        xsi_type = data.delete(:"@xsi:type")
+        data[:xsi_type] = xsi_type if xsi_type
+      end
+      data.reject! {|key, value| key.to_s.start_with?('@')}
+    end
+  end
+end

data/lib/ads_common/savon_headers/base_header_handler.rb

@@ -24,27 +24,24 @@ require 'savon'
 module AdsCommon
   module SavonHeaders
     class BaseHeaderHandler
+
       # Default namespace alias.
       DEFAULT_NAMESPACE = 'wsdl'
+      DEFAULT_ELEMENT_NAME = 'RequestHeader'
 
       # Initializes a header handler.
       #
       # Args:
       #  - credential_handler: a header with credential data
       #  - auth_handler: a header with auth data
-      #  - element_name: an API-specific name of header element
       #  - namespace: default namespace to use
       #  - version: services version
       #
-      def initialize(credential_handler, auth_handler, element_name,
-                     namespace, version)
+      def initialize(credential_handler, auth_handler, namespace, version)
         @credential_handler = credential_handler
         @auth_handler = auth_handler
-        @element_name = element_name
         @namespace = namespace
         @version = version
-        @config = credential_handler.get_config
-        Savon.configure {|config| config.raise_errors = false}
       end
 
       # Enriches soap object with API-specific headers like namespaces, login
@@ -55,22 +52,27 @@ module AdsCommon
       # Args:
       #  - request: a HTTPI Request for extra configuration
       #  - soap: a Savon soap object to fill fields in
-      #  - args: request parameters to adjust for namespaces
       #
       # Returns:
       #  - Modified request and soap structures
       #
-      def prepare_request(request, soap, args)
+      def prepare_request(request, soap)
         soap.namespace = @namespace
-        soap.body = args if args
         # Sets the default namespace for the body.
         soap.input[2] = {:xmlns => @namespace}
         # Sets User-Agent in the HTTP header.
-        request.headers['User-Agent'] = generate_user_agent_string()
+        request.headers['User-Agent'] =
+            @credential_handler.generate_http_user_agent()
+        generate_headers(request, soap)
       end
 
       private
 
+      # Returns element name for SOAP header.
+      def get_header_element_name()
+        return DEFAULT_ELEMENT_NAME
+      end
+
       # Adds namespace to the given string.
       #
       # Args:
@@ -83,17 +85,20 @@ module AdsCommon
         return "%s:%s" % [DEFAULT_NAMESPACE, str]
       end
 
-      # Generates User-Agent text for HTTP request.
-      def generate_user_agent_string()
-        credentials = @credential_handler.credentials(@version)
-        app_name = credentials[:userAgent] || credentials[:useragent]
-        # We don't know the library version here. A breaking change needs to be
-        # introduced. This is scheduled for 0.7.0, using Common version for now.
-        lib_version = '0.6.4'
-        soap_user_agent = "Common-Ruby-%s; %s" % [lib_version, app_name]
-        user_agent = "Savon/%s (%s)" % [Savon::Version, soap_user_agent]
-        user_agent += ' (gzip)' if @config.read('connection.enable_gzip', false)
-        return user_agent
+      # Generates SOAP headers with the default request header element.
+      def generate_headers(request, soap)
+        element_name = get_header_element_name()
+        soap.header[prepend_namespace(element_name)] = generate_request_header()
+      end
+
+      # Generates SOAP default request header with all requested headers.
+      def generate_request_header()
+        credentials = @credential_handler.credentials
+        extra_headers = credentials[:extra_headers]
+        return extra_headers.inject({}) do |result, (header, value)|
+          result[prepend_namespace(header)] = value
+          result
+        end
       end
     end
   end