wrest 4.0.0-universal-java-18

data/lib/wrest/uri.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+# Copyright 2009 Sidu Ponnappa
+
+# 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.
+
+module Wrest # :nodoc:
+  # Wrest::Uri provides a simple api for
+  # REST calls. String#to_uri is a convenience
+  # method to build a Wrest::Uri from a string url.
+  # Note that a Wrest::Uri is immutable.
+  #
+  # Basic HTTP Authentication is supported.
+  # Example:
+  #  "http://kaiwren:fupuppies@coathangers.com/portal/1".to_uri
+  #  "http://coathangers.com/portal/1".to_uri(:username => 'kaiwren', :password => 'fupuppies')
+  #
+  # The second form is preferred as it can handle passwords with special characters like ^ and @
+  #
+  # You can find examples that use real APIs (like delicious) under the wrest/examples directory.
+  class Uri
+    attr_reader :uri, :username, :password, :uri_string, :uri_path, :query, :default_headers
+
+    # Valid tuples for the options are:
+    #   :asynchronous_backend => Can currently be set to either Wrest::AsyncRequest::EventMachineBackend.new
+    #                            or Wrest::AsyncRequest::ThreadBackend.new. Easier to do using Uri#using_em and
+    #                            Uri#using_threads.
+    #   :callback             => Accepts a hash where the keys are response codes or ranges of response codes and
+    #                            the values are the corresponding blocks that will be invoked should the response
+    #                            code match the key.
+    #   :default_headers      => Accepts a hash containing a set of default request headers with which the headers
+    #                            passed to Uri#get, Uri#post etc. are merged. Incoming headers will override the
+    #                            defaults if there are any clashes. Use this to set cookies or use OAuth2 Authorize
+    #                            headers. When extending or cloning a Uri, passing in a new set of default_headers
+    #                            will result in the old set being overridden.
+    #   :username, :password  => HTTP authentication. Passing nil for either username or password will skip it.
+    # See Wrest::Native::Request for other available options and their default values.
+    def initialize(uri_string, options = {})
+      @options = options.clone
+      setup_uri_state!(uri_string)
+      setup_request_config!
+    end
+
+    # Builds a Wrest::UriTemplate by extending the current URI
+    # with the pattern passed to it.
+    def to_template(pattern)
+      template_pattern = URI.join(uri_string, pattern).to_s
+      UriTemplate.new(template_pattern, @options)
+    end
+
+    # Build a new Wrest::Uri by appending _path_ to
+    # the current uri. If the original Wrest::Uri
+    # has a username and password, that will be
+    # copied to the new Wrest::Uri as well.
+    #
+    # Example:
+    #  uri = "https://localhost:3000/v1".to_uri
+    #  uri['/oogas/1'].get
+    #
+    # To change the username and password on the new
+    # instance, simply pass them as an options map.
+    #
+    # Example:
+    #  uri = "https://localhost:3000/v1".to_uri(:username => 'foo', :password => 'bar')
+    #  uri['/oogas/1', {:username => 'meh', :password => 'baz'}].get
+    def [](path, options = nil)
+      Uri.new(uri + File.join(uri_path, path), options || @options)
+    end
+
+    # Clones a Uri, building a new instance with exactly the same uri string.
+    # You can however change the Uri options or add new ones.
+    def clone(opts = {})
+      merged_options = @options.merge(opts)
+      merged_options[:default_headers] = opts[:default_headers] ? @default_headers.merge(opts[:default_headers]) : {}
+      Uri.new(@uri_string, merged_options)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return false if other.class != self.class
+
+      other.uri == uri && username == other.username && password == other.password
+    end
+
+    def hash
+      [@uri, @username, @password].hash
+    end
+
+    # This produces exactly the same string as the Wrest::Uri was constructed with.
+    # If the orignial URI contained a HTTP username and password, that too will
+    # show up, so be careful if using this for logging.
+    def to_s
+      uri_string
+    end
+
+    # :nodoc:
+    def build_get(parameters = {}, headers = {}, &block)
+      Http::Get.new(self, parameters, default_headers.merge(headers),
+                    block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # :nodoc:
+    def build_put(body = '', headers = {}, parameters = {}, &block)
+      Http::Put.new(self, body.to_s, default_headers.merge(headers), parameters,
+                    block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # :nodoc:
+    def build_patch(body = '', headers = {}, parameters = {}, &block)
+      Http::Patch.new(self, body.to_s, default_headers.merge(headers), parameters,
+                      block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # :nodoc:
+    def build_post(body = '', headers = {}, parameters = {}, &block)
+      Http::Post.new(self, body.to_s, default_headers.merge(headers), parameters,
+                     block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # :nodoc:
+    def build_post_form(parameters = {}, headers = {}, &block)
+      headers = default_headers.merge(headers).merge(Wrest::H::ContentType => Wrest::T::FormEncoded)
+      body = Utils.hash_to_param(parameters)
+      Http::Post.new(self, body, headers, {}, block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # :nodoc:
+    def build_delete(parameters = {}, headers = {}, &block)
+      Http::Delete.new(self, parameters, default_headers.merge(headers),
+                       block ? @options.merge(callback_block: block) : @options)
+    end
+
+    # Make a GET request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Get, executes it and returns a Wrest::Native::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def get(parameters = {}, headers = {}, &block)
+      build_get(parameters, headers, &block).invoke
+    end
+
+    # Make a GET request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Get.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    #
+    # Note: get_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous get is currently in alpha. Hence, it should not be used in production.
+    def get_async(parameters = {}, headers = {}, &block)
+      @asynchronous_backend.execute(build_get(parameters, headers, &block))
+    end
+
+    # Make a PUT request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Put, executes it and returns a Wrest::Native::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def put(body = '', headers = {}, parameters = {}, &block)
+      build_put(body, headers, parameters, &block).invoke
+    end
+
+    # Make a PUT request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Put.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    #
+    # Note: put_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous put is currently in alpha. Hence, it should not be used in production.
+    def put_async(body = '', headers = {}, parameters = {}, &block)
+      @asynchronous_backend.execute(build_put(body, headers, parameters, &block))
+    end
+
+    # Make a PATCH request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Patch, executes it and returns a Wrest::Native::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def patch(body = '', headers = {}, parameters = {}, &block)
+      build_patch(body, headers, parameters, &block).invoke
+    end
+
+    # Make a PATCH request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Patch.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    #
+    # Note: patch_async does not return a response and the response should be accessed through callbacks.
+    def patch_async(body = '', headers = {}, parameters = {}, &block)
+      @asynchronous_backend.execute(build_patch(body, headers, parameters, &block))
+    end
+
+    # Makes a POST request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Post, executes it and returns a Wrest::Native::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def post(body = '', headers = {}, parameters = {}, &block)
+      build_post(body, headers, parameters, &block).invoke
+    end
+
+    # Makes a POST request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Post.
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    #
+    # Note: post_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous post is currently in alpha. Hence, it should not be used in production.
+    def post_async(body = '', headers = {}, parameters = {}, &block)
+      @asynchronous_backend.execute(build_post(body, headers, parameters, &block))
+    end
+
+    # Makes a POST request to this URI. This is a convenience API
+    # that mimics a form being posted; some allegly RESTful APIs like FCBK require
+    # this.
+    #
+    # Form encoding involves munging the parameters into a string and placing them
+    # in the body, as well as setting the Content-Type header to
+    # application/x-www-form-urlencoded
+    def post_form(parameters = {}, headers = {}, &block)
+      build_post_form(parameters, headers, &block).invoke
+    end
+
+    # Makes a POST request to this URI. This is a convenience API
+    # that mimics a form being posted; some allegly RESTful APIs like FCBK require
+    # this.
+    #
+    # Form encoding involves munging the parameters into a string and placing them
+    # in the body, as well as setting the Content-Type header to
+    # application/x-www-form-urlencoded
+    #
+    # Note: post_form_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous post_form is currently in alpha. Hence, it should not be used in production.
+    def post_form_async(parameters = {}, headers = {}, &block)
+      @asynchronous_backend.execute(build_post_form(parameters, headers, &block))
+    end
+
+    # Makes a DELETE request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Delete, executes it and returns a Wrest::Native::Response.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    def delete(parameters = {}, headers = {}, &block)
+      build_delete(parameters, headers, &block).invoke
+    end
+
+    # Makes a DELETE request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Delete.
+    #
+    # Remember to escape all parameter strings if necessary, using URI.escape
+    #
+    # Note: delete_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous delete is currently in alpha. Hence, it should not be used in production.
+    def delete_async(parameters = {}, headers = {}, &block)
+      @asynchronous_backend.execute(build_delete(parameters, headers, &block))
+    end
+
+    # Makes an OPTIONS request to this URI. This is a convenience API
+    # that creates a Wrest::Native::Options, executes it and returns the Wrest::Native::Response.
+    def options
+      Http::Options.new(self, @options).invoke
+    end
+
+    def https?
+      @uri.is_a?(URI::HTTPS)
+    end
+
+    # Provides the full path of a request.
+    # For example, for
+    #  http://localhost:3000/demons/1/chi?sort=true
+    # this would return
+    #  /demons/1/chi?sort=true
+    def full_path
+      uri.request_uri
+    end
+
+    def protocol
+      uri.scheme
+    end
+
+    def host
+      uri.host
+    end
+
+    def port
+      uri.port
+    end
+
+    include Http::ConnectionFactory
+    include Uri::Builders
+
+    private
+
+    def setup_request_config!
+      @username = (@options[:username] ||= @uri.user)
+      @password = (@options[:password] ||= @uri.password)
+      @asynchronous_backend = @options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend
+      @options[:callback] = Callback.new(@options[:callback]) if @options[:callback]
+      @default_headers = @options[:default_headers] || {}
+    end
+
+    def setup_uri_state!(uri_string)
+      @uri_string = uri_string.to_s
+      @uri = URI.parse(@uri_string)
+      uri_scheme = URI.split(@uri_string)
+      @uri_path = uri_scheme[-4].split('?').first || ''
+      @uri_path = (@uri_path.empty? ? '/' : @uri_path)
+      @query = uri_scheme[-2] || ''
+    end
+  end
+end

data/lib/wrest/uri_template.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Copyright 2009 Sidu Ponnappa
+
+# 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.
+
+module Wrest
+  class UriTemplate
+    attr_reader :uri_pattern
+
+    def initialize(uri_pattern, options = {})
+      @uri_pattern = uri_pattern.clone
+      @options = options.clone
+    end
+
+    # Builds a new Wrest::Uri from this uri template
+    # by replacing the keys in the options that match with
+    # the corressponding values.
+    #
+    # Example:
+    # template = UriTemplate.new("http://coathangers.com/:resource/:id.:format")
+    # template.to_uri(:resource => 'shen_coins', :id => 5, :format => :json)
+    # => #<Wrest::Uri:0x1225514 @uri=#<URI::HTTP:0x9127d8 URL:http://localhost:3000/shen_coins/5.json>>
+    #
+    # This feature can also be used to handle HTTP authentication where the username
+    # and password needs changing at runtime. However, this approach _will_ fail if
+    # the password contains characters like ^ and @.
+    #
+    # Note that beacuse because both HTTP Auth and UriTemplate
+    # use ':' as a delimiter, the pattern does look slightly weird, but it still works.
+    # Example:
+    # template = UriTemplate.new("http://:username::password@coathangers.com/:resource/:id.:format")
+    # template.to_uri(
+    #  :user => 'kaiwren',
+    #  :password => 'fupuppies',
+    #  :resource => 'portal',
+    #  :id => '1'
+    # )
+    #  => #<Wrest::Uri:0x18e0bec @uri=#<URI::HTTP:0x18e09a8 URL:http://kaiwren:fupuppies@coathangers.com/portal/1>>
+    def to_uri(options = {})
+      merged_options = @options.merge(options)
+      Wrest::Uri.new(merged_options.inject(uri_pattern.clone) do |uri_string, tuple|
+        key, value = tuple
+        uri_string.gsub(":#{key}", value.to_s)
+      end, @options)
+    end
+
+    def [](path)
+      UriTemplate.new(File.join(uri_pattern, path))
+    end
+
+    def ==(other)
+      return false if other.class != self.class
+
+      other.uri_pattern == uri_pattern
+    end
+  end
+end

data/lib/wrest/utils.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Wrest
+  module Utils
+    module_function
+
+    # https://github.com/rails/rails/commit/2a371368c91789a4d689d6a84eb20b238c37678a
+    # A string is blank if it's empty or contains whitespaces only:
+    #
+    #   "".blank?                 # => true
+    #   "   ".blank?              # => true
+    #   "　".blank?               # => true
+    #   " something here ".blank? # => false
+    #
+    def string_blank?(string)
+      string !~ /[^[:space:]]/
+    end
+
+    # https://github.com/rails/rails/commit/69b550fc88f0e155ab997476e576142a2dbec324
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   constantize('Module')   # => Module
+    #   constantize('Foo::Bar') # => Foo::Bar
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C                # => 'inside'
+    #     constantize('C') # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def string_constantize(camel_cased_word)
+      Object.const_get(camel_cased_word)
+    end
+
+    # https://github.com/rails/rails/commit/69b550fc88f0e155ab997476e576142a2dbec324
+    # Removes the module part from the expression in the string.
+    #
+    #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+    #   demodulize('Inflections')                           # => "Inflections"
+    #   demodulize('::Inflections')                         # => "Inflections"
+    #   demodulize('')                                      # => ""
+    #
+    def string_demodulize(path)
+      path = path.to_s
+      if (i = path.rindex('::'))
+        path[(i + 2)..]
+      else
+        path
+      end
+    end
+
+    # https://github.com/rails/rails/commit/69b550fc88f0e155ab997476e576142a2dbec324
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   underscore('ActiveModel')         # => "active_model"
+    #   underscore('ActiveModel::Errors') # => "active_model/errors"
+    #
+    # As a rule of thumb you can think of +underscore+ as the inverse of
+    # #camelize, though there are cases where that does not hold:
+    #
+    #   camelize(underscore('SSLError'))  # => "SslError"
+    def string_underscore(camel_cased_word)
+      return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+
+      word = camel_cased_word.to_s.gsub('::', '/')
+      word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { (Regexp.last_match(1) || Regexp.last_match(2)) << '_' }
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+
+    # https://github.com/rails/rails/commit/a0d7247d1509762283c61182ad82c2eed8d54757
+    # Returns a string representation of the receiver suitable for use as a URL
+    # query string:
+    #
+    #   {:name => 'David', :nationality => 'Danish'}.to_param
+    #   # => "name=David&nationality=Danish"
+    #
+    # The string pairs "key=value" that conform the query string
+    # are sorted lexicographically in ascending order.
+    #
+    def hash_to_param(hash)
+      hash.collect do |key, value|
+        object_to_query(key, value)
+      end.sort * '&'
+    end
+
+    # https://github.com/rails/rails/commit/52b71c01fd3c8a87152f55129a8cb3234190734a
+    #
+    # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+    # param name.
+    def object_to_query(key, object)
+      "#{CGI.escape(key.to_s)}=#{CGI.escape(object.to_s)}"
+    end
+
+    # https://github.com/rails/rails/commit/18707ab17fa492eb25ad2e8f9818a320dc20b823
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
+    #
+    # This simplifies
+    #
+    #   !address || address.empty?
+    #
+    # to
+    #
+    #   address.blank?
+    #
+    # @return [true, false]
+    def object_blank?(object)
+      object.respond_to?(:empty?) ? !!object.empty? : !object
+    end
+
+    # https://github.com/rails/rails/commit/6372d23616b13c62c7a12efa89f958b334dd66ae
+    # Converts self to an integer number of seconds since the Unix epoch.
+    def datetime_to_i(datetime)
+      seconds_per_day = 86_400
+      ((datetime - ::DateTime.civil(1970)) * seconds_per_day).to_i
+    end
+  end
+end

data/lib/wrest/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Copyright 2009-2011 Sidu Ponnappa
+
+# 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.
+
+module Wrest
+  VERSION = '4.0.0'
+end

data/lib/wrest.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Copyright 2009 Sidu Ponnappa
+# 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.
+
+require 'net/http'
+require 'net/https'
+require 'forwardable'
+require 'date'
+require 'cgi'
+require 'base64'
+require 'logger'
+require 'benchmark'
+require 'concurrent'
+require 'nokogiri'
+require 'json'
+
+module Wrest
+  Root = File.dirname(__FILE__)
+
+  $LOAD_PATH.unshift Root
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.enable_evented_requests!
+    require 'wrest/event_machine_backend'
+  end
+
+  # Switch Wrest to using Net::HTTP.
+  def self.use_native!
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    Wrest.const_set('Http', Wrest::Native)
+  ensure
+    $VERBOSE = old_verbose
+  end
+end
+
+Wrest.logger = Logger.new($stdout)
+Wrest.logger.level = Logger::DEBUG
+
+require 'wrest/utils'
+require 'wrest/core_ext/string'
+require 'wrest/hash_with_indifferent_access'
+require 'wrest/hash_with_case_insensitive_access'
+
+# Load Wrest Core
+require 'wrest/version'
+require 'wrest/cache_proxy'
+require 'wrest/http_shared'
+require 'wrest/http_codes'
+require 'wrest/callback'
+require 'wrest/native'
+
+require 'wrest/async_request/thread_pool'
+require 'wrest/async_request/thread_backend'
+require 'wrest/async_request'
+
+require 'wrest/caching'
+
+# Load Wrest Wrappers
+require 'wrest/uri/builders'
+require 'wrest/uri'
+require 'wrest/uri_template'
+require 'wrest/exceptions'
+require 'wrest/components'

data/lib/wrest_no_ext.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Opts out of including Wrest's String Extensions
+module Wrest
+  NoStringExtensions = true
+end
+require 'wrest'