reading 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e839c46251c307a65a234a9a374ad964f68d934d974005d6aa38cbb35e10f756
-  data.tar.gz: fa20c0b78f3fd1194495e1e604bb1d95b37e0334ac12c745d6508e026cd6fe97
+  metadata.gz: e30d2e08f85d4ecb58352862165f63b62dbcbeb436103cf0761f318592359571
+  data.tar.gz: 7991e2a241345bd8f5b8fe268c462b721d610157d2c2652aec16882d3833c65f
 SHA512:
-  metadata.gz: 2bbca1450b2f6ae4c0d2b6d4cfeec495bf30b20639fcb3a5b121711e1d995a8b13a5ca64100d7a5e11d00d60c3808d61d25583510e3cd19902d412eca216154f
-  data.tar.gz: 74a676238941cdd5a0a7ecf8b2a4ed3c705883daadc25b3710a17eb9e325ec294d8b9fad71e653779af1ea9e01d0e8fed6423592dbe750b4f37c79f0f690387d
+  metadata.gz: 1357b2ecd226209ff58e5fa7215ca073bfda99225a9d1623b111417d9bf01ecc9ec61406b2bde9fb3a26f1c7ce6a24e9495eb2bedca403a45d029d9e94e83c0e
+  data.tar.gz: 10285aa58757b8fa07e94945811a9195f6e5015e06ace666c963885b5a5eb19839bae855013a54a76fb4d2a038a9dd1fc53611b2ea0d28a4385073811064cb46

data/bin/reading

@@ -13,9 +13,9 @@
 #   reading '3|📕Trying|Little Library 1970147288'
 #   reading '📕Trying|Little Library 1970147288' 'head, sources'
 
-require 'debug'
 require_relative '../lib/reading'
 require_relative '../lib/reading/stats/terminal_result_formatters'
+require 'debug'
 require 'amazing_print'
 require 'readline'
 require 'pastel'
@@ -38,26 +38,33 @@ GROUP_HEADING_FORMATTERS = [
 def print_grouped_results(grouped_results, group_heading_formatters)
   indent_level = GROUP_HEADING_FORMATTERS.count - group_heading_formatters.count
 
-  if grouped_results.nil? || grouped_results.empty?
+  if grouped_results.nil? || (grouped_results.respond_to?(:empty?) && grouped_results.empty?)
     puts "  " * indent_level + PASTEL.bright_black("none") + "\n"
     return
-  elsif !grouped_results.is_a? Hash
-    puts "  " * indent_level + grouped_results.gsub("\n", "\n" + "  " * indent_level) + "\n"
-    return
   end
 
-  grouped_results.each do |group_name, grouped|
-    puts "  " * indent_level + group_heading_formatters.first.call(group_name)
-    print_grouped_results(grouped, group_heading_formatters[1..])
+  if grouped_results.is_a?(Hash) ||
+    (grouped_results.is_a?(Array) && grouped_results.first.length == 2)
+
+    grouped_results.each do |group_name, grouped|
+      puts "  " * indent_level + group_heading_formatters.first.call(group_name)
+      print_grouped_results(grouped, group_heading_formatters[1..])
+    end
+  elsif grouped_results.is_a?(Array)
+    numbered_results = grouped_results.map.with_index { |v, i| "#{i + 1}. #{v}" }
+
+    puts "  " * indent_level + numbered_results.join("\n" + "  " * indent_level) + "\n"
+  else
+    puts "  " * indent_level + grouped_results.to_s + "\n"
   end
 end
 
 input = ARGV[0]
 unless input
   raise ArgumentError,
-    "Argument required, either a CSV file path or a CSV string. Examples:\n" \
-    "parsereading /home/felipe/reading.csv\n" \
-    "parsereading '3|📕Trying|Little Library 1970147288'"
+    "Argument required, either a CSV file path or a CSV string.\nExamples:\n" \
+    "reading /home/felipe/reading.csv\n" \
+    "reading '3|📕Trying|Little Library 1970147288'"
 end
 
 if ARGV[1]
@@ -86,11 +93,19 @@ if input_is_csv_path
       result_formatters: Reading::Stats::ResultFormatters::TERMINAL,
     )
 
-    print_grouped_results(results, GROUP_HEADING_FORMATTERS)
+    if results.is_a?(Array) && results.first.is_a?(Reading::Item) # `debug` operation
+      r = results
+      puts PASTEL.red.bold("Enter 'c' to leave the debugger.")
+      debugger
+    else
+      print_grouped_results(results, GROUP_HEADING_FORMATTERS)
+    end
   rescue Reading::Error => e
     puts e
   end
 else # CSV string arg
+  input = input.gsub("\\|", "|") # because some pipes are escaped when pasting into the terminal
+
   begin
     item_hashes = Reading.parse(lines: input, hash_output: true, item_view: false)
   rescue Reading::Error => e

data/lib/reading/config.rb

@@ -178,8 +178,8 @@ module Reading
                     spans:
                       [{
                         dates: nil,
-                        progress: 1.0,
                         amount: 0,
+                        progress: 1.0,
                         name: nil,
                         favorite?: false,
                       }],

data/lib/reading/item.rb

@@ -119,12 +119,11 @@ module Reading
       before_index = nil
       middle_indices = experiences.map.with_index { |experience, i|
         if experience.spans.first.dates &&
-          experience.spans.first.dates.begin < date &&
-          experience.last_end_date
+          experience.spans.first.dates.begin < date
 
           before_index = i
 
-          if experience.last_end_date >= date
+          if (experience.last_end_date || Date.today) >= date
             i
           else
             nil
@@ -133,15 +132,14 @@ module Reading
       }
       .compact
 
-      # There are no experiences with done spans that overlap the date.
+      # There are no experiences with spans that overlap the date.
       if middle_indices.none?
         # The Item is planned.
         return [] if experiences.none? { _1.spans.first.dates }
         # date is after all spans.
         return [self, nil] if experiences.all? { _1.last_end_date && date > _1.last_end_date }
-        # date is before all spans, or overlaps with an in-progress span.
-        return [nil, self] if experiences.all? { _1.spans.first.dates.begin >= date } ||
-          experiences.any? { _1.spans.first.dates.begin < date && _1.last_end_date.nil? }
+        # date is before all spans.
+        return [nil, self] if experiences.all? { _1.spans.first.dates.begin >= date }
 
         # Date is in between experiences.
         if before_index
@@ -173,7 +171,7 @@ module Reading
             if span.dates && span.dates.begin < date
               before_index = i
 
-              span.dates.end >= date
+              (span.dates.end || Date.today) >= date
             end
           }
 
@@ -183,15 +181,20 @@ module Reading
         else
           span_middle = experience_middle.spans[span_middle_index]
 
+          unless span_middle.dates.end
+            end_today_instead_of_endless = { dates: span_middle.dates.begin..Date.today }
+            span_middle = span_middle.to_h.merge(end_today_instead_of_endless).to_data
+          end
+
           dates_before = span_middle.dates.begin..date.prev_day
-          amount_before = span_middle.amount * (dates_before.count / span_middle.dates.count.to_f)
+          amount_before = (span_middle.amount || 0) * (dates_before.count / span_middle.dates.count.to_f)
           span_middle_before = span_middle.with(
             dates: dates_before,
             amount: amount_before,
           )
 
           dates_after = date..span_middle.dates.end
-          amount_after = span_middle.amount * (dates_after.count / span_middle.dates.count.to_f)
+          amount_after = (span_middle.amount || 0) * (dates_after.count / span_middle.dates.count.to_f)
           span_middle_after = span_middle.with(
             dates: dates_after,
             amount: amount_after,

data/lib/reading/parsing/attributes/experiences/dates_and_head_transformer.rb

@@ -29,7 +29,10 @@ module Reading
             start_dates = Array.new(size) { |i| parsed_row[:start_dates]&.dig(i) || {} }
             end_dates = Array.new(size) { |i| parsed_row[:end_dates]&.dig(i) || nil }
 
-            start_end_dates = start_dates.zip(end_dates).presence || [[{}, nil]]
+            start_end_dates = start_dates
+              .reject { _1[:planned] }
+              .zip(end_dates)
+              .presence || [[{}, nil]]
 
             experiences_with_dates = start_end_dates.map { |start_entry, end_entry|
               {
@@ -85,12 +88,14 @@ module Reading
               parsed_row[:head][head_index][:format]
             length = Attributes::Shared.length(parsed_row[:sources]&.dig(variant_index), format:) ||
               Attributes::Shared.length(parsed_row[:length], format:)
+            no_end_date = !dates.end if dates &&
+              Config.hash.fetch(:enabled_columns).include?(:end_dates)
 
             [
               {
                 dates: dates,
                 amount: (length if dates),
-                progress: Attributes::Shared.progress(start_entry) ||
+                progress: Attributes::Shared.progress(start_entry, no_end_date:) ||
                   Attributes::Shared.progress(parsed_row[:head][head_index]) ||
                   (1.0 if end_entry),
                 name: span_template.fetch(:name),

data/lib/reading/parsing/attributes/experiences/history_transformer.rb

@@ -1,5 +1,16 @@
 require_relative 'spans_validator'
 
+# TODO Refactor! This entire file has become 🤢🤮 with the accumulation of new
+# features in the History column.
+#
+# Goals of the refactor:
+#   - if possible, avoid daily_spans; build spans with date ranges directly.
+#   - validate spans at every step; that way the origin of bugs will be easier
+#     to find, e.g. for the bug fixed in 6310639, spans became invalid in
+#     #fix_open_ranges! and led to an error elsewhere that didn't give a trace
+#     back to the origin.
+#   - to facilitate the points above, create a class ExperienceBuilder to
+#     contain much of the logic that is currently in this file.
 module Reading
   module Parsing
     module Attributes
@@ -16,13 +27,14 @@ module Reading
           # many days, for example.
           AVERAGE_DAYS_IN_A_MONTH = 30.437r
 
-          private attr_reader :parsed_row, :head_index
+          private attr_reader :parsed_row, :head_index, :next_open_range_id
 
           # @param parsed_row [Hash] a parsed row (the intermediate hash).
           # @param head_index [Integer] current item's position in the Head column.
           def initialize(parsed_row, head_index)
             @parsed_row = parsed_row
             @head_index = head_index
+            @next_open_range_id = 0
           end
 
           # Extracts experiences from the parsed row.
@@ -61,16 +73,21 @@ module Reading
               month: nil,
               day: nil,
               after_single_date: false,
-              open_range: false,
+              open_range_id: nil,
               planned: false,
               amount: nil,
+              repetitions: nil,
+              frequency: nil,
               last_start_year: nil,
               last_start_month: nil,
             }
 
+            # Dates after "not" entries.
+            except_dates = []
+
             entries.each do |entry|
               if entry[:except_dates]
-                reject_exception_dates!(entry, daily_spans, active)
+                except_dates += reject_exception_dates!(entry, daily_spans, active)
                 next
               end
 
@@ -79,10 +96,14 @@ module Reading
 
             spans = merge_daily_spans(daily_spans)
 
-            fix_open_ranges!(spans)
+            spans = fix_open_ranges(spans, except_dates)
 
             relativize_amounts_from_progress!(spans)
 
+            remove_last_end_date_of_today_if_open_range!(spans)
+
+            remove_temporary_keys!(spans)
+
             spans
           end
 
@@ -92,6 +113,7 @@ module Reading
           #   date-and-name combination.
           # @param active [Hash] variables that persist across entries, such as
           #   amount and implied date.
+          # @return [Array<Date>] the rejected dates.
           def reject_exception_dates!(entry, daily_spans, active)
             except_active = {
               year: active[:last_start_year],
@@ -122,6 +144,8 @@ module Reading
             daily_spans.reject! do |(date, _name), _span|
               except_dates.include?(date)
             end
+
+            except_dates
           end
 
           # Expands the given entry into one span per day, then adds them to daily_spans.
@@ -145,7 +169,7 @@ module Reading
             active[:month] = start_month if start_month
             active[:last_start_month] = active[:month]
             if start_day
-              active[:open_range] = false
+              active[:open_range_id] = nil
               active[:day] = start_day
             end
 
@@ -159,8 +183,8 @@ module Reading
               active[:planned] = false
             end
 
-            duplicate_open_range = !start_day && active[:open_range]
-            date_range = date_range(entry, active, duplicate_open_range:)
+            duplicate_open_range_id = active[:open_range_id] if !start_day
+            date_range = date_range(entry, active, duplicate_open_range: !!duplicate_open_range_id)
 
             # A startless date range (i.e. with an implied start date) appearing
             # immediately after a single date has its start date bumped forward
@@ -174,13 +198,15 @@ module Reading
             format = parsed_row[:sources]&.dig(variant_index)&.dig(:format) ||
               parsed_row[:head][head_index][:format]
 
-            amount =
-              Attributes::Shared.length(entry, format:, key_name: :amount, ignore_repetitions: true) ||
-              Attributes::Shared.length(parsed_row[:length], format:, episodic: true)
-            active[:amount] = amount if amount
-
             progress = Attributes::Shared.progress(entry)
 
+            amount_from_entry =
+              Attributes::Shared.length(entry, format:, key_name: :amount, ignore_repetitions: true)
+            amount_from_length =
+              Attributes::Shared.length(parsed_row[:length], format:, episodic: progress.nil? || parsed_row.dig(:length, :repetitions).nil?)
+            amount = amount_from_entry || amount_from_length
+            active[:amount] = amount if amount
+
             # If the entry has no amount and the item has no episodic length,
             # then use progress as amount instead. The typical scenario for this
             # is when tracking fixed-length items such as books. See
@@ -195,17 +221,27 @@ module Reading
               amount_from_progress = true
             end
 
-            repetitions = entry[:repetitions]&.to_i || 1
+            repetitions = entry[:repetitions]&.to_i
             frequency = entry[:frequency]
 
+            # If the entry has no amount or progress, default to the previous
+            # repetitions and frequency.
+            unless amount_from_entry || progress || repetitions
+              repetitions = active[:repetitions]
+              frequency = active[:frequency]
+            end
+
+            active[:repetitions] = repetitions if repetitions
+            active[:frequency] = frequency if frequency
+
             amounts_by_date = distribute_amount_across_date_range(
               date_range || Date.new(active[:year], active[:month], active[:day]),
               amount || active[:amount],
-              repetitions,
+              repetitions || 1,
               frequency,
             )
 
-            in_open_range = active[:open_range] || duplicate_open_range
+            open_range_id = active[:open_range_id] || duplicate_open_range_id
 
             daily_spans_from_entry = amounts_by_date.map { |date, daily_amount|
               span_without_dates = {
@@ -219,9 +255,11 @@ module Reading
                 # Temporary keys (not in the final item data) for marking
                 # spans to ...
                 # ... be distributed evenly across an open date range.
-                in_open_range: in_open_range,
+                open_range_id:,
                 # ... have their amounts adjusted to be relative to previous progress.
-                amount_from_progress: amount_from_progress,
+                amount_from_progress?: amount_from_progress,
+                amount_from_frequency?: !!frequency,
+                implied_date_range?: !date_range && !!frequency,
               }
 
               if entry[:planned] || active[:planned]
@@ -232,7 +270,7 @@ module Reading
 
               # For entries in an open range, add a random number to the key to
               # avoid overwriting entries with the same name, or lacking a name.
-              if in_open_range
+              if open_range_id
                 key << rand
               end
 
@@ -285,7 +323,7 @@ module Reading
             return nil unless entry[:range] || duplicate_open_range
 
             if entry[:end_day]
-              active[:open_range] = false
+              active[:open_range_id] = nil
 
               end_year = entry[:end_year]&.to_i
               end_month = entry[:end_month]&.to_i
@@ -299,11 +337,17 @@ module Reading
               date_range = Date.new(active[:year], active[:month], active[:day])..
                 Date.new(end_year || active[:year], end_month || active[:month], end_day)
 
-              active[:day] = end_day + 1
-              active[:month] = end_month if end_month
-              active[:year] = end_year if end_year
+              date_after_end = date_range.end.next_day
+
+              active[:day] = date_after_end.day
+              active[:month] = date_after_end.month if end_month
+              active[:year] = date_after_end.year if end_year
             else # either starting or continuing (duplicating) an open range
-              active[:open_range] ||= true
+              unless active[:open_range_id]
+                active[:open_range_id] = next_open_range_id
+                @next_open_range_id += 1
+              end
+
               date_range = Date.new(active[:year], active[:month], active[:day])..Date.today
             end
 
@@ -316,7 +360,7 @@ module Reading
           # @param amount [Float, Integer, Item::TimeLength] amount in
           #   pages or time.
           # @param repetitions [Integer] e.g. "x4" in a History entry.
-          # @param frequency [Integer] e.g. "/week" in a History entry.
+          # @param frequency [String] e.g. "/week" in a History entry.
           # @return [Hash{Date => Float, Integer, Item::TimeLength}]
           def distribute_amount_across_date_range(date_or_range, amount, repetitions, frequency)
             unless amount
@@ -366,33 +410,64 @@ module Reading
           # Set each open date range's last end date (wherever it's today, i.e.
           # it wasn't defined) to the day before the next entry's start date.
           # At the same time, distribute each open range's spans evenly.
-          # Lastly, remove the :in_open_range key from spans.
+          # Lastly, remove the :open_range_id key from spans.
           # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @param except_dates [Date] dates after "not" entries which were
+          #   rejected from spans.
           # @return [Array<Hash>]
-          def fix_open_ranges!(spans)
+          def fix_open_ranges(spans, except_dates)
             chunked_by_open_range = spans.chunk_while { |a, b|
               a[:dates] && b[:dates] && # in case of planned entry
-              a[:dates].begin == b[:dates].begin &&
-                a[:in_open_range] == b[:in_open_range]
+                a[:open_range_id] == b[:open_range_id]
             }
 
-            next_chunk_start_date = nil
+            next_start_date = nil
             chunked_by_open_range
-              .reverse_each { |chunk|
-                unless chunk.first[:in_open_range] && chunk.any? { _1[:dates].end == Date.today }
+              .to_a.reverse.map { |chunk|
+                unless chunk.first[:open_range_id]
                   # safe nav. in case of planned entry
-                  next_chunk_start_date = chunk.first[:dates]&.begin
-                  next
+                  next_start_date = chunk.first[:dates]&.begin
+                  next chunk
+                end
+
+                # Filter out spans that begin after the next chunk's start date.
+                if next_start_date
+                  chunk.reject! do |span|
+                    span[:dates].begin >= next_start_date
+                  end
+                end
+
+                # For the remaining spans (which begin before the next chunk's
+                # start date), bound each end date to that date.
+                chunk.reverse_each do |span|
+                  if !next_start_date
+                    next_start_date = span[:dates].begin
+                    next
+                  end
+
+                  if span[:dates].end >= next_start_date
+                    new_dates = span[:dates].begin..next_start_date.prev_day
+
+                    if span[:amount_from_frequency?]
+                      new_to_old_dates_ratio = new_dates.count / span[:dates].count.to_f
+                      span[:amount] = (span[:amount] * new_to_old_dates_ratio).to_i_if_whole
+                    end
+
+                    span[:dates] = new_dates
+                  end
+
+                  next_start_date = span[:dates].begin if span[:dates].begin < next_start_date
                 end
 
-                # Set last end date.
-                if chunk.last[:dates].end == Date.today && next_chunk_start_date
-                  chunk.last[:dates] = chunk.last[:dates].begin..next_chunk_start_date.prev_day
+                if !next_start_date || chunk.first[:dates].begin < next_start_date
+                  next_start_date = chunk.first[:dates].begin
                 end
-                next_chunk_start_date = chunk.first[:dates].begin
+
+                next chunk if chunk.map { |span| span[:open_range_id] }.uniq.count == 1 &&
+                  chunk.map { |span| span[:dates].begin }.uniq.count > 1
 
                 # Distribute spans across the open date range.
-                total_amount = chunk.sum { |c| c[:amount] }
+                total_amount = chunk.sum { |span| span[:amount] }
                 dates = chunk.last[:dates]
                 amount_per_day = total_amount / dates.count.to_f
 
@@ -400,6 +475,7 @@ module Reading
                 last_end_date = chunk.last[:dates].end
 
                 span = nil
+                chunk_dup = chunk.dup
                 amount_acc = 0
                 span_needing_end = nil
                 dates.each do |date|
@@ -409,8 +485,8 @@ module Reading
                   end
 
                   while amount_acc < amount_per_day
-                    break if chunk.empty?
-                    span = chunk.shift
+                    break if chunk_dup.empty?
+                    span = chunk_dup.shift
                     amount_acc += span[:amount]
 
                     if amount_acc < amount_per_day
@@ -427,11 +503,11 @@ module Reading
                 end
 
                 span[:dates] = span[:dates].begin..last_end_date
-              }
 
-            spans.each do |span|
-              span.delete(:in_open_range)
-            end
+                chunk
+              }
+              .reverse
+              .flatten
           end
 
           # Changes amounts taken from progress, from absolute to relative,
@@ -443,15 +519,42 @@ module Reading
           def relativize_amounts_from_progress!(spans)
             amount_acc = 0
             spans.each do |span|
-              if span[:amount_from_progress]
+              if span[:amount_from_progress?]
                 span[:amount] -= amount_acc
               end
 
               amount_acc += span[:amount]
             end
+          end
+
+          # Removes the end date from the last span if it's today, and if it was
+          # written as an open range.
+          # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @return [Array<Hash>]
+          def remove_last_end_date_of_today_if_open_range!(spans)
+            if spans.last[:dates] &&
+              spans.last[:dates].end == Date.today &&
+              (spans.last[:open_range_id] || spans.last[:implied_date_range?])
+
+              spans.last[:dates] = spans.last[:dates].begin..
+            end
+          end
+
+          # Removes all keys that shouldn't be in the final item data.
+          # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @return [Array<Hash>]
+          def remove_temporary_keys!(spans)
+            temporary_keys = %i[
+              open_range_id
+              amount_from_progress?
+              amount_from_frequency?
+              implied_date_range?
+            ]
 
             spans.each do |span|
-              span.delete(:amount_from_progress)
+              temporary_keys.each do |key|
+                span.delete(key)
+              end
             end
           end
         end

data/lib/reading/parsing/attributes/experiences/spans_validator.rb

@@ -15,7 +15,7 @@ module Reading
             #   experiences from the History column.
             # @raise [InvalidDateError] if any date is invalid.
             def validate(experiences, history_column: false)
-              if both_date_columns?
+              if both_date_columns? && !history_column
                 validate_number_of_start_dates_and_end_dates(experiences)
               end
 
@@ -131,7 +131,7 @@ module Reading
                       end
                     end
                     .each_cons(2) do |a, b|
-                      if a.begin > b.begin || a.end > b.end
+                      if a.begin > b.begin || (a.end || Date.today) > (b.end || Date.today)
                         raise InvalidDateError, "Dates are not in order"
                       end
                       if a.cover?(b.begin + 1)

data/lib/reading/parsing/attributes/shared.rb

@@ -9,13 +9,16 @@ module Reading
         # Extracts the :progress sub-attribute (percent, pages, or time) from
         # the given hash.
         # @param hash [Hash] any parsed hash that contains progress.
+        # @param no_end_date [Boolean] for start and end dates (as opposed to
+        #   the History column), whether an end date is present.
         # @return [Float, Integer, Item::TimeLength]
-        def self.progress(hash)
+        def self.progress(hash, no_end_date: nil)
           hash[:progress_percent]&.to_f&./(100) ||
             hash[:progress_pages]&.to_i ||
             hash[:progress_time]&.then { Item::TimeLength.parse(_1) } ||
             (0 if hash[:progress_dnf]) ||
             (1.0 if hash[:progress_done]) ||
+            (0.0 if no_end_date) ||
             nil
         end
 

data/lib/reading/parsing/rows/regular_columns/sources.rb

@@ -91,7 +91,7 @@ module Reading
 
           private
 
-          ISBN_REGEX = /(\d{3}[-\s]?)?\d{10}/
+          ISBN_REGEX = /(\d{3}[-\s]?)?(\d{10}|\d{9}X)/
           ASIN_REGEX = /B0[A-Z\d]{8}/
         end
       end

data/lib/reading/parsing/rows/regular_columns/start_dates.rb

@@ -16,7 +16,11 @@ module Reading
                 (\s+|\z)
               )?
               (
-                (?<date>\d{4}/\d\d?/\d\d?)
+                (
+                  (?<date>\d{4}/\d\d?/\d\d?)
+                  |
+                  (?<planned>\?\?)
+                )
                 (\s+|\z)
               )?
               (

data/lib/reading/stats/grouping.rb

@@ -119,7 +119,9 @@ module Reading
               .compact
               .max
 
-            year_ranges = (begin_date.year..end_date.year).flat_map { |year|
+            end_year = [Date.today.year, end_date.year].min
+
+            year_ranges = (begin_date.year..end_year).flat_map { |year|
               beginning_of_year = Date.new(year, 1, 1)
               end_of_year = Date.new(year + 1, 1, 1).prev_day
 
@@ -191,7 +193,7 @@ module Reading
             groups
           end
         },
-        genre: proc { |items|
+        eachgenre: proc { |items|
           groups = Hash.new { |h, k| h[k] = [] }
 
           items.each do |item|
@@ -200,6 +202,18 @@ module Reading
 
           groups.sort.to_h
         },
+        genre: proc { |items|
+          groups = Hash.new { |h, k| h[k] = [] }
+
+          items.each do |item|
+            if item.genres.any?
+              genre_combination = item.genres.sort.join(", ")
+              groups[genre_combination] << item
+            end
+          end
+
+          groups.sort.to_h
+        },
         length: proc { |items|
           boundaries = Config.hash.fetch(:length_group_boundaries)
 

data/lib/reading/stats/operation.rb

@@ -50,14 +50,14 @@ module Reading
       # Items) of the given hash of grouped items.
       # @param grouped_items [Hash]
       # @yield [Array<Item>]
-      def self.apply_to_inner_items(grouped_items, &)
+      def self.apply_to_inner_items(grouped_items, &block)
         if grouped_items.values.first.is_a? Array
           grouped_items.transform_values! { |inner_items|
             yield inner_items
           }
         else # It's a Hash, so go one level deeper.
           grouped_items.each do |group_name, grouped|
-            apply_to_inner_items(grouped, &)
+            apply_to_inner_items(grouped, &block)
           end
         end
       end
@@ -89,7 +89,7 @@ module Reading
             (lengths.sum / lengths.count.to_f).to_i_if_whole
           end
         },
-        :"average_amount" => proc { |items|
+        average_amount: proc { |items|
           total_amount = items.sum { |item|
             item.experiences.sum { |experience|
               experience.spans.sum(&:amount)
@@ -105,6 +105,9 @@ module Reading
             amounts_by_date.values.sum / amounts_by_date.count
           end
         },
+        list_item: proc { |items|
+          items.map { |item| author_and_title(item) }
+        },
         total_item: proc { |items|
           items.count
         },
@@ -119,12 +122,24 @@ module Reading
         },
         top_rating: proc { |items, number_arg|
           items
-            .max_by(number_arg || DEFAULT_NUMBER_ARG, &:rating)
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { _1.rating || 0}
             .map { |item| [author_and_title(item), item.rating] }
         },
         top_length: proc { |items, number_arg|
           items
-            .map { |item| [author_and_title(item), item.variants.map(&:length).max] }
+            .map { |item|
+              [
+                author_and_title(item),
+                # Longest length, or if undefined length then longest experience
+                # (code adapted from top_amount below).
+                item.variants.map(&:length).max ||
+                  item.experiences.map { |experience|
+                    experience.spans.sum { |span|
+                      (span.amount * span.progress).to_i_if_whole
+                    }
+                  }.max,
+              ]
+            }
             .reject { |_title, length| length.nil? }
             .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length| length }
         },
@@ -152,12 +167,24 @@ module Reading
         },
         bottom_rating: proc { |items, number_arg|
           items
-            .min_by(number_arg || DEFAULT_NUMBER_ARG, &:rating)
+            .min_by(number_arg || DEFAULT_NUMBER_ARG) { _1.rating || 0}
             .map { |item| [author_and_title(item), item.rating] }
         },
         bottom_length: proc { |items, number_arg|
           items
-            .map { |item| [author_and_title(item), item.variants.map(&:length).max] }
+            .map { |item|
+              [
+                author_and_title(item),
+                # Longest length, or if undefined length then longest experience
+                # (code adapted from bottom_amount below).
+                item.variants.map(&:length).max ||
+                  item.experiences.map { |experience|
+                    experience.spans.sum { |span|
+                      (span.amount * span.progress).to_i_if_whole
+                    }
+                  }.max,
+              ]
+            }
             .reject { |_title, length| length.nil? }
             .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length| length }
         },
@@ -183,6 +210,9 @@ module Reading
               speed_hash[:amount] / speed_hash[:days].to_f
             }
         },
+        debug: proc { |items|
+          items
+        },
       }
 
       ALIASES = {
@@ -190,6 +220,7 @@ module Reading
         average_length: %w[al],
         average_amount: %w[aia ai],
         :"average_daily-amount" => %w[ada ad],
+        list_item: %w[li list],
         total_item: %w[item count],
         total_amount: %w[amount],
         top_rating: %w[tr],
@@ -200,6 +231,7 @@ module Reading
         bottom_length: %w[bl],
         bottom_amount: %w[ba],
         bottom_speed: %w[bs],
+        debug: %w[d],
       }
 
       REGEXES = ACTIONS.map { |key, _action|

data/lib/reading/util/hash_array_deep_fetch.rb

@@ -1,31 +1,9 @@
 module Reading
   module Util
-    class FetchDepthExceededError < StandardError
-    end
-
     # Similar to Array#dig and Hash#dig but raises an error for not found elements.
-    #
-    # More flexible but slightly slower alternative:
-    #   keys.reduce(self) { |a, e| a.fetch(e) }
-    #
-    # See performance comparisons:
-    # https://fpsvogel.com/posts/2022/ruby-hash-dot-syntax-deep-fetch
     module HashArrayDeepFetch
       def deep_fetch(*keys)
-        case keys.length
-        when 1
-          fetch(keys[0])
-        when 2
-          fetch(keys[0]).fetch(keys[1])
-        when 3
-          fetch(keys[0]).fetch(keys[1]).fetch(keys[2])
-        when 4
-          fetch(keys[0]).fetch(keys[1]).fetch(keys[2]).fetch(keys[3])
-        when 5
-          fetch(keys[0]).fetch(keys[1]).fetch(keys[2]).fetch(keys[3]).fetch(keys[4])
-        else
-          raise FetchDepthExceededError, "#deep_fetch can't fetch that deep!"
-        end
+        keys.reduce(self) { |a, e| a.fetch(e) }
       end
 
       refine Hash do

data/lib/reading/version.rb

@@ -1,3 +1,3 @@
 module Reading
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reading
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Felipe Vogel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-15 00:00:00.000000000 Z
+date: 2024-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: amazing_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -94,20 +108,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: amazing_print
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rubycritic
   requirement: !ruby/object:Gem::Requirement
@@ -189,23 +189,23 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/fpsvogel/reading
   source_code_uri: https://github.com/fpsvogel/reading
-  changelog_uri: https://github.com/fpsvogel/reading/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/fpsvogel/reading/blob/main/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.5.15
 signing_key: 
 specification_version: 4
 summary: Parses a CSV reading log.