active_element 0.0.10 → 0.0.12

data/lib/active_element/controller_state.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Stores various data for a controller, including various field definitions and authentication
+  # configuration. Used throughout ActiveElement for generating dynamic content based on
+  # controller configuration.
+  class ControllerState
+    attr_reader :permissions, :listable_fields, :viewable_fields, :editable_fields, :searchable_fields
+    attr_accessor :sign_in_path, :sign_in, :sign_in_method, :sign_out_path, :sign_out_method,
+                  :deletable, :authorizor, :authenticator
+
+    def initialize(controller:)
+      @controller = controller
+      @permissions = []
+      @authenticator = nil
+      @authorizor = nil
+      @deletable = false
+      @listable_fields = []
+      @viewable_fields = []
+      @editable_fields = []
+      @searchable_fields = []
+    end
+
+    def deletable?
+      !!deletable
+    end
+
+    def viewable?
+      viewable_fields.present? || controller.public_methods(false).include?(:show)
+    end
+
+    def editable?
+      editable_fields.present? || controller.public_methods(false).include?(:edit)
+    end
+
+    def creatable?
+      editable_fields.present? || controller.public_methods(false).include?(:new)
+    end
+
+    private
+
+    attr_reader :controller
+  end
+end

data/lib/active_element/default_controller.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Encapsulation of all logic performed for default controller actions when no action is defined
+  # by the current controller.
+  class DefaultController
+    def initialize(controller:)
+      @controller = controller
+    end
+
+    def index
+      return render_forbidden(:listable) unless configured?(:listable)
+
+      controller.render 'active_element/default_views/index',
+                        locals: {
+                          collection: collection,
+                          search_filters: default_text_search.search_filters
+                        }
+    end
+
+    def show
+      return render_forbidden(:viewable) unless configured?(:viewable)
+
+      controller.render 'active_element/default_views/show', locals: { record: record }
+    end
+
+    def new
+      return render_forbidden(:editable) unless configured?(:editable)
+
+      controller.render 'active_element/default_views/new', locals: { record: model.new, namespace: namespace }
+    end
+
+    def create # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return render_forbidden(:editable) unless configured?(:editable)
+
+      new_record = model.new(default_record_params.params)
+      # XXX: Ensure associations are applied - there must be a better way.
+      if new_record.save && new_record.reload.update(default_record_params.params)
+        controller.flash.notice = "#{new_record.model_name.to_s.titleize} created successfully."
+        controller.redirect_to record_path(new_record, :show).path
+      else
+        controller.flash.now.alert = "Failed to create #{model.name.to_s.titleize}."
+        controller.render 'active_element/default_views/new', locals: { record: new_record, namespace: namespace }
+      end
+    rescue ActiveRecord::RangeError => e
+      render_range_error(error: e, action: :new)
+    end
+
+    def edit
+      return render_forbidden(:editable) unless configured?(:editable)
+
+      controller.render 'active_element/default_views/edit', locals: { record: record, namespace: namespace }
+    end
+
+    def update # rubocop:disable Metrics/AbcSize
+      return render_forbidden(:editable) unless configured?(:editable)
+
+      if record.update(default_record_params.params)
+        controller.flash.notice = "#{record.model_name.to_s.titleize} updated successfully."
+        controller.redirect_to record_path(record, :show).path
+      else
+        controller.flash.now.alert = "Failed to update #{model.name.to_s.titleize}."
+        controller.render 'active_element/default_views/edit', locals: { record: record, namespace: namespace }
+      end
+    rescue ActiveRecord::RangeError => e
+      render_range_error(error: e, action: :edit)
+    end
+
+    def destroy
+      return render_forbidden(:deletable) unless configured?(:deletable)
+
+      record.destroy
+      controller.flash.notice = "Deleted #{record.model_name.to_s.titleize}."
+      controller.redirect_to record_path(model, :index).path
+    end
+
+    private
+
+    attr_reader :controller
+
+    def render_forbidden(type)
+      controller.render 'active_element/default_views/forbidden', locals: { type: type }
+    end
+
+    def configured?(type)
+      return state.deletable? if type == :deletable
+
+      state.public_send("#{type}_fields").present?
+    end
+
+    def state
+      @state ||= controller.active_element.state
+    end
+
+    def default_record_params
+      @default_record_params ||= ActiveElement::DefaultRecordParams.new(controller: controller, model: model)
+    end
+
+    def default_text_search
+      @default_text_search ||= ActiveElement::DefaultSearch.new(controller: controller, model: model)
+    end
+
+    def record_path(record, type = nil)
+      ActiveElement::Components::Util::RecordPath.new(record: record, controller: controller, type: type)
+    end
+
+    def namespace
+      controller.controller_path.rpartition('/').first.presence&.to_sym
+    end
+
+    def model
+      controller.controller_name.classify.constantize
+    end
+
+    def record
+      @record ||= model.find(controller.params[:id])
+    end
+
+    def collection
+      return model.all unless default_text_search.text_search?
+
+      model.left_outer_joins(default_text_search.search_relations).where(*default_text_search.text_search)
+    end
+
+    def render_range_error(error:, action:)
+      controller.flash.now.alert = formatted_error(error)
+      controller.render "active_element/default_views/#{action}", locals: { record: record, namespace: namespace }
+    end
+
+    def formatted_error(error)
+      return error.cause.message.split("\n").join(', ') if error.try(:cause)&.try(:message).present?
+      return error.message if error.try(:message).present?
+
+      I18n.t('active_element.unexpected_error')
+    end
+  end
+end

data/lib/active_element/default_record_params.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Provides params for ActiveRecord models when using the default boilerplate controller
+  # actions. Navigates input parameters and maps them to appropriate relations as needed.
+  class DefaultRecordParams
+    def initialize(controller:, model:)
+      @controller = controller
+      @model = model
+    end
+
+    def params
+      with_transformed_relations(
+        controller.params.require(controller.controller_name.singularize)
+                  .permit(controller.active_element.state.editable_fields)
+      )
+    end
+
+    private
+
+    attr_reader :controller, :model
+
+    def with_transformed_relations(params)
+      params.to_h.to_h do |key, value|
+        next [key, value] unless relation?(key)
+
+        relation_param(key, value)
+      end
+    end
+
+    def relation_param(key, value)
+      case relation(key).macro
+      when :belongs_to
+        belongs_to_param(key, value)
+      when :has_one
+        has_one_param(key, value)
+      when :has_many
+        has_many_param(key, value)
+      end
+    end
+
+    def belongs_to_param(key, value)
+      [relation(key).foreign_key, value]
+    end
+
+    def has_one_param(key, value) # rubocop:disable Naming/PredicateName
+      [relation(key).name, relation(key).klass.find_by(relation(key).klass.primary_key => value)]
+    end
+
+    def has_many_param(key, _value) # rubocop:disable Naming/PredicateName
+      [relation(key).name, relation(key).klass.where(relation(key).klass.primary_key => relation(key).value)]
+    end
+
+    def relation?(attribute)
+      relation(attribute.to_sym).present?
+    end
+
+    def relation(attribute)
+      model.reflect_on_association(attribute.to_sym)
+    end
+  end
+end

data/lib/active_element/default_search.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Full text search and datetime querying for DefaultController, provides full text search
+  # filters for all controllers with configured searchable fields. Includes support for querying
+  # across relations.
+  class DefaultSearch
+    def initialize(controller:, model:)
+      @controller = controller
+      @model = model
+    end
+
+    def search_filters
+      @search_filters ||= controller.params.permit(*searchable_fields).transform_values do |value|
+        value.try(:compact_blank) || value
+      end.compact_blank
+    end
+
+    def text_search?
+      search_filters.present?
+    end
+
+    def text_search
+      conditions = search_filters.to_h.map do |key, value|
+        next relation_matches(key, value) if relation?(key)
+        next datetime_between(key, value) if datetime?(key)
+
+        model.arel_table[key].matches("#{value}%")
+      end
+      conditions[1..].reduce(conditions.first) do |accumulated, condition|
+        accumulated.and(condition)
+      end
+    end
+
+    def search_relations
+      search_filters.to_h.keys.map { |key| relation?(key) ? key.to_sym : nil }.compact
+    end
+
+    private
+
+    attr_reader :controller, :model
+
+    def searchable_fields
+      controller.active_element.state.searchable_fields.map do |field|
+        next field unless field.to_s.end_with?('_at')
+
+        { field => %i[from to] }
+      end
+    end
+
+    def noop
+      Arel::Nodes::True.new.eq(Arel::Nodes::True.new)
+    end
+
+    def datetime?(key)
+      model.columns.find { |column| column.name.to_s == key.to_s }&.type == :datetime
+    end
+
+    def datetime_between(key, value)
+      return noop if value[:from].blank? && value[:to].blank?
+
+      model.arel_table[key].between(range_begin(value)...range_end(value))
+    end
+
+    def range_begin(value)
+      value[:from].present? ? Time.zone.parse(value[:from]) + timezone_offset : -Float::INFINITY
+    end
+
+    def range_end(value)
+      value[:to].present? ? Time.zone.parse(value[:to]) + timezone_offset : Float::INFINITY
+    end
+
+    def timezone_offset
+      controller.request.cookies['timezone_offset'].to_i.minutes
+    end
+
+    def relation_matches(key, value)
+      fields = searchable_relation_fields(key)
+      relation_model = relation(key).klass
+      fields.select! do |field|
+        relation_model.columns.find { |column| column.name.to_s == field.to_s }&.type == :string
+      end
+
+      return noop if fields.empty?
+
+      relation_conditions(fields, value, relation_model)
+    end
+
+    def relation_conditions(fields, value, relation_model)
+      fields[1..].reduce(relation_model.arel_table[fields.first].matches("#{value}%")) do |condition, field|
+        condition.or(relation_model.arel_table[field].matches("#{value}%"))
+      end
+    end
+
+    def searchable_relation_fields(key)
+      Components::Util.relation_controller(model, controller, key)
+                      &.active_element
+                      &.state
+                      &.fetch(:searchable_fields, []) || []
+    end
+
+    def relation?(attribute)
+      relation(attribute.to_sym).present?
+    end
+
+    def relation(attribute)
+      model.reflect_on_association(attribute.to_sym)
+    end
+  end
+end

data/lib/active_element/json_field_schema.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Generates a schema for a JSON form field based on values stored in the database.
+  class JsonFieldSchema
+    def initialize(table:, column:)
+      @table = table
+      @column = column
+    end
+
+    def schema
+      data.map { |datum| structure(datum) }
+    end
+
+    private
+
+    attr_reader :table, :column, :initial_structure
+
+    def data
+      @data ||= ActiveRecord::Base.connection
+                                  .execute("select #{column} from #{table}")
+                                  .pluck(column)
+                                  .map { |datum| JSON.parse(datum) }
+    end
+
+    def structure(datum)
+      {
+        type: schema_type(datum),
+        shape: schema_shape(datum)&.compact,
+        fields: schema_fields(datum)&.compact
+      }
+    end
+
+    def schema_type(val)
+      case val
+      when Hash
+        'object'
+      when Array
+        'array'
+      when String
+        'string'
+      end
+    end
+
+    def schema_shape(val)
+      return nil unless %w[array object].include?(schema_type(val))
+      return val.map { |item| structure(item).compact } if schema_type(val) == 'array'
+      return val.map { |_key, value| structure(value).compact } if schema_type(val) == 'object'
+
+      { type: schema_type(val) }
+    end
+
+    def schema_fields(val)
+      return nil unless schema_type(val) == 'object'
+
+      val.map { |key, value| { name: key }.merge(structure(value)).compact }
+    end
+  end
+end

data/lib/active_element/pre_render_processors/json.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module PreRenderProcessors
+    # Selects fields from `__json_fields` param created by `Components::JsonField` and parses
+    # each field's JSON data back into request params to allow for transparent JSON data receipt.
+    # All params are permitted and converted to a Hash to allow them to be modified before
+    # converting back to ActionController::Params to avoid disrupting the Rails request flow.
+    class Json
+      def initialize(controller:)
+        @controller = controller
+      end
+
+      def process
+        return if json_fields.blank?
+
+        process_json_fields
+        delete_meta_params
+        rebuild_action_controller_parameters
+      end
+
+      private
+
+      attr_reader :controller
+
+      def process_json_fields
+        json_fields.zip(json_values).each do |field, value|
+          *nested_keys, field_key = field.split('.')
+          param = nested_keys.reduce(permitted_params) { |params, key| params[key] }
+          schema = schema_for(nested_keys + [field_key])
+          param[field_key] = coerced_with_default(value, schema)
+        end
+      end
+
+      def coerced_with_default(value, schema)
+        return coerced_value(JSON.parse(value), schema: schema) unless value == ''
+
+        { 'array' => [], 'object' => {} }.fetch(schema['type'])
+      end
+
+      def delete_meta_params
+        permitted_params.delete('__json_fields')
+        permitted_params.delete('__json_field_schemas')
+      end
+
+      def rebuild_action_controller_parameters
+        controller.params = ActionController::Parameters.new(permitted_params)
+      end
+
+      def json_fields
+        controller.params['__json_fields']
+      end
+
+      def json_values
+        json_fields.map do |json_field|
+          json_field.split('.').reduce(controller.params) { |params, field| params[field] }
+        end
+      end
+
+      def permitted_params
+        @permitted_params ||= controller.params.permit!.to_h
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def coerced_value(val, schema:)
+        return val if val.nil?
+
+        case schema['type']
+        when 'array'
+          val.map { |item| coerced_value(item, schema: schema['shape']) }
+        when 'object'
+          val.to_h { |key, value| [key, coerced_value(value, schema: schema_field(schema, key))] }
+        when 'string', 'boolean', 'time'
+          val
+        when 'float'
+          Float(val)
+        when 'integer'
+          Integer(val)
+        when 'decimal'
+          BigDecimal(val)
+        when 'datetime'
+          DateTime.parse(val)
+        when 'date'
+          Date.parse(val)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def schema_for(path)
+        JSON.parse(path.reduce(permitted_params['__json_field_schemas']) { |schema, key| schema[key] })
+      end
+
+      def schema_field(schema, key)
+        schema['shape']['fields'].find { |each_field| each_field['name'] == key }
+      end
+    end
+  end
+end

data/lib/active_element/pre_render_processors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'pre_render_processors/json'
+
+module ActiveElement
+  # Collection of processors called before the controller flow is handed back to the host
+  # application, i.e. before actions within the main ActiveElement before action, e.g. used for
+  # processing JSON fields.
+  module PreRenderProcessors
+  end
+end

data/lib/active_element/route.rb

@@ -36,6 +36,7 @@ module ActiveElement
     def primary?
       return false if rails_non_index_action?
       return false unless resourceless_get_request?
+      return false if excluded_ancestor?
 
       true
     end
@@ -93,6 +94,17 @@ module ActiveElement
       end
     end
 
+    def excluded_ancestor?
+      ancestors = controller.class.ancestors.map(&:name)
+      excluded_ancestors.any? { |excluded_ancestor| ancestors.include?(excluded_ancestor) }
+    end
+
+    def excluded_ancestors
+      # This will likely end up a config setting, for now we exclude Devise so its controllers
+      # don't appear in the Navbar.
+      %w[DeviseController]
+    end
+
     def permitted_action?
       permissions_check.permitted?
     rescue UnprotectedRouteError

data/lib/active_element/routes.rb

@@ -33,7 +33,8 @@ module ActiveElement
 
     def available_routes
       @available_routes ||= descendants_with_permissions.map do |descendant, required_permissions|
-        descendant.public_methods(false).map do |action|
+        action_methods = descendant.public_methods(false)
+        ([:index] + action_methods).uniq.map do |action|
           route(descendant, action, required_permissions)
         end
       end.flatten.compact.select(&:rails_route?).sort

data/lib/active_element/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveElement
-  VERSION = '0.0.10'
+  VERSION = '0.0.12'
 end

data/lib/active_element.rb

@@ -12,12 +12,18 @@ require_relative 'active_element/active_menu_link'
 require_relative 'active_element/permissions_check'
 require_relative 'active_element/permissions_report'
 require_relative 'active_element/controller_interface'
+require_relative 'active_element/controller_state'
 require_relative 'active_element/controller_action'
+require_relative 'active_element/default_controller'
+require_relative 'active_element/default_record_params'
+require_relative 'active_element/default_search'
+require_relative 'active_element/pre_render_processors'
 require_relative 'active_element/rails_component'
 require_relative 'active_element/route'
 require_relative 'active_element/routes'
 require_relative 'active_element/component'
 require_relative 'active_element/components'
+require_relative 'active_element/json_field_schema'
 require_relative 'active_element/engine'
 
 # ActiveElement API Admin UI template and menu system.
@@ -26,8 +32,11 @@ module ActiveElement
   class UnprotectedRouteError < Error; end
   class UnknownAttributeError < Error; end
 
+  @eager_loaded = {}
+
   class << self
-    attr_writer :application_name, :navbar_items
+    attr_writer :application_name
+    attr_accessor :navbar_items
 
     include Paintbrush
 
@@ -35,10 +44,6 @@ module ActiveElement
       @application_name || RailsComponent.new(Rails).application_name.titleize
     end
 
-    def navbar_items(user)
-      @navbar_items || inferred_navbar_items(user)
-    end
-
     def warning(message)
       warn "#{log_tag} #{paintbrush { yellow(message) }}"
     end
@@ -47,19 +52,6 @@ module ActiveElement
       paintbrush { cyan "[#{blue 'ActiveElement'}]" }
     end
 
-    def active_path_class(user:, current_navbar_item:, current_path:, controller_path:, action_name:)
-      if ActiveMenuLink.new(
-        rails_component: RailsComponent.new(Rails),
-        navbar_items: navbar_items(user),
-        current_path: current_path,
-        current_navbar_item: current_navbar_item,
-        controller_path: controller_path,
-        action_name: action_name
-      ).active?
-        'active'
-      end
-    end
-
     def json_pretty_print(json)
       Components::Util.json_pretty_print(json)
     end
@@ -89,24 +81,15 @@ module ActiveElement
     end
 
     def eager_load(resource)
+      return if @eager_loaded[resource]
+
       suffix = resource == :controllers ? '_controller' : nil
       Rails.root.join("app/#{resource}").glob("**/*#{suffix}.rb").each { |path| require path }
+      @eager_loaded[resource] = true unless Rails.env.development?
     end
 
-    private
-
-    def inferred_navbar_items(user)
-      eager_load_controllers
-      user_routes(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)
-      )
+    def element_id
+      "active-element-#{SecureRandom.uuid}"
     end
   end
 end

data/lib/tasks/active_element.rake

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
 namespace :active_element do
-  desc 'Displays all permissions used by this application'
+  desc 'Display all permissions used by this application'
   task permissions: :environment do
     $stdout.puts ActiveElement::PermissionsReport.new.report
   end
+
+  namespace :json do
+    desc 'Generate JSON form field schema from database values'
+    task schema: :environment do
+      if ENV.key?('table') && ENV.key?('column')
+        ActiveElement::JsonFieldSchema.new(table: ENV.fetch('table'), column: ENV.fetch('column'))
+      else
+        warn(Paintbrush.paintbrush { red "Expected #{cyan 'table'} and #{cyan 'column'} environment variables." })
+      end
+    end
+  end
 end