admino 0.0.1

data/lib/admino/version.rb

@@ -0,0 +1,3 @@
+module Admino
+  VERSION = "0.0.1"
+end

data/spec/admino/query/base_presenter_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe BasePresenter do
+      subject(:presenter) { BasePresenter.new(query, view) }
+      let(:view) { RailsViewContext.new }
+      let(:query) do
+        TestQuery.new(query: { foo: 'value' })
+      end
+      let(:request_object) do
+        double(
+          'ActionDispatch::Request',
+          fullpath: '/?foo=bar'
+        )
+      end
+
+      before do
+        view.stub(:request).and_return(request_object)
+      end
+
+      describe '#form' do
+        let(:result) do
+          presenter.form do |form|
+            form.label(:foo) <<
+            form.text_field(:foo)
+          end
+        end
+
+        before do
+          I18n.backend.store_translations(
+            :en,
+            query: { attributes: { test_query: { foo: 'NAME' } } }
+          )
+        end
+
+        it 'renders a form pointing to the current URL' do
+          expect(result).to have_tag(:form, with: { action: '/?foo=bar' })
+        end
+
+        it 'renders a form with method GET' do
+          expect(result).to have_tag(:form, with: { method: 'get' })
+        end
+
+        it 'renders inputs with a query[] name prefix' do
+          expect(result).to have_tag(:input, with: { type: 'text', name: 'query[foo]' })
+        end
+
+        it 'prefills inputs with query value' do
+          expect(result).to have_tag(:input, with: { type: 'text', value: 'value' })
+        end
+
+        it 'it generates labels in the :query I18n space' do
+          expect(result).to have_tag(:label, text: 'NAME')
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/base_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Base do
+      subject(:query) { Base.new(params, config) }
+      let(:params) { {} }
+      let(:config) { nil }
+
+      it 'takes a request params' do
+        expect(query.params).to eq params
+      end
+
+      context 'with an explicit config' do
+        let(:config) { Configuration.new }
+
+        it 'uses it' do
+          expect(query.config).to eq config
+        end
+      end
+
+      context 'with a declared field' do
+        let(:config) { Configuration.new }
+        let(:field_config) { config.add_field(:field) }
+
+        before do
+          field_config
+        end
+
+        it 'returns a configured Field' do
+          field = query.field_by_name(:field)
+          expect(field.config).to eq field_config
+          expect(field.params).to eq params
+        end
+      end
+
+      context 'with a declared group' do
+        let(:config) { Configuration.new }
+        let(:group_config) { config.add_group(:group, [:one, :two]) }
+
+        before do
+          group_config
+        end
+
+        it 'returns a configured Group' do
+          group = query.group_by_name(:group)
+          expect(group.config).to eq group_config
+          expect(group.params).to eq params
+          expect(group.i18n_key).to eq :group
+        end
+      end
+
+      describe '#scope' do
+        let(:config) { Configuration.new }
+        let(:result) { query.scope(starting_scope) }
+        let(:starting_scope) { ScopeMock.new('explicit') }
+
+        describe 'starting scope' do
+          context 'with an explicit scope' do
+            it 'uses it' do
+              expect(result.name).to eq 'explicit'
+            end
+          end
+
+          context 'with no explicit scope, but a default one configured' do
+            let(:result) { query.scope }
+
+            before do
+              config.starting_scope_callable = Proc.new { |query|
+                ScopeMock.new('configured').foo(query)
+              }
+            end
+
+            before do
+              result
+            end
+
+            it 'calls it with self and uses it' do
+              expect(result.name).to eq 'configured'
+              expect(result.chain).to eq [:foo, [query]]
+            end
+          end
+
+          context 'with no scope' do
+            let(:result) { query.scope }
+
+            it 'raises a ArgumentError' do
+              expect { result }.to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        context 'with a set of fields and groups' do
+          let(:field_config) { config.add_field(:field) }
+          let(:group_config) { config.add_group(:group, [:one, :two]) }
+          let(:scope_chained_with_field) { double('scope 1') }
+          let(:final_chain) { double('scope 2') }
+
+          before do
+            field_config
+            group_config
+            query
+
+            query.field_by_name(:field).
+              stub(:augment_scope).
+              with(starting_scope).
+              and_return(scope_chained_with_field)
+
+            query.group_by_name(:group).
+              stub(:augment_scope).
+              with(scope_chained_with_field).
+              and_return(final_chain)
+          end
+
+          it 'chains them toghether' do
+            expect(result).to eq final_chain
+          end
+        end
+
+        context 'with a configured ending scope' do
+          before do
+            config.ending_scope_callable = Proc.new { |query| bar(query) }
+          end
+
+          it 'calls it with self at the end of the chain' do
+            expect(result.chain).to eq [:bar, [query]]
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/dsl_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Dsl do
+      let(:config) { TestQuery.config }
+      let(:instance) { TestQuery.new }
+
+      it 'allows #field declaration' do
+        field = config.fields.last
+        expect(field.name).to eq :starting_from
+        expect(field.coerce_to).to eq :to_date
+      end
+
+      it 'allows #group declaration' do
+        group = config.groups.first
+        expect(group.name).to eq :bar
+        expect(group.scopes).to eq [:one, :two]
+      end
+
+      it 'allows #starting_scope block declaration' do
+        expect(config.starting_scope_callable.call).to eq 'start'
+      end
+
+      it 'allows #ending_scope block declaration' do
+        expect(config.ending_scope_callable.call).to eq 'end'
+      end
+
+      context 'with a field' do
+        let(:field) { double('Field', value: 'value') }
+
+        before do
+          instance.stub(:field_by_name).
+            with(:foo).
+            and_return(field)
+        end
+
+        it 'it generates a getter' do
+          expect(instance.foo).to eq 'value'
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/field_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Field do
+      subject(:field) { Field.new(config, params) }
+      let(:config) { Configuration::Field.new(:foo) }
+      let(:params) { {} }
+
+      describe '#value' do
+        context 'with a value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the param value for the field' do
+            expect(field.value).to eq 'bar'
+          end
+        end
+
+        context 'else' do
+          it 'returns nil' do
+            expect(field.value).to be_nil
+          end
+        end
+
+        context 'with coertion' do
+          let(:config) {
+            Configuration::Field.new(:foo, coerce: :to_date)
+          }
+
+          context 'with a possible coertion' do
+            let(:params) { { 'query' => { 'foo' => '2014-10-05' } } }
+
+            it 'returns the coerced param value for the field' do
+              expect(field.value).to be_a Date
+            end
+          end
+
+          context 'with a possible coertion' do
+            let(:params) { { 'query' => { 'foo' => '' } } }
+
+            it 'returns nil' do
+              expect(field.value).to be_nil
+            end
+          end
+        end
+      end
+
+      describe '#augment_scope' do
+        let(:result) { field.augment_scope(scope) }
+        let(:scope) { ScopeMock.new('original') }
+
+        context 'if the field has a value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the original scope chained with the field scope' do
+            expect(result.chain).to eq [:foo, ['bar']]
+          end
+        end
+
+        context 'else' do
+          it 'returns the original scope' do
+            expect(result).to eq scope
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/group_presenter_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe GroupPresenter do
+      subject(:presenter) { GroupPresenter.new(group, view) }
+      let(:view) { RailsViewContext.new }
+      let(:group) do
+        double(
+          'Group',
+          query_i18n_key: :query_name,
+          i18n_key: :group,
+          param_name: :group
+        )
+      end
+      let(:request_object) do
+        double(
+          'ActionDispatch::Request',
+          query_parameters: { 'group' => 'bar' },
+          path: '/'
+        )
+      end
+
+      before do
+        view.stub(:request).and_return(request_object)
+      end
+
+      describe '#scope_link' do
+        before do
+          group.stub(:is_scope_active?).with(:foo).and_return(true)
+        end
+
+        context 'active CSS class' do
+          it 'adds an is-active class' do
+            expect(presenter.scope_link(:foo)).to have_tag(:a, with: { class: 'is-active' })
+          end
+
+          context 'if an :active_class option is specified' do
+            it 'adds it' do
+              expect(presenter.scope_link(:foo, active_class: 'active')).to have_tag(:a, with: { class: 'active' })
+            end
+          end
+
+          context 'else' do
+            before do
+              group.stub(:is_scope_active?).with(:foo).and_return(false)
+            end
+
+            it 'does not add it' do
+              expect(presenter.scope_link(:foo)).not_to have_tag(:a, with: { class: 'is-active' })
+            end
+          end
+        end
+
+        context 'label' do
+          before do
+            presenter.stub(:scope_name).with(:foo).and_return('scope_name')
+          end
+
+          it 'uses #scope_name method' do
+            expect(presenter.scope_link(:foo)).to have_tag(:a, text: 'scope_name')
+          end
+
+          context 'if a second parameter is supplied' do
+            it 'uses it' do
+              expect(presenter.scope_link(:foo, 'test')).to have_tag(:a, text: 'test')
+            end
+          end
+        end
+
+        context 'URL' do
+          before do
+            presenter.stub(:scope_path).with(:foo).and_return('URL')
+          end
+
+          it 'uses #scope_path method' do
+            expect(presenter.scope_link(:foo)).to have_tag(:a, href: 'URL')
+          end
+        end
+      end
+
+      describe '#scope_params' do
+        context 'if scope is nil' do
+          it 'deletes the group param' do
+            expect(presenter.scope_params(nil)).not_to have_key 'group'
+          end
+        end
+
+        context 'else' do
+          it 'deletes the group param' do
+            expect(presenter.scope_params(:bar)[:group]).to eq 'bar'
+          end
+        end
+      end
+
+      describe '#name' do
+        context do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              query: { groups: { query_name: { group: { name: 'NAME' } } } }
+            )
+          end
+
+          it 'returns a I18n translatable name for the group' do
+            expect(presenter.name).to eq 'NAME'
+          end
+        end
+
+        context 'if no translation is available' do
+          it 'falls back to a titleized version of the group name' do
+            expect(presenter.name).to eq 'Group'
+          end
+        end
+      end
+
+      describe '#scope_name' do
+        context do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              query: { groups: { query_name: { group: { scopes: { bar: 'NAME' } } } } }
+            )
+          end
+
+          it 'returns a I18n translatable name for the scope' do
+            expect(presenter.scope_name(:bar)).to eq 'NAME'
+          end
+        end
+
+        context 'if no translation is available' do
+          it 'falls back to a titleized version of the scope name' do
+            expect(presenter.scope_name(:bar)).to eq 'Bar'
+          end
+        end
+      end
+    end
+  end
+end
+