active_element 0.0.1 → 0.0.3

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Utility class for converting field names to labels, CSS classes, and data mappers.
+      class FieldMapping # rubocop:disable Metrics/ClassLength
+        include Translations
+
+        def initialize(component, fields, class_name)
+          @component = component
+          @class_name = class_name
+          @fields = fields
+        end
+
+        def mapped_fields
+          fields.map do |field|
+            [
+              field,
+              class_mapper(field),
+              field_to_label(field),
+              decorated_value_mapper(field),
+              options(field)
+            ]
+          end
+        end
+
+        delegate :model, to: :component
+
+        private
+
+        attr_reader :component, :fields, :class_name
+
+        def options(field)
+          { description: i18n.description(field) }
+        end
+
+        def decorated_value_mapper(field)
+          proc do |item|
+            Decorator.new(
+              component: component,
+              item: item,
+              field: field,
+              value: value_mapper(field).call(item)
+            ).decorated_value
+          end
+        end
+
+        def field_to_label(field)
+          return 'ID' if field == :id # Move to i18n if this gets more complex.
+          return i18n.label(field.first) if field.is_a?(Array)
+
+          i18n.label(field)
+        end
+
+        def value_mapper(field)
+          case field
+          when String, Symbol
+            default_value_mapper(field)
+          when Array
+            field.last.fetch(:mapper) { default_value_mapper(*field) }
+          end
+        end
+
+        def class_mapper(field)
+          proc do |item|
+            next default_record_classes(field, item).compact.join(' ') if item.class.is_a?(ActiveModel::Naming)
+
+            field_class(field)
+          end
+        end
+
+        def default_value_mapper(field, options = nil)
+          proc do |item|
+            next default_record_value(field, item, options) if item.class.is_a?(ActiveModel::Naming)
+            next item.public_send(field) if item.respond_to?(field)
+            next item[field] if hash_field?(item, field)
+
+            nil
+          end
+        end
+
+        def hash_field?(item, field)
+          item.respond_to?(:[]) && item.respond_to?(:key?) && item.key?(field)
+        end
+
+        def default_record_value(field, record, options)
+          Util::DisplayValueMapping.new(
+            component: component,
+            field: field,
+            record: record,
+            options: options
+          ).value
+        end
+
+        def default_record_classes(field, record)
+          if field.is_a?(Array)
+            return [
+              inferred_class(field.first, record, field.last),
+              field_class(field, field.last),
+              field.last[:class]
+            ]
+          end
+
+          [inferred_class(field, record), field_class(field)]
+        end
+
+        def inferred_class(field, record, options = nil)
+          {
+            integer: 'font-monospace', decimal: 'font-monospace', float: 'font-monospace',
+            datetime: 'font-monospace', date: 'font-monospace', time: 'font-monospace'
+          }.fetch(
+            Util::DisplayValueMapping.new(
+              component: component, field: field, record: record, options: options
+            ).type,
+            nil
+          )
+        end
+
+        def field_to_name(field)
+          return field.to_s if field.is_a?(Symbol) || field.is_a?(String)
+          return Util::I18n.class_name(field.first) if field.is_a?(Array)
+
+          nil
+        end
+
+        def field_class(field, options = {})
+          field_name = field_to_name(field)
+          base = class_name.blank? ? field_name : "#{class_name}-#{field_name}"
+          [base, format_classes(field_name, options.fetch(:format, nil))].flatten.compact.join(' ')
+        end
+
+        def format_classes(field_name, format_from_options)
+          format_from_translation = i18n.format(field_name)
+          [format_class(format_from_translation), format_class(format_from_options)].compact
+        end
+
+        def format_class(format)
+          { bold: 'fw-bold', monospace: 'font-monospace' }.fetch(format&.to_sym, nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Normalizes Form `fields` parameter from various supported input formats.
+      class FormFieldMapping
+        include SecretFields
+
+        def initialize(record, fields, i18n)
+          @record = record
+          @fields = fields
+          @i18n = i18n
+        end
+
+        def fields_with_types_and_options
+          compiled_fields = fields.map do |field|
+            next field_with_default_type_and_default_options(field) unless field.is_a?(Array)
+            next field if normalized_field?(field)
+            next field_with_default_type_and_provided_options(field) if field_name_with_options?(field)
+            next field_with_type(field) if field_name_with_type?(field)
+
+            raise_unrecognized_field_format(field)
+          end
+
+          fields_with_default_label(compiled_fields)
+        end
+
+        private
+
+        attr_reader :fields, :i18n, :record
+
+        def normalized_field?(field)
+          (field.size == 3) && field.last.is_a?(Hash)
+        end
+
+        def field_name_with_options?(field)
+          field.size == 2 && field.last.is_a?(Hash)
+        end
+
+        def field_name_with_type?(field)
+          field.size == 2
+        end
+
+        def field_with_default_type_and_default_options(field)
+          [field, default_type_from_model(field), {}]
+        end
+
+        def field_with_type(field)
+          [field.first, field.last, {}]
+        end
+
+        def default_type_from_model(field)
+          return default_field_type(field) if record.blank?
+
+          column = record.class.columns.find { |model_column| model_column.name.to_s == field.to_s }
+          return default_field_type(field) if column.blank?
+
+          default_type_from_column_type(field, column.type)
+        end
+
+        def default_type_from_column_type(field, column_type)
+          {
+            string: default_field_type(field),
+            boolean: :check_box,
+            json: :json_field,
+            jsonb: :json_field,
+            geometry: :text_area
+          }.fetch(column_type.to_sym, default_field_type(field))
+        end
+
+        def field_with_default_type_and_provided_options(field)
+          [field.first, default_field_type(field), field.last]
+        end
+
+        def fields_with_default_label(fields)
+          fields.map do |field, type, options|
+            [field, type, options_with_inferred_translations(field, options)]
+          end
+        end
+
+        def raise_unrecognized_field_format(field)
+          raise ArgumentError, "Unexpected field format: #{field}, expected one of: " \
+                               ':field_name, [:field_name, :text_field], ' \
+                               "or [:field_name, :text_field, { label: 'Field Name', ... }"
+        end
+
+        def options_with_inferred_translations(field, options)
+          options.reverse_merge({
+                                  label: i18n.label(field),
+                                  description: i18n.description(field),
+                                  placeholder: i18n.placeholder(field)
+                                })
+        end
+
+        def default_field_type(field)
+          return :password_field if secret_field?(field)
+
+          :text_field
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Maps ActiveRecord record fields to values for editing in forms.
+      class FormValueMapping
+        include RecordMapping
+
+        def numeric_value
+          value_from_record
+        end
+
+        def json_value
+          value_from_record
+        end
+
+        def string_value
+          value_from_record
+        end
+
+        def datetime_value
+          value_from_record.strftime('%Y-%m-%d %H:%M:%S')
+        end
+
+        def time_value
+          value_from_record.strftime('%H:%M:%S')
+        end
+
+        def date_value
+          value_from_record.strftime('%Y-%m-%d')
+        end
+
+        def boolean_value
+          value_from_record
+          component.controller.render_to_string(
+            partial: 'active_element/components/fields/boolean',
+            locals: { value: value_from_record }
+          )
+        end
+
+        def geometry_value
+          require 'rgeo/geo_json'
+          RGeo::GeoJSON.encode(value_from_record).to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Translates various parameters using `I18n` library, allows users to specify labels,
+      # 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('/', '-')
+          plural ? base&.pluralize : base
+        end
+
+        def initialize(component)
+          @component = component
+        end
+
+        def label(field)
+          return titleize(field) unless model?
+
+          key = "admin.models.#{model_key}.fields.#{field}.label"
+          ::I18n.t(key, default: titleize(field))
+        end
+
+        def description(field)
+          return nil unless model?
+
+          key = "admin.models.#{model_key}.fields.#{field}.description"
+          ::I18n.t(key, default: nil)
+        end
+
+        def placeholder(field)
+          return nil unless model?
+
+          key = "admin.models.#{model_key}.fields.#{field}.placeholder"
+          ::I18n.t(key, default: nil)
+        end
+
+        def format(field)
+          return nil unless model?
+
+          key = "admin.models.#{model_key}.fields.#{field}.format"
+          ::I18n.t(key, default: nil)
+        end
+
+        private
+
+        attr_reader :component
+
+        def model_key
+          @model_key ||= component.model.name.underscore.pluralize
+        end
+
+        def model?
+          return false if component.model.nil?
+
+          component.model.is_a?(ActiveModel::Naming)
+        end
+
+        def titleize(field)
+          field.to_s.titleize(keep_id_suffix: true).gsub(/ Id$/, ' ID')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Maps ActiveRecord record columns and fields to values.
+      module RecordMapping
+        DATABASE_TYPES = %i[
+          string json jsonb integer decimal float datetime time date boolean binary geometry
+        ].freeze
+
+        def initialize(component:, record:, field:, options: {})
+          @component = component
+          @record = record
+          @field = field
+          @options = options
+        end
+
+        def value
+          return mapped_value_from_record if association? || column.present?
+
+          value_from_record
+        end
+
+        def type
+          column&.type
+        end
+
+        private
+
+        attr_reader :component, :record, :field, :options
+
+        def column
+          return nil unless record.is_a?(ActiveRecord::Base)
+
+          @column ||= record.class.columns.find { |model_column| model_column.name.to_s == field.to_s }
+        end
+
+        def association?
+          return false unless record.is_a?(ActiveRecord::Base)
+
+          record.association(field).present?
+        rescue ActiveRecord::AssociationNotFoundError
+          false
+        end
+
+        def value_from_record
+          record.public_send(field) if record.respond_to?(field)
+        end
+
+        def mapped_value_from_record
+          return mapped_association_from_record if value_from_record.class.is_a?(ActiveModel::Naming)
+          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,
+            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 numeric_value
+          value_from_record
+        end
+        alias integer_value numeric_value
+        alias decimal_value numeric_value
+        alias float_value numeric_value
+
+        def json_value
+          value_from_record
+        end
+        alias jsonb_value json_value
+
+        def string_value
+          value_from_record
+        end
+        alias text_value string_value
+
+        def datetime_value
+          value_from_record
+        end
+
+        def time_value
+          value_from_record
+        end
+
+        def date_value
+          value_from_record
+        end
+
+        def boolean_value
+          value_from_record
+        end
+        alias binary_value boolean_value
+
+        def geometry_value
+          value_from_record
+        end
+      end
+    end
+  end
+end

data/lib/active_element/components/util.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'util/i18n'
+require_relative 'util/record_mapping'
+require_relative 'util/field_mapping'
+require_relative 'util/form_field_mapping'
+require_relative 'util/form_value_mapping'
+require_relative 'util/display_value_mapping'
+require_relative 'util/association_mapping'
+require_relative 'util/decorator'
+
+module ActiveElement
+  module Components
+    # Utility classes for components (data mapping from models, etc.)
+    module Util
+      def self.json_name(name)
+        name.to_s.camelize(:lower)
+      end
+
+      def self.record_name(record)
+        record&.try(:model_name)&.try(&:singular) || record.class.name.demodulize.underscore
+      end
+
+      def self.sti_record_name(record)
+        return nil unless record.class.respond_to?(:inheritance_column)
+
+        record&.class&.superclass&.model_name&.singular if record&.try(record.class.inheritance_column).present?
+      end
+
+      def self.json_pretty_print(json)
+        theme = Rouge::Themes::Base16.mode(:light)
+        formatter = Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTMLInline.new(theme))
+        lexer = Rouge::Lexers::JSON.new
+        content = JSON.pretty_generate(json.is_a?(String) ? JSON.parse(json) : json)
+        formatted = formatter.format(lexer.lex(content)).gsub('  ', '  ')
+        # rubocop:disable Rails/OutputSafety
+        # TODO: Move to a template.
+        "<div style='font-family: monospace;'>#{formatted}</div>".html_safe
+        # rubocop:enable Rails/OutputSafety
+      end
+    end
+  end
+end

data/lib/active_element/components.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'components/translations'
+require_relative 'components/secret_fields'
+require_relative 'components/util'
+require_relative 'components/link_helpers'
+require_relative 'components/page_description'
+require_relative 'components/form'
+require_relative 'components/collection_table'
+require_relative 'components/item_table'
+require_relative 'components/button'
+require_relative 'components/tabs'
+require_relative 'components/tab'
+require_relative 'components/json'
+
+module ActiveElement
+  # Standardised HTML components to be used in admin front ends.
+  module Components
+  end
+end

data/lib/active_element/controller_action.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Processes all controller actions, verifies permissions, issues redirects, etc.
+  class ControllerAction
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def process_action
+      Rails.logger.info("[#{log_tag}] #{colorized_permissions_message}")
+      return if verified_permissions?
+
+      warn "[#{log_tag}] #{colorized_permissions_message}" if Rails.env.test?
+      return controller.redirect_to redirect_path if redirect_to_default_landing_page?
+
+      render_forbidden
+    end
+
+    private
+
+    attr_reader :controller
+
+    def verified_permissions?
+      return @verified_permissions if defined?(@verified_permissions)
+
+      (@verified_permissions = permissions_check.permitted?)
+    end
+
+    def redirect_path
+      routes.alternative_routes.first.path
+    end
+
+    def render_forbidden
+      return render_json_forbidden if controller.request.format == :json
+
+      controller.render 'active_element/forbidden',
+                        layout: 'active_element_error',
+                        status: :forbidden,
+                        locals: {
+                          missing_permissions: permissions_check.missing,
+                          alternatives: routes.alternative_routes
+                        }
+    end
+
+    def render_json_forbidden
+      controller.render json: { message: "Missing permission(s): #{permissions_check.missing}" },
+                        status: :forbidden
+    end
+
+    def permissions_check
+      @permissions_check ||= PermissionsCheck.new(
+        required: controller.class.active_element_permissions,
+        actual: controller.current_user&.permissions,
+        controller_path: controller.controller_path,
+        action_name: controller.action_name,
+        rails_component: rails_component
+      )
+    end
+
+    def routes
+      @routes ||= Routes.new(
+        permissions: controller.current_user.permissions,
+        rails_component: rails_component
+      )
+    end
+
+    def colorized_permissions_message
+      color = if permissions_check.permitted?
+                :green
+              else
+                (rails_component.environment == 'test' ? :yellow : :red)
+              end
+      ColorizedString.new(permissions_check.message, color: color).value
+    end
+
+    def redirect_to_default_landing_page?
+      return false if controller.request.format == :json
+
+      controller.request.path == '/' && routes.alternative_routes.present?
+    end
+
+    def rails_component
+      @rails_component ||= RailsComponent.new(::Rails)
+    end
+
+    def log_tag
+      ColorizedString.new('ActiveElement', color: :cyan).value
+    end
+  end
+end

data/lib/active_element/engine.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Provides initial setup and gem integration for host Rails application.
+  class Engine < ::Rails::Engine
+    initializer 'active_element.precompile' do |app|
+      next unless app.config.respond_to?(:assets)
+
+      app.config.assets.precompile += %w[
+        active_element/manifest.js
+      ]
+    end
+
+    initializer 'active_element.routes' do |app|
+      app.routes.append do
+        mount Engine => '/'
+      end
+    end
+
+    initializer 'active_element.silence_action_view_notifications', after: 'finisher_hook' do
+      next unless ActiveElement.silence_logging?
+
+      warn '*** Rails ActionView logging events are disabled by default. Set ACTIVE_ELEMENT_DEBUG=1 to enable.'
+    end
+  end
+end