crud_components 0.1.0 → 0.2.0

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

@@ -189,9 +189,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.0'.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.0
 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: