typekit-client 0.0.2 → 0.0.3

data/lib/typekit/helper.rb

@@ -22,6 +22,28 @@ module Typekit
       Rack::Utils.build_nested_query(prepare_parameters(parameters))
     end
 
+    def self.pluralize(name)
+      case name
+      when /^.*s$/
+        name
+      when /^(?<root>.*)y$/
+        "#{ Regexp.last_match(:root) }ies"
+      else
+        "#{ name }s"
+      end
+    end
+
+    def self.singularize(name)
+      case name
+      when /^(?<root>.*)ies$/
+        "#{ Regexp.last_match(:root) }y"
+      when /^(?<root>.*)s$/
+        Regexp.last_match(:root)
+      else
+        name
+      end
+    end
+
     private
 
     def self.prepare_parameters(parameters)

data/lib/typekit/processing/converter/boolean.rb

@@ -0,0 +1,11 @@
+module Typekit
+  module Processing
+    module Converter
+      class Boolean
+        def process(response, object)
+          object # already boolean
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter/datetime.rb

@@ -0,0 +1,11 @@
+module Typekit
+  module Processing
+    module Converter
+      class DateTime
+        def process(response, object)
+          ::DateTime.parse(object)
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter/errors.rb

@@ -0,0 +1,22 @@
+module Typekit
+  module Processing
+    module Converter
+      class Errors
+        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 => 'The servers of Typekit are unable to process the request',
+          503 => 'The Typekit API is offline for maintenance'
+        }
+        ERRORS.default = 'Unknown server error'
+        ERRORS.freeze
+
+        def process(response, errors)
+          raise Error, Array(errors || ERRORS[response.code]).join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter/record.rb

@@ -0,0 +1,15 @@
+module Typekit
+  module Processing
+    module Converter
+      class Record
+        def initialize(name)
+          @klass = Typekit::Record.const_get(name.to_s.capitalize)
+        end
+
+        def process(response, attributes)
+          @klass.new(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter/records.rb

@@ -0,0 +1,18 @@
+module Typekit
+  module Processing
+    module Converter
+      class Records
+        def initialize(name)
+          name = Helper.singularize(name.to_s).capitalize
+          @klass = Typekit::Record.const_get(name)
+        end
+
+        def process(response, attribute_collection)
+          attribute_collection.map do |attributes|
+            @klass.new(attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter/unknown.rb

@@ -0,0 +1,14 @@
+module Typekit
+  module Processing
+    module Converter
+      class Unknown
+        def initialize(name)
+        end
+
+        def process(response, object)
+          object
+        end
+      end
+    end
+  end
+end

data/lib/typekit/processing/converter.rb

@@ -0,0 +1,32 @@
+require_relative 'converter/record'
+require_relative 'converter/records'
+require_relative 'converter/boolean'
+require_relative 'converter/datetime'
+require_relative 'converter/errors'
+require_relative 'converter/unknown'
+
+module Typekit
+  module Processing
+    module Converter
+      MAPPING = {
+        'ok' => Boolean,
+        'errors' => Errors,
+        'published' => DateTime
+      }.freeze
+
+      def self.build(name)
+        if MAPPING.key?(name)
+          MAPPING[name].new
+        elsif Typekit::Record.collection?(name)
+          Records.new(name)
+        elsif Typekit::Record.member?(name)
+          Record.new(name)
+        else
+          Unknown.new(name)
+        end
+      rescue NameError
+        raise Error, 'Unknown converter'
+      end
+    end
+  end
+end

data/lib/typekit/processing/parser/json.rb

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

data/lib/typekit/processing/parser/yaml.rb

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

data/lib/typekit/processing/parser.rb

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

data/lib/typekit/processing/translator.rb

@@ -0,0 +1,16 @@
+module Typekit
+  module Processing
+    class Translator
+      def initialize(format:)
+        @parser = Parser.build(format)
+      end
+
+      def process(response)
+        data = @parser.process(response.body) rescue nil
+        data = { nil => nil } unless data.is_a?(Hash) && data.length == 1
+        name, object = *data.first
+        Converter.build(name).process(response, object)
+      end
+    end
+  end
+end

data/lib/typekit/processing.rb

@@ -0,0 +1,9 @@
+require_relative 'processing/parser'
+require_relative 'processing/converter'
+require_relative 'processing/translator'
+
+module Typekit
+  module Processing
+    Error = Class.new(Typekit::Error)
+  end
+end

data/lib/typekit/record/base.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+module Typekit
+  module Record
+    class Base
+      extend Forwardable
+
+      attr_reader :attributes
+      def_delegator :attributes, :to_json
+
+      def initialize(attributes = {})
+        @attributes = Hash[attributes.map { |k, v| [ k.to_sym, v ] }]
+      end
+
+      def method_missing(name, *arguments)
+        if name.to_s =~ /^(?<name>.*)=$/
+          name = Regexp.last_match(:name).to_sym
+          return super unless arguments.length == 1
+          return super unless @attributes.key?(name)
+          @attributes[name] = arguments.first
+        else
+          return super unless arguments.length.zero?
+          return super unless @attributes.key?(name)
+          @attributes[name]
+        end
+      end
+    end
+  end
+end
+

data/lib/typekit/record/family.rb

@@ -0,0 +1,7 @@
+module Typekit
+  module Record
+    class Family < Base
+      # has_many :libraries, :variations
+    end
+  end
+end

data/lib/typekit/record/kit.rb

@@ -0,0 +1,7 @@
+module Typekit
+  module Record
+    class Kit < Base
+      # has_many :families
+    end
+  end
+end

data/lib/typekit/record/library.rb

@@ -0,0 +1,7 @@
+module Typekit
+  module Record
+    class Library < Base
+      # has_many :families
+    end
+  end
+end

data/lib/typekit/record/variation.rb

@@ -0,0 +1,8 @@
+module Typekit
+  module Record
+    class Variation < Base
+      # belongs_to :family
+      # has_many :libraries
+    end
+  end
+end

data/lib/typekit/record.rb

@@ -0,0 +1,35 @@
+require_relative 'record/base'
+require_relative 'record/family'
+require_relative 'record/variation'
+require_relative 'record/kit'
+require_relative 'record/library'
+
+module Typekit
+  module Record
+    def self.classes
+      @classes ||= ObjectSpace.each_object(Class).select do |klass|
+        klass < Base
+      end
+    end
+
+    def self.collections
+      @collections ||= members.map(&:to_s).map do |name|
+        Helper.pluralize(name.to_s)
+      end.map(&:to_sym)
+    end
+
+    def self.members
+      @members ||= classes.map(&:to_s).map(&:downcase).map do |name|
+        name.sub(/^.*::/, '')
+      end.map(&:to_sym)
+    end
+
+    def self.collection?(name)
+      collections.include?(name.to_sym)
+    end
+
+    def self.member?(name)
+      members.include?(name.to_sym)
+    end
+  end
+end

data/lib/typekit/routing/{map.rb → mapper.rb}

@@ -2,7 +2,7 @@ require 'forwardable'
 
 module Typekit
   module Routing
-    class Map
+    class Mapper
       extend Forwardable
 
       def_delegator :@root, :assemble, :trace

data/lib/typekit/routing/node/base.rb

@@ -37,6 +37,7 @@ module Typekit
 
         def authorize(request)
           raise Error, 'Not permitted' unless permitted?(request)
+          request.sign(self)
           request
         end
       end

data/lib/typekit/routing.rb

@@ -1,6 +1,6 @@
 require_relative 'routing/node'
 require_relative 'routing/proxy'
-require_relative 'routing/map'
+require_relative 'routing/mapper'
 
 module Typekit
   module Routing

data/lib/typekit/version.rb

@@ -1,3 +1,3 @@
 module Typekit
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/typekit.rb

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

data/spec/cassettes/delete_kits_xxx_ok.yml

@@ -0,0 +1,16 @@
+---
+http_interactions:
+- request:
+    method: delete
+    uri: https://typekit.com/api/v1/json/kits/xxx
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Status:
+      - 200 OK
+    body:
+      encoding: UTF-8
+      string: '{"ok":true}'
+  recorded_at: Fri, 30 May 2014 00:00:00 GMT

data/spec/typekit/client_spec.rb

@@ -9,9 +9,9 @@ describe Typekit::Client do
     context 'when successful' do
       options = { vcr: { cassette_name: 'index_kits_ok' } }
 
-      it 'returns hashes', options do
+      it 'returns Records', options do
         result = subject.index(:kits)
-        expect(result).to be_kind_of(Hash)
+        expect(result.map(&:class).uniq).to eq([ Typekit::Record::Kit ])
       end
     end
 
@@ -20,7 +20,7 @@ describe Typekit::Client do
 
       it 'raises exceptions', options do
         expect { subject.index(:kits) }.to \
-          raise_error(Typekit::Error, /(authentication|authorized)/i)
+          raise_error(Typekit::Processing::Error, /Not authorized/i)
       end
     end
 
@@ -33,4 +33,12 @@ describe Typekit::Client do
       end
     end
   end
+
+  describe '#delete' do
+    options = { vcr: { cassette_name: 'delete_kits_xxx_ok' } }
+
+    it 'returns true', options do
+      expect(subject.delete(:kits, 'xxx')).to be(true)
+    end
+  end
 end

data/spec/typekit/configuration_spec.rb

@@ -25,10 +25,26 @@ describe Typekit::Configuration do
     end
   end
 
-  describe 'Base#map' do
-    it 'returns a Map' do
-      expect(build(:default, token: 'nekot').map).to \
-        be_kind_of(Typekit::Routing::Map)
+  describe 'Base' do
+    describe '#mapper' do
+      it 'returns a Mapper' do
+        expect(build(:default, token: 'nekot').mapper).to \
+          be_kind_of(Typekit::Routing::Mapper)
+      end
+    end
+
+    describe '#dispatcher' do
+      it 'returns a Dispatcher' do
+        expect(build(:default, token: 'nekot').dispatcher).to \
+          be_kind_of(Typekit::Connection::Dispatcher)
+      end
+    end
+
+    describe '#translator' do
+      it 'returns a Translator' do
+        expect(build(:default, token: 'nekot').translator).to \
+          be_kind_of(Typekit::Processing::Translator)
+      end
     end
   end
 end

data/spec/typekit/connection/dispatcher_spec.rb

@@ -12,14 +12,14 @@ describe Typekit::Connection::Dispatcher do
     double('Request', action: action, address: address, parameters: {})
   end
 
-  describe '#deliver' do
+  describe '#process' do
     restful_actions.each do |action|
       method = rest_http_dictionary[action]
 
       context "when sending #{ action } Requests" do
         it 'sets the token header' do
           stub = stub_http_request(method, address)
-          response = subject.deliver(create_request(action))
+          response = subject.process(create_request(action))
           expect(stub).to have_requested(method, address).
             with(:headers => { 'X-Typekit-Token' => token })
         end
@@ -27,8 +27,8 @@ describe Typekit::Connection::Dispatcher do
         it 'returns Responses' do
           stub_http_request(method, address).
             to_return(code: '200', body: 'Hej!')
-          response = subject.deliver(create_request(action))
-          expect([ response.code, response.content ]).to eq([ 200, 'Hej!' ])
+          response = subject.process(create_request(action))
+          expect([ response.code, response.body ]).to eq([ 200, 'Hej!' ])
         end
       end
     end

data/spec/typekit/connection/response_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'typekit'
+
+describe Typekit::Connection::Response do
+  let(:subject_class) { Typekit::Connection::Response }
+
+  def create(code: 200, body: '')
+    subject_class.new(code: code, body: body)
+  end
+
+  it 'is considered to be successful for HTTP OK' do
+    expect(create(code: 200)).to be_success
+  end
+
+  it 'is considered to be successful for HTTP Found' do
+    expect(create(code: 302)).to be_success
+  end
+end

data/spec/typekit/helper_spec.rb

@@ -38,6 +38,40 @@ describe Typekit::Helper do
     end
   end
 
+  describe '.pluralize' do
+    {
+      'kit' => 'kits',
+      'kits' => 'kits',
+      'family' => 'families',
+      'families' => 'families',
+      'library' => 'libraries',
+      'libraries' => 'libraries',
+      'variant' => 'variants',
+      'variants' => 'variants'
+    }.each do |k, v|
+      it "returns #{ v } for #{ k }" do
+        expect(subject_module.pluralize(k)).to eq(v)
+      end
+    end
+  end
+
+  describe '.singularize' do
+    {
+      'kit' => 'kit',
+      'kits' => 'kit',
+      'family' => 'family',
+      'families' => 'family',
+      'library' => 'library',
+      'libraries' => 'library',
+      'variant' => 'variant',
+      'variants' => 'variant'
+    }.each do |k, v|
+      it "returns #{ v } for #{ k }" do
+        expect(subject_module.singularize(k)).to eq(v)
+      end
+    end
+  end
+
   describe '.build_query' do
     it 'handels ordinary parameters' do
       queries = [

data/spec/typekit/processing/converter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'typekit'
+
+describe Typekit::Processing::Converter do
+  def create(name)
+    Typekit::Processing::Converter.build(name)
+  end
+
+  let(:request) { double(code: 200) }
+
+  describe '.build#process' do
+    %w{family kit library}.each do |name|
+      it "maps '#{ name }' to a Record" do
+        result = create(name).process(request, {})
+        expect(result).to be_kind_of(Typekit::Record::Base)
+      end
+    end
+
+    %w{families kits libraries}.each do |name|
+      it "maps '#{ name }' to an array of Records" do
+        result = create(name).process(request, [ {} ])
+        result.each { |r| expect(r).to be_kind_of(Typekit::Record::Base) }
+      end
+    end
+
+    %w{ok}.each do |name|
+      it "maps '#{ name }' to a boolean" do
+        result = create(name).process(request, true)
+        expect(result).to be_kind_of(::TrueClass)
+      end
+    end
+
+    %w{published}.each do |name|
+      it "maps '#{ name }' to a datetime" do
+        result = create(name).process(request, '2010-05-20T21:15:31Z')
+        expect(result).to be_kind_of(::DateTime)
+      end
+    end
+
+    [ nil, 'errors' ].each do |name|
+      it "raises an exception for '#{ name }'" do
+        expect { create(name).process(request, nil) }.to \
+          raise_error(Typekit::Processing::Error)
+      end
+    end
+
+    %w{kittens puppies}.each do |name|
+      it "returns unknowns like '#{ name }' as they are" do
+        result = create(name).process(request, 42)
+        expect(result).to be(42)
+      end
+    end
+  end
+end

data/spec/typekit/processing/parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'typekit'
+
+describe Typekit::Processing::Parser do
+  let(:subject_class) { Typekit::Processing::Parser }
+
+  it 'supports JSON' do
+    subject = subject_class.build(:json)
+    result = subject.process('{ "kits": [] }')
+    expect(result).to eq("kits" => [])
+  end
+
+  it 'supports YAML' do
+    subject = subject_class.build(:yaml)
+    result = subject.process("---\nkits: []")
+    expect(result).to eq("kits" => [])
+  end
+
+  it 'does not support XML' do
+    expect { subject_class.build(:xml) }.to \
+      raise_error(Typekit::Processing::Error, /Unknown format/i)
+  end
+end