RubyGems - backlog - Versions diffs - 0.0.4 → 0.0.5 - Mend

backlog 0.0.4 → 0.0.5

Files changed (170) hide show

data/vendor/rails/actionwebservice/examples/googlesearch/direct/search_controller.rb DELETED

@@ -1,58 +0,0 @@
-class SearchController < ApplicationController
-  web_service_api :google_search
-  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

data/vendor/rails/actionwebservice/examples/metaWeblog/README DELETED

@@ -1,17 +0,0 @@
-= metaWeblog example
-This example shows how one might begin to go about adding metaWeblog
-(http://www.xmlrpc.com/metaWeblogApi) API support to a Rails-based
-blogging application.
-The example APIs are more verbose than you may want to make them, for documentation
-reasons.
-= Running
-  1. Copy the "apis" directory and its files into "app" in a Rails project.
-  2. Copy the "controllers" directory and its files into "app" in a Rails project
-  3. Fire up a desktop blogging application (such as w.bloggar, MarsEdit, or BloGTK),
-     point it at http://localhost:3000/xmlrpc/api, and try creating or editing blog posts.

data/vendor/rails/actionwebservice/examples/metaWeblog/apis/blogger_api.rb DELETED

@@ -1,60 +0,0 @@
-#
-# see the blogger API spec at http://www.blogger.com/developers/api/1_docs/
-# note that the method signatures are subtly different to metaWeblog, they
-# are not identical. take care to ensure you handle the different semantics
-# properly if you want to support blogger API too, to get maximum compatibility.
-#
-module Blog
-  class Blog < ActionWebService::Struct
-    member :url,      :string
-    member :blogid,   :string
-    member :blogName, :string
-  end
-  class User < ActionWebService::Struct
-    member :nickname,  :string
-    member :userid,    :string
-    member :url,       :string
-    member :email,     :string
-    member :lastname,  :string
-    member :firstname, :string
-  end
-end
-#
-# blogger
-#
-class BloggerAPI < ActionWebService::API::Base
-  inflect_names false
-  api_method :newPost, :returns => [:string], :expects => [
-    {:appkey=>:string},
-    {:blogid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-    {:content=>:string},
-    {:publish=>:bool}
-  ]
-  api_method :editPost, :returns => [:bool], :expects => [
-    {:appkey=>:string},
-    {:postid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-    {:content=>:string},
-    {:publish=>:bool}
-  ]
-  api_method :getUsersBlogs, :returns => [[Blog::Blog]], :expects => [
-    {:appkey=>:string},
-    {:username=>:string},
-    {:password=>:string}
-  ]
-  api_method :getUserInfo, :returns => [Blog::User], :expects => [
-    {:appkey=>:string},
-    {:username=>:string},
-    {:password=>:string}
-  ]
-end

data/vendor/rails/actionwebservice/examples/metaWeblog/apis/blogger_service.rb DELETED

@@ -1,34 +0,0 @@
-require 'blogger_api'
-class BloggerService < ActionWebService::Base
-  web_service_api BloggerAPI
-  def initialize
-    @postid = 0
-  end
-  def newPost(key, id, user, pw, content, publish)
-    $stderr.puts "id=#{id} user=#{user} pw=#{pw}, content=#{content.inspect} [#{publish}]"
-    (@postid += 1).to_s
-  end
-  def editPost(key, post_id, user, pw, content, publish)
-    $stderr.puts "id=#{post_id} user=#{user} pw=#{pw} content=#{content.inspect} [#{publish}]"
-    true
-  end
-  def getUsersBlogs(key, user, pw)
-    $stderr.puts "getting blogs for #{user}"
-    blog = Blog::Blog.new(
-      :url =>'http://blog',
-      :blogid => 'myblog',
-      :blogName => 'My Blog'
-    )
-    [blog]
-  end
-  def getUserInfo(key, user, pw)
-    $stderr.puts "getting user info for #{user}"
-    Blog::User.new(:nickname => 'user', :email => 'user@test.com')
-  end
-end

data/vendor/rails/actionwebservice/examples/metaWeblog/apis/meta_weblog_api.rb DELETED

@@ -1,67 +0,0 @@
-#
-# here lie structures, cousins of those on http://www.xmlrpc.com/metaWeblog
-# but they don't necessarily the real world reflect
-# so if you do, find that your client complains:
-# please tell, of problems you suffered through
-#
-module Blog
-  class Post < ActionWebService::Struct
-    member :title,       :string
-    member :link,        :string
-    member :description, :string
-    member :author,      :string
-    member :category,    :string
-    member :comments,    :string
-    member :guid,        :string
-    member :pubDate,     :string
-  end
-  class Category < ActionWebService::Struct
-    member :description, :string
-    member :htmlUrl,     :string
-    member :rssUrl,      :string
-  end
-end
-#
-# metaWeblog
-#
-class MetaWeblogAPI < ActionWebService::API::Base
-  inflect_names false
-  api_method :newPost, :returns => [:string], :expects => [
-    {:blogid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-    {:struct=>Blog::Post},
-    {:publish=>:bool}
-  ]
-  api_method :editPost, :returns => [:bool], :expects => [
-    {:postid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-    {:struct=>Blog::Post},
-    {:publish=>:bool},
-  ]
-  api_method :getPost, :returns => [Blog::Post], :expects => [
-    {:postid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-  ]
-  api_method :getCategories, :returns => [[Blog::Category]], :expects => [
-    {:blogid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-  ]
-  api_method :getRecentPosts, :returns => [[Blog::Post]], :expects => [
-    {:blogid=>:string},
-    {:username=>:string},
-    {:password=>:string},
-    {:numberOfPosts=>:int},
-  ]
-end

data/vendor/rails/actionwebservice/examples/metaWeblog/apis/meta_weblog_service.rb DELETED

@@ -1,48 +0,0 @@
-require 'meta_weblog_api'
-class MetaWeblogService < ActionWebService::Base
-  web_service_api MetaWeblogAPI
-  def initialize
-    @postid = 0
-  end
-  def newPost(id, user, pw, struct, publish)
-    $stderr.puts "id=#{id} user=#{user} pw=#{pw}, struct=#{struct.inspect} [#{publish}]"
-    (@postid += 1).to_s
-  end
-  def editPost(post_id, user, pw, struct, publish)
-    $stderr.puts "id=#{post_id} user=#{user} pw=#{pw} struct=#{struct.inspect} [#{publish}]"
-    true
-  end
-  def getPost(post_id, user, pw)
-    $stderr.puts "get post #{post_id}"
-    Blog::Post.new(:title => 'hello world', :description => 'first post!')
-  end
-  def getCategories(id, user, pw)
-    $stderr.puts "categories for #{user}"
-    cat = Blog::Category.new(
-      :description => 'Tech',
-      :htmlUrl     => 'http://blog/tech',
-      :rssUrl      => 'http://blog/tech.rss')
-    [cat]
-  end
-  def getRecentPosts(id, user, pw, num)
-    $stderr.puts "recent #{num} posts for #{user} on blog #{id}"
-    post1 = Blog::Post.new(
-      :title => 'first post!',
-      :link => 'http://blog.xeraph.org/testOne.html',
-      :description => 'this is the first post'
-    )
-    post2 = Blog::Post.new(
-      :title => 'second post!',
-      :link => 'http://blog.xeraph.org/testTwo.html',
-      :description => 'this is the second post'
-    )
-    [post1, post2]
-  end
-end

data/vendor/rails/actionwebservice/examples/metaWeblog/controllers/xmlrpc_controller.rb DELETED

@@ -1,16 +0,0 @@
-#
-# example controller implementing both blogger and metaWeblog APIs
-# in a way that should be compatible with clients supporting both/either.
-#
-# test by pointing your client at http://URL/xmlrpc/api
-#
-require 'meta_weblog_service'
-require 'blogger_service'
-class XmlrpcController < ApplicationController
-  web_service_dispatching_mode :layered
-  web_service :metaWeblog, MetaWeblogService.new
-  web_service :blogger, BloggerService.new
-end

data/vendor/rails/actionwebservice/install.rb DELETED

@@ -1,30 +0,0 @@
-require 'rbconfig'
-require 'find'
-require 'ftools'
-include Config
-# this was adapted from rdoc's install.rb by way of Log4r
-$sitedir = CONFIG["sitelibdir"]
-unless $sitedir
-  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
-  $libdir = File.join(CONFIG["libdir"], "ruby", version)
-  $sitedir = $:.find {|x| x =~ /site_ruby/ }
-  if !$sitedir
-    $sitedir = File.join($libdir, "site_ruby")
-  elsif $sitedir !~ Regexp.quote(version)
-    $sitedir = File.join($sitedir, version)
-  end
-end
-# the acual gruntwork
-Dir.chdir("lib")
-Find.find("action_web_service", "action_web_service.rb") { |f|
-  if f[-3..-1] == ".rb"
-    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
-  else
-    File::makedirs(File.join($sitedir, *f.split(/\//)))
-  end
-}

data/vendor/rails/actionwebservice/lib/action_web_service.rb DELETED

@@ -1,66 +0,0 @@
-#--
-# Copyright (C) 2005 Leon Breedt
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-begin
-  require 'active_support'
-  require 'action_controller'
-  require 'active_record'
-rescue LoadError
-  require 'rubygems'
-  gem 'activesupport', '>= 1.0.2'
-  gem 'actionpack', '>= 1.6.0'
-  gem 'activerecord', '>= 1.9.0'
-end
-$:.unshift(File.dirname(__FILE__) + "/action_web_service/vendor/")
-require 'action_web_service/support/class_inheritable_options'
-require 'action_web_service/support/signature_types'
-require 'action_web_service/base'
-require 'action_web_service/client'
-require 'action_web_service/invocation'
-require 'action_web_service/api'
-require 'action_web_service/casting'
-require 'action_web_service/struct'
-require 'action_web_service/container'
-require 'action_web_service/protocol'
-require 'action_web_service/dispatcher'
-require 'action_web_service/scaffolding'
-ActionWebService::Base.class_eval do
-  include ActionWebService::Container::Direct
-  include ActionWebService::Invocation
-end
-ActionController::Base.class_eval do
-  include ActionWebService::Protocol::Discovery
-  include ActionWebService::Protocol::Soap
-  include ActionWebService::Protocol::XmlRpc
-  include ActionWebService::Container::Direct
-  include ActionWebService::Container::Delegated
-  include ActionWebService::Container::ActionController
-  include ActionWebService::Invocation
-  include ActionWebService::Dispatcher
-  include ActionWebService::Dispatcher::ActionController
-  include ActionWebService::Scaffolding
-end

data/vendor/rails/actionwebservice/lib/action_web_service/api.rb DELETED

@@ -1,301 +0,0 @@
-module ActionWebService # :nodoc:
-  module API # :nodoc:
-    # A web service API class specifies the methods that will be available for
-    # invocation for an API. It also contains metadata such as the method type
-    # signature hints.
-    #
-    # It is not intended to be instantiated.
-    #
-    # It is attached to web service implementation classes like
-    # ActionWebService::Base and ActionController::Base derivatives by using
-    # <tt>container.web_service_api</tt>, where <tt>container</tt> is an
-    # ActionController::Base or a ActionWebService::Base.
-    #
-    # See ActionWebService::Container::Direct::ClassMethods for an example
-    # of use.
-    class Base
-      # Action WebService API subclasses should be reloaded by the dispatcher in Rails
-      # when Dependencies.mechanism = :load.
-      include Reloadable::Deprecated
-      # Whether to transform the public API method names into camel-cased names
-      class_inheritable_option :inflect_names, true
-      # By default only HTTP POST requests are processed
-      class_inheritable_option :allowed_http_methods, [ :post ]
-      # Whether to allow ActiveRecord::Base models in <tt>:expects</tt>.
-      # The default is +false+; you should be aware of the security implications
-      # of allowing this, and ensure that you don't allow remote callers to
-      # easily overwrite data they should not have access to.
-      class_inheritable_option :allow_active_record_expects, false
-      # If present, the name of a method to call when the remote caller
-      # tried to call a nonexistent method. Semantically equivalent to
-      # +method_missing+.
-      class_inheritable_option :default_api_method
-      # Disallow instantiation
-      private_class_method :new, :allocate
-      class << self
-        include ActionWebService::SignatureTypes
-        # API methods have a +name+, which must be the Ruby method name to use when
-        # performing the invocation on the web service object.
-        #
-        # The signatures for the method input parameters and return value can
-        # by specified in +options+.
-        #
-        # A signature is an array of one or more parameter specifiers.
-        # A parameter specifier can be one of the following:
-        #
-        # * A symbol or string representing one of the Action Web Service base types.
-        #   See ActionWebService::SignatureTypes for a canonical list of the base types.
-        # * The Class object of the parameter type
-        # * A single-element Array containing one of the two preceding items. This
-        #   will cause Action Web Service to treat the parameter at that position
-        #   as an array containing only values of the given type.
-        # * A Hash containing as key the name of the parameter, and as value
-        #   one of the three preceding items
-        #
-        # If no method input parameter or method return value signatures are given,
-        # the method is assumed to take no parameters and/or return no values of
-        # interest, and any values that are received by the server will be
-        # discarded and ignored.
-        #
-        # Valid options:
-        # [<tt>:expects</tt>]             Signature for the method input parameters
-        # [<tt>:returns</tt>]             Signature for the method return value
-        # [<tt>:expects_and_returns</tt>] Signature for both input parameters and return value
-        def api_method(name, options={})
-          unless options.is_a?(Hash)
-            raise(ActionWebServiceError, "Expected a Hash for options")
-          end
-          validate_options([:expects, :returns, :expects_and_returns], options.keys)
-          if options[:expects_and_returns]
-            expects = options[:expects_and_returns]
-            returns = options[:expects_and_returns]
-          else
-            expects = options[:expects]
-            returns = options[:returns]
-          end
-          expects = canonical_signature(expects)
-          returns = canonical_signature(returns)
-          if expects
-            expects.each do |type|
-              type = type.element_type if type.is_a?(ArrayType)
-              if type.type_class.ancestors.include?(ActiveRecord::Base) && !allow_active_record_expects
-                raise(ActionWebServiceError, "ActiveRecord model classes not allowed in :expects")
-              end
-            end
-          end
-          name = name.to_sym
-          public_name = public_api_method_name(name)
-          method = Method.new(name, public_name, expects, returns)
-          write_inheritable_hash("api_methods", name => method)
-          write_inheritable_hash("api_public_method_names", public_name => name)
-        end
-        # Whether the given method name is a service method on this API
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.has_api_method?('GetCount')   #=> false
-        #   ProjectsApi.has_api_method?(:getCount)    #=> true
-        def has_api_method?(name)
-          api_methods.has_key?(name)
-        end
-        # Whether the given public method name has a corresponding service method
-        # on this API
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.has_api_method?(:getCount)    #=> false
-        #   ProjectsApi.has_api_method?('GetCount')   #=> true
-        def has_public_api_method?(public_name)
-          api_public_method_names.has_key?(public_name)
-        end
-        # The corresponding public method name for the given service method name
-        #
-        #   ProjectsApi.public_api_method_name('GetCount')  #=> "GetCount"
-        #   ProjectsApi.public_api_method_name(:getCount)   #=> "GetCount"
-        def public_api_method_name(name)
-          if inflect_names
-            name.to_s.camelize
-          else
-            name.to_s
-          end
-        end
-        # The corresponding service method name for the given public method name
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.api_method_name('GetCount') #=> :getCount
-        def api_method_name(public_name)
-          api_public_method_names[public_name]
-        end
-        # A Hash containing all service methods on this API, and their
-        # associated metadata.
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount,          :returns => [:int]
-        #     api_method :getCompletedCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.api_methods #=>
-        #     {:getCount=>#<ActionWebService::API::Method:0x24379d8 ...>,
-        #      :getCompletedCount=>#<ActionWebService::API::Method:0x2437794 ...>}
-        #   ProjectsApi.api_methods[:getCount].public_name #=> "GetCount"
-        def api_methods
-          read_inheritable_attribute("api_methods") || {}
-        end
-        # The Method instance for the given public API method name, if any
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount,          :returns => [:int]
-        #     api_method :getCompletedCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.public_api_method_instance('GetCount')  #=> <#<ActionWebService::API::Method:0x24379d8 ...>
-        #   ProjectsApi.public_api_method_instance(:getCount)   #=> nil
-        def public_api_method_instance(public_method_name)
-          api_method_instance(api_method_name(public_method_name))
-        end
-        # The Method instance for the given API method name, if any
-        #
-        #   class ProjectsApi < ActionWebService::API::Base
-        #     api_method :getCount,          :returns => [:int]
-        #     api_method :getCompletedCount, :returns => [:int]
-        #   end
-        #
-        #   ProjectsApi.api_method_instance(:getCount) #=> <ActionWebService::API::Method:0x24379d8 ...>
-        #   ProjectsApi.api_method_instance('GetCount') #=> <ActionWebService::API::Method:0x24379d8 ...>
-        def api_method_instance(method_name)
-          api_methods[method_name]
-        end
-        # The Method instance for the default API method, if any
-        def default_api_method_instance
-          return nil unless name = default_api_method
-          instance = read_inheritable_attribute("default_api_method_instance")
-          if instance && instance.name == name
-            return instance
-          end
-          instance = Method.new(name, public_api_method_name(name), nil, nil)
-          write_inheritable_attribute("default_api_method_instance", instance)
-          instance
-        end
-        private
-          def api_public_method_names
-            read_inheritable_attribute("api_public_method_names") || {}
-          end
-          def validate_options(valid_option_keys, supplied_option_keys)
-            unknown_option_keys = supplied_option_keys - valid_option_keys
-            unless unknown_option_keys.empty?
-              raise(ActionWebServiceError, "Unknown options: #{unknown_option_keys}")
-            end
-          end
-      end
-    end
-    # Represents an API method and its associated metadata, and provides functionality
-    # to assist in commonly performed API method tasks.
-    class Method
-      attr :name
-      attr :public_name
-      attr :expects
-      attr :returns
-      def initialize(name, public_name, expects, returns)
-        @name = name
-        @public_name = public_name
-        @expects = expects
-        @returns = returns
-        @caster = ActionWebService::Casting::BaseCaster.new(self)
-      end
-      # The list of parameter names for this method
-      def param_names
-        return [] unless @expects
-        @expects.map{ |type| type.name }
-      end
-      # Casts a set of Ruby values into the expected Ruby values
-      def cast_expects(params)
-        @caster.cast_expects(params)
-      end
-      # Cast a Ruby return value into the expected Ruby value
-      def cast_returns(return_value)
-        @caster.cast_returns(return_value)
-      end
-      # Returns the index of the first expected parameter
-      # with the given name
-      def expects_index_of(param_name)
-        return -1 if @expects.nil?
-        (0..(@expects.length-1)).each do |i|
-          return i if @expects[i].name.to_s == param_name.to_s
-        end
-        -1
-      end
-      # Returns a hash keyed by parameter name for the given
-      # parameter list
-      def expects_to_hash(params)
-        return {} if @expects.nil?
-        h = {}
-        @expects.zip(params){ |type, param| h[type.name] = param }
-        h
-      end
-      # Backwards compatibility with previous API
-      def [](sig_type)
-        case sig_type
-        when :expects
-          @expects.map{|x| compat_signature_entry(x)}
-        when :returns
-          @returns.map{|x| compat_signature_entry(x)}
-        end
-      end
-      # String representation of this method
-      def to_s
-        fqn = ""
-        fqn << (@returns ? (@returns[0].human_name(false) + " ") : "void ")
-        fqn << "#{@public_name}("
-        fqn << @expects.map{ |p| p.human_name }.join(", ") if @expects
-        fqn << ")"
-        fqn
-      end
-      private
-        def compat_signature_entry(entry)
-          if entry.array?
-            [compat_signature_entry(entry.element_type)]
-          else
-            if entry.spec.is_a?(Hash)
-              {entry.spec.keys.first => entry.type_class}
-            else
-              entry.type_class
-            end
-          end
-        end
-    end
-  end
-end