admino 0.0.1

data/lib/admino/query/group.rb

@@ -0,0 +1,55 @@
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class Group
+      attr_reader :params
+      attr_reader :config
+      attr_reader :query_i18n_key
+
+      def initialize(config, params, query_i18n_key = nil)
+        @config = config
+        @params = ActiveSupport::HashWithIndifferentAccess.new(params)
+        @query_i18n_key = query_i18n_key
+      end
+
+      def augment_scope(scope)
+        if current_scope
+          scope.send(current_scope)
+        else
+          scope
+        end
+      end
+
+      def current_scope
+        if param_value && available_scopes.include?(param_value.to_sym)
+          param_value.to_sym
+        else
+          nil
+        end
+      end
+
+      def is_scope_active?(scope)
+        current_scope == scope
+      end
+
+      def param_value
+        params.fetch(param_name, nil)
+      end
+
+      def param_name
+        config.name
+      end
+
+      def available_scopes
+        [nil] + config.scopes
+      end
+
+      def i18n_key
+        config.name
+      end
+    end
+  end
+end
+

data/lib/admino/query/group_presenter.rb

@@ -0,0 +1,67 @@
+require 'i18n'
+require 'showcase'
+require 'showcase/helpers/html_options'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class GroupPresenter < Showcase::Presenter
+      def scope_link(scope, *args)
+        options = args.extract_options!
+
+        label = args.first || scope_name(scope)
+
+        active_class = options.delete(:active_class) { 'is-active' }
+        options = Showcase::Helpers::HtmlOptions.new(options)
+
+        if is_scope_active?(scope)
+          options.add_class!(active_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 scope_params(scope)
+        params = ActiveSupport::HashWithIndifferentAccess.new(h.request.query_parameters)
+
+        if scope
+          params.merge!(param_name => scope.to_s)
+        else
+          params.delete(param_name)
+        end
+
+        params
+      end
+
+      def scope_name(scope)
+        scope ||= 'none'
+        I18n.t(
+          :"#{query_i18n_key}.#{i18n_key}.scopes.#{scope}",
+          scope: 'query.groups',
+          default: [
+            :"#{i18n_key}.scopes.#{scope}",
+            scope.to_s.titleize
+          ]
+        )
+      end
+
+      def name
+        I18n.t(
+          :"#{query_i18n_key}.#{i18n_key}.name",
+          scope: 'query.groups',
+          default: [
+            :"#{i18n_key}.name",
+            i18n_key.to_s.titleize
+          ]
+        )
+      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/table/head_row.rb

@@ -0,0 +1,59 @@
+require 'admino/table/row'
+require 'showcase/helpers/html_options'
+
+module Admino
+  module Table
+    class HeadRow < Row
+      attr_reader :resource_klass
+
+      def initialize(resource_klass, view_context)
+        @resource_klass = resource_klass
+        @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)
+        params = parse_column_args(args)
+
+        attribute_name = params[:attribute_name]
+        label = params[:label]
+        options = params[:html_options]
+
+        if label.nil? && attribute_name
+          label = resource_klass.human_attribute_name(attribute_name.to_s)
+        end
+
+        default_options = column_html_options(attribute_name)
+        html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+        html_options.merge_attrs!(options)
+
+        @columns << h.content_tag(:th, label.to_s, html_options.to_h)
+      end
+
+      def to_html
+        @columns.html_safe
+      end
+
+      private
+
+      def column_html_options(attribute_name)
+        if attribute_name
+          { role: attribute_name.to_s.gsub(/_/, '-') }
+        end
+      end
+    end
+  end
+end
+

data/lib/admino/table/presenter.rb

@@ -0,0 +1,81 @@
+require 'showcase'
+require 'admino/table/head_row'
+require 'admino/table/resource_row'
+
+module Admino
+  module Table
+    class Presenter < Showcase::Presenter
+      attr_reader :collection_klass
+
+      def self.tag_helper(name, tag, options = {})
+        default_options_method = :"#{name}_html_options"
+
+        define_method :"#{name}_tag" do |*args, &block|
+          options = args.extract_options!
+          if respond_to?(default_options_method, true)
+            default_options = send(default_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(collection, klass, context)
+        @collection_klass = klass
+        super(collection, context)
+      end
+
+      def to_html(options = {}, &block)
+        table_tag(options) do
+          thead_tag do
+            thead_tr_tag do
+              row = head_row(collection_klass, view_context)
+              h.capture(row, nil, &block) if block_given?
+              row.to_html
+            end
+          end <<
+          tbody_tag do
+            collection.each_with_index.map do |resource, index|
+              tr_html_options = {
+                class: zebra_css_classes[index % zebra_css_classes.size],
+                id: resource.dom_id
+              }
+              tbody_tr_tag(resource, index, tr_html_options) do
+                row = resource_row(resource, view_context)
+                h.capture(row, resource, &block) if block_given?
+                row.to_html
+              end
+            end.join.html_safe
+          end
+        end
+      end
+
+      private
+
+      def collection
+        @collection ||= present_collection(object)
+      end
+
+      def head_row(collection_klass, view_context)
+        HeadRow.new(collection_klass, view_context)
+      end
+
+      def resource_row(resource, view_context)
+        ResourceRow.new(resource, view_context)
+      end
+
+      def zebra_css_classes
+        %w(is-even is-odd)
+      end
+    end
+  end
+end
+

data/lib/admino/table/resource_row.rb

@@ -0,0 +1,135 @@
+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)
+        params = parse_column_args(args)
+
+        attribute_name = params[:attribute_name]
+        label = params[:label]
+        options = params[: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
+
+        default_options = column_html_options(attribute_name)
+        html_options = Showcase::Helpers::HtmlOptions.new(default_options)
+        html_options.merge_attrs!(options)
+
+        @columns << h.content_tag(:td, content, html_options.to_h)
+      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)
+        params = parse_action_args(args)
+
+        action_name = params[:action_name]
+        label = params[:label]
+        url = params[:url]
+        options = params[:html_options]
+
+        if block_given?
+          @actions << h.capture(resource, &block)
+          return
+        end
+
+        if url.nil?
+          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
+
+        base_options = if action_name
+                         action_html_options(action_name)
+                       end
+
+        html_options = Showcase::Helpers::HtmlOptions.new(base_options)
+
+        action_html_options_method = "#{action_name}_action_html_options"
+
+        if respond_to?(action_html_options_method, true)
+          action_html_options = send(action_html_options_method)
+          html_options.merge_attrs!(action_html_options)
+        end
+
+        html_options.merge_attrs!(options)
+
+        if label.nil? && action_name
+          label = I18n.t(
+            :"#{resource.class.model_name.i18n_key}.#{action_name}",
+            scope: 'table.actions',
+            default: [
+              :"#{action_name}",
+              action_name.to_s.titleize
+            ]
+          )
+        end
+
+        @actions << h.link_to(label, url, html_options.to_h)
+      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_html_options(action_name)
+        if action_name
+          { role: action_name.to_s.gsub(/_/, '-') }
+        end
+      end
+
+      def column_html_options(attribute_name)
+        if attribute_name
+          { role: attribute_name.to_s.gsub(/_/, '-') }
+        end
+      end
+    end
+  end
+end
+

data/lib/admino/table/row.rb

@@ -0,0 +1,65 @@
+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)
+        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.shift
+                else
+                  nil
+                end
+
+        {
+          attribute_name: attribute_name,
+          label: label,
+          html_options: options
+        }
+      end
+
+      def parse_action_args(args)
+        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: action_name,
+          url: url,
+          label: label,
+          html_options: options
+        }
+      end
+
+      def to_html
+        nil
+      end
+    end
+  end
+end
+