langfingaz/anki
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge SortKind enum into Column enum

Browse Source
This commit is contained in:
RumovZ 2021-04-09 18:03:29 +02:00
parent c74078ea9e
commit bdd257e140
6 changed files with 144 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
pylib/anki/collection.py
View File

@ -12,7 +12,7 @@ SearchNode = _pb.SearchNode
Progress = _pb.Progress
EmptyCardsReport = _pb.EmptyCardsReport
GraphPreferences = _pb.GraphPreferences
BuiltinSort = _pb.SortOrder.Builtin
BuiltinSort = _pb.SortOrder.Builtin.SortColumn
Preferences = _pb.Preferences
UndoStatus = _pb.UndoStatus
OpChanges = _pb.OpChanges
@ -506,7 +506,7 @@ class Collection:
def find_cards(
self,
query: str,
order: Union[bool, str, BuiltinSort.Kind.V] = False,
order: Union[bool, str, BuiltinSort.V] = False,
reverse: bool = False,
) -> Sequence[CardId]:
"""Return card ids matching the provided search.
@ -521,10 +521,10 @@ class Collection:
desc and vice versa when reverse is set in the collection config, eg
order="c.ivl asc, c.due desc".
If order is a BuiltinSort.Kind value, sort using that builtin sort, eg
col.find_cards("", order=BuiltinSort.Kind.DUE)
If order is a BuiltinSort value, sort using that builtin sort, eg
col.find_cards("", order=BuiltinSort.DUE)
The reverse argument only applies when a BuiltinSort.Kind is provided;
The reverse argument only applies when a BuiltinSort.V is provided;
otherwise the collection config defines whether reverse is set or not.
"""
mode = _build_sort_mode(order, reverse)
@ -535,7 +535,7 @@ class Collection:
def find_notes(
self,
query: str,
order: Union[bool, str, BuiltinSort.Kind.V] = False,
order: Union[bool, str, BuiltinSort.V] = False,
reverse: bool = False,
) -> Sequence[NoteId]:
"""Return note ids matching the provided search.
@ -1123,7 +1123,7 @@ _UndoInfo = Union[_ReviewsUndo, LegacyCheckpoint, None]
def _build_sort_mode(
order: Union[bool, str, BuiltinSort.Kind.V],
order: Union[bool, str, BuiltinSort.V],
reverse: bool,
) -> _pb.SortOrder:
if isinstance(order, str):
@ -1134,4 +1134,4 @@ def _build_sort_mode(
else:
return _pb.SortOrder(none=_pb.Empty())
else:
return _pb.SortOrder(builtin=_pb.SortOrder.Builtin(kind=order, reverse=reverse))
return _pb.SortOrder(builtin=_pb.SortOrder.Builtin(column=order, reverse=reverse))

36
rslib/backend.proto
View File

@ -796,28 +796,22 @@ message SearchOut {
message SortOrder {
message Builtin {
enum Kind {
NOTE_CARDS = 0;
NOTE_CREATION = 1;
NOTE_DUE = 2;
NOTE_EASE = 3;
SORT_FIELD = 4;
NOTE_INTERVAL = 5;
NOTE_LAPSES = 6;
NOTE_MOD = 7;
NOTE_REPS = 8;
TAGS = 9;
NOTETYPE = 10;
CARD_MOD = 11;
REPS = 12;
DUE = 13;
EASE = 14;
LAPSES = 15;
INTERVAL = 16;
DECK = 17;
CARDS = 18;
enum SortColumn {
CARD_MOD = 0;
CARDS = 1;
DECK = 2;
DUE = 3;
EASE = 4;
LAPSES = 5;
INTERVAL = 6;
NOTE_CREATION = 7;
NOTE_MOD = 8;
NOTETYPE = 9;
REPS = 10;
SORT_FIELD = 11;
TAGS = 12;
}
Kind kind = 1;
SortColumn column = 1;
bool reverse = 2;
}
oneof value {

42
rslib/src/backend/search/mod.rs
View File

@ -10,9 +10,9 @@ use super::Backend;
use crate::{
backend_proto as pb,
backend_proto::{
sort_order::builtin::Kind as SortKindProto, sort_order::Value as SortOrderProto,
sort_order::builtin::SortColumn as SortColumnProto, sort_order::Value as SortOrderProto,
},
config::SortKind,
browser_table::Column,
prelude::*,
search::{concatenate_searches, replace_search_node, write_nodes, Node, SortMode},
};
@ -108,28 +108,22 @@ impl SearchService for Backend {
}
}
impl From<SortKindProto> for SortKind {
fn from(kind: SortKindProto) -> Self {
impl From<SortColumnProto> for Column {
fn from(kind: SortColumnProto) -> Self {
match kind {
SortKindProto::NoteCards => SortKind::NoteCards,
SortKindProto::NoteCreation => SortKind::NoteCreation,
SortKindProto::NoteDue => SortKind::NoteDue,
SortKindProto::NoteEase => SortKind::NoteEase,
SortKindProto::NoteInterval => SortKind::NoteInterval,
SortKindProto::NoteLapses => SortKind::NoteLapses,
SortKindProto::NoteMod => SortKind::NoteMod,
SortKindProto::SortField => SortKind::SortField,
SortKindProto::NoteReps => SortKind::NoteReps,
SortKindProto::Tags => SortKind::Tags,
SortKindProto::Notetype => SortKind::Notetype,
SortKindProto::CardMod => SortKind::CardMod,
SortKindProto::Reps => SortKind::Reps,
SortKindProto::Due => SortKind::Due,
SortKindProto::Ease => SortKind::Ease,
SortKindProto::Lapses => SortKind::Lapses,
SortKindProto::Interval => SortKind::Interval,
SortKindProto::Deck => SortKind::Deck,
SortKindProto::Cards => SortKind::Cards,
SortColumnProto::CardMod => Column::CardMod,
SortColumnProto::Cards => Column::Cards,
SortColumnProto::Deck => Column::Deck,
SortColumnProto::Due => Column::Due,
SortColumnProto::Ease => Column::Ease,
SortColumnProto::Lapses => Column::Lapses,
SortColumnProto::Interval => Column::Interval,
SortColumnProto::NoteCreation => Column::NoteCreation,
SortColumnProto::NoteMod => Column::NoteMod,
SortColumnProto::Notetype => Column::Notetype,
SortColumnProto::Reps => Column::Reps,
SortColumnProto::SortField => Column::SortField,
SortColumnProto::Tags => Column::Tags,
}
}
}
@ -142,7 +136,7 @@ impl From<Option<SortOrderProto>> for SortMode {
V::Custom(s) => SortMode::Custom(s),
V::FromConfig(_) => SortMode::FromConfig,
V::Builtin(b) => SortMode::Builtin {
kind: b.kind().into(),
column: b.column().into(),
reverse: b.reverse,
},
}

20
rslib/src/browser_table.rs
View File

@ -4,7 +4,7 @@
use std::sync::Arc;
use itertools::Itertools;
use serde_repr::{Deserialize_repr, Serialize_repr};
use serde::{Deserialize, Serialize};
use strum::{Display, EnumIter, EnumString};
use crate::error::{AnkiError, Result};
@ -22,37 +22,47 @@ use crate::{
timestamp::{TimestampMillis, TimestampSecs},
};
#[derive(
Serialize_repr, Deserialize_repr, Debug, PartialEq, Clone, Copy, Display, EnumString, EnumIter,
)]
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy, Display, EnumIter, EnumString)]
#[serde(rename_all = "camelCase")]
#[strum(serialize_all = "camelCase")]
#[repr(u8)]
pub enum Column {
#[serde(rename = "")]
#[strum(serialize = "")]
Custom,
Answer,
CardMod,
#[serde(rename = "template")]
#[strum(serialize = "template")]
Cards,
Deck,
#[serde(rename = "cardDue")]
#[strum(serialize = "cardDue")]
Due,
#[serde(rename = "cardEase")]
#[strum(serialize = "cardEase")]
Ease,
#[serde(rename = "cardLapses")]
#[strum(serialize = "cardLapses")]
Lapses,
#[serde(rename = "cardIvl")]
#[strum(serialize = "cardIvl")]
Interval,
#[serde(rename = "noteCrt")]
#[strum(serialize = "noteCrt")]
NoteCreation,
NoteMod,
#[serde(rename = "note")]
#[strum(serialize = "note")]
Notetype,
Question,
#[serde(rename = "cardReps")]
#[strum(serialize = "cardReps")]
Reps,
#[serde(rename = "noteFld")]
#[strum(serialize = "noteFld")]
SortField,
#[serde(rename = "noteTags")]
#[strum(serialize = "noteTags")]
Tags,
}

76
rslib/src/config/mod.rs
View File

@ -9,10 +9,9 @@ mod string;
pub(crate) mod undo;
pub use self::{bool::BoolKey, string::StringKey};
use crate::browser_table;
use crate::browser_table::Column;
use crate::prelude::*;
use serde::{de::DeserializeOwned, Serialize};
use serde_derive::Deserialize;
use serde_repr::{Deserialize_repr, Serialize_repr};
use slog::warn;
use strum::IntoStaticStr;
@ -48,9 +47,9 @@ pub(crate) enum ConfigKey {
#[strum(to_string = "timeLim")]
AnswerTimeLimitSecs,
#[strum(to_string = "sortType")]
BrowserSortKind,
BrowserSortColumn,
#[strum(to_string = "noteSortType")]
BrowserNoteSortKind,
BrowserNoteSortColumn,
#[strum(to_string = "curDeck")]
CurrentDeckId,
#[strum(to_string = "curModel")]
@ -131,33 +130,29 @@ impl Collection {
Ok(())
}
pub(crate) fn get_browser_sort_kind(&self) -> SortKind {
self.get_config_default(ConfigKey::BrowserSortKind)
pub(crate) fn get_browser_sort_column(&self) -> Column {
self.get_config_optional(ConfigKey::BrowserSortColumn)
.unwrap_or(Column::NoteCreation)
}
pub(crate) fn get_browser_note_sort_kind(&self) -> SortKind {
self.get_config_default(ConfigKey::BrowserNoteSortKind)
pub(crate) fn get_browser_note_sort_column(&self) -> Column {
self.get_config_optional(ConfigKey::BrowserNoteSortColumn)
.unwrap_or(Column::NoteCreation)
}
pub(crate) fn get_desktop_browser_card_columns(&self) -> Option<Vec<browser_table::Column>> {
pub(crate) fn get_desktop_browser_card_columns(&self) -> Option<Vec<Column>> {
self.get_config_optional(ConfigKey::DesktopBrowserCardColumns)
}
pub(crate) fn set_desktop_browser_card_columns(
&mut self,
columns: Vec<browser_table::Column>,
) -> Result<()> {
pub(crate) fn set_desktop_browser_card_columns(&mut self, columns: Vec<Column>) -> Result<()> {
self.set_config(ConfigKey::DesktopBrowserCardColumns, &columns)
}
pub(crate) fn get_desktop_browser_note_columns(&self) -> Option<Vec<browser_table::Column>> {
pub(crate) fn get_desktop_browser_note_columns(&self) -> Option<Vec<Column>> {
self.get_config_optional(ConfigKey::DesktopBrowserNoteColumns)
}
pub(crate) fn set_desktop_browser_note_columns(
&mut self,
columns: Vec<browser_table::Column>,
) -> Result<()> {
pub(crate) fn set_desktop_browser_note_columns(&mut self, columns: Vec<Column>) -> Result<()> {
self.set_config(ConfigKey::DesktopBrowserNoteColumns, &columns)
}
@ -269,47 +264,6 @@ impl Collection {
}
}
#[derive(Deserialize, PartialEq, Debug, Clone, Copy)]
#[serde(rename_all = "camelCase")]
pub enum SortKind {
NoteCards,
#[serde(rename = "noteCrt")]
NoteCreation,
NoteDue,
NoteEase,
#[serde(rename = "noteIvl")]
NoteInterval,
NoteLapses,
NoteMod,
#[serde(rename = "noteFld")]
SortField,
NoteReps,
#[serde(rename = "note")]
Notetype,
#[serde(rename = "noteTags")]
Tags,
CardMod,
#[serde(rename = "cardReps")]
Reps,
#[serde(rename = "cardDue")]
Due,
#[serde(rename = "cardEase")]
Ease,
#[serde(rename = "cardLapses")]
Lapses,
#[serde(rename = "cardIvl")]
Interval,
Deck,
#[serde(rename = "template")]
Cards,
}
impl Default for SortKind {
fn default() -> Self {
Self::NoteCreation
}
}
// 2021 scheduler moves this into deck config
pub(crate) enum NewReviewMix {
Mix = 0,
@ -334,7 +288,7 @@ pub(crate) enum Weekday {
#[cfg(test)]
mod test {
use super::SortKind;
use super::*;
use crate::collection::open_test_collection;
use crate::decks::DeckId;
@ -342,7 +296,7 @@ mod test {
fn defaults() {
let col = open_test_collection();
assert_eq!(col.get_current_deck_id(), DeckId(1));
assert_eq!(col.get_browser_sort_kind(), SortKind::SortField);
assert_eq!(col.get_browser_sort_column(), Column::SortField);
}
#[test]

163
rslib/src/search/mod.rs
View File

@ -14,14 +14,8 @@ use rusqlite::types::FromSql;
use std::borrow::Cow;
use crate::{
card::CardId,
card::CardType,
collection::Collection,
config::{BoolKey, SortKind},
error::Result,
notes::NoteId,
prelude::AnkiError,
search::parser::parse,
browser_table::Column, card::CardId, card::CardType, collection::Collection, config::BoolKey,
error::Result, notes::NoteId, prelude::AnkiError, search::parser::parse,
};
use sqlwriter::{RequiredTable, SqlWriter};
@ -35,7 +29,7 @@ pub enum SearchItems {
pub enum SortMode {
NoOrder,
FromConfig,
Builtin { kind: SortKind, reverse: bool },
Builtin { column: Column, reverse: bool },
Custom(String),
}
@ -69,7 +63,7 @@ impl SortMode {
match self {
SortMode::NoOrder => RequiredTable::CardsOrNotes,
SortMode::FromConfig => unreachable!(),
SortMode::Builtin { kind, .. } => kind.required_table(),
SortMode::Builtin { column, .. } => column.required_table(),
SortMode::Custom(ref text) => {
if text.contains("n.") {
if text.contains("c.") {
@ -85,28 +79,16 @@ impl SortMode {
}
}
impl SortKind {
impl Column {
fn required_table(self) -> RequiredTable {
match self {
SortKind::NoteCards
| SortKind::NoteCreation
| SortKind::NoteDue
| SortKind::NoteEase
| SortKind::SortField
| SortKind::NoteInterval
| SortKind::NoteLapses
| SortKind::NoteMod
| SortKind::NoteReps
| SortKind::Tags
| SortKind::Notetype => RequiredTable::Notes,
SortKind::Cards => RequiredTable::CardsAndNotes,
SortKind::CardMod
| SortKind::Reps
| SortKind::Due
| SortKind::Ease
| SortKind::Lapses
| SortKind::Interval
| SortKind::Deck => RequiredTable::Cards,
Column::Cards
| Column::NoteCreation
| Column::NoteMod
| Column::Notetype
| Column::SortField
| Column::Tags => RequiredTable::Notes,
_ => RequiredTable::CardsOrNotes,
}
}
}
@ -144,10 +126,10 @@ impl Collection {
match mode {
SortMode::NoOrder => (),
SortMode::FromConfig => unreachable!(),
SortMode::Builtin { kind, reverse } => {
prepare_sort(self, kind, items)?;
SortMode::Builtin { column, reverse } => {
prepare_sort(self, column, items)?;
sql.push_str(" order by ");
write_order(sql, items, kind, reverse)?;
write_order(sql, items, column, reverse)?;
}
SortMode::Custom(order_clause) => {
sql.push_str(" order by ");
@ -192,11 +174,11 @@ impl Collection {
if mode == &SortMode::FromConfig {
*mode = match items {
SearchItems::Cards => SortMode::Builtin {
kind: self.get_browser_sort_kind(),
column: self.get_browser_sort_column(),
reverse: self.get_bool(BoolKey::BrowserSortBackwards),
},
SearchItems::Notes => SortMode::Builtin {
kind: self.get_browser_note_sort_kind(),
column: self.get_browser_note_sort_column(),
reverse: self.get_bool(BoolKey::BrowserNoteSortBackwards),
},
}
@ -205,15 +187,15 @@ impl Collection {
}
/// Add the order clause to the sql.
fn write_order(sql: &mut String, items: SearchItems, kind: SortKind, reverse: bool) -> Result<()> {
fn write_order(sql: &mut String, items: SearchItems, column: Column, reverse: bool) -> Result<()> {
let order = match items {
SearchItems::Cards => card_order_from_sortkind(kind),
SearchItems::Notes => note_order_from_sortkind(kind),
SearchItems::Cards => card_order_from_sort_column(column),
SearchItems::Notes => note_order_from_sort_column(column),
};
if order.is_empty() {
return Err(AnkiError::invalid_input(format!(
"Can't sort {:?} by {:?}.",
items, kind
items, column
)));
}
if reverse {
@ -229,70 +211,69 @@ fn write_order(sql: &mut String, items: SearchItems, kind: SortKind, reverse: bo
Ok(())
}
fn card_order_from_sortkind(kind: SortKind) -> Cow<'static, str> {
match kind {
SortKind::NoteCreation => "n.id asc, c.ord asc".into(),
SortKind::NoteMod => "n.mod asc, c.ord asc".into(),
SortKind::SortField => "n.sfld collate nocase asc, c.ord asc".into(),
SortKind::CardMod => "c.mod asc".into(),
SortKind::Reps => "c.reps asc".into(),
SortKind::Due => "c.type asc, c.due asc".into(),
SortKind::Ease => format!("c.type = {} asc, c.factor asc", CardType::New as i8).into(),
SortKind::Lapses => "c.lapses asc".into(),
SortKind::Interval => "c.ivl asc".into(),
SortKind::Tags => "n.tags asc".into(),
SortKind::Deck => "(select pos from sort_order where did = c.did) asc".into(),
SortKind::Notetype => "(select pos from sort_order where ntid = n.mid) asc".into(),
SortKind::Cards => concat!(
fn card_order_from_sort_column(column: Column) -> Cow<'static, str> {
match column {
Column::CardMod => "c.mod asc".into(),
Column::Cards => concat!(
"coalesce((select pos from sort_order where ntid = n.mid and ord = c.ord),",
// need to fall back on ord 0 for cloze cards
"(select pos from sort_order where ntid = n.mid and ord = 0)) asc"
)
.into(),
_ => "".into(),
Column::Deck => "(select pos from sort_order where did = c.did) asc".into(),
Column::Due => "c.type asc, c.due asc".into(),
Column::Ease => format!("c.type = {} asc, c.factor asc", CardType::New as i8).into(),
Column::Interval => "c.ivl asc".into(),
Column::Lapses => "c.lapses asc".into(),
Column::NoteCreation => "n.id asc, c.ord asc".into(),
Column::NoteMod => "n.mod asc, c.ord asc".into(),
Column::Notetype => "(select pos from sort_order where ntid = n.mid) asc".into(),
Column::Reps => "c.reps asc".into(),
Column::SortField => "n.sfld collate nocase asc, c.ord asc".into(),
Column::Tags => "n.tags asc".into(),
Column::Answer | Column::Custom | Column::Question => "".into(),
}
}
fn note_order_from_sortkind(kind: SortKind) -> Cow<'static, str> {
match kind {
SortKind::Deck
| SortKind::CardMod
| SortKind::NoteCards
| SortKind::NoteDue
| SortKind::NoteEase
| SortKind::NoteInterval
| SortKind::NoteLapses
| SortKind::NoteReps => "(select pos from sort_order where nid = n.id) asc".into(),
SortKind::NoteCreation => "n.id asc".into(),
SortKind::SortField => "n.sfld collate nocase asc".into(),
SortKind::NoteMod => "n.mod asc".into(),
SortKind::Tags => "n.tags asc".into(),
SortKind::Notetype => "(select pos from sort_order where ntid = n.mid) asc".into(),
_ => "".into(),
fn note_order_from_sort_column(column: Column) -> Cow<'static, str> {
match column {
Column::CardMod
| Column::Cards
| Column::Deck
| Column::Due
| Column::Ease
| Column::Interval
| Column::Lapses
| Column::Reps => "(select pos from sort_order where nid = n.id) asc".into(),
Column::NoteCreation => "n.id asc".into(),
Column::NoteMod => "n.mod asc".into(),
Column::Notetype => "(select pos from sort_order where ntid = n.mid) asc".into(),
Column::SortField => "n.sfld collate nocase asc".into(),
Column::Tags => "n.tags asc".into(),
Column::Answer | Column::Custom | Column::Question => "".into(),
}
}
fn prepare_sort(col: &mut Collection, kind: SortKind, items: SearchItems) -> Result<()> {
use SortKind::*;
let notes_mode = items == SearchItems::Notes;
let sql = match kind {
Deck => {
if notes_mode {
include_str!("note_decks_order.sql")
} else {
include_str!("deck_order.sql")
}
}
CardMod if notes_mode => include_str!("card_mod_order.sql"),
Cards => include_str!("template_order.sql"),
NoteCards => include_str!("note_cards_order.sql"),
NoteDue => include_str!("note_due_order.sql"),
NoteEase => include_str!("note_ease_order.sql"),
NoteInterval => include_str!("note_interval_order.sql"),
NoteLapses => include_str!("note_lapses_order.sql"),
NoteReps => include_str!("note_reps_order.sql"),
Notetype => include_str!("notetype_order.sql"),
fn prepare_sort(col: &mut Collection, column: Column, items: SearchItems) -> Result<()> {
let sql = match items {
SearchItems::Cards => match column {
Column::Cards => include_str!("template_order.sql"),
Column::Deck => include_str!("deck_order.sql"),
Column::Notetype => include_str!("notetype_order.sql"),
_ => return Ok(()),
},
SearchItems::Notes => match column {
Column::Cards => include_str!("note_cards_order.sql"),
Column::CardMod => include_str!("card_mod_order.sql"),
Column::Deck => include_str!("note_decks_order.sql"),
Column::Due => include_str!("note_due_order.sql"),
Column::Ease => include_str!("note_ease_order.sql"),
Column::Interval => include_str!("note_interval_order.sql"),
Column::Lapses => include_str!("note_lapses_order.sql"),
Column::Reps => include_str!("note_reps_order.sql"),
Column::Notetype => include_str!("notetype_order.sql"),
_ => return Ok(()),
},
};
col.storage.db.execute_batch(sql)?;