reading 0.9.0 → 1.0.0

data/lib/reading/stats/operation.rb

@@ -1,3 +1,5 @@
+require "bigdecimal/util"
+
 module Reading
   module Stats
     # The beginning of a query which specifies what it does, e.g.
@@ -50,14 +52,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 +91,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 +107,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
         },
@@ -112,77 +117,153 @@ module Reading
           items.sum { |item|
             item.experiences.sum { |experience|
               experience.spans.sum { |span|
-                (span.amount * span.progress).to_i_if_whole
+                (span.amount * (span.progress || 0.0)).to_i_if_whole
               }
             }
           }
         },
         top_rating: proc { |items, number_arg|
           items
-            .max_by(number_arg || DEFAULT_NUMBER_ARG, &:rating)
             .map { |item| [author_and_title(item), item.rating] }
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, rating|
+              rating || 0
+            }
         },
         top_length: proc { |items, number_arg|
           items
-            .map { |item| [author_and_title(item), item.variants.map(&:length).max] }
+            .map { |item|
+              # Longest length, or if undefined length then longest experience
+              # (code adapted from top_amount below).
+              length = item.variants.map(&:length).max ||
+                item.experiences.map { |experience|
+                  experience.spans.sum { |span|
+                    (span.amount * (span.progress || 0.0)).to_i_if_whole
+                  }
+                }.max
+
+              [author_and_title(item), length]
+            }
             .reject { |_title, length| length.nil? }
-            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length| length }
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length|
+              length
+            }
         },
         top_amount: proc { |items, number_arg|
           items
             .map { |item|
               amount = item.experiences.sum { |experience|
                 experience.spans.sum { |span|
-                  (span.amount * span.progress).to_i_if_whole
+                  (span.amount * (span.progress || 0.0)).to_i_if_whole
                 }
               }
 
               [author_and_title(item), amount]
             }
             .reject { |_title, amount| amount.zero? }
-            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, amount| amount }
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, amount|
+              amount
+            }
         },
         top_speed: proc { |items, number_arg|
           items
-            .map { |item| calculate_speed(item) }
+            .map { |item|
+              speed = calculate_speed(item)
+              [author_and_title(item), speed] if speed
+            }
             .compact
             .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, speed_hash|
               speed_hash[:amount] / speed_hash[:days].to_f
             }
         },
+        top_experience: proc { |items, number_arg|
+          items
+            .map { |item|
+              experience_count = item
+                .experiences
+                .count { |experience|
+                  experience.spans.all? { _1.progress.to_d == "1.0".to_d }
+                }
+
+              [author_and_title(item), [experience_count, item.rating || 0]]
+            }
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, experience_count_and_rating|
+              experience_count_and_rating
+            }
+            .map { |title, (experience_count, _rating)|
+              [title, experience_count]
+            }
+        },
+        top_note: proc { |items, number_arg|
+          items
+            .map { |item|
+              notes_word_count = item
+                .notes
+                .sum { |note|
+                  note.content.scan(/[\w[:punct:]]+/).count
+                }
+
+              [author_and_title(item), notes_word_count]
+            }
+            .max_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, notes_word_count|
+              notes_word_count
+            }
+        },
         bottom_rating: proc { |items, number_arg|
           items
-            .min_by(number_arg || DEFAULT_NUMBER_ARG, &:rating)
             .map { |item| [author_and_title(item), item.rating] }
+            .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, rating|
+              rating || 0
+            }
         },
         bottom_length: proc { |items, number_arg|
           items
-            .map { |item| [author_and_title(item), item.variants.map(&:length).max] }
+            .map { |item|
+              # Longest length, or if undefined length then longest experience
+              # (code adapted from bottom_amount below).
+              length = item.variants.map(&:length).max ||
+                item.experiences.map { |experience|
+                  experience.spans.sum { |span|
+                    (span.amount * (span.progress || 0.0)).to_i_if_whole
+                  }
+                }.max
+
+              [author_and_title(item), length]
+            }
             .reject { |_title, length| length.nil? }
-            .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length| length }
+            .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, length|
+              length
+            }
         },
         bottom_amount: proc { |items, number_arg|
           items
             .map { |item|
               amount = item.experiences.sum { |experience|
                 experience.spans.sum { |span|
-                  (span.amount * span.progress).to_i_if_whole
+                  (span.amount * (span.progress || 0.0)).to_i_if_whole
                 }
               }
 
               [author_and_title(item), amount]
             }
             .reject { |_title, amount| amount.zero? }
-            .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, amount| amount }
+            .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, amount|
+              amount
+            }
         },
         bottom_speed: proc { |items, number_arg|
           items
-            .map { |item| calculate_speed(item) }
+            .map { |item|
+              speed = calculate_speed(item)
+              [author_and_title(item), speed] if speed
+            }
             .compact
             .min_by(number_arg || DEFAULT_NUMBER_ARG) { |_title, speed_hash|
               speed_hash[:amount] / speed_hash[:days].to_f
             }
         },
+        debug: proc { |items|
+          items
+        },
       }
 
       ALIASES = {
@@ -190,20 +271,24 @@ 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],
         top_length: %w[tl],
         top_amount: %w[ta],
         top_speed: %w[ts],
+        top_experience: %w[te],
+        top_note: %w[tn],
         bottom_rating: %w[br],
         bottom_length: %w[bl],
         bottom_amount: %w[ba],
         bottom_speed: %w[bs],
+        debug: %w[d],
       }
 
       REGEXES = ACTIONS.map { |key, _action|
-        first_word, second_word = key.to_s.split('_')
+        first_word, second_word = key.to_s.split("_")
         aliases = ALIASES.fetch(key)
 
         regex =
@@ -228,7 +313,7 @@ module Reading
             (
               \A
               \s*
-              (#{aliases.join('|')})
+              (#{aliases.join("|")})
               s?
               \s*
               (?<number_arg>
@@ -296,10 +381,7 @@ module Reading
 
         return nil unless speeds.any?
 
-        speed = speeds
-          .max_by { |hash| hash[:amount] / hash[:days].to_f }
-
-        [author_and_title(item), speed]
+        speeds.max_by { |hash| hash[:amount] / hash[:days].to_f }
       end
 
       # A shorter version of Item::View#name.

data/lib/reading/stats/query.rb

@@ -1,7 +1,8 @@
-require 'pastel'
-require_relative 'operation'
-require_relative 'filter'
-require_relative 'grouping'
+require "pastel"
+require_relative "operation"
+require_relative "filter"
+require_relative "grouping"
+require_relative "result_formatters"
 
 module Reading
   module Stats
@@ -13,9 +14,8 @@ module Reading
       # @param items [Array<Item>] the Items to be queried.
       # @param result_formatters [Boolean, Hash{Symbol => Proc}] to alter the
       #   appearance of results; keys should be from among the keys of
-      #   Operation::ACTIONS. Pre-made formatters for terminal output are in
-      #   terminal_result_formatters.rb.
-      def initialize(input:, items:, result_formatters: {})
+      #   Operation::ACTIONS. Pre-made formatters are in result_formatters.rb.
+      def initialize(input:, items:, result_formatters: Reading::Stats::ResultFormatters::TRUNCATED_TITLES)
         @input = input
         @items = items
         @result_formatters = result_formatters

data/lib/reading/stats/result_formatters.rb

@@ -0,0 +1,140 @@
+require "pastel"
+
+module Reading
+  module Stats
+    module ResultFormatters
+      TRUNCATED_TITLES = {
+        top_length: ->(result) { with_truncated_title(result) },
+        top_amount: ->(result) { with_truncated_title(result) },
+        top_speed: ->(result) { with_truncated_title(result) },
+        top_experience: ->(result) { with_truncated_title(result) },
+        top_note: ->(result) { with_truncated_title(result) },
+        bottom_length: ->(result) { with_truncated_title(result) },
+        botom_amount: ->(result) { with_truncated_title(result) },
+        bottom_speed: ->(result) { with_truncated_title(result) },
+      }
+
+      TERMINAL = {
+        average_length: ->(result) { length_to_s(result) },
+        average_amount: ->(result) { length_to_s(result) },
+        :"average_daily-amount" => ->(result) { "#{length_to_s(result)} per day" },
+        total_item: ->(result) {
+          if result.zero?
+            PASTEL.bright_black("none")
+          else
+            color("#{result} #{result == 1 ? "item" : "items"}")
+          end
+        },
+        total_amount: ->(result) { length_to_s(result) },
+        top_rating: ->(result) { top_or_bottom_numbers_string(result, noun: "star") },
+        top_length: ->(result) { top_or_bottom_lengths_string(result) },
+        top_amount: ->(result) { top_or_bottom_lengths_string(result) },
+        top_speed: ->(result) { top_or_bottom_speeds_string(result) },
+        top_experience: ->(result) { top_or_bottom_numbers_string(result, noun: "experience") },
+        top_note: ->(result) { top_or_bottom_numbers_string(result, noun: "word") },
+        bottom_rating: ->(result) { top_or_bottom_numbers_string(result, noun: "star") },
+        bottom_length: ->(result) { top_or_bottom_lengths_string(result) },
+        botom_amount: ->(result) { top_or_bottom_lengths_string(result) },
+        bottom_speed: ->(result) { top_or_bottom_speeds_string(result) },
+      }
+
+      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"
+        else
+          length_string = 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)}"
+          }
+          .join("\n")
+      end
+
+      # Formats a list of top/bottom speed results as a string.
+      # @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)
+            days = "#{hash[:days]} #{hash[:days] == 1 ? "day" : "days"}"
+            pad = " " * (offset - (index + 1).digits.count)
+
+            title_line = "#{index + 1}. #{pad}#{title}"
+            indent = "    #{" " * offset}"
+            colored_speed = color("#{amount} in #{days}")
+
+            "#{title_line}\n#{indent}#{colored_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"}")
+
+            "#{title_line}\n#{indent}#{number_string}"
+          }
+          .join("\n")
+      end
+
+      # Truncates the title of each result to a specified length.
+      # @param result [Array]
+      # @param length [Integer] the maximum length of the title.
+      # @return [Array]
+      private_class_method def self.with_truncated_title(result, length: 45)
+        result.map do |title, value|
+          truncated_title =
+            if title.length + 1 > length
+              "#{title[0...length]}…"
+            else
+              title
+            end
+
+          [truncated_title, value]
+        end
+      end
+    end
+  end
+end

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 = "1.0.0"
 end

data/lib/reading.rb

@@ -1,10 +1,10 @@
-Dir[File.join(__dir__, 'reading', 'util', '*.rb')].each { |file| require file }
-require_relative 'reading/errors'
-require_relative 'reading/config'
-require_relative 'reading/parsing/csv'
-require_relative 'reading/filter'
-require_relative 'reading/stats/query'
-require_relative 'reading/item/time_length.rb'
+Dir[File.join(__dir__, "reading", "util", "*.rb")].each { |file| require file }
+require_relative "reading/errors"
+require_relative "reading/config"
+require_relative "reading/parsing/csv"
+require_relative "reading/filter"
+require_relative "reading/stats/query"
+require_relative "reading/item/time_length.rb"
 
 # The gem's public API. See https://github.com/fpsvogel/reading#usage
 #

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: reading
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Felipe Vogel
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -24,48 +23,76 @@ 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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.18'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.18'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: shoulda-context
   requirement: !ruby/object:Gem::Requirement
@@ -95,34 +122,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: amazing_print
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rubycritic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.7'
-description: 
+        version: '4.0'
 email:
 - fps.vogel@gmail.com
 executables:
@@ -173,7 +199,7 @@ files:
 - lib/reading/stats/grouping.rb
 - lib/reading/stats/operation.rb
 - lib/reading/stats/query.rb
-- lib/reading/stats/terminal_result_formatters.rb
+- lib/reading/stats/result_formatters.rb
 - lib/reading/util/blank.rb
 - lib/reading/util/exclude.rb
 - lib/reading/util/hash_array_deep_fetch.rb
@@ -189,24 +215,22 @@ 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
-post_install_message: 
+  changelog_uri: https://github.com/fpsvogel/reading/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.4.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Parses a CSV reading log.
 test_files: []