shaf_client 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7299a5c0ec8bb7cb0922bb5cddee002c4007e40181bf3ded4a8d28c503185858
-  data.tar.gz: 576b70f8568906c69127f94ca123c9e154cd32cd0ac08efd99a14213f42aa7c6
+  metadata.gz: 7c7758e0a388759de54cd305d5b1541c01c071d0155939fca0dd8a2f9fb57438
+  data.tar.gz: c297702586a42855ec25e3f8e0d9fef33936393b3ade5b3258a2a89b03b85896
 SHA512:
-  metadata.gz: 598ebc50a8981d76c9bc32bf878e7900d4a8d3d5c3a8b5c8eb7d75a8e1c7754f17d7b2a3104964fd3ba34502d9eb8d56171b23c76f87de9805f9bbef48826edb
-  data.tar.gz: 536c50642866b57a5697d2e95f1fab76981af719e69c54538415aeb739f166562a3d67d10415f03e28b64ee9b2f10f18cf7bf7f464123c79e3704461aa932e23
+  metadata.gz: 2a82f835d9fdd3ec4a9fd131c93263fcfc99f51ac737cafb3e0fdec5d75b51b4f3280d0b0110d75f1d80d097462437bbd2a72aa754eb46a02db8459861d6a12a
+  data.tar.gz: bb44a183ec62744bfdc163e526d072ba00b543eea33098a3d2828ad58fc16aa9b0fc444a129d3b5e420707530951c44be51f88c63acacf8d4ecab114cdd645ed

data.tar.gz.sig

@@ -1,2 +1,2 @@
-=ft0���ohp����{tk
��y���ȹ����A��4�rS%�vH^f��.�akg~�,����m����T��y9g<'��yN�-D�025q!x���������1���z1��j7:]�r���Z���'���M�&X�C��L�C�]���{�˭~���~F��Oe3��
-d��b
�%���:�[Q<=w�/CF1�o]Wh
+2�ӳ�&;M����ťPY�����"��$y��J��<uVZ�Y���H>����>��%�\w�����]��	�'huQ��Ok��8JlӦ�f��&����'��[�)d�!�b�������f$��H�&rz^�;m,��
+�w	��Y��+3)G?�����jO0:��19}�,ꍤj��N<ⷈ�-ڒb�f���0�[U�?y��:,�������JG)�/>���5�J着L�2㤛S�R�6�ƥ�1�

data/lib/shaf_client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'faraday'
+require 'faraday-http-cache'
 require 'json'
-require 'shaf_client/middleware/http_cache'
 require 'shaf_client/middleware/redirect'
 require 'shaf_client/resource'
 require 'shaf_client/form'
@@ -75,20 +75,20 @@ class ShafClient
 
   def setup_client
     @adapter = options.fetch(:faraday_adapter, DEFAULT_ADAPTER)
+    cache_params = faraday_cache_params(options)
 
     @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
+      conn.use Faraday::HttpCache, **cache_params
       connect_adapter(conn)
     end
   end
 
-  def cache_options
-    options.merge(
-      accessed_by: self,
-      auth_header: auth_header
-    )
+  def faraday_cache_params(options)
+    options.fetch(:faraday_http_cache, shared_cache: false).tap do |cache_params|
+      cache_params[:store] ||= options[:http_cache_store] if options[:http_cache_store]
+    end
   end
 
   def connect_adapter(connection)
@@ -100,7 +100,6 @@ class ShafClient
   def request(method:, uri:, payload: nil, opts: {})
     payload = JSON.generate(payload) if payload&.is_a?(Hash)
     headers = default_headers(method).merge(opts.fetch(:headers, {}))
-    headers[:skip_cache] = true if opts[:skip_cache]
 
     @client.send(method) do |req|
       req.url uri

data/lib/shaf_client/resource.rb

@@ -59,7 +59,7 @@ class ShafClient
     end
 
     def reload!
-      self << get(:self, skip_cache: true)
+      self << get(:self, headers: {'Cache-Control': 'no-cache'})
     end
 
     protected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shaf_client
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Sammy Henningsson
@@ -30,7 +30,7 @@ cert_chain:
   ZMhjYR7sRczGJx+GxGU2EaR0bjRsPVlC4ywtFxoOfRG3WaJcpWGEoAoMJX6Z0bRv
   M40=
   -----END CERTIFICATE-----
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -46,6 +46,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: faraday-http-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -91,14 +105,6 @@ files:
 - lib/shaf_client/curie.rb
 - lib/shaf_client/form.rb
 - lib/shaf_client/link.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/http_cache.rb

@@ -1,93 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,84 +0,0 @@
-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

@@ -1,104 +0,0 @@
-# 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

@@ -1,186 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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