active_rest_client 0.9.58

data/lib/active_rest_client/headers_list.rb

@@ -0,0 +1,47 @@
+module ActiveRestClient
+  class HeadersList
+    STORE_MULTIPLE_VALUES = ["set-cookie"]
+    def initialize
+      @store = {}
+    end
+
+    def []=(key,value)
+      key = find_existing(key)
+      if STORE_MULTIPLE_VALUES.include?(key.downcase)
+        @store[key] ||= []
+        @store[key] << value
+      else
+        @store[key] = value
+      end
+    end
+
+    def [](key)
+      key = find_existing(key)
+      @store[key]
+    end
+
+    def each(split_multiple_headers = false)
+      @store.keys.each do |key|
+        value = @store[key]
+        if value.is_a?(Array) && split_multiple_headers
+          value.each do |inner_value|
+            yield(key, inner_value)
+          end
+        else
+          yield(key, value)
+        end
+      end
+    end
+
+    private
+
+    def find_existing(key)
+      key_downcase = key.downcase
+      @store.keys.each do |found_key|
+        return found_key if found_key.downcase == key_downcase
+      end
+      key
+    end
+
+  end
+end

data/lib/active_rest_client/instrumentation.rb

@@ -0,0 +1,62 @@
+module ActiveRestClient
+  class Instrumentation < ActiveSupport::LogSubscriber
+    def request_call(event)
+      self.class.time_spent += event.duration
+      self.class.calls_made += 1
+      name = '%s (%.1fms)' % [ActiveRestClient::NAME, event.duration]
+      ActiveRestClient::Logger.debug "  \033[1;4;32m#{name}\033[0m #{event.payload[:name]}"
+    end
+
+    def self.time_spent=(value)
+      @@time_spent = value
+    end
+
+    def self.time_spent
+      @@time_spent ||= 0
+    end
+
+    def self.calls_made=(value)
+      @@calls_made = value
+    end
+
+    def self.calls_made
+      @@calls_made ||= 0
+    end
+
+    def self.reset
+      @@time_spent = 0
+      @@calls_made = 0
+    end
+
+    def logger
+      ActiveRestClient::Logger
+    end
+  end
+
+  module ControllerInstrumentation
+    extend ActiveSupport::Concern
+
+    protected
+
+    def append_info_to_payload(payload)
+      super
+      payload[:active_rest_client_time_spent] = ActiveRestClient::Instrumentation.time_spent
+      payload[:active_rest_client_calls_made] = ActiveRestClient::Instrumentation.calls_made
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages, time_spent, calls_made = super, payload[:active_rest_client_time_spent], payload[:active_rest_client_calls_made]
+        messages << ("#{ActiveRestClient::NAME}: %.1fms for %d calls" % [time_spent.to_f, calls_made]) if calls_made
+        ActiveRestClient::Instrumentation.reset
+        messages
+      end
+    end
+  end
+end
+
+ActiveRestClient::Instrumentation.attach_to :active_rest_client
+
+ActiveSupport.on_load(:action_controller) do
+  include ActiveRestClient::ControllerInstrumentation
+end

data/lib/active_rest_client/lazy_association_loader.rb

@@ -0,0 +1,95 @@
+require 'active_support/hash_with_indifferent_access'
+
+module ActiveRestClient
+  class LazyAssociationLoader
+    include Enumerable
+
+    def initialize(name, value, request, options = {})
+      @name = name
+      @request = request
+      @object = nil
+      @options = options
+      if value.is_a? Array
+        @subloaders = value.map {|url| LazyAssociationLoader.new(name, url, request, options)}
+      elsif value.is_a?(Hash) && (value.has_key?("url") || value.has_key?(:url))
+        @url = (value["url"] || value[:url])
+      elsif value.is_a?(Hash) && (value.has_key?("href") || value.has_key?(:href)) # HAL
+        @url = (value["href"] || value[:href])
+        @_hal_attributes = HashWithIndifferentAccess.new(value)
+      elsif value.is_a?(Hash)
+        mapped = {}
+        value.each do |k,v|
+          mapped[k.to_sym] = LazyAssociationLoader.new(name, v, request, options)
+        end
+        @subloaders = mapped
+        # Need to also ensure that the hash/wrapped object is returned when the property is accessed
+      elsif value.is_a? String
+        @url = value
+      else
+        raise InvalidLazyAssociationContentException.new("Invalid content for #{@name}, expected Array, String or Hash containing 'url' key")
+      end
+    end
+
+    def _hal_attributes(key)
+      @_hal_attributes[key]
+    end
+
+    def size
+      if @subloaders
+        @subloaders.size
+      else
+        ensure_lazy_loaded
+        @object.size
+      end
+    end
+
+    def each
+      if @subloaders
+        if @subloaders.is_a? Array
+          @subloaders.each do |loader|
+            yield loader
+          end
+        elsif @subloaders.is_a? Hash
+          @subloaders.each do |key,value|
+            yield key, value
+          end
+        end
+      else
+        ensure_lazy_loaded
+        @object.each do |obj|
+          yield obj
+        end
+      end
+    end
+
+    def keys
+      @subloaders.keys
+    end
+
+    def method_missing(name, *args)
+      if @subloaders.is_a? Hash
+        return @subloaders[name.to_sym]
+      end
+      ensure_lazy_loaded
+      if @object
+        @object.send(name, *args)
+      end
+    end
+
+    private
+
+    def ensure_lazy_loaded
+      if @object.nil?
+        @request.method[:method] = :get
+        @request.method[:options][:url] = @url
+        @request.method[:options][:overriden_name] = @options[:overriden_name]
+        request = ActiveRestClient::Request.new(@request.method, @request.object)
+        request.url = request.forced_url = @url
+        @object = request.call
+      end
+    end
+  end
+
+  class InvalidLazyAssociationContentException < Exception ; end
+
+end

data/lib/active_rest_client/lazy_loader.rb

@@ -0,0 +1,23 @@
+module ActiveRestClient
+  class LazyLoader
+    def initialize(request, params = nil)
+      @request = request
+      @params = params
+      @result = nil
+    end
+
+    def method_missing(name, *args)
+      if @result.nil?
+        @result = @request.call(@params)
+      end
+      @result.send(name, *args)
+    end
+
+    def respond_to?(name)
+      if @result.nil?
+        @result = @request.call(@params)
+      end
+      @result.respond_to?(name)
+    end
+  end
+end

data/lib/active_rest_client/logger.rb

@@ -0,0 +1,67 @@
+module ActiveRestClient
+  class Logger
+    @logfile = nil
+    @messages = []
+
+    def self.logfile=(value)
+      @logfile = value
+    end
+
+    def self.messages
+      @messages
+    end
+
+    def self.reset!
+      @logfile = nil
+      @messages = []
+    end
+
+    def self.debug(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.debug(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << message
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.info(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.info(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << message
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.warn(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.warn(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << message
+        end
+      else
+        @messages << message
+      end
+    end
+
+    def self.error(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error(message)
+      elsif @logfile
+        File.open(@logfile, "a") do |f|
+          f << message
+        end
+      else
+        @messages << message
+      end
+    end
+  end
+end

data/lib/active_rest_client/mapping.rb

@@ -0,0 +1,65 @@
+module ActiveRestClient
+  module Mapping
+    module ClassMethods
+      def get(name, url, options = {})
+        _map_call(name, url:url, method: :get, options:options)
+      end
+
+      def put(name, url, options = {})
+        _map_call(name, url:url, method: :put, options:options)
+      end
+
+      def post(name, url, options = {})
+        _map_call(name, url:url, method: :post, options:options)
+      end
+
+      def delete(name, url, options = {})
+        _map_call(name, url:url, method: :delete, options:options)
+      end
+
+      def _map_call(name, details)
+        _calls[name] = {name:name}.merge(details)
+        _calls["lazy_#{name}".to_sym] = {name:name}.merge(details)
+        self.class.send(:define_method, name) do |options={}|
+          _call(name, options)
+        end
+        self.class.send(:define_method, "lazy_#{name}".to_sym) do |options={}|
+          _call("lazy_#{name}", options)
+        end
+      end
+
+      def _call(name, options)
+        mapped = _calls[name]
+        lazy_forced = false
+        if mapped.nil? && name.to_s[/^lazy_/]
+          mapped = _calls[name.to_s.gsub(/^lazy_/, '').to_sym]
+          lazy_forced = true
+        end
+        request = Request.new(mapped, self, options)
+        if lazy_load? || lazy_forced
+          ActiveRestClient::LazyLoader.new(request)
+        else
+          request.call
+        end
+      end
+
+      def _calls
+        @_calls
+      end
+
+      def _mapped_method(name)
+        _calls[name]
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@_calls, {})
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end

data/lib/active_rest_client/proxy_base.rb

@@ -0,0 +1,143 @@
+module ActiveRestClient
+  class ProxyBase
+    cattr_accessor :mappings, :request, :original_handler
+    cattr_accessor :original_body, :original_get_params, :original_post_params, :original_url
+
+    module ClassMethods
+      def get(match, &block)
+        add_mapping(:get, match, block)
+      end
+
+      def post(match, &block)
+        add_mapping(:post, match, block)
+      end
+
+      def put(match, &block)
+        add_mapping(:put, match, block)
+      end
+
+      def delete(match, &block)
+        add_mapping(:delete, match, block)
+      end
+
+      def add_mapping(method_type, match, block)
+        @mappings ||= []
+
+        if match.is_a?(String) && (param_keys = match.scan(/:\w+/)) && param_keys.any?
+          param_keys.each do |key|
+            match.gsub!(key, "([^/]+)")
+          end
+          param_keys = param_keys.map {|k| k.gsub(":", "").to_sym}
+          match = Regexp.new(match)
+        end
+
+        @mappings << OpenStruct.new(http_method:method_type, match:match, block:block, param_keys:param_keys)
+      end
+
+      def body(value = nil)
+        @body = value if value
+        @body
+      end
+
+      def url(value = nil)
+        @url = value if value
+        @url
+      end
+
+      def get_params(value = nil)
+        @get_params = value if value
+        @get_params
+      end
+
+      def post_params(value = nil)
+        @post_params = value if value
+        @post_params
+      end
+
+      def params(value = nil)
+        @params = value if value
+        @params
+      end
+
+      def passthrough
+        rebuild_request
+        @original_handler.call(@request)
+      end
+
+      def translate(result, options = {})
+        result.headers["content-type"] = "application/hal+json"
+        result = OpenStruct.new(status:result.status, headers:result.headers, body:result.body)
+        obj = Oj.load(result.body)
+        result.body = yield obj
+        result
+      end
+
+      def rebuild_request
+        if @url != @original_url
+          @request.forced_url = @request.url = @url
+        end
+        if @body != @original_body
+          @request.body = @body
+        elsif @post_params != @original_post_params
+          @request.body = nil
+          @request.prepare_request_body(@post_params)
+        end
+        if @get_params != @original_get_params
+          @request.get_params = @get_params
+          @request.prepare_url
+          @request.append_get_parameters
+        end
+      end
+
+      def handle(request, &block)
+        @request = request
+        @original_handler = block
+
+        @original_body = request.body
+        @body = @original_body.dup
+
+        @original_get_params = request.get_params
+        @get_params = @original_get_params.dup
+
+        @original_post_params = request.post_params
+        @post_params = (@original_post_params || {}).dup
+
+        @original_url = request.url
+        @url = @original_url.dup
+
+        if mapping = find_mapping_for_current_request
+          self.class_eval(&mapping.block)
+        else
+          passthrough
+        end
+      end
+
+      def find_mapping_for_current_request
+        uri = URI.parse(@original_url)
+        @mappings ||= []
+        @params = {}
+        @mappings.each do |mapping|
+          match = mapping.match
+          if (match_data = uri.path.match(match)) && @request.http_method.to_sym == mapping.http_method
+            matches = match_data.to_a
+            matches.shift
+            matches.each_with_index do |value, index|
+              @params[mapping.param_keys[index]] = value
+            end
+            return mapping
+          end
+        end
+        nil
+      end
+
+      def render(body, status=200, content_type="application/javascript", headers={})
+        headers["Content-type"] = content_type
+        OpenStruct.new(body:body, status:status, headers:headers, proxied:true)
+      end
+    end
+
+    def self.inherited(base)
+      base.extend(ClassMethods)
+    end
+  end
+end