card 1.93.5 → 1.93.6

data/mod/search/set/abstract/02_filter_formgroups.rb

@@ -0,0 +1,134 @@
+include_set Abstract::FilterFormHelper
+
+# FIXME: the vast majority of these need to be moved back to wikirate
+format :html do
+  view :filter_name_formgroup, cache: :never do
+    text_filter :name
+  end
+
+  view :filter_project_formgroup, cache: :never do
+    select_filter_type_based :project
+  end
+
+  view :filter_year_formgroup, cache: :never do
+    select_filter :year, "Year", "most recent"
+  end
+
+  view :filter_wikirate_topic_formgroup, cache: :never do
+    # select_filter_type_based :wikirate_topic
+    autocomplete_filter :wikirate_topic
+  end
+
+  view :filter_metric_formgroup, cache: :never do
+    # select_filter_type_based :metric
+    autocomplete_filter :metric
+  end
+
+  view :filter_wikirate_company_formgroup, cache: :never do
+    # select_filter_type_based :wikirate_company
+    autocomplete_filter :wikirate_company
+  end
+
+  view :filter_research_policy_formgroup, cache: :never do
+    multiselect_filter :research_policy, "Research Policy"
+  end
+
+  def research_policy_select
+    select_filter_type_based :research_policy
+  end
+
+  view :filter_metric_type_formgroup, cache: :never do
+    multiselect_filter :metric_type, "Metric Type"
+  end
+
+  def metric_type_select
+    select_filter :metric_type, "Metric Type"
+  end
+
+  view :filter_metric_value_formgroup, cache: :never do
+    select_filter :metric_value, "Value", "exists"
+  end
+
+  view :filter_designer_formgroup, cache: :never do
+    select_filter :designer, "Designer"
+  end
+
+  view :filter_importance_formgroup, cache: :never do
+    multiselect_filter :importance, "My Vote", %w[upvotes novotes]
+  end
+
+  view :filter_industry_formgroup, cache: :never do
+    select_filter :industry, "Industry"
+  end
+
+  def sort_options
+    {}
+  end
+
+  def default_year_option
+    { "Most Recent" => "latest" }
+  end
+
+  def year_options
+    type_options(:year, "desc").each_with_object(default_year_option) do |v, h|
+      h[v] = v
+    end
+  end
+
+  def metric_value_options
+    opts = {
+      "All" => "all",
+      "Researched" => "exists",
+      "Known" => "known",
+      "Unknown" => "unknown",
+      "Not Researched" => "none",
+      "Edited today" => "today",
+      "Edited this week" => "week",
+      "Edited this month" => "month",
+      "Outliers" => "outliers"
+    }
+    return opts unless filter_param(:range)
+    opts.each_with_object({}) do |(k, v), h|
+      h[add_range(k, v)] = v
+    end
+  end
+
+  def add_range key, _value
+    key # unless selected_value?(value)
+    # range = filter_param :range
+    # "#{range[:from]} <= #{key} < #{range[:to]}"
+  end
+
+  def selected_value? value
+    (filter_param(:metric_value) && value == filter_param(:metric_value)) ||
+      value == "exists"
+  end
+
+  def metric_type_options
+    %i[researched formula wiki_rating].map { |n| Card.quick_fetch(n).name }
+  end
+
+  def research_policy_options
+    type_options :research_policy
+  end
+
+  def importance_options
+    { "I voted FOR" => :upvotes,
+      "I voted AGAINST" => :downvotes,
+      "I did NOT vote" => :novotes }
+  end
+
+  def industry_options
+    card_name = CompanyFilterQuery::INDUSTRY_METRIC_NAME
+    Card[card_name].value_options
+  end
+
+  def designer_options
+    metrics = Card.search type_id: MetricID, return: :name
+    metrics.map do |m|
+      names = m.to_name.parts
+      # score metric?
+      names.length == 3 ? names[2] : names[0]
+    end.uniq!(&:downcase).sort_by!(&:downcase)
+  end
+end

data/mod/search/set/abstract/03_filter.rb

@@ -0,0 +1,117 @@
+include_set Abstract::FilterFormgroups
+include_set Abstract::Utility
+
+def filter_class
+  Card::FilterQuery
+end
+
+def filter_and_sort_wql
+  sort? ? filter_wql.merge(sort_wql) : filter_wql
+end
+
+def filter_wql
+  return {} if filter_hash.empty?
+  filter_wql_from_params
+end
+
+# separate method is needed for tests
+def filter_wql_from_params
+  filter_class.new(filter_keys_with_values, blocked_id_wql).to_wql
+end
+
+def sort_wql
+  return {} if !sort? || sort_param.blank?
+  sort_hash
+end
+
+def sort?
+  true
+end
+
+def current_sort
+  sort_param || default_sort_option
+end
+
+def blocked_id_wql
+  not_ids = filter_param :not_ids
+  not_ids.present? ? { id: ["not in", not_ids.split(",")] } : {}
+end
+
+def advanced_filter_keys
+  []
+end
+
+# all filter keys in the order they were selected
+def all_filter_keys
+  @all_filter_keys ||= filter_keys_from_params | filter_keys | advanced_filter_keys
+end
+
+def filter_keys
+  [:name]
+end
+
+def filter_keys_from_params
+  filter_hash.keys.map(&:to_sym) - [:not_ids]
+end
+
+format :html do
+  delegate :filter_hash, to: :card
+
+  def filter_fields slot_selector: nil, sort_field: nil
+    form_args = { action: filter_action_path, class: "slotter" }
+    form_args["data-slot-selector"] = slot_selector if slot_selector
+    filter_form filter_form_data, sort_field, form_args
+  end
+
+  def filter_form_data
+    all_filter_keys.each_with_object({}) do |cat, h|
+      h[cat] = { label: filter_label(cat),
+                 input_field: _render("filter_#{cat}_formgroup"),
+                 active: show_filter_field?(cat) }
+    end
+  end
+
+  def show_filter_field? field
+    filter_hash.present? ? filter_hash[field] : card.default_filter_option[field]
+  end
+
+  def filter_label field
+    return "Keyword" if field.to_sym == :name
+    Card.fetch_name(field) { field.to_s.capitalize }
+  end
+
+  def filter_action_path
+    path
+  end
+
+  view :filter_form, cache: :never do
+    filter_fields slot_selector: "._filter-result-slot",
+                  sort_field: _render(:sort_formgroup)
+  end
+
+  # @param data [Hash] the filter categories. The hash needs for every category
+  #   a hash with a label and a input_field entry.
+  def filter_form data={}, sort_input_field=nil, form_args={}
+    haml :filter_form, categories: data,
+                       sort_input_field: sort_input_field,
+                       form_args: form_args
+  end
+
+  def sort_options
+    {
+      "Alphabetical": :name,
+      "Recently Updated": :updated_at
+    }
+  end
+
+  view :sort_formgroup, cache: :never do
+    select_tag "sort",
+               options_for_select(sort_options, card.current_sort),
+               class: "pointer-select _filter-sort",
+               "data-minimum-results-for-search": "Infinity"
+  end
+end
+
+def default_sort_option
+  wql_from_content[:sort]
+end

data/mod/search/set/abstract/04_right_filter_form.rb

@@ -0,0 +1,23 @@
+# To be included in a field card to get a filter for the parent.
+# The core view renders a filter for the left card.
+
+include_set Set::Abstract::Filter
+
+def virtual?
+  true
+end
+
+format :html do
+  def filter_action_path
+    path mark: card.name.left, view: filter_view
+  end
+
+  # FIXME: wikirate-specific reference in selector
+  view :core, cache: :never do
+    filter_fields slot_selector: ".RIGHT-all_metric_value.filter_result-view"
+  end
+
+  def filter_view
+    :filter_result
+  end
+end

data/mod/search/set/abstract/search.rb

@@ -1,5 +1,6 @@
 include_set Abstract::SearchParams
 include_set Abstract::Paging
+include_set Abstract::Filter
 
 def search _args={}
   raise Error, "search not overridden"
@@ -106,26 +107,59 @@ format :csv do
 end
 
 format :html do
-  view :card_list do
+  def with_results
     return render_no_search_results if search_with_params.empty?
-    search_result_list do
-      search_with_params.map do |item_card|
-        nest_item item_card, size: voo.size do |rendered, item_view|
-          klass = "search-result-item item-#{item_view}"
-          %(<div class="#{klass}">#{rendered}</div>)
-        end
+    yield
+  end
+
+  view :card_list do
+    with_results do
+      search_result_list "search-result-list" do |item_card|
+        card_list_item item_card
       end
     end
   end
 
-  def search_result_list
+  def card_list_item item_card
+    nest_item item_card, size: voo.size do |rendered, item_view|
+      %(<div class="search-result-item item-#{item_view}">#{rendered}</div>)
+    end
+  end
+
+  def search_result_list klass
     with_paging do
-      wrap_with :div, class: "search-result-list" do
-        yield
+      wrap_with :div, class: klass do
+        search_with_params.map do |item_card|
+          yield item_card
+        end
+      end
+    end
+  end
+
+  view :select_item, cache: :never do
+    wrap do
+      haml :select_item
+    end
+  end
+
+  def default_select_item_args _args
+    class_up "card-slot", "_filter-result-slot"
+  end
+
+  view :checkbox_list, cache: :never do
+    with_results do
+      search_result_list "_search-checkbox-list" do |item_card|
+        checkbox_item item_card
       end
     end
   end
 
+  def checkbox_item item_card
+    subformat(item_card).wrap do
+      haml :checkbox_item, unique_id: unique_id, item_card: item_card
+    end
+  end
+
   def closed_limit
     [search_params[:limit].to_i, Card.config.closed_search_limit].min
   end

data/mod/search/set/abstract/wql_search.rb

@@ -8,34 +8,38 @@ def search args={}
   query.run
 end
 
-# override this to define search
-def wql_hash
-  @wql_hash ||= begin
-    query = content
-    query = query.is_a?(Hash) ? query : parse_json_query(query)
-    query.symbolize_keys
-  end
-end
-
-def query_args args={}
-  wql_hash.merge args
+def fetch_query args={}
+  @query ||= {}
+  @query[args.to_s] ||= query(args.clone) # cache query
 end
 
 def query args={}
   Query.new standardized_query_args(args), name
 end
 
-def fetch_query args={}
-  @query ||= {}
-  @query[args.to_s] ||= query(args.clone) # cache query
-end
-
 def standardized_query_args args
   args = query_args(args).symbolize_keys
   args[:context] ||= name
   args
 end
 
+# override this to define search
+def wql_hash
+  @wql_hash ||= wql_from_content.merge filter_and_sort_wql
+end
+
+def wql_from_content
+  @wql_from_content ||= begin
+    query = content
+    query = query.is_a?(Hash) ? query : parse_json_query(query)
+    query.symbolize_keys
+  end
+end
+
+def query_args args={}
+  wql_hash.merge args
+end
+
 def parse_json_query query
   empty_query_error! if query.empty?
   JSON.parse query
@@ -49,8 +53,8 @@ def empty_query_error!
 end
 
 format do
-  def default_search_params
-    @default_search_params ||= { limit: (card_content_limit || default_limit) }
+  def default_limit
+    card_content_limit || super
   end
 
   def card_content_limit

data/mod/search/spec/set/{all → abstract}/filter_spec.rb

@@ -1,9 +1,10 @@
-describe Card::Set::All::Filter do
+describe Card::Set::Abstract::Filter do
   subject do
-    Card["A"].format.filter_form a: { input_field: "<input id='a'/>", label: "A" },
-                                 b: { input_field: "<select id='b'/>", label: "B" },
-                                 c: { input_field: "<select id='c'/>", label: "C",
-                                      active: true }
+    search_card = Card.new type: "Search"
+    search_card.format.filter_form a: { input_field: "<input id='a'/>", label: "A" },
+                                   b: { input_field: "<select id='b'/>", label: "B" },
+                                   c: { input_field: "<select id='c'/>", label: "C",
+                                        active: true }
   end
 
   specify "#filter_form" do

data/mod/search/template/{all/filter → abstract/03_filter}/filter_form.haml

@@ -8,9 +8,11 @@
             - unless category[:active]
               = haml_partial :filter_input, key: key, category: category
 
-      %form._filter-form{form_args, "accept-charset" => "UTF-8",
-                                  "data-remote" => "true",
-                                  :method => "get"}
+      %form._filter-form{form_args, "accept-charset": "UTF-8",
+                                    "data-remote": "true",
+                                    method: "get"}
+        - not_ids = params.dig :filter, :not_ids
+        %input{ type: :hidden, name: "filter[not_ids]", class: "_not-ids", value: not_ids }
         .d-flex.flex-row
           - if sort_input_field
             %i.material-icons.text-muted.md-24.p-2 sort
@@ -25,10 +27,10 @@
                 = haml_partial :filter_input, key: key, category: category
 
             .dropdown._add-filter-dropdown
-              %button.btn.btn-secondary.dropdown-toggle{"aria-expanded" => "false",
-                                                      "aria-haspopup" => "true",
-                                                      "data-toggle" => "dropdown",
-                                                      :type => "button"}
+              %button.btn.btn-secondary.dropdown-toggle{"aria-expanded": "false",
+                                                        "aria-haspopup": "true",
+                                                        "data-toggle": "dropdown",
+                                                        type: "button" }
                 Add filter
               .dropdown-menu
                 - categories.each do |key, category|