jahuty 2.1.0 → 3.2.1

data/lib/jahuty.rb

@@ -1,23 +1,33 @@
-require "jahuty/version"
+# frozen_string_literal: true
 
-require "jahuty/snippet"
+require 'jahuty/version'
 
-require "jahuty/data/problem"
-require "jahuty/data/render"
+require 'jahuty/action/base'
+require 'jahuty/action/index'
+require 'jahuty/action/show'
 
-require "jahuty/exception/not_ok"
+require 'jahuty/api/client'
 
-require "jahuty/service/connect"
-require "jahuty/service/render"
+require 'jahuty/cache/facade'
 
-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'
+
+require 'jahuty/response/handler'
 
-  class << self
-    attr_accessor :key
+require 'jahuty/service/base'
+require 'jahuty/service/snippet'
 
-    def key?
-      !(@key.nil? || @key.empty?)
-    end
-  end
+require 'jahuty/client'
+
+require 'jahuty/util'
+
+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/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/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,38 @@
+# 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)
+
+        # Cnvert the action's string method to Faraday's verb-based methods.
+        @client.send(
+          request.method.to_sym,
+          request.path,
+          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/client.rb

@@ -0,0 +1,51 @@
+# 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::Facade.new(cache || ::MiniCache::Store.new)
+      @expires_in = expires_in
+      @services   = {}
+    end
+
+    # Allows services to be accessed as properties (e.g., jahuty.snippets).
+    def method_missing(name, *args, &block)
+      if args.empty? && name == :snippets
+        unless @services.key?(name)
+          @services[name] = Service::Snippet.new(
+            client: self, cache: @cache, expires_in: @expires_in
+          )
+        end
+        @services[name]
+      else
+        super
+      end
+    end
+
+    def request(action)
+      @requests ||= Request::Factory.new
+
+      request = @requests.call(action)
+
+      @client ||= Api::Client.new(api_key: @api_key)
+
+      response = @client.send(request)
+
+      @responses ||= Response::Handler.new
+
+      result = @responses.call(action, response)
+
+      raise Exception::Error.new(result), 'API problem' if result.is_a?(Resource::Problem)
+
+      result
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name == :snippets || 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,29 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Request
+    # Instantiates a request from an action.
+    class Factory
+      def call(action)
+        Base.new(
+          method: 'get',
+          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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Resource
+    # Instantiates and returns a resource.
+    class Factory
+      CLASSES = {
+        problem: Problem.name,
+        render: Render.name
+      }.freeze
+
+      def call(resource_name, payload)
+        klass = class_name(resource_name.to_sym)
+
+        raise ArgumentError, "#{resource_name} missing" if klass.nil?
+
+        Object.const_get(klass).send(:from, **payload)
+      end
+
+      private
+
+      def class_name(resource_name)
+        CLASSES[resource_name.to_sym]
+      end
+    end
+  end
+end

data/lib/jahuty/resource/problem.rb

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jahuty
+  module Resource
+    # A snippet's rendered content.
+    class Render
+      attr_accessor :content, :snippet_id
+
+      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
+        @content
+      end
+    end
+  end
+end

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?(action, payload)
+          payload.map { |data| @resources.call resource_name, data }
+        elsif resource?(action, payload)
+          @resources.call resource_name, payload
+        else
+          raise ArgumentError, 'Action and payload mismatch'
+        end
+      end
+
+      private
+
+      def collection?(action, payload)
+        action.is_a?(Action::Index) && 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?(action, payload)
+        !action.is_a?(Action::Index) && payload.is_a?(::Object)
+      end
+
+      def success?(response)
+        response.headers['Content-Type'].include?('application/json') &&
+          response.status.between?(200, 299)
+      end
+    end
+  end
+end