Filterable

Decouple your filtering and faceted search using concerns

How

Use a Filterable concern to mediate between your controllers/concerns and the filtering logic
In separate Filter classes, define how and which rules apply, and how to update filter params

Caveats

The Book and Restaurant classes in this example mimick an ActiveRecord model. The array refinements simply serve as stand-ins for model scopes or AR queries.

app/reflexes/filter_reflex.rb

class FilterReflex < ApplicationReflex
  include Filterable
  
  def filter
    resource, param = element.dataset.to_h.fetch_values(:resource, :param)
    value = if element["type"] == "checkbox"
      element.checked
    else 
      element.dataset.value || element.value
    end

    set_filter_for!(resource, param, value)
  end  
end

app/controllers/concerns/filterable.rb

module Filterable
  extend ActiveSupport::Concern

  included do
    if respond_to?(:helper_method)
      helper_method :filter_active_for?
      helper_method :filter_for
    end
  end

  def filter_active_for?(resource, attribute, value=true)
    filter = filter_for(resource)

    filter.active_for?(attribute, value)
  end

  private

  def filter_for(resource)
    "#{resource}Filter".constantize.new(session)
  end

  def set_filter_for!(resource, param, value)
    filter_for(resource).merge!(param, value)
  end
end

app/controllers/books_controller.rb

class BooksController < ApplicationController
  include Filterable

  def index
    @books = Book.all
    @books = filter_for("Book").apply!(@books)
  end
end

app/filters/base_filter.rb

class BaseFilter
  include ActiveModel::Model
  include ActiveModel::Attributes

  def initialize(session)
    @_session = session
    super(@_session.fetch(:filters, {})[filter_resource_class])
  end

  def apply!(_chain)
    raise NotImplementedError
  end

  def merge!(_attribute, _value)
    @_session[:filters] ||= {}
    @_session[:filters][filter_resource_class] ||= {}
  end

  def active_for?(attribute, value=true)
    filter_attribute = send(attribute)

    return filter_attribute.include?(value) if filter_attribute.is_a?(Enumerable)
    filter_attribute == value
  end

  def filter_resource_class
    @filter_resource_class || self.class.name.match(/\A(?<resource>.*)Filter\Z/)[:resource]
  end
end

app/filters/book_filter.rb

class BookFilter < BaseFilter
  attribute :query, :string, default: ""

  def apply!(chain)
    chain = chain.search(query) if query.present?
    chain
  end

  def merge!(attribute, value)
    super

    send(:"#{attribute}=", value)

    @_session[:filters]["Book"].merge!(attribute => send(attribute))
  end
end

app/models/book.rb

class Book < ApplicationRecord
  scope :search, -> { where ... }
end

app/views/books/index.html.erb

<h2 class="mt-4">Books</h2>

<input type="text" class="form-control" id="book_query" placeholder="Search for author or title" data-reflex="input->Filter#filter" data-resource="Book" data-param="query" data-reflex-root="#books-table"/>

<table class="table" id="books-table">
  <thead>
    <tr>
      <th scope="col">Author</th>
      <th scope="col">Title</th>
    </tr>
  </thead>
  <tbody>
    <% @books.each do |book| %>
      <tr>
        <td><%= book.author %></td>
        <td><%= book.title %></td>
      </tr>
    <% end %>
  </tbody>
</table>