active_element 0.0.10 → 0.0.11

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

@@ -29,18 +29,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 = {}
 
@@ -25,6 +25,22 @@ module ActiveElement
       @authorize
     end
 
+    def listable_fields(*args)
+      state[:listable_fields] = args.map(&:to_sym)
+    end
+
+    def viewable_fields(*args)
+      state[:viewable_fields] = args.map(&:to_sym)
+    end
+
+    def editable_fields(*args)
+      state[:editable_fields] = args.map(&:to_sym)
+    end
+
+    def searchable_fields(*args)
+      state[:searchable_fields] = args.map(&:to_sym)
+    end
+
     def application_name
       RailsComponent.new(::Rails).application_name
     end
@@ -38,6 +54,32 @@ module ActiveElement
       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
+
+    def sign_out_method
+      state[:sign_out_method]
+    end
+
+    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
+
+    def sign_in_method
+      state[:sign_in_method]
+    end
+
     def authenticate
       authenticator&.call
       @current_user = state[:authorizor]&.call
@@ -66,6 +108,10 @@ 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
@@ -73,9 +119,5 @@ module ActiveElement
     def initialize_state
       self.class.state[controller_class] ||= { permissions: [], authenticator: nil }
     end
-
-    def state
-      self.class.state[controller_class]
-    end
   end
 end

data/lib/active_element/default_controller.rb

@@ -0,0 +1,93 @@
+# 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
+      controller.render 'active_element/default_views/index',
+                        locals: {
+                          collection: collection,
+                          search_filters: default_text_search.search_filters
+                        }
+    end
+
+    def show
+      controller.render 'active_element/default_views/show', locals: { record: record }
+    end
+
+    def new
+      controller.render 'active_element/default_views/new', locals: { record: model.new, namespace: namespace }
+    end
+
+    def create # rubocop:disable Metrics/AbcSize
+      new_record = model.new(default_record_params.params)
+      # Ensure associations are applied:
+      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
+    end
+
+    def edit
+      controller.render 'active_element/default_views/edit', locals: { record: record, namespace: namespace }
+    end
+
+    def update # rubocop:disable Metrics/AbcSize
+      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
+    end
+
+    def destroy
+      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 default_record_params
+      @default_record_params ||= ActiveElement::DefaultRecordParams.new(controller: controller, model: model)
+    end
+
+    def default_text_search
+      @default_text_search ||= ActiveElement::DefaultTextSearch.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
+  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.fetch(: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_text_search.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Full text search querying for DefaultController, provides full text search filters for all
+  # controllers with configured searchable fields. Includes support for querying across relations.
+  class DefaultTextSearch
+    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
+      base_fields = controller.active_element.state.fetch(:searchable_fields, [])
+      base_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[: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.11'
 end