cathode 0.0.1 → 0.1.0

data/app/helpers/cathode/application_helper.rb

@@ -1,4 +0,0 @@
-module Cathode
-  module ApplicationHelper
-  end
-end

data/spec/dummy/app/api/dummy_api.rb

@@ -1,4 +0,0 @@
-puts 'here'
-class DummyApi < Cathode::Base
-  resource :products, actions: [:index]
-end

data/spec/integration/api_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-def make_request(method, path, params = nil, version = '1.0.0')
-  send(method, path, params, { 'Accept-Version' => version })
-end
-
-describe 'API' do
-  context 'with the default API (all actions)' do
-    before(:all) do
-      use_api do
-        version 1.5 do
-          resource :products, actions: [:all]
-        end
-      end
-    end
-
-    let!(:products) { create_list(:product, 5) }
-
-    describe 'GET #index' do
-      subject { make_request :get, 'api/products' }
-
-      it 'responds with all records' do
-        subject
-        expect(response.body).to eq(products.to_json)
-      end
-    end
-
-    describe 'GET #show' do
-      subject { make_request :get, 'api/products/1', nil, '1.5' }
-
-      it 'responds with the record' do
-        subject
-        expect(response.body).to eq(products.first.to_json)
-      end
-    end
-
-    describe 'POST #create' do
-      subject { make_request :post, 'api/products', product: { title: 'hello', cost: 1900 } }
-
-      it 'responds with the new record' do
-        subject
-        expect(response.body).to eq(Product.new(title: 'hello', cost: 1900).to_json)
-      end
-    end
-
-    describe 'DELETE #destroy' do
-      subject { make_request :delete, 'api/products/1' }
-
-      it 'responds with success' do
-        expect(subject).to eq(200)
-      end
-    end
-  end
-
-  context 'with an access filter' do
-    subject { make_request :get, 'api/products/1' }
-
-    let!(:products) { create_list(:product, 5) }
-
-    context 'when inaccessible' do
-      before(:all) do
-        use_api do
-          resource :products do
-            action(:show) { access_filter { false } }
-          end
-        end
-      end
-
-      it 'responds with unauthorized' do
-        expect(subject).to eq(401)
-      end
-    end
-
-    context 'when accessible' do
-      before(:all) do
-        use_api do
-          resource :products do
-            action(:show) { access_filter { true } }
-          end
-        end
-      end
-
-      it 'responds with success' do
-        expect(subject).to eq(200)
-      end
-    end
-  end
-end

data/spec/lib/action_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-describe Cathode::Action do
-  describe '.create' do
-    subject { Cathode::Action.create(action, :products) }
-
-    context 'with :index' do
-      let(:action) { :index }
-
-      it 'creates a IndexAction' do
-        expect(subject.class).to eq(Cathode::IndexAction)
-      end
-    end
-
-    context 'with :show' do
-      let(:action) { :show }
-
-      it 'creates a ShowAction' do
-        expect(subject.class).to eq(Cathode::ShowAction)
-      end
-    end
-
-    context 'with :create' do
-      let(:action) { :create }
-
-      it 'creates a CreateAction' do
-        expect(subject.class).to eq(Cathode::CreateAction)
-      end
-    end
-
-    context 'with :update' do
-      let(:action) { :update }
-
-      it 'creates an UpdateAction' do
-        expect(subject.class).to eq(Cathode::UpdateAction)
-      end
-    end
-
-    context 'with :destroy' do
-      let(:action) { :destroy }
-
-      it 'creates a DestroyAction' do
-        expect(subject.class).to eq(Cathode::DestroyAction)
-      end
-    end
-  end
-
-  describe '#perform' do
-    let!(:products) { create_list(:product, 5) }
-
-    subject { Cathode::Action.create(action, :products).perform(params) }
-
-    context ':index' do
-      let(:action) { :index }
-      let(:params) { {} }
-
-      it 'sets status as ok' do
-        expect(subject[:status]).to eq(:ok)
-      end
-
-      it 'sets body as all resource records' do
-        expect(subject[:body]).to eq(Product.all)
-      end
-    end
-
-    context ':show' do
-      let(:action) { :show }
-      let(:params) { { :id => 3 } }
-
-      subject { Cathode::Action.create(action, :products, &block).perform(params) }
-
-      context 'with access filter' do
-        context 'when accessible' do
-          let(:block) { proc { access_filter(&proc { true }) } }
-
-          it 'sets status as ok' do
-            expect(subject[:status]).to eq(:ok)
-          end
-
-          it 'sets body as the record' do
-            expect(subject[:body]).to eq(products[2])
-          end
-        end
-
-        context 'when inaccessible' do
-          let(:block) { proc { access_filter(&proc { false }) } }
-
-          it 'sets status as unauthorized' do
-            expect(subject[:status]).to eq(:unauthorized)
-          end
-
-          it 'sets body as nil' do
-            expect(subject[:body]).to be_nil
-          end
-        end
-      end
-    end
-
-    context ':create' do
-      let(:action) { :create }
-      let(:params) { { :title => 'cool product' } }
-
-      it 'sets status as ok' do
-        expect(subject[:status]).to eq(:ok)
-      end
-
-      it 'sets body as the new record' do
-        expect(subject[:body].title).to eq('cool product')
-      end
-    end
-
-    context ':update' do
-      let(:action) { :update }
-      let(:params) { { :id => product.id, :title => 'cooler product' } }
-      let(:product) { create(:product, title: 'cool product') }
-
-      it 'sets status as ok' do
-        expect(subject[:status]).to eq(:ok)
-      end
-
-      it 'sets body as the updated record' do
-        expect(subject[:body].title).to eq('cooler product')
-      end
-    end
-
-    context ':destroy' do
-      let(:action) { :destroy }
-      let(:params) { { :id => product.id } }
-      let!(:product) { create(:product) }
-
-      it 'sets status as ok' do
-        expect(subject[:status]).to eq(:ok)
-      end
-
-      it 'removes the record' do
-        expect { subject }.to change { Product.count }.by(-1)
-      end
-    end
-  end
-end

data/spec/lib/base_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Cathode::Base do
-  describe '#version' do
-    subject { Cathode::Base.version 1.5 do
-      resource :products
-    end }
-
-    it 'creates a new version' do
-      expect(subject.version).to eq('1.5.0')
-    end
-
-    it 'contains the resources' do
-      expect(subject.resources.keys).to eq([:products])
-    end
-  end
-
-  describe '#resource' do
-    context 'with resource name' do
-      subject { Cathode::Base.resource(:products) }
-
-      it 'initializes version 1.0.0' do
-        subject
-        expect(Cathode::Version.all['1.0.0'].resources[:products]).to_not be_nil
-      end
-    end
-  end
-end

data/spec/lib/request_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Cathode::Request do
-
-end

data/spec/lib/resources_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe Cathode::Resource do
-  describe '.new' do
-    context 'with a nonexistent resource' do
-      subject { Cathode::Resource.new(:boxes, [:all]) }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Cathode::UnknownResourceError)
-      end
-    end
-
-    context 'with an existing resource' do
-      context 'with all methods' do
-        subject { Cathode::Resource.new(:products, actions: [:all]) }
-
-        it 'creates a controller' do
-          subject
-          expect(Cathode::ProductsController).to_not be_nil
-        end
-
-        it 'adds index, create, update, show, delete routes' do
-          subject
-          expect(Cathode::Engine.routes.recognize_path('products', method: :get)).to be_true
-          expect(Cathode::Engine.routes.recognize_path('products/1', method: :get)).to be_true
-          expect(Cathode::Engine.routes.recognize_path('products', method: :post)).to be_true
-          expect(Cathode::Engine.routes.recognize_path('products/1', method: :put)).to be_true
-          expect(Cathode::Engine.routes.recognize_path('products/1', method: :delete)).to be_true
-        end
-
-        it 'does not add the edit route' do
-          expect { Cathode::Engine.routes.recognize_path('products/1/edit', method: :get) }.to raise_error
-        end
-      end
-
-      context 'with subset of methods' do
-        subject { Cathode::Resource.new(:products, actions: [:index, :show]) }
-
-        it 'creates a controller' do
-          subject
-          expect(Cathode::ProductsController).to_not be_nil
-        end
-
-        it 'adds routes only for the defined actions' do
-          subject
-          expect(Cathode::Engine.routes.recognize_path('products', method: :get)).to be_true
-          expect(Cathode::Engine.routes.recognize_path('products/1', method: :get)).to be_true
-        end
-
-        it 'does not add the other routes' do
-          subject
-          expect { Cathode::Engine.routes.recognize_path('products/1/edit', method: :get) }.to raise_error
-          expect { Cathode::Engine.routes.recognize_path('products', method: :post) }.to raise_error
-          expect { Cathode::Engine.routes.recognize_path('products/1', method: :put) }.to raise_error
-          expect { Cathode::Engine.routes.recognize_path('products/1', method: :delete) }.to raise_error
-        end
-      end
-
-      context 'with a block action' do
-        subject { Cathode::Resource.new(:products, &block) }
-
-        context 'and plain actions' do
-          let(:block) { proc { action :index } }
-
-          it 'adds the route' do
-            subject
-            expect(Cathode::Engine.routes.recognize_path('products', method: :get)).to be_true
-          end
-
-          it 'does not add other actions' do
-            subject
-            expect { Cathode::Engine.routes.recognize_path('products', method: :post) }.to raise_error
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/versioning_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Cathode::Version do
-  describe '.new' do
-    subject { Cathode::Version.new(version, &block) }
-
-    describe 'creation of semvers with flexible version input' do
-      let(:block) { nil }
-
-      context 'with bad version number' do
-        let(:version) { 'a' }
-
-        it 'raises an error' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'with good version' do
-        context 'with integer' do
-          let(:version) { 1 }
-
-          it 'sets the semantic version' do
-            expect(subject.version).to eq('1.0.0')
-          end
-        end
-
-        context 'with float' do
-          let(:version) { 1.5 }
-
-          it 'sets the semantic version' do
-            expect(subject.version).to eq('1.5.0')
-          end
-        end
-
-        context 'with string' do
-          let(:version) { '1.5.1' }
-
-          it 'sets the semantic version' do
-            expect(subject.version).to eq('1.5.1')
-          end
-        end
-
-        context 'with prerelease' do
-          let(:version) { '1.6.0-pre' }
-
-          it 'sets the semantic version' do
-            expect(subject.version).to eq('1.6.0-pre')
-          end
-        end
-      end
-    end
-
-    describe 'creation of resources' do
-      let(:version) { 1 }
-
-      context 'with no params or block' do
-        let(:block) { proc do
-          resource :products
-        end }
-
-        it 'creates the resource' do
-          expect(Cathode::Resource).to receive(:new) do |resource, params, &block|
-            expect(resource).to eq(:products)
-            expect(params).to be_nil
-            expect(block).to be_nil
-          end
-          subject
-        end
-      end
-
-      context 'with params' do
-        let(:block) { proc do
-          resource :sales, actions: [:index, :create]
-        end }
-
-        it 'creates the resource' do
-          expect(Cathode::Resource).to receive(:new) do |resource, params, &block|
-            expect(resource).to eq(:sales)
-            expect(params).to eq(actions: [:index, :create])
-            expect(block).to be_nil
-          end
-          subject
-        end
-      end
-
-      context 'with params and block' do
-        let(:block) { proc do
-          resource :salespeople, actions: [:index] do
-            action :create
-          end
-        end }
-
-        it 'creates the resource' do
-          expect(Cathode::Resource).to receive(:new) do |resource, params, &block|
-            expect(resource).to eq(:salespeople)
-            expect(params).to eq(actions: [:index])
-            expect(block).to_not be_nil
-          end
-          subject
-        end
-      end
-    end
-  end
-end