remote-resource 0.1.0

data/lib/remote_resource/scope_evaluator.rb

@@ -0,0 +1,52 @@
+module RemoteResource
+  class ScopeEvaluator
+    attr_reader :scope
+
+    def initialize(scope = nil)
+      @scope = normalize_scope(scope)
+    end
+
+    def evaluate_on(target_object)
+      scope = {}
+      @scope.each_pair do |attr_key, target_method|
+        scope[attr_key.to_sym] = target_object.send(target_method.to_sym)
+      end
+      scope
+    end
+
+    private
+    # Internal: Returns a Boolean indicating whether or not the scope should be
+    # looked up (evaluated on) the target_object. This allows direct values for
+    # the scope to be used, rather then references to methods on the target
+    # object.
+    def should_eval_attribute_scope?
+      @scope.values.all? { |scope_value| scope_value.is_a? Symbol }
+    end
+
+    # Internal: Returns a hash where the values of the scope have been evaluated
+    # on the provided target_object.
+    def eval_attribute_scope(target_object)
+      scope = {}
+      @scope.each_pair do |attr_key, target_method|
+        scope[attr_key.to_sym] = target_object.send(target_method.to_sym)
+      end
+      scope
+    end
+
+    # Internal: Normalizes the scope argument. Always returns the scope as a
+    # Hash, despite it being able to be specified as a Symbol, Array, or Hash.
+    # An undefined scope returns an empty Hash.
+    def normalize_scope(scope)
+      if ! scope
+        scope = {}
+      elsif scope.is_a? Symbol
+        scope = { scope => scope }
+      elsif scope.is_a? Array
+        scope = {}.tap do |hash|
+          scope.each { |method| hash[method.to_sym] = method.to_sym }
+        end
+      end
+      scope
+    end
+  end
+end

data/lib/remote_resource/storage/cache_control.rb

@@ -0,0 +1,120 @@
+module RemoteResource
+  # A class to represent the 'Cache-Control' header options.
+  # > This implementation is based on 'rack-cache' internals by Ryan Tomayko.
+  # It breaks the several directives into keys/values and stores them into
+  # a Hash.
+  # This file stolen from faraday-http-cache @ 907c33ec25eba8317931e53c84cfa
+  # See: https://github.com/plataformatec/faraday-http-cache
+  class CacheControl
+    # Initialize a new CacheControl.
+    def initialize(header)
+      @directives = parse(header.to_s)
+    end
+
+    # Checks if the 'public' directive is present.
+    def public?
+      @directives['public']
+    end
+
+    # Checks if the 'private' directive is present.
+    def private?
+      @directives['private']
+    end
+
+    # Checks if the 'no-cache' directive is present.
+    def no_cache?
+      @directives['no-cache']
+    end
+
+    # Checks if the 'no-store' directive is present.
+    def no_store?
+      @directives['no-store']
+    end
+
+    # Gets the 'max-age' directive as an Integer.
+    #
+    # Returns nil if the 'max-age' directive isn't present.
+    def max_age
+      @directives['max-age'].to_i if @directives.key?('max-age')
+    end
+
+    # Gets the 'max-age' directive as an Integer.
+    #
+    # takes the age header integer value and reduces the max-age and s-maxage
+    # if present to account for having to remove static age header when caching responses
+    def normalize_max_ages(age)
+      if age > 0
+        @directives['max-age'] = @directives['max-age'].to_i - age if @directives.key?('max-age')
+        @directives['s-maxage'] = @directives['s-maxage'].to_i - age if @directives.key?('s-maxage')
+      end
+    end
+
+    # Gets the 's-maxage' directive as an Integer.
+    #
+    # Returns nil if the 's-maxage' directive isn't present.
+    def shared_max_age
+      @directives['s-maxage'].to_i if @directives.key?('s-maxage')
+    end
+    alias_method :s_maxage, :shared_max_age
+
+    # Internal: Checks if the 'must-revalidate' directive is present.
+    def must_revalidate?
+      @directives['must-revalidate']
+    end
+
+    # Internal: Checks if the 'proxy-revalidate' directive is present.
+    def proxy_revalidate?
+      @directives['proxy-revalidate']
+    end
+
+    # Gets the String representation for the cache directives.
+    # Directives are joined by a '=' and then combined into a single String
+    # separated by commas. Directives with a 'true' value will omit the '='
+    # sign and their value.
+    #
+    # Returns the Cache Control string.
+    def to_s
+      booleans = []
+      values = []
+
+      @directives.each do |key, value|
+        if value == true
+          booleans << key
+        elsif value
+          values << "#{key}=#{value}"
+        end
+      end
+
+      (booleans.sort + values.sort).join(', ')
+    end
+
+    private
+
+    # Parses the Cache Control string to a Hash.
+    # Existing whitespace will be removed and the string is split on commas.
+    # For each part everything before a '=' will be treated as the key
+    # and the exceeding will be treated as the value. If only the key is
+    # present then the assigned value will default to true.
+    #
+    # Examples:
+    #   parse("max-age=600")
+    #   # => { "max-age" => "600"}
+    #
+    #   parse("max-age")
+    #   # => { "max-age" => true }
+    #
+    # Returns a Hash.
+    def parse(header)
+      directives = {}
+
+      header.delete(' ').split(',').each do |part|
+        next if part.empty?
+
+        name, value = part.split('=', 2)
+        directives[name.downcase] = (value || true) unless name.empty?
+      end
+
+      directives
+    end
+  end
+end

data/lib/remote_resource/storage/db_cache.rb

@@ -0,0 +1,36 @@
+require 'remote_resource/storage/serializers/marshal'
+
+module RemoteResource
+  class DBCache
+    ADAPTERS = %i(active_record)
+
+    attr_reader :column_name
+    attr_accessor :target_instance
+
+    def initialize(_adapter, column_name, _serializer = :marshal)
+      @adapter = :active_record
+      @column_name = column_name.to_sym
+      @serializer = Serializers::MarshalSerializer.new
+    end
+
+    # always returns a hash
+    def read_column
+      raw = @target_instance.read_attribute(column_name)
+      raw ? @serializer.load(raw) : {}
+    end
+
+    def write_column(hash)
+      fail ArgumentError 'must be a hash!' unless hash.is_a? Hash
+      raw = @serializer.dump(hash)
+      @target_instance.update_attribute(column_name, raw)
+    end
+
+    def read_key(key)
+      read_column[key.to_sym]
+    end
+
+    def write_key(key, value)
+      write_column(read_column.merge(key.to_sym => value))
+    end
+  end
+end

data/lib/remote_resource/storage/db_cache_factory.rb

@@ -0,0 +1,38 @@
+require 'remote_resource/storage/db_cache'
+
+module RemoteResource
+  class UnsupportedDatabase < StandardError; end
+
+  class DBCacheFactory
+    def initialize(base_class, options)
+      @base_class = base_class
+      @options = options
+    end
+
+    def create_for_class(target_class)
+      db_cache_adapter = db_cache_adapter_for(target_class)
+      if db_cache_adapter
+        column_name = @options[:cache_column] ||
+                      default_or_magic_column_name_for(@base_class)
+        DBCache.new(db_cache_adapter, column_name)
+      else
+        fail UnsupportedDatabase
+      end
+    end
+
+    private
+
+    def default_or_magic_column_name_for(base_class)
+      "#{base_class.underscore}_cache"
+    end
+
+    def db_cache_adapter_for(klass)
+      DBCache::ADAPTERS.detect do |adapter_name|
+        klass.ancestors.any? do |parent_class|
+          next unless (class_name = parent_class.name)
+          class_name.split('::').first.underscore.to_sym == adapter_name
+        end
+      end
+    end
+  end
+end

data/lib/remote_resource/storage/memory.rb

@@ -0,0 +1,27 @@
+require 'remote_resource/storage/storage_entry'
+
+module RemoteResource
+  module Storage
+    class Memory
+      attr_accessor :memory_value
+
+      def initialize
+        @memory_value = {}
+      end
+
+      def read_key(key)
+        value = @memory_value[key]
+        return nil unless value.is_a? Hash
+        StorageEntry.new(value[:headers], value[:data])
+      end
+
+      def write_key(key, storage_entry)
+        if @memory_value[key]
+          @memory_value[key].merge!(storage_entry.to_hash)
+        else
+          @memory_value[key] = storage_entry.to_hash
+        end
+      end
+    end
+  end
+end

data/lib/remote_resource/storage/null_storage_entry.rb

@@ -0,0 +1,43 @@
+require 'active_support/time'
+
+require 'remote_resource/storage/cache_control'
+
+module RemoteResource
+  # An unset storage entry
+  class NullStorageEntry
+    attr_reader :headers, :data
+
+    def initialize
+      @headers = {}
+      @data = {}
+    end
+
+    def to_hash
+      { data: @data, headers: @headers }
+    end
+
+    def cache_control
+      @cache_control ||= CacheControl.new('')
+    end
+
+    def expired?
+      true
+    end
+
+    def data?
+      false
+    end
+
+    def exists?
+      false
+    end
+
+    def headers_for_validation
+      {}
+    end
+
+    def validateable?
+      false
+    end
+  end
+end

data/lib/remote_resource/storage/redis.rb

@@ -0,0 +1,27 @@
+require 'remote_resource/storage/serializers/marshal'
+require 'remote_resource/storage/storage_entry'
+
+module RemoteResource
+  module Storage
+    class Redis
+      def initialize(redis, serializer = nil)
+        @redis = redis
+        @serializer = serializer || Serializers::MarshalSerializer.new
+      end
+
+      def read_key(key)
+        redis_value = @redis.hgetall key
+        StorageEntry.new @serializer.load(redis_value['headers']),
+                         @serializer.load(redis_value['data'])
+      end
+
+      def write_key(storage_key, storage_entry)
+        write_args = []
+        storage_entry.to_hash.each_pair do |key, value|
+          write_args.concat([key, @serializer.dump(value)]) unless value.empty?
+        end
+        @redis.hmset storage_key, *write_args
+      end
+    end
+  end
+end

data/lib/remote_resource/storage/serializer.rb

@@ -0,0 +1,15 @@
+module RemoteResource
+  module Storage
+    class UnImplemntedError < StandardError; end
+
+    class Serializer
+      def load(_object)
+        fail UnImplemntedError 'Must implement serializer#load'
+      end
+
+      def dump(_object)
+        fail UnImplemntedError 'Must implement serializer#dump'
+      end
+    end
+  end
+end

data/lib/remote_resource/storage/serializers/marshal.rb

@@ -0,0 +1,18 @@
+require_relative '../serializer'
+
+module RemoteResource
+  module Storage
+    module Serializers
+      class MarshalSerializer < Serializer
+        def load(object)
+          return nil unless object
+          Marshal.load(object)
+        end
+
+        def dump(object)
+          Marshal.dump(object)
+        end
+      end
+    end
+  end
+end

data/lib/remote_resource/storage/storage_entry.rb

@@ -0,0 +1,69 @@
+require 'active_support/time'
+
+require 'remote_resource/storage/cache_control'
+
+module RemoteResource
+  # A storage entry closely resembles a network response. This seeks to
+  # counteract the impedance mismatch because API responses are done on the
+  # resource level and we want to query storages at the attribute level. Headers
+  # are also handled on the resource (response) level as well, and thus apply
+  # for many attributes.
+  class StorageEntry
+    def self.from_response(response)
+      new(response.headers, response.data)
+    end
+
+    attr_reader :headers, :data
+
+    def initialize(headers, data)
+      @headers = headers.try(:to_hash) || {}
+      @data = data.try(:to_hash) || {}
+    end
+
+    def to_hash
+      {}.tap do |hash|
+        hash[:data] = @data unless @data.size == 0
+        hash[:headers] = @headers unless @headers.size == 0
+      end
+    end
+
+    def cache_control
+      @cache_control ||= CacheControl.new(headers['cache-control'])
+    end
+
+    # TODO: Extract this and make it better
+    # See: https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.4
+    # Cache-Control (http 1.1) overrides Expires header (http: 1.0)
+    def expired?
+      if cache_control.must_revalidate?
+        true
+      elsif cache_control.max_age
+        expire = DateTime.parse(headers['date']) + cache_control.max_age.seconds
+        Time.now > expire
+      else
+        false
+      end
+    end
+
+    def data?
+      !data.empty?
+    end
+
+    def exists?
+      !headers.empty? || data?
+    end
+
+    def headers_for_validation
+      v_headers = {}
+      v_headers['If-None-Match'] = headers['etag'] if headers['etag']
+      if headers['last-modified']
+        v_headers['If-Modified-Since'] = headers['last-modified']
+      end
+      v_headers
+    end
+
+    def validateable?
+      headers.key?('last-modified') || headers.key?('etag')
+    end
+  end
+end