refactor get_recently_added_entries, new_user and empty_library

src/library.cr

@@ -520,49 +520,37 @@ class Library
     }[0..11]
   end
 
+  alias RA = NamedTuple(entry: Entry, percentage: Float64, grouped_count: Int32)
+
   def get_recently_added_entries(username)
     entries = [] of Entry
     titles.each do |t|
       t.entries.each { |e| entries << e }
     end
     entries.sort! { |a, b| b.date_added <=> a.date_added }
-    # Only grab entries form the last 3 months
-    # otherwise we will be grouping neighbours by Title for the entire
-    # library every time. Is this premature optimisation or reasonable optimisation?
     entries.select! { |e| e.date_added > 3.months.ago }
 
-    i = 0
+    # Group Entries if neighbour is same Title
-    recently_added = [] of NamedTuple(entry: Entry, percentage: Float64, grouped_count: Int32)
+    recently_added = [] of RA
-    while i <= entries.size - 1
+    entries.each do |e|
-      grouped_count = neighbouring_title_count(entries, i)
+      last = recently_added.last?
-      if grouped_count > 1
+      if last && e.title_id == last[:entry].title_id
-        # delete grouped entries (except for first)
+        # A NamedTuple is immutable, so we have to cast it to a Hash first
-        entries.delete_at(i+1..i+grouped_count-1)
+        last_hash = last.to_h
+        count = last_hash[:grouped_count].as(Int32)
+        last_hash[:grouped_count] = count + 1
+        recently_added[recently_added.size - 1] = RA.from last_hash
+      else
+        recently_added << {
+          entry:         e,
+          percentage:    e.book.load_percentage(username, e.title),
+          grouped_count: 1,
+        }
       end
-      recently_added << { 
-        entry: entries[i], 
-        percentage: entries[i].book.load_percentage(username, entries[i].title),
-        grouped_count: grouped_count
-      }
-      i += 1
     end
 
     recently_added[0..11]
   end
-
-  private def neighbouring_title_count(entries, index : Int32)
-    count = 1
-    book_title = entries[index].book.title
-    while index < entries.size - 1
-      if book_title == entries[index+1].book.title # is it ok to compare via book.title?
-        count += 1
-      else
-        break
-      end
-      index += 1
-    end
-    count
-  end
   
   private def get_continue_reading_entry(username, title)
     in_progress_entries = title.entries.select do |e|

src/routes/main.cr

@@ -68,14 +68,9 @@ class MainRouter < Router
         username = get_username env
         continue_reading = @context.library.get_continue_reading_entries username
         recently_added = @context.library.get_recently_added_entries username
-
-        new_user = true
         titles = @context.library.titles
-        titles.each { |t| new_user = false if t.load_percentage(username) > 0 }
+        new_user = ! titles.any? { |t| t.load_percentage(username) > 0 }
-
+        empty_library = titles.size == 0
-        empty_library = true
-        empty_library = false if titles.size > 0
-
         layout "home"
       rescue e
         @context.error e