ysm4r 0.1

data/Authors.txt

@@ -0,0 +1,2 @@
+"Brian Hawthorne" <brian.lee.hawthorne@gmail.com>
+"Patrick Chanezon" <chanezon@google.com>

data/ChangeLog.txt

@@ -0,0 +1 @@
+0.1 -first version, supports YSM versions 1 and 2, not fully tested

data/License.txt

@@ -0,0 +1,13 @@
+Copyright 2007 Brian Hawthorne
+
+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.

data/Rakefile

@@ -0,0 +1,209 @@
+require 'rubygems'
+gem 'soap4r'
+require 'soap/compat'
+require 'net/http'
+require 'fileutils'
+require 'rake/clean'
+require 'rake/testtask'
+begin
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+require 'lib/soapex/wsdl2ruby'
+require 'lib/ysm4r/service'
+
+CLOBBER.include('pkg')
+
+# Determine the current version of the software
+CURRENT_VERSION = '0.1'
+PKG_VERSION = ENV['REL'] ? ENV['REL'] : CURRENT_VERSION
+
+SRC_RB = FileList['lib/**/*.rb']
+
+SANDBOX = true
+WSDLDIR = 'wsdl'
+LIBDIR = 'lib'
+GENDIR = LIBDIR + '/ysm4r'
+
+CLEAN.include(WSDLDIR)
+YSM::Service.getVersions.each do |vnum|
+    CLEAN.include(File.join(GENDIR, "v#{vnum}"))
+end
+
+# The default task is run if rake is given no explicit arguments.
+desc "Default task runs the unit tests."
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+desc "gets the wsdl files for YSM services"
+task :getwsdl do
+  host = "searchmarketing.yahoo.com"
+  YSM::Service.getVersions.each do |vnum|
+    vname = "v#{vnum}"
+    mkdir_p(File.join(WSDLDIR, vname, "sandbox"))
+    YSM::Service.getServices(vnum).each do |s|
+      path = "/developer/docs/V#{vnum}/wsdl/V#{vnum}/#{s}Service.wsdl"
+      save(getfile(host, path), getWsdlFileName(vname,s))
+
+      # put sandbox wsdls in their own directory
+      if ["Location", "Upgrade"].include?(s)
+        path = "/developer/docs/V#{vnum}/wsdl-sandbox/V#{vnum}/#{s}Service.wsdl"
+        save(getfile(host, path), getWsdlFileName(vname, s, true))
+      end
+    end
+
+  end
+end
+
+desc "generates YSM classes from the wsdl files"
+task :generate do
+  YSM::Service.getVersions.each do |vnum|
+    vname = "v#{vnum}"
+    gendir = File.join(GENDIR, "v#{vnum}")
+    mkdir_p(File.join(gendir, "sandbox"))
+    YSM::Service.getServices(vnum).each do |name|
+      generateServiceFiles(gendir, vnum, name)
+      if ["Location", "Upgrade"].include?(name)
+        generateServiceFiles(gendir, vnum, name, true)
+      end
+    end
+  end
+end
+
+def generateServiceFiles(gendir, versionnum, servicename, sandbox=false)
+  versionname = "v#{versionnum}"
+  wsdlfilename = getWsdlFileName(versionname, servicename, sandbox)
+  sandbox = sandbox ? "sandbox" : ""
+  generator = SOAP::MultiService::WSDL2Ruby.new(File.join(gendir, sandbox), true)
+  generator.run(wsdlfilename, :modulepath=>"YSM::#{servicename}Service", :classdef=>nil, :mapping_registry=>nil, :driver=>nil)
+  fixFile(versionname, File.join(gendir, sandbox, "#{servicename}Service.rb"))
+  fixFile(versionname, File.join(gendir, sandbox, "#{servicename}ServiceMappingRegistry.rb"))
+  fixFile(versionname, File.join(gendir, sandbox, "#{servicename}ServiceDriver.rb"))
+end
+
+def filterFile(file)
+  tempfile = file + '.tmp'
+  outfile = File.new(tempfile,"w")
+  File.open(file, "r") do |infile|
+    yield(infile, outfile)
+  end
+  outfile.close
+  File.rename(tempfile, file)
+end
+
+def fixFile(versionname, file)
+  puts "fixing: #{file}"
+  filterFile(file) do |infile, outfile|
+    input = infile.read
+    # driver imports mapping registry instead of classdef file
+    if file =~ /Driver/
+      input.gsub!(/require \'(.*)Service/, 'require \'\1ServiceMappingRegistry')
+    end
+    # set proper requirepath (should be done by wsdl2ruby)
+    input.gsub!(/require \'(.*)Service(.*).rb\'/, 'require \'ysm4r/' + versionname + '/\1Service\2\'')
+    outfile.puts input
+  end
+end 
+
+  
+def getWsdlFileName(version, service, sandbox=false)
+    #(puts("getWsdlFilename(#{version.inspect}, #{service.inspect}, #{sandbox.inspect})")) if $DEBUG
+    sandbox = sandbox ? "sandbox" : ""
+    File.join(WSDLDIR, version, sandbox, service+".wsdl")
+end
+     
+def getfile(host, path)
+    puts "getting http://#{host}#{path}"
+    http = Net::HTTP.new(host)
+    http.start { |w| w.get2(path).body }
+end
+
+def fixWsdl(wsdl)
+  ['type', 'base'].each do |name|
+    ['long', 'string', 'date', 'int', 'boolean'].each do |type|
+      wsdl.gsub!(Regexp.new("#{name}=\"#{type}\""),"#{name}=\"xsd:#{type}\"")
+    end
+  end
+  schema_ns = "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
+  if wsdl !~ Regexp.new(schema_ns)
+    wsdl.gsub!(/(<wsdl:definitions[^>]*)>/, '\1 ' + schema_ns + '>')
+  end
+  wsdl.gsub!("ServiceService", "Service")
+  wsdl
+end
+
+# Saves this document to the specified @var path.
+#doesn't create the file if contains markup for google 404 page
+def save(content, path)
+    if content !~ /<H2>Error 404<\/H2>/
+        File::open(path, 'w') {|f| f.write(fixWsdl(content))}
+    end
+end
+
+# ====================================================================
+# Create a task that will package the Rake software into distributable
+# gem files.
+
+PKG_FILES = FileList[
+  '*.*', 
+  'Rakefile', 
+  'lib/**/*.rb', 
+  'examples/**/*.rb', 
+  'test/**/*.rb',
+  'scripts/**/*.rb'
+]
+
+PKG_FILES.exclude(/\._/)
+
+if ! defined?(Gem)
+  puts "Package Target requires RubyGEMs"
+else
+  spec = Gem::Specification.new do |s|
+    
+    #### Basic information.
+
+    s.name = 'ysm4r'
+    s.version = PKG_VERSION
+    s.summary = "Client library for the Yahoo Search Marketing API."
+    s.description = %{\
+Ysm4r provides a high-level Ruby interface to Yahoo's Search Marketing API.\
+Currently the following API versions are supported:\
+\
+* V1\
+* V2\
+}
+
+    s.files = PKG_FILES.to_a
+    s.require_path = 'lib'
+    s.autorequire = 'ysm4r'
+    
+    s.test_files = PKG_FILES.select { |fn| fn =~ /^test\/test/ }
+    
+    #s.has_rdoc = true
+    s.has_rdoc = false
+    #s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+    #s.rdoc_options <<
+#      '--title' <<  'Builder -- Easy XML Building' <<
+#      '--main' << 'README' <<
+#      '--line-numbers'
+    
+    s.author = "Brian Hawthorne"
+    s.homepage = "http://rubyforge.org/projects/ysm4r/"
+    s.requirements << 'soap4r v 1.5.6 or greater'
+    s.requirements << 'http-access2 v 2.0.5 or greater'
+    s.rubyforge_project = 'ysm4r'
+  end
+  
+  Rake::GemPackageTask.new(spec) do |t|
+    t.need_tar = true
+  end
+end
+
+#require 'scripts/publish'
+

data/Readme.txt

@@ -0,0 +1,4 @@
+ysm4r:  a Ruby client for Yahoo's Search Marketing API
+
+Forked from Patrick Chanezon's Google AdWords client for ruby (adwords4r):
+http://code.google.com/p/google-api-adwords-ruby/

data/clean.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+rm -rf lib/ysm4r/v1/*
+rm -rf lib/ysm4r/v2/*

data/lib/soapex/driver.rb

@@ -0,0 +1,13 @@
+require 'soap/rpc/driver'
+
+module SOAP::RPC
+  class Driver
+    def prepare(headers, endpoint=nil)
+      self.proxy.endpoint_url = endpoint if endpoint
+      headers.each {|h| self.headerhandler << h}
+      (self.wiredump_dev = STDOUT) if $DEBUG
+      self.options['protocol.http.ssl_config.verify_mode'] = nil
+      (self.wiredump_file_base = "debug") if $DEBUG
+    end
+  end
+end

data/lib/soapex/error.rb

@@ -0,0 +1,49 @@
+module SOAP::MultiService
+
+  # Generic error provides base class for more specific errors
+  # while still allowing a blanket rescue for any multiservice error.
+  class Error < StandardError; end
+
+  # Raised if a call is made to a method that does not exist in the multiservice API
+  class UnknownAPICall < Error; end
+        
+  # Raised if an attempt is made to instantiate a type that does not exist in
+  # the multiservice SOAP API
+  class UnknownType < Error; end
+        
+  # Raised if a call returns with a SOAP error
+  class ApiError < Error
+    attr_accessor :soap_faultcode
+    attr_accessor :soap_faultstring
+    attr_accessor :code
+    attr_accessor :internal
+    attr_accessor :message
+    attr_accessor :trigger
+    attr_accessor :violations
+    
+    def initialize(fault)
+      @soap_faultcode = getOrNil(fault, 'faultcode')
+      @soap_faultstring = getOrNil(fault, 'faultstring')
+      @code = getOrNil(fault.detail, 'code')
+      @internal = getOrNil(fault.detail,'internal')
+      @message = @soap_faultstring #getOrNil(fault.detail,'message')
+      @message = getOrNil(fault.detail,'message')
+      @trigger = getOrNil(fault.detail,'trigger')
+      @violations = getOrNil(fault.detail,'violations')
+    end
+
+    def inspect
+      "#<SOAP::MultiService::ApiError: \"#{@code || @soap_faultstring || @message}\">"
+    end
+
+    def to_s
+      inspect
+    end
+      
+    private
+    def getOrNil(obj, meth)
+        obj.respond_to?(meth) ? eval("obj.#{meth}") : nil
+    end
+  end
+end
+

data/lib/soapex/mapping.rb

@@ -0,0 +1,31 @@
+require 'soap/mapping/mapping'
+require 'soap/mapping/registry'
+
+def needspatch
+  SOAP::Mapping.set_attributes(a=[], :x=>10)
+  a != [10]
+rescue Exception => e
+  true
+end
+  
+if needspatch
+
+  # Apply mapping patch only if it has not already been applied.
+  class << SOAP::Mapping
+    alias set_attributes_old set_attributes
+    def set_attributes(obj, values)
+      if not obj.is_a?(::SOAP::Mapping::Object) and obj.kind_of?(Array)
+        values.each do |key, value|
+          if value.kind_of?(Array)
+            obj.concat(value)
+          else
+            obj << value
+          end
+        end
+      else
+        set_attributes_old(obj, values)
+      end
+    end
+  end
+
+end

data/lib/soapex/wsdl2ruby.rb

@@ -0,0 +1,166 @@
+# WSDL4R - WSDL to ruby mapping library.
+# Copyright (C) 2002-2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'logger'
+require 'xsd/qname'
+require 'wsdl/importer'
+require 'wsdl/soap/classDefCreator'
+require 'wsdl/soap/servantSkeltonCreator'
+require 'wsdl/soap/driverCreator'
+require 'wsdl/soap/clientSkeltonCreator'
+require 'wsdl/soap/standaloneServerStubCreator'
+require 'wsdl/soap/cgiStubCreator'
+
+
+module SOAP
+module MultiService
+
+class WSDL2Ruby
+  attr_reader :options, :logger, :basedir
+
+  Options = [:classdef, :mapping_registry, :driver, :client_skelton, :servant_skelton,
+    :standalone_server_stub, :cgi_stub]
+
+  def initialize(basedir, force=false, logger=nil)
+    @basedir = basedir
+    @force = force
+    @logger ||= Logger.new(STDERR)
+  end
+
+  def run(location, options={})
+    @modulepath = (options[:modulepath] || "")
+    @wsdl = import(location)
+    @servicename = @wsdl.services[0].name.name
+    Options.each do |optname|
+      if options.key?(optname)
+        servicename = (options[optname] || @servicename)
+        method("create_#{optname.to_s}".to_sym).call(servicename)
+      end
+    end
+  end
+
+private
+
+  def create_classdef(servicename)
+    @logger.info { "Creating class definition." }
+    @classdef_filename = servicename + '.rb'
+    write_file(@classdef_filename) do |f|
+      f << WSDL::SOAP::ClassDefCreator.new(@wsdl, @modulepath).dump
+    end
+  end
+
+  def create_mapping_registry(servicename)
+    @logger.info { "Creating mapping registry." }
+    @mapping_registry_filename = servicename + 'MappingRegistry.rb'
+    write_file(@mapping_registry_filename) do |f|
+      f << "require '#{@classdef_filename}'\n" if @classdef_filename
+      f << WSDL::SOAP::MappingRegistryCreator.new(@wsdl, @modulepath).dump
+    end
+  end
+
+  def create_driver(servicename)
+    @logger.info { "Creating driver." }
+    @driver_filename = servicename + 'Driver.rb'
+    write_file(@driver_filename) do |f|
+      f << "require '#{@classdef_filename}'\n\n" if @classdef_filename
+      f << WSDL::SOAP::DriverCreator.new(@wsdl, @modulepath).dump(create_name(servicename))
+    end
+  end
+
+  def create_client_skelton(servicename)
+    @logger.info { "Creating client skelton." }
+    @client_skelton_filename = servicename + 'Client.rb'
+    write_file(@client_skelton_filename) do |f|
+      f << shbang << "\n"
+      f << "require '#{@driver_filename}'\n\n" if @driver_filename
+      f << WSDL::SOAP::ClientSkeltonCreator.new(@wsdl, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def create_servant_skelton(servicename)
+    @logger.info { "Creating servant skelton." }
+    @servant_skelton_filename = servicename + 'Servant' + '.rb'
+    write_file(@servant_skelton_filename) do |f|
+      f << "require '#{@classdef_filename}'\n\n" if @classdef_filename
+      f << WSDL::SOAP::ServantSkeltonCreator.new(@wsdl, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def create_cgi_stub(servicename=nil)
+    @logger.info { "Creating CGI stub." }
+    @cgi_stubFilename = servicename + '.cgi'
+    write_file(@cgi_stubFilename) do |f|
+      f << shbang << "\n"
+      if @servant_skelton_filename
+	f << "require '#{@servant_skelton_filename}'\n\n"
+      end
+      f << WSDL::SOAP::CGIStubCreator.new(@wsdl, @modulepath).dump(create_name(servicename))
+    end
+  end
+
+  def create_standalone_server_stub(servicename=nil)
+    @logger.info { "Creating standalone stub." }
+    @standalone_server_stub_filename = servicename + '.rb'
+    write_file(@standalone_server_stub_filename) do |f|
+      f << shbang << "\n"
+      f << "require '#{@servant_skelton_filename}'\n\n" if @servant_skelton_filename
+      f << WSDL::SOAP::StandaloneServerStubCreator.new(@wsdl, @modulepath).dump(
+	create_name(servicename))
+    end
+  end
+
+  def write_file(filename)
+    check_file(filename) or return
+
+    if @basedir
+      filename = File.join(basedir, filename)
+    end
+    File.open(filename, "w") do |f|
+      yield f
+    end
+  end
+
+  def check_file(filename)
+    if @basedir
+      filename = File.join(basedir, filename)
+    end
+    if FileTest.exist?(filename)
+      if @force
+	@logger.warn {
+	  "File '#{filename}' exists but overrides it."
+	}
+	true
+      else
+	@logger.warn {
+	  "File '#{filename}' exists.  #{$0} did not override it."
+	}
+	false
+      end
+    else
+      @logger.info { "Creates file '#{filename}'." }
+      true
+    end
+  end
+
+  def shbang
+    "#!/usr/bin/env ruby"
+  end
+
+  def create_name(name)
+    name ? XSD::QName.new(@wsdl.targetnamespace, name) : nil
+  end
+
+  def import(location)
+    WSDL::Importer.import(location)
+  end
+end
+
+end
+end