crud_components 0.1.0 → 0.2.1

data/lib/crud_components/like_spec.rb

@@ -5,17 +5,12 @@ module CrudComponents
   #   :title                       own column
   #   %i[title subtitle]           several own columns, OR-combined
   #   { authors: %i[name email] }  join, explicit columns
-  #   :publisher                   join, delegate to Publisher's search_in
-  #   { user: :address }           nested join, delegate to Address
+  #   :publisher                   join, search Publisher's label (what you see)
+  #   { user: :address }           nested join, search Address's label
   #
   # Specs never contain SQL strings; conditions are built through Arel with
   # LIKE wildcards escaped, so they are parameterized end to end.
   module LikeSpec
-    # Only *delegation* hops (an association name resolved through the target's
-    # search_in) can form a cycle; explicit nesting is bounded by the literal
-    # spec. So the guard counts delegations only.
-    MAX_DELEGATIONS = 5
-
     module_function
 
     def apply(scope, spec, value)
@@ -29,8 +24,14 @@ module CrudComponents
 
       return scope.where(condition) if joins.empty?
 
-      # distinct only matters once a join can multiply rows
-      scope.left_joins(joins).where(condition).distinct
+      # A join can multiply rows, so the match has to be de-duplicated. We do it
+      # with an id subquery rather than SELECT DISTINCT: DISTINCT compares every
+      # selected column, which Postgres can't do for a json (or other
+      # non-comparable) column the scope happens to select — it raises "could not
+      # identify an equality operator for type json". The subquery sidesteps that
+      # and keeps the join (and its rows) out of the outer query entirely.
+      key = model.arel_table[model.primary_key]
+      scope.where(key.in(model.left_joins(joins).where(condition).select(key).arel))
     end
 
     Entry = Struct.new(:path, :klass, :column) do
@@ -47,19 +48,16 @@ module CrudComponents
       end
     end
 
-    # Resolves a spec into flat [path, klass, column] entries, expanding
-    # association names without columns through the target's search_in spec.
-    # `delegations` counts only delegation hops (the cycle risk).
-    def expand(model, spec, path = [], delegations = 0)
-      if delegations > MAX_DELEGATIONS
-        raise DefinitionError, "search_in/like delegation more than #{MAX_DELEGATIONS} levels deep " \
-                               "starting at #{model} — most likely a delegation cycle"
-      end
-
+    # Resolves a spec into flat [path, klass, column] entries. A bare
+    # association name resolves to the target's label column — the text you
+    # actually see in that association's cell — so it can never reach a
+    # target's hidden columns (passwords, tokens, …) and there is no
+    # search_in chain to form a cycle.
+    def expand(model, spec, path = [])
       Array.wrap(spec).flat_map do |item|
         case item
-        when Symbol, String then expand_name(model, item.to_sym, path, delegations)
-        when Hash then item.flat_map { |assoc, sub| expand_assoc(model, assoc.to_sym, sub, path, delegations) }
+        when Symbol, String then expand_name(model, item.to_sym, path)
+        when Hash then item.flat_map { |assoc, sub| expand_assoc(model, assoc.to_sym, sub, path) }
         else
           raise DefinitionError, "invalid like-spec element #{item.inspect} for #{model} — " \
                                  'use column symbols, association symbols, or { assoc => columns } hashes'
@@ -67,38 +65,39 @@ module CrudComponents
       end
     end
 
-    def expand_name(model, name, path, delegations)
+    def expand_name(model, name, path)
       if model.columns_hash.key?(name.to_s)
         [Entry.new(path, model, name)]
       elsif (reflection = model.reflect_on_association(name))
-        delegate(model, reflection, path, delegations)
+        delegate(model, reflection, path)
       else
         raise DefinitionError, "like-spec references '#{name}', which is neither a column nor " \
                                "an association of #{model}"
       end
     end
 
-    # Explicit nesting ({ assoc => columns }) — bounded by the spec, not a
-    # cycle risk, so it does not count against the delegation limit.
-    def expand_assoc(model, assoc, sub, path, delegations)
+    # Explicit nesting ({ assoc => columns }) — spell the target's columns out.
+    def expand_assoc(model, assoc, sub, path)
       reflection = model.reflect_on_association(assoc)
       raise DefinitionError, "like-spec references association '#{assoc}', " \
                              "which #{model} does not have" unless reflection
 
-      expand(reflection.klass, sub, path + [assoc], delegations)
+      expand(reflection.klass, sub, path + [assoc])
     end
 
-    # Association name without columns: use the target model's search_in spec.
-    def delegate(model, reflection, path, delegations)
+    # Association name without columns: search the target's label column — the
+    # name shown in its cell ("search what you see"). A block/computed label has
+    # no single column to match, so ask for the columns explicitly.
+    def delegate(model, reflection, path)
       target = reflection.klass
-      target_spec = Structure.for(target).search_in_spec
-      if target_spec.nil?
-        raise DefinitionError, "cannot delegate like-spec to #{model}##{reflection.name}: " \
-                               "#{target}'s search_in is a custom block — spell the columns out, " \
-                               "e.g. { #{reflection.name}: %i[...] }"
+      label = Structure.for(target).label_column_name
+      if label.nil?
+        raise DefinitionError, "cannot search #{model}##{reflection.name} by label: " \
+                               "#{target}'s label is not a column (custom block or computed method) — " \
+                               "spell the columns out, e.g. { #{reflection.name}: %i[...] }"
       end
 
-      expand(target, target_spec, path + [reflection.name], delegations + 1)
+      [Entry.new(path + [reflection.name], target, label)]
     end
 
     def deep_merge(left, right)

data/lib/crud_components/presenters/collection.rb

@@ -15,7 +15,7 @@ module CrudComponents
       attr_reader :model, :structure, :fieldset, :query, :layout, :param_prefix, :owner
 
       def initialize(view:, records:, fieldset: nil, query: :auto, layout: :table,
-                     param_prefix: nil, actions: true, group_by: nil,
+                     param_prefix: nil, actions: true, search_bar: true, group_by: nil,
                      extra_columns: nil, picker: false, picked_columns: :auto)
         super(view: view)
         unless records.respond_to?(:klass)
@@ -31,6 +31,7 @@ module CrudComponents
         @layout = layout
         @param_prefix = param_prefix
         @actions_enabled = actions
+        @search_bar_enabled = search_bar
         # Two orthogonal column-picker knobs (see ColumnSelection): the gear is on
         # iff `picker`; the selection comes from the param (`:auto`) or verbatim
         # from the resolved Array — they never both read the param.
@@ -181,8 +182,13 @@ module CrudComponents
         @filter_fields ||= static? ? [] : query.filter_fields
       end
 
+      # Match by name, not object identity: a prebuilt Query carries its *own*
+      # DynamicField instances (from its extra_fields), while the collection built
+      # its own from extra_columns. Same column, different objects — `include?`
+      # would miss them and silently drop the inline filter/sort (issue #21).
+      # Declared fields are memoized on the Structure, so they share a name too.
       def filterable_field?(field)
-        filter_fields.include?(field)
+        filter_fields.any? { |f| f.name == field.name }
       end
 
       def filter_form_id
@@ -192,7 +198,7 @@ module CrudComponents
 
       # ── header search (?q=) and reset ──────────────────────────────────────
       def searchable?
-        !static? && query && query.searchable?
+        @search_bar_enabled && !static? && query && query.searchable?
       end
 
       def search_param_name
@@ -238,7 +244,7 @@ module CrudComponents
 
       # ── sorting ──────────────────────────────────────────────────────────
       def sortable_field?(field)
-        !static? && query && query.sortable_fields.include?(field)
+        !static? && query && query.sortable_fields.any? { |f| f.name == field.name }
       end
 
       def sort_url(field)
@@ -355,11 +361,14 @@ module CrudComponents
         @actions_enabled && (custom_actions_partial.present? || row_action_definitions.any?)
       end
 
-      # The trailing column exists when there are row actions *or* a column
-      # picker (its gear lives in that column's header cell) — so the header,
-      # rows and width all agree even on a picker-only, action-less table.
+      # The trailing column exists when something needs to live in it: row
+      # actions (in the body cells), the column picker (its gear in the header
+      # cell), or the inline filter row (its submit/reset button sits in this
+      # column). Without it a filterable table would render filter inputs with
+      # no button to apply them. Keeping it here also keeps the header, rows and
+      # width all in agreement.
       def trailing_column?
-        actions_column? || column_picker?
+        actions_column? || column_picker? || filterable?
       end
 
       def custom_actions_partial

data/lib/crud_components/presenters/filter.rb

@@ -6,16 +6,21 @@ module CrudComponents
     class Filter < Base
       attr_reader :model, :structure, :query
 
-      def initialize(view:, model:, fieldset: nil, query: nil, param_prefix: nil)
+      def initialize(view:, model:, fieldset: nil, query: nil, param_prefix: nil, extra_columns: nil, sort: false)
         super(view: view)
         @model = model.is_a?(Class) ? model : model.klass
         @structure = Structure.for(@model)
+        @sort = sort
+        # Dynamic columns become extra query fields, so their filters appear in the
+        # form exactly like a declared field's — mirrors crud_collection's
+        # extra_columns: (issue #22). A prebuilt query already carries its own.
+        dynamic_fields = Array(extra_columns).map { |c| c.to_field(@model) }
         @query = if query.is_a?(Query)
                    query
                  else
                    Query.new(@model, view.request.query_parameters,
                              fieldset: @structure.fieldset(fieldset || :index),
-                             ability: ability, param_prefix: param_prefix)
+                             ability: ability, param_prefix: param_prefix, extra_fields: dynamic_fields)
                  end
       end
 
@@ -27,10 +32,29 @@ module CrudComponents
       def param_name(key) = query.param_name(key)
       def value(key) = query.value(key)
 
-      # Keep sort and foreign params; our own controls resubmit themselves.
+      # ── sorting (headerless surfaces) ──────────────────────────────────────
+      # Whether to render the sort picker: asked for, and there's something to
+      # sort by. A table carries its own header sort links, so this is opt-in.
+      def sort_control? = @sort && query.sortable_fields.any?
+
+      # The fields offered in the sort picker, as [human_name, name] pairs.
+      def sort_field_choices
+        query.sortable_fields.map { |f| [f.human_name, f.name.to_s] }
+      end
+
+      # [field_name, direction] currently in effect, or [nil, 'asc'] when unsorted.
+      def sort_state
+        current, dir = query.sort_state
+        [current, dir || 'asc']
+      end
+
+      # Keep foreign params; our own controls resubmit themselves. Sort/dir are
+      # kept as hidden inputs (to preserve the current sort across an Apply) unless
+      # the sort picker renders them — then they'd duplicate, so we drop them.
       def preserved_params
         own = fields.flat_map { |f| [param_name(f.name.to_s), param_name("#{f.name}_geq"), param_name("#{f.name}_leq")] }
         own += [param_name('q'), param_name('page'), param_name('per')]
+        own += [param_name('sort'), param_name('dir')] if sort_control?
         view.request.query_parameters.reject { |key, _| own.include?(key) }
       end
     end

data/lib/crud_components/query.rb

@@ -7,6 +7,10 @@ module CrudComponents
   class Query
     SORT_DIRECTIONS = %w[asc desc].freeze
 
+    # The reserved params the query itself reads. Pagination (page/per) is the
+    # host's — it lives in the controller, never here — so it is not listed.
+    RESERVED_PARAMS = %w[q sort dir].freeze
+
     attr_reader :model, :structure, :fieldset, :param_prefix
 
     def initialize(model, params, fieldset: nil, ability: nil, param_prefix: nil, extra_fields: [])
@@ -42,11 +46,38 @@ module CrudComponents
     # Current value of a (logical, unprefixed) param — for filter controls.
     def value(key) = param(key)
 
-    def active?
-      keys = filter_fields.flat_map { |f| [f.name.to_s, "#{f.name}_geq", "#{f.name}_leq"] }
-      (keys + ['q']).any? { |key| param(key) }
+    # The (prefixed) request-param names this query reads: every visible filter
+    # field's value and `_geq`/`_leq` bounds, plus the reserved q/sort/dir. The
+    # single source of truth for a strong-params permit list, so it can't drift
+    # from the columns:
+    #   params.permit(*query.permitted_keys)
+    def permitted_keys
+      (filter_param_keys + RESERVED_PARAMS).map { |key| param_name(key) }
+    end
+
+    # The subset of the current request params this query reads, present values
+    # only, keyed by their real (prefixed) param names. Feed it to
+    # filter-preserving links (pagers, breadcrumbs, "reset" targets) instead of
+    # keeping a hand-maintained copy of the params.
+    def filter_params
+      permitted_keys.each_with_object({}) do |key, kept|
+        raw = @params[key]
+        kept[key] = raw if raw.is_a?(String) && raw.present?
+      end
+    end
+
+    # The active filter and search values keyed by their logical (unprefixed)
+    # name — for rendering active-filter chips. Range bounds appear as
+    # `<field>_geq` / `<field>_leq`; the search box as `q`.
+    def active_filters
+      (filter_param_keys + ['q']).each_with_object({}) do |key, active|
+        val = param(key)
+        active[key] = val if val
+      end
     end
 
+    def active? = active_filters.any?
+
     # [field_name_string, direction_string] or nil.
     def sort_state
       field = current_sort_field
@@ -57,6 +88,14 @@ module CrudComponents
 
     private
 
+    # Logical (unprefixed) filter param keys: each visible filter field's value
+    # plus its `_geq`/`_leq` bounds. Bounds are listed for every field even
+    # though only ranges use them — apply_filters reads all three uniformly, so
+    # the permit list mirrors exactly what can reach SQL.
+    def filter_param_keys
+      filter_fields.flat_map { |field| [field.name.to_s, "#{field.name}_geq", "#{field.name}_leq"] }
+    end
+
     def prefix = param_prefix ? "#{param_prefix}_" : ''
 
     def param(key)
@@ -75,12 +114,12 @@ module CrudComponents
 
     def apply_filters(scope)
       filter_fields.reduce(scope) do |current, field|
-        exact = param(field.name.to_s)
+        value = param(field.name.to_s)
         geq = param("#{field.name}_geq")
         leq = param("#{field.name}_leq")
-        next current unless exact || geq || leq
+        next current unless value || geq || leq
 
-        field.apply_filter(current, exact: exact, geq: geq, leq: leq)
+        field.apply_filter(current, value: value, geq: geq, leq: leq)
       end
     end
 

data/lib/crud_components/structure.rb

@@ -172,6 +172,13 @@ module CrudComponents
       label_source.is_a?(Symbol) ? label_source : nil
     end
 
+    # The label as a real database column, else nil (block label, or a Symbol
+    # naming a computed method). Only a column can be sorted or LIKE-matched.
+    def label_column_name
+      name = label_field_name
+      name if name && model.column_names.include?(name.to_s)
+    end
+
     # The icon name (no library prefix) badging this model: the declared `icon`,
     # else the name-based guess in `config.model_icons` (keyed by the singular
     # underscored model name), else `config.model_fallback_icon` (nil = none).
@@ -189,9 +196,12 @@ module CrudComponents
       @search_in_spec ||= (@search_decl.presence || default_search_spec)
     end
 
+    # "Search what you see": with no search_in declared, ?q= covers the text
+    # shown on the index — own string/text columns, plus associations through
+    # their label. Columns you never display (and a model's hidden secrets) are
+    # never reached. Derived from the index fieldset; declared search_in wins.
     def default_search_spec
-      model.columns.select { |col| %i[string text].include?(col.type) }
-           .map { |col| col.name.to_sym }
+      fieldset_fields(fieldset(:index)).filter_map(&:search_spec_entry).uniq
     end
 
     def searchable?

data/lib/crud_components/typed_filter.rb

@@ -0,0 +1,113 @@
+module CrudComponents
+  # The mechanism behind a typed dynamic-column filter (built internally by
+  # {Fields::Base} — you don't construct one). It pairs a value type with an apply
+  # block: the type drives casting and the rendered control, the block reaches SQL.
+  #
+  # A {DynamicColumn} gets one when its `filter:` block declares keyword params; the
+  # type comes from the column's `as:` (overridable with `filter_as:`). The block
+  # declares which of `eq:` / `geq:` / `leq:` / `contains:` it handles and is called
+  # with only those — each value already cast to the type (numeric → BigDecimal,
+  # date → Date, boolean → true/false), or nil when the param is blank or doesn't
+  # parse. Which control renders follows from the type and the declared keywords: a
+  # numeric/date block that asks for a bound (`geq:`/`leq:`) renders a range; one
+  # that asks only for `eq:` renders a single field.
+  #
+  # @api private
+  class TypedFilter
+    TYPES = %i[text numeric date boolean select].freeze
+
+    # Every keyword a block may declare. The bare `?field=` value binds to
+    # `contains:` when the block asks for it, otherwise to `eq:`; the `_geq`/`_leq`
+    # params bind to `geq:`/`leq:`.
+    KEYWORDS = %i[eq contains geq leq choices].freeze
+
+    attr_reader :type, :choices
+
+    def initialize(type, apply, choices: nil)
+      unless TYPES.include?(type)
+        raise ArgumentError, "unknown filter type #{type.inspect} — one of #{TYPES.map(&:inspect).join(', ')}"
+      end
+      raise ArgumentError, 'a typed filter needs an apply block (a callable)' unless apply.respond_to?(:call)
+
+      @type = type
+      @apply = apply
+      @choices = choices
+      @keywords = declared_keywords(apply)
+    end
+
+    # The filter partial to render (`crud_components/filters/_<control>`).
+    def control
+      case type
+      when :numeric then range? ? :number_range : :number
+      when :date    then range? ? :date_range : :date
+      else type
+      end
+    end
+
+    # Apply with the raw param values (Strings or nil): `value` is the bare
+    # `?field=`, `geq`/`leq` the bounds. Each is cast to the type and routed to the
+    # keyword the block declared; a value that doesn't cast becomes nil, so junk
+    # never reaches SQL.
+    def apply(scope, value: nil, geq: nil, leq: nil)
+      single = (@keywords.include?(:contains) && !@keywords.include?(:eq)) ? :contains : :eq
+      values = { single => cast(value), geq: cast(geq), leq: cast(leq), choices: @choices }
+      @apply.call(scope, **values.slice(*@keywords))
+    end
+
+    # The `[label, value]` pairs a `:select` offers, or nil for any other type. A
+    # callable `choices` is resolved here (passed the query when it takes an arg).
+    def filter_choices(query = nil)
+      return nil unless type == :select
+
+      raw = @choices.respond_to?(:call) ? (@choices.arity.zero? ? @choices.call : @choices.call(query)) : @choices
+      Array(raw).map { |opt| opt.is_a?(Array) ? opt : [opt.to_s, opt] }
+    end
+
+    private
+
+    TRUE_VALUES = %w[true t 1 yes on].freeze
+    FALSE_VALUES = %w[false f 0 no off].freeze
+
+    def range? = (@keywords & %i[geq leq]).any?
+
+    # The keywords the block declared. A block with `**` (keyrest) takes everything.
+    def declared_keywords(apply)
+      params = apply.respond_to?(:parameters) ? apply.parameters : []
+      return KEYWORDS if params.any? { |kind, _| kind == :keyrest }
+
+      params.filter_map { |kind, name| name if %i[key keyreq].include?(kind) }
+    end
+
+    def cast(value)
+      return nil if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+      case type
+      when :numeric then cast_decimal(value)
+      when :date    then cast_date(value)
+      when :boolean then cast_boolean(value)
+      else value
+      end
+    end
+
+    def cast_decimal(value)
+      decimal = BigDecimal(value.to_s)
+      decimal.finite? ? decimal : nil
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def cast_date(value)
+      Date.parse(value.to_s)
+    rescue ArgumentError, TypeError, RangeError
+      nil
+    end
+
+    def cast_boolean(value)
+      down = value.to_s.downcase
+      return true if TRUE_VALUES.include?(down)
+      return false if FALSE_VALUES.include?(down)
+
+      nil
+    end
+  end
+end

data/lib/crud_components/version.rb

@@ -1,3 +1,3 @@
 module CrudComponents
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/lib/crud_components.rb

@@ -17,6 +17,13 @@ module CrudComponents
   # nullable columns offer it as a "not set" choice). Improbable as a real
   # value, so it never collides with a genuine enum key or boolean string.
   NULL_FILTER_VALUE = '__null__'.freeze
+
+  # The two non-blank values of an attachment **presence** filter — its 3-state
+  # control (any / present / absent) submits these, and the query turns them into
+  # an EXISTS / NOT EXISTS (`where.associated` / `where.missing`) over the backing
+  # attachment association rather than a value match. See {Fields::AttachmentField}.
+  PRESENT_FILTER_VALUE = 'present'.freeze
+  ABSENT_FILTER_VALUE = 'absent'.freeze
 end
 
 require_relative 'crud_components/version'
@@ -25,6 +32,7 @@ require_relative 'crud_components/config'
 require_relative 'crud_components/permission_context'
 require_relative 'crud_components/like_spec'
 require_relative 'crud_components/where_like'
+require_relative 'crud_components/typed_filter'
 require_relative 'crud_components/fields/base'
 require_relative 'crud_components/fields/string_field'
 require_relative 'crud_components/fields/text_field'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crud_components
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Anatoly Zelenin
@@ -75,6 +75,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -110,8 +111,11 @@ files:
 - app/views/crud_components/fields/_text.html.erb
 - app/views/crud_components/fields/_url.html.erb
 - app/views/crud_components/filters/_boolean.html.erb
+- app/views/crud_components/filters/_date.html.erb
 - app/views/crud_components/filters/_date_range.html.erb
+- app/views/crud_components/filters/_number.html.erb
 - app/views/crud_components/filters/_number_range.html.erb
+- app/views/crud_components/filters/_presence.html.erb
 - app/views/crud_components/filters/_select.html.erb
 - app/views/crud_components/filters/_text.html.erb
 - app/views/crud_components/form_fields/_belongs_to.html.erb
@@ -130,6 +134,7 @@ files:
 - crud_components.gemspec
 - docs/extending.md
 - docs/fields.md
+- docs/filtering.md
 - docs/forms.md
 - docs/performance.md
 - docs/security.md
@@ -173,6 +178,7 @@ files:
 - lib/crud_components/query.rb
 - lib/crud_components/route_resolver.rb
 - lib/crud_components/structure.rb
+- lib/crud_components/typed_filter.rb
 - lib/crud_components/version.rb
 - lib/crud_components/where_like.rb
 - lib/generators/crud_components/install/install_generator.rb
@@ -188,6 +194,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/itadventurer/crud_components
   source_code_uri: https://github.com/itadventurer/crud_components
+  changelog_uri: https://github.com/itadventurer/crud_components/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: