Pattern search forms

app/assets/stylesheets/mo/_form_elements.scss

@@ -180,3 +180,9 @@ form {
   max-height: 30rem;
   overflow-y: auto;
 }
+
+.panel-body {
+  .form-group:last-child {
+    margin-bottom: 0;
+  }
+}

app/assets/stylesheets/mo/_utilities.scss

@@ -122,6 +122,10 @@
   object-fit: contain;
 }
 
+.flex-grow-1 {
+  flex-grow: 1 !important;
+}
+
 .text-larger {
   font-size: larger !important;
 }

app/classes/pattern_search/base.rb

@@ -3,17 +3,19 @@
 module PatternSearch
   # Base class for PatternSearch; handles everything but build_query
   class Base
-    attr_accessor :errors, :parser, :flavor, :args, :query
+    attr_accessor :errors, :parser, :flavor, :args, :query, :form_params
 
     def initialize(string)
       self.errors = []
       self.parser = PatternSearch::Parser.new(string)
+      self.form_params = make_terms_available_to_faceted_form
       build_query
       self.query = Query.lookup(model.name.to_sym, flavor, args)
     rescue Error => e
       errors << e
     end
 
+    # rubocop:disable Metrics/AbcSize
     def build_query
       self.flavor = :all
       self.args   = {}
@@ -33,6 +35,7 @@ def build_query
         end
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def help_message
       "#{:pattern_search_terms_help.l}\n#{self.class.terms_help}"
@@ -54,5 +57,83 @@ def lookup_param(var)
       end
       nil
     end
+
+    # Build a hash so we can populate the form fields with from the values from
+    # the saved search string. Turn ranges into ranges, and dates into dates.
+    # NOTE: The terms may be translated! We have to look up the param names that
+    # the translations map to.
+    # rubocop:disable Metrics/AbcSize
+    def make_terms_available_to_faceted_form
+      parser.terms.each_with_object({}) do |term, hash|
+        # term is what the user typed in, not the parsed value.
+        param = lookup_param_name(term.var)
+        if fields_with_dates.include?(param)
+          start, range = check_for_date_range(term)
+          hash[param] = start
+          hash[:"#{param}_range"] = range if range
+        elsif fields_with_numeric_range.include?(param)
+          start, range = check_for_numeric_range(term)
+          hash[param] = start
+          hash[:"#{param}_range"] = range if range
+        else
+          hash[param] = term.vals.join(", ")
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def lookup_param_name(var)
+      # See if this var matches an English parameter name first.
+      return var if params[var].present?
+
+      # Then check if any of the translated parameter names match.
+      params.each_key do |key|
+        return key if var.to_s == :"search_term_#{key}".l.tr(" ", "_")
+      end
+      nil
+    end
+
+    # The string could be a date string like "2010-01-01", or a range string
+    # like "2010-01-01-2010-01-31", or "2023-2024", or "08-10".
+    # If it is a range, return the two dates.
+    # Try for fidelity to the stored string, eg only years.
+    def check_for_date_range(term)
+      bits = term.vals[0].split("-")
+      case bits.size
+      when 1
+        start = bits[0]
+        range = nil
+      when 2
+        start, range = bits
+      when 4
+        start = "#{bits[0]}-#{bits[1]}"
+        range = "#{bits[2]}-#{bits[3]}"
+      else
+        start, range = term.parse_date_range
+      end
+
+      range = nil if start == range
+
+      [start, range]
+    end
+
+    def check_for_numeric_range(term)
+      bits = term.vals[0].split("-")
+
+      if bits.size == 2
+        bits.map(&:to_i)
+      else
+        [term.vals[0], nil]
+      end
+    end
+
+    # These are set in the subclasses, but seem stable enough to be here.
+    def fields_with_dates
+      [:when, :created, :modified].freeze
+    end
+
+    def fields_with_numeric_range
+      [:confidence].freeze
+    end
   end
 end

app/classes/pattern_search/name.rb

@@ -34,6 +34,31 @@ def self.params
       PARAMS
     end
 
+    # List of fields that are displayed in the search form.
+    # Autocompleters have id fields, and range fields are concatenated.
+    def self.fields
+      params.keys + [
+        :created_range, :modified_range, :rank_range, :pattern
+      ]
+    end
+
+    def self.fields_with_dates
+      [:created, :modified]
+    end
+
+    def self.fields_with_range
+      [:created, :modified, :rank]
+    end
+
+    def self.fields_with_ids
+      []
+    end
+
+    # hash of required: fields
+    def self.fields_with_requirements
+      {}
+    end
+
     def params
       self.class.params
     end

app/classes/pattern_search/observation.rb

@@ -9,7 +9,7 @@ class Observation < Base
       created: [:created_at, :parse_date_range],
       modified: [:updated_at, :parse_date_range],
 
-      # names
+      # names. note that the last four require the first one to be present
       name: [:names, :parse_list_of_names],
       exclude_consensus: [:exclude_consensus, :parse_boolean], # of_look_alikes
       include_subtaxa: [:include_subtaxa, :parse_boolean],
@@ -53,6 +53,34 @@ def self.params
       PARAMS
     end
 
+    # List of fields that are displayed in the search form.
+    # Autocompleters have id fields, and range fields are concatenated.
+    def self.fields
+      params.keys + [
+        :name_id, :location_id, :user_id, :herbarium_id, :list_id, :project_id,
+        :project_lists_id, :when_range, :created_range, :modified_range,
+        :rank_range, :confidence_range, :pattern
+      ]
+    end
+
+    def self.fields_with_dates
+      [:when, :created, :modified]
+    end
+
+    def self.fields_with_range
+      [:when, :created, :modified, :rank, :confidence]
+    end
+
+    def self.fields_with_ids
+      [:name, :location, :user, :herbarium, :list, :project, :species_list]
+    end
+
+    # hash of required: fields
+    def self.fields_with_requirements
+      { name: [:exclude_consensus, :include_subtaxa, :include_synonyms,
+               :include_all_name_proposals] }
+    end
+
     def params
       self.class.params
     end

app/classes/pattern_search/parser.rb

@@ -12,7 +12,7 @@ class Parser
     /x
 
     def initialize(string)
-      self.incoming_string = string
+      self.incoming_string = string || ""
       self.terms = parse_incoming_string
     end
 

app/controllers/concerns/filterable.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+#
+#  = Filterable Concern
+#
+#  This is a module of reusable methods included by controllers that handle
+#  "faceted" pattern searches per model, with separate inputs for each keyword.
+#
+#  We're translating the params hash into the format that the user would have
+#  typed into the search box if they knew how to do that, because that's what
+#  the PatternSearch class expects to parse. The PatternSearch class then
+#  unpacks, validates and re-translates all these params into the actual params
+#  used by the Query class. This may seem roundabout: of course we do know the
+#  Query param names in advance, so we could theoretically just pass the values
+#  directly into Query and render the index. But we'd still have to be able to
+#  validate the input, and give messages for all the possible errors there.
+#  PatternSearch class handles all that.
+#
+################################################################################
+
+module Filterable
+  extend ActiveSupport::Concern
+
+  # Rubocop is incorrect here. This is a concern, not a class.
+  # rubocop:disable Metrics/BlockLength
+  included do
+    def search_subclass
+      PatternSearch.const_get(@filter.class.search_type.capitalize)
+    end
+
+    def formatted_pattern_search_string
+      sift_and_restructure_form_params
+      keyword_strings = @sendable_params.map do |key, value|
+        "#{key}:#{value}"
+      end
+      keyword_strings.join(" ")
+    end
+
+    # One oddball is `confidence` - the string "0" should not count as a value.
+    def sift_and_restructure_form_params
+      @keywords = @filter.attributes.to_h.compact_blank.symbolize_keys
+
+      remove_invalid_field_combinations
+      concatenate_range_fields
+
+      @sendable_params = remove_ids_and_format_strings(@keywords)
+      # @storable_params = configure_storable_params(@keywords)
+    end
+
+    # Passing some fields will raise an error if the required field is missing,
+    # so just toss them.
+    def remove_invalid_field_combinations
+      return unless search_subclass.respond_to?(:fields_with_requirements)
+
+      search_subclass.fields_with_requirements.each do |req, fields|
+        next if @keywords[req].present?
+
+        fields.each { |field| @keywords.delete(field) }
+      end
+    end
+
+    # Check for `fields_with_range`, and concatenate them if range val present,
+    # removing the `_range` field.
+    def concatenate_range_fields
+      return unless search_subclass.respond_to?(:fields_with_range)
+
+      search_subclass.fields_with_range.each do |key|
+        next if @keywords[:"#{key}_range"].blank?
+
+        @keywords[key] = [@keywords[key].to_s.strip,
+                          @keywords[:"#{key}_range"].to_s.strip].join("-")
+        @keywords.delete(:"#{key}_range")
+      end
+    end
+
+    # SENDABLE_PARAMS - params with ids can be sent to index and query.
+    #
+    # This method deletes the strings typed in the form and sends ids, saving a
+    # lookup at the receiver. However, we still want a legible string saved in
+    # the session, so we can repopulate the form with legible values - plus
+    # maybe in the url. Could send the id versions as separate `filter` param?
+    #
+    # Need to modify autocompleters to check for record id on load if prefilled.
+    def substitute_strings_with_ids(keywords)
+      search_subclass.fields_with_ids.each do |key|
+        next if keywords[:"#{key}_id"].blank?
+
+        keywords[key] = keywords[:"#{key}_id"]
+        keywords.delete(:"#{key}_id")
+      end
+      keywords
+    end
+
+    # STORABLE_PARAMS - params for the pattern string in session.
+    # These methods don't modify the original @keywords.
+    #
+    # Ideally we'd store full strings for all values, including names and
+    # locations, so we can repopulate the form with the same values.
+    def remove_ids_and_format_strings(keywords)
+      escape_strings_and_remove_ids(keywords)
+      escape_locations_and_remove_ids(keywords)
+    end
+
+    # Escape-quote the strings, the way the short form requires.
+    # rubocop:disable Metrics/AbcSize
+    def escape_strings_and_remove_ids(keywords)
+      search_subclass.fields_with_ids.each do |key|
+        # location, region handled separately
+        next if keywords[key].blank? || strings_with_commas.include?(key.to_sym)
+
+        list = keywords[key].split(",").map(&:strip)
+        list = list.map { |name| "\"#{name}\"" }
+        keywords[key] = list.join(",")
+        next if keywords[:"#{key}_id"].blank?
+
+        keywords.delete(:"#{key}_id")
+      end
+      keywords
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Escape-quote the locations and their commas. We'd prefer to have legible
+    # strings in the url, but the comma handling is difficult.
+    def escape_locations_and_remove_ids(keywords)
+      if keywords[:location].present?
+        list = keywords[:location].split("\n").map(&:strip)
+        list = list.map { |location| escape_location_string(location) }
+        keywords[:location] = list.join(",")
+      end
+      keywords.delete(:location_id) if keywords[:location_id].present?
+      escape_region_string(keywords)
+    end
+
+    def escape_region_string(keywords)
+      return keywords if keywords[:region].blank?
+
+      keywords[:region] = escape_location_string(keywords[:region].strip)
+      keywords
+    end
+
+    def escape_location_string(location)
+      "\"#{location.tr(",", "\\,")}\""
+    end
+
+    def strings_with_commas
+      [:location, :region].freeze
+    end
+  end
+  # rubocop:enable Metrics/BlockLength
+end