gestart-admino 1.0.0

data/lib/admino/query/sorting_presenter.rb

@@ -0,0 +1,60 @@
+require 'showcase'
+require 'active_support/core_ext/object/deep_dup'
+
+module Admino
+  module Query
+    class SortingPresenter < Showcase::Presenter
+      def scope_link(scope, *args)
+        options = args.extract_options!
+
+        label = args.first || scope_name(scope)
+
+        desc_class = options.delete(:desc_class) { 'is-desc' }
+        asc_class = options.delete(:asc_class) { 'is-asc' }
+
+        options = Showcase::Helpers::HtmlOptions.new(options)
+
+        if is_scope_active?(scope)
+          options.add_class!(ascending? ? asc_class : desc_class)
+        end
+
+        h.link_to label, scope_path(scope), options.to_h
+      end
+
+      def scope_path(scope)
+        h.request.path + "?" + scope_params(scope).to_query
+      end
+
+      def scopes
+        @scopes ||= super.map do |scope|
+          ScopePresenter.new(scope, self, view_context)
+        end
+      end
+
+      def scope_params(scope)
+        params = ActiveSupport::HashWithIndifferentAccess.new(
+          h.request.query_parameters.deep_dup
+        )
+
+        if is_scope_active?(scope)
+          params.merge!(sorting: scope.to_s, sort_order: ascending? ? 'desc' : 'asc')
+        elsif default_scope == scope
+          params.merge!(sorting: scope.to_s, sort_order: default_direction.to_s)
+        else
+          params.merge!(sorting: scope.to_s, sort_order: 'asc')
+        end
+
+        params
+      end
+
+      def scope_name(scope)
+        I18n.t(
+          :"#{query_i18n_key}.#{scope}",
+          scope: 'query.sorting_scopes',
+          default: scope.to_s.titleize.capitalize
+        )
+      end
+    end
+  end
+end
+

data/lib/admino/query.rb

@@ -0,0 +1,15 @@
+require 'admino/query/base'
+require 'admino/query/base_presenter'
+require 'admino/query/configuration'
+require 'admino/query/search_field'
+require 'admino/query/filter_group'
+require 'admino/query/filter_group_presenter'
+require 'admino/query/sorting'
+require 'admino/query/sorting_presenter'
+require 'admino/query/scope_presenter'
+
+module Admino
+  module Query
+  end
+end
+

data/lib/admino/table/head_row.rb

@@ -0,0 +1,86 @@
+require 'admino/table/row'
+require 'showcase/helpers/html_options'
+
+module Admino
+  module Table
+    class HeadRow < Row
+      attr_reader :resource_klass
+      attr_reader :query
+
+      def initialize(resource_klass, query, view_context)
+        @resource_klass = resource_klass
+        @query = query
+        @columns = +""
+
+        super(view_context)
+      end
+
+      def actions(*args, &block)
+        default_options = column_html_options(:actions)
+        label = I18n.t(
+          :"#{resource_klass.model_name.i18n_key}.title",
+          scope: 'table.actions',
+          default: [
+            :title,
+            'Actions'
+          ]
+        )
+
+        @columns << h.content_tag(:th, label.to_s, default_options)
+      end
+
+      def column(*args, &block)
+        attribute_name, label, html_options = parse_column_args(args)
+
+        if label.nil?
+          label = column_label(attribute_name)
+        elsif label.is_a? Symbol
+          label = column_label(label)
+        end
+
+        html_options = complete_column_html_options(
+          attribute_name,
+          html_options
+        )
+
+        sorting_scope = html_options.delete(:sorting)
+        sorting_html_options = html_options.delete(:sorting_html_options) { {} }
+
+        if sorting_scope
+          raise ArgumentError, 'query object is required' unless query
+          label = query.sorting.scope_link(sorting_scope, label, sorting_html_options)
+        end
+
+        @columns << h.content_tag(:th, label.to_s, html_options)
+      end
+
+      def to_html
+        @columns.html_safe
+      end
+
+      private
+
+      def column_label(attribute_name)
+        if attribute_name
+          resource_klass.human_attribute_name(attribute_name.to_s)
+        end
+      end
+
+      def complete_column_html_options(attribute_name, final_html_options)
+        if attribute_name.nil?
+          return final_html_options
+        end
+
+        default_options = column_html_options(attribute_name)
+        html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+        html_options.merge_attrs!(final_html_options)
+        html_options = html_options.to_h
+      end
+
+      def column_html_options(attribute_name)
+        { role: attribute_name.to_s.gsub(/_/, '-') }
+      end
+    end
+  end
+end
+

data/lib/admino/table/presenter.rb

@@ -0,0 +1,122 @@
+require 'showcase'
+require 'admino/table/head_row'
+require 'admino/table/resource_row'
+
+module Admino
+  module Table
+    class Presenter < Showcase::Presenter
+      attr_reader :collection_klass
+      attr_reader :query
+
+      def self.tag_helper(name, tag, options = {})
+        options_method = :"#{name}_html_options"
+
+        define_method :"#{name}_tag" do |*args, &block|
+          options = args.extract_options!
+          if respond_to?(options_method, true)
+            default_options = send(options_method, *args)
+            html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+            html_options.merge_attrs!(options)
+            options = html_options.to_h
+          end
+          h.content_tag(tag, options, &block)
+        end
+      end
+
+      tag_helper :table,    :table
+      tag_helper :thead,    :thead
+      tag_helper :thead_tr, :tr
+      tag_helper :tbody,    :tbody
+      tag_helper :tbody_tr, :tr, params: %w(resource index)
+
+      def initialize(*args)
+        context = args.pop
+        collection = args.shift
+
+        @collection_klass = args.shift
+
+        if !@collection_klass && !collection.empty?
+          @collection_klass = collection.first.class
+        end
+
+        @query = args.shift
+
+        super(collection, context)
+      end
+
+      def to_html(options = {}, &block)
+
+        if @collection_klass.nil?
+          raise ArgumentError, 'collection is empty and no explicit class is specified'
+        end
+
+        table_tag(options) do
+          thead_tag do
+            thead_tr_tag do
+              th_tags(&block)
+            end
+          end <<
+          tbody_tag do
+            tbody_tr_tags(&block)
+          end
+        end
+      end
+
+      private
+
+      def tbody_tr_tags(&block)
+        collection.each_with_index.map do |resource, index|
+          html_options = base_tbody_tr_html_options(resource, index)
+          tbody_tr_tag(resource, index, html_options) do
+            td_tags(resource, &block)
+          end
+        end.join.html_safe
+      end
+
+      def th_tags(&block)
+        row = head_row(collection_klass, query, view_context)
+        if block_given?
+          h.capture(row, nil, &block)
+        end
+        row.to_html
+      end
+
+      def td_tags(resource, &block)
+        row = resource_row(resource, view_context)
+        if block_given?
+          h.capture(row, resource, &block)
+        end
+        row.to_html
+      end
+
+      def collection
+        object
+      end
+
+      def head_row(collection_klass, query, view_context)
+        HeadRow.new(collection_klass, query, view_context)
+      end
+
+      def resource_row(resource, view_context)
+        ResourceRow.new(resource, view_context)
+      end
+
+      def base_tbody_tr_html_options(resource, index)
+        options = {
+          class: zebra_css_classes[index % zebra_css_classes.size]
+        }
+
+        if resource.respond_to?(:dom_id)
+          options[:id] = resource.dom_id
+        end
+
+        options
+      end
+
+      def zebra_css_classes
+        %w(is-even is-odd)
+      end
+    end
+  end
+end
+

data/lib/admino/table/resource_row.rb

@@ -0,0 +1,145 @@
+require 'admino/table/row'
+require 'showcase/helpers/html_options'
+
+module Admino
+  module Table
+    class ResourceRow < Row
+      attr_reader :resource
+
+      def initialize(resource, view_context)
+        @resource = resource
+        @columns = +""
+        @actions = []
+
+        super(view_context)
+      end
+
+      def column(*args, &block)
+        attribute_name, label, html_options = parse_column_args(args)
+
+        html_options = complete_column_html_options(
+          attribute_name,
+          html_options
+        )
+
+        if block_given?
+          content = h.capture(resource, &block)
+        elsif attribute_name.present?
+          content = resource.send(attribute_name)
+        else
+          raise ArgumentError, 'attribute name or block required'
+        end
+
+        @columns << h.content_tag(:td, content, html_options)
+      end
+
+      def actions(*actions, &block)
+        if block_given?
+          h.capture(&block)
+        else
+          actions.each do |action|
+            action(action)
+          end
+        end
+      end
+
+      def action(*args, &block)
+        if block_given?
+          @actions << h.capture(resource, &block)
+        else
+          action_name, url, label, html_options = parse_action_args(args)
+
+          label ||= action_label(action_name)
+          url ||= action_url(action_name)
+          html_options = complete_action_html_options(
+            action_name,
+            html_options
+          )
+
+          @actions << h.link_to(label, url, html_options)
+        end
+      end
+
+      def to_html
+        buffer = @columns
+
+        if @actions.any?
+          html_options = column_html_options(:actions)
+          buffer << h.content_tag(:td, html_options) do
+            @actions.join(" ").html_safe
+          end
+        end
+
+        buffer.html_safe
+      end
+
+      private
+
+      def action_url(action_name)
+        if action_name.nil?
+          raise ArgumentError,
+                'no URL provided, action name required'
+        end
+
+        action_url_method = "#{action_name}_action_url"
+
+        if !respond_to?(action_url_method, true)
+          raise ArgumentError,
+                "no URL provided, ##{action_url_method} method required"
+        end
+
+        url = send(action_url_method)
+      end
+
+      def complete_action_html_options(action_name, final_html_options)
+        if action_name
+          default_options = action_html_options(action_name)
+          html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+
+          action_html_options_method = "#{action_name}_action_html_options"
+          if respond_to?(action_html_options_method, true)
+            html_options.merge_attrs!(send(action_html_options_method))
+          end
+
+          html_options.merge_attrs!(final_html_options)
+          html_options.to_h
+        else
+          final_html_options
+        end
+      end
+
+      def complete_column_html_options(attribute_name, final_html_options)
+        if attribute_name
+          default_options = column_html_options(attribute_name)
+          html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+          html_options.merge_attrs!(final_html_options)
+          html_options.to_h
+        else
+          final_html_options
+        end
+      end
+
+      def action_label(action_name)
+        return nil unless action_name
+
+        I18n.t(
+          :"#{resource.class.model_name.i18n_key}.#{action_name}",
+          scope: 'table.actions',
+          default: [
+            :"#{action_name}",
+            action_name.to_s.titleize
+          ]
+        )
+      end
+
+      def action_html_options(action_name)
+        { role: action_name.to_s.gsub(/_/, '-') }
+      end
+
+      def column_html_options(attribute_name)
+        { role: attribute_name.to_s.gsub(/_/, '-') }
+      end
+    end
+  end
+end
+

data/lib/admino/table/row.rb

@@ -0,0 +1,56 @@
+module Admino
+  module Table
+    class Row
+      attr_reader :view_context
+
+      alias_method :h, :view_context
+
+      def initialize(view_context)
+        @view_context = view_context
+      end
+
+      def parse_column_args(args)
+        html_options = args.extract_options!
+
+        attribute_name = if args.first.is_a?(Symbol)
+                           args.shift
+                         else
+                           nil
+                         end
+
+        label = if args.first.is_a?(String) || args.first.is_a?(Symbol)
+                  args.shift
+                else
+                  nil
+                end
+
+        [attribute_name, label, html_options]
+      end
+
+      def parse_action_args(args)
+        html_options = args.extract_options!
+
+        action_name = if args.first.is_a?(Symbol)
+                        args.shift
+                      else
+                        nil
+                      end
+
+        url = if args.first.is_a?(String)
+                  args.shift
+                else
+                  nil
+                end
+
+        label = args.shift
+
+        [action_name, url, label, html_options]
+      end
+
+      def to_html
+        nil
+      end
+    end
+  end
+end
+

data/lib/admino/table.rb

@@ -0,0 +1,7 @@
+require 'admino/table/presenter'
+
+module Admino
+  module Table
+  end
+end
+

data/lib/admino/version.rb

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

data/lib/admino.rb

@@ -0,0 +1,14 @@
+require 'active_support/core_ext/module/delegation'
+
+require "admino/version"
+require "admino/query"
+require "admino/table"
+require "admino/action_view_extension"
+
+module Admino
+end
+
+ActiveSupport.on_load(:action_view) do
+  include Admino::ActionViewExtension
+end
+

data/lib/gestart-admino.rb

@@ -0,0 +1 @@
+require 'admino'

data/spec/admino/integration_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe 'Action View integration' do
+  let(:context) { RailsViewContext.new }
+
+  describe '#simple_table_for' do
+    let(:collection) { [ first_post, second_post ] }
+    let(:first_post) { Post.new('1') }
+    let(:second_post) { Post.new('2') }
+    let(:params) {
+      {
+        sorting: 'by_title',
+        sort_order: 'desc'
+      }
+    }
+    let(:query) { TestQuery.new(params) }
+
+    it 'produces HTML' do
+      result = context.table_for(collection, query: query) do |table, record|
+        table.column :title, sorting: :by_title
+        table.actions do
+          table.action :show, '/foo', 'Show'
+        end
+      end
+
+      expect(result).to have_tag(:table) do
+        with_tag 'thead th:first-child', with: { role: 'title' }
+        with_tag 'thead th:last-child', with: { role: 'actions' }
+
+        with_tag 'th:first-child a', with: { class: 'is-desc', href: '/?sort_order=asc&sorting=by_title' }, text: 'Title'
+        with_tag 'th:last-child', text: 'Actions'
+
+        with_tag 'tbody tr:first-child', with: { class: 'is-even' }
+        with_tag 'tbody tr:last-child', with: { class: 'is-odd' }
+
+        with_tag 'tbody tr:first-child td:first-child', with: { role: 'title' }, text: 'Post 1'
+        with_tag 'tbody tr:first-child td:last-child', with: { role: 'actions' }
+
+        with_tag 'tbody tr:first-child td:last-child a', with: { role: 'show', href: '/foo' }
+      end
+    end
+  end
+
+  describe '#simple_search_form_for' do
+    let(:params) {
+      {
+        query: { foo: 'test' }
+      }
+    }
+    let(:query) { TestQuery.new(params) }
+
+    it 'produces HTML' do
+      result = context.simple_search_form_for(query) do |f|
+        f.input :foo
+      end
+
+      expect(result).to have_tag(:form, with: { action: '/?p=1', method: 'get' }) do
+        with_tag 'input', with: { type: 'text', value: 'test', name: 'query[foo]' }
+      end
+    end
+  end
+end
+

data/spec/admino/query/base_presenter_spec.rb

@@ -0,0 +1,59 @@
+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
+        allow(view).to receive(:request).and_return(request_object)
+      end
+
+      describe '#simple_form' do
+        let(:result) do
+          presenter.simple_form do |form|
+            form.input(: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, content: 'NAME')
+        end
+      end
+    end
+  end
+end
+