shaf_client 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fdd37c57d1bf069216445f7aacbb04e50aa451bd91a0512f21733aa22b030d2
-  data.tar.gz: 423457d2aa3cd2d79c959488f70ba9a4f454b5a2ce8887fc34377d7613223b0f
+  metadata.gz: 7299a5c0ec8bb7cb0922bb5cddee002c4007e40181bf3ded4a8d28c503185858
+  data.tar.gz: 576b70f8568906c69127f94ca123c9e154cd32cd0ac08efd99a14213f42aa7c6
 SHA512:
-  metadata.gz: 77716b275f965a5f9ae1c5753497bcd5590d5e1250cd0b4241783f8bb874597b42a4ed840ad32d9945313cd64a9366294b015b7825b15aaa208aba8430e8232e
-  data.tar.gz: a110d1773f71aa7d4d71aa04cc702e26a462df87116bd29339c5fbd60d3af001992a968493bbaeaecd5fc731931cc25ede2e2ae72f7da9bde867d3a60a307a66
+  metadata.gz: 598ebc50a8981d76c9bc32bf878e7900d4a8d3d5c3a8b5c8eb7d75a8e1c7754f17d7b2a3104964fd3ba34502d9eb8d56171b23c76f87de9805f9bbef48826edb
+  data.tar.gz: 536c50642866b57a5697d2e95f1fab76981af719e69c54538415aeb739f166562a3d67d10415f03e28b64ee9b2f10f18cf7bf7f464123c79e3704461aa932e23

data/lib/shaf_client.rb

@@ -2,38 +2,31 @@
 
 require 'faraday'
 require 'json'
-require 'shaf_client/middleware/cache'
+require 'shaf_client/middleware/http_cache'
 require 'shaf_client/middleware/redirect'
 require 'shaf_client/resource'
 require 'shaf_client/form'
 
 class ShafClient
-  extend Middleware::Cache::Control
+  class Error < StandardError; end
 
   MIME_TYPE_JSON = 'application/json'
+  MIME_TYPE_HAL  = 'application/hal+json'
+  DEFAULT_ADAPTER = :net_http
 
   def initialize(root_uri, **options)
     @root_uri = root_uri.dup
-    adapter = options.fetch(:faraday_adapter, :net_http)
-    setup options
+    @options = options
 
-    @client = Faraday.new(url: root_uri) do |conn|
-      conn.basic_auth(@user, @pass) if basic_auth?
-      conn.use Middleware::Cache, auth_header: auth_header
-      conn.use Middleware::Redirect
-      conn.adapter adapter
-    end
+    setup_default_headers
+    setup_basic_auth
+    setup_client
   end
 
   def get_root(**options)
     get(@root_uri, **options)
   end
 
-  def get_form(uri, **options)
-    response = request(method: :get, uri: uri, opts: options)
-    Form.new(self, response.body, response.status, response.headers)
-  end
-
   def get_doc(uri, **options)
     response = request(method: :get, uri: uri, opts: options)
     response&.body || ''
@@ -51,18 +44,19 @@ class ShafClient
     end
   end
 
+  def stubs
+    return unless @adapter == :test
+    @stubs ||= Faraday::Adapter::Test::Stubs.new
+  end
+
   private
 
-  attr_reader :auth_header
+  attr_reader :options, :auth_header
 
-  def setup(options)
-    setup_default_headers options
-    setup_basic_auth options
-  end
-
-  def setup_default_headers(options)
+  def setup_default_headers
     @default_headers = {
-      'Content-Type' => options.fetch(:content_type, MIME_TYPE_JSON)
+      'Content-Type' => options.fetch(:content_type, MIME_TYPE_JSON),
+      'Accept' => options.fetch(:accept, MIME_TYPE_HAL)
     }
     return unless token = options[:auth_token]
 
@@ -70,7 +64,7 @@ class ShafClient
     @default_headers[@auth_header] = token
   end
 
-  def setup_basic_auth(options)
+  def setup_basic_auth
     @user, @pass = options.slice(:user, :password).values
     @auth_header = options.fetch(:auth_header, 'Authorization') if basic_auth?
   end
@@ -79,9 +73,33 @@ class ShafClient
     @user && @pass
   end
 
+  def setup_client
+    @adapter = options.fetch(:faraday_adapter, DEFAULT_ADAPTER)
+
+    @client = Faraday.new(url: @root_uri) do |conn|
+      conn.basic_auth(@user, @pass) if basic_auth?
+      conn.use Middleware::HttpCache, cache_options
+      conn.use Middleware::Redirect
+      connect_adapter(conn)
+    end
+  end
+
+  def cache_options
+    options.merge(
+      accessed_by: self,
+      auth_header: auth_header
+    )
+  end
+
+  def connect_adapter(connection)
+    args = [@adapter]
+    args << stubs if @adapter == :test
+    connection.adapter(*args)
+  end
+
   def request(method:, uri:, payload: nil, opts: {})
     payload = JSON.generate(payload) if payload&.is_a?(Hash)
-    headers = @default_headers.merge(opts.fetch(:headers, {}))
+    headers = default_headers(method).merge(opts.fetch(:headers, {}))
     headers[:skip_cache] = true if opts[:skip_cache]
 
     @client.send(method) do |req|
@@ -89,5 +107,13 @@ class ShafClient
       req.body = payload if payload
       req.headers.merge! headers
     end
+  rescue StandardError => e
+    raise Error, e.message
+  end
+
+  def default_headers(http_method)
+    headers = @default_headers.dup
+    headers.delete('Content-Type') unless %i[put patch post].include? http_method
+    headers
   end
 end

data/lib/shaf_client/base_resource.rb

@@ -18,9 +18,11 @@ class ShafClient
     end
 
     def to_h
-      attributes
-        .merge(_links: transform_values_to_s(links))
-        .merge(_embedded: transform_values_to_s(embedded_resources))
+      attributes.dup.tap do |hash|
+        hash[:_links] = transform_values_to_s(links)
+        embedded = transform_values_to_s(embedded_resources)
+        hash[:_embedded] = embedded unless embedded.empty?
+      end
     end
 
     def to_s
@@ -28,19 +30,27 @@ class ShafClient
     end
 
     def attribute(key)
+      raise Error, "No attribute for key: #{key}" unless attributes.key? key
       attributes.fetch(key.to_sym)
     end
 
     def link(rel)
-      links.fetch(rel.to_sym)
+      rewritten_rel = best_match(links.keys, rel)
+      raise Error, "No link with rel: #{rel}" unless links.key? rewritten_rel
+      links[rewritten_rel]
     end
 
     def curie(rel)
-      curies.fetch(rel.to_sym)
+      raise Error, "No curie with rel: #{rel}" unless curies.key? rel.to_sym
+      curies[rel.to_sym]
     end
 
     def embedded(rel)
-      embedded_resources.fetch(rel.to_sym)
+      rewritten_rel = best_match(embedded_resources.keys, rel)
+      unless embedded_resources.key? rewritten_rel
+        raise Error, "No embedded resources with rel: #{rel}"
+      end
+      embedded_resources[rewritten_rel]
     end
 
     def [](key)
@@ -115,6 +125,19 @@ class ShafClient
       super
     end
 
+    def best_match(rels, rel)
+      rel = rel.to_sym
+      return rel if rels.include? rel
+
+      unless rel.to_s.include? ':'
+        matches = rels.grep(/[^:]*:#{rel}/)
+        return matches.first if matches.size == 1
+        raise Error, "Ambiguous rel: #{rel}. (#{matches})" if matches.size > 1
+      end
+
+      best_match(rels, rel.to_s.tr('_', '-')) if rel.to_s.include? '_'
+    end
+
     def transform_values_to_s(hash)
       hash.transform_values do |value|
         if value.is_a? Array

data/lib/shaf_client/form.rb

@@ -30,14 +30,14 @@ class ShafClient
       attribute(:method).downcase.to_sym
     end
 
-    # def validate; end
-
     def submit
       client.send(http_method, target, payload: @values)
     end
 
-    def reload!
-      self << get_form(:self, skip_cache: true)
+    def valid?
+      attribute(:fields).all? do |field|
+        valid_field? field
+      end
     end
 
     protected
@@ -49,5 +49,33 @@ class ShafClient
       end
       super
     end
+
+    def valid_field?(field)
+      key = field['name'].to_sym
+      return false unless validate_required(field, key)
+      return true  if values[key].nil?
+      return false unless validate_number(field, key)
+      return false unless validate_string(field, key)
+      true
+    end
+
+    private
+
+    def validate_required(field, key)
+      return true unless field['required']
+      return false if values[key].nil?
+      return false if values[key].respond_to?(:empty) && values[key].empty?
+      true
+    end
+
+    def validate_string(field, key)
+      return true unless %w[string text].include? field.fetch('type', '').downcase
+      values[key].is_a? String
+    end
+
+    def validate_number(field, key)
+      return true unless %w[int integer number].include? field.fetch('type', '').downcase
+      values.fetch(key, 0).is_a? Numeric
+    end
   end
 end

data/lib/shaf_client/middleware/http_cache.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'shaf_client/middleware/http_cache/in_memory'
+require 'shaf_client/middleware/http_cache/file_storage'
+require 'shaf_client/middleware/http_cache/query'
+require 'shaf_client/middleware/http_cache/accessor'
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      Response = Struct.new(:status, :body, :headers, keyword_init: true)
+
+      def initialize(app, cache_class: InMemory, accessed_by: nil, **options)
+        @app = app
+        @options = options
+        @cache = cache_class.new(options)
+        add_accessors_to accessed_by
+      end
+
+      def call(env)
+        skip_cache = env[:request_headers].delete :skip_cache
+        cached_entry = nil
+
+        if cacheable?(env)
+          query = Query.from(env)
+          cache.load(query) do |cached|
+            return cached_response(cached) if cached.valid? && !skip_cache
+            add_etag(env, cached.etag)
+            cached_entry = cached
+          end
+        end
+
+        @app.call(env).on_complete do
+          handle_not_modified(env, cached_entry)
+          update_cache(env)
+        end
+      end
+
+      private
+
+      attr_reader :cache
+
+      def add_accessors_to(obj)
+        return unless obj
+        obj.extend Accessor.for(cache)
+      end
+
+      def cacheable?(env)
+        %i[get head].include? env[:method]
+      end
+
+      def cached_response(entry)
+        cached_headers = entry.response_headers.transform_keys(&:to_s)
+        Response.new(body: entry.payload, headers: cached_headers)
+      end
+
+      def add_etag(env, etag)
+        env[:request_headers]['If-None-Match'] = etag if etag
+      end
+
+      def handle_not_modified(env, cached_entry)
+        return unless env[:status] == 304
+
+        cached_headers = cached_entry.response_headers.transform_keys(&:to_s)
+        env[:body] = cached_entry.payload
+        env[:response_headers] = cached_headers.merge(env[:response_headers])
+
+        expire_at = Entry.from(env).expire_at
+        cache.update_expiration(cached_entry, expire_at)
+      end
+
+      def update_cache(env)
+        cache.inc_request_count
+        entry = Entry.from(env)
+        return unless storable?(env: env, entry: entry)
+
+        cache.store entry
+      end
+
+      def storable?(env:, entry:)
+        return false unless %i[get put].include? env[:method]
+        return false unless env[:status] != 204
+        return false unless (200..299).cover? env[:status]
+        return false unless entry.etag || entry.expire_at
+
+        request_headers = env.request_headers.transform_keys { |k| k.downcase.to_sym }
+        entry.vary.keys.all? do |key|
+          request_headers.include? key
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/accessor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      module Accessor
+        module Accessible
+          extend Forwardable
+          def_delegator :__cache, :size, :cache_size
+          def_delegator :__cache, :clear, :clear_cache
+          def_delegator :__cache, :clear_stale, :clear_stale_cache
+        end
+
+        def self.for(cache)
+          block = proc { cache }
+
+          Module.new do
+            include Accessible
+            define_method(:__cache, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/base.rb

@@ -0,0 +1,84 @@
+require 'shaf_client/middleware/http_cache/entry'
+require 'shaf_client/middleware/http_cache/key'
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      class Base
+        DEFAULT_PURGE_THRESHOLD         = 1000
+        DEFAULT_NO_REQUEST_BETWEEN_PURGE = 500
+
+        attr_writer :request_count, :purge_threshold
+
+        def initialize(**_options); end
+
+        def purge_threshold
+          @purge_threshold ||= DEFAULT_PURGE_THRESHOLD
+        end
+
+        def requests_between_purge
+          DEFAULT_NO_REQUEST_BETWEEN_PURGE
+        end
+
+        def should_purge?
+          (request_count % requests_between_purge).zero?
+        end
+
+        def inc_request_count
+          self.request_count += 1
+          return unless should_purge?
+
+          clear_invalid
+          purge
+        end
+
+        def request_count
+          @request_count ||= 0
+        end
+
+        def purge_target
+          (purge_threshold * 0.8).to_i
+        end
+
+        def purge
+          return unless size > purge_threshold
+
+          count = size - purge_target
+          return unless count.positive?
+
+          delete_if do
+            break if count.zero?
+            count -= 1
+          end
+        end
+
+        def load(query)
+          entry = get(query)
+          return entry unless block_given?
+          yield entry if entry
+        end
+
+        def store(entry)
+          return unless entry.storable?
+          put(entry)
+        end
+
+        def update_expiration(entry, expire_at)
+          return unless expire_at
+
+          updated_entry = entry.dup
+          updated_entry.expire_at = expire_at
+          store(updated_entry)
+        end
+
+        %i[size get put clear clear_invalid delete_if].each do |name|
+          define_method(name) do
+            raise NotImplementedError, "#{self.class} does not implement required method #{name}"
+          end
+        end
+
+        private :delete_if
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/entry.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'shaf_client/middleware/http_cache/key'
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      class Entry
+        extend Key
+
+        attr_reader :key, :payload, :etag, :vary, :response_headers
+        attr_accessor :expire_at
+
+        class << self
+          def from(env)
+            response_headers = response_headers(env)
+
+            new(
+              key: key(env.fetch(:url)),
+              payload: env[:body],
+              etag: response_headers[:etag],
+              expire_at: expire_at(response_headers),
+              vary: vary(env),
+              response_headers: response_headers
+            )
+          end
+
+          private
+
+          def response_headers(env)
+            response_headers = env.response_headers
+            response_headers ||= {}
+            response_headers.transform_keys { |k| k.downcase.to_sym }
+          end
+
+          def request_headers(env)
+            request_headers = env.request_headers
+            request_headers ||= {}
+            request_headers.transform_keys { |k| k.downcase.to_sym }
+          end
+
+          def expire_at(headers)
+            cache_control = headers[:'cache-control']
+            return unless cache_control
+
+            max_age = cache_control[/\bmax-age=(\d+)/, 1]
+            Time.now + max_age.to_i if max_age
+          end
+
+          def vary(env)
+            response_headers = response_headers(env)
+            request_headers  = request_headers(env)
+            keys = response_headers.fetch(:vary, '').split(',')
+            keys.each_with_object({}) do |key, vary|
+              key = key.strip.downcase.to_sym
+              # The respose that we see is already decoded (e.g. gunzipped) so
+              # we shouldn't need to care about the Accept-Encoding header
+              next if key == :'accept-encoding'
+              vary[key] = request_headers[key]
+            end
+          end
+        end
+
+        def initialize(key:, payload: nil, etag: nil, expire_at: nil, vary: {}, response_headers: {})
+          expire_at = Time.parse(expire_at) if expire_at.is_a? String
+          @key = key.freeze
+          @payload = payload.freeze
+          @etag = etag.freeze
+          @expire_at = expire_at.freeze
+          @vary = vary.freeze
+          @response_headers = response_headers
+          freeze
+        end
+
+        def expired?
+          not fresh?
+        end
+
+        def fresh?
+          !!(expire_at && expire_at >= Time.now)
+        end
+
+        def valid?
+          return false unless payload?
+          fresh?
+        end
+
+        def invalid?
+          !valid?
+        end
+
+        def payload?
+          !!(payload && !payload.empty?)
+        end
+
+        def storable?
+          return false unless payload?
+          !!(etag || expire_at)
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/file_storage.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'securerandom'
+require 'shaf_client/middleware/http_cache/base'
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      class FileStorage < Base
+        class FileEntry < Entry
+          attr_reader :filepath
+
+          def self.deserialize(content)
+            new(**JSON.parse(content, symbolize_names: true))
+          end
+
+          def self.from_entry(entry, filepath)
+            new(
+              key: entry.key,
+              etag: entry.etag,
+              expire_at: entry.expire_at,
+              vary: entry.vary,
+              payload: entry.payload,
+              filepath: filepath,
+              response_headers: entry.response_headers
+            )
+          end
+
+          def initialize(
+            key:,
+            filepath:,
+            payload: nil,
+            etag: nil,
+            expire_at: nil,
+            vary: {},
+            response_headers: {}
+          )
+            @filepath = filepath
+            super(
+              key: key,
+              payload: payload,
+              etag: etag,
+              expire_at: expire_at,
+              vary: vary,
+              response_headers: response_headers
+            )
+          end
+
+          def serialize
+            JSON.pretty_generate(
+              key: key,
+              etag: etag,
+              expire_at: expire_at,
+              vary: vary,
+              filepath: filepath,
+              response_headers: response_headers,
+              payload: payload
+            )
+          end
+        end
+
+        def initialize(**options)
+          init_dir(options.delete(:directory))
+        end
+
+        def size
+          count = 0
+          each_file { count += 1 }
+          count
+        end
+
+        def clear
+          return unless Dir.exist? cache_dir
+
+          FileUtils.remove_entry_secure cache_dir
+          Dir.mkdir cache_dir
+        end
+
+        def clear_invalid
+          delete_if(&:invalid?)
+        end
+
+        def get(query)
+          find(query)
+        end
+
+        def put(entry)
+          existing = find(Query.from(entry))
+          unlink(existing) if existing
+          write(entry)
+        end
+
+        def each_file
+          return unless Dir.exist? cache_dir
+
+          Dir.each_child(cache_dir) do |dir|
+            Dir.each_child(File.join(cache_dir, dir)) do |file|
+              yield File.join(cache_dir, dir, file)
+            end
+          end
+        end
+
+        def each
+          each_file do |file|
+            yield parse(file)
+          end
+        end
+
+        private
+
+        attr_reader :cache_dir
+
+        def init_dir(dir)
+          @cache_dir = String(dir)
+          return if !@cache_dir.empty? && File.exist?(@cache_dir)
+
+          @cache_dir = File.join(Dir.tmpdir, 'shaf_client_http_cache') if @cache_dir.empty?
+          Dir.mkdir(@cache_dir) unless Dir.exist? @cache_dir
+        end
+
+        def delete_if
+          each do |entry|
+            unlink(entry) if yield entry
+          end
+        end
+
+        def find(query)
+          dir = dir(query.key)
+          return unless dir && Dir.exist?(dir)
+
+          Dir.each_child(dir) do |filename|
+            path = File.join(dir, filename)
+            file_entry = parse(path)
+            return file_entry if query.match?(file_entry.vary)
+          end
+        end
+
+        def dir(key)
+          File.join(cache_dir, key.to_s.tr('/', '_'))
+        end
+
+        def parse(path)
+          raise Error.new("File not readable: #{path}") unless File.readable? path
+
+          content = File.read(path)
+          FileEntry.deserialize(content)
+        end
+
+        def unlink(entry)
+          File.unlink(entry.filepath) if entry.filepath
+          dir = File.dirname(entry.filepath)
+          Dir.delete(dir) if Dir.empty? dir
+        end
+
+        def write(entry)
+          dir = dir(entry.key)
+          raise Error.new("File not writable: #{dir}") unless File.writable? File.dirname(dir)
+          Dir.mkdir(dir) unless Dir.exist?(dir)
+
+          path = File.join(dir, filename(entry))
+          raise Error.new("File not writable: #{dir}") unless File.writable? dir
+          content = FileEntry.from_entry(entry, path).serialize
+          File.write(path, content)
+        end
+
+        def filename(entry)
+          [entry.expire_at, SecureRandom.hex(4)].join('_')
+        end
+      end
+    end
+  end
+end
+# shaf_client_http_cache
+# .
+# └── shaf_client_http_cache
+#     ├── host_posts
+#     │   ├── 2019-08-06T12:05:27_j2f
+#     │   ├── 2019-08-06T10:43:10_io1
+#     │   └── 2019-08-07T12:05:27_k13
+#     ├── host_posts_5
+#     │   └── 2019-08-07T22:12:23_kj1
+#     └── host_comments
+#         └── 2019-08-05T10:35:00_22m
+

data/lib/shaf_client/middleware/http_cache/in_memory.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'shaf_client/middleware/http_cache/base'
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      class InMemory < Base
+        def size
+          mutex.synchronize do
+            cache.sum { |_key, entries| entries.size }
+          end
+        end
+
+        def clear
+          mutex.synchronize { @cache = new_hash }
+        end
+
+        def clear_invalid
+          mutex.synchronize do
+            cache.each do |_key, entries|
+              entries.keep_if(&:valid?)
+            end
+          end
+        end
+
+        def get(query)
+          mutex.synchronize { find(query) }
+        end
+
+        def put(entry)
+          mutex.synchronize do
+            existing = find(Query.from(entry))
+            cache[entry.key].delete(existing) if existing
+            cache[entry.key].unshift entry
+          end
+        end
+
+        private
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+        def cache
+          @cache ||= new_hash
+        end
+
+        def new_hash
+          Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def delete_if(&block)
+          mutex.synchronize do
+            cache.each do |_key, entries|
+              entries.delete_if(&block)
+            end
+          end
+        end
+
+        def find(query)
+          cache[query.key].find { |e| query.match?(e.vary) }
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/key.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      module Key
+        def key(uri)
+          uri = URI(uri) if uri.is_a? String
+          query = (uri.query || '').split('&').sort.join('&')
+          [uri.host, uri.path, query].join('_').to_sym
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/http_cache/query.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class ShafClient
+  module Middleware
+    class HttpCache
+      class Query
+        extend Key
+
+        attr_reader :key, :headers
+
+        def self.from(env)
+          return from_entry(env) if env.is_a? Entry
+
+          new(
+            key: key(env.fetch(:url)),
+            headers: env.request_headers.transform_keys { |k| k.downcase.to_sym }
+          )
+        end
+
+        def self.from_entry(entry)
+          new(
+            key: entry.key,
+            headers: entry.vary
+          )
+        end
+
+        def initialize(key:, headers: {})
+          @key = key
+          @headers = headers
+        end
+
+        def match?(vary)
+          vary.all? do |key, value|
+            headers[key] == value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/middleware/redirect.rb

@@ -8,14 +8,14 @@ class ShafClient
         @app = app
       end
 
-      def call(request_env)
-        @app.call(request_env).on_complete do |response_env|
-          status = response_env[:status]
-          location = response_env[:response_headers]['Location']
+      def call(env)
+        @app.call(env).on_complete do
+          status = env[:status]
+          location = env[:response_headers]['Location']
           next unless redirect? status
           next unless location
-          update_env(request_env, status, location)
-          @app.call(request_env)
+          update_env(env, status, location)
+          @app.call(env)
         end
       end
 
@@ -23,12 +23,12 @@ class ShafClient
         [301, 302, 303, 307, 308].include? status
       end
 
-      def update_env(request_env, status, location)
+      def update_env(env, status, location)
         if status == 303
-          request_env[:method] = :get
-          request_env[:body] = nil
+          env[:method] = :get
+          env[:body] = nil
         end
-        request_env[:url] = URI(location)
+        env[:url] = URI(location)
       end
     end
   end

data/lib/shaf_client/resource.rb

@@ -5,7 +5,7 @@ class ShafClient
   class Resource < BaseResource
     attr_reader :http_status, :headers
 
-    class ResourceClasses
+    class ResourceMapper
       class << self
         def all
           @all ||= Hash.new(Resource)
@@ -22,12 +22,12 @@ class ShafClient
     end
 
     def self.profile(name)
-      ResourceClasses.set(name, self)
+      ResourceMapper.set(name, self)
     end
 
     def self.build(client, payload, status = nil, headers = {})
-      profile = headers.fetch('content-type', '')[/profile=([\w-]+)/, 1]
-      ResourceClasses.for(profile).new(client, payload, status, headers)
+      profile = headers.fetch('content-type', '')[/profile=([\w-]+)\b/, 1]
+      ResourceMapper.for(profile).new(client, payload, status, headers)
     end
 
     def initialize(client, payload, status = nil, headers = {})
@@ -37,7 +37,7 @@ class ShafClient
       super(payload)
     end
 
-    %i[get put post delete patch get_form].each do |method|
+    %i[get put post delete patch].each do |method|
       define_method(method) do |rel, payload = nil, **options|
         href = link(rel).href
         client.send(method, href, payload: payload, **options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shaf_client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Sammy Henningsson
@@ -30,7 +30,7 @@ cert_chain:
   ZMhjYR7sRczGJx+GxGU2EaR0bjRsPVlC4ywtFxoOfRG3WaJcpWGEoAoMJX6Z0bRv
   M40=
   -----END CERTIFICATE-----
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2019-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -91,7 +91,14 @@ files:
 - lib/shaf_client/curie.rb
 - lib/shaf_client/form.rb
 - lib/shaf_client/link.rb
-- lib/shaf_client/middleware/cache.rb
+- lib/shaf_client/middleware/http_cache.rb
+- lib/shaf_client/middleware/http_cache/accessor.rb
+- lib/shaf_client/middleware/http_cache/base.rb
+- lib/shaf_client/middleware/http_cache/entry.rb
+- lib/shaf_client/middleware/http_cache/file_storage.rb
+- lib/shaf_client/middleware/http_cache/in_memory.rb
+- lib/shaf_client/middleware/http_cache/key.rb
+- lib/shaf_client/middleware/http_cache/query.rb
 - lib/shaf_client/middleware/redirect.rb
 - lib/shaf_client/resource.rb
 homepage: https://github.com/sammyhenningsson/shaf_client

data/lib/shaf_client/middleware/cache.rb

@@ -1,186 +0,0 @@
-# FIXME zip payload
-
-class ShafClient
-  module Middleware
-    class Cache
-      DEFAULT_THRESHOLD = 10_000
-
-      Response = Struct.new(:status, :body, :headers, keyword_init: true)
-
-      module Control
-        def cache_size
-          Cache.size
-        end
-
-        def clear_cache
-          Cache.clear
-        end
-
-        def clear_stale_cache
-          Cache.clear_stale
-        end
-      end
-
-      class << self
-        attr_writer :threshold
-
-        def inc_request_count
-          @request_count ||= 0
-          @request_count += 1
-          return if (@request_count % 500 != 0)
-          clear_stale
-          check_threshold
-        end
-
-        def size
-          cache.size
-        end
-
-        def clear
-          mutex.synchronize do
-            @cache = {}
-          end
-        end
-
-        def clear_stale
-          mutex.synchronize do
-            cache.delete_if { |_key, entry| expired? entry }
-          end
-        end
-
-        def get(key:, check_expiration: true)
-          entry = nil
-          mutex.synchronize do
-            entry = cache[key.to_sym].dup
-          end
-          return entry[:payload] if valid?(entry, check_expiration)
-          yield if block_given?
-        end
-
-        def get_etag(key:)
-          mutex.synchronize do
-            cache.dig(key.to_sym, :etag)
-          end
-        end
-
-        def store(key:, payload:, etag: nil, expire_at: nil)
-          return unless payload && key && (etag || expire_at)
-
-          mutex.synchronize do
-            cache[key.to_sym] = {
-              payload: payload,
-              etag: etag,
-              expire_at: expire_at
-            }
-          end
-        end
-
-        def threshold
-          @threshold ||= DEFAULT_THRESHOLD
-        end
-
-        private
-
-        def mutex
-          @mutex = Mutex.new
-        end
-
-        def cache
-          mutex.synchronize do
-            @cache ||= {}
-          end
-        end
-
-        def valid?(entry, check_expiration = true)
-          return false unless entry
-          return false unless entry[:payload]
-          return true unless check_expiration
-          !expired? entry
-        end
-
-        def expired?(entry)
-          return true unless entry[:expire_at]
-          entry[:expire_at] < Time.now
-        end
-
-        def check_threshold
-          return if size < threshold
-
-          count = 500
-          cache.each do |key, _value|
-            break if count <= 0
-            cache[key] = nil
-            count -= 1
-          end
-          cache.compact!
-        end
-      end
-
-      def initialize(app, **options)
-        @app = app
-        @options = options
-      end
-
-      def call(request_env)
-        key = cache_key(request_env[:url], request_env[:request_headers])
-
-        skip_cache = request_env[:request_headers].delete :skip_cache
-
-        if !skip_cache && request_env[:method] == :get
-          cached = self.class.get(key: key)
-          return Response.new(body: cached, headers: {}) if cached
-        end
-
-        add_etag(request_env, key)
-
-        @app.call(request_env).on_complete do |response_env|
-          # key might have changed in other middleware
-          key = cache_key(response_env[:url], request_env[:request_headers])
-          add_cached_payload(response_env, key)
-          cache_response(response_env, key)
-          self.class.inc_request_count
-        end
-      end
-
-      def add_etag(env, key = nil)
-        return unless %i[get head].include? env[:method]
-        key ||= cache_key(env[:url], env[:request_headers])
-        etag = self.class.get_etag(key: key)
-        env[:request_headers]['If-None-Match'] = etag if etag
-      end
-
-      def add_cached_payload(response_env, key)
-        return if response_env[:status] != 304
-        cached = self.class.get(key: key, check_expiration: false)
-        response_env[:body] = cached if cached
-      end
-
-      def cache_response(response_env, key)
-        etag = response_env[:response_headers]['etag']
-        cache_control = response_env[:response_headers]['cache-control']
-        expire_at = expiration(cache_control)
-        self.class.store(
-          key: key,
-          payload: response_env[:body],
-          etag: etag,
-          expire_at: expire_at
-        )
-      end
-
-      def cache_key(url, request_headers)
-        :"#{url}.#{request_headers&.dig(auth_header)}"
-      end
-
-      def auth_header
-        @options.fetch(:auth_header, 'X-AUTH-TOKEN')
-      end
-
-      def expiration(cache_control)
-        return unless cache_control
-
-        max_age = cache_control[/max-age=\s?(\d+)/, 1]
-        Time.now + max_age.to_i if max_age
-      end
-    end
-  end
-end