typekit-client 0.0.3 → 0.0.4

data/lib/typekit/routing/node.rb

@@ -1,5 +0,0 @@
-require_relative 'node/base'
-require_relative 'node/root'
-require_relative 'node/scope'
-require_relative 'node/collection'
-require_relative 'node/operation'

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

@@ -1,46 +0,0 @@
-module Typekit
-  module Routing
-    module Node
-      class Base
-        def append(child)
-          children << child
-        end
-
-        def assemble(request, path)
-          process(request, path)
-          return authorize(request) if path.empty?
-          lookup!(path.first).assemble(request, path)
-        end
-
-        def match(name)
-        end
-
-        def process(request, path)
-        end
-
-        def permitted?(request)
-        end
-
-        protected
-
-        def children
-          @children ||= []
-        end
-
-        def lookup(name)
-          children.find { |c| c.match(name) }
-        end
-
-        def lookup!(name)
-          lookup(name) or raise Error, 'Not found'
-        end
-
-        def authorize(request)
-          raise Error, 'Not permitted' unless permitted?(request)
-          request.sign(self)
-          request
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Typekit
-  module Routing
-    module Node
-      class Collection < Base
-        def initialize(name, only: nil)
-          @name = name
-          @actions = only && Array(only) || Typekit.actions
-          unless (@actions - Typekit.actions).empty?
-            raise Error, 'Not supported'
-          end
-        end
-
-        def match(name)
-          @name == name
-        end
-
-        def process(request, path)
-          request << path.shift # @name
-          return request if path.empty?
-          request << path.shift # id
-        end
-
-        def permitted?(request)
-          return false unless @actions.include?(request.action)
-
-          id_present = request.path.last != @name
-          member_action = Helper.member_action?(request.action)
-
-          id_present == member_action
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Typekit
-  module Routing
-    module Node
-      class Operation < Base
-        def initialize(name, action:, on:, **options)
-          # TODO: how about on == :collection?
-          unless Typekit.actions.include?(action) && on == :member
-            raise Error, 'Not supported'
-          end
-          @name = name
-          @action = action
-        end
-
-        def match(name)
-          if @name.is_a?(String) && @name =~ /^:/
-            true
-          else
-            @name == name
-          end
-        end
-
-        def process(request, path)
-          request << path.shift # @name
-        end
-
-        def permitted?(request)
-          @action == request.action
-        end
-      end
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-module Typekit
-  module Routing
-    module Node
-      class Root < Base
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Typekit
-  module Routing
-    module Node
-      class Scope < Base
-        def initialize(path)
-          @path = Array(path)
-        end
-
-        def match(name)
-          !lookup(name).nil?
-        end
-
-        def process(request, path)
-          @path.each { |chunk| request << chunk }
-        end
-      end
-    end
-  end
-end

data/lib/typekit/routing/proxy.rb

@@ -1,17 +0,0 @@
-module Typekit
-  module Routing
-    class Proxy
-      def initialize(owner, **options)
-        @owner = owner
-        @options = options
-      end
-
-      def method_missing(name, *arguments, **options, &block)
-        name = :"define_#{ name }"
-        return super unless @owner.respond_to?(name)
-        # NOTE: https://bugs.ruby-lang.org/issues/9776
-        @owner.send(name, *arguments, **options, **@options, &block)
-      end
-    end
-  end
-end

data/spec/typekit/configuration_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'typekit'
-
-describe Typekit::Configuration do
-  let(:subject_module) { Typekit::Configuration }
-
-  def build(name, **options)
-    subject_module.build(name, **options)
-  end
-
-  describe '.build' do
-    it 'requies an API token to be given' do
-      expect { build(:default) }.to \
-        raise_error(subject_module::Error, /Not enough arguments/i)
-    end
-
-    it 'returns registeries of settings' do
-      expect(build(:default, token: 'nekot')).to \
-        be_kind_of(subject_module::Base)
-    end
-
-    it 'raises exceptions when encouters unknown registeries' do
-      expect { build(:awesome, token: 'nekot') }.to \
-        raise_error(subject_module::Error, /Unknown configuration/i)
-    end
-  end
-
-  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/adaptor_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'typekit'
-
-describe Typekit::Connection::Adaptor do
-  let(:address) { 'https://typekit.com/api/v1/json/kits' }
-
-  [ 'Standard' ].each do |adaptor|
-    subject { Typekit::Connection::Adaptor.const_get(adaptor).new }
-
-    describe "#{ adaptor }.process" do
-      it 'returns the code, headers, and body of the response' do
-        stub_http_request(:get, address).to_return(
-          code: '200', body: 'Hej!', headers: { 'a' => 'b' } )
-        response = subject.process(:get, address)
-        expect(response).to eq([ '200', { 'a' => [ 'b' ] }, 'Hej!' ])
-      end
-
-      it 'raises exceptions when encounters unknown methods' do
-        expect { subject.process(:smile, address) }.to \
-          raise_error(Typekit::Connection::Error, /Invalid method/i)
-      end
-    end
-  end
-end

data/spec/typekit/connection/dispatcher_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'typekit'
-
-describe Typekit::Connection::Dispatcher do
-  extend RESTHelper
-
-  let(:token) { 'arbitrary' }
-  let(:address) { 'https://typekit.com/api/v1/json/kits' }
-  let(:subject) { Typekit::Connection::Dispatcher.new(token: token) }
-
-  def create_request(action)
-    double('Request', action: action, address: address, parameters: {})
-  end
-
-  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.process(create_request(action))
-          expect(stub).to have_requested(method, address).
-            with(:headers => { 'X-Typekit-Token' => token })
-        end
-
-        it 'returns Responses' do
-          stub_http_request(method, address).
-            to_return(code: '200', body: 'Hej!')
-          response = subject.process(create_request(action))
-          expect([ response.code, response.body ]).to eq([ 200, 'Hej!' ])
-        end
-      end
-    end
-  end
-end

data/spec/typekit/connection/request_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'typekit'
-
-describe Typekit::Connection::Request do
-  subject { Typekit::Connection::Request.new(action: :show) }
-
-  describe '#address' do
-    it 'assembles the address' do
-      [ :kits, 'xxx', :families, 'yyy' ].each { |chunk| subject << chunk }
-      expect(subject.address).to eq('kits/xxx/families/yyy')
-    end
-  end
-end

data/spec/typekit/connection/response_spec.rb

@@ -1,18 +0,0 @@
-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/processing/parser_spec.rb

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

data/spec/typekit/routing/mapper_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-require 'typekit'
-
-describe Typekit::Routing::Mapper do
-  extend RESTHelper
-
-  def create_request(action)
-    # TODO: mock?
-    Typekit::Connection::Request.new(action: action)
-  end
-
-  describe '#define' do
-    it 'declares new resources' do
-      subject.define { resources(:kits) }
-      request = subject.trace(create_request(:index), [ :kits ])
-      expect(request.address).to eq('kits')
-    end
-
-    it 'declares nested resources' do
-      subject.define { resources(:kits) { resources(:families) } }
-      request = subject.trace(create_request(:show),
-        [ :kits, 'xxx', :families, 'yyy' ])
-      expect(request.address).to eq('kits/xxx/families/yyy')
-    end
-
-    it 'declares scoped resources' do
-      subject.define do
-        scope 'https://typekit.com/api' do
-          scope [ 'v1', :json ] do
-            resources(:kits) { resources(:families) }
-          end
-        end
-      end
-      request = subject.trace(create_request(:show),
-        [ :kits, 'xxx', :families, 'yyy' ])
-      expect(request.address).to eq(
-        'https://typekit.com/api/v1/json/kits/xxx/families/yyy')
-    end
-
-    it 'declares custom operations' do
-      subject.define { resources(:kits) { show(:published, on: :member) } }
-      request = subject.trace(create_request(:show),
-        [ :kits, 'xxx', :published ])
-      expect(request.address).to eq('kits/xxx/published')
-    end
-
-    it 'declares custom operations with variable names' do
-      subject.define do
-        resources :kits do
-          resources :families do
-            show ':variant', on: :member
-          end
-        end
-      end
-      request = subject.trace(create_request(:show),
-        [ :kits, 'xxx', :families, 'yyy', 'zzz' ])
-      expect(request.address).to eq('kits/xxx/families/yyy/zzz')
-    end
-  end
-
-  describe '#trace' do
-    shared_examples 'adequate resource tracer' do
-      restful_member_actions.each do |action|
-        it "assembles addresses of #{ action } Requests" do
-          request = subject.trace(create_request(action),
-            [ *subject_path, 'xxx' ])
-          expect(request.address).to eq("#{ subject_address }/xxx")
-        end
-      end
-
-      restful_collection_actions.each do |action|
-        it "assembles addresses of #{ action } Requests" do
-          request = subject.trace(create_request(action), subject_path)
-          expect(request.address).to eq(subject_address)
-        end
-      end
-
-      restful_member_actions.each do |action|
-        it "raises exceptions for #{ action } actions to collections" do
-          expect do
-            subject.trace(create_request(action), subject_path)
-          end.to raise_error(Typekit::Routing::Error, /Not permitted/i)
-        end
-      end
-
-      restful_collection_actions.each do |action|
-        it "raises exceptions for #{ action } actions to members" do
-          expect do
-            subject.trace(create_request(action), [ *subject_path, 'xxx' ])
-          end.to raise_error(Typekit::Routing::Error, /Not permitted/i)
-        end
-      end
-    end
-
-    context 'when working with plain collections' do
-      before(:each) do
-        subject.define { resources(:kits) }
-      end
-
-      let(:subject_path) { [ :kits ] }
-      let(:subject_address) { 'kits' }
-
-      it_behaves_like 'adequate resource tracer'
-    end
-
-    context 'when working with nested collections' do
-      before(:each) do
-        subject.define do
-          resources :kits do
-            resources :families
-          end
-        end
-      end
-
-      let(:subject_path) { [ :kits, 'yyy', :families ] }
-      let(:subject_address) { 'kits/yyy/families' }
-
-      it_behaves_like 'adequate resource tracer'
-    end
-
-    family_actions = [ :show, :update, :delete ]
-
-    context "when only #{ family_actions.join(', ') } are allowed" do
-      before(:each) do
-        subject.define do
-          resources :kits do
-            resources :families, only: family_actions
-          end
-        end
-      end
-
-      (restful_collection_actions - family_actions).each do |action|
-        it "raises expections for #{ action } actions" do
-          expect do
-            subject.trace(create_request(action),
-              [ :kits, 'xxx', :families ])
-          end.to raise_error(Typekit::Routing::Error, /Not permitted/i)
-        end
-      end
-
-      (restful_member_actions - family_actions).each do |action|
-        it "raises expections for #{ action } actions" do
-          expect do
-            subject.trace(create_request(action),
-              [ :kits, 'xxx', :families, 'yyy' ])
-          end.to raise_error(Typekit::Routing::Error, /Not permitted/i)
-        end
-      end
-    end
-
-    restful_actions.each do |action|
-      it "assembles addresses for custom #{ action } actions" do
-        subject.define do
-          resources :kits do
-            send(action, :havefun, on: :member)
-          end
-        end
-        request = subject.trace(create_request(action),
-          [ :kits, 'xxx', :havefun ])
-        expect(request.address).to eq('kits/xxx/havefun')
-      end
-    end
-
-    it 'does not support reopening of resource declarations' do
-      subject.define do
-        resources :kits
-        resources :kits do
-          resources :families
-        end
-      end
-      expect do
-        subject.trace(create_request(:show),
-          [ :kits, 'xxx', :families, 'yyy' ])
-      end.to raise_error(Typekit::Routing::Error, /Not found/i)
-    end
-  end
-end