typekit-client 0.0.2

data/lib/typekit.rb

@@ -0,0 +1,13 @@
+require_relative 'typekit/version'
+require_relative 'typekit/core'
+
+require_relative 'typekit/helper'
+require_relative 'typekit/configuration'
+
+require_relative 'typekit/connection'
+require_relative 'typekit/routing'
+
+require_relative 'typekit/parser'
+require_relative 'typekit/processor'
+
+require_relative 'typekit/client'

data/lib/typekit/client.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+
+module Typekit
+  class Client
+    extend Forwardable
+
+    def_delegators :@config, :map, :dispatcher, :processor
+    private def_delegator :dispatcher, :deliver
+    private def_delegator :processor, :process
+
+    def initialize(config: :default, **options)
+      @config = Configuration.build(config, **options)
+    end
+
+    def perform(*arguments)
+      process(deliver(trace(*arguments)))
+    end
+
+    Typekit.actions.each do |action|
+      define_method(action) do |*arguments|
+        perform(action, *arguments)
+      end
+    end
+
+    private
+
+    def prepare(action, *path)
+      parameters = path.last.is_a?(Hash) ? path.pop : {}
+      [ action.to_sym, path.flatten.map(&:to_sym), parameters ]
+    end
+
+    def trace(*arguments)
+      action, path, parameters = prepare(*arguments)
+      request = Connection::Request.new(action: action, parameters: parameters)
+      map.trace(request, path)
+    end
+  end
+end

data/lib/typekit/configuration.rb

@@ -0,0 +1,16 @@
+require_relative 'configuration/base'
+require_relative 'configuration/default'
+
+module Typekit
+  module Configuration
+    Error = Class.new(Typekit::Error)
+
+    def self.build(name, **options)
+      self.const_get(name.to_s.capitalize).new(**options)
+    rescue NameError
+      raise Error, 'Unknown configuration'
+    rescue ArgumentError => e
+      raise Error, 'Not enough arguments'
+    end
+  end
+end

data/lib/typekit/configuration/base.rb

@@ -0,0 +1,21 @@
+module Typekit
+  module Configuration
+    class Base
+      attr_reader :version, :format, :token
+
+      def initialize(version: 1, format: :json, token:)
+        @version = version
+        @format = format
+        @token = token
+      end
+
+      [ :map, :dispatcher, :processor ].each do |component|
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{ component }
+            @#{ component } ||= build_#{ component }
+          end
+        METHOD
+      end
+    end
+  end
+end

data/lib/typekit/configuration/default.rb

@@ -0,0 +1,34 @@
+module Typekit
+  module Configuration
+    class Default < Base
+      private
+
+      def build_map
+        context = [ Typekit.address, "v#{ version }", format ]
+        Routing::Map.new do
+          scope context do
+            resources :families, only: :show do
+              show ':variant', on: :member
+            end
+
+            resources :kits do
+              resources :families, only: [ :show, :update, :delete ]
+              show :published, on: :member
+              update :publish, on: :member
+            end
+
+            resources :libraries, only: [ :index, :show ]
+          end
+        end
+      end
+
+      def build_dispatcher
+        Connection::Dispatcher.new(adaptor: :standard, token: token)
+      end
+
+      def build_processor
+        Processor.new(format: format)
+      end
+    end
+  end
+end

data/lib/typekit/connection.rb

@@ -0,0 +1,10 @@
+require_relative 'connection/adaptor'
+require_relative 'connection/request'
+require_relative 'connection/response'
+require_relative 'connection/dispatcher'
+
+module Typekit
+  module Connection
+    Error = Class.new(Typekit::Error)
+  end
+end

data/lib/typekit/connection/adaptor.rb

@@ -0,0 +1,13 @@
+require_relative 'adaptor/standard'
+
+module Typekit
+  module Connection
+    module Adaptor
+      def self.build(name)
+        self.const_get(name.to_s.capitalize).new
+      rescue NameError
+        raise Error, 'Unknown connection adaptor'
+      end
+    end
+  end
+end

data/lib/typekit/connection/adaptor/standard.rb

@@ -0,0 +1,32 @@
+require 'net/https'
+require 'uri'
+
+module Typekit
+  module Connection
+    module Adaptor
+      class Standard
+        def process(method, address, parameters = {}, headers = {})
+          klass = Net::HTTP.const_get(method.to_s.capitalize)
+          request = klass.new(build_uri(address, parameters))
+          headers.each { |k, v| request[k] = v }
+          http = Net::HTTP.new(request.uri.host, request.uri.port)
+          http.use_ssl = true if address =~ /^https:/
+          response = http.request(request)
+          [ response.code, response.to_hash, response.body ]
+        rescue NameError
+          raise Error, 'Invalid method'
+        rescue SocketError
+          raise Error, 'Connection failed'
+        end
+
+        private
+
+        def build_uri(address, parameters)
+          chunks = [ address ]
+          chunks << Helper.build_query(parameters) unless parameters.empty?
+          URI(chunks.join('?'))
+        end
+      end
+    end
+  end
+end

data/lib/typekit/connection/dispatcher.rb

@@ -0,0 +1,17 @@
+module Typekit
+  module Connection
+    class Dispatcher
+      def initialize(adaptor: :standard, token:)
+        @token = token
+        @adaptor = Adaptor.build(adaptor)
+      end
+
+      def deliver(request)
+        method = Helper.translate_action(request.action)
+        code, _, body = @adaptor.process(method, request.address,
+          request.parameters, 'X-Typekit-Token' => @token)
+        Response.new(code: code.to_i, content: body)
+      end
+    end
+  end
+end

data/lib/typekit/connection/request.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+
+module Typekit
+  module Connection
+    class Request
+      extend Forwardable
+
+      attr_reader :action, :parameters, :path
+      def_delegators :@path, :<<
+
+      def initialize(action:, parameters: {})
+        @action = action
+        @parameters = parameters
+        @path = []
+      end
+
+      def address
+        # TODO: cache?
+        @path.map(&:to_s).join('/')
+      end
+    end
+  end
+end

data/lib/typekit/connection/response.rb

@@ -0,0 +1,20 @@
+module Typekit
+  module Connection
+    class Response
+      attr_reader :code, :content
+
+      def initialize(code:, content:)
+        @code = code
+        @content = content
+      end
+
+      def success?
+        @code == 200
+      end
+
+      def redirect?
+        @code == 302
+      end
+    end
+  end
+end

data/lib/typekit/core.rb

@@ -0,0 +1,16 @@
+module Typekit
+  Error = Class.new(StandardError)
+
+  @address = 'https://typekit.com/api'.freeze
+
+  @actions = [ :index, :show, :create, :update, :delete ].freeze
+  @collection_actions = [ :index, :create ].freeze
+  @member_actions = [ :show, :update, :delete ].freeze
+  @action_dictionary = { :index => :get, :show => :get,
+    :create => :post, :update => :post, :delete => :delete }.freeze
+
+  singleton_class.class_eval do
+    attr_reader :address, :actions, :collection_actions,
+      :member_actions, :action_dictionary
+  end
+end

data/lib/typekit/helper.rb

@@ -0,0 +1,43 @@
+require 'rack/utils'
+
+module Typekit
+  module Helper
+    Error = Class.new(Typekit::Error)
+
+    def self.member_action?(action)
+      if Typekit.member_actions.include?(action)
+        true
+      elsif Typekit.collection_actions.include?(action)
+        false
+      else
+        raise Error, 'Unknown action'
+      end
+    end
+
+    def self.translate_action(action)
+      Typekit.action_dictionary[action] or raise Error, 'Unknown action'
+    end
+
+    def self.build_query(parameters)
+      Rack::Utils.build_nested_query(prepare_parameters(parameters))
+    end
+
+    private
+
+    def self.prepare_parameters(parameters)
+      # PATCH: https://github.com/rack/rack/issues/557
+      Hash[
+        parameters.map do |key, value|
+          case value
+          when Integer, TrueClass, FalseClass
+            [ key, value.to_s ]
+          when Hash
+            [ key, prepare_parameters(value) ]
+          else
+            [ key, value ]
+          end
+        end
+      ]
+    end
+  end
+end

data/lib/typekit/parser.rb

@@ -0,0 +1,14 @@
+require_relative 'parser/json'
+require_relative 'parser/yaml'
+
+module Typekit
+  module Parser
+    Error = Class.new(Typekit::Error)
+
+    def self.build(format)
+      self.const_get(format.to_s.upcase).new
+    rescue NameError
+      raise Error, 'Unknown format'
+    end
+  end
+end

data/lib/typekit/parser/json.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+module Typekit
+  module Parser
+    class JSON
+      def process(data)
+        ::JSON.parse(data)
+      rescue
+        raise Error, 'Unable to parse'
+      end
+    end
+  end
+end

data/lib/typekit/parser/yaml.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+
+module Typekit
+  module Parser
+    class YAML
+      def process(data)
+        ::YAML.load(data)
+      rescue
+        raise Error, 'Unable to parse'
+      end
+    end
+  end
+end

data/lib/typekit/processor.rb

@@ -0,0 +1,38 @@
+module Typekit
+  class Processor
+    ERRORS = {
+      400 => 'There are errors in the data provided by your application',
+      401 => 'Authentication is needed to access the requested endpoint',
+      403 => 'Your application has been rate limited',
+      404 => 'You are requesting a resource that does not exist',
+      500 => 'Typekit’s servers are unable to process the request',
+      503 => 'Typekit’s API is offline for maintenance'
+    }.freeze
+
+    def initialize(format:)
+      @parser = Parser.build(format)
+    end
+
+    def process(response)
+      if response.success?
+        data = @parser.process(response.content)
+        process_success(response, data)
+      else
+        data = @parser.process(response.content) rescue {}
+        process_failure(response, data)
+      end
+    end
+
+    private
+
+    def process_success(request, data)
+      data
+    end
+
+    def process_failure(request, data)
+      return data if request.redirect?
+      message = data['errors'] || ERRORS[request.code] || 'Unknown server error'
+      raise Error, Array(message).join(', ')
+    end
+  end
+end

data/lib/typekit/routing.rb

@@ -0,0 +1,9 @@
+require_relative 'routing/node'
+require_relative 'routing/proxy'
+require_relative 'routing/map'
+
+module Typekit
+  module Routing
+    Error = Class.new(Typekit::Error)
+  end
+end

data/lib/typekit/routing/map.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+
+module Typekit
+  module Routing
+    class Map
+      extend Forwardable
+
+      def_delegator :@root, :assemble, :trace
+
+      def initialize(&block)
+        @root = Node::Root.new
+        define(&block) if block_given?
+      end
+
+      def define(&block)
+        proxy = Proxy.new(self)
+        proxy.instance_eval(&block)
+      end
+
+      def define_scope(path, parent: @root, &block)
+        child = Node::Scope.new(path)
+        parent.append(child)
+        proxy = Proxy.new(self, parent: child)
+        proxy.instance_eval(&block)
+      end
+
+      def define_resources(name, parent: @root, **options, &block)
+        child = Node::Collection.new(name, **options)
+        parent.append(child)
+        return unless block_given?
+        proxy = Proxy.new(self, parent: child)
+        proxy.instance_eval(&block)
+      end
+
+      Typekit.actions.each do |action|
+        define_method "define_#{ action }" do |name, parent:, **options|
+          child = Node::Operation.new(name, action: action, **options)
+          parent.append(child)
+        end
+      end
+    end
+  end
+end