jmeeks-actionwebservice 2.3.2

data/Rakefile

@@ -0,0 +1,173 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'lib', 'action_web_service', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'actionwebservice'
+PKG_VERSION   = ActionWebService::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "aws"
+RUBY_FORGE_USER    = "webster132"
+
+desc "Default Task"
+task :default => [ :test ]
+
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.test_files = Dir['test/*_test.rb']
+  t.verbose = true
+}
+
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+desc 'Build the MySQL test database'
+task :build_database do 
+  %x( mysqladmin -uroot create actionwebservice_unittest )
+  %x( mysql -uroot actionwebservice_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
+end
+
+
+# Generate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Action Web Service -- Web services for Action Pack"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('CHANGELOG')
+  rdoc.rdoc_files.include('lib/action_web_service.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/api/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/client/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/container/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/dispatcher/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/protocol/*.rb')
+  rdoc.rdoc_files.include('lib/action_web_service/support/*.rb')
+}
+
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "Web service support for Action Pack."
+  s.description = %q{Adds WSDL/SOAP and XML-RPC web service support to Action Pack}
+  s.version = PKG_VERSION
+
+  s.author = "Leon Breedt, Kent Sibilev"
+  s.email = "bitserf@gmail.com, ksibilev@yahoo.com"
+  s.rubyforge_project = "aws"
+  s.homepage = "http://www.rubyonrails.org"
+
+  s.add_dependency('actionpack', '= 2.3.2' + PKG_BUILD)
+  s.add_dependency('activerecord', '= 2.3.2' + PKG_BUILD)
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.autorequire = 'actionwebservice'
+
+  s.files = [ "Rakefile", "setup.rb", "README", "TODO", "CHANGELOG", "MIT-LICENSE" ]
+  s.files = s.files + Dir.glob( "examples/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
+  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
+  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
+  s.files = s.files + Dir.glob( "generators/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
+end
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+
+# Publish beta gem
+desc "Publish the API documentation"
+task :pgem => [:package] do 
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
+end
+
+# Publish documentation
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/aws", "doc").upload
+end
+
+
+def each_source_file(*args)
+	prefix, includes, excludes, open_file = args
+	prefix ||= File.dirname(__FILE__)
+	open_file = true if open_file.nil?
+	includes ||= %w[lib\/action_web_service\.rb$ lib\/action_web_service\/.*\.rb$]
+	excludes ||= %w[lib\/action_web_service\/vendor]
+	Find.find(prefix) do |file_name|
+		next if file_name =~ /\.svn/
+		file_name.gsub!(/^\.\//, '')
+		continue = false
+		includes.each do |inc|
+			if file_name.match(/#{inc}/)
+				continue = true
+				break
+			end
+		end
+		next unless continue
+		excludes.each do |exc|
+			if file_name.match(/#{exc}/)
+				continue = false
+				break
+			end
+		end
+		next unless continue
+		if open_file
+			File.open(file_name) do |f|
+				yield file_name, f
+			end
+		else
+			yield file_name
+		end
+	end
+end
+
+desc "Count lines of the AWS source code"
+task :lines do
+  total_lines = total_loc = 0
+  puts "Per File:"
+	each_source_file do |file_name, f|
+    file_lines = file_loc = 0
+    while line = f.gets
+      file_lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      file_loc += 1
+    end
+    puts "  #{file_name}: Lines #{file_lines}, LOC #{file_loc}"
+    total_lines += file_lines
+    total_loc += file_loc
+  end
+  puts "Total:"
+  puts "  Lines #{total_lines}, LOC #{total_loc}"
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/TODO

@@ -0,0 +1,32 @@
+= Post-1.0
+  - Document/Literal SOAP support
+    - URL-based dispatching, URL identifies method
+
+  - Add :rest dispatching mode, a.l.a. Backpack API. Clean up dispatching
+    in general. Support vanilla XML-format as a "Rails" protocol?
+    XML::Simple deserialization into params?
+
+      web_service_dispatching_mode :rest
+
+      def method1(params)
+      end
+
+      def method2(params)
+      end
+
+
+      /ws/method1
+        <xml>
+      /ws/method2
+        <yaml>
+
+  - Allow locking down a controller to only accept messages for a particular
+    protocol.  This will allow us to generate fully conformant error messages
+    in cases where we currently fudge it if we don't know the protocol.
+
+  - Allow AWS user to participate in typecasting, so they can centralize
+    workarounds for buggy input in one place
+  
+= Refactoring
+  - Don't have clean way to go from SOAP Class object to the xsd:NAME type
+    string -- NaHi possibly looking at remedying this situation

data/examples/googlesearch/README

@@ -0,0 +1,143 @@
+= Google Service example
+
+This example shows how one would implement an API like Google
+Search that uses lots of structured types.
+
+There are examples for "Direct" and "Delegated" dispatching
+modes.
+
+There is also an example for API definition file autoloading.
+
+
+= Running the examples
+
+  1. Add the files to an Action Web Service enabled Rails project.
+
+    "Direct" example:
+
+      * Copy direct/search_controller.rb to "app/controllers"
+        in a Rails project.
+      * Copy direct/google_search_api.rb to "app/apis"
+        in a Rails project
+
+    "Delegated" example:
+
+      * Copy delegated/search_controller.rb to "app/controllers"
+        in a Rails project.
+      * Copy delegated/google_search_service.rb to "lib"
+        in a Rails project.
+
+     "Autoloading" example:
+
+      * Copy autoloading/google_search_api.rb to "app/apis" (create the directory
+        if it doesn't exist) in a Rails project.
+
+      * Copy autoloading/google_search_controller.rb "app/controllers"
+        in a Rails project.
+  
+
+  2. Go to the WSDL url in a browser, and check that it looks correct.
+
+      "Direct" and "Delegated" examples:
+        http://url_to_project/search/wsdl
+
+      "Autoloading" example:
+        http://url_to_project/google_search/wsdl
+     
+     You can compare it to Google's hand-coded WSDL at http://api.google.com/GoogleSearch.wsdl
+     and see how close (or not) the generated version is. 
+     
+     Note that I used GoogleSearch as the canonical "best practice"
+     interoperable example when implementing WSDL/SOAP support, which might
+     explain extreme similarities :)
+
+
+  3. Test that it works with .NET (Mono in this example):
+
+        $ wget WSDL_URL
+        $ mv wsdl GoogleSearch.wsdl
+        $ wsdl -out:GoogleSearch.cs GoogleSearch.wsdl
+
+     Add these lines to the GoogleSearchService class body (be mindful of the 
+     wrapping):
+
+        public static void Main(string[] args)
+        {
+            GoogleSearchResult result;
+            GoogleSearchService service;
+        
+            service = new GoogleSearchService();
+            result = service.doGoogleSearch("myApiKey", "my query", 10, 30, true, "restrict", false, "lr", "ie", "oe");
+            System.Console.WriteLine("documentFiltering: {0}", result.documentFiltering);
+            System.Console.WriteLine("searchComments: {0}", result.searchComments);
+            System.Console.WriteLine("estimatedTotalResultsCount: {0}", result.estimatedTotalResultsCount);
+            System.Console.WriteLine("estimateIsExact: {0}", result.estimateIsExact);
+            System.Console.WriteLine("resultElements:");
+            foreach (ResultElement element in result.resultElements) {
+              System.Console.WriteLine("\tsummary: {0}", element.summary);
+              System.Console.WriteLine("\tURL: {0}", element.URL);
+              System.Console.WriteLine("\tsnippet: {0}", element.snippet);
+              System.Console.WriteLine("\ttitle: {0}", element.title);
+              System.Console.WriteLine("\tcachedSize: {0}", element.cachedSize);
+              System.Console.WriteLine("\trelatedInformationPresent: {0}", element.relatedInformationPresent);
+              System.Console.WriteLine("\thostName: {0}", element.hostName);
+              System.Console.WriteLine("\tdirectoryCategory: {0}", element.directoryCategory.fullViewableName);
+              System.Console.WriteLine("\tdirectoryTitle: {0}", element.directoryTitle);
+            }
+            System.Console.WriteLine("searchQuery: {0}", result.searchQuery);
+            System.Console.WriteLine("startIndex: {0}", result.startIndex);
+            System.Console.WriteLine("endIndex: {0}", result.endIndex);
+            System.Console.WriteLine("searchTips: {0}", result.searchTips);
+            System.Console.WriteLine("directoryCategories:");
+            foreach (DirectoryCategory cat in result.directoryCategories) {
+              System.Console.WriteLine("\t{0} ({1})", cat.fullViewableName, cat.specialEncoding);
+            }
+            System.Console.WriteLine("searchTime: {0}", result.searchTime);
+        }
+
+    Now compile and run:
+
+      $ mcs -reference:System.Web.Services GoogleSearch.cs
+      $ mono GoogleSearch.exe
+
+
+    If you had the application running (on the same host you got
+    the WSDL from), you should see something like this:
+
+
+        documentFiltering: True
+        searchComments:
+        estimatedTotalResultsCount: 322000
+        estimateIsExact: False
+        resultElements:
+                summary: ONlamp.com: Rolling with Ruby on Rails
+                URL: http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html
+                snippet: Curt Hibbs shows off Ruby on Rails by building a simple ...
+                title: Teh Railz0r
+                cachedSize: Almost no lines of code!
+                relatedInformationPresent: True
+                hostName: rubyonrails.com
+                directoryCategory: Web Development
+                directoryTitle:
+        searchQuery: http://www.google.com/search?q=ruby+on+rails
+        startIndex: 10
+        endIndex: 40
+        searchTips: "on" is a very common word and was not included in your search [details]
+        directoryCategories:
+                Web Development (UTF-8)
+                Programming (US-ASCII)
+        searchTime: 1E-06
+
+
+    Also, if an API method throws an exception, it will be sent back to the
+    caller in the protocol's exception format, so they should get an exception
+    thrown on their side with a meaningful error message.
+
+    If you don't like this behaviour, you can do:
+
+      class MyController < ActionController::Base
+        web_service_exception_reporting false
+      end
+
+  4. Crack open a beer. Publishing APIs for working with the same model as
+     your Rails web app should be easy from now on :)

data/examples/googlesearch/autoloading/google_search_api.rb

@@ -0,0 +1,50 @@
+class DirectoryCategory < ActionWebService::Struct
+  member :fullViewableName, :string
+  member :specialEncoding,  :string
+end
+
+class ResultElement < ActionWebService::Struct
+  member :summary,                   :string
+  member :URL,                       :string
+  member :snippet,                   :string
+  member :title,                     :string
+  member :cachedSize,                :string
+  member :relatedInformationPresent, :bool
+  member :hostName,                  :string
+  member :directoryCategory,         DirectoryCategory
+  member :directoryTitle,            :string
+end
+
+class GoogleSearchResult < ActionWebService::Struct
+  member :documentFiltering,          :bool
+  member :searchComments,             :string
+  member :estimatedTotalResultsCount, :int
+  member :estimateIsExact,            :bool
+  member :resultElements,             [ResultElement]
+  member :searchQuery,                :string
+  member :startIndex,                 :int
+  member :endIndex,                   :int
+  member :searchTips,                 :string
+  member :directoryCategories,        [DirectoryCategory]
+  member :searchTime,                 :float
+end
+
+class GoogleSearchAPI < ActionWebService::API::Base
+  inflect_names false
+
+  api_method :doGetCachedPage,         :returns => [:string], :expects => [{:key=>:string}, {:url=>:string}]
+  api_method :doGetSpellingSuggestion, :returns => [:string], :expects => [{:key=>:string}, {:phrase=>:string}]
+
+  api_method :doGoogleSearch, :returns => [GoogleSearchResult], :expects => [
+    {:key=>:string},
+    {:q=>:string},
+    {:start=>:int},
+    {:maxResults=>:int},
+    {:filter=>:bool},
+    {:restrict=>:string},
+    {:safeSearch=>:bool},
+    {:lr=>:string},
+    {:ie=>:string},
+    {:oe=>:string}
+  ]
+end

data/examples/googlesearch/autoloading/google_search_controller.rb

@@ -0,0 +1,57 @@
+class GoogleSearchController < ApplicationController
+  wsdl_service_name 'GoogleSearch'
+
+  def doGetCachedPage
+    "<html><body>i am a cached page. my key was %s, url was %s</body></html>" % [@params['key'], @params['url']]
+  end
+
+  def doSpellingSuggestion
+    "%s: Did you mean '%s'?" % [@params['key'], @params['phrase']]
+  end
+
+  def doGoogleSearch
+    resultElement = ResultElement.new
+    resultElement.summary = "ONlamp.com: Rolling with Ruby on Rails"
+    resultElement.URL = "http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html"
+    resultElement.snippet = "Curt Hibbs shows off Ruby on Rails by building a simple application that requires " +
+                            "almost no Ruby experience. ... Rolling with Ruby on Rails. ..."
+    resultElement.title = "Teh Railz0r"
+    resultElement.cachedSize = "Almost no lines of code!"
+    resultElement.relatedInformationPresent = true
+    resultElement.hostName = "rubyonrails.com"
+    resultElement.directoryCategory = category("Web Development", "UTF-8")
+
+    result = GoogleSearchResult.new
+    result.documentFiltering = @params['filter']
+    result.searchComments = ""
+    result.estimatedTotalResultsCount = 322000
+    result.estimateIsExact = false
+    result.resultElements = [resultElement]
+    result.searchQuery = "http://www.google.com/search?q=ruby+on+rails"
+    result.startIndex = @params['start']
+    result.endIndex = @params['start'] + @params['maxResults']
+    result.searchTips = "\"on\" is a very common word and was not included in your search [details]"
+    result.searchTime = 0.000001
+
+    # For Mono, we have to clone objects if they're referenced by more than one place, otherwise
+    # the Ruby SOAP collapses them into one instance and uses references all over the
+    # place, confusing Mono. 
+    #
+    # This has recently been fixed:
+    #   http://bugzilla.ximian.com/show_bug.cgi?id=72265
+    result.directoryCategories = [
+      category("Web Development", "UTF-8"),
+      category("Programming", "US-ASCII"),
+    ]
+
+    result
+  end
+
+  private
+    def category(name, encoding)
+      cat = DirectoryCategory.new
+      cat.fullViewableName = name.dup
+      cat.specialEncoding = encoding.dup
+      cat
+    end
+end