forest_liana 9.22.11 → 9.22.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 345a74b2a7088f0c84717c3023f50fef3c0918db97d392e936047abfb57a3b48
-  data.tar.gz: 9abe4f90a54bddf3df9cf4cd73db258ef60962ec9bf5353904dd916676b15aac
+  metadata.gz: fcbf97d59c4b454c53e5f068f969e8e503e2a722c1a011e2d03b7f9e73a0c152
+  data.tar.gz: cd6608d3c224d6daaedd240928a34cec77d49c35bfdf52fdb0d5b5187a23cf02
 SHA512:
-  metadata.gz: 1f096e618b492ecea05c88063f3deb647a8928deaf524c95b35572061db3c7094c34484c492134dfdcf18d52f0897d7fa9d9f1a645ff419cfbb18489681532c0
-  data.tar.gz: 2d818ad0f0e90d95f5574643a2b50d94615ec0f5601b9e10d8477f250ddd6e0ab9c34f6a23d0d9e470f69dbb76861fddf99b26a45b20449262a0251b08eaada6
+  metadata.gz: 78dd9047c6f8647076342d0a99f223ad66c7c33590b6b8be4726901d4aa6b057eb97eb4137cd6de3852fcf06d505621b77e6d6b653bb699443e753b57955a782
+  data.tar.gz: c0dc2372c158fb2f86929279b3594ae6aec5b2270ae6fd74a19871c7dc26af89b0b20d8d5f8a822ddd6147ab11d89413f80df582168ea31e41e7fac847c2e430

data/app/controllers/forest_liana/actions_controller.rb

@@ -47,6 +47,12 @@ module ForestLiana
       {:field_changed => found_field_changed, :fields => fields, :params => params, :user => forest_user}
     end
 
+    def ensure_single_record_selection(action, attributes)
+      return if SingleRecordSelection.allowed?(action, attributes)
+
+      raise ForestLiana::Errors::HTTP422Error.new(SingleRecordSelection::MESSAGE)
+    end
+
     def handle_result(result, action)
       if result.nil? || !result.is_a?(Array)
         return render status: 500, json: { error: 'Error in smart action load hook: hook must return an array of fields' }
@@ -104,6 +110,8 @@ module ForestLiana
       if !action
         render status: 500, json: {error: 'Error in smart action load hook: cannot retrieve action from collection'}
       else
+        ensure_single_record_selection(action, load_request)
+
         # Get the smart action hook load context
         context = get_smart_action_load_ctx(action.fields)
 
@@ -132,6 +140,8 @@ module ForestLiana
         return render status: 500, json: {error: 'Error in smart action change hook: fields params must be an array'}
       end
 
+      ensure_single_record_selection(action, change_request)
+
       # Get the smart action hook change context
       context = get_smart_action_change_ctx(change_request[:fields], change_request[:changed_field])
 

data/app/controllers/forest_liana/application_controller.rb

@@ -27,6 +27,8 @@ module ForestLiana
       Object.const_get('PaperTrail::Version').is_a?(Class) rescue false
     end
 
+    around_action :with_request_cache
+
     # NOTICE: Calling the method set_paper_trail_whodunnit loads the PaperTrail
     #         gem and Forest detects the PaperTrail::Version automatically. This
     #         method is used to set the whodunnit field automatically to track
@@ -131,6 +133,10 @@ module ForestLiana
 
     private
 
+    def with_request_cache(&block)
+      ForestLiana::RequestCache.with(&block)
+    end
+
     # NOTICE: What survives becomes(), which allocates a fresh instance and copies @attributes
     #         onto it and nothing else. Shared by both controllers' get_record, unlike the rest of
     #         their rendering, because getting it wrong is a correctness bug rather than a
@@ -256,11 +262,16 @@ module ForestLiana
           params_fields_hash = params_fields.to_hash
         end
 
+        forest_collection = nil
+        smart_relations = nil
         params_fields_hash.inject({}) do |fields, param_field|
           relation_name = param_field[0]
           relation_fields = param_field[1]
-          forest_collection = ForestLiana.apimap.find { |collection| collection.name.to_s == model.to_s.gsub('::', '__') }
-          smart_relations = forest_collection.fields_smart_belongs_to
+          forest_collection ||= begin
+            collection_name = model.to_s.gsub('::', '__')
+            ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
+          end
+          smart_relations ||= forest_collection.fields_smart_belongs_to
 
           if relation_name == ForestLiana.name_for(model)
             fields[relation_name] = relation_fields

data/app/helpers/forest_liana/decoration_helper.rb

@@ -2,7 +2,7 @@ module ForestLiana
   module DecorationHelper
     def self.detect_match_and_decorate record, index, field_name, value, search_value, match_fields
       begin
-        match = value.match(/#{search_value}/i)
+        match = value.match(search_value.is_a?(Regexp) ? search_value : compile_search_pattern(search_value))
         if match
           match_fields[index] = { id: record['id'], search: [] } if match_fields[index].nil?
           match_fields[index][:search] << field_name
@@ -12,6 +12,7 @@ module ForestLiana
     end
 
     def self.decorate_for_search(records_serialized, field_names, search_value)
+      search_pattern = compile_search_pattern(search_value)
       match_fields = {}
       records_serialized['data'].each_with_index do |record, index|
         unless record['attributes']
@@ -21,14 +22,19 @@ module ForestLiana
         field_names.each do |field_name|
           value = record['attributes'][field_name]
           if value
-            detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
+            detect_match_and_decorate(record, index, field_name, value, search_pattern, match_fields)
           end
         end
 
-        detect_match_and_decorate(record, index, 'id', record['id'], search_value, match_fields)
+        detect_match_and_decorate(record, index, 'id', record['id'], search_pattern, match_fields)
       end
       match_fields.empty? ? nil : match_fields
     end
 
+    # Literal, like the LIKE that found the records: a regex metacharacter in the search must not
+    # highlight what the query never matched, nor raise and highlight nothing.
+    def self.compile_search_pattern(search_value)
+      Regexp.new(Regexp.escape(search_value.to_s), Regexp::IGNORECASE)
+    end
   end
 end

data/app/helpers/forest_liana/query_helper.rb

@@ -1,16 +1,19 @@
 module ForestLiana
   module QueryHelper
     def self.get_one_associations(resource)
-      associations = SchemaUtils.one_associations(resource)
-        .select do |association|
-          if SchemaUtils.polymorphic?(association)
-            SchemaUtils.polymorphic_models(association).all? { |model| SchemaUtils.model_included?(model) }
-          else
-            SchemaUtils.model_included?(association.klass)
-          end
-        end
+      model = resource.is_a?(ActiveRecord::Relation) ? resource.klass : resource
+
+      LookupCache.fetch(:one_associations, model) { scan_one_associations(model).freeze }
+    end
 
-      associations
+    def self.scan_one_associations(resource)
+      SchemaUtils.one_associations(resource).select do |association|
+        if SchemaUtils.polymorphic?(association)
+          SchemaUtils.polymorphic_models(association).all? { |model| SchemaUtils.model_included?(model) }
+        else
+          SchemaUtils.model_included?(association.klass)
+        end
+      end
     end
 
     def self.get_one_association_names_symbol(resource)

data/app/serializers/forest_liana/serializer_factory.rb

@@ -2,6 +2,8 @@ require 'jsonapi-serializers'
 
 module ForestLiana
   class SerializerFactory
+    # Keyed by the fields array itself, which serialize builds anew on each call.
+    FIELD_SETS = ObjectSpace::WeakMap.new
 
     def self.define_serializer(active_record_class, serializer)
       serializer_name = self.build_serializer_name(active_record_class)
@@ -212,7 +214,7 @@ module ForestLiana
           return {} if self.class.to_one_associations.nil?
           data = {}
           self.class.to_one_associations.each do |attribute_name, attr_data|
-            relation = object.class.reflect_on_all_associations.find { |a| a.name == attribute_name }
+            relation = object.class.reflect_on_association(attribute_name)
             next if !should_include_attr?(attribute_name, attr_data)
 
             if relation && relation.belongs_to? && relation.polymorphic?.nil?
@@ -252,7 +254,7 @@ module ForestLiana
           collection = self.type
 
           unless @options.dig(:context, :unoptimized)
-            return false unless @options[:fields][collection]&.include?(attribute_name.to_sym)
+            return false unless field_set(collection)&.include?(attribute_name.to_sym)
           end
 
           # Allow "if: :show_title?" and "unless: :hide_title?" attribute options.
@@ -262,12 +264,19 @@ module ForestLiana
           show_attr = true
           show_attr &&= send(if_method_name) if if_method_name
           show_attr &&= !send(unless_method_name) if unless_method_name
-          show_attr &&= @_fields[type.to_s].include?(formatted_attribute_name) if @_fields[type.to_s]
+          show_attr &&= field_set(type.to_s).include?(formatted_attribute_name) if @_fields[type.to_s]
           show_attr
         end
 
         private
 
+        def field_set(collection)
+          fields = @_fields[collection]
+          return nil if fields.nil?
+
+          FIELD_SETS[fields] ||= Set.new(fields)
+        end
+
         def intercom_integration?
           ForestLiana.integrations
             .try(:[], :intercom)

data/app/services/forest_liana/ability/permission.rb

@@ -35,6 +35,7 @@ module ForestLiana
       end
 
       def is_smart_action_authorized?(user, collection, parameters, endpoint, http_method)
+        ensure_single_record_selection(collection, parameters, endpoint, http_method)
         return true unless has_permission_system?
 
         user_data = get_user_data(user['id'])
@@ -54,8 +55,8 @@ module ForestLiana
 
       # +refetch+ drops the cached permissions first. Only a caller about to refuse on a denial asks
       # for it (a stale, up to TTL-old cache may sit behind a permission granted moments ago): the
-      # refetch deletes the cluster-wide `forest.collections` entry, so a field that is merely
-      # redacted is answered from the cache.
+      # refetch rewrites the cluster-wide `forest.collections` entry and this request's copy, so a
+      # field that is merely redacted is answered from the cache.
       def read_permissions(user, collection_names, refetch: false)
         @read_permissions_cache ||= {}
         to_fetch = refetch ? collection_names.uniq : collection_names.uniq - @read_permissions_cache.keys
@@ -251,17 +252,20 @@ module ForestLiana
       end
 
       def get_user_data(user_id, force_fetch = true)
-        cache = Rails.cache.fetch('forest.users', expires_in: TTL) do
-          users = {}
-          get_permissions('/liana/v4/permissions/users').each do |user|
-            users[user['id'].to_s] = user
-          end
+        cache = RequestCache.fetch('forest.users') do
+          Rails.cache.fetch('forest.users', expires_in: TTL) do
+            users = {}
+            get_permissions('/liana/v4/permissions/users').each do |user|
+              users[user['id'].to_s] = user
+            end
 
-          users
+            users
+          end
         end
 
         if !cache.key?(user_id.to_s) && force_fetch
           Rails.cache.delete('forest.users')
+          RequestCache.delete('forest.users')
           get_user_data(user_id, false)
         else
           cache[user_id.to_s]
@@ -273,9 +277,15 @@ module ForestLiana
       # followed failed, so during a Forest API incident every pod re-hit the dead API on every
       # request instead of riding on the last good payload until the TTL ran out.
       def get_collections_permissions_data(force_fetch = false)
-        Rails.cache.write('forest.collections', fetch_collections_permissions, expires_in: TTL) if force_fetch == true
+        if force_fetch == true
+          collections = fetch_collections_permissions
+          Rails.cache.write('forest.collections', collections, expires_in: TTL)
+          return RequestCache.write('forest.collections', collections)
+        end
 
-        Rails.cache.fetch('forest.collections', expires_in: TTL) { fetch_collections_permissions }
+        RequestCache.fetch('forest.collections') do
+          Rails.cache.fetch('forest.collections', expires_in: TTL) { fetch_collections_permissions }
+        end
       end
 
       def fetch_collections_permissions
@@ -285,9 +295,15 @@ module ForestLiana
       end
 
       def get_chart_data(rendering_id, force_fetch = false)
-        Rails.cache.write('forest.stats', fetch_chart_data(rendering_id), expires_in: TTL) if force_fetch == true
+        if force_fetch == true
+          stats = fetch_chart_data(rendering_id)
+          Rails.cache.write('forest.stats', stats, expires_in: TTL)
+          return RequestCache.write('forest.stats', stats)
+        end
 
-        Rails.cache.fetch('forest.stats', expires_in: TTL) { fetch_chart_data(rendering_id) }
+        RequestCache.fetch('forest.stats') do
+          Rails.cache.fetch('forest.stats', expires_in: TTL) { fetch_chart_data(rendering_id) }
+        end
       end
 
       def fetch_chart_data(rendering_id)
@@ -297,8 +313,10 @@ module ForestLiana
       end
 
       def has_permission_system?
-        Rails.cache.fetch('forest.has_permission') do
-          (get_permissions('/liana/v4/permissions/environment') == true) ? false : true
+        RequestCache.fetch('forest.has_permission') do
+          Rails.cache.fetch('forest.has_permission') do
+            (get_permissions('/liana/v4/permissions/environment') == true) ? false : true
+          end
         end
       end
 
@@ -331,6 +349,24 @@ module ForestLiana
         actions
       end
 
+      def ensure_single_record_selection(collection, parameters, endpoint, http_method)
+        schema_action = find_action_from_endpoint(ForestLiana.name_for(collection), endpoint, http_method)
+        return unless schema_action&.type == 'single'
+
+        selections = [parameters[:data][:attributes], signed_approval_attributes(parameters)].compact
+        return if selections.all? { |attributes| SingleRecordSelection.allowed?(schema_action, attributes) }
+
+        raise ForestLiana::Errors::HTTP422Error.new(SingleRecordSelection::MESSAGE)
+      end
+
+      def signed_approval_attributes(parameters)
+        return unless parameters[:data][:attributes][:signed_approval_request]
+
+        RequestPermission.decodeSignedApprovalRequest(parameters)[:data][:attributes]
+      rescue JWT::DecodeError
+        nil
+      end
+
       def find_action_from_endpoint(collection_name, endpoint, http_method)
         collection = ForestLiana.apimap.find { |collection| collection.name.to_s == collection_name }
 

data/app/services/forest_liana/base_getter.rb

@@ -777,8 +777,7 @@ module ForestLiana
       # Handle composite primary keys - name might be an Array
       name_sym = name.is_a?(Array) ? name : name.to_sym
       ForestLiana::QueryHelper.get_one_associations(projected_resource)
-                              .select { |association| association.name == name_sym }
-                              .first
+                              .find { |association| association.name == name_sym }
     end
 
     def is_active_storage_association?(association)

data/app/services/forest_liana/request_cache.rb

@@ -0,0 +1,28 @@
+module ForestLiana
+  # Keeps what a Forest request reads from Rails.cache for the rest of that request: each read
+  # there deserializes the whole payload again. Off outside +with+, where every call goes straight
+  # to Rails.cache as before.
+  class RequestCache < ActiveSupport::CurrentAttributes
+    attribute :store
+
+    def self.with(&block)
+      set(store: {}, &block)
+    end
+
+    def self.fetch(key)
+      return yield if store.nil?
+      return store[key] if store.key?(key)
+
+      store[key] = yield
+    end
+
+    def self.write(key, value)
+      store[key] = value unless store.nil?
+      value
+    end
+
+    def self.delete(key)
+      store&.delete(key)
+    end
+  end
+end

data/app/services/forest_liana/resources_getter.rb

@@ -235,7 +235,7 @@ module ForestLiana
 
       begin
         segment_query = @params[:segmentQuery].gsub(/\;\s*$/, '')
-        ScopeManager.inject_context_variables_on_query(segment_query, @user)
+        segment_query = ScopeManager.inject_context_variables_on_query(segment_query, @user)
 
         @records = @records.where(
           "#{@resource.table_name}.#{@resource.primary_key} IN (SELECT id FROM (#{segment_query}) as ids)"

data/app/services/forest_liana/schema_utils.rb

@@ -2,6 +2,12 @@ module ForestLiana
   class SchemaUtils
 
     def self.associations(active_record_class)
+      model = active_record_class.is_a?(ActiveRecord::Relation) ? active_record_class.klass : active_record_class
+
+      LookupCache.fetch(:associations, model) { scan_associations(model).freeze }
+    end
+
+    def self.scan_associations(active_record_class)
       active_record_class.reflect_on_all_associations.select do |association|
         begin
           polymorphic?(association) ? true : !is_active_type?(association.klass)
@@ -89,14 +95,14 @@ module ForestLiana
     end
 
     def self.polymorphic_models(relation)
-      models = []
-      ForestLiana.models.each do |model|
-        unless model.reflect_on_all_associations.select { |association| association.options[:as] == relation.name.to_sym }.empty?
-          models << model
-        end
-      end
+      name = relation.name.to_sym
+      LookupCache.fetch(:polymorphic_models, name) { scan_polymorphic_models(name).freeze }
+    end
 
-      models
+    def self.scan_polymorphic_models(name)
+      ForestLiana.models.select do |model|
+        model.reflect_on_all_associations.any? { |association| association.options[:as] == name }
+      end
     end
 
 

data/app/services/forest_liana/scope_manager.rb

@@ -64,18 +64,21 @@ module ForestLiana
 
     def self.invalidate_scope_cache(rendering_id)
       Rails.cache.delete('forest.scopes.' + rendering_id.to_s)
+      RequestCache.delete("forest.scopes.#{rendering_id}")
     end
 
     def self.fetch_scopes(rendering_id)
-      Rails.cache.fetch("forest.scopes.#{rendering_id}", expires_in: @@scope_cache_expiration_delta) do
-        response = ForestLiana::ForestApiRequester.get("/liana/v4/permissions/renderings/#{rendering_id}")
-        raise 'Unable to fetch scopes' unless response.is_a?(Net::HTTPOK)
-        parsed_response = JSON.parse(response.body)
-
-        {
-          'scopes' => decode_scope(parsed_response['collections']),
-          'team' => parsed_response['team']
-        }
+      RequestCache.fetch("forest.scopes.#{rendering_id}") do
+        Rails.cache.fetch("forest.scopes.#{rendering_id}", expires_in: @@scope_cache_expiration_delta) do
+          response = ForestLiana::ForestApiRequester.get("/liana/v4/permissions/renderings/#{rendering_id}")
+          raise 'Unable to fetch scopes' unless response.is_a?(Net::HTTPOK)
+          parsed_response = JSON.parse(response.body)
+
+          {
+            'scopes' => decode_scope(parsed_response['collections']),
+            'team' => parsed_response['team']
+          }
+        end
       end
     end
 

data/app/services/forest_liana/search_query_builder.rb

@@ -20,8 +20,7 @@ module ForestLiana
 
     def perform(resource)
       @resource = @records = resource
-      @tables_associated_to_relations_name =
-        ForestLiana::QueryHelper.get_tables_associated_to_relations_name(@resource)
+      @tables_associated_to_relations_name = nil
       # Two different contributors, kept apart rather than folded into one flag: a lambda that
       # runs without raising isn't necessarily a lambda that filtered anything (one returning its
       # query untouched pushes no condition, constrains nothing). Conflating the two let a
@@ -265,12 +264,16 @@ module ForestLiana
     end
 
     def association_table_name(name)
-      QueryHelper.get_tables_associated_to_relations_name(@records).detect { |key, values|
+      tables_associated_to_relations_name.detect { |key, values|
         break key if Array(values).include?(name)
       }
 
     end
 
+    def tables_associated_to_relations_name
+      @tables_associated_to_relations_name ||= QueryHelper.get_tables_associated_to_relations_name(@resource)
+    end
+
     # Recorded here, checked separately by +assert_sort_readable!+: a count route runs this same
     # parsing (Rails strips the ORDER BY from the emitted COUNT SQL on its own) but must not refuse
     # a sort it never actually applies, so the two are split rather than checked inline.

data/app/services/forest_liana/single_record_selection.rb

@@ -0,0 +1,11 @@
+module ForestLiana
+  module SingleRecordSelection
+    MESSAGE = 'This action can only be triggered on one record at a time.'
+
+    def self.allowed?(action, attributes)
+      return true unless action&.type == 'single'
+
+      !attributes[:all_records] && Array(attributes[:ids]).length == 1
+    end
+  end
+end

data/app/services/forest_liana/utils/context_variables_injector.rb

@@ -27,7 +27,7 @@ module ForestLiana
         while (match = regex.match(value_with_context_variables_injected))
           context_variable_key = match[1]
 
-          value_with_context_variables_injected.gsub!(
+          value_with_context_variables_injected = value_with_context_variables_injected.gsub(
             /{{#{context_variable_key}}}/,
             yield(context_variable_key)
           )

data/lib/forest_liana/lookup_cache.rb

@@ -1,14 +1,27 @@
 module ForestLiana
-  # Remembers lookups by name over ForestLiana.models, .apimap and .names_overriden: on a large
-  # schema each one is a linear scan, schema_for_resource a scan of scans, and every request runs
-  # several. Any of the three being replaced or growing (the bootstrapper, a Forest collection
-  # file, a code reload) drops everything remembered, so an answer never outlives what it read.
+  # Remembers lookups over ForestLiana.models, .apimap and .names_overriden, and what
+  # .included_models/.excluded_models let through: on a large schema each one is a linear scan,
+  # schema_for_resource a scan of scans, and every request runs several. Any of these being
+  # replaced or growing (the bootstrapper, a Forest collection file, a code reload) drops everything
+  # remembered, so an answer never outlives what it read.
   module LookupCache
+    # Swapped as a whole, so a thread never pairs new sources with the stores of old ones.
+    Snapshot = Struct.new(:sources, :sizes, :stores) do
+      def current?(models, apimap, names, included, excluded)
+        same?(0, models) && same?(1, apimap) && same?(2, names) && same?(3, included) && same?(4, excluded)
+      end
+
+      private
+
+      def same?(index, source)
+        source.equal?(sources[index]) && source.size == sizes[index]
+      end
+    end
+
     # A miss is not remembered: the router resolves a request's collection before authenticating
     # it, so caching unknown names would let any caller grow this cache without bound.
     def self.fetch(namespace, key)
-      reset_if_stale
-      store = (@stores[namespace] ||= {})
+      store = (current_stores[namespace] ||= {})
       return store[key] if store.key?(key)
 
       value = yield
@@ -17,21 +30,23 @@ module ForestLiana
     end
 
     def self.reset!
-      @stores = nil
+      @snapshot = nil
     end
 
-    def self.reset_if_stale
+    # Runs on every lookup, thousands of times per list: a hit must not allocate.
+    def self.current_stores
       models = ForestLiana.models
       apimap = ForestLiana.apimap
       names = ForestLiana.names_overriden
-      return if @stores && models.equal?(@models) && models.size == @models_size &&
-                apimap.equal?(@apimap) && apimap.size == @apimap_size &&
-                names.equal?(@names) && names.size == @names_size
+      included = ForestLiana.included_models
+      excluded = ForestLiana.excluded_models
+      snapshot = @snapshot
+      return snapshot.stores if snapshot&.current?(models, apimap, names, included, excluded)
 
-      @models, @models_size = models, models.size
-      @apimap, @apimap_size = apimap, apimap.size
-      @names, @names_size = names, names.size
-      @stores = {}
+      sources = [models, apimap, names, included, excluded]
+      snapshot = Snapshot.new(sources, sources.map(&:size), {})
+      @snapshot = snapshot
+      snapshot.stores
     end
   end
 end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.22.11"
+  VERSION = "9.22.13"
 end

data/spec/helpers/forest_liana/decoration_helper_spec.rb

@@ -76,16 +76,22 @@ module ForestLiana
         end
       end
 
-      context 'when regex matching raises an exception' do
+      context 'when search_value is not a valid regex' do
         let(:search_value) { '[invalid_regex' }
 
-        it 'handles the exception gracefully' do
+        it 'does not match a value that does not contain it' do
           expect {
             described_class.detect_match_and_decorate(record, index, field_name, value, search_value, match_fields)
           }.not_to raise_error
 
           expect(match_fields).to be_empty
         end
+
+        it 'matches a value that contains it literally' do
+          described_class.detect_match_and_decorate(record, index, field_name, 'a[invalid_regex', search_value, match_fields)
+
+          expect(match_fields[index][:search]).to eq(['name'])
+        end
       end
 
       context 'with special regex characters in search_value' do
@@ -97,6 +103,12 @@ module ForestLiana
 
           expect(match_fields[index][:search]).to include('name')
         end
+
+        it 'does not match a value without the literal character' do
+          described_class.detect_match_and_decorate(record, index, field_name, 'testXemail', search_value, match_fields)
+
+          expect(match_fields).to be_empty
+        end
       end
     end
 
@@ -179,6 +191,31 @@ module ForestLiana
 
           expect(result[0][:search]).to eq(['name'])
         end
+
+        it 'compiles the search pattern once for every record and field' do
+          allow(Regexp).to receive(:new).and_call_original
+          expect(Regexp).to receive(:new).with('john', Regexp::IGNORECASE).once.and_call_original
+
+          described_class.decorate_for_search(records_serialized, field_names, search_value)
+        end
+
+        it 'highlights a search holding regex metacharacters literally' do
+          records_serialized['data'][1]['attributes']['name'] = 'f(x)'
+
+          result = described_class.decorate_for_search(records_serialized, field_names, '(')
+
+          expect(result).to eq({ 1 => { id: '2', search: ['name'] } })
+        end
+
+        it 'does not read a quantifier as one' do
+          records_serialized['data'][1]['attributes']['name'] = 'aaa'
+
+          expect(described_class.decorate_for_search(records_serialized, field_names, 'a*')).to be_nil
+        end
+
+        it 'does not read an alternation as one' do
+          expect(described_class.decorate_for_search(records_serialized, field_names, 'zzz|john')).to be_nil
+        end
       end
 
       context 'when no matches are found' do
@@ -228,6 +265,12 @@ module ForestLiana
             described_class.decorate_for_search(records_serialized, field_names, search_value)
           }.to raise_error(ArgumentError, "Missing 'attributes' key in record #{records_serialized['data'][0]}")
         end
+
+        it 'raises ArgumentError even when the search holds regex metacharacters' do
+          expect {
+            described_class.decorate_for_search(records_serialized, field_names, '[john')
+          }.to raise_error(ArgumentError, "Missing 'attributes' key in record #{records_serialized['data'][0]}")
+        end
       end
     end
   end