Merge pull request #326 from otaviocc/oc/sort

Sort using Nook Phone order

ACHNBrowserUI/ACHNBrowserUI/viewModels/ItemsViewModel.swift

@@ -11,18 +11,9 @@ import Combine
 import Backend
 
 class ItemsViewModel: ObservableObject {
-    @Published var items: [Item] = []
-    @Published var sortedItems: [Item] = []
-    @Published var searchItems: [Item] = []
-    @Published var searchText = ""
-
-    public let category: Backend.Category
-
-    private var itemCancellable: AnyCancellable?
-    private var searchCancellable: AnyCancellable?
-
-    private static var META_KEYWORD_CACHE: [String: [Item]] = [:]
-
+
+    // MARK: - Nested types
+
     enum Sort: String, CaseIterable {
         case name, buy, sell, set, similar, critterpedia
 
@@ -41,78 +32,107 @@ class ItemsViewModel: ObservableObject {
             }
         }
     }
-
+
+    // MARK: - Properties
+
+    @Published var allItems: [Item] = []
+    @Published var sortedItems: [Item] = []
+    @Published var searchItems: [Item] = []
+    @Published var searchText = ""
+
+    var items: [Item] {
+        if !searchText.isEmpty {
+            return searchItems
+        } else if sort != nil {
+            return sortedItems
+        } else {
+            return allItems
+        }
+    }
+
+    public let category: Backend.Category
+
     var sort: Sort? {
         didSet {
             guard let sort = sort else { return }
             switch sort {
             case .name:
                 let order: ComparisonResult = sort == oldValue ? .orderedAscending : .orderedDescending
-                sortedItems = items.sorted{ $0.localizedName.localizedCompare($1.localizedName) == order }
+                sortedItems = allItems
+                    .sorted(by: removingOccurrences(of: "-", order: order))
             case .buy:
                 let compare: (Int, Int) -> Bool = sort == oldValue ? (<) : (>)
-                sortedItems = items.filter{ $0.buy != nil}.sorted{ compare($0.buy!, $1.buy!) }
+                sortedItems = allItems.filter { $0.buy != nil}.sorted { compare($0.buy!, $1.buy!) }
             case .sell:
                 let compare: (Int, Int) -> Bool = sort == oldValue ? (<) : (>)
-                sortedItems = items.filter{ $0.sell != nil}.sorted{ compare($0.sell!, $1.sell!) }
+                sortedItems = allItems.filter { $0.sell != nil}.sorted { compare($0.sell!, $1.sell!) }
             case .set:
                 let compare: (String, String) -> Bool = sort == oldValue ? (<) : (>)
-                sortedItems = items.filter{ $0.set != nil}.sorted{ compare($0.set!, $1.set!) }
+                sortedItems = allItems.filter { $0.set != nil}.sorted { compare($0.set!, $1.set!) }
             case .similar:
                 let compare: (String, String) -> Bool = sort == oldValue ? (<) : (>)
-                sortedItems = items.filter{ $0.tag != nil}.sorted{ compare($0.tag!, $1.tag!) }
+                sortedItems = allItems.filter { $0.tag != nil}.sorted { compare($0.tag!, $1.tag!) }
             case .critterpedia:
                 let compare: (Int, Int) -> Bool = sort == oldValue ? (>) : (<)
-                sortedItems = items.filter{ $0.critterId != nil}
-                                .sorted{ compare($0.critterId!, $1.critterId!) }
+                sortedItems = allItems
+                    .filter { $0.critterId != nil}
+                    .sorted{ compare($0.critterId!, $1.critterId!) }
             }
         }
     }
-
-    public init(category: Backend.Category, items: [Item]) {
+
+    private var itemCancellable: AnyCancellable?
+    private var searchCancellable: AnyCancellable?
+    private static var META_KEYWORD_CACHE: [String: [Item]] = [:]
+
+    // MARK: - Life cycle
+
+    public init(category: Backend.Category, items allItems: [Item]) {
         self.category = category
-        self.items = items
-        setupSearch()
-
+        self.allItems = allItems
+        setUpSearch()
     }
 
     public init(category: Backend.Category) {
         self.category = category
-        setupSearch()
+        setUpSearch()
 
         itemCancellable = Items.shared.$categories
             .subscribe(on: DispatchQueue.global())
             .map{ $0[category]?.sorted{ $0.localizedName.localizedCompare($1.localizedName) == .orderedAscending } ?? [] }
             .receive(on: DispatchQueue.main)
             .sink { [weak self] in
-                self?.items = $0
+                self?.allItems = $0
         }
     }
 
     public init(meta: String) {
         self.category = .other
         if let items = Self.META_KEYWORD_CACHE[meta] {
-            self.items = items
+            self.allItems = items
         } else {
             itemCancellable = Items.shared.$categories
                 .subscribe(on: DispatchQueue.global())
                 .map{ $0.values.flatMap{ $0 }.filter({ $0.metas.contains(meta) }) }
                 .receive(on: DispatchQueue.main)
-                .sink { [weak self] items in
-                    Self.META_KEYWORD_CACHE[meta] = items
-                    self?.items = items
+                .sink { [weak self] allItems in
+                    Self.META_KEYWORD_CACHE[meta] = allItems
+                    self?.allItems = allItems
             }
         }
-        setupSearch()
+        setUpSearch()
     }
 
+    // MARK: - Private
+
     private func items(with string: String) -> [Item] {
-        items.filter {
+        allItems.filter {
             $0.localizedName.lowercased().contains(string.lowercased())
         }
+        .sorted(by: removingOccurrences(of: "-", order: .orderedAscending))
     }
-    
-    private func setupSearch() {
+
+    private func setUpSearch() {
         searchCancellable = $searchText
             .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
             .removeDuplicates()
@@ -122,4 +142,12 @@ class ItemsViewModel: ObservableObject {
                 self?.searchItems = $0
         }
     }
+
+    private func removingOccurrences(of string: String, order: ComparisonResult) -> (Item, Item) -> Bool {
+        {
+            let first = $0.localizedName.replacingOccurrences(of: string, with: " ")
+            let second = $1.localizedName.replacingOccurrences(of: string, with: " ")
+            return first.localizedCompare(second) == order
+        }
+    }
 }

ACHNBrowserUI/ACHNBrowserUI/views/items/ItemsView.swift

@@ -44,18 +44,6 @@ struct ItemsView: View {
         }
     }
 
-    var currentItems: [Item] {
-        get {
-            if !viewModel.searchText.isEmpty {
-                return viewModel.searchItems
-            } else if viewModel.sort != nil {
-                return viewModel.sortedItems
-            } else {
-                return viewModel.items
-            }
-        }
-    }
-
     private var sortButton: some View {
         Menu {
             ForEach(ItemsViewModel.Sort.allCases(for: viewModel.category), id: \.self) { sort in
@@ -125,7 +113,7 @@ struct ItemsView: View {
         if contentMode == .grid {
             ScrollView {
                 LazyVGrid(columns: [GridItem(.adaptive(minimum: 120), spacing: 16)], spacing: 16) {
-                    ForEach(currentItems) { item in
+                    ForEach(viewModel.items) { item in
                         ItemGridItemView(item: item)
                     }
                 }
@@ -135,7 +123,7 @@ struct ItemsView: View {
         } else {
             List {
                 Section(header: SearchField(searchText: $viewModel.searchText)) {
-                    ForEach(currentItems) { item in
+                    ForEach(viewModel.items) { item in
                         NavigationLink(destination: LazyView(ItemDetailView(item: item))) {
                             ItemRowView(displayMode: contentMode == .listLarge ? .large : .compact,
                                         item: item)