Merge 94a1f5a8ea into 94fb55bb6f

crates/index-scheduler/src/lib.rs

@@ -84,8 +84,6 @@ pub struct Query {
     pub limit: Option<u32>,
     /// The minimum [task id](`meilisearch_types::tasks::Task::uid`) to be matched
     pub from: Option<u32>,
-    /// The order used to return the tasks. By default the newest tasks are returned first and the boolean is `false`.
-    pub reverse: Option<bool>,
     /// The allowed [statuses](`meilisearch_types::tasks::Task::status`) of the matched tasls
     pub statuses: Option<Vec<Status>>,
     /// The allowed [kinds](meilisearch_types::tasks::Kind) of the matched tasks.
@@ -128,7 +126,6 @@ impl Query {
             Query {
                 limit: None,
                 from: None,
-                reverse: None,
                 statuses: None,
                 types: None,
                 index_uids: None,
@@ -709,12 +706,7 @@ impl IndexScheduler {
         let mut tasks = self.all_task_ids(rtxn)?;
 
         if let Some(from) = &query.from {
-            let range = if query.reverse.unwrap_or_default() {
+            tasks.remove_range(from.saturating_add(1)..);
-                u32::MIN..*from
-            } else {
-                from.saturating_add(1)..u32::MAX
-            };
-            tasks.remove_range(range);
         }
 
         if let Some(status) = &query.statuses {
@@ -834,11 +826,7 @@ impl IndexScheduler {
         )?;
 
         if let Some(limit) = query.limit {
-            tasks = if query.reverse.unwrap_or_default() {
+            tasks = tasks.into_iter().rev().take(limit as usize).collect();
-                tasks.into_iter().take(limit as usize).collect()
-            } else {
-                tasks.into_iter().rev().take(limit as usize).collect()
-            };
         }
 
         Ok(tasks)
@@ -963,13 +951,10 @@ impl IndexScheduler {
         let rtxn = self.env.read_txn()?;
 
         let (tasks, total) = self.get_task_ids_from_authorized_indexes(&rtxn, &query, filters)?;
-        let tasks = if query.reverse.unwrap_or_default() {
+        let tasks = self.get_existing_tasks(
-            Box::new(tasks.into_iter()) as Box<dyn Iterator<Item = u32>>
+            &rtxn,
-        } else {
+            tasks.into_iter().rev().take(query.limit.unwrap_or(u32::MAX) as usize),
-            Box::new(tasks.into_iter().rev()) as Box<dyn Iterator<Item = u32>>
+        )?;
-        };
-        let tasks =
-            self.get_existing_tasks(&rtxn, tasks.take(query.limit.unwrap_or(u32::MAX) as usize))?;
 
         let ProcessingTasks { started_at, processing, .. } =
             self.processing_tasks.read().map_err(|_| Error::CorruptedTaskQueue)?.clone();

crates/meilisearch-types/src/error.rs

@@ -318,7 +318,6 @@ InvalidTaskBeforeStartedAt            , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskCanceledBy                 , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskFrom                       , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskLimit                      , InvalidRequest       , BAD_REQUEST ;
-InvalidTaskReverse                    , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskStatuses                   , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskTypes                      , InvalidRequest       , BAD_REQUEST ;
 InvalidTaskUids                       , InvalidRequest       , BAD_REQUEST  ;

crates/meilisearch/src/routes/tasks.rs

@@ -42,8 +42,6 @@ pub struct TasksFilterQuery {
     pub limit: Param<u32>,
     #[deserr(default, error = DeserrQueryParamError<InvalidTaskFrom>)]
     pub from: Option<Param<TaskId>>,
-    #[deserr(default, error = DeserrQueryParamError<InvalidTaskReverse>)]
-    pub reverse: Option<Param<bool>>,
 
     #[deserr(default, error = DeserrQueryParamError<InvalidTaskUids>)]
     pub uids: OptionStarOrList<u32>,
@@ -75,7 +73,6 @@ impl TasksFilterQuery {
         Query {
             limit: Some(self.limit.0),
             from: self.from.as_deref().copied(),
-            reverse: self.reverse.as_deref().copied(),
             statuses: self.statuses.merge_star_and_none(),
             types: self.types.merge_star_and_none(),
             index_uids: self.index_uids.map(|x| x.to_string()).merge_star_and_none(),
@@ -145,7 +142,6 @@ impl TaskDeletionOrCancelationQuery {
         Query {
             limit: None,
             from: None,
-            reverse: None,
             statuses: self.statuses.merge_star_and_none(),
             types: self.types.merge_star_and_none(),
             index_uids: self.index_uids.map(|x| x.to_string()).merge_star_and_none(),
@@ -705,14 +701,14 @@ mod tests {
         {
             let params = "from=12&limit=15&indexUids=toto,tata-78&statuses=succeeded,enqueued&afterEnqueuedAt=2012-04-23&uids=1,2,3";
             let query = deserr_query_params::<TasksFilterQuery>(params).unwrap();
-            snapshot!(format!("{:?}", query), @r###"TasksFilterQuery { limit: Param(15), from: Some(Param(12)), reverse: None, uids: List([1, 2, 3]), canceled_by: None, types: None, statuses: List([Succeeded, Enqueued]), index_uids: List([IndexUid("toto"), IndexUid("tata-78")]), after_enqueued_at: Other(2012-04-24 0:00:00.0 +00:00:00), before_enqueued_at: None, after_started_at: None, before_started_at: None, after_finished_at: None, before_finished_at: None }"###);
+            snapshot!(format!("{:?}", query), @r###"TasksFilterQuery { limit: Param(15), from: Some(Param(12)), uids: List([1, 2, 3]), canceled_by: None, types: None, statuses: List([Succeeded, Enqueued]), index_uids: List([IndexUid("toto"), IndexUid("tata-78")]), after_enqueued_at: Other(2012-04-24 0:00:00.0 +00:00:00), before_enqueued_at: None, after_started_at: None, before_started_at: None, after_finished_at: None, before_finished_at: None }"###);
         }
         {
             // Stars should translate to `None` in the query
             // Verify value of the default limit
             let params = "indexUids=*&statuses=succeeded,*&afterEnqueuedAt=2012-04-23&uids=1,2,3";
             let query = deserr_query_params::<TasksFilterQuery>(params).unwrap();
-            snapshot!(format!("{:?}", query), @"TasksFilterQuery { limit: Param(20), from: None, reverse: None, uids: List([1, 2, 3]), canceled_by: None, types: None, statuses: Star, index_uids: Star, after_enqueued_at: Other(2012-04-24 0:00:00.0 +00:00:00), before_enqueued_at: None, after_started_at: None, before_started_at: None, after_finished_at: None, before_finished_at: None }");
+            snapshot!(format!("{:?}", query), @"TasksFilterQuery { limit: Param(20), from: None, uids: List([1, 2, 3]), canceled_by: None, types: None, statuses: Star, index_uids: Star, after_enqueued_at: Other(2012-04-24 0:00:00.0 +00:00:00), before_enqueued_at: None, after_started_at: None, before_started_at: None, after_finished_at: None, before_finished_at: None }");
         }
         {
             // Stars should also translate to `None` in task deletion/cancelation queries

crates/meilisearch/src/search/mod.rs

@@ -1733,10 +1733,7 @@ fn format_fields(
     // select the attributes to retrieve
     let displayable_names =
         displayable_ids.iter().map(|&fid| field_ids_map.name(fid).expect("Missing field name"));
-    permissive_json_pointer::map_leaf_values(
+    permissive_json_pointer::map_leaf_values(&mut document, displayable_names, |key, value| {
-        &mut document,
-        displayable_names,
-        |key, array_indices, value| {
         // To get the formatting option of each key we need to see all the rules that applies
         // to the value and merge them together. eg. If a user said he wanted to highlight `doggo`
         // and crop `doggo.name`. `doggo.name` needs to be highlighted + cropped while `doggo.age` is only
@@ -1767,7 +1764,6 @@ fn format_fields(
             format,
             &mut infos,
             compute_matches,
-                array_indices,
             locales,
         );
 
@@ -1776,8 +1772,7 @@ fn format_fields(
                 matches.insert(key.to_owned(), infos);
             }
         }
-        },
+    });
-    );
 
     let selectors = formatted_options
         .keys()
@@ -1795,14 +1790,13 @@ fn format_value(
     format_options: Option<FormatOptions>,
     infos: &mut Vec<MatchBounds>,
     compute_matches: bool,
-    array_indices: &[usize],
     locales: Option<&[Language]>,
 ) -> Value {
     match value {
         Value::String(old_string) => {
             let mut matcher = builder.build(&old_string, locales);
             if compute_matches {
-                let matches = matcher.matches(array_indices);
+                let matches = matcher.matches();
                 infos.extend_from_slice(&matches[..]);
             }
 
@@ -1814,15 +1808,51 @@ fn format_value(
                 None => Value::String(old_string),
             }
         }
-        // `map_leaf_values` makes sure this is only called for leaf fields
+        Value::Array(values) => Value::Array(
-        Value::Array(_) => unreachable!(),
+            values
-        Value::Object(_) => unreachable!(),
+                .into_iter()
+                .map(|v| {
+                    format_value(
+                        v,
+                        builder,
+                        format_options.map(|format_options| FormatOptions {
+                            highlight: format_options.highlight,
+                            crop: None,
+                        }),
+                        infos,
+                        compute_matches,
+                        locales,
+                    )
+                })
+                .collect(),
+        ),
+        Value::Object(object) => Value::Object(
+            object
+                .into_iter()
+                .map(|(k, v)| {
+                    (
+                        k,
+                        format_value(
+                            v,
+                            builder,
+                            format_options.map(|format_options| FormatOptions {
+                                highlight: format_options.highlight,
+                                crop: None,
+                            }),
+                            infos,
+                            compute_matches,
+                            locales,
+                        ),
+                    )
+                })
+                .collect(),
+        ),
         Value::Number(number) => {
             let s = number.to_string();
 
             let mut matcher = builder.build(&s, locales);
             if compute_matches {
-                let matches = matcher.matches(array_indices);
+                let matches = matcher.matches();
                 infos.extend_from_slice(&matches[..]);
             }
 

crates/meilisearch/tests/search/formatted.rs

@@ -208,10 +208,7 @@ async fn format_nested() {
                         "doggos.name": [
                           {
                             "start": 0,
-                            "length": 5,
+                            "length": 5
-                            "indices": [
-                              0
-                            ]
                           }
                         ]
                       }

crates/meilisearch/tests/tasks/errors.rs

@@ -279,55 +279,6 @@ async fn task_bad_from() {
     "###);
 }
 
-#[actix_rt::test]
-async fn task_bad_reverse() {
-    let server = Server::new_shared();
-
-    let (response, code) = server.tasks_filter("reverse=doggo").await;
-    snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
-    {
-      "message": "Invalid value in parameter `reverse`: could not parse `doggo` as a boolean, expected either `true` or `false`",
-      "code": "invalid_task_reverse",
-      "type": "invalid_request",
-      "link": "https://docs.meilisearch.com/errors#invalid_task_reverse"
-    }
-    "###);
-
-    let (response, code) = server.tasks_filter("reverse=*").await;
-    snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
-    {
-      "message": "Invalid value in parameter `reverse`: could not parse `*` as a boolean, expected either `true` or `false`",
-      "code": "invalid_task_reverse",
-      "type": "invalid_request",
-      "link": "https://docs.meilisearch.com/errors#invalid_task_reverse"
-    }
-    "###);
-
-    let (response, code) = server.cancel_tasks("reverse=doggo").await;
-    snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
-    {
-      "message": "Unknown parameter `reverse`: expected one of `uids`, `canceledBy`, `types`, `statuses`, `indexUids`, `afterEnqueuedAt`, `beforeEnqueuedAt`, `afterStartedAt`, `beforeStartedAt`, `afterFinishedAt`, `beforeFinishedAt`",
-      "code": "bad_request",
-      "type": "invalid_request",
-      "link": "https://docs.meilisearch.com/errors#bad_request"
-    }
-    "###);
-
-    let (response, code) = server.delete_tasks("reverse=doggo").await;
-    snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
-    {
-      "message": "Unknown parameter `reverse`: expected one of `uids`, `canceledBy`, `types`, `statuses`, `indexUids`, `afterEnqueuedAt`, `beforeEnqueuedAt`, `afterStartedAt`, `beforeStartedAt`, `afterFinishedAt`, `beforeFinishedAt`",
-      "code": "bad_request",
-      "type": "invalid_request",
-      "link": "https://docs.meilisearch.com/errors#bad_request"
-    }
-    "###);
-}
-
 #[actix_rt::test]
 async fn task_bad_after_enqueued_at() {
     let server = Server::new_shared();

crates/meilisearch/tests/tasks/mod.rs

@@ -62,44 +62,6 @@ async fn list_tasks() {
     assert_eq!(response["results"].as_array().unwrap().len(), 2);
 }
 
-#[actix_rt::test]
-async fn list_tasks_pagination_and_reverse() {
-    let server = Server::new().await;
-    // First of all we want to create a lot of tasks very quickly. The fastest way is to delete a lot of unexisting indexes
-    let mut last_task = None;
-    for i in 0..10 {
-        let index = server.index(format!("test-{i}"));
-        last_task = Some(index.create(None).await.0.uid());
-    }
-    server.wait_task(last_task.unwrap()).await;
-
-    let (response, code) = server.tasks_filter("limit=3").await;
-    assert_eq!(code, 200);
-    let results = response["results"].as_array().unwrap();
-    let task_ids: Vec<_> = results.iter().map(|ret| ret["uid"].as_u64().unwrap()).collect();
-    snapshot!(format!("{task_ids:?}"), @"[9, 8, 7]");
-
-    let (response, code) = server.tasks_filter("limit=3&from=1").await;
-    assert_eq!(code, 200);
-    let results = response["results"].as_array().unwrap();
-    let task_ids: Vec<_> = results.iter().map(|ret| ret["uid"].as_u64().unwrap()).collect();
-    snapshot!(format!("{task_ids:?}"), @"[1, 0]");
-
-    // In reversed order
-
-    let (response, code) = server.tasks_filter("limit=3&reverse=true").await;
-    assert_eq!(code, 200);
-    let results = response["results"].as_array().unwrap();
-    let task_ids: Vec<_> = results.iter().map(|ret| ret["uid"].as_u64().unwrap()).collect();
-    snapshot!(format!("{task_ids:?}"), @"[0, 1, 2]");
-
-    let (response, code) = server.tasks_filter("limit=3&from=8&reverse=true").await;
-    assert_eq!(code, 200);
-    let results = response["results"].as_array().unwrap();
-    let task_ids: Vec<_> = results.iter().map(|ret| ret["uid"].as_u64().unwrap()).collect();
-    snapshot!(format!("{task_ids:?}"), @"[8, 9]");
-}
-
 #[actix_rt::test]
 async fn list_tasks_with_star_filters() {
     let server = Server::new().await;
@@ -231,6 +193,131 @@ async fn list_tasks_status_and_type_filtered() {
     assert_eq!(response["results"].as_array().unwrap().len(), 2);
 }
 
+#[actix_rt::test]
+async fn get_task_filter_error() {
+    let server = Server::new().await;
+
+    let (response, code) = server.tasks_filter("lol=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Unknown parameter `lol`: expected one of `limit`, `from`, `uids`, `canceledBy`, `types`, `statuses`, `indexUids`, `afterEnqueuedAt`, `beforeEnqueuedAt`, `afterStartedAt`, `beforeStartedAt`, `afterFinishedAt`, `beforeFinishedAt`",
+      "code": "bad_request",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#bad_request"
+    }
+    "###);
+
+    let (response, code) = server.tasks_filter("uids=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Invalid value in parameter `uids`: could not parse `pied` as a positive integer",
+      "code": "invalid_task_uids",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_task_uids"
+    }
+    "###);
+
+    let (response, code) = server.tasks_filter("from=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Invalid value in parameter `from`: could not parse `pied` as a positive integer",
+      "code": "invalid_task_from",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_task_from"
+    }
+    "###);
+
+    let (response, code) = server.tasks_filter("beforeStartedAt=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Invalid value in parameter `beforeStartedAt`: `pied` is an invalid date-time. It should follow the YYYY-MM-DD or RFC 3339 date-time format.",
+      "code": "invalid_task_before_started_at",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_task_before_started_at"
+    }
+    "###);
+}
+
+#[actix_rt::test]
+async fn delete_task_filter_error() {
+    let server = Server::new().await;
+
+    let (response, code) = server.delete_tasks("").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Query parameters to filter the tasks to delete are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `canceledBy`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.",
+      "code": "missing_task_filters",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#missing_task_filters"
+    }
+    "###);
+
+    let (response, code) = server.delete_tasks("lol=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Unknown parameter `lol`: expected one of `uids`, `canceledBy`, `types`, `statuses`, `indexUids`, `afterEnqueuedAt`, `beforeEnqueuedAt`, `afterStartedAt`, `beforeStartedAt`, `afterFinishedAt`, `beforeFinishedAt`",
+      "code": "bad_request",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#bad_request"
+    }
+    "###);
+
+    let (response, code) = server.delete_tasks("uids=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Invalid value in parameter `uids`: could not parse `pied` as a positive integer",
+      "code": "invalid_task_uids",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_task_uids"
+    }
+    "###);
+}
+
+#[actix_rt::test]
+async fn cancel_task_filter_error() {
+    let server = Server::new().await;
+
+    let (response, code) = server.cancel_tasks("").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Query parameters to filter the tasks to cancel are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `canceledBy`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.",
+      "code": "missing_task_filters",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#missing_task_filters"
+    }
+    "###);
+
+    let (response, code) = server.cancel_tasks("lol=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Unknown parameter `lol`: expected one of `uids`, `canceledBy`, `types`, `statuses`, `indexUids`, `afterEnqueuedAt`, `beforeEnqueuedAt`, `afterStartedAt`, `beforeStartedAt`, `afterFinishedAt`, `beforeFinishedAt`",
+      "code": "bad_request",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#bad_request"
+    }
+    "###);
+
+    let (response, code) = server.cancel_tasks("uids=pied").await;
+    assert_eq!(code, 400, "{}", response);
+    meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
+    {
+      "message": "Invalid value in parameter `uids`: could not parse `pied` as a positive integer",
+      "code": "invalid_task_uids",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_task_uids"
+    }
+    "###);
+}
+
 macro_rules! assert_valid_summarized_task {
     ($response:expr, $task_type:literal, $index:literal) => {{
         assert_eq!($response.as_object().unwrap().len(), 5);

crates/milli/src/search/new/matches/mod.rs

@@ -105,8 +105,6 @@ impl FormatOptions {
 pub struct MatchBounds {
     pub start: usize,
     pub length: usize,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub indices: Option<Vec<usize>>,
 }
 
 /// Structure used to analyze a string, compute words that match,
@@ -222,20 +220,15 @@ impl<'t, 'tokenizer> Matcher<'t, 'tokenizer, '_, '_> {
     }
 
     /// Returns boundaries of the words that match the query.
-    pub fn matches(&mut self, array_indices: &[usize]) -> Vec<MatchBounds> {
+    pub fn matches(&mut self) -> Vec<MatchBounds> {
         match &self.matches {
-            None => self.compute_matches().matches(array_indices),
+            None => self.compute_matches().matches(),
             Some((tokens, matches)) => matches
                 .iter()
                 .map(|m| MatchBounds {
                     start: tokens[m.get_first_token_pos()].byte_start,
                     // TODO: Why is this in chars, while start is in bytes?
                     length: m.char_count,
-                    indices: if array_indices.is_empty() {
-                        None
-                    } else {
-                        Some(array_indices.to_owned())
-                    },
                 })
                 .collect(),
         }

crates/permissive-json-pointer/src/lib.rs

@@ -45,7 +45,7 @@ fn contained_in(selector: &str, key: &str) -> bool {
 /// map_leaf_values(
 ///     value.as_object_mut().unwrap(),
 ///     ["jean.race.name"],
-///     |key, _array_indices, value| match (value, key) {
+///     |key, value| match (value, key) {
 ///         (Value::String(name), "jean.race.name") => *name = "patou".to_string(),
 ///         _ => unreachable!(),
 ///     },
@@ -66,18 +66,17 @@ fn contained_in(selector: &str, key: &str) -> bool {
 pub fn map_leaf_values<'a>(
     value: &mut Map<String, Value>,
     selectors: impl IntoIterator<Item = &'a str>,
-    mut mapper: impl FnMut(&str, &[usize], &mut Value),
+    mut mapper: impl FnMut(&str, &mut Value),
 ) {
     let selectors: Vec<_> = selectors.into_iter().collect();
-    map_leaf_values_in_object(value, &selectors, "", &[], &mut mapper);
+    map_leaf_values_in_object(value, &selectors, "", &mut mapper);
 }
 
 pub fn map_leaf_values_in_object(
     value: &mut Map<String, Value>,
     selectors: &[&str],
     base_key: &str,
-    array_indices: &[usize],
+    mapper: &mut impl FnMut(&str, &mut Value),
-    mapper: &mut impl FnMut(&str, &[usize], &mut Value),
 ) {
     for (key, value) in value.iter_mut() {
         let base_key = if base_key.is_empty() {
@@ -95,12 +94,12 @@ pub fn map_leaf_values_in_object(
         if should_continue {
             match value {
                 Value::Object(object) => {
-                    map_leaf_values_in_object(object, selectors, &base_key, array_indices, mapper)
+                    map_leaf_values_in_object(object, selectors, &base_key, mapper)
                 }
                 Value::Array(array) => {
-                    map_leaf_values_in_array(array, selectors, &base_key, array_indices, mapper)
+                    map_leaf_values_in_array(array, selectors, &base_key, mapper)
                 }
-                value => mapper(&base_key, array_indices, value),
+                value => mapper(&base_key, value),
             }
         }
     }
@@ -110,24 +109,13 @@ pub fn map_leaf_values_in_array(
     values: &mut [Value],
     selectors: &[&str],
     base_key: &str,
-    base_array_indices: &[usize],
+    mapper: &mut impl FnMut(&str, &mut Value),
-    mapper: &mut impl FnMut(&str, &[usize], &mut Value),
 ) {
-    // This avoids allocating twice
+    for value in values.iter_mut() {
-    let mut array_indices = Vec::with_capacity(base_array_indices.len() + 1);
-    array_indices.extend_from_slice(base_array_indices);
-    array_indices.push(0);
-
-    for (i, value) in values.iter_mut().enumerate() {
-        *array_indices.last_mut().unwrap() = i;
         match value {
-            Value::Object(object) => {
+            Value::Object(object) => map_leaf_values_in_object(object, selectors, base_key, mapper),
-                map_leaf_values_in_object(object, selectors, base_key, &array_indices, mapper)
+            Value::Array(array) => map_leaf_values_in_array(array, selectors, base_key, mapper),
-            }
+            value => mapper(base_key, value),
-            Value::Array(array) => {
-                map_leaf_values_in_array(array, selectors, base_key, &array_indices, mapper)
-            }
-            value => mapper(base_key, &array_indices, value),
         }
     }
 }
@@ -755,14 +743,12 @@ mod tests {
             }
         });
 
-        map_leaf_values(
+        map_leaf_values(value.as_object_mut().unwrap(), ["jean.race.name"], |key, value| {
-            value.as_object_mut().unwrap(),
+            match (value, key) {
-            ["jean.race.name"],
-            |key, _, value| match (value, key) {
                 (Value::String(name), "jean.race.name") => *name = S("patou"),
                 _ => unreachable!(),
-            },
+            }
-        );
+        });
 
         assert_eq!(
             value,
@@ -789,7 +775,7 @@ mod tests {
         });
 
         let mut calls = 0;
-        map_leaf_values(value.as_object_mut().unwrap(), ["jean"], |key, _, value| {
+        map_leaf_values(value.as_object_mut().unwrap(), ["jean"], |key, value| {
             calls += 1;
             match (value, key) {
                 (Value::String(name), "jean.race.name") => *name = S("patou"),
@@ -812,52 +798,4 @@ mod tests {
             })
         );
     }
-
-    #[test]
-    fn map_array() {
-        let mut value: Value = json!({
-            "no_array": "peter",
-            "simple": ["foo", "bar"],
-            "nested": [
-                {
-                    "a": [
-                        ["cat", "dog"],
-                        ["fox", "bear"],
-                    ],
-                    "b": "hi",
-                },
-                {
-                    "a": ["green", "blue"],
-                },
-            ],
-        });
-
-        map_leaf_values(
-            value.as_object_mut().unwrap(),
-            ["no_array", "simple", "nested"],
-            |_key, array_indices, value| {
-                *value = format!("{array_indices:?}").into();
-            },
-        );
-
-        assert_eq!(
-            value,
-            json!({
-                "no_array": "[]",
-                "simple": ["[0]", "[1]"],
-                "nested": [
-                    {
-                        "a": [
-                            ["[0, 0, 0]", "[0, 0, 1]"],
-                            ["[0, 1, 0]", "[0, 1, 1]"],
-                        ],
-                        "b": "[0]",
-                    },
-                    {
-                        "a": ["[1, 0]", "[1, 1]"],
-                    },
-                ],
-            })
-        );
-    }
 }