reading 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 70825fd8a882da595b06db4f8a0766962dd71b8149248ada3ed55280d68b2975
+  data.tar.gz: 124c660e9888c712a8bedc05156700b3e233300a8fe9806dd36ec168e910bfea
+SHA512:
+  metadata.gz: 174a7a35761e5a26569651bee4e7ddefd0bbe8592b3828df34cb9f465d0a734876a57bb0fecb04683c470567a0df151289c375213cdf7ad67d632d8d06d02d10
+  data.tar.gz: 0cec333e90f2a701521d06c4924083e137268112c1a2749effb17b952b3028a4f4deae9ababd9ce1592eb0a21ba60afac75c0e18f81762af936306d86f2adb82

data/bin/reading

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+# A script that provides a quick way to see the output of a CSV string.
+#
+# Usage:
+# Run on the command line:
+#   reading "<CSV string>" "<optional comma-separated names of enabled columns>`
+#
+# Examples:
+#   reading '3|📕Trying|Lexpub 1970147288'
+#   reading '📕Trying|Lexpub 1970147288' 'head, sources'
+
+
+require_relative "../lib/reading/csv"
+require "amazing_print"
+
+input = ARGV[0]
+unless input
+  raise ArgumentError, "CSV string argument required, such as '3|📕Trying|Lexpub 1970147288'"
+end
+
+config = {}
+if ARGV[1]
+  enabled_columns = ARGV[1].split(",").map(&:strip).map(&:to_sym)
+  config[:csv] = { enabled_columns: }
+end
+
+csv = Reading::CSV.new(input, config:)
+items = csv.parse
+
+ap items

data/lib/reading/attribute/all_attributes.rb

@@ -0,0 +1,83 @@
+require_relative "attribute"
+require_relative "variants/variants_attribute"
+require_relative "experiences/experiences_attribute"
+
+module Reading
+  class Row
+    using Util::StringRemove
+    using Util::HashArrayDeepFetch
+
+    # The simpler attributes are collected below. The more complex attributes
+    # are separated into their own files.
+
+    class RatingAttribute < Attribute
+      def parse
+        return nil unless columns[:rating]
+
+        rating = columns[:rating].strip
+        return nil if rating.empty?
+
+        Integer(rating, exception: false) ||
+          Float(rating, exception: false) ||
+          (raise InvalidRatingError, "Invalid rating")
+      end
+    end
+
+    class AuthorAttribute < Attribute
+      def parse
+        item_head
+          .remove(/\A#{config.deep_fetch(:csv, :regex, :formats)}/)
+          .match(/.+(?=#{config.deep_fetch(:csv, :short_separator)})/)
+          &.to_s
+          &.strip
+      end
+    end
+
+    class TitleAttribute < Attribute
+      def parse
+        if item_head.end_with?(config.deep_fetch(:csv, :short_separator).rstrip)
+          raise InvalidHeadError, "Missing title? Head column ends in a separator"
+        end
+
+        item_head
+          .remove(/\A#{config.deep_fetch(:csv, :regex, :formats)}/)
+          .remove(/.+#{config.deep_fetch(:csv, :short_separator)}/)
+          .remove(/#{config.deep_fetch(:csv, :long_separator)}.+\z/)
+          .strip
+          .presence || (raise InvalidHeadError, "Missing title")
+      end
+    end
+
+    class GenresAttribute < Attribute
+      def parse
+        return nil unless columns[:genres]
+
+        columns[:genres]
+          .split(config.deep_fetch(:csv, :separator))
+          .map(&:strip)
+          .map(&:downcase)
+          .map(&:presence)
+          .compact.presence
+      end
+    end
+
+    class NotesAttribute < Attribute
+      def parse
+        return nil unless columns[:public_notes]
+
+        columns[:public_notes]
+          .presence
+          &.chomp
+          &.remove(/#{config.deep_fetch(:csv, :long_separator).rstrip}\s*\z/)
+          &.split(config.deep_fetch(:csv, :long_separator))
+          &.map { |string|
+            {
+              blurb?: !!string.delete!(config.deep_fetch(:csv, :blurb_emoji)),
+              private?: !!string.delete!(config.deep_fetch(:csv, :private_emoji)),
+              content: string.strip,
+            }
+          }
+      end
+    end
+  end
+end

data/lib/reading/attribute/attribute.rb

@@ -0,0 +1,25 @@
+module Reading
+  class Row
+    # A base class that contains behaviors common to ___Attribute classes.
+    class Attribute
+      private attr_reader :item_head, :columns, :config
+
+      # @param item_head [String] see Row#item_heads for a definition.
+      # @param columns [Array<String>] the CSV row split into columns.
+      # @param config [Hash]
+      def initialize(item_head: nil, columns: nil, config:)
+        unless item_head || columns
+          raise ArgumentError, "Either item_head or columns must be given to an Attribute."
+        end
+
+        @item_head = item_head
+        @columns = columns
+        @config = config
+      end
+
+      def parse
+        raise NotImplementedError, "#{self.class} should have implemented #{__method__}"
+      end
+    end
+  end
+end

data/lib/reading/attribute/experiences/dates_validator.rb

@@ -0,0 +1,94 @@
+module Reading
+  # Methods to validate dates. This does not cover all the ways dates can be
+  # invalid, just the ones not covered by ExperiencesAttribute during parsing.
+  module DatesValidator
+    using Util::HashArrayDeepFetch
+
+    class << self
+      # Checks the dates in the given experiences hash, and raises an error at
+      # the first invalid date found.
+      # @param experiences [Array<Hash>]
+      # @param config [Hash]
+      def validate(experiences, config)
+        validate_dates_started_are_in_order(experiences) if dates_started_column?(config)
+        validate_dates_finished_are_in_order(experiences) if dates_finished_column?(config)
+        validate_experiences_of_same_variant_do_not_overlap(experiences) if both_date_columns?(config)
+        validate_spans_are_in_order_and_not_overlapping(experiences)
+      end
+
+      private
+
+      def dates_started_column?(config)
+        config.deep_fetch(:csv, :enabled_columns).include?(:dates_started)
+      end
+
+      def dates_finished_column?(config)
+        config.deep_fetch(:csv, :enabled_columns).include?(:dates_finished)
+      end
+
+      def both_date_columns?(config)
+        dates_started_column?(config) && dates_finished_column?(config)
+      end
+
+      def validate_dates_started_are_in_order(experiences)
+        experiences
+          .filter { |exp| exp[:spans].any? }
+          .map { |exp| exp[:spans].first[:dates].begin }
+          .each_cons(2) do |a, b|
+            if (a.nil? && b.nil?) || (a && b && a > b )
+              raise InvalidDateError, "Dates started are not in order"
+            end
+          end
+      end
+
+      def validate_dates_finished_are_in_order(experiences)
+        experiences
+          .filter { |exp| exp[:spans].any? }
+          .map { |exp| exp[:spans].last[:dates].end }
+          .each_cons(2) do |a, b|
+            if (a.nil? && b.nil?) || (a && b && a > b )
+              raise InvalidDateError, "Dates finished are not in order"
+            end
+          end
+      end
+
+      def validate_experiences_of_same_variant_do_not_overlap(experiences)
+        experiences
+          .group_by { |exp| exp[:variant_index] }
+          .each do |_variant_index, exps|
+            exps.filter { |exp| exp[:spans].any? }.each_cons(2) do |a, b|
+              a_metaspan = a[:spans].first[:dates].begin..a[:spans].last[:dates].end
+              b_metaspan = b[:spans].first[:dates].begin..b[:spans].last[:dates].end
+              if a_metaspan.cover?(b_metaspan.begin || a_metaspan.begin || a_metaspan.end) ||
+                  b_metaspan.cover?(a_metaspan.begin || b_metaspan.begin || b_metaspan.end)
+                raise InvalidDateError, "Experiences are overlapping"
+              end
+            end
+          end
+      end
+
+      def validate_spans_are_in_order_and_not_overlapping(experiences)
+        experiences
+          .filter { |exp| exp[:spans].any? }
+          .each do |exp|
+            exp[:spans]
+              .map { |span| span[:dates] }
+              .each do |dates|
+                if dates.begin && dates.end && dates.begin > dates.end
+                  raise InvalidDateError, "A date range is backward"
+                end
+              end
+              .each_cons(2) do |a, b|
+                if a.begin > b.begin || a.end > b.end
+                  raise InvalidDateError, "Dates are not in order"
+                end
+                if a.cover?(b.begin || a.begin || a.end) ||
+                    b.cover?(a.begin || b.begin || b.end)
+                  raise InvalidDateError, "Dates are overlapping"
+                end
+              end
+          end
+      end
+    end
+  end
+end

data/lib/reading/attribute/experiences/experiences_attribute.rb

@@ -0,0 +1,74 @@
+require_relative "spans_subattribute"
+require_relative "progress_subattribute"
+require_relative "dates_validator"
+require "date"
+
+module Reading
+  class Row
+    class ExperiencesAttribute < Attribute
+      using Util::HashArrayDeepFetch
+      using Util::HashDeepMerge
+
+      def parse
+        started, finished = dates_split(columns)
+
+        experiences_with_dates = started.map.with_index { |entry, i|
+          variant_index = variant_index(entry)
+          spans_attr = SpansSubattribute.new(date_entry: entry, dates_finished: finished, date_index: i, variant_index:, columns:, config:)
+
+          {
+            spans: spans_attr.parse                       || template.fetch(:spans),
+            group: group(entry)                           || template.fetch(:group),
+            variant_index: variant_index                  || template.fetch(:variant_index)
+          }
+        }.presence
+
+        if experiences_with_dates
+          # Raises an error if any sequence of dates does not make sense.
+          DatesValidator.validate(experiences_with_dates, config)
+
+          return experiences_with_dates
+        else
+          if prog = ProgressSubattribute.new(columns:, config:).parse_head
+            return [template.deep_merge(spans: [{ progress: prog }] )]
+          else
+            return nil
+          end
+        end
+      end
+
+      private
+
+      def template
+        @template ||= config.deep_fetch(:item, :template, :experiences).first
+      end
+
+      def dates_split(columns)
+        dates_finished = columns[:dates_finished]&.presence
+                          &.split(config.deep_fetch(:csv, :separator))&.map(&:strip) || []
+        # Don't use #has_key? because simply checking for nil covers the
+        # case where dates_started is the last column and omitted.
+        started_column_exists = columns[:dates_started]&.presence
+
+        dates_started =
+          if started_column_exists
+            columns[:dates_started]&.presence&.split(config.deep_fetch(:csv, :separator))&.map(&:strip)
+          else
+            [""] * dates_finished.count
+          end
+
+        [dates_started, dates_finished]
+      end
+
+      def group(entry)
+        entry.match(config.deep_fetch(:csv, :regex, :group_experience))&.captures&.first
+      end
+
+      def variant_index(date_entry)
+        match = date_entry.match(config.deep_fetch(:csv, :regex, :variant_index))
+
+        (match&.captures&.first&.to_i || 1) - 1
+      end
+    end
+  end
+end

data/lib/reading/attribute/experiences/progress_subattribute.rb

@@ -0,0 +1,48 @@
+module Reading
+  class Row
+    class ProgressSubattribute
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :date_entry, :variant_index, :columns, :config
+
+      # @param date_entry [String] the entry in Dates Started.
+      # @param variant_index [Integer] the variant index, for getting length for default amount.
+      # @param columns [Array<String>]
+      # @param config [Hash]
+      def initialize(date_entry: nil, variant_index: nil, columns:, config:)
+        @date_entry = date_entry
+        @variant_index = variant_index
+        @columns = columns
+        @config = config
+      end
+
+      def parse
+        progress(date_entry) || progress(columns[:head])
+      end
+
+      def parse_head
+        progress(columns[:head])
+      end
+
+      private
+
+      def progress(str)
+        prog = str.match(config.deep_fetch(:csv, :regex, :progress))
+
+        if prog
+          if prog_percent = prog[:percent]&.to_i
+            return prog_percent / 100.0
+          elsif prog_time = prog[:time]
+            return prog_time
+          elsif prog_pages = prog[:pages]&.to_i
+            return prog_pages
+          end
+        end
+
+        dnf = str.match(config.deep_fetch(:csv, :regex, :dnf))&.captures&.first
+        return 0 if dnf
+        nil
+      end
+    end
+  end
+end

data/lib/reading/attribute/experiences/spans_subattribute.rb

@@ -0,0 +1,82 @@
+module Reading
+  class Row
+    class SpansSubattribute
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :date_entry, :dates_finished, :date_index, :variant_index, :columns, :config
+
+      # @param date_entry [String] the entry in Dates Started.
+      # @param dates_finished [Array<String>] the entries in Dates Finished.
+      # @param date_index [Integer] the index of the entry.
+      # @param variant_index [Integer] the variant index, for getting length for default amount.
+      # @param columns [Array<String>]
+      # @param config [Hash]
+      def initialize(date_entry:, dates_finished:, date_index:, variant_index:, columns:, config:)
+        @date_entry = date_entry
+        @dates_finished = dates_finished
+        @date_index = date_index
+        @variant_index = variant_index
+        @columns = columns
+        @config = config
+      end
+
+      def parse
+        started = date_started(date_entry)
+        finished = date_finished(dates_finished, date_index)
+        return [] if started.nil? && finished.nil?
+
+        progress_attr = ProgressSubattribute.new(date_entry:, variant_index:, columns:, config:)
+        progress = progress_attr.parse
+
+        [{
+          dates: started..finished                || template.fetch(:dates),
+          amount: length                          || template.fetch(:amount),
+          progress: progress || (1.0 if finished) || template.fetch(:progress),
+          name:                                   template.fetch(:name),
+          favorite?:                              template.fetch(:favorite?),
+        }]
+      end
+
+      private
+
+      def template
+        @template ||= config.deep_fetch(:item, :template, :experiences, 0, :spans).first
+      end
+
+      def date_started(date_entry)
+        dates = date_entry.scan(config.deep_fetch(:csv, :regex, :date))
+        raise InvalidDateError, "Conjoined dates" if dates.count > 1
+        raise InvalidDateError, "Missing or incomplete date" if date_entry.present? && dates.empty?
+
+        date_str = dates.first
+        Date.parse(date_str) if date_str
+      rescue Date::Error
+        raise InvalidDateError, "Unparsable date"
+      end
+
+      def date_finished(dates_finished, date_index)
+        return nil if dates_finished.nil?
+
+        date_str = dates_finished[date_index]&.presence
+        Date.parse(date_str) if date_str
+      rescue Date::Error
+        if date_str.match?(config.deep_fetch(:csv, :regex, :date))
+          raise InvalidDateError, "Unparsable date"
+        else
+          raise InvalidDateError, "Missing or incomplete date"
+        end
+      end
+
+      def length
+        sources_str = columns[:sources]&.presence || " "
+        bare_variant = sources_str
+          .split(config.deep_fetch(:csv, :regex, :formats_split))
+          .dig(variant_index)
+          &.split(config.deep_fetch(:csv, :long_separator))
+          &.first
+        length_attr = LengthSubattribute.new(bare_variant:, columns:, config:)
+        length_attr.parse
+      end
+    end
+  end
+end

data/lib/reading/attribute/variants/extra_info_subattribute.rb

@@ -0,0 +1,44 @@
+module Reading
+  class Row
+    class ExtraInfoSubattribute
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :item_head, :variant_with_extras, :config
+
+      # @param item_head [String] see Row#item_heads for a definition.
+      # @param variant_with_extras [String] the full variant string.
+      # @param config [Hash]
+      def initialize(item_head:, variant_with_extras: nil, config:)
+        @item_head = item_head
+        @variant_with_extras = variant_with_extras
+        @config = config
+      end
+
+      def parse
+        (
+          Array(extra_info(item_head)) +
+            Array(extra_info(variant_with_extras))
+        ).presence
+      end
+
+      def parse_head
+        extra_info(item_head)
+      end
+
+      private
+
+      def template
+        config.deep_fetch(:item, :template, :variants, 0, :series).first
+      end
+
+      def extra_info(str)
+        separated = str.split(config.deep_fetch(:csv, :long_separator))
+        separated.delete_at(0) # everything before the extra info
+        separated.reject { |str|
+          str.start_with?("#{config.deep_fetch(:csv, :series_prefix)} ") ||
+            str.match(config.deep_fetch(:csv, :regex, :series_volume))
+        }.presence
+      end
+    end
+  end
+end

data/lib/reading/attribute/variants/length_subattribute.rb

@@ -0,0 +1,45 @@
+module Reading
+  class Row
+    class LengthSubattribute
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :item_head, :bare_variant, :columns, :config
+
+      # @param bare_variant [String] the variant string before series / extra info.
+      # @param columns [Array<String>]
+      # @param config [Hash]
+      def initialize(bare_variant:, columns:, config:)
+        @bare_variant = bare_variant
+        @columns = columns
+        @config = config
+      end
+
+      def parse
+        in_variant = length_in(
+          bare_variant,
+          time_regex: config.deep_fetch(:csv, :regex, :time_length_in_variant),
+          pages_regex: config.deep_fetch(:csv, :regex, :pages_length_in_variant),
+        )
+        in_length = length_in(
+          columns[:length],
+          time_regex: config.deep_fetch(:csv, :regex, :time_length),
+          pages_regex: config.deep_fetch(:csv, :regex, :pages_length),
+        )
+
+        in_variant || in_length ||
+          (raise InvalidLengthError, "Missing length" unless columns[:length].blank?)
+      end
+
+      private
+
+      def length_in(str, time_regex:, pages_regex:)
+        return nil if str.blank?
+
+        time_length = str.strip.match(time_regex)&.captures&.first
+        return time_length unless time_length.nil?
+
+        str.strip.match(pages_regex)&.captures&.first&.to_i
+      end
+    end
+  end
+end

data/lib/reading/attribute/variants/series_subattribute.rb

@@ -0,0 +1,57 @@
+module Reading
+  class Row
+    class SeriesSubattribute
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :item_head, :variant_with_extras, :config
+
+      # @param item_head [String] see Row#item_heads for a definition.
+      # @param variant_with_extras [String] the full variant string.
+      # @param config [Hash]
+      def initialize(item_head:, variant_with_extras: nil, config:)
+        @item_head = item_head
+        @variant_with_extras = variant_with_extras
+        @config = config
+      end
+
+      def parse
+        (
+          Array(series(item_head)) +
+            Array(series(variant_with_extras))
+        ).presence
+      end
+
+      def parse_head
+        series(item_head)
+      end
+
+      private
+
+      def template
+        config.deep_fetch(:item, :template, :variants, 0, :series).first
+      end
+
+      def series(str)
+        separated = str
+          .split(config.deep_fetch(:csv, :long_separator))
+          .map(&:strip)
+          .map(&:presence)
+          .compact
+
+        separated.delete_at(0) # everything before the series/extra info
+
+        separated.map { |str|
+          volume = str.match(config.deep_fetch(:csv, :regex, :series_volume))
+          prefix = "#{config.deep_fetch(:csv, :series_prefix)} "
+
+          if volume || str.start_with?(prefix)
+            {
+              name: str.delete_suffix(volume.to_s).delete_prefix(prefix) || template[:name],
+              volume: volume&.captures&.first&.to_i                      || template[:volume],
+            }
+          end
+        }.compact.presence
+      end
+    end
+  end
+end

data/lib/reading/attribute/variants/sources_subattribute.rb

@@ -0,0 +1,78 @@
+module Reading
+  class Row
+    class SourcesSubattribute
+      using Util::StringRemove
+      using Util::HashArrayDeepFetch
+
+      private attr_reader :item_head, :bare_variant, :config
+
+      # @param bare_variant [String] the variant string before series / extra info.
+      # @param config [Hash]
+      def initialize(bare_variant:, config:)
+        @bare_variant = bare_variant
+        @config = config
+      end
+
+      def parse
+        urls = sources_urls(bare_variant).map { |url|
+          {
+            name: url_name(url) || template.deep_fetch(:sources, 0, :name),
+            url: url,
+          }
+        }
+
+        names = sources_names(bare_variant).map { |name|
+          {
+            name: name,
+            url: template.deep_fetch(:sources, 0, :url),
+          }
+        }
+
+        (urls + names).presence
+      end
+
+      private
+
+      def template
+        @template ||= config.deep_fetch(:item, :template, :variants).first
+      end
+
+      def sources_urls(str)
+        str.scan(config.deep_fetch(:csv, :regex, :url))
+      end
+
+      # Turns everything that is not a source name (ISBN, source URL, length) into
+      # a separator, then splits by that separator and removes empty elements
+      # and format emojis. What's left is source names.
+      def sources_names(str)
+        not_names = [:isbn, :url, :time_length_in_variant, :pages_length_in_variant]
+        names_and_separators = str
+
+        not_names.each do |regex_type|
+          names_and_separators = names_and_separators.gsub(
+            config.deep_fetch(:csv, :regex, regex_type),
+            config.deep_fetch(:csv, :separator),
+          )
+        end
+
+        names_and_separators
+          .split(config.deep_fetch(:csv, :separator))
+          .map { |name| name.remove(/\A\s*#{config.deep_fetch(:csv, :regex, :formats)}\s*/) }
+          .map(&:strip)
+          .reject(&:empty?)
+      end
+
+      def url_name(url)
+        config
+          .deep_fetch(:item, :sources, :names_from_urls)
+          .each do |url_part, name|
+            if url.include?(url_part)
+              return name
+            end
+          end
+
+        config.deep_fetch(:item, :sources, :default_name_for_url)
+      end
+    end
+  end
+end