RubyGems - active_element - Versions diffs - 0.0.1 → 0.0.2 - Mend

active_element 0.0.1 → 0.0.2

Files changed (113) hide show

data/app/views/kaminari/_gap.html.erb ADDED Viewed

@@ -0,0 +1,3 @@
+<li class='page-item disabled'>
+  <%= link_to raw(t 'views.pagination.truncate'), '#', class: 'page-link' %>
+</li>

data/app/views/kaminari/_last_page.html.erb ADDED Viewed

@@ -0,0 +1,3 @@
+<li class="page-item">
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.last'), url, remote: remote, class: 'page-link' %>
+</li>

data/app/views/kaminari/_next_page.html.erb ADDED Viewed

@@ -0,0 +1,3 @@
+<li class="page-item">
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, rel: 'next', remote: remote, class: 'page-link' %>
+</li>

data/app/views/kaminari/_page.html.erb ADDED Viewed

@@ -0,0 +1,9 @@
+<% if page.current? %>
+  <li class="page-item active">
+    <%= content_tag :a, page, data: { remote: remote }, rel: page.rel, class: 'page-link' %>
+  </li>
+<% else %>
+  <li class="page-item">
+    <%= link_to page, url, remote: remote, rel: page.rel, class: 'page-link' %>
+  </li>
+<% end %>

data/app/views/kaminari/_paginator.html.erb ADDED Viewed

@@ -0,0 +1,17 @@
+<%= paginator.render do %>
+  <nav>
+    <ul class="pagination">
+      <%= first_page_tag unless current_page.first? %>
+      <%= prev_page_tag unless current_page.first? %>
+      <% each_page do |page| %>
+        <% if page.left_outer? || page.right_outer? || page.inside_window? %>
+          <%= page_tag page %>
+        <% elsif !page.was_truncated? -%>
+          <%= gap_tag %>
+        <% end %>
+      <% end %>
+      <%= next_page_tag unless current_page.last? %>
+      <%= last_page_tag unless current_page.last? %>
+    </ul>
+  </nav>
+<% end %>

data/app/views/kaminari/_prev_page.html.erb ADDED Viewed

@@ -0,0 +1,3 @@
+<li class="page-item">
+  <%= link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, rel: 'prev', remote: remote, class: 'page-link' %>
+</li>

data/app/views/layouts/active_element.html.erb ADDED Viewed

@@ -0,0 +1,65 @@
+<html>
+  <head>
+    <%= render_active_element_hook 'active_element/before_head' %>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/js/all.min.js" integrity="sha512-fD9DI5bZwQxOi7MhYWnnNPlvXdp/2Pj3XSTRrFs5FQa4mizyGLnJcN6tuvUS6LbmgN1ut+XGSABKvjN0H6Aoow==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/2.9.2/umd/popper.min.js" integrity="sha512-2rNj2KJ+D8s1ceNasTIex6z4HWyOnEYLVC3FigGOmyQCZc2eBXKgOxQmo3oKLHyfcj53uz4QMsRCWNbLd32Q1g==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <%= stylesheet_link_tag 'active_element/application', 'data-turbolinks-track': 'reload' %>
+    <%= javascript_include_tag 'active_element/application', 'data-turbolinks-track': 'reload' %>
+    <% if Rails.application.assets.find_asset('application.css').present? %>
+      <%= stylesheet_link_tag 'application', 'data-turbolinks-track': 'reload' %>
+    <% end %>
+    <% if Rails.application.assets.find_asset('application.js').present? %>
+      <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
+    <% end %>
+    <%= csrf_meta_tag %>
+    <%= render_active_element_hook 'active_element/after_head' %>
+  </head>
+  <body>
+    <%= render_active_element_hook 'active_element/before_navbar' %>
+    <%= render partial: 'active_element/navbar/menu' %>
+    <%= render_active_element_hook 'active_element/after_navbar' %>
+    <% flash.each do |type, message| %>
+      <div class="flash card text-bg-<%= { notice: 'info', alert: 'danger' }.fetch(type.to_sym, 'info') %> flash <%= type %> float-end">
+          <div class="card-body">
+            <%= message %>
+            <button type="button" class="btn-close" aria-label="Close"></button>
+          </div>
+      </div>
+    <% end %>
+    <%= render_active_element_hook 'active_element/before_content' %>
+    <div class="content p-3 m-3">
+      <%= yield %>
+    </div>
+    <%= render partial: 'active_element/components/form/templates' %>
+    <%= render partial: 'active_element/components/secret/templates' %>
+    <%= render partial: 'active_element/theme/templates' %>
+    <%= render_active_element_hook 'active_element/after_content' %>
+    <script>
+      var popoverTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="popover"]'))
+      var popoverList = popoverTriggerList.map(function (popoverTriggerEl) {
+        return new bootstrap.Popover(popoverTriggerEl)
+      })
+      document.querySelectorAll('.flash .btn-close').forEach(element => {
+        element.onclick = ev => {
+          ev.stopPropagation();
+          ev.target.parentElement.parentElement.classList.add('d-none');
+        };
+      });
+    </script>
+  </body>
+</html>

data/app/views/layouts/active_element_error.html.erb ADDED Viewed

@@ -0,0 +1,40 @@
+<html>
+  <head>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.0/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-gH2yIJqKdNHPEq0n4Mqa/HGKIhSkIHeL5AyhkYV8i59U5AR6csBvApHHNl/vI1Bx" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" integrity="sha512-iecdLmaskl7CVkqkXNQ/ZH/XLlvWZOJyj7Yy7tcenmpD1ypASozpmT/E0iPtmFIB46ZmdtAc9eNBvH0H/ZpiBw==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.0/dist/js/bootstrap.bundle.min.js" integrity="sha384-A3rJD856KowSb7dwlZdYEkO39Gagi7vIsF0jrRAoQmDKKtQBHUuLZ9AsSv4jD4Xa" crossorigin="anonymous"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/js/all.min.js" integrity="sha512-fD9DI5bZwQxOi7MhYWnnNPlvXdp/2Pj3XSTRrFs5FQa4mizyGLnJcN6tuvUS6LbmgN1ut+XGSABKvjN0H6Aoow==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+  </head>
+  <style>
+    body {
+      background-color: #623131;
+    }
+    a {
+      color: #d7df93;
+    }
+    div.content {
+      position: absolute;
+      color: #efefef;
+      left: 50%;
+      top: 40%;
+      -webkit-transform: translate(-50%, -50%);
+      transform: translate(-50%, -50%);
+      text-align: center;
+    }
+  </style>
+  <%= render_active_element_hook 'before_error_content' %>
+  <body>
+    <div class="wrapper">
+      <div class="middle">
+        <div class="content p-3 m-3">
+          <%= yield %>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>

data/config/routes.rb ADDED Viewed

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+ActiveElement::Engine.routes.draw do
+  post '/_text_search', controller: 'active_element/text_searches', action: 'create'
+end

data/lib/active_element/active_menu_link.rb ADDED Viewed

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module ActiveElement
+  # Detects which link should be highlighted in the main application menu.
+  class ActiveMenuLink
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(rails_component:, current_path:, controller_path:, action_name:, current_navbar_item:, navbar_items:)
+      @rails_component = rails_component
+      @current_path = current_path
+      @controller_path = controller_path
+      @action_name = action_name
+      @current_navbar_item = current_navbar_item
+      @navbar_items = navbar_items
+    end
+    # rubocop:enable Metrics/ParameterLists
+    def active?
+      return true if exact_match?
+      return true if !any_exact_match? && exact_without_query_string_match?
+      return true if !any_exact_match? && !any_exact_without_query_string_match? && exact_without_resource_match?
+      false
+    end
+    private
+    attr_reader :rails_component,
+                :current_path, :controller_path, :action_name,
+                :current_navbar_item, :navbar_items
+    def exact_match?(navbar_item = current_navbar_item)
+      exact_matched_route(navbar_item)&.fetch(:path) == current_path
+    end
+    def exact_matched_route(navbar_item)
+      rails_component.route_paths_with_requirements.find do |route_path_with_requirements|
+        route_path_with_requirements[:path] == navbar_item[:path]
+      end
+    end
+    def any_exact_match?
+      navbar_items.any? do |navbar_item|
+        exact_match?(navbar_item)
+      end
+    end
+    def exact_without_query_string_match?(navbar_item = current_navbar_item)
+      exact_matched_route_without_query_string(navbar_item)&.fetch(:path) == without_query_string(current_path)
+    end
+    def any_exact_without_query_string_match?
+      navbar_items.any? do |navbar_item|
+        exact_without_query_string_match?(navbar_item)
+      end
+    end
+    def exact_matched_route_without_query_string(navbar_item)
+      rails_component.route_paths_with_requirements.find do |route_path_with_requirements|
+        route_path_with_requirements[:path] == without_query_string(navbar_item[:path])
+      end
+    end
+    def without_query_string(path)
+      path.rpartition('?').compact_blank.first
+    end
+    def exact_without_resource_match?
+      route = exact_matched_route_without_resource(current_navbar_item)
+      return false if route.blank?
+      route[:controller] == controller_path
+    end
+    def exact_matched_route_without_resource(navbar_item)
+      rails_component.route_paths_with_requirements.find do |route_path_with_requirements|
+        navbar_item.dig(:spec, :controller) == route_path_with_requirements[:controller]
+      end
+    end
+  end
+end

data/lib/active_element/active_record_text_search_authorization.rb ADDED Viewed

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+ActiveRecord::Base.class_eval do
+  class << self
+    attr_reader :authorized_active_element_text_search_fields
+    def authorize_active_element_text_search_for(field, exposes:)
+      @authorized_active_element_text_search_fields ||= []
+      @authorized_active_element_text_search_fields << [field, exposes]
+    end
+  end
+end

data/lib/active_element/colorized_string.rb ADDED Viewed

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module ActiveElement
+  # Wraps strings in terminal escape codes to provide colourisation in (e.g.) logging output.
+  class ColorizedString
+    COLOR_CODES = {
+      cyan: '36',
+      red: '31',
+      green: '32',
+      blue: '34',
+      purple: '35',
+      yellow: '33',
+      light_gray: '37',
+      light_blue: '1;34',
+      white: '1;37'
+    }.freeze
+    def initialize(string, color:)
+      @string = string
+      @color = color
+    end
+    def value
+      return string unless Rails.env.development? || Rails.env.test?
+      "\e[#{COLOR_CODES.fetch(color)}m#{string}\e[0m"
+    end
+    private
+    attr_reader :string, :color
+  end
+end

data/lib/active_element/component.rb ADDED Viewed

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+module ActiveElement
+  # Exposed by `component` view helper, used as general entrypoint for component creation.
+  class Component
+    def initialize(controller)
+      @controller = controller
+    end
+    def page_title(title, **kwargs)
+      controller.content_tag(:h2, title, **kwargs)
+    end
+    def page_subtitle(subtitle, **kwargs)
+      controller.content_tag(:h3, subtitle, **kwargs)
+    end
+    def page_section_title(section_title, **kwargs)
+      kwargs[:class] ||= 'mt-3'
+      controller.content_tag(:h4, section_title, **kwargs)
+    end
+    def page_description(content)
+      render Components::PageDescription.new(controller, content: content)
+    end
+    def show_button(record = nil, flag_or_options = true, **kwargs) # rubocop:disable Style/OptionalBooleanParameter
+      render Components::Button.new(controller, record, flag_or_options, type: :show, **kwargs)
+    end
+    def new_button(record = nil, flag_or_options = true, **kwargs) # rubocop:disable Style/OptionalBooleanParameter
+      render Components::Button.new(controller, record, flag_or_options, type: :new, **kwargs)
+    end
+    def edit_button(record = nil, flag_or_options = true, **kwargs) # rubocop:disable Style/OptionalBooleanParameter
+      render Components::Button.new(controller, record, flag_or_options, type: :edit, **kwargs)
+    end
+    def destroy_button(record = nil, flag_or_options = true, **kwargs) # rubocop:disable Style/OptionalBooleanParameter
+      confirm = kwargs.delete(:confirm) { true }
+      render Components::Button.new(
+        controller, record, flag_or_options, type: :destroy, confirm: confirm, **kwargs
+      )
+    end
+    def button(title = nil, url = nil, type: 'primary', float: nil, **kwargs, &block)
+      render Components::Button.new(
+        controller, nil, { path: url, title: title }, type: type, float: float, **kwargs, &block
+      )
+    end
+    def json(key, object)
+      render Components::Json.new(controller, object: object, key: key)
+    end
+    def tabs(class: nil, &block)
+      class_name = binding.local_variable_get(:class) || 'tabs'
+      render Components::Tabs.new(controller, class_name: class_name, &block)
+    end
+    def table(**kwargs)
+      class_name = kwargs.delete(:class) { default_class(kwargs[:collection], kwargs[:item], kwargs[:model_name]) }
+      return render item_table(controller, class_name: class_name, **kwargs) if kwargs.key?(:item)
+      if kwargs.key?(:collection)
+        return render collection_table(controller, class_name: class_name, params: params, **kwargs)
+      end
+      raise ArgumentError, 'Must provide one of `item` or `collection`.'
+    end
+    def form(fields: nil, submit: nil, item: nil, **kwargs)
+      render Components::Form.new(controller, fields: fields, submit: submit, item: item, **kwargs)
+    end
+    private
+    attr_reader :controller
+    def item_table(controller, **kwargs)
+      Components::ItemTable.new(controller, **kwargs)
+    end
+    def collection_table(controller, **kwargs)
+      Components::CollectionTable.new(controller, **kwargs)
+    end
+    def render(component)
+      ActiveElement.with_silenced_logging do
+        controller.render_to_string component.template, locals: component.locals, layout: nil
+      end
+    end
+    def default_class(collection, item, model_name)
+      class_from_collection(collection, model_name) || class_from_item(item, model_name)
+    end
+    def class_from_collection(collection, model_name)
+      return model_name.pluralize if model_name.present?
+      return nil if collection.nil?
+      Components::Util::I18n.class_name(class_name_from_item(collection.first), plural: true)
+    end
+    def class_from_item(item, model_name)
+      return model_name.pluralize if model_name.present?
+      return nil if item.nil?
+      Components::Util::I18n.class_name(class_name_from_item(item))
+    end
+    def params
+      controller.params
+    end
+    def class_name_from_item(item)
+      Components::Util.sti_record_name(item) || Components::Util.record_name(item)
+    end
+  end
+end

data/lib/active_element/components/button.rb ADDED Viewed

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+module ActiveElement
+  module Components
+    # A clickable button.
+    # rubocop:disable Metrics/ClassLength
+    class Button
+      # rubocop:disable Metrics/MethodLength
+      def initialize(controller, record, flag_or_options, confirm: false, type: :primary, method: nil,
+                     float: nil, icon: nil, **kwargs, &block)
+        @controller = controller
+        @record = record.is_a?(ActiveRecord::Relation) ? record.klass.new : record
+        @flag_or_options = flag_or_options
+        @float = float
+        @kwargs = kwargs
+        @kwargs_class = kwargs.delete(:class)
+        @confirm = confirm
+        @type = type
+        @method = method
+        @icon = icon
+        @block_given = block_given?
+        @content = block.call if block_given?
+      end
+      # rubocop:enable Metrics/MethodLength
+      def template
+        'active_element/components/button'
+      end
+      def locals # rubocop:disable Metrics/MethodLength
+        {
+          controller: controller,
+          method: link_method,
+          path: resource_path,
+          confirm: confirm,
+          type: type,
+          title: title,
+          float_class: float_class,
+          icon: icon,
+          button_class: button_class,
+          kwargs_class: kwargs_class,
+          kwargs: kwargs,
+          content: content,
+          block_given: block_given
+        }
+      end
+      private
+      attr_reader :controller, :record, :flag_or_options, :float, :kwargs, :kwargs_class, :type, :method, :icon,
+                  :block_given, :content, :confirm
+      def link_method
+        return method if method.present?
+        { show: :get, destroy: :delete, new: :get, edit: :get }.fetch(type, :get)
+      end
+      def button_class # rubocop:disable Metrics/MethodLength
+        case type
+        when :destroy
+          'btn-danger destroy-button action-button'
+        when :show
+          'btn-primary show-button action-button'
+        when :edit
+          'btn-primary edit-button action-button'
+        when :new
+          'btn-primary new-button action-button'
+        else
+          "btn-#{type}"
+        end
+      end
+      def float_class
+        { 'end' => 'float-end', 'start' => 'float-start', nil => nil }.fetch(float)
+      end
+      def namespace_prefix
+        # XXX: We guess the namespace from the current controller's module name. This will work
+        # most of the time but will break the current record's controller exists in a different
+        # namespace to the current controller, e.g. `BackEndAdmin::UsersController` and
+        # `FrontEndAdmin::ThemesController` - if `FrontEndAdmin::ThemesController` renders a
+        # collection of `User` objects, the "show" path will be wrong:
+        # `front_end_admin_user_path`. Maybe descend through the full controller class tree to
+        # find a best match ?
+        namespace = controller.class.name.deconstantize.underscore
+        return nil if namespace.blank?
+        "#{namespace}_"
+      end
+      def record_path
+        return nil if record.nil?
+        controller.helpers.public_send(default_record_path, record)
+      rescue NoMethodError
+        controller.helpers.public_send(sti_record_path, record)
+      end
+      def default_record_path
+        "#{record_path_prefix}#{namespace_prefix}#{record_name}_path"
+      end
+      def sti_record_path
+        "#{record_path_prefix}#{namespace_prefix}#{sti_record_name}_path"
+      end
+      def record_path_prefix
+        case type
+        when :edit
+          'edit_'
+        when :new
+          'new_'
+        end
+      end
+      def title
+        return flag_or_options[:title] if flag_or_options.is_a?(Hash) && flag_or_options[:title].present?
+        return default_action_title if %i[show destroy edit new].include?(type)
+        kwargs.fetch(:title, '')
+      end
+      def default_action_title
+        return 'View' if type == :show
+        return 'Delete' if type == :destroy
+        return 'Edit' if type == :edit
+        return "Create New #{(sti_record_name || record_name).titleize}" if type == :new
+      end
+      def resource_path
+        return record_path if flag_or_options == true && record.present?
+        return nil if !flag_or_options.is_a?(Hash) && record.blank?
+        return resource_path_from_options if resource_path_from_options.present?
+        record_path
+      end
+      def resource_path_from_options
+        return nil unless flag_or_options.is_a?(Hash)
+        return flag_or_options[:path].call(record) if flag_or_options[:path].is_a?(Proc)
+        flag_or_options[:path]
+      end
+      def record_name
+        Util.record_name(record)
+      end
+      def sti_record_name
+        Util.sti_record_name(record)
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/active_element/components/collection_table.rb ADDED Viewed

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+module ActiveElement
+  module Components
+    # A table component for rendering a collection of data.
+    class CollectionTable
+      include LinkHelpers
+      include SecretFields
+      include Translations
+      DEFAULT_PAGE_SIZE = 50
+      attr_reader :controller, :model_name
+      # rubocop:disable Metrics/MethodLength
+      def initialize(controller, class_name:, collection:, fields:, params:, model_name: nil, style: nil,
+                     show: false, new: false, edit: false, destroy: false, paginate: true, group: nil,
+                     group_title: false, row_class: nil, **_kwargs)
+        @controller = controller
+        @class_name = class_name
+        @model_name = model_name
+        @collection = collection || []
+        @fields = fields
+        @style = style
+        @params = params
+        @show = show
+        @new = new
+        @edit = edit
+        @destroy = destroy
+        @paginate = paginate
+        @group = group
+        @group_title = group_title
+        @row_class = row_class
+        verify_paginate_and_group
+      end
+      # rubocop:enable Metrics/MethodLength
+      def template
+        'active_element/components/table/collection'
+      end
+      def locals # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        {
+          component: self,
+          class_name: class_name,
+          collection: group ? collection : paginated_collection,
+          fields: Util::FieldMapping.new(self, fields, class_name).mapped_fields,
+          style: style,
+          new: new,
+          show: show,
+          edit: edit,
+          destroy: destroy,
+          group: group,
+          group_title: group_title,
+          display_pagination: display_pagination?,
+          page_sizes: [5, 10, 25, 50, 75, 100, 200],
+          page_size: page_size,
+          i18n: i18n,
+          row_class_mapper: row_class_mapper
+        }
+      end
+      def model
+        return collection.klass if collection.is_a?(ActiveRecord::Relation)
+        collection&.first.class.is_a?(ActiveModel::Naming) ? collection.first.class : nil
+      end
+      def grouped_collection
+        collection.group_by do |item|
+          item.class.is_a?(ActiveModel::Naming) ? item.public_send(group) : item.fetch(group)
+        end
+      end
+      private
+      attr_reader :class_name, :collection, :fields, :style, :row_class,
+                  :new, :show, :edit, :destroy,
+                  :paginate, :params, :group, :group_title
+      def paginated_collection
+        return collection unless paginate && collection.respond_to?(:page)
+        return collection.page(page_number).per(page_size) if supports_pagination_but_not_yet_paginated?
+        @paginated_collection ||= collection.page(page_number).per(page_size)
+      end
+      def supports_pagination_but_not_yet_paginated?
+        collection.respond_to?(:page) && !collection.respond_to?(:current_per_page)
+      end
+      def page_number
+        params[:page].presence || 1
+      end
+      def page_size
+        params[:page_size].presence || DEFAULT_PAGE_SIZE
+      end
+      def display_pagination?
+        return false if group.present?
+        return false unless paginate && paginated_collection.respond_to?(:total_count)
+        paginated_collection.total_count > (params[:page_size].presence&.to_i || DEFAULT_PAGE_SIZE)
+      end
+      def verify_paginate_and_group
+        return unless paginate == false && group.present?
+        raise ArgumentError, 'Cannot specify both `paginate: false` and a `group` argument.'
+      end
+      def row_class_mapper
+        row_class.is_a?(Proc) ? row_class : proc { row_class }
+      end
+    end
+  end
+end