jahuty 1.1.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff13faee32c61d478e8fabba2b5dd1167580ecac2eb1a422fadae594ccd08658
-  data.tar.gz: d2c91dce7f2bf07882d7630165369442fc069e2e3bb642e7efb61100e3ac23a6
+  metadata.gz: 88cfffd7646bfc5849b4f45076f7dba175a65b8a5a89734e00db137dc49ee6e4
+  data.tar.gz: 85d9a607c72e94f041adc4fe22da7309f6228f6c07b50b49a1ad3f6c768be67c
 SHA512:
-  metadata.gz: 368bbb9bada206a90887549a7757449ff8d8ac4371ba3004d483f87bfcb088c7cd27ed2597ab09e90250dafdd8ac7e5174d7021f79b03efd305c00bd154d5e79
-  data.tar.gz: 8ceda7e751c0c5c6f3fce92e9274545ae02d55afd3f71f8d752ccac440056ed6cdcf7c9129d89cf46015eccb633a6ac28d08c9c9fd2975e306d4075517139024
+  metadata.gz: d0292d5ee64c8d715a9506ef3586c0bcacddacf9c5b97a384b6bc608b119152220f3eda45f6a4b35792a7aab0bfa6895db0ed747b842ab4d45d561d0bdd7a271
+  data.tar.gz: dba24f33415884a663f959c9a8ebf7b443773b88ade368d46a2c7026c8cc1ead6b60c481b4d5fb9f4e956ba6ef2d41dbdf12b20fb9a333a4e75544cdd9c00759

data/.circleci/config.yml

@@ -0,0 +1,33 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+  codecov: codecov/codecov@1.1.3
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3-stretch-node
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Update bundler
+          command: gem install bundler
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: Run rubocop
+          command: bundle exec rake rubocop
+      - run:
+          name: Run specs
+          command: |
+            bundle exec rspec --profile 10 \
+                              --format RspecJunitFormatter \
+                              --out test_results/rspec.xml \
+                              --format progress \
+                              $(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)
+      - store_test_results:
+          path: test_results
+      - codecov/upload:
+          file: ./coverage/coverage.xml

data/.rubocop.yml

@@ -0,0 +1,15 @@
+require:
+ - rubocop-performance
+ - rubocop-rspec
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+Metrics/BlockLength:
+  Exclude:
+    - 'jahuty.gemspec'
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'spec/**/*.rb'
+Metrics/ModuleLength:
+  Exclude:
+    - 'spec/**/*.rb'

data/CHANGELOG.md

@@ -5,6 +5,32 @@ 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
+
+- 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.
+
+## 3.0.0 - 2020-12-30
+
+- Change from a static-based architecture (e.g., `Jahuty::Snippet.render(1)`) to an instance-based one (e.g., `jahuty.snippets.render(1)`) to make the library easier to develop, test, and use.
+- Change `README` and fix broken links from `www.jahuty.com/docs` to `docs.jahuty.com`.
+- Add [CircleCI](https://circleci.com/gh/jahuty/jahuty-ruby) continuous integration.
+- Add [Rubocop](https://github.com/rubocop-hq/rubocop) code analyzer and formatter, based on the community style guide.
+- Add code coverage analysis with [Simplecov](https://github.com/simplecov-ruby/simplecov) and [Codecov.io](https://codecov.io/gh/jahuty/jahuty-ruby).
+
+## 2.0.0 - 2020-07-04
+
+- Change `Service::Get` to `Service::Render`.
+- Change `Snippet.get` to `Snippet.render`.
+- Change optional second argument of `Snippet.render` from `params` hash to options hash with `params` key.
+- Change `Data::Snippet` to `Data::Render`.
+- Remove `id` attribute from `Data::Render`.
+- Change API endpoint to `snippets/:id/render`.
+
+## 1.1.2 - 2020-07-04
+
+- Change the Faraday gem from `~> 0.1` to `~> 1.0`.
+
 ## 1.1.1 - 2020-03-15
 
 - Change snippet parameters to JSON query string parameter (e.g., `params={"foo":"bar"}`) from serialized query string parameter (e.g.,`params[foo]=bar`).

data/Gemfile

@@ -1,4 +1,6 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in jahuty.gemspec
 gemspec

data/README.md

@@ -1,109 +1,177 @@
+[![CircleCI](https://circleci.com/gh/jahuty/jahuty-ruby.svg?style=svg)](https://circleci.com/gh/jahuty/jahuty-ruby) [![codecov](https://codecov.io/gh/jahuty/jahuty-ruby/branch/master/graph/badge.svg?token=NLDCGGYB8S)](https://codecov.io/gh/jahuty/jahuty-ruby) [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop-hq/rubocop)
+
 # jahuty-ruby
-Welcome [Jahuty's](https://www.jahuty.com) Ruby SDK!
+
+Welcome to the [Ruby SDK](https://docs.jahuty.com/sdks/ruby) for [Jahuty's API](https://docs.jahuty.com/api)!
 
 ## Installation
 
-This library requires [Ruby 2.3+](https://www.ruby-lang.org/en/downloads/releases/).
+This library requires [Ruby 2.6+](https://www.ruby-lang.org/en/downloads/releases/).
 
 It is multi-platform, and we strive to make it run equally well on Windows, Linux, and OSX.
 
-Add this line to your application's `Gemfile`, where `x` is the latest major version number:
+To install, add this line to your application's `Gemfile` and run `bundle install`:
 
 ```ruby
-gem "jahuty", "~> x"
-```
-
-And then execute:
-
-```bash
-$ bundle
+gem 'jahuty', '~> 3.1'
 ```
 
 ## Usage
 
-Before use, the library needs to be configured with your [API key](https://www.jahuty.com/docs/api#authentication) (ideally, once during startup):
+Instantiate the client with your [API key](https://docs.jahuty.com/api#authentication) and use `snippets.render` to render your snippet:
 
 ```ruby
-require "jahuty"
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
 
-Jahuty.key = "YOUR_API_KEY"
+puts jahuty.snippets.render YOUR_SNIPPET_ID
 ```
 
-With the API key set, you can use the `get()` method to retrieve a snippet:
-
-Then, use the `.get` method to fetch a snippet:
+You can also access the render's content with `to_s` or `content`:
 
 ```ruby
-require "jahuty"
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+
+render = jahuty.snippets.render YOUR_SNIPPET_ID
 
-# retrieve the snippet
-snippet = Snippet.get YOUR_SNIPPET_ID
+a = render.to_s
 
-# convert it to a string
-snippet.to_s
+b = render.content
 
-# or, access its attributes
-snippet.id
-snippet.content
+a == b  # returns true
 ```
 
 In an HTML view:
 
 ```html+erb
-<%-
-require "jahuty"  
-
-Jahuty.key = "YOUR_API_KEY"
-%>
+<%- jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY') -%>
 <!doctype html>
 <html>
 <head>
     <title>Awesome example</title>
 </head>
 <body>
-    <%= Snippet.get YOUR_SNIPPET_ID %>
+    <%== jahuty.snippets.render YOUR_SNIPPET_ID %>
 </body>
 ```
 
 ## Parameters
 
-You can [pass parameters](https://www.jahuty.com/docs/passing-a-parameter) into your snippet with an optional second argument:
+You can [pass parameters](https://docs.jahuty.com/liquid/parameters) into your snippet using the `params` option:
 
 ```ruby
-require "jahuty"
-
-Snippet.get(YOUR_SNIPPET_ID, {
-  foo:   "bar",
-  baz:   ["qux", "quux"],
-  corge: {
-    grault: {
-      garply: "waldo"
-    }
-  }
-});
+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 variables](https://www.jahuty.com/docs/assigning-a-variable) below in your snippet:
+The parameters above would be equivalent to [assigning the variable](https://docs.jahuty.com/liquid/variables) below in your snippet:
 
 ```html
 {% assign foo = "bar" %}
-{% assign baz = ["qux", "quux"] %}
-{% assign corge.grault.garply = "waldo" %}
 ```
 
-## Errors
+## Caching
+
+You can use caching to control how frequently this library requests the latest content from Jahuty's API.
+
+* When content is in _development_ (i.e., frequently changing and low traffic), you can use the default in-memory store to view content changes instantaneously with slower response times.
+* When content is in _production_ (i.e., more stable and high traffic), you can use persistent caching to update content less frequently and improve your application's response time.
+
+### Caching in memory (default)
+
+By default, this library uses an in-memory cache to avoid requesting the same render more than once during the same request lifecycle. For example:
+
+```ruby
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+
+# This call will send a synchronous API request; cache the result in memory;
+# and, return the result to the caller.
+render1 = jahuty.snippets.render YOUR_SNIPPET_ID
+
+# This call skips sending an API request and uses the cached value instead.
+render2 = jahuty.snippets.render YOUR_SNIPPET_ID
+```
+
+The in-memory cache only persists for the duration of the original request, however. At the end of the request's lifecycle, the cache will be discarded. To store renders across requests, you need a persistent cache.
+
+### Caching persistently
+
+A persistent cache allows renders to be cached across multiple requests. This reduces the number of synchronous network requests to Jahuty's API and improves your application's average response time.
+
+To configure Jahuty to use your persistent cache, pass a cache implementation to the client via the `cache` configuration option:
+
+```ruby
+jahuty = new Jahuty::Client.new(
+  api_key: 'YOUR_API_KEY',
+  cache: cache
+)
+```
 
-If you don't set your API key before calling `Snippet.get`, a `StandardError` will be raised. If an error occurs with [Jahuty's API](https://www.jahuty.com/docs/api), a `NotOk` exception will be raised:
+The persistent cache implementation you choose and configure is up to you. There are many libraries available, and most frameworks provide their own. At this time, we support any object which responds to `get(key)`/`set(key, value, expires_in:)` or `read(key)`/`write(key, value, expires_in:)` including [ActiveSupport::Cache::Store](https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch).
+
+### Expiring
+
+There are three methods for configuring this library's `:expires_in`, the amount of time between when a render is stored and when it's considered stale. From lowest-to-highest precedence, the methods are:
+
+1. configuring your caching implementation,
+1. configuring this library's default `:expires_in`, and
+1. configuring a render's `:expires_in`.
+
+#### Configuring your caching implementation
+
+You can usually configure your caching implementation with a default `:expires_in`. If no other `:expires_in` is configured, this library will defer to the caching implementation's default `:expires_in`.
+
+#### Configuring this library's default `:expires_in`
+
+You can configure a default `:expires_in` for all of this library's renders by passing an integer number of seconds via the client's `:expires_in` configuration option:
+
+```ruby
+jahuty = Jahuty::Client.new(
+  api_key: 'YOUR_API_KEY',
+  cache: cache,
+  expires_in: 60  # <- Cache all renders for sixty seconds
+)
+```
+
+If this library's default `:expires_in` is set, it will take precedence over the default `:expires_is` 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:
 
 ```ruby
-require "jahuty"
+# Default to the caching implementation's :expires_in for all renders.
+jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY', cache: cache)
 
+# Except, cache this render for 60 seconds.
+render = jahuty.snippets.render(1, expires_in: 60)
+```
+
+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`.
+
+### 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:
+
+```ruby
+# Disable all caching.
+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)
+```
+
+## Errors
+
+If an error occurs with [Jahuty's API](https://docs.jahuty.com/api#errors), a `Jahuty::Exception::Error` will be raised:
+
+```ruby
 begin
-  Snippet.get YOUR_SNIPPET_ID
-rescue StandardError => e
-  # hmm, did you set the API key first?
-rescue Jahuty::Exception::NotOk => e
-  # hmm, the API returned something besides 2xx status code
+  jahuty = Jahuty::Client.new(api_key: 'YOUR_API_KEY')
+  jahuty.snippets.render YOUR_SNIPPET_ID
+rescue Jahuty::Exception::Error => e
+  # The API returned an error. See the error's problem for details.
   puts e.problem.type    # a URL to more information
   puts e.problem.status  # the status code
   puts e.problem.detail  # a description of the error

data/Rakefile

@@ -1,6 +1,14 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec
+
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-performance'
+  task.requires << 'rubocop-rspec'
+end

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "jahuty/snippets"
+require 'bundler/setup'
+require 'jahuty/snippets'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "jahuty/snippets"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/bin/setup

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+# frozen_string_literal: true
+
 set -euo pipefail
 IFS=$'\n\t'
 set -vx

data/jahuty.gemspec

@@ -1,30 +1,47 @@
+# frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require "jahuty"
+require 'jahuty/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "jahuty"
+  spec.name          = 'jahuty'
   spec.version       = Jahuty::VERSION
-  spec.authors       = ["Jack Clayton"]
-  spec.email         = ["jack@jahuty.com"]
+  spec.authors       = ['Jack Clayton']
+  spec.email         = ['jack@jahuty.com']
 
-  spec.summary       = %q{Jahuty's Ruby SDK.}
-  spec.description   = %q{Turn any page into a content-managed page.}
-  spec.homepage      = "https://github.com/jahuty/jahuty-ruby"
-  spec.license       = "MIT"
+  spec.summary       = 'Jahuty\'s Ruby SDK.'
+  spec.description   = 'Turn any page into a content-managed page.'
+  spec.homepage      = 'https://www.jahuty.com'
+  spec.license       = 'MIT'
 
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/jahuty/jahuty-ruby'
+  spec.metadata['changelog_uri'] = 'https://github.com/jahuty/jahuty-ruby/blob/master/CHANGELOG.md'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.6'
 
-  spec.add_dependency 'faraday', '~> 0.1'
+  spec.add_dependency 'faraday', '~> 1.0'
+  spec.add_dependency 'mini_cache', '~> 1.1'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.3"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~>0.4'
+  spec.add_development_dependency 'rubocop', '~> 1.7'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.9'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.1'
+  spec.add_development_dependency 'simplecov', '~>0.20'
+  spec.add_development_dependency 'simplecov-cobertura', '~> 1.4'
+  spec.add_development_dependency 'webmock', '~> 3.11'
 end

data/lib/jahuty.rb

@@ -1,23 +1,30 @@
-require "jahuty/version"
+# frozen_string_literal: true
 
-require "jahuty/snippet"
+require 'jahuty/version'
 
-require "jahuty/data/problem"
-require "jahuty/data/snippet"
+require 'jahuty/action/base'
+require 'jahuty/action/show'
 
-require "jahuty/exception/not_ok"
+require 'jahuty/api/client'
 
-require "jahuty/service/connect"
-require "jahuty/service/get"
+require 'jahuty/cache/facade'
+require 'jahuty/cache/manager'
 
-module Jahuty
-  @key
+require 'jahuty/exception/error'
+
+require 'jahuty/request/base'
+require 'jahuty/request/factory'
+
+require 'jahuty/resource/problem'
+require 'jahuty/resource/render'
+require 'jahuty/resource/factory'
 
-  class << self
-    attr_accessor :key
+require 'jahuty/service/base'
+require 'jahuty/service/snippet'
+require 'jahuty/service/factory'
 
-    def key?
-      !(@key.nil? || @key.empty?)
-    end
-  end
+require 'jahuty/client'
+
+module Jahuty
+  BASE_URI = 'https://api.jahuty.com'
 end

data/lib/jahuty/action/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Action
+    # Provides common logic for service actions.
+    class Base
+      attr_accessor :resource, :params
+
+      def initialize(resource:, params: {})
+        @resource = resource
+        @params   = params
+      end
+    end
+  end
+end

data/lib/jahuty/action/show.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Action
+    # Displays a specific resource.
+    class Show < Base
+      attr_accessor :id
+
+      def initialize(resource:, id:, params: {})
+        @id = id
+
+        super(resource: resource, params: params)
+      end
+    end
+  end
+end

data/lib/jahuty/api/client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Jahuty
+  module Api
+    # Handles HTTP requests and responses.
+    class Client
+      HEADERS = {
+        'Accept' => 'application/json;q=0.9,*/*;q=0.8',
+        'Accept-Encoding' => 'gzip, deflate',
+        'Content-Type' => 'application/json; charset=utf-8',
+        'User-Agent' => "Jahuty Ruby SDK v#{::Jahuty::VERSION}"
+      }.freeze
+
+      def initialize(api_key:)
+        @api_key  = api_key
+      end
+
+      def send(request)
+        @client ||= Faraday.new(url: ::Jahuty::BASE_URI, headers: headers)
+
+        @client.send(
+          request.method.to_sym,
+          request.path,
+          { params: request.params }
+        )
+      end
+
+      private
+
+      def headers
+        { 'Authorization' => "Bearer #{@api_key}" }.merge(HEADERS)
+      end
+    end
+  end
+end

data/lib/jahuty/cache/facade.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Cache
+    # Abstracts away the differences in cache implementation methods and
+    # argument lists.
+    class Facade
+      def initialize(cache)
+        @cache = cache
+      end
+
+      def delete(key)
+        if @cache.respond_to? :delete
+          @cache.delete key
+        elsif @cache.respond_to? :unset
+          @cache.unset key
+        else
+          raise NoMethodError, 'Cache must respond to :delete or :unset'
+        end
+      end
+
+      def read(key)
+        if @cache.respond_to? :read
+          @cache.read key
+        elsif @cache.respond_to? :get
+          @cache.get key
+        else
+          raise NoMethodError, 'Cache must respond to :read or :get'
+        end
+      end
+
+      def write(key, value, expires_in: nil)
+        if Object.const_defined?('::ActiveSupport::Cache::Store') &&
+           @cache.is_a?(::ActiveSupport::Cache::Store)
+          @cache.write key, value, expires_in: expires_in, race_condition_ttl: 10
+        elsif @cache.respond_to? :write
+          @cache.write key, value, expires_in: expires_in
+        elsif @cache.respond_to? :set
+          @cache.set key, value, expires_in: expires_in
+        else
+          raise NoMethodError, 'Cache must respond to :write or :set'
+        end
+      end
+    end
+  end
+end

data/lib/jahuty/cache/manager.rb

@@ -0,0 +1,47 @@
+# 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/client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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
+      @expires_in = expires_in
+      @services   = Service::Factory.new(client: self)
+    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)
+      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
+
+      request = @requests.call(action)
+
+      @client ||= Api::Client.new(api_key: @api_key)
+
+      response = @client.send(request)
+
+      @resources ||= Resource::Factory.new
+
+      resource = @resources.call(action, response)
+
+      raise Exception::Error.new(resource), 'API responded with a problem' if resource.is_a?(Resource::Problem)
+
+      resource
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @services.respond_to?(name, include_private) || super
+    end
+  end
+end

data/lib/jahuty/exception/{not_ok.rb → error.rb}

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 module Jahuty
   module Exception
-    class NotOk < ::StandardError
+    # Thrown when a client- or server-error occurs.
+    class Error < ::StandardError
       attr_reader :problem
 
       def initialize(problem)
         @problem = problem
+
+        super
       end
 
       def message

data/lib/jahuty/request/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Request
+    # Provides common logic for all requests.
+    class Base
+      attr_accessor :method, :path, :params
+
+      def initialize(method:, path:, params: {})
+        @method = method
+        @path   = path
+        @params = params
+      end
+    end
+  end
+end

data/lib/jahuty/request/factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Request
+    # Instantiates a request from an action. Currently, this is elementary. As
+    # we add actions, it will become more complicated.
+    class Factory
+      def call(action)
+        Base.new(
+          method: 'get',
+          path: "snippets/#{action.id}/render",
+          params: action.params
+        )
+      end
+    end
+  end
+end

data/lib/jahuty/resource/factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Jahuty
+  module Resource
+    # Negotiates the resource to return given the requested action and the
+    # server's response.
+    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)
+
+        payload = parse(response)
+
+        Object.const_get(resource_class).send(:new, **payload)
+      end
+
+      private
+
+      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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Resource
+    # An application/problem+json response. The API should respond with a
+    # problem whenever a client- or server-error occurs.
+    class Problem
+      attr_accessor :status, :type, :detail
+
+      def initialize(status:, type:, detail:)
+        @status = status
+        @type   = type
+        @detail = detail
+      end
+    end
+  end
+end

data/lib/jahuty/resource/render.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Resource
+    # A snippet's rendered content.
+    class Render
+      attr_accessor :content
+
+      def initialize(content:)
+        @content = content
+      end
+
+      def to_s
+        @content
+      end
+    end
+  end
+end

data/lib/jahuty/service/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Service
+    # Provides common logic to services.
+    class Base
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/jahuty/service/factory.rb

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

data/lib/jahuty/service/snippet.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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?
+
+        action = ::Jahuty::Action::Show.new(id: id, resource: 'render', params: params)
+
+        @client.fetch action, expires_in: expires_in
+      end
+    end
+  end
+end

data/lib/jahuty/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jahuty
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Jack Clayton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-15 00:00:00.000000000 Z
+date: 2021-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mini_cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,104 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
 description: Turn any page into a content-managed page.
 email:
 - jack@jahuty.com
@@ -73,8 +185,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -84,33 +198,46 @@ files:
 - bin/setup
 - jahuty.gemspec
 - lib/jahuty.rb
-- lib/jahuty/data/problem.rb
-- lib/jahuty/data/snippet.rb
-- lib/jahuty/exception/not_ok.rb
-- lib/jahuty/service/connect.rb
-- lib/jahuty/service/get.rb
-- lib/jahuty/snippet.rb
+- lib/jahuty/action/base.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
+- lib/jahuty/request/factory.rb
+- lib/jahuty/resource/factory.rb
+- lib/jahuty/resource/problem.rb
+- lib/jahuty/resource/render.rb
+- lib/jahuty/service/base.rb
+- lib/jahuty/service/factory.rb
+- lib/jahuty/service/snippet.rb
 - lib/jahuty/version.rb
-homepage: https://github.com/jahuty/jahuty-ruby
+homepage: https://www.jahuty.com
 licenses:
 - MIT
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://www.jahuty.com
+  source_code_uri: https://github.com/jahuty/jahuty-ruby
+  changelog_uri: https://github.com/jahuty/jahuty-ruby/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Jahuty's Ruby SDK.

data/lib/jahuty/data/problem.rb

@@ -1,21 +0,0 @@
-module Jahuty
-  module Data
-    class Problem
-      attr_accessor :status, :type, :detail
-
-      def initialize(status, type, detail)
-        @status = status
-        @type   = type
-        @detail = detail
-      end
-
-      def self.from(data)
-        raise ArgumentError.new "Key :status does not exist" if !data.key?(:status)
-        raise ArgumentError.new "Key :type does not exist" if !data.key?(:type)
-        raise ArgumentError.new "Key :detail does not exist" if !data.key?(:detail)
-
-        Problem.new(data[:status], data[:type], data[:detail])
-      end
-    end
-  end
-end

data/lib/jahuty/data/snippet.rb

@@ -1,23 +0,0 @@
-module Jahuty
-  module Data
-    class Snippet
-      attr_accessor :id, :content
-
-      def initialize(id, content)
-        @id      = id
-        @content = content
-      end
-
-      def self.from(data)
-        raise ArgumentError.new "Key :id does not exist" if !data.key?(:id)
-        raise ArgumentError.new "Key :content does not exist" if !data.key?(:content)
-
-        Snippet.new(data[:id], data[:content])
-      end
-
-      def to_s
-        @content
-      end
-    end
-  end
-end

data/lib/jahuty/service/connect.rb

@@ -1,23 +0,0 @@
-require "faraday"
-
-module Jahuty
-  module Service
-    class Connect
-      URL = "https://www.jahuty.com/api"
-
-      HEADERS  = {
-        "Accept":          "application/json;q=0.9,*/*;q=0.8",
-        "Accept-Encoding": "gzip, deflate",
-        "Content-Type":    "application/json; charset=utf-8",
-        "User-Agent":      "Jahuty Ruby client #{::Jahuty::VERSION}"
-      }
-
-      def call(key)
-        Faraday.new(
-          url: URL,
-          headers: {"Authorization": "Bearer #{key}"}.merge(HEADERS)
-        )
-      end
-    end
-  end
-end

data/lib/jahuty/service/get.rb

@@ -1,25 +0,0 @@
-require "json"
-
-module Jahuty
-  class Service::Get
-    @connection
-
-    def initialize(connection)
-      @connection = connection
-    end
-
-    def call(id, params = {})
-      options = { params: params.to_json } if !params.empty?
-
-      response = @connection.get("snippets/#{id}", options || {})
-
-      payload = JSON.parse(response.body, symbolize_names: true)
-
-      if response.status != 200
-        raise Exception::NotOk.new(Data::Problem.from(payload))
-      end
-
-      return Data::Snippet.from(payload)
-    end
-  end
-end

data/lib/jahuty/snippet.rb

@@ -1,15 +0,0 @@
-module Jahuty
-  class Snippet
-    @get
-
-    class << self
-      def get(id, params = {})
-        raise "API key not set. Did you use Jahuty.key?" unless Jahuty.key?
-
-        @get ||= Service::Get.new(Service::Connect.new.call(Jahuty.key))
-
-        @get.call(id, params)
-      end
-    end
-  end
-end