jahuty 3.1.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88cfffd7646bfc5849b4f45076f7dba175a65b8a5a89734e00db137dc49ee6e4
-  data.tar.gz: 85d9a607c72e94f041adc4fe22da7309f6228f6c07b50b49a1ad3f6c768be67c
+  metadata.gz: b7f9dd15bdc516d3e7249bba915822f742642f59c7209f47151b963ba34b53d1
+  data.tar.gz: 11bb09b250f358f13d5cafb3a585a1db525ddf988b6fea70dd19c7586a5a77a3
 SHA512:
-  metadata.gz: d0292d5ee64c8d715a9506ef3586c0bcacddacf9c5b97a384b6bc608b119152220f3eda45f6a4b35792a7aab0bfa6895db0ed747b842ab4d45d561d0bdd7a271
-  data.tar.gz: dba24f33415884a663f959c9a8ebf7b443773b88ade368d46a2c7026c8cc1ead6b60c481b4d5fb9f4e956ba6ef2d41dbdf12b20fb9a333a4e75544cdd9c00759
+  metadata.gz: 42ee47a4e2e936a10c4e14bee9990db9c170e53e852d257190cf7636d8c27ce6e7f4da04eeb1cf1ea333e00f65ffc7ed1847b0a47ec4c7ea024d067ee9bca196
+  data.tar.gz: e1ec48bb180b4f81145f4a6b939bc3a9fe64a792bbb7a513b705b49e61b4ac379dfbc0c38fb12880122282d12816d90c8798ca6b283bb8fce6befe5777eb3174

data/.rubocop.yml

@@ -4,6 +4,8 @@ require:
 AllCops:
   TargetRubyVersion: 2.6
   NewCops: enable
+  Exclude:
+   - vendor/bundle/**/*
 Metrics/BlockLength:
   Exclude:
     - 'jahuty.gemspec'
@@ -13,3 +15,9 @@ Metrics/BlockLength:
 Metrics/ModuleLength:
   Exclude:
     - 'spec/**/*.rb'
+RSpec/ExampleLength:
+  Exclude:
+    - 'spec/jahuty/system_spec.rb'
+RSpec/MultipleExpectations:
+  Exclude:
+    - 'spec/jahuty/system_spec.rb'

data/CHANGELOG.md

@@ -5,7 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 3.1.0 - 2020-01-04
+## 3.3.1 - 2021-05-02
+
+### Fixed
+
+- Fixed [#19](https://github.com/jahuty/jahuty-ruby/issues/19) where renders were cached without regard for their content version.
+
+## 3.3.0 - 2021-04-29
+
+- Add the `prefer_latest` configuration option to the client and render methods. This setting allows you to render a snippet's _latest_ content instead of the default _published_ content.
+
+## 3.2.1 - 2021-03-16
+
+- Fix issue with double-enveloping the `params` query string parameter.
+- Add system tests for params, caching, problems, and collections.
+
+## 3.2.0 - 2021-03-08
+
+- Added collections to the library with `all_renders` method. This was a rather large change and required adding new objects like `Action::Show`, refactoring old ones like `Resource::Factory`, and removing some objects like `Cache::Manager` and `Service::Factory` which added unnecessary complexity.
+- Added `snippet_id` to `Resource::Render` to help keep track of a render's parent snippet.
+
+## 3.1.1 - 2021-02-26
+
+- Add support for extra, unused attributes returned by the API to support evolution.
+- Fix the `method redefined` warnings in `cache/manager_spec.rb` and `cache/facade_spec.rb`.
+- Fix the `expect { }.not_to raise_error(SpecificErrorClass)` false positives warnings in `resource/render_spec.rb`.
+
+## 3.1.0 - 2021-01-04
 
 - Add caching support for any cache implementation that supports `get/set` or `read/write` methods.
 - Default to using in-memory [mini-cache](https://github.com/derrickreimer/mini_cache) storage.

data/README.md

@@ -13,7 +13,7 @@ It is multi-platform, and we strive to make it run equally well on Windows, Linu
 To install, add this line to your application's `Gemfile` and run `bundle install`:
 
 ```ruby
-gem 'jahuty', '~> 3.1'
+gem 'jahuty', '~> 3.3'
 ```
 
 ## Usage
@@ -26,7 +26,7 @@ jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
 puts jahuty.snippets.render YOUR_SNIPPET_ID
 ```
 
-You can also access the render's content with `to_s` or `content`:
+You can access the render's content with `to_s` or `content`:
 
 ```ruby
 jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
@@ -54,9 +54,45 @@ In an HTML view:
 </body>
 ```
 
-## Parameters
+You can also use tags to render a collection of snippets with the `snippets.all_renders` method:
 
-You can [pass parameters](https://docs.jahuty.com/liquid/parameters) into your snippet using the `params` option:
+```ruby
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+
+renders = jahuty.snippets.all_renders 'YOUR_TAG'
+
+renders.each { |render| puts render }
+```
+
+## Rendering content
+
+You can use the `prefer_latest` configuration option to render a snippet's _latest_ content to your team in _development_ and its _published_ content to your customers in _production_.
+
+By default, Jahuty will render a snippet's _published_ content, the content that existed the last time someone clicked the "Publish" button, to avoid exposing your creative process to customers.
+
+To render a snippet's _latest_ content, the content that currently exists in the editor, you can use the `prefer_latest` configuration option at the library or render level:
+
+```ruby
+jahuty = Jahuty::Client.new api_key: 'YOUR_API_KEY', prefer_latest: true
+```
+
+You can also prefer the latest content (or not) for a single render:
+
+```ruby
+# Render the _published_ content for all snippets...
+jahuty = Jahuty::Client.new api_key: 'YOUR_API_KEY'
+
+# ... except, render the _latest_ content for this one.
+jahuty.snippets.render YOUR_SNIPPET_ID, prefer_latest: true
+```
+
+## Passing dynamic parameters
+
+You can use the _same_ snippet to generate _different_ content by defining [variables](https://docs.jahuty.com/liquid/variables) in your snippets and setting their values via [parameters](https://docs.jahuty.com/liquid/parameters).
+
+### Snippet parameters
+
+Use the `params` option to pass parameters into your snippet:
 
 ```ruby
 jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
@@ -64,13 +100,41 @@ jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
 jahuty.snippets.render YOUR_SNIPPET_ID, params: { foo: 'bar' }
 ```
 
-The parameters above would be equivalent to [assigning the variable](https://docs.jahuty.com/liquid/variables) below in your snippet:
+The parameters above would be equivalent to assigning the following variable in your snippet:
 
 ```html
 {% assign foo = "bar" %}
 ```
 
-## Caching
+### Collection parameters
+
+Collection parameters use a slightly different syntax.
+
+If you're rendering a collection, the first dimension of the `params` key determines the parameters' scope. Use an asterisk key (`*`) to pass the same parameters to all snippets, or use a snippet id as key to pass parameters to a specific snippet.
+
+```ruby
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+
+jahuty.snippets.all_renders 'YOUR_TAG', params: {
+  '*' => { foo: 'bar' },
+  '1' => { baz: 'qux' }
+}
+```
+
+This will pass the params `{ foo: 'bar' }` to all snippets, except for snippet `1`, which will be passed `{ foo: 'bar', baz: 'qux' }`.
+
+The two parameter lists will be merged recursively, and parameters for a specific snippet will take precedence over parameters for all snippets. For example, the parameter `foo` will be assigned the value `"bar"` for all snippets, except for snippet `1`, where it will be assigned the value `"qux"`:
+
+```ruby
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+
+jahuty.snippets.all_renders 'YOUR_TAG', params: {
+  '*' => { foo: 'bar' },
+  '1' => { foo: 'qux' }
+}
+```
+
+## Caching for performance
 
 You can use caching to control how frequently this library requests the latest content from Jahuty's API.
 
@@ -133,22 +197,44 @@ jahuty = Jahuty::Client.new(
 )
 ```
 
-If this library's default `:expires_in` is set, it will take precedence over the default `:expires_is` of the caching implementation.
+If this library's default `:expires_in` is set, it will take precedence over the default `:expires_in` of the caching implementation.
 
 #### Configuring a render's `:expires_in`
 
-You can configure a single render's `:expires_in` by passing an integer number of seconds via its `:expires_in` configuration option:
+You can configure `:expires_in` for individual renders by passing an integer number of seconds via the render method's `:expires_in` configuration option:
 
 ```ruby
-# Default to the caching implementation's :expires_in for all renders.
-jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY', cache: cache)
+# Cache all renders 300 seconds (five minutes).
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY', cache: cache, expires_in: 300)
 
 # Except, cache this render for 60 seconds.
-render = jahuty.snippets.render(1, expires_in: 60)
+render = jahuty.snippets.render YOUR_SNIPPET_ID, expires_in: 60
+
+# Except, cache the renders in this collection for 120 seconds.
+render = jahuty.snippets.all_renders 'YOUR_TAG', expires_in: 120
 ```
 
 If a render's `:expires_in` is set, it will take precedence over the library's default `:expires_in` and the caching implementation's `:expires_in`.
 
+### Caching collections
+
+By default, this library will cache each render returned by `all_renders`:
+
+```ruby
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY', cache: cache)
+
+# Sends a network request, caches each render, and returns the collection.
+jahuty.snippets.all_renders 'YOUR_TAG';
+
+# If this reder exists in the collection, the cached value will be used instead
+# of sending a network request for the latest version.
+jahuty.snippets.render YOUR_SNIPPET_ID;
+```
+
+This is a powerful feature, especially when combined with a persistent cache. Using the `all_renders` method, you can render and cache an arbitrarily large chunk of content with a single network request. Because any subsequent call to `render` a snippet in the collection will use its cached version, you can reduce the number of network requests to load your content.
+
+This method is even more powerful when combined with an asynchronous background job. When `all_renders` can be called outside your request cycle periodically, you can turn your cache into your content storage mechanism. You can render and cache dynamic content as frequently as you like without any hit to your application's response time.
+
 ### Disabling caching
 
 You can disable caching, even the default in-memory caching, by passing an `:expires_in` of zero (`0`) or a negative integer (e.g., `-1`) via any of the methods described above. For example:
@@ -159,10 +245,10 @@ jahuty1 = Jahuty::Client.new(api_key: 'YOUR_API_KEY', expires_in: 0)
 
 # Disable caching for this render.
 jahuty2 = Jahuty::Client.new(api_key: 'YOUR_API_KEY', expires_in: 60)
-jahuty2.snippets.render(1, expires_in: 0)
+jahuty2.snippets.render 1, expires_in: 0
 ```
 
-## Errors
+## Handling errors
 
 If an error occurs with [Jahuty's API](https://docs.jahuty.com/api#errors), a `Jahuty::Exception::Error` will be raised:
 

data/lib/jahuty.rb

@@ -3,12 +3,12 @@
 require 'jahuty/version'
 
 require 'jahuty/action/base'
+require 'jahuty/action/index'
 require 'jahuty/action/show'
 
 require 'jahuty/api/client'
 
 require 'jahuty/cache/facade'
-require 'jahuty/cache/manager'
 
 require 'jahuty/exception/error'
 
@@ -19,12 +19,15 @@ require 'jahuty/resource/problem'
 require 'jahuty/resource/render'
 require 'jahuty/resource/factory'
 
+require 'jahuty/response/handler'
+
 require 'jahuty/service/base'
 require 'jahuty/service/snippet'
-require 'jahuty/service/factory'
 
 require 'jahuty/client'
 
+require 'jahuty/util'
+
 module Jahuty
   BASE_URI = 'https://api.jahuty.com'
 end

data/lib/jahuty/action/index.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Action
+    # Displays a collection of resources.
+    class Index < Base
+    end
+  end
+end

data/lib/jahuty/api/client.rb

@@ -20,10 +20,11 @@ module Jahuty
       def send(request)
         @client ||= Faraday.new(url: ::Jahuty::BASE_URI, headers: headers)
 
+        # Cnvert the action's string method to Faraday's verb-based methods.
         @client.send(
           request.method.to_sym,
           request.path,
-          { params: request.params }
+          request.params
         )
       end
 

data/lib/jahuty/client.rb

@@ -5,32 +5,28 @@ require 'mini_cache'
 module Jahuty
   # Executes requests against Jahuty's API and returns resources.
   class Client
-    def initialize(api_key:, cache: nil, expires_in: nil)
-      @api_key    = api_key
-      @cache      = cache || ::MiniCache::Store.new
+    def initialize(api_key:, cache: nil, expires_in: nil, prefer_latest: false)
+      @api_key = api_key
+      @cache = Cache::Facade.new(cache || ::MiniCache::Store.new)
       @expires_in = expires_in
-      @services   = Service::Factory.new(client: self)
+      @services = {}
+      @prefer_latest = prefer_latest
     end
 
     # Allows services to be accessed as properties (e.g., jahuty.snippets).
     def method_missing(name, *args, &block)
-      if args.empty? && @services.respond_to?(name)
-        @services.send(name)
+      if args.empty? && name == :snippets
+        unless @services.key?(name)
+          @services[name] = Service::Snippet.new(
+            client: self, cache: @cache, expires_in: @expires_in, prefer_latest: @prefer_latest
+          )
+        end
+        @services[name]
       else
         super
       end
     end
 
-    def fetch(action, expires_in: nil)
-      @manager ||= Cache::Manager.new(
-        client: self,
-        cache: @cache,
-        expires_in: expires_in || @expires_in
-      )
-
-      @manager.fetch(action)
-    end
-
     def request(action)
       @requests ||= Request::Factory.new
 
@@ -40,17 +36,17 @@ module Jahuty
 
       response = @client.send(request)
 
-      @resources ||= Resource::Factory.new
+      @responses ||= Response::Handler.new
 
-      resource = @resources.call(action, response)
+      result = @responses.call(action, response)
 
-      raise Exception::Error.new(resource), 'API responded with a problem' if resource.is_a?(Resource::Problem)
+      raise Exception::Error.new(result), 'API problem' if result.is_a?(Resource::Problem)
 
-      resource
+      result
     end
 
     def respond_to_missing?(name, include_private = false)
-      @services.respond_to?(name, include_private) || super
+      name == :snippets || super
     end
   end
 end

data/lib/jahuty/request/factory.rb

@@ -2,16 +2,28 @@
 
 module Jahuty
   module Request
-    # Instantiates a request from an action. Currently, this is elementary. As
-    # we add actions, it will become more complicated.
+    # Instantiates a request from an action.
     class Factory
       def call(action)
         Base.new(
           method: 'get',
-          path: "snippets/#{action.id}/render",
+          path: path(action),
           params: action.params
         )
       end
+
+      private
+
+      def path(action)
+        case action
+        when ::Jahuty::Action::Show
+          "snippets/#{action.id}/render"
+        when ::Jahuty::Action::Index
+          'snippets/render'
+        else
+          raise ArgumentError, 'Action is not supported'
+        end
+      end
     end
   end
 end

data/lib/jahuty/resource/factory.rb

@@ -1,31 +1,20 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Jahuty
   module Resource
-    # Negotiates the resource to return given the requested action and the
-    # server's response.
+    # Instantiates and returns a resource.
     class Factory
       CLASSES = {
         problem: Problem.name,
         render: Render.name
       }.freeze
 
-      def call(action, response)
-        if success? response
-          resource_name = action.resource
-        elsif problem? response
-          resource_name = 'problem'
-        else
-          raise ArgumentError, 'Unexpected response'
-        end
-
-        resource_class = class_name(resource_name.to_sym)
+      def call(resource_name, payload)
+        klass = class_name(resource_name.to_sym)
 
-        payload = parse(response)
+        raise ArgumentError, "#{resource_name} missing" if klass.nil?
 
-        Object.const_get(resource_class).send(:new, **payload)
+        Object.const_get(klass).send(:from, **payload)
       end
 
       private
@@ -33,18 +22,6 @@ module Jahuty
       def class_name(resource_name)
         CLASSES[resource_name.to_sym]
       end
-
-      def problem?(response)
-        response.headers['Content-Type'] == 'application/problem+json'
-      end
-
-      def parse(response)
-        JSON.parse(response.body, symbolize_names: true)
-      end
-
-      def success?(response)
-        response.status.between?(200, 299)
-      end
     end
   end
 end

data/lib/jahuty/resource/problem.rb

@@ -12,6 +12,14 @@ module Jahuty
         @type   = type
         @detail = detail
       end
+
+      def self.from(data)
+        raise ArgumentError.new, 'Key :status missing' unless data.key?(:status)
+        raise ArgumentError.new, 'Key :type missing' unless data.key?(:type)
+        raise ArgumentError.new, 'Key :detail missing' unless data.key?(:detail)
+
+        Problem.new(data.slice(:status, :type, :detail))
+      end
     end
   end
 end

data/lib/jahuty/resource/render.rb

@@ -4,10 +4,18 @@ module Jahuty
   module Resource
     # A snippet's rendered content.
     class Render
-      attr_accessor :content
+      attr_accessor :content, :snippet_id
 
-      def initialize(content:)
+      def initialize(content:, snippet_id:)
         @content = content
+        @snippet_id = snippet_id
+      end
+
+      def self.from(data)
+        raise ArgumentError.new, 'Key :content missing' unless data.key?(:content)
+        raise ArgumentError.new, 'Key :snippet_id missing' unless data.key?(:snippet_id)
+
+        Render.new(data.slice(:content, :snippet_id))
       end
 
       def to_s

data/lib/jahuty/response/handler.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Jahuty
+  module Response
+    # Inspects the response and returns the appropriate resource or collection.
+    class Handler
+      def call(action, response)
+        resource_name = name_resource action, response
+
+        payload = parse response
+
+        @resources ||= ::Jahuty::Resource::Factory.new
+
+        if collection?(payload)
+          payload.map { |data| @resources.call resource_name, data }
+        elsif resource?(payload)
+          @resources.call resource_name, payload
+        else
+          raise ArgumentError, 'Action and payload mismatch'
+        end
+      end
+
+      private
+
+      def collection?(payload)
+        payload.is_a?(::Array)
+      end
+
+      def name_resource(action, response)
+        if success? response
+          action.resource
+        elsif problem? response
+          'problem'
+        else
+          raise ArgumentError, 'Unexpected response'
+        end
+      end
+
+      def parse(response)
+        JSON.parse(response.body, symbolize_names: true)
+      end
+
+      def problem?(response)
+        response.headers['Content-Type'].include?('application/problem+json') &&
+          (response.status < 200 || response.status >= 300)
+      end
+
+      def resource?(payload)
+        payload.is_a?(::Object)
+      end
+
+      def success?(response)
+        response.headers['Content-Type'].include?('application/json') &&
+          response.status.between?(200, 299)
+      end
+    end
+  end
+end

data/lib/jahuty/service/snippet.rb

@@ -4,12 +4,95 @@ module Jahuty
   module Service
     # A service for interacting with snippets.
     class Snippet < Base
-      def render(id, params: {}, expires_in: nil)
-        params = { params: params.to_json } unless params.empty?
+      def initialize(client:, cache:, expires_in: nil, prefer_latest: false)
+        super(client: client)
 
-        action = ::Jahuty::Action::Show.new(id: id, resource: 'render', params: params)
+        @cache = cache
+        @expires_in = expires_in
+        @prefer_latest = prefer_latest
+      end
+
+      def all_renders(tag, params: {}, expires_in: @expires_in, prefer_latest: @prefer_latest)
+        renders = index_renders tag: tag, params: params, prefer_latest: prefer_latest
+
+        cache_renders renders: renders, params: params, expires_in: expires_in, latest: prefer_latest
+
+        renders
+      end
+
+      def render(snippet_id, params: {}, expires_in: @expires_in, prefer_latest: @prefer_latest)
+        key = cache_key snippet_id: snippet_id, params: params, latest: prefer_latest
+
+        render = @cache.read(key)
+
+        @cache.delete key unless render.nil? || cacheable?(expires_in)
+
+        if render.nil?
+          render = show_render snippet_id: snippet_id, params: params, prefer_latest: prefer_latest
+
+          @cache.write key, render, expires_in: expires_in if cacheable?(expires_in)
+        end
+
+        render
+      end
+
+      private
+
+      def cache_key(snippet_id:, params: {}, latest: false)
+        fingerprint = Digest::MD5.new
+        fingerprint << "snippets/#{snippet_id}/render/"
+        fingerprint << params.to_json
+        fingerprint << '/latest' if latest
+
+        "jahuty_#{fingerprint.hexdigest}"
+      end
+
+      def cache_renders(renders:, params:, expires_in: @expires_in, latest: false)
+        return if renders.nil?
+
+        return unless cacheable?(expires_in)
+
+        global_params = params['*'] || {}
+
+        renders.each do |render|
+          local_params = params[render.snippet_id.to_s] || {}
+          render_params = ::Jahuty::Util.deep_merge global_params, local_params
+
+          key = cache_key snippet_id: render.snippet_id, params: render_params, latest: latest
+
+          @cache.write key, render, expires_in: expires_in
+        end
+      end
+
+      def cacheable?(expires_in)
+        expires_in.nil? || expires_in.positive?
+      end
+
+      def index_renders(tag:, params: {}, prefer_latest: false)
+        request_params = { tag: tag }
+        request_params[:params] = params.to_json unless params.empty?
+        request_params[:latest] = 1 if prefer_latest
+
+        action = ::Jahuty::Action::Index.new(
+          resource: 'render',
+          params: request_params
+        )
+
+        @client.request action
+      end
+
+      def show_render(snippet_id:, params: {}, prefer_latest: false)
+        request_params = {}
+        request_params[:params] = params.to_json unless params.empty?
+        request_params[:latest] = 1 if prefer_latest
+
+        action = ::Jahuty::Action::Show.new(
+          id: snippet_id,
+          resource: 'render',
+          params: request_params
+        )
 
-        @client.fetch action, expires_in: expires_in
+        @client.request action
       end
     end
   end

data/lib/jahuty/util.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jahuty
+  # Utility methods.
+  class Util
+    # Deeply merges two hashes like Rails.
+    #
+    # Ideally, the API and this library could use the same method to merge
+    # parameters. This library's method just needs to be deterministic and not
+    # collide distinct combinations.
+    #
+    # @see  https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+    def self.deep_merge(first_hash, other_hash, &block)
+      first_hash.merge!(other_hash) do |key, first_val, other_val|
+        if first_val.is_a?(Hash) && other_val.is_a?(Hash)
+          deep_merge(first_val, other_val, &block)
+        elsif block
+          yield(key, first_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+  end
+end

data/lib/jahuty/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jahuty
-  VERSION = '3.1.0'
+  VERSION = '3.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jahuty
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.3.1
 platform: ruby
 authors:
 - Jack Clayton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-09 00:00:00.000000000 Z
+date: 2021-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -199,10 +199,10 @@ files:
 - jahuty.gemspec
 - lib/jahuty.rb
 - lib/jahuty/action/base.rb
+- lib/jahuty/action/index.rb
 - lib/jahuty/action/show.rb
 - lib/jahuty/api/client.rb
 - lib/jahuty/cache/facade.rb
-- lib/jahuty/cache/manager.rb
 - lib/jahuty/client.rb
 - lib/jahuty/exception/error.rb
 - lib/jahuty/request/base.rb
@@ -210,9 +210,10 @@ files:
 - lib/jahuty/resource/factory.rb
 - lib/jahuty/resource/problem.rb
 - lib/jahuty/resource/render.rb
+- lib/jahuty/response/handler.rb
 - lib/jahuty/service/base.rb
-- lib/jahuty/service/factory.rb
 - lib/jahuty/service/snippet.rb
+- lib/jahuty/util.rb
 - lib/jahuty/version.rb
 homepage: https://www.jahuty.com
 licenses:
@@ -237,7 +238,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Jahuty's Ruby SDK.

data/lib/jahuty/cache/manager.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Jahuty
-  module Cache
-    # Fetches the requested action from the cache or API.
-    class Manager
-      def initialize(cache:, client:, expires_in: nil)
-        @client     = client
-        @cache      = Facade.new(cache)
-        @expires_in = expires_in
-      end
-
-      def fetch(action, expires_in: nil)
-        key   = key action
-        value = @cache.read key
-
-        @cache.delete key unless value.nil? || cacheable(expires_in)
-
-        if value.nil?
-          value = @client.request action
-          @cache.write key, value, expires_in: expires_in || @expires_in if cacheable(expires_in)
-        end
-
-        value
-      end
-
-      private
-
-      def cacheable(expires_in)
-        expires_in.nil? || expires_in.positive?
-      end
-
-      def key(action)
-        # We only build cache keys for show-render actions at this time.
-        unless action.is_a?(::Jahuty::Action::Show) && action.resource == 'render'
-          raise ArgumentError, 'Action must be show render'
-        end
-
-        fingerprint = Digest::MD5.new
-        fingerprint << "snippets/#{action.id}/render/"
-        fingerprint << action.params.to_json
-
-        "jahuty_#{fingerprint.hexdigest}"
-      end
-    end
-  end
-end

data/lib/jahuty/service/factory.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Jahuty
-  module Service
-    # Instantiates the requested service and memoizes it for subsequent
-    # requests.
-    class Factory
-      CLASSES = {
-        snippets: Snippet.name
-      }.freeze
-
-      def initialize(client:)
-        @client   = client
-        @services = {}
-      end
-
-      def method_missing(name, *args, &block)
-        if args.empty? && class_name?(name)
-          unless @services.key?(name)
-            klass   = class_name(name)
-            service = Object.const_get(klass).send(:new, client: @client)
-            @services[name] = service
-          end
-
-          @services[name]
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        class_name(name) || super
-      end
-
-      private
-
-      def class_name(service_name)
-        CLASSES[service_name]
-      end
-
-      def class_name?(service_name)
-        CLASSES.key?(service_name)
-      end
-    end
-  end
-end