reading 1.0.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 731cc9d7bf42123b5627cc5bd498c317cf1f60faed19d75010bf01d360945cf3
-  data.tar.gz: 6e74543ddfd36e7a3221b7c668797106d1082805a62be57aade5c32266a45b27
+  metadata.gz: 4bf09fbcc2e77924a371eade404c83ad4fd5c3d7576eac45d0c1236c3db479f6
+  data.tar.gz: f854509f8ae88553df964428d18098fceeb3c885093728c2f54bba530199c8cb
 SHA512:
-  metadata.gz: a6ee081473b294836ac9ad2d787283460de4563b3725548cae3447001a1f6d29e3435bc13fe1185fb84a167942c7fa3c040c5610685d389f7a541b6c5a739e42
-  data.tar.gz: 6b67433e096a8111bf15582fdc3b409beef982636446ec71f2ca0916b7366253087c38877bb8ffc7dbf25e2cdaf2acc3075388412072ca6c88c4b2a633558e62
+  metadata.gz: a285b194b566697bd586628d1266ed5582e1cfab48dc3023e243635e4b21b3f31f100cf4b41a1777358b70175c15a8b2d57d7589859697c917e1914f452e492e
+  data.tar.gz: 6aa82f83175a22cd652b545aa46935ba5ef72009d33b8bbcd35a6667e1c2081cbe708fce40703503027aaf5938c5020a475fea9575d6e5d45fe75bef49233b4e

data/bin/reading

@@ -1,15 +1,15 @@
 #!/usr/bin/env ruby
 
-# Starts the reading statistics interactive CLI, if a CSV file path arg is given.
-# If a CSV string is given instead, then parsing output (item hashes) is displayed.
+# Runs a reading statistics query, if a file path arg (CSV or TXT)is given.
+# If a non-path string is given, then displays parsed output (item Hashes).
 #
 # Usage:
 # Run on the command line:
-#   reading "<CSV file path or string>" "<optional comma-separated names of enabled columns>"
+#   reading "<file path or entry string>" "<query, if file path>" "<optional comma-separated names of enabled columns>"
 #
 # Examples:
-#   reading /home/felipe/reading.csv
-#   reading /home/felipe/reading.csv 'head, sources'
+#   reading /home/felipe/reading.csv 'amount by year'
+#   reading /home/felipe/reading.csv 'amount by year' 'head, sources'
 #   reading '3|📕Trying|Little Library 1970147288'
 #   reading '📕Trying|Little Library 1970147288' 'head, sources'
 
@@ -17,29 +17,15 @@ require_relative "../lib/reading"
 require_relative "../lib/reading/stats/result_formatters"
 require "debug"
 require "amazing_print"
-require "readline"
 require "pastel"
 
-EXIT_COMMANDS = %w[exit e quit q]
 PASTEL = Pastel.new
-GROUP_HEADING_FORMATTERS = [
-  -> { PASTEL.magenta.bold.underline(_1) },
-  -> { PASTEL.green.bold.underline(_1) },
-  -> { PASTEL.yellow.bold.underline(_1) },
-  -> { PASTEL.cyan.bold.underline(_1) },
-  -> { PASTEL.magenta.on_white(_1) },
-  -> { PASTEL.green.on_white(_1) },
-  -> { PASTEL.yellow.on_white(_1) },
-]
 
 # Recursively prints a hash of results (possibly grouped).
 # @param grouped_results [Hash, Array]
-# @param group_heading_formatters [Array<Proc>] a subset of GROUP_HEADING_FORMATTERS
-def print_grouped_results(grouped_results, group_heading_formatters)
-  indent_level = GROUP_HEADING_FORMATTERS.count - group_heading_formatters.count
-
+def print_grouped_results(grouped_results)
   if grouped_results.nil? || (grouped_results.respond_to?(:empty?) && grouped_results.empty?)
-    puts "  " * indent_level + PASTEL.bright_black("none") + "\n"
+    puts "none\n"
     return
   end
 
@@ -47,70 +33,93 @@ def print_grouped_results(grouped_results, group_heading_formatters)
     (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..])
+      group_name  = group_name.nil? ? "(none)" : group_name
+      puts "# #{group_name}"
+      print_grouped_results(grouped)
     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"
+    puts grouped_results.join("\n") + "\n\n"
   else
-    puts "  " * indent_level + grouped_results.to_s + "\n"
+    puts grouped_results.to_s + "\n\n"
   end
 end
 
-input = ARGV[0]
-unless input
-  raise ArgumentError,
-    "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]
-  enabled_columns = ARGV[1].split(",").map(&:strip).map(&:to_sym)
-  Reading::Config.build(enabled_columns:)
+# Builds a Reading::Config from a comma-separated string of column names.
+# @param enabled_columns_str [String, nil]
+def build_config(enabled_columns_str:)
+  if enabled_columns_str
+    enabled_columns = enabled_columns_str.split(",").map(&:strip).map(&:to_sym)
+    Reading::Config.build(enabled_columns:)
+  end
 end
 
-input_is_csv_path = input.end_with?(".csv") || input.end_with?(".txt")
+# Runs a stats query on a file at the given path, and prints the results.
+# @param file_path [String] path to a CSV or TXT file.
+# @param query [String] the stats query to run.
+# @param enabled_columns_str [String, nil] comma-separated string of enabled column names.
+def run_query(file_path:, query:, enabled_columns_str:)
+  return if query.blank?
 
-if input_is_csv_path
+  build_config(enabled_columns_str: ARGV[2])
   error_handler = ->(e) { puts "Skipped a row due to a parsing error: #{e}" }
 
-  items = Reading.parse(path: input, item_view: false, error_handler:)
-
-  loop do
-    raw_input = Readline.readline(PASTEL.bright_cyan("> "), true)
-
-    exit if EXIT_COMMANDS.include?(raw_input)
-
-    input = raw_input.presence
-    next if raw_input.blank?
-
-    results = Reading.stats(
-      input:,
-      items:,
-      result_formatters: Reading::Stats::ResultFormatters::TERMINAL,
-    )
-
-    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
+  items = Reading.parse(path: file_path, item_view: false, error_handler:)
+  results = Reading.stats(
+    input: query,
+    items:,
+    result_formatters: Reading::Stats::ResultFormatters::TERMINAL,
+  )
+
+  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)
   end
-else # CSV string arg
-  input = input.gsub("\\|", "|") # because some pipes are escaped when pasting into the terminal
+rescue Reading::Error => e
+  puts e
+end
+
+# Parses a string of one or more reading log entries, and prints the resulting item Hashes.
+# @param entry [String] one or more reading log entries, separated by newlines.
+# @param enabled_columns_str [String, nil] comma-separated string of enabled column names.
+def print_parsed(entry:, enabled_columns_str:)
+  build_config(enabled_columns_str:)
+  entry = entry.gsub("\\|", "|") # because some pipes are escaped when pasting into the terminal
 
   begin
-    item_hashes = Reading.parse(lines: input, hash_output: true, item_view: false)
+    item_hashes = Reading.parse(lines: entry, hash_output: true, item_view: false)
   rescue Reading::Error => e
     puts "Skipped a row due to a parsing error: #{e}"
   end
 
   ap item_hashes
 end
+
+#################################################
+# Script execution starts here.
+#################################################
+
+input = ARGV[0]
+unless input
+  raise ArgumentError,
+    "First argument required, either a CSV/TXT file path or a reading log entry string.\nExamples:\n" \
+    "  reading /home/felipe/reading.csv\n" \
+    "  reading '3|📕Trying|Little Library 1970147288'"
+end
+
+input_is_file_path = input.end_with?(".csv") || input.end_with?(".txt")
+
+if input_is_file_path
+  query = ARGV[1]
+  unless query
+    raise ArgumentError,
+      "Second argument required, the stats query to run.\nExample:\n" \
+      "  reading /home/felipe/reading.csv 'amount by year'" \
+  end
+
+  run_query(file_path: input, query:, enabled_columns_str: ARGV[2])
+else
+  print_parsed(entry: input, enabled_columns_str: ARGV[1])
+end

data/lib/reading/item/time_length.rb

@@ -2,7 +2,7 @@ module Reading
   class Item
     # The length of an item when it is a time, as opposed to pages. (Pages are
     # represented simply with an Integer or Float.)
-    class Item::TimeLength
+    class TimeLength
       include Comparable
 
       attr_reader :value # in total minutes
@@ -12,17 +12,17 @@ module Reading
         @value = value
       end
 
-      # Builds an Item::TimeLength from a string.
+      # Builds a TimeLength from a string.
       # @param string [String] a time duration in "h:mm" format.
       # @return [TimeLength, nil]
       def self.parse(string)
-        return nil unless string.match? /\A\d+:\d\d\z/
+        return nil unless string.match?(/\A\d+:\d\d\z/)
 
         hours, minutes = string.split(":").map(&:to_i)
         new((hours * 60) + minutes)
       end
 
-      # Builds an Item::TimeLength based on a page count.
+      # Builds a TimeLength based on a page count.
       # @param pages [Integer, Float]
       # @return [TimeLength]
       def self.from_pages(pages)
@@ -74,7 +74,9 @@ module Reading
       # Converts @value to an Integer if it's a whole number, and returns self.
       # @return [TimeLength]
       def to_i_if_whole!
-        if @value.to_i == @value
+        if @value.is_a?(Float) && @value.nan?
+          @value = 0
+        elsif @value.to_i == @value
           @value = @value.to_i
         end
 
@@ -85,32 +87,36 @@ module Reading
       # refinement Numeric#to_i_if_whole.
       # @return [TimeLength]
       def to_i_if_whole
-        return self if @value.is_a?(Integer) || @value.to_i != @value
+        if @value.is_a?(Float) && @value.nan?
+          return self.class.new(0)
+        else
+          return self if @value.is_a?(Integer) || @value.to_i != @value
 
-        self.class.new(@value.to_i)
+          self.class.new(@value.to_i)
+        end
       end
 
       # @param other [TimeLength, Numeric]
       # @return [TimeLength]
       def +(other)
-        if other.is_a? Item::TimeLength
+        if other.is_a? TimeLength
           self.class.new(value + other.value)
         elsif other.is_a? Numeric
           self.class.new(value + self.class.pages_to_minutes(other))
         else
-          raise TypeError, "#{other.class} can't be added to Item::TimeLength."
+          raise TypeError, "#{other.class} can't be added to TimeLength."
         end
       end
 
       # @param other [TimeLength, Numeric]
       # @return [TimeLength]
       def -(other)
-        if other.is_a? Item::TimeLength
+        if other.is_a? TimeLength
           self.class.new(value - other.value)
         elsif other.is_a? Numeric
           self.class.new(value - self.class.pages_to_minutes(other))
         else
-          raise TypeError, "#{other.class} can't be subtracted from Item::TimeLength."
+          raise TypeError, "#{other.class} can't be subtracted from TimeLength."
         end
       end
 
@@ -134,6 +140,17 @@ module Reading
         end
       end
 
+      # For relativizing progress to a percentage of amount.
+      # @param other [TimeLength, Numeric]
+      # @return [TimeLength]
+      def percentage_of(other)
+        if other.is_a? TimeLength
+          value.to_f / other.value
+        else
+          raise TypeError, "TimeLength can't be percent-divided by #{other.class}."
+        end
+      end
+
       # See https://web.archive.org/web/20221206095821/https://www.mutuallyhuman.com/blog/class-coercion-in-ruby/
       # @param other [Numeric]
       def coerce(other)
@@ -153,7 +170,7 @@ module Reading
           other = self.class.from_pages(other)
         end
 
-        unless other.is_a? Item::TimeLength
+        unless other.is_a? TimeLength
           raise TypeError, "TimeLength can't be compared to #{other.class} #{other}."
         end
 

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

@@ -90,14 +90,28 @@ module Reading
               Attributes::Shared.length(parsed_row[:length], format:)
             no_end_date = !dates.end if dates &&
               Config.hash.fetch(:enabled_columns).include?(:end_dates)
+            progress = Attributes::Shared.progress(start_entry, no_end_date:) ||
+              Attributes::Shared.progress(parsed_row[:head][head_index]) ||
+              (1.0 if end_entry)
+            amount =
+              if dates && length
+                length
+              elsif !progress.is_a?(Float)
+                progress
+              end
+
+            # Change progress from absolute to relative (percentage) if amount is given.
+            if amount && progress && !progress.is_a?(Float)
+              amount_time = amount.is_a?(Item::TimeLength) ? amount : Item::TimeLength.from_pages(amount)
+              progress_time = progress.is_a?(Item::TimeLength) ? progress : Item::TimeLength.from_pages(progress)
+              progress = progress_time.percentage_of(amount_time)
+            end
 
             [
               {
-                dates: dates,
-                amount: (length if dates),
-                progress: Attributes::Shared.progress(start_entry, no_end_date:) ||
-                  Attributes::Shared.progress(parsed_row[:head][head_index]) ||
-                  (1.0 if end_entry),
+                dates:,
+                amount:,
+                progress:,
                 name: span_template.fetch(:name),
                 favorite?: span_template.fetch(:favorite?),
               }.map { |k, v| [k, v || span_template.fetch(k)] }.to_h

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

@@ -212,15 +212,22 @@ module Reading
             # is when tracking fixed-length items such as books. See
             # https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#history-pages-and-stopping-points-books
             if !amount && progress
-              if progress.is_a? Float
+              if progress.is_a?(Float)
                 total_length = Attributes::Shared.length(parsed_row[:length], format:)
-                amount = total_length * progress
+                amount = total_length * progress if total_length
               else
                 amount = progress
               end
               amount_from_progress = true
             end
 
+            # Change progress from absolute to relative (percentage) if amount is given.
+            if amount && progress && !progress.is_a?(Float)
+              amount_time = amount.is_a?(Item::TimeLength) ? amount : Item::TimeLength.from_pages(amount)
+              progress_time = progress.is_a?(Item::TimeLength) ? progress : Item::TimeLength.from_pages(progress)
+              progress = progress_time.percentage_of(amount_time)
+            end
+
             repetitions = entry[:repetitions]&.to_i
             frequency = entry[:frequency]
 

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

@@ -16,7 +16,7 @@ module Reading
           hash[:progress_percent]&.to_f&./(100) ||
             hash[:progress_pages]&.to_i ||
             hash[:progress_time]&.then { Item::TimeLength.parse(_1) } ||
-            (0 if hash[:progress_dnf]) ||
+            (0.0 if hash[:progress_dnf]) ||
             (1.0 if hash[:progress_done]) ||
             (0.0 if no_end_date) ||
             nil

data/lib/reading/stats/filter.rb

@@ -372,7 +372,7 @@ module Reading
             match = value.match(DATES_REGEX) ||
               (raise InputError,
                 "End date must be in yyyy/[mm] format, or a date range " \
-                "(yyyy/[mm]-[yyyy]/[mm])")
+                "(yyyy/[mm]-yyyy/[mm])")
 
             start_date = Date.new(
               match[:start_year].to_i,

data/lib/reading/stats/grouping.rb

@@ -10,8 +10,6 @@ module Reading
       # @param items [Array<Item>] the Items on which to run the operation.
       # @return [Hash] the return value of the group action(s).
       def self.group(input, items)
-        grouped_items = {}
-
         match = input.match(REGEX)
 
         if match
@@ -80,7 +78,7 @@ module Reading
             end
           end
 
-          groups.sort.to_h
+          groups.sort_by { |key, _items| key }.to_h
         },
         source: proc { |items|
           groups = Hash.new { |h, k| h[k] = [] }
@@ -103,7 +101,7 @@ module Reading
               end
           end
 
-          groups.sort.to_h
+          groups.sort_by { |key, _items| key }.to_h
         },
         year: proc { |items|
           begin_date = items
@@ -187,7 +185,14 @@ module Reading
             end
 
             groups.transform_keys! { |month_range|
-              [month_range.begin.year, month_range.begin.month]
+              array = [month_range.begin.year, month_range.begin.month]
+
+              array.define_singleton_method(:to_s) do
+                map { it.to_s.rjust(2, "0") }
+                  .join("/")
+              end
+
+              array
             }
 
             groups
@@ -200,7 +205,7 @@ module Reading
             item.genres.each { |genre| groups[genre] << item }
           end
 
-          groups.sort.to_h
+          groups.sort_by { |key, _items| key }.to_h
         },
         genre: proc { |items|
           groups = Hash.new { |h, k| h[k] = [] }
@@ -212,7 +217,7 @@ module Reading
             end
           end
 
-          groups.sort.to_h
+          groups.sort_by { |key, _items| key }.to_h
         },
         length: proc { |items|
           boundaries = Config.hash.fetch(:length_group_boundaries)

data/lib/reading/stats/result_formatters.rb

@@ -20,9 +20,9 @@ module Reading
         :"average_daily-amount" => ->(result) { "#{length_to_s(result)} per day" },
         total_item: ->(result) {
           if result.zero?
-            PASTEL.bright_black("none")
+            "none"
           else
-            color("#{result} #{result == 1 ? "item" : "items"}")
+            "#{result} #{result == 1 ? "item" : "items"}"
           end
         },
         total_amount: ->(result) { length_to_s(result) },
@@ -40,44 +40,25 @@ module Reading
 
       private
 
-      PASTEL = Pastel.new
-
-      # Applies a terminal color.
-      # @param string [String]
-      # @return [String]
-      private_class_method def self.color(string)
-        PASTEL.bright_blue(string)
-      end
-
       # Converts a length/amount (pages or time) into a string.
       # @param length [Numeric, Reading::Item::TimeLength]
-      # @param color [Boolean] whether a terminal color should be applied.
       # @return [String]
-      private_class_method def self.length_to_s(length, color: true)
-        if length.is_a?(Numeric)
-          length_string = "#{length.round} pages"
+      private_class_method def self.length_to_s(length)
+        if length.nil? || length.zero?
+          "none"
+        elsif length.is_a?(Numeric)
+          "#{length.round} pages"
         else
-          length_string = length.to_s
+          length.to_s
         end
-
-        color ? color(length_string) : length_string
       end
 
       # Formats a list of top/bottom length results as a string.
       # @param result [Array]
       # @return [String]
       private_class_method def self.top_or_bottom_lengths_string(result)
-        offset = result.count.digits.count
-
         result
-          .map.with_index { |(title, length), index|
-            pad = " " * (offset - (index + 1).digits.count)
-
-            title_line = "#{index + 1}. #{pad}#{title}"
-            indent = "    #{" " * offset}"
-
-            "#{title_line}\n#{indent}#{length_to_s(length)}"
-          }
+          .map { |title, length| "#{title}\n  #{length_to_s(length)}" }
           .join("\n")
       end
 
@@ -85,36 +66,24 @@ module Reading
       # @param result [Array]
       # @return [String]
       private_class_method def self.top_or_bottom_speeds_string(result)
-        offset = result.count.digits.count
-
         result
-          .map.with_index { |(title, hash), index|
-            amount = length_to_s(hash[:amount], color: false)
+          .map { |title, hash|
+            amount = length_to_s(hash[:amount])
             days = "#{hash[:days]} #{hash[:days] == 1 ? "day" : "days"}"
-            pad = " " * (offset - (index + 1).digits.count)
+            speed = "#{amount} in #{days}"
 
-            title_line = "#{index + 1}. #{pad}#{title}"
-            indent = "    #{" " * offset}"
-            colored_speed = color("#{amount} in #{days}")
-
-            "#{title_line}\n#{indent}#{colored_speed}"
+            "#{title}\n  #{speed}"
           }
           .join("\n")
       end
 
       # Formats a list of top/bottom number results as a string.
       private_class_method def self.top_or_bottom_numbers_string(result, noun:)
-        offset = result.count.digits.count
-
         result
-          .map.with_index { |(title, number), index|
-            pad = " " * (offset - (index + 1).digits.count)
-
-            title_line = "#{index + 1}. #{pad}#{title}"
-            indent = "    #{" " * offset}"
-            number_string = color("#{number} #{number == 1 ? noun : "#{noun}s"}")
+          .map { |title, number|
+            number_string = "#{number} #{number == 1 ? noun : "#{noun}s"}"
 
-            "#{title_line}\n#{indent}#{number_string}"
+            "#{title}\n  #{number_string}"
           }
           .join("\n")
       end

data/lib/reading/util/numeric_to_i_if_whole.rb

@@ -4,7 +4,11 @@ module Reading
     module NumericToIIfWhole
       refine Numeric do
         def to_i_if_whole
-          to_i == self ? to_i : self
+          if is_a?(Float) && nan?
+            0
+          else
+            to_i == self ? to_i : self
+          end
         end
       end
     end

data/lib/reading/version.rb

@@ -1,3 +1,3 @@
 module Reading
-  VERSION = "1.0.2"
+  VERSION = "1.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reading
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.1
 platform: ruby
 authors:
 - Felipe Vogel
@@ -230,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Parses a CSV reading log.
 test_files: []