sem4r 0.1.1 → 0.1.2

data/lib/sem4r/account.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # -------------------------------------------------------------------
 # Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
 #
@@ -39,311 +40,7 @@ module Sem4r
     def client_email
       credentials.client_email
     end
-
-    ############################################################################
-    # Info Service
-
-    # FREE_USAGE_API_UNITS_PER_MONTH
-    #   Retrieves the number of  free API units that can be used by the developer
-    #   token being used to make the call for this month.
-    #   Specify only the apiUsageType parameter.
-    #
-    # TOTAL_USAGE_API_UNITS_PER_MONTH
-    #   Retrieves the total number of API units for this entire month that can
-    #   be used by the developer token being used to make this call. Includes
-    #   both free and paid API units.
-    #   Specify only the apiUsageType parameter.
-    #
-    # OPERATION_COUNT
-    #   Retrieves the number of operations recorded for the developer token
-    #   being used to make this call over the given date range.
-    #   The given dates
-    #   are inclusive; to get the operation count for a single day, supply it as
-    #   both the start and end date.
-    #   Specify the apiUsageType and dateRange parameters.
-    #
-    # UNIT_COUNT
-    #   Retrieves the number of API units recorded for the developer token being
-    #   used to make this call.
-    #     o Specify the apiUsageType and dateRange parameters to retrieve
-    #       the units recorded over the given date range.
-    #     o Specify the apiUsageType, serviceName, methodName, operator,
-    #       dateRange to retrieve the units recorded over the given date
-    #       range for a specified method.
-    #
-    # UNIT_COUNT_FOR_CLIENTS
-    #   Retrieves the number of API units recorded for a subset of clients over
-    #   the given date range for the developer token being used to make this
-    #   call.
-    #   The given dates are inclusive; to get the unit count for a single
-    #   day, supply it as both the start and end date.
-    #   Specify the apiUsageType, dateRange and clientEmails parameters.
-    #
-    # METHOD_COST
-    #   Retrieves the cost, in API units per operation, of the given method on
-    #   a specific date for the developer token being used to make this call.
-    #
-    #   Methods default to a cost of 1. Specify the apiUsageType, dateRange
-    #   (start date and end date should be the same), serviceName, methodName,
-    #   operator parameters.
-
-    enum :UsageTypes, [
-      :FREE_USAGE_API_UNITS_PER_MONTH,
-      :UNIT_COUNT,
-      :TOTAL_USAGE_API_UNITS_PER_MONTH,
-      :OPERATION_COUNT,
-      :UNIT_COUNT_FOR_CLIENTS,
-      :METHOD_COST]
-
-    def year_unit_cost(usage_type)
-      raise "usage type '#{usage_type}' not permitted" unless UsageTypes.include?(usage_type)
-      soap_message = service.info.unit_cost(@credentials, usage_type)
-      add_counters( soap_message.counters )
-      cost = REXML::XPath.first( soap_message.response, "//getResponse/rval/cost")
-      cost.text.to_i
-    end
-
-    ############################################################################
-    # Targeting Idea
-
-    def targeting_idea(&block)
-      selector = TargetingIdeaSelector.new(&block)
-      soap_message = service.targeting_idea.get(@credentials, selector.to_xml)
-      add_counters( soap_message.counters )
-      rval = REXML::XPath.first( soap_message.response, "//getResponse/rval")
-      els = REXML::XPath.match( rval, "entries")
-      els.map do |el|
-        TargetingIdea.from_element( el )
-      end
-    end
-
-    def p_targeting_idea(&block)
-      targeting_ideas = targeting_idea(&block)
-      targeting_ideas.each{ |idea| puts idea }
-    end
-
-    ############################################################################
-    # Bulk Jobs
-
-    def p_jobs
-      selector = BulkMutateJobSelector.new
-      soap_message = service.bulk_mutate_job.all(credentials, selector)
-      add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//getResponse/rval")
-      jobs = els.map do |el|
-        BulkMutateJob.from_element(el)
-      end
-
-      puts "#{jobs.length} bulk mutate jobs"
-      jobs.each do |job|
-        puts job.to_s
-      end
-      self
-    end
-
-    def job_mutate(bulk_mutate_job)
-      soap_message = service.bulk_mutate_job.mutate(credentials, bulk_mutate_job)
-      add_counters( soap_message.counters )
-      el = REXML::XPath.first( soap_message.response, "//rval")
-      BulkMutateJob.from_element(el)
-    end
-
-    ############################################################################
-    # Geo Location
-
-    def geo_location
-      soap_message = service.geo_location.get(@credentials, "")
-      add_counters( soap_message.counters )
-      # cost = REXML::XPath.first( soap_message.response, "//getResponse/rval/cost")
-      # cost.text.to_i
-    end
-
-    ############################################################################
-    # Reports - Service Report
-
-    def report(&block)
-      Report.new(self, &block)
-    end
-
-    def p_reports(refresh = false)
-      reports(refresh).each do |report|
-        puts report.to_s
-      end
-    end
-
-    def reports(refresh = false)
-      _reports unless @reports and !refresh
-      @reports
-    end
-
-    private
-
-    def _reports
-      soap_message = service.report.all(credentials)
-      add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//getAllJobsResponse/getAllJobsReturn")
-      @reports = els.map do |el|
-        Report.from_element(self, el)
-      end
-    end
-
-    public
-
-    ############################################################################
-    # Report Definitions - Service Report Definition
-
-    def report_definition(&block)
-      ReportDefinition.new(self, &block)
-    end
-
-    def p_report_definitions(refresh = false)
-      report_definitions(refresh).each do |report_definition|
-        puts report_definition.to_s
-      end
-    end
-
-    def report_definitions(refresh = false)
-      _report_definitions unless @report_definitions and !refresh
-      @report_definitions
-    end
-
-    private
-
-    def _report_definitions
-      soap_message = service.report_definition.get(credentials, ReportDefinitionSelector.new.to_xml)
-      add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//getAllJobsResponse/getAllJobsReturn")
-      @report_definitions = els.map do |el|
-        ReportDefinition.from_element(self, el)
-      end
-    end
-
-    public
-
-    ############################################################################
-    # Info Account - Service Account
-
-    def p_info
-      _info unless @currency_code
-      puts "currency_code: #{@currency_code}"
-      puts "customer_id: #{@customer_id}"
-      puts @billing_address
-    end
-
-    def currency_code
-      _info unless @currency_code
-      @currency_code
-    end
-
-    def customer_id
-      _info unless @customer_id
-      @customer_id
-    end
-
-    private
-
-    def _info
-      soap_message = service.account.account_info(credentials)
-      add_counters( soap_message.counters )
-      el = REXML::XPath.first( soap_message.response, "//getAccountInfoResponse/getAccountInfoReturn")
-      @currency_code = el.elements['currencyCode'].text.strip
-      @customer_id   = el.elements['customerId'].text.strip
-      @billing_address = BillingAddress.from_element( el.elements['billingAddress'] )
-    end
-
-    public
-
-    ############################################################################
-    # Account - Service Account
-
-    def client_accounts(refresh = false)
-      _client_accounts unless @accounts and !refresh
-      @accounts
-    end
-
-    def p_client_accounts(refresh = false)
-      cs = client_accounts(refresh)
-      # puts "#{cs.length} client accounts"
-      cs.each do |account|
-        puts account.to_s
-      end
-      self
-    end
-
-    alias clients client_accounts
-    alias p_clients p_client_accounts
-
-    private
-
-    def _client_accounts
-      soap_message = service.account.client_accounts(credentials)
-      add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//getClientAccountsReturn")
-      @accounts = els.map do |el|
-        client_email = el.text
-        Account.new( adwords, Credentials.new(@credentials, client_email) )
-      end
-    end
-
-    public
-
-    ############################################################################
-    # Campaign - Service Campaign
-
-    # TODO: accettare un parametro opzionale campaign(name=nil,&block)
-    #       la campagna che verra' creata ha il nome gia' settato
-    #       se esiste gia' una campagna con quel nome allora fara' da contesto
-    #       e non verra' creata
-    def campaign(name = nil, &block)
-      campaign = Campaign.new(self, name, &block)
-      campaign.save
-      @campaigns ||= []
-      @campaigns.push(campaign)
-      campaign
-    end
-
-    alias create_campaign campaign
-
-    def campaigns(refresh = false, opts = {}) # conditions = nil
-      if refresh.respond_to?(:keys)
-        opts = refresh
-        refresh = false
-      end
-      _campaigns unless @campaigns and !refresh
-      @campaigns
-      # return @campaigns unless conditions
-      # @campaigns.find_all {|c| c.name =~ conditions}
-    end
-
-    def p_campaigns(refresh = false, opts = {}) # conditions = nil
-      if refresh.respond_to?(:keys)
-        opts = refresh
-        refresh = false
-      end
-
-      cs = campaigns(refresh, opts)
-      puts "#{cs.length} campaigns"
-      campaigns(refresh).each do |campaign|
-        puts campaign.to_s
-      end
-      self
-    end
-
-    private
-
-    def _campaigns
-      soap_message = service.campaign.all(credentials)
-      add_counters( soap_message.counters )
-      rval = REXML::XPath.first( soap_message.response, "//getResponse/rval")
-      els = REXML::XPath.match( rval, "entries")
-      @campaigns = els.map do |el|
-        Campaign.from_element(self, el)
-      end
-    end
-
-    public
-
-    ###########################################################################
-
+  
   end
+
 end

data/lib/sem4r/ad_group/ad_group.rb

@@ -96,10 +96,10 @@ module Sem4r
 
     def self.from_element(campaign, el)
       new(campaign) do
-        @id          = el.elements["id"].text.strip.to_i
-        name           el.elements["name"].text.strip
-        status         el.elements["status"].text.strip
-        bids           el.elements["bids"]
+        @id          = el.at_xpath("id").text.strip.to_i
+        name           el.at_xpath("name").text.strip
+        status         el.at_xpath("status").text.strip
+        bids           el.at_xpath("bids")
       end
     end
 
@@ -117,8 +117,8 @@ module Sem4r
       unless @id
         soap_message = service.ad_group.create(credentials, to_xml("operand"))
         add_counters( soap_message.counters )
-        rval = REXML::XPath.first( soap_message.response, "//mutateResponse/rval")
-        id = REXML::XPath.match( rval, "value/id" ).first
+        rval = soap_message.response.xpath("//mutateResponse/rval").first
+        id = rval.xpath("value/id").first
         @id = id.text.strip.to_i
       end
     end
@@ -181,8 +181,8 @@ module Sem4r
     def _ads
       soap_message = service.ad_group_ad.all(credentials, id)
       add_counters( soap_message.counters )
-      rval = REXML::XPath.first( soap_message.response, "//getResponse/rval")
-      els = REXML::XPath.match( rval, "entries/ad")
+      rval = soap_message.response.xpath("//getResponse/rval").first
+      els = rval.xpath( "entries/ad" )
       @ads = els.map do |el|
         AdGroupAd.from_element( self, el )
       end
@@ -198,9 +198,11 @@ module Sem4r
         o = AdGroupAdOperation.new.add(ad)
         xml + o.to_xml("operations")
       end
+
       soap_message = service.ad_group_ad.mutate(credentials, xml)
       add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//mutateResponse/rval/value/ad/id")
+      els = soap_message.response.xpath("//mutateResponse/rval/value/ad/id")
+
       els.each_with_index do |e,index|
         id = e.text.strip.to_i
         unsaved_ads[index].instance_eval{ @id = id }
@@ -266,8 +268,8 @@ module Sem4r
     def _criterions
       soap_message = service.ad_group_criterion.all(credentials, id)
       add_counters( soap_message.counters )
-      rval = REXML::XPath.first( soap_message.response, "//getResponse/rval")
-      els = REXML::XPath.match( rval, "entries/criterion")
+      rval = soap_message.response.xpath("//getResponse/rval").first
+      els = rval.xpath( "entries/criterion" )
       @criterions = els.map do |el|
         Criterion.from_element( self, el )
       end
@@ -287,7 +289,7 @@ module Sem4r
       end
       soap_message = service.ad_group_criterion.mutate(credentials, xml)
       add_counters( soap_message.counters )
-      els = REXML::XPath.match( soap_message.response, "//mutateResponse/rval/value/criterion/id")
+      els = soap_message.response.xpath("//mutateResponse/rval/value/criterion/id")
       els.each_with_index do |e,index|
         id = e.text.strip.to_i
         unsaved_criterions[index].criterion.instance_eval{ @id = id }
@@ -324,8 +326,8 @@ module Sem4r
     def _ad_params
       soap_message = service.ad_param.all(credentials, id)
       add_counters( soap_message.counters )
-      rval = REXML::XPath.first( soap_message.response, "//getResponse/rval")
-      els = REXML::XPath.match( rval, "entries")
+      rval = soap_message.response.xpath("//getResponse/rval").first
+      els = rval.xpath( "entries" )
       @ad_params = els.map do |el|
         AdParam.from_element( self, el )
       end

data/lib/sem4r/ad_group/ad_group_bids.rb

@@ -40,7 +40,7 @@ module Sem4r
     end
 
     def self.from_element(el)
-      type =  el.elements["AdGroupBids.Type"].text.strip
+      type = el.at_xpath("AdGroupBids.Type").text.strip
       klass = Module::const_get(type)
       klass.from_element(el)
     end
@@ -114,15 +114,15 @@ module Sem4r
 
     def self.from_element(el)
       new do
-        kel = el.elements["keywordMaxCpc"]
+        kel = el.at_xpath("keywordMaxCpc")
         if kel
-          el_amount = kel.elements["amount"]
-          keyword_max_cpc     el_amount.elements["microAmount"].text.strip.to_i
+          el_amount = kel.at_xpath("amount")
+          keyword_max_cpc(el_amount.at_xpath("microAmount").text.strip.to_i)
         end
-        sel = el.elements["siteMaxCpc"]
+        sel = el.at_xpath("siteMaxCpc")
         if sel
-          el_amount = sel.elements["amount"]
-          site_max_cpc     el_amount.elements["microAmount"].text.strip.to_i
+          el_amount = sel.at_xpath("amount")
+          site_max_cpc(el_amount.at_xpath("microAmount").text.strip.to_i)
         end
         # TODO: it is possible something like:
         #        el.elements["maxCpc"] do |el|
@@ -130,6 +130,7 @@ module Sem4r
         #            max_cpc el["microAmount"]
         #          end
         #        end
+
       end
     end
   end
@@ -157,10 +158,10 @@ module Sem4r
 
     def self.from_element(el)
       new do
-        kel = el.elements["maxCpm"]
+        kel = el.xpath("maxCpm").first
         if kel
-          el_amount = kel.elements["amount"]
-          max_cpm     el_amount.elements["microAmount"].text.strip.to_i
+          el_amount = kel.xpath("amount").first
+          max_cpm     el_amount.xpath("microAmount").first.text.strip.to_i
         end
       end
     end

data/lib/sem4r/ad_group/ad_group_service.rb

@@ -27,14 +27,14 @@ module Sem4r
 
     def initialize(connector)
       @connector = connector
-      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201003"
+      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201008"
       @header_namespace = @service_namespace
-      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201003/AdGroupService"
+      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201008/AdGroupService"
     end
 
-    soap_call_v2009 :all,       :mutate => false
-    soap_call_v2009 :create,    :mutate => true
-    soap_call_v2009 :delete,    :mutate => true
+    soap_call_v2010 :all,       :mutate => false
+    soap_call_v2010 :create,    :mutate => true
+    soap_call_v2010 :delete,    :mutate => true
 
     def _all(campaign_id)
       <<-EOFS

data/lib/sem4r/ad_group_ad/ad_group_ad.rb

@@ -85,7 +85,7 @@ module Sem4r
     end
 
     def self.from_element( ad_group, el )
-      xml_type =       el.elements["Ad.Type"].text.strip
+      xml_type =       el.at_xpath("Ad.Type").text.strip
       case xml_type
       when TextAd
         AdGroupTextAd.from_element(ad_group, el)

data/lib/sem4r/ad_group_ad/ad_group_ad_service.rb

@@ -27,15 +27,15 @@ module Sem4r
 
     def initialize(connector)
       @connector = connector
-      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201003"
+      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201008"
       @header_namespace = @service_namespace
       
-      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201003/AdGroupAdService"
+      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201008/AdGroupAdService"
     end
 
-    soap_call_v2009 :all,   :mutate => false
-    soap_call_v2009 :mutate
-
+    soap_call_v2010 :all,   :mutate => false
+    soap_call_v2010 :mutate
+      
     private
 
     def _all(ad_group_id)

data/lib/sem4r/ad_group_ad/ad_group_mobile_ad.rb

@@ -111,13 +111,13 @@ module Sem4r
 
     def self.from_element(ad_group, el)
       new(ad_group) do
-        @id         = el.elements["id"].text.strip.to_i
-        # type          el.elements["Ad.Type"].text
-        headline       el.elements["headline"].text.strip
-        description    el.elements["description"].text.strip
-        business_name  el.elements["businessName"].text.strip
-        country_code   el.elements["countryCode"].text.strip
-        phone_number   el.elements["phoneNumber"].text.strip
+        @id         = el.at_xpath("id").text.strip.to_i
+        # type          el.at_xpath("Ad.Type").text
+        headline       el.at_xpath("headline").text.strip
+        description    el.at_xpath("description").text.strip
+        business_name  el.at_xpath("businessName").text.strip
+        country_code   el.at_xpath("countryCode").text.strip
+        phone_number   el.at_xpath("phoneNumber").text.strip
         # TODO: estrarre le carriers
       end
     end
@@ -126,8 +126,8 @@ module Sem4r
       unless @id
         soap_message = service.ad_group_ad.create(credentials, to_xml("operand"))
         add_counters( soap_message.counters )
-        rval = REXML::XPath.first( soap_message.response, "//mutateResponse/rval")
-        id = REXML::XPath.match( rval, "value/ad/id" ).first
+        rval = soap_message.response.xpath("//mutateResponse/rval", soap_message.response_headers).first
+        id = rval.xpath("value/ad/id").first
         @id = id.text.strip.to_i
       end
       self

data/lib/sem4r/ad_group_ad/ad_group_text_ad.rb

@@ -68,13 +68,13 @@ module Sem4r
 
     def self.from_element(ad_group, el)
       new(ad_group) do
-        @id         = el.elements["id"].text.strip.to_i
-        # type          el.elements["Ad.Type"].text
-        url           el.elements["url"].text.strip
-        display_url   el.elements["displayUrl"].text.strip
-        headline      el.elements["headline"].text.strip
-        description1  el.elements["description1"].text.strip
-        description2  el.elements["description2"].text.strip
+        @id         = el.at_xpath("id").text.strip.to_i
+        # type          el.at_xpath("Ad.Type").text
+        url           el.at_xpath("url").text.strip
+        display_url   el.at_xpath("displayUrl").text.strip
+        headline      el.at_xpath("headline").text.strip
+        description1  el.at_xpath("description1").text.strip
+        description2  el.at_xpath("description2").text.strip
       end
     end
 
@@ -87,8 +87,8 @@ module Sem4r
         ad_operation = AdGroupAdOperation.new.add self
         soap_message = service.ad_group_ad.mutate(credentials, ad_operation.to_xml("operations"))
         add_counters( soap_message.counters )
-        rval = REXML::XPath.first( soap_message.response, "//mutateResponse/rval")
-        id = REXML::XPath.match( rval, "value/ad/id" ).first
+        rval = soap_message.response.xpath("//mutateResponse/rval").first
+        id = rval.xpath("value/ad/id").first
         @id = id.text.strip.to_i
       end
       self

data/lib/sem4r/ad_group_criterion/ad_group_criterion.rb

@@ -38,7 +38,7 @@ module Sem4r
     end
 
     def self.from_element(ad_group, el)
-      type =  el.elements["AdGroupCriterion.Type"].text.strip
+      type =  el.at_xpath("AdGroupCriterion.Type").text.strip
       klass = Module::const_get(type)
       klass.from_element(ad_group, el)
     end
@@ -53,8 +53,8 @@ module Sem4r
         soap_message =
           criterion.service.ad_group_criterion.mutate(criterion.credentials, o.to_xml("operations"))
         criterion.add_counters( soap_message.counters )
-        rval = REXML::XPath.first( soap_message.response, "//mutateResponse/rval")
-        id = REXML::XPath.match( rval, "value/criterion/id" ).first
+        rval = soap_message.response.xpath("//mutateResponse/rval").first
+        id = rval.xpath("value/criterion/id").first
         criterion.instance_eval{ @id = id.text.strip.to_i }
       end
       self
@@ -79,8 +79,8 @@ module Sem4r
 
     def self.from_element(ad_group, el)
       new(ad_group) do
-        criterion Criterion.from_element(ad_group, el.elements["criterion"])
-        bids      AdGroupCriterionBids.from_element(el.elements["bids"])
+        criterion Criterion.from_element(ad_group, el.at_xpath("criterion"))
+        bids      AdGroupCriterionBids.from_element(el.at_xpath("bids"))
       end
     end
 
@@ -119,7 +119,7 @@ module Sem4r
 
     def self.from_element(ad_group, el)
       new(ad_group) do
-        criterion Criterion.from_element(ad_group, el.elements["criterion"])
+        criterion Criterion.from_element(ad_group, el.at_xpath("criterion"))
       end
     end
 

data/lib/sem4r/ad_group_criterion/ad_group_criterion_bids.rb

@@ -35,7 +35,7 @@ module Sem4r
     ]
 
     def self.from_element(el)
-      type =  el.elements["AdGroupCriterionBids.Type"].text.strip
+      type =  el.at_xpath("AdGroupCriterionBids.Type").text.strip
       klass = Module::const_get(type)
       klass.from_element(el)
     end
@@ -63,12 +63,11 @@ module Sem4r
 
     def self.from_element(el)
       new do
-        bid_source       el.elements["bidSource"].text.strip
-
-        el_maxCpc = el.elements["maxCpc"]
-        el_amount = el_maxCpc.elements["amount"]
-        max_cpc     el_amount.elements["microAmount"].text.strip.to_i
+        bid_source       el.at_xpath("bidSource").text.strip
 
+        el_maxCpc = el.at_xpath("maxCpc")
+        el_amount = el_maxCpc.at_xpath("amount")
+        max_cpc     el_amount.at_xpath("microAmount").text.strip.to_i
         # TODO: it is possible something like:
         #        el.elements["maxCpc"] do |el|
         #          el.elements["amount"] do el

data/lib/sem4r/ad_group_criterion/ad_group_criterion_operations.rb

@@ -32,4 +32,3 @@ module Sem4r
     end
   end
 end
-

data/lib/sem4r/ad_group_criterion/ad_group_criterion_service.rb

@@ -27,14 +27,14 @@ module Sem4r
 
     def initialize(connector)
       @connector = connector
-      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201003"
+      @service_namespace = "https://adwords.google.com/api/adwords/cm/v201008"
       @header_namespace = @service_namespace
 
-      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201003/AdGroupCriterionService"
+      @sandbox_service_url = "https://adwords-sandbox.google.com/api/adwords/cm/v201008/AdGroupCriterionService"
     end
 
-    soap_call_v2009 :all,   :mutate => false
-    soap_call_v2009 :mutate
+    soap_call_v2010 :all,   :mutate => false
+    soap_call_v2010 :mutate
 
     private
     

data/lib/sem4r/ad_group_criterion/criterion.rb

@@ -45,9 +45,9 @@ module Sem4r
     end
 
     def self.from_element( ad_group, el )
-      xml_type =       el.elements["Criterion.Type"].text.strip
-      #      klass = Module::const_get(type)
-      #      klass.from_element(ad_group, el)
+      xml_type = el.at_xpath("Criterion.Type").text.strip
+      # klass = Module::const_get(type)
+      # klass.from_element(ad_group, el)
       case xml_type
       when Keyword
         CriterionKeyword.from_element(ad_group, el)