wrest 4.0.0-universal-java-18

data/lib/wrest/async_request/thread_backend.rb

@@ -0,0 +1,34 @@
+# 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 native://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
+  module AsyncRequest
+    # Uses a pool of Threads to make requests.
+    # Only recommended for production use on JRuby.
+    class ThreadBackend
+      attr_reader :thread_pool
+
+      def initialize(number_of_threads = 5)
+        @thread_pool = ThreadPool.new(number_of_threads)
+      end
+
+      def execute(request)
+        @thread_pool.execute_eventually(request)
+      end
+
+      # Uses Thread#join to wait until all
+      # background requests are completed.
+      def wait_for_thread_pool!
+        @thread_pool.join_pool_threads!
+      end
+    end
+  end
+end

data/lib/wrest/async_request/thread_pool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copyright 2009-2016 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 native://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
+  module AsyncRequest
+    class ThreadPool
+      def initialize(number_of_threads)
+        @pool = Concurrent::FixedThreadPool.new(number_of_threads)
+      end
+
+      def execute_eventually(request)
+        @pool.post { request.invoke }
+        nil
+      end
+
+      def join_pool_threads!
+        @pool.wait_for_termination
+      end
+    end
+  end
+end

data/lib/wrest/async_request.rb

@@ -0,0 +1,51 @@
+# 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 native://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
+  module AsyncRequest
+    # Loads Wrest eventmachine backend alongwith eventmachine gem
+    def self.enable_em
+      require 'wrest/async_request/event_machine_backend'
+    end
+
+    # Assign default backend to be used for asynchronous request. Default is to use threads
+    def self.default_backend=(backend)
+      @default_backend = backend
+    end
+
+    # Assign default backend for asynchronous request to using eventmachine.
+    def self.default_to_em!
+      enable_em
+      self.default_backend = Wrest::AsyncRequest::EventMachineBackend.new
+    end
+
+    # Assign default backend for asynchronous request to using threads.
+    def self.default_to_threads!(number_of_threads = 5)
+      self.default_backend = Wrest::AsyncRequest::ThreadBackend.new(number_of_threads)
+    end
+
+    # Returns the default backend, which is the ThreadBackend
+    def self.default_backend
+      @default_backend || default_to_threads!
+    end
+
+    # Uses Thread#join to wait until all background requests
+    # are completed.
+    #
+    # Use this as the last instruction in a script to prevent it from
+    # exiting before background threads have completed running.
+    #
+    # Needs Wrest.default_backend to be an instance of ThreadBackend.
+    def self.wait_for_thread_pool!
+      default_backend.wait_for_thread_pool!
+    end
+  end
+end

data/lib/wrest/cache_proxy.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Wrest
+  class CacheProxy
+    class << self
+      def new(get, cache_store)
+        if cache_store
+          DefaultCacheProxy.new(get, cache_store)
+        else
+          NullCacheProxy.new(get)
+        end
+      end
+    end
+
+    class NullCacheProxy
+      def initialize(get)
+        @get = get
+      end
+
+      def get
+        @get.invoke_without_cache_check
+      end
+    end
+
+    class DefaultCacheProxy
+      HOP_BY_HOP_HEADERS = %w[connection
+                              keep-alive
+                              proxy-authenticate
+                              proxy-authorization
+                              te
+                              trailers
+                              transfer-encoding
+                              upgrade].freeze
+
+      def initialize(get, cache_store)
+        @get         = get
+        @cache_store = cache_store
+      end
+
+      def log_cached_response
+        Wrest.logger.debug "<*> (GET #{@get.hash}) #{@get.uri.protocol}://#{@get.uri.host}:#{@get.uri.port}#{@get.http_request.path}"
+      end
+
+      def get
+        cached_response = @cache_store[@get.full_uri_string]
+        return fresh_get_response if cached_response.nil?
+
+        if cached_response.expired?
+          expired_cached_response(cached_response)
+        else
+          log_cached_response
+          cached_response
+        end
+      end
+
+      def update_cache_headers_for(cached_response, new_response)
+        # RFC 2616 13.5.3 (Combining Headers)
+        cached_response.headers.merge!(new_response.headers.reject do |key, _value|
+                                         (HOP_BY_HOP_HEADERS.include? key.downcase)
+                                       end)
+      end
+
+      def cache(response)
+        @cache_store[@get.full_uri_string] = response.clone if response&.cacheable?
+      end
+
+      # :nodoc:
+      def fresh_get_response
+        @cache_store.delete @get.full_uri_string
+
+        response = @get.invoke_without_cache_check
+
+        cache(response)
+
+        response
+      end
+
+      # :nodoc:
+      def get_validated_response_for(cached_response)
+        new_response = send_validation_request_for(cached_response)
+        if new_response.code == '304'
+          update_cache_headers_for(cached_response, new_response)
+          log_cached_response
+          cached_response
+        else
+          cache(new_response)
+          new_response
+        end
+      end
+
+      # :nodoc:
+      # Send a cache-validation request to the server. This would be the actual Get request with extra cache-validation headers.
+      # If a 304 (Not Modified) is received, Wrest would use the cached_response itself. Otherwise the new response is cached and used.
+      def send_validation_request_for(cached_response)
+        last_modified            = cached_response.last_modified
+        etag                     = cached_response.headers['etag']
+
+        cache_validation_headers = {}
+        cache_validation_headers['if-modified-since'] = last_modified unless last_modified.nil?
+        cache_validation_headers['if-none-match'] = etag unless etag.nil?
+
+        new_request = @get.build_request_without_cache_store(cache_validation_headers)
+
+        new_request.invoke
+      end
+
+      private
+
+      # :nodoc:
+      def expired_cached_response(cached_response)
+        if cached_response.can_be_validated?
+          get_validated_response_for(cached_response)
+        else
+          fresh_get_response
+        end
+      end
+    end
+  end
+end

data/lib/wrest/caching/memcached.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+begin
+  gem 'dalli', '~> 2'
+rescue Gem::LoadError => e
+  Wrest.logger.debug 'Dalli ~> 2 not found. The Dalli gem is necessary to use the memcached caching back-end.'
+  raise e
+end
+
+require 'dalli'
+
+module Wrest
+  module Caching
+    class Memcached
+      def initialize(server_urls = nil, options = {})
+        @memcached = Dalli::Client.new(server_urls, options)
+      end
+
+      def [](key)
+        @memcached.get(key)
+      end
+
+      def []=(key, value)
+        @memcached.set(key, value)
+      end
+
+      # should be compatible with Hash - return value of the deleted element.
+      def delete(key)
+        value = self[key]
+
+        @memcached.delete key
+
+        value
+      end
+    end
+  end
+end

data/lib/wrest/caching/redis.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+begin
+  gem 'redis', '~> 3'
+rescue Gem::LoadError => e
+  Wrest.logger.debug 'Redis ~> 3 not found. The Redis gem is necessary to use redis as a caching back-end.'
+  raise e
+end
+
+require 'redis'
+require 'yaml'
+
+module Wrest
+  module Caching
+    class Redis
+      def initialize(redis_options = {})
+        @redis = ::Redis.new(redis_options)
+      end
+
+      def [](key)
+        value = @redis.get(key)
+        value.nil? ? nil : YAML.unsafe_load(value)
+      end
+
+      def []=(key, response)
+        marshalled_response = YAML.dump(response)
+        @redis.set(key, marshalled_response)
+        @redis.expire(key, response.freshness_lifetime) unless response.expired?
+      end
+
+      def delete(key)
+        value = self[key]
+        @redis.del(key)
+        value
+      end
+    end
+  end
+end

data/lib/wrest/caching.rb

@@ -0,0 +1,57 @@
+# 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 native://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
+  module Caching
+    # Loads the Memcached caching back-end and the Dalli gem
+    def self.enable_memcached
+      require 'wrest/caching/memcached'
+    end
+
+    # Loads the Redis caching back-end and the Redis gem
+    def self.enable_redis
+      require 'wrest/caching/redis'
+    end
+
+    # Configures Wrest to cache all requests. This will use a Ruby Hash.
+    # WARNING: This should NEVER be used in a real environment. The Hash will
+    # keep growing since Wrest does not limit the size of a cache store.
+    #
+    # Please switch to the memcached or redis back-end for production use.
+    def self.default_to_hash!
+      self.default_store = ({})
+    end
+
+    # Default Wrest to using memcached for caching requests.
+    def self.default_to_memcached!
+      enable_memcached
+      self.default_store = Wrest::Caching::Memcached.new
+    end
+
+    # Default Wrest to using redis for caching requests.
+    #
+    # Options to configuring the redis gem can be passed as arguments.
+    def self.default_to_redis!(redis_options = {})
+      enable_redis
+      self.default_store = Wrest::Caching::Redis.new(redis_options)
+    end
+
+    # Assign the default cache store to be used. Default is none.
+    def self.default_store=(store)
+      @default_store = store
+    end
+
+    # Returns the default store for caching, if any is set.
+    def self.default_store
+      @default_store
+    end
+  end
+end

data/lib/wrest/callback.rb

@@ -0,0 +1,70 @@
+# 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 native://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 Callback
+    attr_reader :callback_hash
+
+    def initialize(callable)
+      case callable
+      when Hash
+        @callback_hash = Callback.ensure_values_are_collections(callable)
+      when Proc
+        @callback_hash = {}
+        callable.call(self)
+      when Callback
+        @callback_hash = callable.callback_hash.dup
+      end
+    end
+
+    def merge(callback)
+      merged_callback_hash = callback_hash.clone
+      other_callback_hash = callback.callback_hash
+      other_callback_hash.each do |code, callback_blocks|
+        merged_callback_hash[code] ||= []
+        merged_callback_hash[code] += callback_blocks
+      end
+      Callback.new(merged_callback_hash)
+    end
+
+    def execute(response)
+      callback_hash.each do |code, callback_list|
+        callback_list.each { |callback| callback.call(response) } if case code
+                                                                     when Range
+                                                                       code.include?(response.code.to_i)
+                                                                     when Integer
+                                                                       code == response.code.to_i
+                                                                     end
+      end
+    end
+
+    def on(code, &block)
+      @callback_hash[code] ? @callback_hash[code] << block : @callback_hash[code] = [block]
+    end
+
+    { 200 => 'ok', 201 => 'created', 202 => 'accepted', 204 => 'no_content', 301 => 'moved_permanently', 302 => 'found', 303 => 'see_other', 304 => 'not_modified',
+      307 => 'temporary_redirect', 400 => 'bad_request', 401 => 'unauthorized', 403 => 'forbidden', 404 => 'not_found', 405 => 'method_not_allowed',
+      406 => 'not_acceptable', 422 => 'unprocessable_entity', 500 => 'internal_server_error' }.each do |code, method|
+      method_name = "on_#{method}".to_sym
+      define_method method_name do |&block|
+        (@callback_hash[code] ? @callback_hash[code] << block : @callback_hash[code] = [block]) if block
+      end
+    end
+
+    def self.ensure_values_are_collections(hash)
+      result = {}
+      hash.each do |code, block|
+        result[code] = block.is_a?(Array) ? block : [block]
+      end
+      result
+    end
+  end
+end

data/lib/wrest/components/container/alias_accessors.rb

@@ -0,0 +1,70 @@
+# 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
+  module Components
+    module Container
+      module AliasAccessors
+        def self.included(klass) # :nodoc:
+          klass.extend AliasAccessors::ClassMethods
+        end
+
+        def self.build_aliased_attribute_getter(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name};#{attribute_name};end;"
+        end
+
+        def self.build_aliased_attribute_setter(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name}=(value);self.#{attribute_name}=value;end;"
+        end
+
+        def self.build_aliased_attribute_queryer(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name}?;self.#{attribute_name}?;end;"
+        end
+
+        module ClassMethods
+          # Creates an alias set of getter, setter and query methods for
+          # attributes that aren't quite the way you'd like them to be; this
+          # is especially useful when you have no control over the source web
+          # sevice/resource.
+          #
+          # For example, lets say that a particular resource exposes a
+          # User's age as 'a' and sex as 's'. Typically, you'd have to access it as
+          # user.a and user.s whereas you's like to access it as user.age and user.sex.
+          # This is where alias_accessors comes into the picture. Your User class would
+          # look somethig like this:
+          #
+          #  class User
+          #    include Wrest::Components::Container
+          #
+          #    alias_accessors  :a => :age,
+          #                     :s => :sex
+          #  end
+          # This would create the methods user.age, user.age= and user.age? which delegates
+          # to user.a, user.a= and user.a? respectively.
+          #
+          # See examples/wow_realm_status.rb for a working example.
+          #
+          # WARNING: If you try to create an alias with the same name as the attribute,
+          # and then use it, you _will_ cause an infinite loop.
+          def alias_accessors(alias_map)
+            alias_map.each do |attribute_name, alias_name|
+              class_eval(
+                AliasAccessors.build_aliased_attribute_getter(attribute_name, alias_name) +
+                AliasAccessors.build_aliased_attribute_setter(attribute_name, alias_name) +
+                AliasAccessors.build_aliased_attribute_queryer(attribute_name, alias_name)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wrest/components/container/typecaster.rb

@@ -0,0 +1,178 @@
+# 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
+  module Components
+    module Container
+      # An extension to Container that adds support for specifying
+      # how the values associated with certain attribute keys
+      # should be typecast.
+      #
+      # This extension can be used in situations where the attributes
+      # hash consists of just strings with no associated tup information.
+      # For example, params recieved from a web browser may contain
+      # attributes like
+      #  'id' => '4', 'dateofbirth' => '1984-04-05'
+      # and we'd like to have these cast to an integer and a date
+      # respectively, rather than have to deal with them as strings.
+      module Typecaster
+        PARSING = {
+          'symbol' => proc { |symbol| symbol.to_s.to_sym },
+          'date' => proc { |date| ::Date.parse(date) },
+          'datetime' => proc { |time|
+            begin
+              Time.xmlschema(time).utc
+            rescue StandardError
+              ::DateTime.parse(time).utc
+            end
+          },
+          'integer' => proc { |integer| integer.to_i },
+          'float' => proc { |float| float.to_f },
+          'decimal' => proc do |number|
+            if number.is_a?(String)
+              number.to_d
+            else
+              BigDecimal(number)
+            end
+          end,
+          'boolean' => proc { |boolean| %w[1 true].include?(boolean.to_s.strip) },
+          'string' => proc { |string| string.to_s },
+          'yaml' => proc { |yaml|
+            begin
+              YAML.safe_load(yaml)
+            rescue StandardError
+              yaml
+            end
+          },
+          'base64Binary' => proc { |bin| ::Base64.decode64(bin) },
+          'binary' => proc { |bin, entity| _parse_binary(bin, entity) },
+          'file' => proc { |file, entity| _parse_file(file, entity) },
+          'double' => proc { |float| float.to_f },
+          'dateTime' => proc { |time|
+            begin
+              Time.xmlschema(time).utc
+            rescue StandardError
+              ::DateTime.parse(time).utc
+            end
+          }
+        }.freeze
+
+        def self.included(klass)
+          # :nodoc:
+          klass.extend Typecaster::ClassMethods
+          klass.class_eval { include Typecaster::InstanceMethods }
+          klass.send(:alias_method, :initialize_without_typecasting, :initialize)
+          klass.send(:alias_method, :initialize, :initialize_with_typecasting)
+        end
+
+        module Helpers
+          def as_base64_binary
+            PARSING['base64Binary']
+          end
+
+          def as_boolean
+            PARSING['boolean']
+          end
+
+          def as_decimal
+            PARSING['decimal']
+          end
+
+          def as_date
+            PARSING['date']
+          end
+
+          def as_datetime
+            PARSING['datetime']
+          end
+
+          def as_float
+            PARSING['float']
+          end
+
+          def as_integer
+            PARSING['integer']
+          end
+
+          def as_symbol
+            PARSING['symbol']
+          end
+
+          def as_yaml
+            PARSING['yaml']
+          end
+        end
+
+        module ClassMethods
+          # Accepts a set of attribute-name/lambda pairs which are used
+          # to typecast string values injected through the constructor.
+          # Typically needed when populating an +Container+
+          # directly from request params. Typecasting kicks in for
+          # a given value _only_ if it is a String, Hash or Array, the
+          # three classes that deserilisation can produce.
+          #
+          # Typecast information is inherited by subclasses; however be
+          # aware that explicitly invoking +typecast+ in a subclass will
+          # discard inherited typecast information leaving only the casts
+          # defined in the subclass.
+          #
+          # Note that this _will_ increase the time needed to initialize
+          # instances.
+          #
+          # Common typecasts such as integer, float, datetime etc. are
+          # available through predefined helpers. See TypecastHelpers
+          # for a full list.
+          #
+          # Example:
+          #
+          #  class Demon
+          #    include Wrest::Components::Container
+          #    include Wrest::Components::Container::Typecaster
+          #
+          #    typecast         :age          =>  as_integer,
+          #                     :chi          =>  lambda{|chi| Chi.new(chi)}
+          #  end
+          #
+          #  kai_wren = Demon.new('age' => '1500', 'chi' => '1024')
+          #  kai_wren.age           # => 1500
+          #  kai_wren.chi           # => #<Chi:0x113af8c @count="1024">
+          def typecast(cast_map)
+            @typecast_map = @typecast_map ? @typecast_map.merge(cast_map.transform_keys(&:to_sym)) : cast_map.transform_keys(&:to_sym)
+          end
+
+          def typecast_map # :nodoc:
+            if defined?(@typecast_map)
+              @typecast_map
+            elsif superclass != Object && superclass.respond_to?(:typecast_map)
+              superclass.typecast_map
+            else
+              {}
+            end
+          end
+        end
+
+        module InstanceMethods # :nodoc:
+          def initialize_with_typecasting(attributes = {})
+            # :nodoc:
+            initialize_without_typecasting(attributes)
+            self.class.typecast_map.each do |key, typecaster|
+              value = @attributes[key]
+              if value.is_a?(String) || value.is_a?(Hash) || value.is_a?(Array)
+                @attributes[key] =
+                  typecaster.call(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end