querylane 0.1.0 → 0.2.0

data/lib/querylane/rewriter.rb

@@ -50,6 +50,40 @@ module Querylane
       text.strip
     end
 
+    # The query with one filter chip's term replaced by its typed value as
+    # plain words ("smith last:smiht" → "smith smiht"), for a chip that offers
+    # it (Chip#as_words); otherwise the query unchanged.
+    #
+    # @param query [Querylane::Query] valid
+    # @param chip [Querylane::Chips::Chip, nil]
+    # @return [String]
+    def as_words(query, chip)
+      return query.source unless chip&.as_words
+
+      words_in_place(query, chip.ranges.first, chip.as_words)
+    end
+
+    # The query text with `range` replaced by `typed` as plain words.
+    #
+    # @return [String]
+    def words_in_place(query, range, typed)
+      words = typed.split.map { |word| bare_word(query.definition, word) }.join(" ")
+      # Keep the words apart from a neighbour typed without a space (`last:"x"is:active`).
+      before = (range.begin.positive? && !query.source[range.begin - 1].match?(/\s/)) ? " " : ""
+      after = (range.end < query.source.length && !query.source[range.end].match?(/\s/)) ? " " : ""
+      replace(query.source, range, "#{before}#{words}#{after}")
+    end
+
+    # A word that reads back as a plain word: anything the parser would take
+    # as syntax (an operator key, a leading "-", OR, NOT, brackets, quotes) or
+    # the interpreter would read as an operator ("1234" as a last four) is
+    # quoted, since quoted words are never interpreted.
+    def bare_word(definition, word)
+      plain = word.match?(/\A[^\s()"-][^\s()"]*\z/) && !word.match?(/\A#{Parser::KEY}/o) && !%w[OR NOT].include?(word) &&
+        definition.interpret(word).nil?
+      plain ? word : quoted(word)
+    end
+
     # The options panel's view of a query: each field's value (keyed by the
     # compose field name), the parts no field can show (kept as typed), and,
     # per masked field, the masked terms it leaves in the box (masked values
@@ -139,7 +173,7 @@ module Querylane
         written = found.map { |token| token.quoted ? quoted(token.text) : quote(token.text) }
         operator.default ? written.join(" ") : written.map { |text| "#{operator.key}:#{text}" }.join(" ")
       else
-        found = found.map { |token| operator.normalize ? token.with(text: operator.normalize.call(token.text)) : token }
+        found = found.map { |token| (operator.normalize && !typed?(operator)) ? token.with(text: operator.normalize.call(token.text)) : token }
         join_or(found.uniq.map { |token| "#{operator.key}:#{token.quoted ? quoted(token.text) : quote(token.text)}" })
       end
     end
@@ -169,7 +203,15 @@ module Querylane
       end
     end
 
-    def display(term) = term.quoted ? quoted(term.value.to_s) : term.value.to_s
+    # A field's text for a term: quoted as typed; a `display_value: :typed` filter
+    # shows the value as typed, others (and interpreted terms, whose typed
+    # token would read differently once prefixed) the normalized value.
+    def display(term)
+      value = (typed?(term.operator) && !term.interpreted) ? term.raw.to_s : term.value.to_s
+      term.quoted ? quoted(value) : value
+    end
+
+    def typed?(operator) = operator.is_a?(Definition::FilterOperator) && operator.display_value == :typed
 
     # Always quoted, with " and \ escaped.
     def quoted(value) = %("#{value.to_s.gsub(/["\\]/) { |char| "\\#{char}" }}")

data/lib/querylane/search.rb

@@ -211,6 +211,8 @@ module Querylane
           chip = Chips.for(query).find { |candidate| candidate.index == chip_index }
           alternative = chip&.alternatives&.find { |candidate| candidate.index == alternative_index }
           alternative ? Rewriter.replace(query.source, chip.ranges.first, alternative.text) : query.source
+        elsif @request.as_words
+          Rewriter.as_words(query, Chips.for(query).find { |candidate| candidate.index == @request.as_words })
         else
           chip = Chips.for(query).find { |candidate| candidate.index == @request.remove }
           chip ? Rewriter.remove(query.source, chip.ranges) : query.source

data/lib/querylane/searchers/meilisearch.rb

@@ -67,10 +67,27 @@ module Querylane
 
       def client = @client.respond_to?(:call) ? @client.call : @client
 
+      # Turns a backend failure into SearchUnavailable and logs why. An API
+      # error is logged by code, type and status only: its message can echo
+      # the filter, and filters carry what the user searched for.
       def call
         yield
-      rescue ::Meilisearch::ApiError, ::Meilisearch::CommunicationError, ::Meilisearch::TimeoutError => error
-        raise SearchUnavailable, "Meilisearch #{error.class.name.demodulize}"
+      rescue ::Meilisearch::ApiError => error
+        unavailable(error, "code=#{error.code} type=#{error.type} http=#{error.http_code}", error.code)
+      rescue ::Meilisearch::CommunicationError, ::Meilisearch::TimeoutError => error
+        unavailable(error, without_url_secrets(error.message))
+      end
+
+      # A connection error can quote the client URL; keep its host and port,
+      # drop any user:password@ and query string.
+      def without_url_secrets(message)
+        message.gsub(%r{(\w+://)[^\s/@]+@}, '\1').gsub(/\?[^\s)]*/, "")
+      end
+
+      def unavailable(error, detail, code = nil)
+        name = "Meilisearch #{error.class.name.demodulize}"
+        Querylane.configuration.logger.warn("[querylane] search unavailable: #{name} #{detail}")
+        raise SearchUnavailable, [name, code].compact.join(" ")
       end
 
       # Indexes whose scope and query can match something; the others are

data/lib/querylane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Querylane
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/querylane.rb

@@ -14,6 +14,7 @@ require "strscan"
 
 require "querylane/version"
 require "querylane/errors"
+require "querylane/copy"
 require "querylane/configuration"
 require "querylane/filter"
 require "querylane/scope"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: querylane
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ajaya Agrawalla
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -79,6 +79,7 @@ files:
 - lib/querylane/configuration.rb
 - lib/querylane/context.rb
 - lib/querylane/controller.rb
+- lib/querylane/copy.rb
 - lib/querylane/definition.rb
 - lib/querylane/doctor.rb
 - lib/querylane/engine.rb