reading 0.6.1 → 0.8.0

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

@@ -1,74 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

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

@@ -1,69 +0,0 @@
-require_relative "series_subattribute"
-require_relative "sources_subattribute"
-require_relative "length_subattribute"
-require_relative "extra_info_subattribute"
-
-module Reading
-  class Row
-    class VariantsAttribute < Attribute
-      using Util::HashArrayDeepFetch
-
-      def parse
-        sources_str = columns[:sources]&.presence || " "
-
-        format_as_separator = config.deep_fetch(:csv, :regex, :formats_split)
-
-        sources_str.split(format_as_separator).map { |variant_with_extras|
-          # without extra info or series
-          bare_variant = variant_with_extras
-            .split(config.deep_fetch(:csv, :long_separator))
-            .first
-
-          series_attr = SeriesSubattribute.new(item_head:, variant_with_extras:, config:)
-          sources_attr = SourcesSubattribute.new(bare_variant:, config:)
-          # Length, despite not being very complex, is still split out into a
-          # subattribute because it needs to be accessible to
-          # ExperiencesAttribute (more specifically SpansSubattribute) which
-          # uses length as a default value for amount.
-          length_attr = LengthSubattribute.new(bare_variant:, columns:, config:)
-          extra_info_attr = ExtraInfoSubattribute.new(item_head:, variant_with_extras:, config:)
-
-          variant =
-            {
-              format: format(bare_variant) || format(item_head) || template.fetch(:format),
-              series: series_attr.parse                         || template.fetch(:series),
-              sources: sources_attr.parse                       || template.fetch(:sources),
-              isbn: isbn(bare_variant)                          || template.fetch(:isbn),
-              length: length_attr.parse                         || template.fetch(:length),
-              extra_info: extra_info_attr.parse                 || template.fetch(:extra_info)
-            }
-
-          if variant != template
-            variant
-          else
-            nil
-          end
-        }.compact.presence
-      end
-
-      private
-
-      def template
-        @template ||= config.deep_fetch(:item, :template, :variants).first
-      end
-
-      def format(str)
-        emoji = str.match(/^#{config.deep_fetch(:csv, :regex, :formats)}/).to_s
-        config.deep_fetch(:item, :formats).key(emoji)
-      end
-
-      def isbn(str)
-        isbns = str.scan(config.deep_fetch(:csv, :regex, :isbn))
-        if isbns.count > 1
-          raise InvalidSourceError, "Only one ISBN/ASIN is allowed per item variant"
-        end
-        isbns[0]&.to_s
-      end
-    end
-  end
-end

data/lib/reading/csv.rb

@@ -1,76 +0,0 @@
-# Used throughout, in other files.
-require_relative "util/blank"
-require_relative "util/string_remove"
-require_relative "util/string_truncate"
-require_relative "util/hash_to_struct"
-require_relative "util/hash_deep_merge"
-require_relative "util/hash_array_deep_fetch"
-require_relative "util/hash_compact_by_template"
-require_relative "errors"
-
-# Used just here.
-require_relative "config"
-require_relative "line"
-
-module Reading
-  class CSV
-    using Util::HashDeepMerge
-    using Util::HashArrayDeepFetch
-    using Util::HashToStruct
-
-    attr_reader :config
-
-    # @param feed [Object] the input source, which must respond to #each_line;
-    #   if nil, the file at the given path is used.
-    # @param path [String] the path of the source file.
-    # @param config [Hash] a custom config which overrides the defaults,
-    #   e.g. { errors: { styling: :html } }
-    def initialize(feed = nil, path: nil, config: {})
-      validate_feed_or_path(feed, path)
-
-      @feed = feed
-      @path = path
-      @config ||= Config.new(config).hash
-    end
-
-    # Parses a CSV reading log into item data (an array of Structs).
-    # For what the Structs look like, see the Hash at @default_config[:item][:template]
-    # in config.rb. The Structs are identical in structure to that Hash (with
-    # every inner Hash replaced with a Struct).
-    # @return [Array<Struct>] an array of Structs like the template in config.rb
-    def parse
-      feed = @feed || File.open(@path)
-      items = []
-
-      feed.each_line do |string|
-        line = Line.new(string, self)
-        row = line.to_row
-
-        items += row.parse
-      end
-
-      items.map(&:to_struct)
-    ensure
-      feed&.close if feed.respond_to?(:close)
-    end
-
-    private
-
-    # Checks on the given feed and path (arguments to #initialize).
-    # @raise [FileError] if the given path is invalid.
-    # @raise [ArgumentError] if both feed and path are nil.
-    def validate_feed_or_path(feed, path)
-      return true if feed
-
-      if path
-        if !File.exist?(path)
-          raise FileError, "File not found! #{path}"
-        elsif File.directory?(path)
-          raise FileError, "The reading log must be a file, but the path given is a directory: #{path}"
-        end
-      else
-        raise ArgumentError, "Either a feed (String, File, etc.) or a file path must be provided."
-      end
-    end
-  end
-end

data/lib/reading/line.rb

@@ -1,23 +0,0 @@
-require_relative "row/compact_planned_row"
-require_relative "row/blank_row"
-require_relative "row/regular_row"
-
-module Reading
-  # A bridge between rows as strings and as parsable Rows, used whenever the
-  # context of the line in the CSV is needed, e.g. converting a line to a Row,
-  # or adding a CSV line to a Row parsing error.
-  class Line
-    attr_reader :string, :csv
-
-    def initialize(string, csv)
-      @string = string.dup.force_encoding(Encoding::UTF_8).strip
-      @csv = csv
-    end
-
-    def to_row
-      return CompactPlannedRow.new(self) if CompactPlannedRow.match?(self)
-      return BlankRow.new(self) if BlankRow.match?(self)
-      RegularRow.new(self)
-    end
-  end
-end

data/lib/reading/row/blank_row.rb

@@ -1,23 +0,0 @@
-require_relative "row"
-
-module Reading
-  # An empty or commented-out row. A null object which returns an empty array.
-  class BlankRow < Row
-    using Util::HashArrayDeepFetch
-
-    # Whether the given CSV line is a blank row.
-    # @param line [Reading::Line]
-    # @return [Boolean]
-    def self.match?(line)
-      comment_char = line.csv.config.deep_fetch(:csv, :comment_character)
-
-      line.string.strip.empty? ||
-        line.string.strip.start_with?(comment_char)
-    end
-
-    # Overrides Row#parse.
-    def parse
-      []
-    end
-  end
-end