active_element 0.0.10 → 0.0.12

data/lib/active_element/components/form.rb

@@ -10,20 +10,21 @@ module ActiveElement
       attr_reader :controller
 
       # rubocop:disable Metrics/MethodLength
-      def initialize(controller, fields:, submit:, item:, title: nil, destroy: false,
-                     modal: false, columns: 1, expanded: true, **kwargs)
+      def initialize(controller, fields:, submit:, item:, title: nil, destroy: false, search: false,
+                     modal: false, columns: 1, **kwargs)
         @controller = controller
         @fields = fields
         @title = title
         @submit = submit
         @destroy = destroy
-        @expanded = expanded
         @item = item
         @modal = modal
         @kwargs = kwargs
         @columns = columns
+        @search = search
         @action = kwargs.delete(:action) { default_action }
         @method = kwargs.delete(:method) { default_method }.to_s.downcase.to_sym
+        @tabindex = 1
       end
       # rubocop:enable Metrics/MethodLength
 
@@ -31,10 +32,10 @@ module ActiveElement
         'active_element/components/form'
       end
 
-      def locals # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def locals # rubocop:disable Metrics/MethodLength
         {
           component: self,
-          fields: Util::FormFieldMapping.new(record, fields, i18n).fields_with_types_and_options,
+          fields: form_field_mapping.fields_with_types_and_options,
           record: record,
           submit_label: submit_label,
           submit_position: submit_position,
@@ -44,7 +45,6 @@ module ActiveElement
           kwargs: kwargs,
           destroy: destroy,
           modal: modal,
-          expanded: expanded,
           columns: columns,
           title: title,
           id: form_id
@@ -61,6 +61,10 @@ module ActiveElement
         base_options_for_select(field, field_options)
       end
 
+      def full_error_message
+        record&.errors&.full_messages&.join(', ')
+      end
+
       def valid?(field = nil)
         return true if record.blank? || !record.changed?
 
@@ -93,14 +97,18 @@ module ActiveElement
         end&.first
       end
 
-      def value_for(field, default = nil)
-        return form_value_mapping_value(field) if record.class.is_a?(ActiveModel::Naming)
-        return default_record_value(field, default) if record.present? && record.respond_to?(field)
-        return item[field].presence || default if item.present?
+      def value_for(*field, default: nil)
+        return form_value_mapping_value(field.first) if record.class.is_a?(ActiveModel::Naming)
+        return default_record_value(field.first, default) if record.present? && record.respond_to?(field.first)
+        return nested_value(field).presence || default if item.present?
 
         default
       end
 
+      def nested_value(field)
+        field.reduce(item) { |hash, key| hash.fetch(key, {}) }
+      end
+
       def form_value_mapping_value(field)
         Util::FormValueMapping.new(component: self, record: record, field: field).value
       end
@@ -114,7 +122,7 @@ module ActiveElement
       end
 
       def value_for_json_array_field(field, schema_field, element_index = nil)
-        array = value_for(field, {}).fetch(schema_field[:name], [])
+        array = value_for(field, default: {}).fetch(schema_field[:name], [])
         return array if element_index.nil?
 
         array.fetch(element_index, nil)
@@ -130,13 +138,27 @@ module ActiveElement
         record&.class
       end
 
+      def tabindex
+        (@tabindex += 1)
+      end
+
       private
 
       attr_reader :fields, :submit, :title, :kwargs, :item, :method, :action,
-                  :destroy, :modal, :expanded, :columns
+                  :destroy, :modal, :columns, :search
+
+      def form_field_mapping
+        @form_field_mapping ||= Util::FormFieldMapping.new(
+          record: record,
+          controller: controller,
+          fields: fields,
+          i18n: i18n,
+          search: search
+        )
+      end
 
       def valid_field?(field)
-        return true if record.respond_to?("#{field}_changed?") && !record.public_send("#{field}_changed?")
+        return true if record.respond_to?(:changed?) && !record.changed?
 
         record&.errors.blank? || record.errors.full_messages_for(field).blank?
       end
@@ -157,7 +179,7 @@ module ActiveElement
 
       def submit_label_from_model
         return "Create #{humanized_model_name}" if record.present? && method == :post
-        return "Update #{humanized_model_name}" if record.present? && %i[patch put].include?(method)
+        return 'Save Changes' if record.present? && %i[patch put].include?(method)
 
         nil
       end
@@ -189,7 +211,7 @@ module ActiveElement
       end
 
       def form_id
-        kwargs.fetch(:id) { "form-#{SecureRandom.uuid}" }
+        kwargs.fetch(:id) { ActiveElement.element_id }
       end
 
       def autoformat(val, field_options)
@@ -209,10 +231,19 @@ module ActiveElement
         end
       end
 
+      def default_action_type
+        case controller.action_name
+        when 'new', 'create'
+          :create
+        when 'edit', 'update'
+          :update
+        end
+      end
+
       def default_action
-        return controller.request.path unless record.is_a?(ActiveModel::Naming)
+        return controller.request.path unless record.class.is_a?(ActiveModel::Naming)
 
-        Util::RecordPath.new(record: record, controller: controller).path
+        Util::RecordPath.new(record: record, controller: controller, type: default_action_type).path
       end
     end
   end

data/lib/active_element/components/navbar.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # A navigation bar providing links to areas within the application.
+    class Navbar
+      include Translations
+
+      attr_reader :controller
+
+      def initialize(controller, items: nil, fixed: true)
+        @controller = controller
+        @items = items
+        @fixed = fixed
+      end
+
+      def template
+        'active_element/components/navbar'
+      end
+
+      def locals
+        {
+          component: self,
+          items: items,
+          fixed: fixed
+        }
+      end
+
+      def active_path_class(current_navbar_item:)
+        if ActiveMenuLink.new(
+          rails_component: RailsComponent.new(Rails),
+          navbar_items: items,
+          current_path: controller.request.path,
+          current_navbar_item: current_navbar_item,
+          controller_path: controller.controller_path,
+          action_name: controller.action_name
+        ).active?
+          'active'
+        end
+      end
+
+      private
+
+      attr_reader :fixed
+
+      def items
+        return @items unless @items.nil?
+
+        ActiveElement.eager_load_controllers
+
+        @items ||= user_routes(controller.active_element.current_user).available.select(&:primary?).map do |route|
+          { path: route.path, title: route.title, spec: route.spec }
+        end
+      end
+
+      def user_routes(user)
+        ActiveElement::Routes.new(
+          permissions: user&.permissions,
+          rails_component: ActiveElement::RailsComponent.new(Rails)
+        )
+      end
+    end
+  end
+end

data/lib/active_element/components/phone_fields.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Provides a convenience method for detecting a field should be classified as a phone number.
+    module PhoneFields
+      PHONE_FIELDS = %w[phone telephone tel mobile].freeze
+
+      def phone_field?(field)
+        PHONE_FIELDS.any? { |phone_field| field.to_s.downcase.split('_').include?(phone_field) }
+      end
+    end
+  end
+end

data/lib/active_element/components/text_search/authorization.rb

@@ -20,12 +20,12 @@ module ActiveElement
           end
         end
 
-        def initialize(model:, params:, user:, search_columns:, result_columns:)
+        def initialize(model:, params:, user:, search_columns:, value_column:)
           @model = model
           @params = params
           @user = user
           @search_columns = search_columns
-          @result_columns = result_columns
+          @value_column = value_column
         end
 
         def authorized?
@@ -45,14 +45,15 @@ module ActiveElement
 
         private
 
-        attr_reader :model, :params, :user, :search_columns, :result_columns
+        attr_reader :model, :params, :user, :search_columns, :value_column
 
         def development_message
           paintbrush { green "Bypassed text search authorization in development environment: #{yellow message}" }
         end
 
         def missing_permissions
-          (search_columns + result_columns).reject { |column| user_permitted?(column) }
+          (search_columns + [value_column]).reject { |column| user_permitted?(column) }
+                                           .compact_blank
                                            .map { |column| permission_for(column.name) }
                                            .uniq
                                            .sort
@@ -87,6 +88,8 @@ module ActiveElement
         end
 
         def user_permitted?(column)
+          return false if column.blank?
+
           user&.permissions&.include?(permission_for(column.name))
         end
 
@@ -99,10 +102,10 @@ module ActiveElement
         end
 
         def authorized_model?
-          TextSearch.authorized_text_searches.any? do |authorized_model, search_fields, result_fields|
+          TextSearch.authorized_text_searches.any? do |authorized_model, search_fields, value_field|
             next false unless authorized_model == model
             next false unless authorized_fields?(search_columns, Array(search_fields))
-            next false unless authorized_fields?(result_columns, Array(result_fields))
+            next false unless authorized_fields?(Array(value_column), Array(value_field))
 
             true
           end

data/lib/active_element/components/text_search/component.rb

@@ -92,7 +92,9 @@ module ActiveElement
         end
 
         def model
-          @model ||= params[:model].camelize(:upper).safe_constantize
+          @model ||= ActiveRecord::Base.descendants.find do |descendant|
+            descendant.name == params[:model].camelize(:upper)
+          end
         end
 
         def authorization
@@ -101,7 +103,7 @@ module ActiveElement
             params: params,
             user: controller.active_element.current_user,
             search_columns: sql.search_columns.compact,
-            result_columns: (sql.search_columns + [sql.value_column]).compact
+            value_column: sql.value_column
           )
         end
 

data/lib/active_element/components/text_search.rb

@@ -17,6 +17,19 @@ module ActiveElement
         def register_authorized_text_search(model:, with:, providing:)
           authorized_text_searches << [model, with, providing]
         end
+
+        def text_search_options(model:, with:, providing:)
+          {
+            search: { model: model.name.underscore, with: with, providing: providing },
+            placeholder: "Search for #{model.name.titleize} by #{humanized_names(with).join(', ')}..."
+          }
+        end
+
+        private
+
+        def humanized_names(names)
+          Array(names).compact.map.map(&:to_s).map(&:humanize)
+        end
       end
     end
   end

data/lib/active_element/components/util/association_mapping.rb

@@ -3,10 +3,11 @@
 module ActiveElement
   module Components
     module Util
-      # Utility class for mapping an association to a linked URL (e.g. for displaying associations in a table).
+      # Utility class for mapping an association to a linked URL display value, (e.g. for
+      # displaying associations in a table, form, etc.).
       class AssociationMapping
-        def initialize(component:, field:, record:, associated_record:, options:)
-          @component = component
+        def initialize(controller:, field:, record:, associated_record:, options: {})
+          @controller = controller
           @field = field
           @record = record
           @associated_record = associated_record
@@ -15,19 +16,49 @@ module ActiveElement
 
         def link_tag
           verify_display_attribute
-          return display_value if associated_record_path.blank?
+          return associated_record.map { |value| link_to(value) } if multiple_association?
+          return link_to(associated_record) if single_association?
+        end
 
-          component.controller.helpers.link_to(display_value, associated_record_path)
+        def relation_id # rubocop:disable Metrics/CyclomaticComplexity
+          case relation.macro
+          when :has_one
+            associated_record&.public_send(relation_key)
+          when :has_many
+            associated_record&.map(&relation_key)
+          when :belongs_to
+            record&.public_send(relation_key)
+          end
+        end
+
+        def relation_key
+          case relation.macro
+          when :has_one, :has_many
+            relation.klass.primary_key
+          when :belongs_to
+            relation.foreign_key
+          end
+        end
+
+        def display_value(value = associated_record)
+          return value&.public_send(display_field) if display_field.present?
+          return nil if associated_model&.primary_key.blank?
+
+          value.public_send(associated_model.primary_key)
         end
 
         private
 
-        attr_reader :component, :field, :record, :associated_record, :options
+        attr_reader :controller, :field, :record, :associated_record, :options
+
+        def relation
+          @relation ||= record.class.reflect_on_association(field)
+        end
 
-        def associated_record_path
-          return nil unless component.controller.helpers.respond_to?(path_helper)
+        def associated_record_path(path_for)
+          return nil unless controller.helpers.respond_to?(path_helper)
 
-          component.controller.helpers.public_send(path_helper, associated_record)
+          controller.helpers.public_send(path_helper, path_for)
         end
 
         def verify_display_attribute
@@ -38,42 +69,66 @@ module ActiveElement
                 "`#{associated_record.class.name}.default_display_attribute`"
         end
 
-        def display_value
-          associated_record.public_send(display_field)
-        end
-
         def display_field
           @display_field ||= options.fetch(:attribute) do
-            next associated_record.class.default_display_attribute if defined_display_attribute?
+            next associated_model.default_display_attribute if defined_display_attribute?
             next default_display_attribute if default_display_attribute.present?
 
-            associated_record.class.primary_key
+            associated_model.primary_key
           end
         end
 
         def defined_display_attribute?
-          associated_record.class.respond_to?(:default_display_attribute)
+          associated_model.respond_to?(:default_display_attribute)
         end
 
         def namespace
-          component.controller.class.name.deconstantize.underscore
+          controller.class.name.deconstantize.underscore
         end
 
         def resource_name
-          record.public_send(field).model_name.singular
+          record.public_send(field)&.model_name&.singular
         end
 
         def default_display_attribute
           %i[name email display_name username].find do |display_field|
-            associated_record.respond_to?(display_field) && associated_record.method(display_field).arity.zero?
+            next true if associated_model_callable_method?(display_field.to_sym)
+            next true if associated_model.columns.map(&:name).map(&:to_sym).include?(display_field.to_sym)
+
+            false
           end
         end
 
+        def associated_model
+          record.association(field).klass
+        end
+
+        def associated_model_callable_method?(name)
+          return false unless associated_model.public_instance_methods.include?(name)
+          return false unless associated_model.public_instance_method(name).arity.zero?
+
+          true
+        end
+
+        def single_association?
+          %i[has_one belongs_to].include?(relation.macro)
+        end
+
+        def multiple_association?
+          relation.macro == :has_many
+        end
+
         def path_helper
           return "#{resource_name}_path" if namespace.blank?
 
           "#{namespace}_#{resource_name}_path"
         end
+
+        def link_to(value)
+          return display_value(value) if associated_record_path(value).blank?
+
+          controller.helpers.link_to(display_value(value), associated_record_path(value))
+        end
       end
     end
   end

data/lib/active_element/components/util/display_value_mapping.rb

@@ -7,12 +7,21 @@ module ActiveElement
       class DisplayValueMapping
         include RecordMapping
 
+        def mapped_association_from_record
+          association_mapping.link_tag
+        end
+
         def numeric_value
           value_from_record
         end
 
         def json_value
-          ActiveElement.json_pretty_print(value_from_record)
+          return ActiveElement.json_pretty_print(value_from_record) unless component.is_a?(CollectionTable)
+
+          component.controller.render_to_string(
+            partial: 'active_element/components/fields/json',
+            locals: { value: value_from_record, field_id: ActiveElement.element_id }
+          )
         end
 
         def string_value
@@ -20,15 +29,15 @@ module ActiveElement
         end
 
         def datetime_value
-          value_from_record.strftime('%Y-%m-%d %H:%M:%S')
+          with_timezone_offset(value_from_record).strftime('%Y-%m-%d %H:%M:%S')
         end
 
         def time_value
-          value_from_record.strftime('%H:%M:%S')
+          with_timezone_offset(value_from_record).strftime('%H:%M:%S')
         end
 
         def date_value
-          value_from_record.strftime('%Y-%m-%d')
+          with_timezone_offset(value_from_record).strftime('%Y-%m-%d')
         end
 
         def boolean_value