card-mod-filter 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a74d8d165d6938cdcc7dba028a7e9d4c51f5c81bafff831be97e2b941af7cd3
+  data.tar.gz: 8de27d3a0e862aef786b5121d0f51ae4809f15ea90ed6ba1d7ab83f1f8c0a6c2
+SHA512:
+  metadata.gz: 1b3b5cb680b5be0c170c6a9c9b651e1aadac8a56fdc5ac772363bdf1741640a51c676419ea3df0c131bb0b8529330507e930d44acfbf2d03e3d12d1da26493a5
+  data.tar.gz: 525485ae8d031e33f3f653cfbe99a70f67c1098071ea7985a7107852e32f5b5b5743c8b1c86f610472c76c06e3b457398f48dba48904978df6e3b9957877a4b4

data/README.md

@@ -0,0 +1,60 @@
+<!--
+# @title README - mod: filter
+-->
+
+# Filter mod
+
+This mod provides a framework for enhancing card searches with advanced filtering
+interfaces. 
+
+Include the Abstract::Filter set in any search set to add both:
+
+- a `filter_form` view with progressive disclosure filter accordions inside an offcanvas, 
+  and
+- a `compact_filter_form` view that opens compact filter interfaces in place above search
+  results.
+
+The mod also adds support for a `filtered_list` view of list/pointer cards that makes it
+easier to choose list items from options too numerous or complicated to fit into a 
+standard dropdown.
+
+Filters for a given set can be specified with the `#filter_map` method, which should
+return a list of filter configurations. Each configuration can be a Symbol or a Hash.
+For example, here is a simple configuration with three filters.
+
+```
+def filter_map 
+  [name topic bookmark]
+end
+```
+
+For each filter you can use methods to define:
+  1. labels, eg `#filter_topic_label` (same as the filter key if not defined)
+  2. options, eg `#filter_topic_options` (empty by default)
+  3. a default value, eg `#filter_topic_default` (blank unless specified), and
+  4. a type, eg `#filter_topic_type` (defaults to text).
+
+Type options include:
+
+  - text
+  - autocomplete
+  - radio
+  - check
+  - select
+  - multiselect
+  - range
+
+It is also possible to write custom filter types in the following manner:
+
+```
+def filter_myfield_type
+  :my_custom_type
+end  
+
+def my_custom_type_filter
+  # returns filter ui
+end
+```
+
+Note that fields that use radio and check filtering in the `filter_form` view will use 
+select and multiselect filtering respectively in the `compact_filter_form` view.

data/lib/card/filter_query.rb

@@ -0,0 +1,78 @@
+class Card
+  # Class for generating CQL based on filter params
+  class FilterQuery
+    def initialize filter_keys_with_values, extra_cql={}
+      @filter_cql = Hash.new { |h, k| h[k] = [] }
+      @rules = yield if block_given?
+      @rules ||= {}
+      @filter_keys_with_values = filter_keys_with_values
+      @extra_cql = extra_cql
+      prepare_filter_cql
+    end
+
+    def add_to_cql key, value
+      @filter_cql[key] << value
+    end
+
+    def add_rule key, value
+      return unless value.present?
+
+      case @rules[key]
+      when Symbol
+        send("#{@rules[key]}_rule", key, value)
+      when Proc
+        @rules[key].call(key, value).each do |cql_key, val|
+          @filter_cql[cql_key] << val
+        end
+      else
+        send "#{key}_cql", value
+      end
+    end
+
+    def to_cql
+      @cql = {}
+      @filter_cql.each do |cql_key, values|
+        next if values.empty?
+
+        case cql_key
+        when :right_plus, :left_plus, :type
+          merge_using_and cql_key, values
+        else
+          merge_using_array cql_key, values
+        end
+      end
+      @cql.merge @extra_cql
+    end
+
+    private
+
+    def prepare_filter_cql
+      @filter_keys_with_values.each do |key, values|
+        add_rule key, values
+      end
+    end
+
+    def merge_using_array cql_key, values
+      @cql[cql_key] = values.one? ? values.first : values
+    end
+
+    def merge_using_and cql_key, values
+      hash = build_nested_hash cql_key, values
+      @cql.deep_merge! hash
+    end
+
+    # nest values with the same key using :and
+    def build_nested_hash key, values
+      return { key => values[0] } if values.one?
+
+      val = values.pop
+      { key => val, and: build_nested_hash(key, values) }
+    end
+
+    def name_cql name
+      return unless name.present?
+
+      @filter_cql[:name] = ["match", name]
+    end
+  end
+end

data/set/abstract/0_filter/filter_fields.rb

@@ -0,0 +1,46 @@
+format :html do
+  def filter_config category
+    @filter_config ||= {}
+    @filter_config[category] ||=
+      %i[type default options label].each_with_object({}) do |trait, hash|
+        method = "filter_#{category}_#{trait}"
+        hash[trait] = send method if respond_to? method
+      end
+  end
+
+  def filter_name_type
+    :text
+  end
+
+  def filter_label field
+    filter_config(field)[:label] || filter_label_from_name(field)
+  end
+
+  def filter_label_from_name field
+    Card.fetch_name(field) { field.to_s.sub(/^\*/, "").titleize }
+  end
+
+  def filter_closer_value field, value
+    try("filter_#{field}_closer_value", value) || value
+  end
+
+  def filter_options raw
+    return raw if raw.is_a? Array
+
+    raw.each_with_object([]) do |(key, value), array|
+      array << [key, value.to_s]
+      array
+    end
+  end
+
+  def type_options type_codename, order="asc", max_length=nil
+    Card.cache.fetch "#{type_codename}-TYPE-OPTIONS" do
+      res = Card.search type: type_codename, return: :name, sort_by: "name", dir: order
+      max_length ? (res.map { |i| [trim_option(i, max_length), i] }) : res
+    end
+  end
+
+  def trim_option option, max_length
+    option.size > max_length ? "#{option[0..max_length]}..." : option
+  end
+end

data/set/abstract/0_filter/filter_form/_compact_filter_input.haml

@@ -0,0 +1,7 @@
+._filter-input.filter-input-group.input-group.input-group-sm{"data-category": field[:key],
+                                                             "class": "_filter-input-#{field[:key]}" }
+  %button.btn.btn-secondary.input-group-text.p-1._delete-filter-input{:type => "button"}
+    = icon_tag :remove
+  %span.input-group-text._selected-category.text-muted
+    = field[:label]
+  = field[:input_field]

data/set/abstract/0_filter/filter_form/compact_filter_form.haml

@@ -0,0 +1,46 @@
+- @compact_filter_form = true
+.card.w-100.nodblclick
+  .card-body
+    ._compact-filter
+      // FILTERING PROTOTYPES
+      ._filter-input-field-prototypes.d-none
+        - compact_filter_form_fields.each do |field|
+          = haml_partial :compact_filter_input, field: field
+
+      // FORM
+      %form._compact-filter-form._filter-form{ filter_form_args }
+        %input{ type: :hidden,
+                name: "filter[not_ids]",
+                class: "_not-ids",
+                value: params.dig(:filter, :not_ids) }
+        = render_compact_quick_filters
+        .filter-and-sort.d-flex.flex-wrap
+          = render_filter_sort_dropdown
+
+
+          // FILTERING
+          .filter-in-filter-form
+            = icon_tag :filter, "filter-section-icon"
+            ._filter-container.d-flex.flew-row.flex-wrap.align-items-start
+              // FILTERS inserted here dynamically from prototypes
+
+              // ADD FILTER DROPDOWN
+              .dropdown._add-filter-dropdown.me-2
+                %button.btn.btn-sm.btn-primary._filter-dropdown.dropdown-toggle{"aria-expanded": "false",
+                                                                                "aria-haspopup": "true",
+                                                                                "data-bs-toggle": "dropdown",
+                                                                                type: "button" }
+                  More Filters
+                .dropdown-menu
+                  - compact_filter_form_fields.each do |field|
+                    %a{ class: "dropdown-item _filter-category-select",
+                        href: "#",
+                        "data-category": field[:key],
+                        "data-label": field[:label],
+                        "data-active": ("true" if field[:active])}
+                      = field[:label]
+
+              // RESET BUTTON
+              ._reset-filter{ "data-reset": reset_filter_data }
+                %button.btn.btn-sm.btn-secondary{ type: "button" }
+                  = icon_tag :reset

data/set/abstract/0_filter/filter_form/compact_quick_filters.haml

@@ -0,0 +1,14 @@
+- if (quick_filters = quick_filter_list).present?
+  .quick-filter._quick-filter
+
+    = icon_tag :quick_filter, "filter-section-icon"
+    .quick-filter-links.d-flex.flex-wrap
+      - quick_filters.each do |hash|
+        - f = quick_filter_item hash.clone, hash.keys.first
+        %a{ "data-filter": f[:filter],
+            href: "#",
+            class: f[:class],
+            title: "Quick Filter: #{f[:text]}" }
+          = f[:icon]
+          = f[:text]
+      = custom_quick_filters

data/set/abstract/0_filter/filter_form/filter_bars.haml

@@ -0,0 +1,4 @@
+%form._filter-form._filter-bars{ filter_form_args }
+  .filter-form.accordion
+    - filter_map.each do |item|
+      = filter_bar item

data/set/abstract/0_filter/filter_form/filter_sort_dropdown.haml

@@ -0,0 +1,12 @@
+// SORTING
+- options = sort_options
+- current = current_sort
+- if options.present?
+  .sort-in-filter-form
+    .input-group.input-group-sm.flex-nowrap.sort-input-group.mb-2.me-2
+      %span.input-group-text.text-muted Sort
+      = select_tag "sort_by",
+                   options_for_select(options, current),
+                   class: "pointer-select _filter-sort form-control",
+                   include_blank: ("--" unless options.values.include? current),
+                   "data-minimum-results-for-search": "Infinity"

data/set/abstract/0_filter/filter_form/filtered_results_header.haml

@@ -0,0 +1,33 @@
+.filtered-results-header._filtered-results-header
+  %form.filtered-results-form{ filter_form_args }
+    .header-top-row.mb-4.d-flex.justify-content-between.align-items-center
+      .filter-badges._filter-closers
+        - removables = removable_filters
+        - removables.each do |key, value|
+          - filter = filter_hash_without key, value
+          %a.btn.btn-sm.btn-outline-primary.m-1.ms-0{ "data-filter": JSON(filter),
+                                                      class: "filter-closer close-filter-#{key}" }
+            = "#{filter_label key}: "
+            %span.fw-bold
+              = filter_closer_value key, value
+
+            = icon_tag :remove, class: "ms-2"
+        - if removables.size > 1
+          %a.clear-filters.m-1.ms-0{ "data-filter": "{}", href: "#" }
+            Clear All
+         
+
+      ._filters-button.ms-3
+        %a.text-reset.fw-bold{ "data-bs": { toggle: "offcanvas",
+                                            target: "##{offcanvas_filter_id}" },
+                               title: "All Filters",
+                               href: "" }
+          = icon_tag :filter_list
+          ALL FILTERS
+
+    .header-middle-row.my-4
+      = render_filtered_results_visualization
+    .header-bottom-row.mb-2.mt-4.d-flex.justify-content-between.align-items-center
+      = render_filtered_results_stats
+      = render_filter_sort_dropdown
+

data/set/abstract/0_filter/filter_form/offcanvas_filters.haml

@@ -0,0 +1,9 @@
+._offcanvas-filter.offcanvas.offcanvas-end{ id: offcanvas_filter_id,
+                                            "data-bs": {
+                                              scroll: "true", backdrop: "false"
+                                            } }
+  .offcanvas-header
+    %h5.offcanvas-title Filters
+    %button.btn.btn-close{ "data-bs": { dismiss: "offcanvas" } }
+  .offcanvas-body{ data: { path: path, query: JSON(filter: filter_hash) } }
+

data/set/abstract/0_filter/filter_form/open_filter_button.haml

@@ -0,0 +1 @@
+

data/set/abstract/0_filter/filter_form/select_item.haml

@@ -0,0 +1,15 @@
+.filter-header.card-header
+  %h5
+    Select Item
+    -#.badge.bg-secondary
+    -#  = card.count
+.filter-selector.p-2
+  - if card.count > 0
+    .filter-bulk-selector.pb-3
+      %input#select-all._select-all{name: "", type: "checkbox", value: ""}
+      %label{for: "select-all"}
+        select
+        %span._unselected-items
+          = search_with_params.size
+        following
+  = render :checkbox_list

data/set/abstract/0_filter/filter_form/selectable_filtered_content.haml

@@ -0,0 +1,2 @@
+._selectable-filtered-content._over-card-link
+  = render_compact_filtered_content hide: :export_button

data/set/abstract/0_filter/filter_form.rb

@@ -0,0 +1,123 @@
+format :html do
+  view :filter_bars, cache: :never, template: :haml
+
+  # ~~~~ Compact (inline) sort and filter ui
+  # including prototypes, filters, sorting, "More", and reset
+
+  view :compact_filter_form, cache: :never, template: :haml
+  view :filter_sort_dropdown, cache: :never, template: :haml
+  view :compact_quick_filters, cache: :never, template: :haml
+
+  # ~~~~ FILTER RESULTS
+
+  view :filtered_content do
+    wrap true, class: "_filtered-content nodblclick" do
+      [render_offcanvas_filters, render_filtered_results(home_view: :filtered_results)]
+    end
+  end
+
+  view :compact_filtered_content do
+    wrap true, class: "_filtered-content nodblclick" do
+      voo.hide! :filtered_results_header
+      [render_compact_filter_form, render_filtered_results(home_view: :filtered_results)]
+    end
+  end
+
+  view :filtered_results, cache: :never do
+    wrap true, class: "_filter-result-slot" do
+      [render_filtered_results_header, render_core, render_filtered_results_footer]
+    end
+  end
+
+  view :offcanvas_filters, template: :haml, cache: :never
+  view :filtered_results_header, template: :haml, cache: :never
+  view :filtered_results_stats, cache: :never do
+    labeled_badge count_with_params, "Results"
+  end
+
+  # for override
+  view(:filtered_results_visualization) { "" }
+  view(:filtered_results_footer) { "" }
+
+  view :selectable_filtered_content, template: :haml, cache: :never
+
+  before(:select_item) { class_up "card-slot", "_filter-result-slot" }
+  view :select_item, cache: :never, wrap: :slot, template: :haml
+
+  def filter_form_args
+    {
+      action: path,
+      class: "slotter",
+      method: "get",
+      "accept-charset": "UTF-8",
+      "data-remote": true,
+      "data-slot-selector": "._filter-result-slot",
+      "data-filter": filter_hash.to_json
+    }
+  end
+
+  def compact_filter_form_fields
+    @compact_filter_form_fields ||=
+      all_filter_keys.map do |key|
+        { key: key,
+          label: filter_label(key),
+          input_field: filter_input_field(key, compact: true),
+          active: active_filter?(key) }
+      end
+  end
+
+  def filter_bar item
+    item = { key: item } unless item.is_a? Hash
+    body = filter_bar_content item
+    title = filter_label item[:key]
+    context = item[:key].to_name.safe_key
+    accordion_item title, body: body, open: item[:open], context: context
+  end
+
+  def filter_bar_content item
+    if item[:type] == :group
+      accordion do
+        item[:filters].map do |subitem|
+          filter_bar subitem
+        end.join
+      end
+    else
+      filter_input_field item[:key]
+    end
+  end
+
+  def offcanvas_filter_id
+    "d0-#{card.name.safe_key}-offCanvasFilters"
+  end
+
+  def reset_filter_data
+    JSON default_filter_hash
+  end
+
+  def quick_filter_item hash, filter_key
+    {
+      text: (hash.delete(:text) || hash[filter_key]),
+      class: css_classes(hash.delete(:class),
+                         "_compact-filter-link quick-filter-by-#{filter_key}"),
+      filter: JSON(hash[:filter] || hash)
+    }
+  end
+
+  # for override
+  def quick_filter_list
+    []
+  end
+
+  # for override
+  def custom_quick_filters
+    ""
+  end
+
+  def active_filter? field
+    if filter_keys_from_params.present?
+      filter_hash.key? field
+    else
+      default_filter_hash.key? field
+    end
+  end
+end

data/set/abstract/0_filter/filter_input_fields/check_filter.haml

@@ -0,0 +1,13 @@
+- tag_method = field_type == :check ? :check_box_tag : :radio_button_tag
+.filter-list._filter-list{ class: "filter-#{field_type}-list _filter-#{field}-field"}
+  - options.each_with_index do |(label, value), index|
+    - id = "filter-#{input_name.to_name.key}-#{value.to_name.key}"
+    - value ||= label
+    .form-check{ class: ("_more-filter-option" if index > 10) }
+      %label.form-check-label{ for: id }<
+        = label
+      = send tag_method, input_name, value, value.in?(default),
+                         id: id, class: "form-check-input _submit-on-change"
+  - if options.size > 10
+    ._show-more-filter-options.show-more-filter-options
+      %a{ href: "#" } show more

data/set/abstract/0_filter/filter_input_fields.rb

@@ -0,0 +1,111 @@
+format :html do
+  COMPACT_FILTER_TYPES = { radio: :select, check: :multiselect }.freeze
+
+  def filter_input_field field, default: nil, compact: false
+    fc = filter_config field
+    default ||= fc[:default]
+    filter_type = (compact && COMPACT_FILTER_TYPES[fc[:type]]) || fc[:type] || :text
+    send "#{filter_type}_filter", field, default, fc[:options]
+  end
+
+  private
+
+  # ~~~~~~~ FILTER TYPES ~~~~~~~~~~~~~~~ #
+
+  def check_filter *args
+    check_or_radio_filter :check, *args
+  end
+
+  def radio_filter *args
+    check_or_radio_filter :radio, *args
+  end
+
+  def select_filter field, default, options, multiple: false
+    options = filter_options options
+    options = [["--", ""]] + options unless default
+    select_filter_tag field, default, options, multiple: multiple
+  end
+
+  def multiselect_filter field, default, options
+    select_filter field, default, options, multiple: true
+  end
+
+  def autocomplete_filter type_code, _default, options_card=nil
+    options_card ||= Card::Name[type_code, :type, :by_name]
+    text_filter type_code, "", class: "#{type_code}_autocomplete",
+                               "data-options-card": options_card
+  end
+
+  def text_filter field, default, opts
+    opts ||= {}
+    value = filter_param(field) || default
+    text_filter_with_name_and_value filter_input_name(field), value, opts
+  end
+
+  def range_filter field, default, opts
+    opts ||= {}
+    default ||= {}
+    add_class opts, "simple-text range-filter-field"
+    wrap_with :div, class: "input-group" do
+      [range_sign(:from),
+       sub_text_filter(field, :from, default, opts),
+       range_sign(:to),
+       sub_text_filter(field, :to, default, opts)]
+    end
+  end
+
+  # ~~~~~~~ HELPER METHODS ~~~~~~~~~~~~~~~ #
+
+  def check_or_radio_filter check_or_radio, field, default, options
+    haml :check_filter,
+         field_type: check_or_radio,
+         field: field,
+         input_name: filter_input_name(field, multi: (check_or_radio == :check)),
+         options: filter_options(options),
+         default: Array.wrap(filter_param(field) || default)
+  end
+
+  def text_filter_with_name_and_value name, value, opts
+    opts[:class] ||= "simple-text"
+    add_class opts, "form-control _submit-after-typing"
+    text_field_tag name, value, opts
+  end
+
+  def select_filter_tag field, default, options, multiple: false, disabled: false
+    klasses = "_filter_input_field filter-input filter-input-#{field} " \
+              "_submit-on-change form-control " \
+              "pointer-#{'multi' if multiple}select"
+    # not sure form-control does much here?
+    klasses << " _no-select2" if @compact_filter_form # select2 initiated once active
+
+    select_tag filter_input_name(field, multi: multiple),
+               options_for_select(options, (filter_param(field) || default)),
+               id: "filter-input-#{unique_id}",
+               multiple: multiple,
+               class: klasses,
+               disabled: disabled
+  end
+
+  def range_sign side
+    dir = side == :from ? "greater" : "less"
+    icon_tag("#{dir}_than", class: "input-group-text range-sign")
+  end
+
+  def sub_text_filter field, subfield, default={}, opts={}
+    name = filter_input_name field, subfield: subfield
+    value = filter_hash.dig(field, subfield) || default[subfield]
+    text_filter_with_name_and_value name, value, opts
+  end
+
+  def filter_input_name field, subfield: nil, multi: false
+    parts = [filter_prefix, "[#{field}]"]
+    parts << "[#{subfield}]" if subfield
+    parts << "[]" if multi
+    parts.join
+  end
+
+  # for override
+  def filter_prefix
+    "filter"
+  end
+end

data/set/abstract/0_filter.rb

@@ -0,0 +1,131 @@
+include_set Abstract::BsBadge
+
+format do
+  def filter_class
+    Card::FilterQuery
+  end
+
+  def filter_map
+    [{ key: :name, open: true }]
+  end
+
+  def filter_keys_from_params
+    filter_hash.keys.map(&:to_sym) - [:not_ids]
+  end
+
+  def sort_options
+    { "Alphabetical": :name, "Recently Added": :create }
+  end
+
+  # all filter keys in the order they were selected
+  def all_filter_keys
+    @all_filter_keys ||= filter_keys_from_params | filter_keys
+  end
+
+  def current_sort
+    sort_param || default_sort_option
+  end
+
+  def default_sort_option
+    cql = card.cql_content || {}
+    cql[:sort_by] || cql[:sort]
+  end
+
+  def filter_param field
+    filter_hash[field.to_sym]
+  end
+
+  def filter_hash
+    @filter_hash ||= filter_hash_from_params || voo.filter || default_filter_hash
+  end
+
+  def filter_hash_from_params
+    param = Env.params[:filter]
+    if param.blank?
+      nil
+    elsif param.to_s == "empty"
+      {}
+    else
+      Env.hash(param).deep_symbolize_keys
+    end
+  end
+
+  def sort_param
+    @sort_param ||= safe_sql_param :sort_by
+  end
+
+  def safe_sql_param key
+    param = Env.params[key]
+    param.blank? ? nil : Card::Query.safe_sql(param)
+  end
+
+  def filter_keys
+    filter_keys_from_map_list(filter_map).flatten.compact
+  end
+
+  def filter_keys_from_map_list list
+    list.map do |item|
+      case item
+      when Symbol then item
+      when Hash then filter_keys_from_map_hash item
+      end
+    end
+  end
+
+  def filter_keys_from_map_hash item
+    item[:filters] ? filter_keys_from_map_list(item[:filters]) : item[:key]
+  end
+
+  def filter_keys_with_values
+    filter_keys.map do |key|
+      values = filter_param(key)
+      values.present? ? [key, values] : next
+    end.compact
+  end
+
+  # initial values for filtered search
+  def default_filter_hash
+    {}
+  end
+
+  def filter_hash_without key, value
+    filter_hash.clone.tap do |hash|
+      case hash[key]
+      when Array
+        hash[key] = hash[key] - Array.wrap(value)
+      else
+        hash.delete key
+      end
+    end
+  end
+
+  def removable_filters
+    each_removable_filter do |key, value, array|
+      if value.is_a? Array
+        value.each { |v| array << [key, v] }
+      elsif !empty_filter_value_hash? value
+        array << [key, value]
+      end
+    end
+  end
+
+  def empty_filter_value_hash? value
+    value.is_a?(Hash) && value.values.present? && !value.values.select(&:present?).any?
+  end
+
+  def each_removable_filter
+    filter_hash&.each_with_object([]) do |(key, val), arr|
+      yield key, val, arr if val.present? && filter_config(key)[:default] != val
+    end
+  end
+
+  def extra_paging_path_args
+    super.merge filter_and_sort_hash
+  end
+
+  def filter_and_sort_hash
+    { filter: filter_hash }.tap do |hash|
+      hash[:sort_by] = sort_param if sort_param
+    end
+  end
+end

data/set/abstract/cached_type_options.rb

@@ -0,0 +1,8 @@
+# in FormHelper, #type_options has a special caching for the type options in filters.
+#
+# If this mod is included in the type set, it will clear that cache when items are
+# added or deleted.
+
+event :clear_cached_type_options, :integrate do
+  Card.cache.delete "#{type_code}-TYPE-OPTIONS"
+end

data/set/abstract/cql_search/filter.rb

@@ -0,0 +1,33 @@
+# needs to be included here because Abstract::Search does not have Abstract::Filter
+# when Abstract::CqlSearch includes Abstract::Search.
+include_set Abstract::Filter
+
+format do
+  def search_params
+    super.merge filter_and_sort_cql
+  end
+
+  def filter_and_sort_cql
+    filter_cql.merge sort_cql
+  end
+
+  def filter_cql
+    return {} if filter_hash.empty?
+
+    filter_cql_from_params
+  end
+
+  # separate method is needed for tests
+  def filter_cql_from_params
+    filter_class.new(filter_keys_with_values, blocked_id_cql).to_cql
+  end
+
+  def sort_cql
+    { sort_by: current_sort }
+  end
+
+  def blocked_id_cql
+    not_ids = filter_param :not_ids
+    not_ids.present? ? { id: ["not in", not_ids.split(",")] } : {}
+  end
+end

data/set/abstract/filter_link.rb

@@ -0,0 +1,15 @@
+
+
+format :html do
+  def filterable filter_hash={}, html_opts={}
+    add_class html_opts, "_filterable _noFilterUrlUpdates"
+    html_opts[:data] ||= {}
+    html_opts[:data][:filter] = filter_hash
+    wrap_with :div, yield, html_opts
+  end
+
+  def filtering selector=nil
+    selector ||= "._compact-filter:visible"
+    wrap_with :div, yield, class: "_filtering", "data-filter-selector": selector
+  end
+end

data/set/abstract/filterable_list.rb

@@ -0,0 +1,16 @@
+# Makes it so that a List can be viewed (and filtered) as a Search
+
+include_set Abstract::CqlSearch
+include_set Abstract::SearchViews
+
+def cql_content
+  { referred_to_by: "_" }
+end
+
+def item_cards args={}
+  standard_item_cards args
+end
+
+def count
+  item_strings.size
+end

data/set/abstract/filtered_list/filter_items.haml

@@ -0,0 +1,28 @@
+._filter-items.container-fluid.nodblclick._noFilterUrlUpdates{ data: filter_items_data }
+  .row
+    = nest filter_card, view: :compact_filter_form
+    ._unselected.col-6.border.mt-2.px-0
+      = nest filter_card, view: :select_item,
+                          items: { view: implicit_item_view },
+                          cql: { limit: 10 }
+    ._selected.col-6.border.mt-2.ps-0.pe-0
+      .selected-box
+        .card-header
+          %h5
+            Selected
+            .badge.bg-secondary
+              %span._selected-items 0
+        ._selected-item-list{ style: "display:none" }
+          .deselector.p-2
+            %input#deselect-all._deselect-all{ type: "checkbox", checked: true, disabled: true }
+            %label{ for: "deselect-all" }
+              deselect
+              %span._selected-items 0
+              following
+          ._selected-bin.p-2
+      ._filter-help.alert.alert-secondary
+        Filter and select items to add them here.
+      .form-group
+        .selected-item-buttons.p-2
+          = button_tag "Cancel", class: "cancel-modal", data: { dismiss: :modal }
+          = render :add_selected_link

data/set/abstract/filtered_list/filtered_list_input.haml

@@ -0,0 +1,7 @@
+.filtered-list-editor
+  %ul.pointer-list.filtered-list-review._filtered-list.list-group.vertical.p-0
+    - card.item_cards(context: :raw).each do |item_card|
+      = nest_item item_card, view: filtered_item_view, wrap: filtered_item_wrap
+  %br
+  .clearfix
+    = add_item_modal_link

data/set/abstract/filtered_list.rb

@@ -0,0 +1,105 @@
+def unique_items?
+  true
+end
+
+def not_ids_value
+  unique_items? ? item_ids.map(&:to_s).join(",") : ""
+end
+
+format :html do
+  view :filtered_list, unknown: true do
+    filtered_list_input
+  end
+
+  view :filter_items_modal, unknown: true, wrap: :modal do
+    render_filter_items
+  end
+
+  view :filter_items, unknown: true, wrap: :slot, template: :haml
+
+  def filtered_item_view
+    implicit_item_view
+  end
+
+  def filtered_item_wrap
+    :filtered_list_item
+  end
+
+  def filtered_list_input
+    with_nest_mode :normal do
+      wrap { haml :filtered_list_input }
+    end
+  end
+
+  def add_item_modal_link text=nil
+    modal_link (text || "Add Item"),
+               size: :xl,
+               class: "btn btn-sm btn-outline-secondary _add-item-link",
+               path: {
+                 view: :filter_items_modal,
+                 slot: filter_items_modal_slot,
+                 filter: filter_items_default_filter,
+                 # each key value below is there to help support new cards configured
+                 # by type_plus_right sets. do not remove without testing that case
+                 # (not currently covered by specs)
+                 type: :list.cardname,
+                 filter_card: filter_card.name,
+                 filter_items: filter_item_config
+               }
+  end
+
+  def filter_items_default_filter
+    { not_ids: card.not_ids_value }
+  end
+
+  def filter_items_data
+    {
+      "slot-selector": "modal-origin",
+      "item-selector": "._filtered-list-item",
+      item: filter_item_config
+    }
+  end
+
+  def filter_item_config
+    %i[view wrap duplicable].each_with_object({}) do |key, hash|
+      hash[key] = params.dig(:filter_items, key) || send("filtered_item_#{key}")
+    end
+  end
+
+  def filtered_item_duplicable
+    !card.unique_items?
+  end
+
+  def filter_items_modal_slot
+    { hide: [:modal_footer] }
+  end
+
+  view :add_selected_link, unknown: true do
+    button_tag "Add Selected", class: "_add-selected btn btn-primary", disabled: true
+  end
+
+  def filtered_list_item item_card
+    nest_item item_card do |rendered, item_view|
+      wrap_item rendered, item_view
+    end
+  end
+
+  # for override
+  # @return [Card] search card on which filtering is based
+  def filter_card
+    filter_card_from_params || default_filter_card
+  end
+
+  def default_filter_card
+    fcard = card.options_card
+    return fcard if fcard.respond_to? :cql_hash
+
+    fcard.fetch :referred_to_by, new: {}
+  end
+
+  def filter_card_from_params
+    return unless params[:filter_card]&.present?
+
+    Card.fetch params[:filter_card], new: {}
+  end
+end

data/set/abstract/list/filter.rb

@@ -0,0 +1 @@
+include_set Abstract::FilteredList

data/set/abstract/search/filter_inclusion.rb

@@ -0,0 +1,7 @@
+# this file is a little strange.
+#
+# It is necessary to have a new file in the search directory rather than adding
+# #include_set directly to search.rb, because this makes it so that
+# extra_paging_path_args overrides the code in search/search_params.
+
+include_set Filter

data/set/all/filtered_list_item.haml

@@ -0,0 +1,8 @@
+._filtered-list-item.row{ data: wrap_data }
+  .col-1._handle
+    = icon_tag :reorder
+  .col-10
+    = interior
+  .col-1.filtered-list-item-button
+    %button._filtered-list-item-delete.btn.btn-secondary.btn-sm.m-2{ type: "button"}
+      = icon_tag :remove

data/set/all/filtered_list_item.rb

@@ -0,0 +1,11 @@
+basket[:list_input_options] << :filtered_list
+
+def supports_content_option_view?
+  super || (item_name == "filtered list")
+end
+
+format :html do
+  wrapper :filtered_list_item, template: :haml do
+    haml :filtered_list_item
+  end
+end

data/set/type/list.rb

@@ -0,0 +1,4 @@
+def input_type_content_options
+  # TODO: need to make super work here somehow or refactor around baskets
+  %w[multiselect checkbox list] << "filtered list"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-filter
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- Philipp Kühl
+- Ethan McCutchen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: card-mod-search
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: card-mod-bootstrap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/card/filter_query.rb
+- set/abstract/0_filter.rb
+- set/abstract/0_filter/filter_fields.rb
+- set/abstract/0_filter/filter_form.rb
+- set/abstract/0_filter/filter_form/_compact_filter_input.haml
+- set/abstract/0_filter/filter_form/compact_filter_form.haml
+- set/abstract/0_filter/filter_form/compact_quick_filters.haml
+- set/abstract/0_filter/filter_form/filter_bars.haml
+- set/abstract/0_filter/filter_form/filter_sort_dropdown.haml
+- set/abstract/0_filter/filter_form/filtered_results_header.haml
+- set/abstract/0_filter/filter_form/offcanvas_filters.haml
+- set/abstract/0_filter/filter_form/open_filter_button.haml
+- set/abstract/0_filter/filter_form/select_item.haml
+- set/abstract/0_filter/filter_form/selectable_filtered_content.haml
+- set/abstract/0_filter/filter_input_fields.rb
+- set/abstract/0_filter/filter_input_fields/check_filter.haml
+- set/abstract/cached_type_options.rb
+- set/abstract/cql_search/filter.rb
+- set/abstract/filter_link.rb
+- set/abstract/filterable_list.rb
+- set/abstract/filtered_list.rb
+- set/abstract/filtered_list/filter_items.haml
+- set/abstract/filtered_list/filtered_list_input.haml
+- set/abstract/list/filter.rb
+- set/abstract/search/filter_inclusion.rb
+- set/all/filtered_list_item.haml
+- set/all/filtered_list_item.rb
+- set/type/list.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: filter
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: filter
+test_files: []