active_fields 1.0.0 → 2.0.0

data/lib/active_fields/has_active_fields.rb

@@ -6,13 +6,12 @@ module ActiveFields
     extend ActiveSupport::Concern
 
     class_methods do
-      attr_reader :active_fields_config
-
       def has_active_fields(types: ActiveFields.config.type_names)
         include CustomizableConcern
 
-        @active_fields_config = CustomizableConfig.new(self)
-        @active_fields_config.types = types
+        types.each do |field_type|
+          ActiveFields.registry.add(field_type, name)
+        end
       end
     end
   end

data/lib/active_fields/registry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Storage for configured relations between active fields and customizable models
+  class Registry
+    include Singleton
+
+    def initialize
+      @customizables = {}
+      @fields = {}
+    end
+
+    # Add relation between active field type and customizable type
+    def add(field_type_name, customizable_type)
+      if ActiveFields.config.type_names.exclude?(field_type_name)
+        raise ArgumentError, "undefined ActiveFields type provided for #{customizable_type}: #{field_type_name}"
+      end
+
+      @customizables[field_type_name] ||= Set.new
+      @customizables[field_type_name] << customizable_type
+
+      @fields[customizable_type] ||= Set.new
+      @fields[customizable_type] << field_type_name
+
+      nil
+    end
+
+    # Returns customizable types that allow provided active field type name
+    def customizable_types_for(field_type_name)
+      @customizables[field_type_name]
+    end
+
+    # Returns active field type names, allowed for given customizable type
+    def field_type_names_for(customizable_type)
+      @fields[customizable_type]
+    end
+  end
+end

data/lib/active_fields/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveFields
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/lib/active_fields.rb

@@ -1,45 +1,91 @@
 # frozen_string_literal: true
 
 require_relative "active_fields/version"
+require_relative "active_fields/constants"
 require_relative "active_fields/engine"
 
 module ActiveFields
-  autoload :Config, "active_fields/config"
-  autoload :CustomizableConfig, "active_fields/customizable_config"
-  autoload :HasActiveFields, "active_fields/has_active_fields"
+  extend ActiveSupport::Autoload
+
+  class << self
+    def eager_load!
+      super
+      Casters.eager_load!
+      Validators.eager_load!
+      Finders.eager_load!
+    end
+  end
+
+  eager_autoload do
+    autoload :Config
+    autoload :Registry
+    autoload :HasActiveFields
+  end
 
   module Casters
-    autoload :BaseCaster, "active_fields/casters/base_caster"
-    autoload :BooleanCaster, "active_fields/casters/boolean_caster"
-    autoload :DateCaster, "active_fields/casters/date_caster"
-    autoload :DateArrayCaster, "active_fields/casters/date_array_caster"
-    autoload :DateTimeCaster, "active_fields/casters/date_time_caster"
-    autoload :DateTimeArrayCaster, "active_fields/casters/date_time_array_caster"
-    autoload :DecimalCaster, "active_fields/casters/decimal_caster"
-    autoload :DecimalArrayCaster, "active_fields/casters/decimal_array_caster"
-    autoload :EnumCaster, "active_fields/casters/enum_caster"
-    autoload :EnumArrayCaster, "active_fields/casters/enum_array_caster"
-    autoload :IntegerCaster, "active_fields/casters/integer_caster"
-    autoload :IntegerArrayCaster, "active_fields/casters/integer_array_caster"
-    autoload :TextCaster, "active_fields/casters/text_caster"
-    autoload :TextArrayCaster, "active_fields/casters/text_array_caster"
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BaseCaster
+      autoload :BooleanCaster
+      autoload :DateCaster
+      autoload :DateArrayCaster
+      autoload :DateTimeCaster
+      autoload :DateTimeArrayCaster
+      autoload :DecimalCaster
+      autoload :DecimalArrayCaster
+      autoload :EnumCaster
+      autoload :EnumArrayCaster
+      autoload :IntegerCaster
+      autoload :IntegerArrayCaster
+      autoload :TextCaster
+      autoload :TextArrayCaster
+    end
   end
 
   module Validators
-    autoload :BaseValidator, "active_fields/validators/base_validator"
-    autoload :BooleanValidator, "active_fields/validators/boolean_validator"
-    autoload :DateValidator, "active_fields/validators/date_validator"
-    autoload :DateArrayValidator, "active_fields/validators/date_array_validator"
-    autoload :DateTimeValidator, "active_fields/validators/date_time_validator"
-    autoload :DateTimeArrayValidator, "active_fields/validators/date_time_array_validator"
-    autoload :DecimalValidator, "active_fields/validators/decimal_validator"
-    autoload :DecimalArrayValidator, "active_fields/validators/decimal_array_validator"
-    autoload :EnumValidator, "active_fields/validators/enum_validator"
-    autoload :EnumArrayValidator, "active_fields/validators/enum_array_validator"
-    autoload :IntegerValidator, "active_fields/validators/integer_validator"
-    autoload :IntegerArrayValidator, "active_fields/validators/integer_array_validator"
-    autoload :TextValidator, "active_fields/validators/text_validator"
-    autoload :TextArrayValidator, "active_fields/validators/text_array_validator"
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BaseValidator
+      autoload :BooleanValidator
+      autoload :DateValidator
+      autoload :DateArrayValidator
+      autoload :DateTimeValidator
+      autoload :DateTimeArrayValidator
+      autoload :DecimalValidator
+      autoload :DecimalArrayValidator
+      autoload :EnumValidator
+      autoload :EnumArrayValidator
+      autoload :IntegerValidator
+      autoload :IntegerArrayValidator
+      autoload :TextValidator
+      autoload :TextArrayValidator
+    end
+  end
+
+  module Finders
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BaseFinder
+      autoload :SingularFinder
+      autoload :ArrayFinder
+
+      autoload :BooleanFinder
+      autoload :DateFinder
+      autoload :DateArrayFinder
+      autoload :DateTimeFinder
+      autoload :DateTimeArrayFinder
+      autoload :DecimalFinder
+      autoload :DecimalArrayFinder
+      autoload :EnumFinder
+      autoload :EnumArrayFinder
+      autoload :IntegerFinder
+      autoload :IntegerArrayFinder
+      autoload :TextFinder
+      autoload :TextArrayFinder
+    end
   end
 
   class << self
@@ -49,5 +95,7 @@ module ActiveFields
     end
 
     alias_method :configure, :config
+
+    def registry = Registry.instance
   end
 end

data/lib/generators/active_fields/install/install_generator.rb

@@ -5,7 +5,7 @@ require "rails/generators"
 module ActiveFields
   module Generators
     class InstallGenerator < ::Rails::Generators::Base
-      desc "This generator creates an create_initializer and copies plugin migrations"
+      desc "This generator creates an initializer and copies plugin migrations"
 
       def create_initializer
         initializer "active_fields.rb", <<~RUBY

data/lib/generators/active_fields/scaffold/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates a controller, routes and views for managing Active Fields,
+    along with form inputs for Active Values and some useful helper methods.
+
+    The code it generates is unlikely to be a perfect fit for your application.
+    You’ll most probably want to customize the generated code.
+
+Examples:
+    `bin/rails generate active_fields:scaffold`

data/lib/generators/active_fields/scaffold/scaffold_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module ActiveFields
+  module Generators
+    class ScaffoldGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "This generator creates some useful templates"
+
+      def copy_files
+        Dir.glob("**/*", base: self.class.source_root).each do |path|
+          next unless File.file?(File.expand_path(path, self.class.source_root))
+
+          copy_file path, File.join("app", path)
+        end
+      end
+
+      def insert_into_application_controller
+        inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
+          optimize_indentation(<<~CODE, 2)
+            include ActiveFieldsControllerConcern
+            helper ActiveFieldsHelper
+          CODE
+        end
+      end
+
+      def add_routes
+        route "resources :active_fields"
+      end
+    end
+  end
+end

data/lib/generators/active_fields/scaffold/templates/controllers/active_fields_controller.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+class ActiveFieldsController < ApplicationController
+  before_action :set_active_field, only: %i[show edit update destroy]
+
+  def index
+    @active_fields = ActiveFields.config.field_base_class.order(:customizable_type, :id)
+  end
+
+  def show; end
+
+  def new
+    @active_field = model_class.new
+  end
+
+  def create
+    @active_field = model_class.new(active_field_create_params(model_class))
+
+    if @active_field.save
+      redirect_to edit_active_field_path(@active_field), status: :see_other
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit; end
+
+  def update
+    if @active_field.update(active_field_update_params(@active_field.class))
+      redirect_to edit_active_field_path(@active_field), status: :see_other
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @active_field.destroy!
+
+    redirect_to active_fields_path, status: :see_other
+  end
+
+  private
+
+  def active_field_create_params(model_class)
+    params.require(:active_field).permit(*permitted_attributes_for_create(model_class)).tap do |attrs|
+      attrs.transform_values! do |value|
+        value.is_a?(Array) ? compact_array_param(value) : value
+      end
+    end
+  end
+
+  def active_field_update_params(model_class)
+    params.require(:active_field).permit(*permitted_attributes_for_update(model_class)).tap do |attrs|
+      attrs.transform_values! do |value|
+        value.is_a?(Array) ? compact_array_param(value) : value
+      end
+    end
+  end
+
+  # It is strongly recommended to move it to, for example, policies.
+  def permitted_attributes_for_create(model_class)
+    if model_class == ActiveFields::Field::Boolean
+      %i[customizable_type name required nullable default_value]
+    elsif model_class == ActiveFields::Field::Date
+      %i[customizable_type name required min max default_value]
+    elsif model_class == ActiveFields::Field::DateArray
+      [:customizable_type, :name, :min_size, :max_size, :min, :max, default_value: []]
+    elsif model_class == ActiveFields::Field::DateTime
+      %i[customizable_type name required min max precision default_value]
+    elsif model_class == ActiveFields::Field::DateTimeArray
+      [:customizable_type, :name, :min_size, :max_size, :min, :max, :precision, default_value: []]
+    elsif model_class == ActiveFields::Field::Decimal
+      %i[customizable_type name required min max precision default_value]
+    elsif model_class == ActiveFields::Field::DecimalArray
+      [:customizable_type, :name, :min_size, :max_size, :min, :max, :precision, default_value: []]
+    elsif model_class == ActiveFields::Field::Enum
+      [:customizable_type, :name, :required, :default_value, allowed_values: []]
+    elsif model_class == ActiveFields::Field::EnumArray
+      [:customizable_type, :name, :min_size, :max_size, allowed_values: [], default_value: []]
+    elsif model_class == ActiveFields::Field::Integer
+      %i[customizable_type name required min max default_value]
+    elsif model_class == ActiveFields::Field::IntegerArray
+      [:customizable_type, :name, :min_size, :max_size, :min, :max, default_value: []]
+    elsif model_class == ActiveFields::Field::Text
+      %i[customizable_type name min_length max_length default_value]
+    elsif model_class == ActiveFields::Field::TextArray
+      [:customizable_type, :name, :min_size, :max_size, :min_length, :max_length, default_value: []]
+    else
+      raise ArgumentError, "undefined model_class `#{model_class.inspect}`"
+    end
+  end
+
+  # It is strongly recommended to move it to, for example, policies.
+  def permitted_attributes_for_update(model_class)
+    if model_class == ActiveFields::Field::Boolean
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::Date
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::DateArray
+      [:name, default_value: []]
+    elsif model_class == ActiveFields::Field::DateTime
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::DateTimeArray
+      [:name, default_value: []]
+    elsif model_class == ActiveFields::Field::Decimal
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::DecimalArray
+      [:name, default_value: []]
+    elsif model_class == ActiveFields::Field::Enum
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::EnumArray
+      [:name, default_value: []]
+    elsif model_class == ActiveFields::Field::Integer
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::IntegerArray
+      [:name, default_value: []]
+    elsif model_class == ActiveFields::Field::Text
+      %i[name default_value]
+    elsif model_class == ActiveFields::Field::TextArray
+      [:name, default_value: []]
+    else
+      raise ArgumentError, "undefined model_class `#{model_class.inspect}`"
+    end
+  end
+
+  def set_active_field
+    @active_field = ActiveFields.config.field_base_class.find(params[:id])
+  end
+
+  def model_class
+    (ActiveFields.config.fields[params[:type]&.to_sym] || ActiveFields.config.type_class_names.first).constantize
+  end
+end

data/lib/generators/active_fields/scaffold/templates/controllers/concerns/active_fields_controller_concern.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveFieldsControllerConcern
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :active_fields_finders_params
+  end
+
+  def active_fields_finders_params
+    @active_fields_finders_params ||=
+      params.permit(
+        f: [
+          :n,
+          :name,
+          :op,
+          :operator,
+          :v,
+          :value,
+          v: [],
+          value: [],
+        ],
+      )[:f] || {}
+  end
+
+  def compact_array_param(value)
+    if value.first == ""
+      value[1..-1]
+    else
+      value
+    end
+  end
+end

data/lib/generators/active_fields/scaffold/templates/helpers/active_fields_helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module ActiveFieldsHelper
+  ARRAY_SIZE_OPERATIONS = %i[size_eq size_not_eq size_gt size_gteq size_lt size_lteq].freeze
+  private_constant :ARRAY_SIZE_OPERATIONS
+
+  def render_array_field(form:, name:, value:, field_method:, field_opts: {})
+    render partial: "shared/array_field", locals: {
+      form: form,
+      name: name,
+      value: value,
+      field_method: field_method,
+      field_opts: field_opts,
+    }
+  end
+
+  def render_active_field_form(active_field:)
+    partial = active_field_form(active_field)
+
+    render partial: partial, locals: { active_field: active_field }
+  end
+
+  def render_active_value_input(form:, active_value:)
+    partial = active_value_input(active_value.active_field)
+
+    render partial: partial, locals: { form: form, active_value: active_value, active_field: active_value.active_field }
+  end
+
+  def render_active_fields_finders_form(active_fields:, url:)
+    render partial: "active_fields/finders/form", locals: { active_fields: active_fields, url: url }
+  end
+
+  def active_field_finder_input_types(active_field:)
+    return [] if active_field.value_finder_class.nil?
+
+    types = [active_field.type_name]
+    types += [:array_size] if active_field.value_finder_class.operations.intersect?(ARRAY_SIZE_OPERATIONS)
+
+    types
+  end
+
+  def render_active_field_finder_input(form:, type:, active_field:, template: false, selected: {})
+    if type == :array_size
+      operations = active_field.value_finder_class.operations & ARRAY_SIZE_OPERATIONS
+      partial = "active_fields/finders/inputs/array_size"
+    else
+      operations = active_field.value_finder_class.operations - ARRAY_SIZE_OPERATIONS
+      partial = "active_fields/finders/inputs/#{type}"
+    end
+
+    render partial: partial, locals: {
+      form: form,
+      active_field: active_field,
+      operations: operations,
+      template: template,
+      selected: selected,
+    }
+  end
+
+  def render_selected_active_field_finder_input(form:, active_fields:, finder_params:)
+    active_field_name = finder_params[:n] || finder_params[:name]
+    active_field = active_fields.find { |active_field| active_field.name == active_field_name }
+    return if active_field&.value_finder_class.nil?
+
+    op = (finder_params[:op] || finder_params[:operator])&.to_sym
+    if active_field.value_finder_class.operations.include?(op)
+      operation = op
+      operator = active_field.value_finder_class.operator_for(op)
+    else
+      operation = active_field.value_finder_class.operation_for(op)
+      operator = op
+    end
+    return if operation.nil? || operator.nil?
+
+    value = finder_params[:v] || finder_params[:value]
+
+    type =
+      if ARRAY_SIZE_OPERATIONS.include?(operation)
+        :array_size
+      else
+        active_field.type_name
+      end
+
+    render_active_field_finder_input(
+      form: form,
+      type: type,
+      active_field: active_field,
+      template: false,
+      selected: { operation: operation, operator: operator, value: value },
+    )
+  end
+
+  def active_field_form(active_field)
+    "active_fields/forms/#{active_field.type_name}"
+  end
+
+  def active_value_input(active_field)
+    "active_fields/values/inputs/#{active_field.type_name}"
+  end
+end

data/lib/generators/active_fields/scaffold/templates/javascript/controllers/active_fields_finders_form_controller.js

@@ -0,0 +1,59 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = [
+    "inputTemplatesContainer",
+    "inputTemplate",
+    "inputsContainer",
+    "input",
+  ]
+
+  connect() {
+    this.inputTemplatesContainerTarget.style.display = "none"
+  }
+
+  addInput(e) {
+    e.preventDefault()
+
+    const selectedOption = e.target.options[e.target.selectedIndex]
+    const selectedName = selectedOption.dataset.activeFieldName
+    const selectedType = selectedOption.value
+
+    if (!selectedName || !selectedType) { return }
+
+    const templateInput = this.inputTemplateTargets.find((templateInput) => {
+      return templateInput.dataset.activeFieldName === selectedName && templateInput.dataset.type === selectedType
+    })
+
+    let newInput = templateInput.cloneNode(true)
+    newInput.dataset.activeFieldsFindersFormTarget = "input"
+    this.#setInputIndex(newInput)
+
+    this.inputsContainerTarget.append(newInput)
+
+    e.target.value = ""
+  }
+
+  removeInput(e) {
+    e.preventDefault()
+
+    e.target.parentElement.remove()
+  }
+
+  #getLastIndex() {
+    if (this.inputTargets.length === 0) { return -1 }
+
+    return Math.max(...this.inputTargets.map((input) => +input.dataset.index))
+  }
+
+  #setInputIndex(input) {
+    const newIndex = this.#getLastIndex() + 1
+
+    input.dataset.index = newIndex.toString()
+    Array.from(input.children).forEach((element) => {
+      if (element.hasAttribute("name") && element.name.includes("[0]")) {
+        element.name = element.name.replace("[0]", `[${newIndex}]`)
+      }
+    })
+  }
+}

data/lib/generators/active_fields/scaffold/templates/javascript/controllers/array_field_controller.js

@@ -0,0 +1,25 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["templateFieldGroup"]
+
+  connect() {
+    this.templateFieldGroupTarget.style.display = "none"
+  }
+
+  addField(e) {
+    e.preventDefault()
+
+    let newFieldGroup = this.templateFieldGroupTarget.cloneNode(true)
+    delete newFieldGroup.dataset.arrayFieldTarget
+    newFieldGroup.style.removeProperty("display")
+
+    e.target.before(newFieldGroup)
+  }
+
+  removeField(e) {
+    e.preventDefault()
+
+    e.target.parentElement.remove()
+  }
+}

data/lib/generators/active_fields/scaffold/templates/views/active_fields/edit.html.erb

@@ -0,0 +1,5 @@
+<h1>Editing Active Field #<%= @active_field.id %></h1>
+
+<%= render_active_field_form(active_field: @active_field) %>
+
+<div><%= link_to "Back", active_fields_path %></div>

data/lib/generators/active_fields/scaffold/templates/views/active_fields/finders/_form.html.erb

@@ -0,0 +1,42 @@
+<div data-controller="active-fields-finders-form">
+  <% selector_options = [["-", [["< Add filter >", ""]]]] + active_fields.map do |active_field|
+    [
+      active_field.name,
+      active_field_finder_input_types(active_field: active_field).map do |type|
+        [
+          "#{active_field.name} [#{type}]",
+          type,
+          { data: { "active-field-name": active_field.name } },
+        ]
+      end
+    ]
+  end
+  %>
+  <%= select_tag :selector,
+    grouped_options_for_select(selector_options),
+    data: { "active-fields-finders-form-target": "selector", action: "change->active-fields-finders-form#addInput" }
+  %>
+
+  <div data-active-fields-finders-form-target="inputTemplatesContainer" style="display: none;">
+    <% active_fields.each do |active_field| %>
+      <%= fields_for :f, nil, index: 0 do |ff| %>
+        <% active_field_finder_input_types(active_field: active_field).each do |type| %>
+          <%= render_active_field_finder_input(form: ff, type: type, active_field: active_field, template: true) %>
+        <% end %>
+      <% end %>
+    <% end %>
+  </div>
+
+  <%= form_with(url: url, method: :get) do |f| %>
+    <div data-active-fields-finders-form-target="inputsContainer">
+      <% active_fields_finders_params.each do |index, finder_params| %>
+        <%= fields_for :f, nil, index: index do |ff| %>
+          <%= render_selected_active_field_finder_input(form: ff, active_fields: active_fields, finder_params: finder_params) %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <%= f.submit "Filter" %>
+    <%= link_to "Reset", url %>
+  <% end %>
+</div>

data/lib/generators/active_fields/scaffold/templates/views/active_fields/finders/inputs/_array_size.html.erb

@@ -0,0 +1,16 @@
+<div
+  data-active-fields-finders-form-target="<%= template ? "inputTemplate" : "input" %>"
+  data-type="array_size"
+  data-active-field-name="<%= active_field.name %>"
+  data-index="<%= form.index %>"
+>
+  <%= form.label :n, active_field.name, for: nil %>
+  <%= form.hidden_field :n, value: active_field.name, id: nil %>
+  <%= form.select :op,
+        operations.map { |operation_name| [operation_name, active_field.value_finder_class.operator_for(operation_name)] },
+        { selected: selected[:operator] },
+        { id: nil }
+  %>
+  <%= form.number_field :v, { value: selected[:value], min: 0, max: active_field.max_size, id: nil } %>
+  <%= button_tag "Remove", type: "button", data: { action: "click->active-fields-finders-form#removeInput" } %>
+</div>