RubyGems - rq - Versions diffs - 3.4.0 → 3.5.0 - Mend

rq 3.4.0 → 3.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1063) hide show

data/rails/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/rails/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/rails/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/rails/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/rails/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/rails/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/rails/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/rails/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/rails/vendor/rails/actionwebservice/lib/action_web_service/api.rb DELETED

@@ -1,249 +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
-      # 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
-        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
-        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
-        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
-        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.
-        def api_methods
-          read_inheritable_attribute("api_methods") || {}
-        end
-        # The Method instance for the given public API method name, if any
-        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
-        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