admino 0.0.1

data/spec/admino/query/group_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Group do
+      subject(:group) { Group.new(config, params) }
+      let(:config) { Configuration::Group.new(:foo, [:bar]) }
+      let(:params) { {} }
+
+      describe '#current_scope' do
+        context 'with no param' do
+          let(:params) { {} }
+
+          it 'returns the param value for the field' do
+            expect(group.current_scope).to be_nil
+          end
+        end
+
+        context 'with an invalid value' do
+          let(:params) { { 'foo' => 'qux' } }
+
+          it 'returns the param value for the field' do
+            expect(group.current_scope).to be_nil
+          end
+        end
+
+        context 'with a valid value' do
+          let(:params) { { 'foo' => 'bar' } }
+
+          it 'returns nil' do
+            expect(group.current_scope).to eq :bar
+          end
+        end
+      end
+
+      describe '#augment_scope' do
+        let(:result) { group.augment_scope(scope) }
+        let(:scope) { ScopeMock.new('original') }
+
+        context 'if the field has a value' do
+          let(:params) { { 'foo' => 'bar' } }
+
+          it 'returns the original scope chained with the group scope' do
+            expect(result.chain).to eq [:bar, []]
+          end
+        end
+
+        context 'else' do
+          it 'returns the original scope' do
+            expect(result).to eq scope
+          end
+        end
+      end
+
+      describe '#is_scope_active?' do
+        let(:params) { { 'foo' => 'bar' } }
+
+        it 'returns true if the provided scope is the one currently active' do
+          expect(group.is_scope_active?(:bar)).to be_true
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/table/head_row_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Admino
+  module Table
+    describe HeadRow do
+      subject(:row) { HeadRow.new(klass, view) }
+      let(:view) { RailsViewContext.new }
+      let(:klass) { Post }
+
+      it 'takes a class and a view context' do
+        expect(row.resource_klass).to eq klass
+        expect(row.view_context).to eq view
+      end
+
+      describe '#column' do
+        subject { row.to_html }
+
+        context 'text' do
+          context 'with label' do
+            before do
+              row.column(:title, 'This is a title')
+            end
+
+            it 'generates a label with it' do
+              should have_tag(:th, text: 'This is a title')
+            end
+          end
+
+          context 'with no label' do
+            before { row.column(:title) }
+
+            it 'generates a label with the titleized attribute name' do
+              should have_tag(:th, text: 'Title')
+            end
+          end
+
+          context 'with I18n set up' do
+            before do
+              I18n.backend.store_translations(
+                :en,
+                activemodel: { attributes: { post: { title: 'Post title' } } }
+              )
+            end
+
+            before { row.column(:title) }
+
+            it 'generates a label with the human attribute name' do
+              should have_tag(:th, text: 'Post title')
+            end
+          end
+        end
+
+        context 'role' do
+          before { row.column(:author_name) }
+
+          it 'generates a role attribute with the snake-cased name of the attribute' do
+            should have_tag(:th, with: { role: 'author-name' })
+          end
+        end
+
+        context 'with html options param' do
+          before { row.column(:title, class: 'foo') }
+
+          it 'uses it to build attributes' do
+            should have_tag(:th, with: { class: 'foo' })
+          end
+        end
+      end
+
+      describe '#actions' do
+        subject { row.to_html }
+
+        context do
+          before { row.actions }
+
+          it 'renders a th cell with role "actions"' do
+            should have_tag(:th, with: { role: 'actions' })
+          end
+
+          it 'renders a th cell with text "Actions"' do
+            should have_tag(:th, text: 'Actions')
+          end
+        end
+
+        context 'with generic I18n set up' do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              table: { actions: { title: 'Available actions' } }
+            )
+          end
+
+          it 'renders a th cell with I18n text' do
+            row.actions
+            should have_tag(:th, text: 'Available actions')
+          end
+
+          context 'and specific I18n set up' do
+            before do
+              I18n.backend.store_translations(
+                :en,
+                table: { actions: { post: { title: 'Post actions' } } }
+              )
+            end
+
+            it 'uses the specific I18n text' do
+              row.actions
+              should have_tag(:th, text: 'Post actions')
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/table/presenter_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Admino
+  module Table
+    describe Presenter do
+      subject(:presenter) { presenter_klass.new(collection, Post, view) }
+      let(:presenter_klass) { Presenter }
+      let(:view) { RailsViewContext.new }
+
+      let(:collection) { [ first_post, second_post ] }
+      let(:first_post) { Post.new('1') }
+      let(:first_post_presenter) { double('PresentedPost', dom_id: 'post_1') }
+      let(:second_post) { Post.new('2') }
+      let(:second_post_presenter) { double('PresentedPost', dom_id: 'post_2') }
+
+      let(:head_row) { double('HeadRow', to_html: '<td id="thead_td"></td>'.html_safe) }
+      let(:resource_row) { double('ResourceRow', to_html: '<td id="tbody_td"></td>'.html_safe) }
+
+      before do
+        PostPresenter.stub(:new).with(first_post, view).and_return(first_post_presenter)
+        PostPresenter.stub(:new).with(second_post, view).and_return(second_post_presenter)
+
+        HeadRow.stub(:new).with(Post, view).and_return(head_row)
+        ResourceRow.stub(:new).with(first_post_presenter, view).and_return(resource_row)
+        ResourceRow.stub(:new).with(second_post_presenter, view).and_return(resource_row)
+      end
+
+      describe '#.to_html' do
+        let(:result) { presenter.to_html }
+
+        it 'outputs a table' do
+          expect(result).to have_tag(:table)
+        end
+
+        it 'outputs a thead with a single row' do
+          expect(result).to have_tag('table thead tr')
+        end
+
+        it 'outputs a tbody with a row for each collection member' do
+          expect(result).to have_tag('table tbody tr', count: 2)
+        end
+
+        it 'adds a record idenfier to each collection row' do
+          expect(result).to have_tag('tbody tr#post_1')
+          expect(result).to have_tag('tbody tr#post_2')
+        end
+
+        it 'adds zebra classes to each collection row' do
+          expect(result).to have_tag('tbody #post_1.is-even')
+          expect(result).to have_tag('tbody #post_2.is-odd')
+        end
+
+        it 'delegates thead columns creation to .to_html HeadRow' do
+          expect(result).to have_tag('thead tr td#thead_td')
+        end
+
+        it 'delegates tbody columns creation to .to_html ResourceRow' do
+          expect(result).to have_tag('tbody tr td#tbody_td')
+        end
+
+        it 'allows passing table HTML options' do
+          expect(presenter.to_html(id: 'table')).to have_tag(:table, with: { id: 'table' })
+        end
+
+        context 'with a block' do
+          let(:block_call_args) do
+            block_call_args = []
+            presenter.to_html do |*args|
+              block_call_args << args
+            end
+            block_call_args
+          end
+
+          it 'calls it once passing the HeadRow instance' do
+            expect(block_call_args[0]).to eq [head_row, nil]
+          end
+
+          it 'calls it once for each collection member passing the ResourceRow instance and the member itself' do
+            expect(block_call_args[1]).to eq [resource_row, first_post_presenter]
+            expect(block_call_args[2]).to eq [resource_row, second_post_presenter]
+          end
+        end
+
+        context 'custom table HTML options' do
+          let(:presenter_klass) do
+            Class.new(Presenter) do
+              private
+
+              def table_html_options
+                { id: 'table' }
+              end
+
+              def thead_html_options
+                { id: 'thead' }
+              end
+
+              def thead_tr_html_options
+                { id: 'thead_tr' }
+              end
+
+              def tbody_html_options
+                { id: 'tbody' }
+              end
+
+              def tbody_tr_html_options(resource, index)
+                { class: "index-#{index}" }
+              end
+
+              def zebra_css_classes
+                %w(one two)
+              end
+            end
+          end
+
+          it "allows customizing the default table html attributes" do
+            expect(presenter.to_html).to have_tag(:table, with: { id: 'table' })
+          end
+
+          it "allows customizing the the default thead html attributes" do
+            expect(presenter.to_html).to have_tag(:thead, with: { id: 'thead' })
+          end
+
+          it "allows customizing the the default thead_tr html attributes" do
+            expect(presenter.to_html).to have_tag('thead tr#thead_tr')
+          end
+
+          it "allows customizing the the default tbody html attributes" do
+            expect(presenter.to_html).to have_tag(:tbody, with: { id: 'tbody' })
+          end
+
+          it "allows customizing the tbody_tr html attributes" do
+            expect(presenter.to_html).to have_tag(:tr, with: { id: 'post_1', class: 'index-0' })
+          end
+
+          it 'allows customizing zebra classes' do
+            expect(presenter.to_html).to have_tag(:tr, with: { id: 'post_1', class: 'one' })
+          end
+        end
+
+        context 'custom row builders' do
+          let(:presenter_klass) do
+            Class.new(Presenter) do
+              private
+
+              def head_row(*args)
+                OpenStruct.new(to_html: '<td id="custom_thead_td"></td>'.html_safe)
+              end
+
+              def resource_row(*args)
+                OpenStruct.new(to_html: '<td id="custom_tbody_td"></td>'.html_safe)
+              end
+            end
+          end
+
+          it 'allows customizing head row renderers' do
+            expect(presenter.to_html).to have_tag('thead tr td#custom_thead_td')
+          end
+
+          it 'allows customizing resource row renderers' do
+            expect(presenter.to_html).to have_tag('tbody tr td#custom_tbody_td')
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/table/resource_row_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module Admino
+  module Table
+    describe ResourceRow do
+      subject(:row) { ResourceRow.new(resource, view) }
+      let(:view) { RailsViewContext.new }
+      let(:resource) { Post.new('1') }
+
+      it 'takes a resource and a view context' do
+        expect(row.resource).to eq resource
+        expect(row.view_context).to eq view
+      end
+
+      describe '#column' do
+        subject { row.to_html }
+
+        context 'if block is present' do
+          before do
+            row.column { 'foo' }
+          end
+
+          it 'fills the cell with the block content' do
+            should have_tag(:td, text: 'foo')
+          end
+        end
+
+        context 'if attribute is present' do
+          before { row.column(:title) }
+
+          it 'fills the cell with the attribute value' do
+            should have_tag(:td, text: 'Post 1')
+          end
+        end
+
+        context 'if both attribute and block are missing' do
+          it 'raises an ArgumentError' do
+            expect { row.column('Title') }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'role attribute' do
+          before { row.column(:author_name) }
+
+          it 'generates a role attribute with the snake-cased name of the attribute' do
+            should have_tag(:td, with: { role: 'author-name' })
+          end
+        end
+
+        context 'with HTML options param' do
+          before { row.column(:title, class: 'title') }
+
+          it 'uses it to build attributes' do
+            should have_tag(:td, with: { class: 'title' })
+          end
+        end
+      end
+
+      describe '#actions' do
+        context 'block given' do
+          it 'yields the block' do
+            called = false
+            result = row.actions do
+              called = true
+            end
+
+            expect(called).to be_true
+          end
+        end
+
+        context 'no block' do
+          before do
+            row.stub(:action)
+          end
+
+          before do
+            row.actions(:show, :destroy)
+          end
+
+          it 'calls #action for each passed param' do
+            expect(row).to have_received(:action).with(:show)
+            expect(row).to have_received(:action).with(:destroy)
+          end
+        end
+      end
+
+      describe '#action' do
+        subject { row.to_html }
+
+        context 'URL' do
+          context 'with an explicit URL' do
+            before { row.action(:show, '/') }
+
+            it 'generates a link with the specified URL' do
+              should have_tag(:a, with: { href: '/' })
+            end
+          end
+
+          context 'with no explicit URL' do
+            let(:row) { row_subclass.new(resource, view) }
+            let(:row_subclass) do
+              Class.new(ResourceRow) do
+                def show_action_url
+                  "/posts/#{resource.to_param}"
+                end
+              end
+            end
+
+            before { row.action(:show) }
+
+            it 'uses a method to build the URL (ie. show_url)' do
+              should have_tag(:a, with: { href: '/posts/1' })
+            end
+          end
+
+          context 'with no explicit URL and no action name' do
+            it 'raises an ArgumentError' do
+              expect { row.action(:show) }.to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        context 'with no arguments' do
+          it 'raises an ArgumentError' do
+            expect { row.action }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'td cell' do
+          before { row.action(:show, '/') }
+
+          it 'generates a td cell with actions role' do
+            should have_tag(:td, with: { role: 'actions' })
+          end
+        end
+
+        context 'link role' do
+          before { row.action(:show, '/') }
+
+          it 'generates a link with role' do
+            should have_tag(:a, with: { role: 'show' })
+          end
+        end
+
+        context 'link text' do
+          context do
+            before { row.action(:show, '/') }
+
+            it 'generates a link with a titleized attribute' do
+              should have_tag(:a, text: 'Show')
+            end
+          end
+
+          context 'if I18n is set up' do
+            before do
+              I18n.backend.store_translations(
+                :en,
+                table: { actions: { post: { show: 'Show post' } } }
+              )
+            end
+
+            before { row.action(:show, '/') }
+
+            it 'generates a I18n text' do
+              should have_tag(:a, text: 'Show post')
+            end
+          end
+        end
+
+        context 'with html options' do
+          before { row.action(:show, '/', class: 'foo') }
+
+          it 'renders them as attributes' do
+            should have_tag(:a, with: { class: 'foo' })
+          end
+
+          context 'with a class that implements a <action_name>_html_options' do
+            let(:row) { row_subclass.new(resource, view) }
+            let(:row_subclass) do
+              Class.new(ResourceRow) do
+                def show_action_html_options
+                  { class: 'button' }
+                end
+              end
+            end
+
+            it 'renders them as attributes' do
+              should have_tag(:a, with: { class: 'foo button' })
+            end
+          end
+        end
+
+        context 'with block' do
+          before do
+            row.action { 'Foo' }
+          end
+
+          it 'renders it' do
+            should have_tag(:td, text: 'Foo')
+          end
+        end
+      end
+    end
+  end
+end
+