active_element 0.0.10 → 0.0.11

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,10 @@ 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 } }
+        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

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

@@ -4,13 +4,17 @@ module ActiveElement
   module Components
     module Util
       # Normalizes Form `fields` parameter from various supported input formats.
-      class FormFieldMapping
+      class FormFieldMapping # rubocop:disable Metrics/ClassLength
         include SecretFields
+        include PhoneFields
+        include EmailFields
 
-        def initialize(record, fields, i18n)
+        def initialize(record:, fields:, controller:, i18n:, search: false)
           @record = record
           @fields = fields
+          @controller = controller
           @i18n = i18n
+          @search = search
         end
 
         def fields_with_types_and_options
@@ -28,7 +32,7 @@ module ActiveElement
 
         private
 
-        attr_reader :fields, :i18n, :record
+        attr_reader :fields, :i18n, :record, :controller, :search
 
         def normalized_field?(field)
           (field.size == 3) && field.last.is_a?(Hash)
@@ -43,29 +47,116 @@ module ActiveElement
         end
 
         def field_with_default_type_and_default_options(field)
-          [field, default_type_from_model(field), {}]
+          return [field, type_from_file(field).to_sym, options_from_file(field)] if file_configuration?(field)
+          return relation_text_search_field(field) if relation?(field) && record.present? && !search?
+
+          [field, default_type_from_model(field), default_options(field)]
         end
 
         def field_with_type(field)
-          [field.first, field.last, {}]
+          [field.first, field.last, default_options(field)]
+        end
+
+        def association_mapping(field)
+          @association_mapping ||= AssociationMapping.new(
+            controller: controller,
+            field: field,
+            record: record,
+            associated_record: record.public_send(field)
+          )
+        end
+
+        def file_configuration?(field)
+          # XXX: json_field schema is loaded separately so we ignore file configuration here.
+          # This does prevent specifying an alternative field type in a config file but can still
+          # be defined inline if e.g. a user wants a text_area instead of a json_field:
+          #
+          #   active_element.component.form fields: [:foo, :bar, [:some_json_field, :text_area]]
+          #
+          file_configuration_path(field).file? && default_type_from_model(field) != :json_field
+        end
+
+        def type_from_file(field)
+          YAML.safe_load(file_configuration_path(field).read, symbolize_names: true)
+              .fetch(:type, default_type_from_model(field))
+        end
+
+        def options_from_file(field)
+          YAML.safe_load(file_configuration_path(field).read, symbolize_names: true).fetch(:options, {})
+        end
+
+        def file_configuration_path(field)
+          record_field_configuration_path(field) || sti_field_configuration_path(field)
+        end
+
+        def record_field_configuration_path(field)
+          record_name = Util.record_name(record)
+          return nil if record_name.blank?
+
+          Rails.root.join('config/forms', record_name, "#{field}.yml")
+        end
+
+        def sti_record_field_configuration_path(field)
+          sti_record_name = Util.sti_record_name(record)
+          return nil if sti_record_name.blank?
+
+          Rails.root.join('config/forms', sti_record_name, "#{field}.yml")
         end
 
         def default_type_from_model(field)
           return default_field_type(field) if record.blank?
+          return default_field_type(field) if column(field).blank?
+
+          default_type_from_column_type(field, column(field).type)
+        end
+
+        def column(field)
+          model&.columns&.find { |model_column| model_column.name.to_s == field.to_s }
+        end
+
+        def model
+          record&.class || controller.controller_name.classify.safe_constantize
+        end
+
+        def relation?(field)
+          relation(field).present?
+        end
 
-          column = record.class.columns.find { |model_column| model_column.name.to_s == field.to_s }
-          return default_field_type(field) if column.blank?
+        def relation(field)
+          model&.reflect_on_association(field)
+        end
+
+        def relation_text_search_field(field)
+          relation_model = relation(field).klass
+          record.public_send(field)
+          [field, :text_search_field,
+           TextSearch.text_search_options(
+             model: relation_model,
+             with: searchable_fields(field),
+             providing: relation_model.primary_key
+           ).merge({ display_value: association_mapping(field).display_value })]
+        end
 
-          default_type_from_column_type(field, column.type)
+        def searchable_fields(field)
+          Util.relation_controller(model, controller, field)
+              .active_element
+              .state
+              .fetch(:searchable_fields, [])
         end
 
-        def default_type_from_column_type(field, column_type)
+        def default_type_from_column_type(field, column_type) # rubocop:disable Metrics/MethodLength
           {
             string: default_field_type(field),
             boolean: :check_box,
             json: :json_field,
             jsonb: :json_field,
-            geometry: :text_area
+            geometry: :text_area,
+            datetime: :datetime_field,
+            date: :date_field,
+            time: :time_field,
+            integer: :number_field,
+            decimal: :number_field,
+            float: :number_field
           }.fetch(column_type.to_sym, default_field_type(field))
         end
 
@@ -94,10 +185,36 @@ module ActiveElement
         end
 
         def default_field_type(field)
+          return default_search_field_type(field) if search?
           return :password_field if secret_field?(field)
+          return :email_field if email_field?(field)
+          return :phone_field if phone_field?(field)
+
+          :text_field
+        end
+
+        def search?
+          search
+        end
+
+        def default_search_field_type(field)
+          return :datetime_range_field if column(field)&.type == :datetime
 
           :text_field
         end
+
+        def default_options(field)
+          { required: required?(field) }
+        end
+
+        def required?(field)
+          return false if record.blank?
+          return false unless record.class.respond_to?(:validators)
+
+          record.class.validators.find do |validator|
+            validator.kind == :presence && validator.attributes.include?(field.to_sym)
+          end
+        end
       end
     end
   end

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

@@ -20,15 +20,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

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

@@ -7,7 +7,7 @@ module ActiveElement
       # descriptions, placeholders, etc. for various components in locales files.
       class I18n
         def self.class_name(val, plural: false)
-          base = val&.to_s&.underscore&.tr('_', '-')&.tr('/', '-')
+          base = val&.to_s&.underscore&.tr('/', '_')
           plural ? base&.pluralize : base
         end
 

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

@@ -49,41 +49,60 @@ module ActiveElement
         end
 
         def mapped_value_from_record
-          return mapped_association_from_record if value_from_record.class.is_a?(ActiveModel::Naming)
+          return mapped_association_from_record if association?
           return nil if value_from_record.nil?
           return value_from_record unless DATABASE_TYPES.include?(column.type) || value_from_record.blank?
 
           send("#{column.type}_value")
         end
 
-        def mapped_association_from_record
-          AssociationMapping.new(
-            component: component,
+        def association_mapping
+          @association_mapping ||= AssociationMapping.new(
+            controller: component.controller,
             field: field,
             record: record,
             associated_record: value_from_record,
             options: options
-          ).link_tag
+          )
         end
 
         # Override these methods as required in a class that includes this module:
 
+        def mapped_association_from_record
+          association_mapping.relation_id
+        end
+
         def numeric_value
           value_from_record
         end
-        alias integer_value numeric_value
-        alias decimal_value numeric_value
-        alias float_value numeric_value
+
+        def integer_value
+          numeric_value
+        end
+
+        def decimal_value
+          numeric_value
+        end
+
+        def float_value
+          numeric_value
+        end
 
         def json_value
           value_from_record
         end
-        alias jsonb_value json_value
+
+        def jsonb_value
+          json_value
+        end
 
         def string_value
           value_from_record
         end
-        alias text_value string_value
+
+        def text_value
+          string_value
+        end
 
         def datetime_value
           value_from_record
@@ -100,11 +119,24 @@ module ActiveElement
         def boolean_value
           value_from_record
         end
-        alias binary_value boolean_value
+
+        def binary_value
+          boolean_value
+        end
 
         def geometry_value
           value_from_record
         end
+
+        def timezone_offset
+          component.controller.request.cookies['timezone_offset'].to_i.minutes
+        end
+
+        def with_timezone_offset(val)
+          return val if val.blank?
+
+          val - timezone_offset
+        end
       end
     end
   end