active_element 0.0.12 → 0.0.13

data/lib/active_element/default_record_params.rb

@@ -1,62 +0,0 @@
-# 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

@@ -1,110 +0,0 @@
-# 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