active_element 0.0.1 → 0.0.2

data/lib/active_element/components/form.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # A form component for rendering a standard form with various inputs in a uniform manner,
+    # includes validation errors.
+    class Form # rubocop:disable Metrics/ClassLength
+      include Translations
+
+      attr_reader :controller
+
+      # rubocop:disable Metrics/MethodLength
+      def initialize(controller, fields:, submit:, item:, title: nil, destroy: false,
+                     modal: false, columns: 1, expanded: true, **kwargs)
+        @controller = controller
+        @fields = fields
+        @title = title
+        @submit = submit
+        @destroy = destroy
+        @expanded = expanded
+        @item = item
+        @modal = modal
+        @kwargs = kwargs
+        @columns = columns
+        @method = kwargs.delete(:method) { default_method }.to_s.downcase.to_sym
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def template
+        'active_element/components/form'
+      end
+
+      def locals # rubocop:disable Metrics/MethodLength
+        {
+          component: self,
+          fields: Util::FormFieldMapping.new(record, fields, i18n).fields_with_types_and_options,
+          record: record,
+          submit_label: submit_label,
+          submit_position: submit_position,
+          class_name: class_name,
+          method: method,
+          kwargs: kwargs,
+          destroy: destroy,
+          modal: modal,
+          expanded: expanded,
+          columns: columns,
+          title: title,
+          id: form_id
+        }
+      end
+
+      def class_name
+        [default_class_name, kwargs.fetch(:class, nil)].compact.join(' ')
+      end
+
+      def options_for_select(field, field_options)
+        return [['', '']] + base_options_for_select(field, field_options) unless field_options[:blank] == false
+
+        base_options_for_select(field, field_options)
+      end
+
+      def valid?(field = nil)
+        return true if record.blank? || !record.changed?
+
+        record.valid?
+
+        return record&.errors.blank? if field.nil?
+
+        valid_field?(field)
+      end
+
+      def name_for(form, schema_field, type:)
+        base = "#{form.object_name}[#{schema_field.fetch(:name)}]"
+        type == :array ? "#{base}[]" : base
+      end
+
+      def schema_for(field, options)
+        options.key?(:schema) ? options.fetch(:schema) : schema_from_yaml(field)
+      end
+
+      def schema_from_yaml(field)
+        YAML.safe_load(
+          Rails.root.join("config/forms/#{record.class.name.underscore}/#{field}.yml").read,
+          symbolize_names: true
+        )
+      end
+
+      def display_value_for_select(field, options)
+        options_for_select(field, options).find do |_display_value, value|
+          value == value_for(field)
+        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?
+
+        default
+      end
+
+      def form_value_mapping_value(field)
+        Util::FormValueMapping.new(component: self, record: record, field: field).value
+      end
+
+      def default_record_value(field, default)
+        record&.public_send(field).presence || default
+      end
+
+      def options_for_json_array_field(options)
+        options.map { |option| option.is_a?(Array) ? option : [option, option] }
+      end
+
+      def value_for_json_array_field(field, schema_field, element_index = nil)
+        array = value_for(field, {}).fetch(schema_field[:name], [])
+        return array if element_index.nil?
+
+        array.fetch(element_index, nil)
+      end
+
+      def record
+        return nil if kwargs.fetch(:model, nil).blank?
+
+        kwargs[:model].is_a?(Array) ? kwargs[:model].last : kwargs[:model]
+      end
+
+      def model
+        record&.class
+      end
+
+      private
+
+      attr_reader :fields, :submit, :title, :kwargs, :item, :method, :destroy, :modal, :expanded, :columns
+
+      def valid_field?(field)
+        return true if record.respond_to?("#{field}_changed?") && !record.public_send("#{field}_changed?")
+
+        record&.errors.blank? || record.errors.full_messages_for(field).blank?
+      end
+
+      def submit_position
+        return submit[:position] if submit.is_a?(Hash) && submit[:position].present?
+
+        :bottom
+      end
+
+      def submit_label
+        return submit[:label] if submit.is_a?(Hash) && submit[:label].present?
+        return submit if submit.is_a?(String)
+        return submit_label_from_model if record.present? && submit_label_from_model.present?
+
+        'Submit'
+      end
+
+      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)
+
+        nil
+      end
+
+      def humanized_model_name
+        record.class.name.titleize
+      end
+
+      def base_options_for_select(field, field_options)
+        return normalized_options(field_options.fetch(:options)) if field_options.key?(:options)
+        return default_options_for_select(field, field_options) if record.class.is_a?(ActiveModel::Naming)
+
+        raise ArgumentError, "Must provide select options `[:#{field}, { options: [...] }]` or a record instance."
+      end
+
+      def normalized_options(options)
+        options.map { |option| option.is_a?(Array) ? option : [option, option] }
+      end
+
+      def default_class_name
+        return nil if record.blank?
+
+        Util::I18n.class_name(record.class.name)
+      end
+
+      def default_options_for_select(field, field_options)
+        options = record.class.distinct.order(field).pluck(field)
+        [options.map { |option| autoformat(option, field_options) }, options].transpose
+      end
+
+      def form_id
+        kwargs.fetch(:id) { "form-#{SecureRandom.uuid}" }
+      end
+
+      def autoformat(val, field_options)
+        return val unless field_options[:autoformat] || !field_options.key?(:autoformat)
+
+        val.titleize
+      end
+
+      def default_method
+        case controller.action_name
+        when 'edit'
+          'PATCH'
+        when 'index'
+          'GET'
+        else
+          'POST'
+        end
+      end
+    end
+  end
+end

data/lib/active_element/components/item_table.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # A table component for rendering the fields of a single object horizontally.
+    class ItemTable
+      include LinkHelpers
+      include SecretFields
+
+      attr_reader :controller, :model_name
+
+      def initialize(controller, item:, fields:, class_name: nil, model_name: nil,
+                     edit: false, new: false, destroy: false, style: nil, row_class: nil, **_kwargs)
+        @controller = controller
+        @class_name = class_name
+        @model_name = model_name
+        @item = item
+        @fields = fields
+        @destroy = destroy
+        @edit = edit
+        @new = new
+        @style = style
+        @row_class = row_class
+      end
+
+      def template
+        'active_element/components/table/item'
+      end
+
+      def locals # rubocop:disable Metrics/MethodLength
+        {
+          component: self,
+          class_name: class_name,
+          item: item,
+          fields: Util::FieldMapping.new(self, fields, class_name).mapped_fields,
+          destroy: destroy,
+          edit: edit,
+          new: new,
+          style: style,
+          row_class_mapper: row_class_mapper
+        }
+      end
+
+      def model
+        item.class.is_a?(ActiveModel::Naming) ? item.class : nil
+      end
+
+      private
+
+      attr_reader :class_name, :item, :fields, :edit, :new, :destroy, :style, :row_class
+
+      def row_class_mapper
+        row_class.is_a?(Proc) ? row_class : proc { row_class }
+      end
+    end
+  end
+end

data/lib/active_element/components/json.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Outputs a `<script>` tag and sets globally-available JSON data, available as `ActiveElement.jsonData.<key>`.
+    # Note key is camelized, so `foo_bar_baz` becomes `fooBarBaz`.
+    class Json
+      def initialize(controller, object:, key:)
+        @controller = controller
+        @object = object
+        @key = key
+      end
+
+      def template
+        'active_element/components/json'
+      end
+
+      def locals
+        {
+          controller: controller,
+          object: object,
+          key: ActiveElement::Components::Util.json_name(key)
+        }
+      end
+
+      private
+
+      attr_reader :controller, :object, :key
+    end
+  end
+end

data/lib/active_element/components/link_helpers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Provides helpers for generating links to show, destroy, etc. actions.
+    module LinkHelpers
+    end
+  end
+end

data/lib/active_element/components/page_description.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Provides a description of a page, intended to be used underneath the `page_title` component.
+    class PageDescription
+      def initialize(controller, content:)
+        @controller = controller
+        @content = content
+      end
+
+      def template
+        'active_element/components/page_description'
+      end
+
+      def locals
+        {
+          component: self,
+          content: content
+        }
+      end
+
+      private
+
+      attr_reader :controller, :content
+    end
+  end
+end

data/lib/active_element/components/secret_fields.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Provides a convenience method for detecting a field should be classified as a secret, used
+    # for censoring values or selecting the default form field type as `password_field`, etc.
+    module SecretFields
+      SECRET_FIELDS = %w[secret password].freeze
+
+      def secret_field?(field)
+        SECRET_FIELDS.any? { |secret_field| field.to_s.downcase.include?(secret_field) }
+      end
+    end
+  end
+end

data/lib/active_element/components/tab.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # One navigation tab in a Tabs component.
+    class Tab
+      attr_reader :title, :path, :content
+
+      def initialize(controller, title:, path:, &block)
+        @controller = controller
+        @title = title
+        @path = path
+        @content = block_given? ? block.call : ''
+      end
+
+      def selected?
+        controller.request.fullpath == path
+      end
+
+      def identifier
+        Util::I18n.class_name(title)
+      end
+
+      def to_s
+        ''
+      end
+
+      def tab(title)
+        yield Tab.new(title)
+      end
+
+      private
+
+      attr_reader :controller
+    end
+  end
+end

data/lib/active_element/components/tabs.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Navigation tabs component.
+    class Tabs
+      def initialize(controller, class_name:)
+        @controller = controller
+        @class_name = class_name
+        @tabs = []
+        yield self
+      end
+
+      def to_s
+        ''
+      end
+
+      def tab(title:, path:, &block)
+        Tab.new(controller, title: title, path: path, &block).tap { |tab| @tabs << tab }
+      end
+
+      def template
+        'active_element/components/tabs'
+      end
+
+      def locals
+        { tabs: tabs, class_name: class_name }
+      end
+
+      private
+
+      attr_reader :tabs, :controller, :class_name
+    end
+  end
+end

data/lib/active_element/components/translations.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    # Provides `#i18n` method as standard entrypoint to translation point, specifies required
+    # interface for classes that use this module.
+    module Translations
+      def i18n
+        @i18n ||= Util::I18n.new(self)
+      end
+
+      def model
+        raise NotImplementedError,
+              'Component must implement `#model` and return `nil` or an ActiveRecord model class.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Utility class for mapping an association to a linked URL (e.g. for displaying associations in a table).
+      class AssociationMapping
+        def initialize(component:, field:, record:, associated_record:, options:)
+          @component = component
+          @field = field
+          @record = record
+          @associated_record = associated_record
+          @options = options || {}
+        end
+
+        def link_tag
+          verify_display_attribute
+          return display_value if associated_record_path.blank?
+
+          component.controller.helpers.link_to(display_value, associated_record_path)
+        end
+
+        private
+
+        attr_reader :component, :field, :record, :associated_record, :options
+
+        def associated_record_path
+          return nil unless component.controller.helpers.respond_to?(path_helper)
+
+          component.controller.helpers.public_send(path_helper, associated_record)
+        end
+
+        def verify_display_attribute
+          return if display_field.present?
+
+          raise ArgumentError,
+                "Must provide { attribute: :example_attribute } for `#{field}` or define " \
+                "`#{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 default_display_attribute if default_display_attribute.present?
+
+            associated_record.class.primary_key
+          end
+        end
+
+        def defined_display_attribute?
+          associated_record.class.respond_to?(:default_display_attribute)
+        end
+
+        def namespace
+          component.controller.class.name.deconstantize.underscore
+        end
+
+        def resource_name
+          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?
+          end
+        end
+
+        def path_helper
+          return "#{resource_name}_path" if namespace.blank?
+
+          "#{namespace}_#{resource_name}_path"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Decorates a field by rendering a user-provided partial found in
+      # app/views/decorators/<model-name-plural>/_<field-name>.html.erb
+      class Decorator
+        def initialize(component:, item:, field:, value:)
+          @component = component
+          @item = item
+          @field = field
+          @value = value
+        end
+
+        def decorated_value
+          return default_decorated_value unless decorate?
+
+          render
+        end
+
+        private
+
+        attr_reader :component, :item, :field, :value
+
+        def render(sti: false)
+          component.controller.render_to_string(partial: decorator_path(sti: sti), locals: locals)
+        rescue ActionView::MissingTemplate
+          if sti
+            component.controller.missing_template_store[decorator_path] = true
+            default_decorated_value
+          else
+            render(sti: true)
+          end
+        end
+
+        def locals
+          {
+            record: item,
+            field: field,
+            default: value,
+            value: value, # Provide both default and value, default might change in future.
+            context: component.class.name.demodulize.underscore
+          }
+        end
+
+        def decorate?
+          return false unless item.class.is_a?(ActiveModel::Naming) || component.model_name.present?
+
+          !missing_template?
+        end
+
+        def missing_template?
+          component.controller.missing_template_store[decorator_path].present?
+        end
+
+        def decorator_path(sti: false)
+          Rails.root.join(
+            'app/views/decorators',
+            model_path_name(sti: sti).pluralize,
+            field.to_s
+          ).relative_path_from(Rails.root.join('app/views')).to_s
+        end
+
+        def model_path_name(sti:)
+          return component.model_name if component.model_name.present?
+          return record_name(sti: sti) if record_name(sti: sti).present?
+          return item_record_name if item_record_name.present?
+
+          item.class.name
+        end
+
+        def record_name(sti:)
+          return Util.sti_record_name(item) if sti
+
+          Util.record_name(item).presence
+        end
+
+        def item_record_name
+          item.try(:model_name)&.singular
+        end
+
+        def render_with_default_decorator(template)
+          component.controller.render_to_string(
+            partial: "active_element/decorators/#{template}",
+            locals: { value: value }
+          )
+        end
+
+        def default_decorated_value # rubocop:disable Metrics/MethodLength
+          case value
+          when true, false
+            render_with_default_decorator('boolean')
+          when DateTime
+            render_with_default_decorator('datetime')
+          when Date
+            render_with_default_decorator('date')
+          when Time
+            render_with_default_decorator('time')
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module Components
+    module Util
+      # Maps ActiveRecord record fields to values for display (e.g. in tables).
+      class DisplayValueMapping
+        include RecordMapping
+
+        def numeric_value
+          value_from_record
+        end
+
+        def json_value
+          ActiveElement.json_pretty_print(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
+          component.controller.render_to_string(
+            partial: 'active_element/components/fields/boolean',
+            locals: { value: value_from_record }
+          )
+        end
+
+        def geometry_value
+          require 'rgeo/geo_json'
+          Util.json_pretty_print(RGeo::GeoJSON.encode(value_from_record))
+        end
+      end
+    end
+  end
+end