active_element 0.0.10 → 0.0.12

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
+
+        def relation(field)
+          model&.reflect_on_association(field)
+        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_text_search_field(field)
+          [field, :text_search_field,
+           TextSearch.text_search_options(
+             model: relation(field).klass,
+             with: searchable_fields(field),
+             providing: relation(field).klass.primary_key
+           ).merge({ display_value: association_mapping(field).display_value, label: i18n.label(field) })]
+        end
+
+        def searchable_fields(field)
+          (Util.relation_controller(model, controller, field)&.active_element&.state&.searchable_fields || [])
+            .reject { |field| field.to_s.end_with?('_at') } # FIXME: Select strings/numbers only.
+        end
 
-          default_type_from_column_type(field, column.type)
+        def relation_primary_key(field)
+          relation(field).options.fetch(:primary_key) { relation_model.primary_key }
         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,48 @@ 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)
+          }.merge(field_options(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
+
+        def field_options(field)
+          return NumericField.new(field: field, column: column(field)).options if numeric?(field)
+
+          {}
+        end
+
+        def numeric?(field)
+          %i[float decimal integer].include?(column(field)&.type)
+        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/numeric_field.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Provides options for a `<input type="number" />` element based on database column properties.
+      class NumericField
+        def initialize(field:, column:)
+          @field = field
+          @column = column
+        end
+
+        def options
+          {
+            step: step,
+            min: min,
+            max: max
+          }.compact
+        end
+
+        private
+
+        attr_reader :field, :column
+
+        def step
+          return 'any' if column.blank?
+          return '1' if column.type == :integer
+          return 'any' if column.try(:scale).blank?
+
+          "0.#{'1'.rjust(column.scale, '0')}"
+        end
+
+        def min
+          return min_decimal if column.try(:precision).present?
+          return min_integer if column.try(:limit).present?
+
+          nil
+        end
+
+        def max
+          return max_decimal if column.try(:precision).present?
+          return max_integer if column.try(:limit).present?
+
+          nil
+        end
+
+        # XXX: This is the theoretical maximum value for a column with a given precision but,
+        # since the maximum database value is constrained by total significant figures (i.e.
+        # before and after the decimal point), an input can still be provided that would cause an
+        # error, so the default controller rescues `ActiveRecord::RangeError` to deal with this.
+        def max_decimal
+          '9' * column.precision
+        end
+
+        def min_decimal
+          "-#{'9' * column.precision}"
+        end
+
+        # `limit` represents available bytes for storing a signed integer e.g.
+        # 2**(8 * 8) / 2 - 1 == 9223372036854775807
+        # which matches PostgreSQL's `bigint` max value:
+        # https://www.postgresql.org/docs/current/datatype-numeric.html
+        def max_integer
+          ((2**(column.limit * 8)) / 2) - 1
+        end
+
+        def min_integer
+          -2**(column.limit * 8) / 2
+        end
+      end
+    end
+  end
+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

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

@@ -13,6 +13,10 @@ module ActiveElement
 
         def path
           record_path || sti_record_path
+        rescue NoMethodError
+          raise Error,
+                "Unable to map #{record.inspect} to a Rails route. Tried:\n" \
+                "#{[default_record_path, sti_record_path].compact.join("\n")}"
         end
 
         private
@@ -36,9 +40,20 @@ module ActiveElement
         def record_path
           return nil if record.nil?
 
-          controller.helpers.public_send(default_record_path, record)
+          controller.helpers.public_send(default_record_path, *path_arguments)
         rescue NoMethodError
-          controller.helpers.public_send(sti_record_path, record)
+          raise NoMethodError if sti_record_name.nil?
+
+          controller.helpers.public_send(sti_record_path, *path_arguments)
+        end
+
+        def path_arguments
+          case type
+          when :edit, :update, :show, :destroy
+            [record]
+          when :new, :index
+            []
+          end
         end
 
         def default_record_path
@@ -46,6 +61,8 @@ module ActiveElement
         end
 
         def sti_record_path
+          return nil if sti_record_name.nil?
+
           "#{record_path_prefix}#{namespace_prefix}#{sti_record_name}_path"
         end
 
@@ -63,9 +80,9 @@ module ActiveElement
 
         def record_path_prefix
           case type
-          when :edit, :update
+          when :edit
             'edit_'
-          when :new, :create
+          when :new
             'new_'
           end
         end

data/lib/active_element/components/util.rb

@@ -9,6 +9,7 @@ require_relative 'util/form_value_mapping'
 require_relative 'util/display_value_mapping'
 require_relative 'util/association_mapping'
 require_relative 'util/decorator'
+require_relative 'util/numeric_field'
 
 module ActiveElement
   module Components
@@ -29,18 +30,25 @@ module ActiveElement
       end
 
       def self.default_record_name(record)
-        record.class.name.demodulize.underscore
+        (record.is_a?(Class) ? record.name : record.class.name).demodulize.underscore
+      end
+
+      def self.relation_controller(model, controller, relation)
+        namespace = controller.controller_path.rpartition('/').first.presence
+        base = "#{model.reflect_on_association(relation).klass.name.pluralize}Controller"
+        return base.safe_constantize if namespace.nil?
+
+        "#{namespace.classify}::#{base}".safe_constantize || base.safe_constantize
       end
 
       def self.json_pretty_print(json)
-        theme = Rouge::Themes::Base16.mode(:light)
-        formatter = Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTMLInline.new(theme))
+        formatter = Rouge::Formatters::HTML.new
         lexer = Rouge::Lexers::JSON.new
         content = JSON.pretty_generate(json.is_a?(String) ? JSON.parse(json) : json)
-        formatted = formatter.format(lexer.lex(content)).gsub('  ', '  ')
+        formatted = formatter.format(lexer.lex(content)).gsub('  ', '&nbsp;&nbsp;').gsub("\n", '<br/>')
         # rubocop:disable Rails/OutputSafety
         # TODO: Move to a template.
-        "<div style='font-family: monospace;'>#{formatted}</div>".html_safe
+        "<div class='json-highlight' style='font-family: monospace;'>#{formatted}</div>".html_safe
         # rubocop:enable Rails/OutputSafety
       end
     end

data/lib/active_element/components.rb

@@ -2,8 +2,11 @@
 
 require_relative 'components/translations'
 require_relative 'components/secret_fields'
+require_relative 'components/email_fields'
+require_relative 'components/phone_fields'
 require_relative 'components/util'
 require_relative 'components/link_helpers'
+require_relative 'components/navbar'
 require_relative 'components/page_description'
 require_relative 'components/form'
 require_relative 'components/collection_table'

data/lib/active_element/controller_action.rb

@@ -11,7 +11,7 @@ module ActiveElement
 
     def process_action
       Rails.logger.info("#{ActiveElement.log_tag} #{colorized_permissions_message}")
-      return if verified_permissions?
+      process_pre_render and return if verified_permissions?
 
       warn "#{ActiveElement.log_tag} #{colorized_permissions_message}" if Rails.env.test?
       return controller.redirect_to redirect_path if redirect_to_default_landing_page?
@@ -30,6 +30,12 @@ module ActiveElement
       (@verified_permissions = permissions_check.permitted?)
     end
 
+    def process_pre_render
+      PreRenderProcessors::Json.new(controller: controller).process
+
+      true
+    end
+
     def redirect_path
       routes.alternative_routes.first.path
     end
@@ -72,7 +78,7 @@ module ActiveElement
       color = if permissions_check.permitted?
                 :green
               else
-                (rails_component.environment == 'test' ? :yellow : :red)
+                rails_component.environment == 'test' ? :yellow : :red
               end
       paintbrush { public_send(color, permissions_check.message) }
     end

data/lib/active_element/controller_interface.rb

@@ -5,7 +5,7 @@ module ActiveElement
   # Encapsulates core functionality such as `authenticate_with`, `permit_action`, and `component`
   # without polluting application controller namespace.
   class ControllerInterface
-    attr_reader :missing_template_store, :current_user
+    attr_reader :missing_template_store, :current_user, :assigned_editable_fields
 
     @state = {}
 
@@ -16,7 +16,7 @@ module ActiveElement
     def initialize(controller_class, controller_instance = nil)
       @controller_class = controller_class
       @controller_instance = controller_instance
-      initialize_state
+      initialize_state(controller_class)
       @missing_template_store = {}
       @authorize = false
     end
@@ -25,22 +25,64 @@ module ActiveElement
       @authorize
     end
 
+    def listable_fields(*args)
+      state.listable_fields.concat(args.map(&:to_sym)).uniq!
+    end
+
+    def viewable_fields(*args)
+      state.viewable_fields.concat(args.map(&:to_sym)).uniq!
+    end
+
+    def editable_fields(*args)
+      state.editable_fields.concat(args.map(&:to_sym)).uniq!
+    end
+
+    def searchable_fields(*args)
+      state.searchable_fields.concat(args.map(&:to_sym)).uniq!
+    end
+
+    def deletable
+      state.deletable = true
+    end
+
     def application_name
       RailsComponent.new(::Rails).application_name
     end
 
     def authenticate_with(&block)
-      state[:authenticator] = block
+      state.authenticator = block
     end
 
     def authorize_with(&block)
       @authorize = true
-      state[:authorizor] = block
+      state.authorizor = block
+    end
+
+    def sign_out_with(method: :get, &block)
+      state.sign_out_method = method
+      state.sign_out_path = block
+    end
+
+    def sign_out_path
+      state.sign_out_path&.call
+    end
+
+    delegate :sign_out_method, to: :state
+
+    def sign_in_with(method: :get, &block)
+      state.sign_in_method = method
+      state.sign_in_path = block
+    end
+
+    def sign_in_path
+      state.sign_in_path&.call
     end
 
+    delegate :sign_in_method, to: :state
+
     def authenticate
       authenticator&.call
-      @current_user = state[:authorizor]&.call
+      @current_user = state.authorizor&.call
 
       nil
     end
@@ -49,16 +91,12 @@ module ActiveElement
       raise ArgumentError, "Must specify `with: '<permission>'` or `always: true`" unless with.present? || always
       raise ArgumentError, 'Cannot specify both `with` and `always: true`' if with.present? && always
 
-      state[:permissions] << { with: with, always: always, action: action }
+      state.permissions << { with: with, always: always, action: action }
     end
 
-    def authenticator
-      state[:authenticator]
-    end
+    delegate :authenticator, to: :state
 
-    def permissions
-      state.fetch(:permissions)
-    end
+    delegate :permissions, to: :state
 
     def component
       return (@component ||= ActiveElement::Component.new(controller_instance)) unless controller_instance.nil?
@@ -66,16 +104,16 @@ module ActiveElement
       raise ArgumentError, 'Attempted to use ActiveElement component from a controller class method.'
     end
 
+    def state
+      self.class.state[controller_class]
+    end
+
     private
 
     attr_reader :controller_class, :controller_instance
 
-    def initialize_state
-      self.class.state[controller_class] ||= { permissions: [], authenticator: nil }
-    end
-
-    def state
-      self.class.state[controller_class]
+    def initialize_state(key)
+      self.class.state[key] ||= ControllerState.new(controller: controller_instance)
     end
   end
 end