tiny_admin 0.3.0 → 0.5.0

data/lib/tiny_admin/router.rb

@@ -2,9 +2,11 @@
 
 module TinyAdmin
   class Router < BasicApp
-    TinyAdmin::Settings.instance.load_settings
-
     route do |r|
+      context.settings = TinyAdmin::Settings.instance
+      context.settings.load_settings
+      context.router = r
+
       r.on 'auth' do
         context.slug = nil
         r.run Authentication
@@ -27,11 +29,11 @@ module TinyAdmin
         r.redirect settings.root_path
       end
 
-      TinyAdmin::Settings.instance.pages.each do |slug, data|
+      context.pages.each do |slug, data|
         setup_page_route(r, slug, data)
       end
 
-      TinyAdmin::Settings.instance.resources.each do |slug, options|
+      context.resources.each do |slug, options|
         setup_resource_routes(r, slug, options: options || {})
       end
 
@@ -74,29 +76,30 @@ module TinyAdmin
     end
 
     def setup_collection_routes(router, options:)
-      repository = options[:repository].new(options[:model])
+      context.repository = options[:repository].new(options[:model])
       action_options = options[:index] || {}
 
       # Custom actions
       custom_actions = setup_custom_actions(
         router,
         options[:collection_actions],
-        repository: repository,
+        repository: context.repository,
         options: action_options
       )
 
       # Index
-      actions = options[:only]
-      if !actions || actions.include?(:index) || actions.include?('index')
+      if options[:only].include?(:index) || options[:only].include?('index')
         router.is do
-          index_action = TinyAdmin::Actions::Index.new(repository, path: request.path, params: request.params)
-          render_page index_action.call(app: self, context: context, options: action_options, actions: custom_actions)
+          context.actions = custom_actions
+          context.request = request
+          index_action = TinyAdmin::Actions::Index.new
+          render_page index_action.call(app: self, context: context, options: action_options)
         end
       end
     end
 
     def setup_member_routes(router, options:)
-      repository = options[:repository].new(options[:model])
+      context.repository = options[:repository].new(options[:model])
       action_options = (options[:show] || {}).merge(record_not_found_page: settings.record_not_found)
 
       router.on String do |reference|
@@ -106,32 +109,36 @@ module TinyAdmin
         custom_actions = setup_custom_actions(
           router,
           options[:member_actions],
-          repository: repository,
+          repository: context.repository,
           options: action_options
         )
 
         # Show
-        actions = options[:only]
-        if !actions || actions.include?(:show) || actions.include?('show')
+        if options[:only].include?(:show) || options[:only].include?('show')
           router.is do
-            show_action = TinyAdmin::Actions::Show.new(repository, path: request.path, params: request.params)
-            render_page show_action.call(app: self, context: context, options: action_options, actions: custom_actions)
+            context.actions = custom_actions
+            context.request = request
+            show_action = TinyAdmin::Actions::Show.new
+            render_page show_action.call(app: self, context: context, options: action_options)
           end
         end
       end
     end
 
     def setup_custom_actions(router, custom_actions, repository:, options:)
-      (custom_actions || []).map do |custom_action|
+      context.repository = repository
+      (custom_actions || []).each_with_object({}) do |custom_action, result|
         action_slug, action = custom_action.first
         action_class = action.is_a?(String) ? Object.const_get(action) : action
 
         router.get action_slug.to_s do
-          custom_action = action_class.new(repository, path: request.path, params: request.params)
+          context.actions = {}
+          context.request = request
+          custom_action = action_class.new
           render_page custom_action.call(app: self, context: context, options: options)
         end
 
-        action_slug.to_s
+        result[action_slug.to_s] = action_class
       end
     end
   end

data/lib/tiny_admin/settings.rb

@@ -5,10 +5,26 @@ module TinyAdmin
     include Singleton
     include Utils
 
+    DEFAULTS = {
+      %i[authentication plugin] => Plugins::NoAuth,
+      %i[authentication login] => Views::Pages::SimpleAuthLogin,
+      %i[components flash] => Views::Components::Flash,
+      %i[components head] => Views::Components::Head,
+      %i[components navbar] => Views::Components::Navbar,
+      %i[components pagination] => Views::Components::Pagination,
+      %i[helper_class] => Support,
+      %i[page_not_found] => Views::Pages::PageNotFound,
+      %i[record_not_found] => Views::Pages::RecordNotFound,
+      %i[repository] => Plugins::ActiveRecordRepository,
+      %i[root_path] => '/admin',
+      %i[root page] => Views::Pages::Root,
+      %i[root title] => 'TinyAdmin'
+    }.freeze
+
     attr_accessor :authentication,
                   :components,
                   :extra_styles,
-                  :navbar,
+                  :helper_class,
                   :page_not_found,
                   :record_not_found,
                   :repository,
@@ -18,66 +34,96 @@ module TinyAdmin
                   :scripts,
                   :style_links
 
-    attr_reader :pages, :resources
+    def [](key)
+      send(key)
+    end
+
+    def []=(key, value)
+      send("#{key}=", value)
+      convert_value(key, value)
+    end
 
     def load_settings
-      @authentication ||= {}
-      @authentication[:plugin] ||= Plugins::NoAuth
-      @authentication[:login] ||= Views::Pages::SimpleAuthLogin
-      @authentication[:plugin] = Object.const_get(authentication[:plugin]) if authentication[:plugin].is_a?(String)
-
-      @page_not_found ||= Views::Pages::PageNotFound
-      @page_not_found = Object.const_get(@page_not_found) if @page_not_found.is_a?(String)
-      @record_not_found ||= Views::Pages::RecordNotFound
-      @record_not_found = Object.const_get(@record_not_found) if @record_not_found.is_a?(String)
-
-      @pages ||= {}
-      @repository ||= Plugins::ActiveRecordRepository
-      @resources ||= {}
-      @root_path ||= '/admin'
-      @root_path = '/' if @root_path == ''
-      @sections ||= []
+      # default values
+      DEFAULTS.each do |(option, param), default|
+        if param
+          self[option] ||= {}
+          self[option][param] ||= default
+        else
+          self[option] ||= default
+        end
+      end
 
-      @root ||= {}
-      @root[:title] ||= 'TinyAdmin'
-      @root[:page] ||= Views::Pages::Root
+      context.pages ||= {}
+      context.resources ||= {}
+      @sections ||= []
+      @root_path = '/' if @root_path == ''
 
-      if @authentication[:plugin] == Plugins::SimpleAuth
-        @authentication[:logout] ||= ['logout', "#{root_path}/auth/logout"]
+      if @authentication[:plugin] <= Plugins::SimpleAuth
+        @authentication[:logout] ||= { name: 'logout', path: "#{root_path}/auth/logout" }
       end
+      context.navbar = prepare_navbar(sections, logout: authentication[:logout])
+    end
 
-      @components ||= {}
-      @components[:flash] ||= Views::Components::Flash
-      @components[:head] ||= Views::Components::Head
-      @components[:navbar] ||= Views::Components::Navbar
-      @components[:pagination] ||= Views::Components::Pagination
+    private
 
-      @navbar = prepare_navbar(sections, logout: authentication[:logout])
+    def convert_value(key, value)
+      if value.is_a?(Hash)
+        value.each_key do |key2|
+          path = [key, key2]
+          if DEFAULTS[path].is_a?(Class) || DEFAULTS[path].is_a?(Module)
+            self[key][key2] = Object.const_get(self[key][key2])
+          end
+        end
+      elsif value.is_a?(String) && (DEFAULTS[[key]].is_a?(Class) || DEFAULTS[[key]].is_a?(Module))
+        self[key] = Object.const_get(self[key])
+      end
     end
 
     def prepare_navbar(sections, logout:)
       items = sections.each_with_object({}) do |section, list|
-        slug = section[:slug]
+        unless section.is_a?(Hash)
+          section_class = Object.const_get(section)
+          next unless section_class.respond_to?(:to_h)
+
+          section = section_class.to_h
+        end
+
+        slug = section[:slug].to_s
         case section[:type]&.to_sym
         when :url
-          list[slug] = [section[:name], section[:url], section[:options]]
+          list[slug] = add_url_section(slug, section)
         when :page
-          page = section[:page]
-          pages[slug] = page.is_a?(String) ? Object.const_get(page) : page
-          list[slug] = [section[:name], route_for(slug)]
+          list[slug] = add_page_section(slug, section)
         when :resource
-          repository = section[:repository] || settings.repository
-          resources[slug] = {
-            model: section[:model].is_a?(String) ? Object.const_get(section[:model]) : section[:model],
-            repository: repository.is_a?(String) ? Object.const_get(repository) : repository
-          }
-          resources[slug].merge! section.slice(:resource, :only, :index, :show, :collection_actions, :member_actions)
-          hidden = section[:options] && (section[:options].include?(:hidden) || section[:options].include?('hidden'))
-          list[slug] = [section[:name], route_for(slug)] unless hidden
+          list[slug] = add_resource_section(slug, section)
         end
       end
       items['auth/logout'] = logout if logout
       items
     end
+
+    def add_url_section(_slug, section)
+      section.slice(:name, :options).tap { _1[:path] = section[:url] }
+    end
+
+    def add_page_section(slug, section)
+      page = section[:page]
+      context.pages[slug] = page.is_a?(String) ? Object.const_get(page) : page
+      { name: section[:name], path: route_for(slug), class: context.pages[slug] }
+    end
+
+    def add_resource_section(slug, section)
+      repository = section[:repository] || settings.repository
+      context.resources[slug] = {
+        model: section[:model].is_a?(String) ? Object.const_get(section[:model]) : section[:model],
+        repository: repository.is_a?(String) ? Object.const_get(repository) : repository
+      }
+      resource_options = section.slice(:resource, :only, :index, :show, :collection_actions, :member_actions)
+      resource_options[:only] ||= %i[index show]
+      context.resources[slug].merge!(resource_options)
+      hidden = section[:options] && (section[:options].include?(:hidden) || section[:options].include?('hidden'))
+      { name: section[:name], path: route_for(slug) } unless hidden
+    end
   end
 end

data/lib/tiny_admin/support.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module TinyAdmin
+  class Support
+    class << self
+      def call(value, options: [])
+        options.inject(value) { |result, message| result&.send(message) } if value && options&.any?
+      end
+
+      def downcase(value, options: [])
+        value&.downcase
+      end
+
+      def format(value, options: [])
+        Kernel.format(options.first, value) if value && options&.any?
+      end
+
+      def round(value, options: [])
+        value&.round(options&.first&.to_i || 2)
+      end
+
+      def strftime(value, options: [])
+        value&.strftime(options&.first || '%Y-%m-%d %H:%M')
+      end
+
+      def to_date(value, options: [])
+        value.to_date.to_s if value
+      end
+
+      def upcase(value, options: [])
+        value&.upcase
+      end
+    end
+  end
+end

data/lib/tiny_admin/utils.rb

@@ -5,7 +5,8 @@ module TinyAdmin
     def params_to_s(params)
       list = params.each_with_object([]) do |(param, value), result|
         if value.is_a?(Hash)
-          result.concat(value.map { |k, v| "#{param}[#{k}]=#{v}" })
+          values = value.map { |key, val| "#{param}[#{key}]=#{val}" }
+          result.concat(values)
         else
           result.push(["#{param}=#{value}"])
         end
@@ -18,23 +19,30 @@ module TinyAdmin
         page.options = options
         page.head_component = settings.components[:head]&.new
         page.flash_component = settings.components[:flash]&.new
-        page.navbar_component = settings.components[:navbar]&.new(
+        page.navbar_component = settings.components[:navbar]&.new
+        page.navbar_component&.update_attributes(
           current_slug: context&.slug,
           root_path: settings.root_path,
           root_title: settings.root[:title],
-          items: options&.include?(:no_menu) ? [] : settings.navbar
+          items: options&.include?(:no_menu) ? [] : context&.navbar
         )
-
         yield(page) if block_given?
       end
     end
 
-    def route_for(section, reference: nil, action: nil)
+    def route_for(section, reference: nil, action: nil, query: nil)
       root_path = settings.root_path == '/' ? nil : settings.root_path
       route = [root_path, section, reference, action].compact.join("/")
+      route << "?#{query}" if query
       route[0] == '/' ? route : route.prepend('/')
     end
 
+    def to_label(string)
+      return '' unless string
+
+      string.respond_to?(:humanize) ? string.humanize : string.tr('_', ' ').capitalize
+    end
+
     def context
       TinyAdmin::Context.instance
     end

data/lib/tiny_admin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TinyAdmin
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/tiny_admin/views/actions/index.rb

@@ -4,12 +4,9 @@ module TinyAdmin
   module Views
     module Actions
       class Index < DefaultLayout
-        attr_accessor :actions, :fields, :filters, :pagination_component, :prepare_record, :records
+        attr_accessor :actions, :fields, :filters, :links, :pagination_component, :prepare_record, :records
 
         def template
-          @fields = fields.each_with_object({}) { |field, result| result[field.name] = field }
-          @filters ||= {}
-
           super do
             div(class: 'index') {
               div(class: 'row') {
@@ -17,19 +14,12 @@ module TinyAdmin
                   h1(class: 'title') { title }
                 }
                 div(class: 'col-8') {
-                  ul(class: 'nav justify-content-end') {
-                    (actions || []).each do |action|
-                      li(class: 'nav-item') {
-                        href = route_for(context.slug, action: action)
-                        a(href: href, class: 'nav-link btn btn-outline-secondary') { action }
-                      }
-                    end
-                  }
+                  actions_buttons
                 }
               }
 
               div(class: 'row') {
-                div_class = filters.any? ? 'col-9' : 'col-12'
+                div_class = filters&.any? ? 'col-9' : 'col-12'
                 div(class: div_class) {
                   table(class: 'table') {
                     table_header if fields.any?
@@ -38,10 +28,11 @@ module TinyAdmin
                   }
                 }
 
-                if filters.any?
+                if filters&.any?
                   div(class: 'col-3') {
-                    filters_form_attrs = { section_path: route_for(context.slug), filters: filters }
-                    render TinyAdmin::Views::Components::FiltersForm.new(**filters_form_attrs)
+                    filters_form = TinyAdmin::Views::Components::FiltersForm.new
+                    filters_form.update_attributes(section_path: route_for(context.slug), filters: filters)
+                    render filters_form
                   }
                 end
               }
@@ -57,7 +48,9 @@ module TinyAdmin
           thead {
             tr {
               fields.each_value do |field|
-                td(class: "field-header-#{field.name} field-header-type-#{field.type}") { field.title }
+                td(class: "field-header-#{field.name} field-header-type-#{field.type}") {
+                  field.options[:header] || field.title
+                }
               end
               td { whitespace }
             }
@@ -73,15 +66,46 @@ module TinyAdmin
                   field = fields[key]
                   td(class: "field-value-#{field.name} field-value-type-#{field.type}") {
                     if field.options && field.options[:link_to]
-                      reference = record.send(field.options[:field])
-                      a(href: route_for(field.options[:link_to], reference: reference)) { value }
+                      a(href: route_for(field.options[:link_to], reference: value)) {
+                        field.apply_call_option(record) || value
+                      }
                     else
                       value
                     end
                   }
                 end
-                td(class: 'actions') {
-                  a(href: route_for(context.slug, reference: record.id)) { 'show' }
+
+                td(class: 'actions p-1') {
+                  div(class: 'btn-group btn-group-sm') {
+                    link_class = 'btn btn-outline-secondary'
+                    if links
+                      links.each do |link|
+                        whitespace
+                        if link == 'show'
+                          a(href: route_for(context.slug, reference: record.id), class: link_class) { 'show' }
+                        else
+                          a(href: route_for(context.slug, reference: record.id, action: link), class: link_class) {
+                            to_label(link)
+                          }
+                        end
+                      end
+                    else
+                      a(href: route_for(context.slug, reference: record.id), class: link_class) { 'show' }
+                    end
+                  }
+                }
+              }
+            end
+          }
+        end
+
+        def actions_buttons
+          ul(class: 'nav justify-content-end') {
+            (actions || {}).each do |action, action_class|
+              li(class: 'nav-item mx-1') {
+                href = route_for(context.slug, action: action)
+                a(href: href, class: 'nav-link btn btn-outline-secondary') {
+                  action_class.respond_to?(:title) ? action_class.title : action
                 }
               }
             end

data/lib/tiny_admin/views/actions/show.rb

@@ -4,14 +4,7 @@ module TinyAdmin
   module Views
     module Actions
       class Show < DefaultLayout
-        attr_reader :fields, :prepare_record, :record
-        attr_accessor :actions
-
-        def setup_record(record:, fields:, prepare_record:)
-          @record = record
-          @fields = fields
-          @prepare_record = prepare_record
-        end
+        attr_accessor :actions, :fields, :prepare_record, :record
 
         def template
           super do
@@ -21,27 +14,21 @@ module TinyAdmin
                   h1(class: 'title') { title }
                 }
                 div(class: 'col-8') {
-                  ul(class: 'nav justify-content-end') {
-                    (actions || []).each do |action|
-                      li(class: 'nav-item') {
-                        href = route_for(context.slug, reference: context.reference, action: action)
-                        a(href: href, class: 'nav-link btn btn-outline-secondary') { action }
-                      }
-                    end
-                  }
+                  actions_buttons
                 }
               }
 
-              prepare_record.call(record).each_with_index do |(_key, value), index|
-                field = fields[index]
+              prepare_record.call(record).each do |key, value|
+                field = fields[key]
                 div(class: "field-#{field.name} row lh-lg") {
                   if field
-                    div(class: 'field-header col-2') { field.title }
+                    div(class: 'field-header col-2') { field.options[:header] || field.title }
                   end
                   div(class: 'field-value col-10') {
-                    if field.options && field.options[:link_to]
-                      reference = record.send(field.options[:field])
-                      a(href: route_for(field.options[:link_to], reference: reference)) { value }
+                    if field.options[:link_to]
+                      a(href: route_for(field.options[:link_to], reference: value)) {
+                        field.apply_call_option(record) || value
+                      }
                     else
                       value
                     end
@@ -51,6 +38,21 @@ module TinyAdmin
             }
           end
         end
+
+        private
+
+        def actions_buttons
+          ul(class: 'nav justify-content-end') {
+            (actions || {}).each do |action, action_class|
+              li(class: 'nav-item mx-1') {
+                href = route_for(context.slug, reference: context.reference, action: action)
+                a(href: href, class: 'nav-link btn btn-outline-secondary') {
+                  action_class.respond_to?(:title) ? action_class.title : action
+                }
+              }
+            end
+          }
+        end
       end
     end
   end

data/lib/tiny_admin/views/components/basic_component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TinyAdmin
+  module Views
+    module Components
+      class BasicComponent < Phlex::HTML
+        def update_attributes(attributes)
+          attributes.each do |key, value|
+            send("#{key}=", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiny_admin/views/components/filters_form.rb

@@ -3,13 +3,8 @@
 module TinyAdmin
   module Views
     module Components
-      class FiltersForm < Phlex::HTML
-        attr_reader :filters, :section_path
-
-        def initialize(section_path:, filters:)
-          @section_path = section_path
-          @filters = filters
-        end
+      class FiltersForm < BasicComponent
+        attr_accessor :filters, :section_path
 
         def template
           form(class: 'form_filters', method: 'get') {

data/lib/tiny_admin/views/components/flash.rb

@@ -3,24 +3,21 @@
 module TinyAdmin
   module Views
     module Components
-      class Flash < Phlex::HTML
-        attr_reader :errors, :notices, :warnings
+      class Flash < BasicComponent
+        attr_accessor :messages
 
         def template
+          @messages ||= {}
+          notices = messages[:notices]
+          warnings = messages[:warnings]
+          errors = messages[:errors]
+
           div(class: 'flash') {
             div(class: 'notices alert alert-success', role: 'alert') { notices.join(', ') } if notices&.any?
             div(class: 'notices alert alert-warning', role: 'alert') { warnings.join(', ') } if warnings&.any?
             div(class: 'notices alert alert-danger', role: 'alert') { errors.join(', ') } if errors&.any?
           }
         end
-
-        def update(messages:)
-          return unless messages
-
-          @notices = messages[:notices]
-          @warnings = messages[:warnings]
-          @errors = messages[:errors]
-        end
       end
     end
   end

data/lib/tiny_admin/views/components/head.rb

@@ -3,8 +3,8 @@
 module TinyAdmin
   module Views
     module Components
-      class Head < Phlex::HTML
-        attr_reader :extra_styles, :page_title, :style_links
+      class Head < BasicComponent
+        attr_accessor :extra_styles, :page_title, :style_links
 
         def template
           head {
@@ -19,12 +19,6 @@ module TinyAdmin
             style { extra_styles } if extra_styles
           }
         end
-
-        def update(page_title, style_links: [], extra_styles: nil)
-          @page_title = page_title
-          @style_links = style_links
-          @extra_styles = extra_styles
-        end
       end
     end
   end