reading 0.8.0 → 0.9.1

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

@@ -4,6 +4,7 @@ module Reading
       # Transformer for the :variant item attribute.
       class Variants < Attribute
         using Util::HashArrayDeepFetch
+        using Util::NumericToIIfWhole
 
         # @param parsed_row [Hash] a parsed row (the intermediate hash).
         # @param head_index [Integer] current item's position in the Head column.
@@ -14,13 +15,15 @@ module Reading
 
           # || [{}] in case there is no Sources column.
           (parsed_row[:sources].presence || [{}])&.map { |variant|
+            format = variant[:format] || head[:format]
+
             {
-              format: variant[:format] || head[:format],
+              format:,
               series: (series(head) + series(variant)).presence,
               sources: sources(variant) || sources(head),
               isbn: variant[:isbn] || variant[:asin],
-              length: Attributes::Shared.length(variant) ||
-                Attributes::Shared.length(parsed_row[:length]),
+              length: Attributes::Shared.length(variant, format:) ||
+                Attributes::Shared.length(parsed_row[:length], format:),
               extra_info: Array(head[:extra_info]) + Array(variant[:extra_info]),
             }.map { |k, v| [k, v || template.fetch(k)] }.to_h
           }&.compact&.presence
@@ -29,7 +32,7 @@ module Reading
         # A shortcut to the variant template.
         # @return [Hash]
         def template
-          config.deep_fetch(:item, :template, :variants).first
+          Config.hash.deep_fetch(:item, :template, :variants).first
         end
 
         # The :series sub-attribute for the given parsed hash.
@@ -57,11 +60,11 @@ module Reading
         end
 
         # The name for the given URL string, according to
-        # config[:source_names_from_urls], or nil.
+        # Config.hash[:source_names_from_urls], or nil.
         # @param url [String] a URL.
         # @return [String, nil]
         def url_name(url)
-          config
+          Config.hash
             .fetch(:source_names_from_urls)
             .each do |url_part, name|
               if url.include?(url_part)

data/lib/reading/parsing/csv.rb

@@ -1,23 +1,12 @@
-# Used throughout, in other files.
-require_relative "../util/blank"
-require_relative "../util/string_remove"
-require_relative "../util/string_truncate"
-require_relative "../util/numeric_to_i_if_whole"
-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 "../item"
-require_relative "parser"
-require_relative "transformer"
+require 'pastel'
+require_relative '../item'
+require_relative 'parser'
+require_relative 'transformer'
 
 module Reading
   module Parsing
     #
-    # Validates a path or stream (string, file, etc.) of a CSV reading log, then
+    # Validates a path or lines (string, file, etc.) of a CSV reading log, then
     # parses it into an array of Items.
     #
     # Parsing happens in two steps:
@@ -31,31 +20,35 @@ module Reading
     # inspired by the Parslet gem: https://kschiess.github.io/parslet/transform.html
     #
     class CSV
-      private attr_reader :parser, :transformer, :hash_output, :item_view
+      private attr_reader :parser, :transformer, :hash_output, :item_view, :error_handler, :pastel
 
-      # Validates a path or stream (string, file, etc.) of a CSV reading log,
+      # Validates a path or lines (string, file, etc.) of a CSV reading log,
       # builds the config, and initializes the parser and transformer.
-      # @param path [String] path to the CSV file; used if no stream is given.
-      # @param stream [Object] an object responding to #each_linewith CSV row(s);
+      # @param path [String] path to the CSV file; used if no lines are given.
+      # @param lines [Object] an object responding to #each_line with CSV row(s);
       #   if nil, path is used instead.
-      # @param config [Hash] a custom config which overrides the defaults,
+      # @param config [Hash, Config] a custom config which overrides the defaults,
       #   e.g. { errors: { styling: :html } }
       # @param hash_output [Boolean] whether an array of raw Hashes should be
       #   returned, without Items being created from them.
-      # @param view [Class, nil, Boolean] the class that will be used to build
+      # @param item_view [Class, nil, Boolean] the class that will be used to build
       #   each Item's view object, or nil/false if no view object should be built.
       #   If you use a custom view class, the only requirement is that its
       #   #initialize take an Item and a full config as arguments.
-      def initialize(path = nil, stream: nil, config: {}, hash_output: false, item_view: Item::View)
-        validate_path_or_stream(path, stream)
-        full_config = Config.new(config).hash
+      # @param error_handler [Proc] if not provided, errors are raised.
+      def initialize(path: nil, lines: nil, config: nil, hash_output: false, item_view: Item::View, error_handler: nil)
+        validate_path_or_lines(path, lines)
+
+        Config.build(config) if config
 
         @path = path
-        @stream = stream
+        @lines = lines
         @hash_output = hash_output
         @item_view = item_view
-        @parser = Parser.new(full_config)
-        @transformer = Transformer.new(full_config)
+        @parser = Parser.new
+        @transformer = Transformer.new
+        @error_handler = error_handler
+        @pastel = Pastel.new
       end
 
       # Parses and transforms the reading log into item data.
@@ -64,16 +57,26 @@ module Reading
       #   structure to that Hash (with every inner Hash replaced by a Data for
       #   dot access).
       def parse
-        input = @stream || File.open(@path)
+        input = @lines || File.open(@path)
         items = []
 
         input.each_line do |line|
           begin
             intermediate = parser.parse_row_to_intermediate_hash(line)
+
             next if intermediate.empty? # When the row is blank or a comment.
+
             row_items = transformer.transform_intermediate_hash_to_item_hashes(intermediate)
           rescue Reading::Error => e
-            raise e.class, "#{e.message} in the row \"#{line}\""
+            colored_e =
+              e.class.new("#{pastel.bright_red(e.message)} in the row #{pastel.bright_yellow(line.chomp)}")
+
+            if error_handler
+              error_handler.call(colored_e)
+              next
+            else
+              raise colored_e
+            end
           end
 
           items += row_items
@@ -90,11 +93,11 @@ module Reading
 
       private
 
-      # Checks on the given stream and path (arguments to #initialize).
+      # Checks on the given lines and path (arguments to #initialize).
       # @raise [FileError] if the given path is invalid.
-      # @raise [ArgumentError] if both stream and path are nil.
-      def validate_path_or_stream(path, stream)
-        if stream && stream.respond_to?(:each_line)
+      # @raise [ArgumentError] if both lines and path are nil.
+      def validate_path_or_lines(path, lines)
+        if lines && lines.respond_to?(:each_line)
           return true
         elsif path
           if !File.exist?(path)
@@ -104,7 +107,7 @@ module Reading
           end
         else
           raise ArgumentError,
-            "Either a file path or a stream (string, file, etc.) must be provided."
+            "Provide either a file path or object implementing #each_line (String, File, etc.)."
         end
       end
     end

data/lib/reading/parsing/parser.rb

@@ -1,6 +1,8 @@
-require_relative "rows/regular"
-require_relative "rows/compact_planned"
-require_relative "rows/comment"
+require_relative 'rows/blank'
+require_relative 'rows/regular'
+require_relative 'rows/compact_planned'
+require_relative 'rows/custom_config'
+require_relative 'rows/comment'
 
 module Reading
   module Parsing
@@ -43,14 +45,6 @@ module Reading
     #
     class Parser
       using Util::HashArrayDeepFetch
-      using Util::StringRemove
-
-      attr_reader :config
-
-      # @param config [Hash] an entire config.
-      def initialize(config)
-        @config = config
-      end
 
       # Parses a row string into a hash that mirrors the structure of the row.
       # @param string [String] a string containing a row of a CSV reading log.
@@ -58,7 +52,7 @@ module Reading
       def parse_row_to_intermediate_hash(string)
         columns = extract_columns(string)
 
-        if config.fetch(:skip_compact_planned) && columns.has_key?(Rows::CompactPlanned::Head)
+        if Config.hash.fetch(:skip_compact_planned) && columns.has_key?(Rows::CompactPlanned::Head)
           return {}
         end
 
@@ -76,14 +70,19 @@ module Reading
       #   Parsing::Rows::Column.
       def extract_columns(string)
         string = string.dup.force_encoding(Encoding::UTF_8)
-        column_strings = string.split(config.fetch(:column_separator))
+        column_strings = string.split(Config.hash.fetch(:column_separator))
 
-        row_types = [Rows::Regular, Rows::CompactPlanned, Rows::Comment]
+        row_types = [Rows::Blank, Rows::Regular, Rows::CompactPlanned, Rows::CustomConfig, Rows::Comment]
         column_classes = row_types
-          .find { |row_type| row_type.match?(string, config) }
+          .find { |row_type| row_type.match?(string) }
+          .tap { |row_type|
+            if row_type == Rows::CustomConfig
+              row_type.merge_custom_config!(string)
+            end
+          }
           .column_classes
-          .filter { |column_class|
-            config.fetch(:enabled_columns).include?(column_class.to_sym)
+          .select { |column_class|
+            Config.hash.fetch(:enabled_columns).include?(column_class.to_sym)
           }
 
         if !column_classes.count.zero? && column_strings.count > column_classes.count
@@ -123,7 +122,7 @@ module Reading
         # it doesn't contain any format emojis, return the same as above but
         # with an extra level of nesting (except when the parsed result is nil).
         if column_class.split_by_format? &&
-            !column_string.match?(config.deep_fetch(:regex, :formats))
+            !column_string.match?(Config.hash.deep_fetch(:regex, :formats))
 
           parsed_column = parse_segments(column_class, column_string)
           # Wrap a non-empty value in an array so that e.g. a head without
@@ -136,18 +135,18 @@ module Reading
         # The rest is the complex case: if the column *can and is* split by format.
 
         # Each format plus the string after it.
-        format_strings = column_string.split(config.deep_fetch(:regex, :formats_split))
+        format_strings = column_string.split(Config.hash.deep_fetch(:regex, :formats_split))
 
         # If there's a string before the first format, e.g. "DNF" in Head column.
-        unless format_strings.first.match?(config.deep_fetch(:regex, :formats))
+        unless format_strings.first.match?(Config.hash.deep_fetch(:regex, :formats))
           before_formats = parse_segment(column_class, format_strings.shift, before_formats: true)
         end
 
         # Parse each format-plus-string into an array of segments.
         heads = format_strings.map { |string|
-          format_emoji = string[config.deep_fetch(:regex, :formats)]
-          string.remove!(format_emoji)
-          format = config.fetch(:formats).key(format_emoji)
+          format_emoji = string[Config.hash.deep_fetch(:regex, :formats)]
+          string.sub!(format_emoji, '')
+          format = Config.hash.fetch(:formats).key(format_emoji)
 
           parse_segments(column_class, string)
             .merge(format: format)
@@ -252,7 +251,7 @@ module Reading
       # @return [Hash{Symbol => String}] e.g. { author: "Bram Stoker", title: "Dracula"}
       def parse_segment_with_regex(segment, regex)
         segment
-          .tr(config.fetch(:ignored_characters), "")
+          .tr(Config.hash.fetch(:ignored_characters), "")
           .strip
           .match(regex)
           &.named_captures

data/lib/reading/parsing/rows/blank.rb

@@ -0,0 +1,23 @@
+module Reading
+  module Parsing
+    module Rows
+      # A row that is a blank line.
+      module Blank
+        using Util::HashArrayDeepFetch
+
+        # No columns.
+        # @return [Array]
+        def self.column_classes
+          []
+        end
+
+        # Is a blank line.
+        # @param row_string [String]
+        # @return [Boolean]
+        def self.match?(row_string)
+          row_string == "\n"
+        end
+      end
+    end
+  end
+end

data/lib/reading/parsing/rows/comment.rb

@@ -5,20 +5,19 @@ module Reading
       module Comment
         using Util::HashArrayDeepFetch
 
-        # No columns; comments are parsed as if the row were blank.
+        # No columns; parsed as if the row were blank.
         # @return [Array]
         def self.column_classes
           []
         end
 
-        # Starts with a comment character and does not include any format emojis.
-        # (Commented rows that DO include format emojis are matched as compact
-        # planned rows.)
+        # Starts with a comment character. Note: this must be called *after*
+        # calling ::match? on Rows::CompactPlanned and Rows::CustomConfig,
+        # because those check for starting with a comment character too.
         # @param row_string [String]
-        # @param config [Hash]
         # @return [Boolean]
-        def self.match?(row_string, config)
-          row_string.lstrip.start_with?(config.fetch(:comment_character))
+        def self.match?(row_string)
+          row_string.lstrip.start_with?(Config.hash.fetch(:comment_character))
         end
       end
     end

data/lib/reading/parsing/rows/compact_planned.rb

@@ -1,6 +1,7 @@
-require_relative "column"
-require_relative "compact_planned_columns/head"
-require_relative "regular_columns/sources"
+require_relative 'column'
+require_relative 'compact_planned_columns/head'
+require_relative 'regular_columns/sources'
+require_relative 'regular_columns/length'
 
 module Reading
   module Parsing
@@ -12,17 +13,16 @@ module Reading
         # The columns that are possible in this type of row.
         # @return [Array<Class>]
         def self.column_classes
-          [CompactPlanned::Head, Regular::Sources]
+          [CompactPlanned::Head, Regular::Sources, Regular::Length]
         end
 
         # Starts with a comment character and includes one or more format emojis.
         # @param row_string [String]
-        # @param config [Hash]
         # @return [Boolean]
-        def self.match?(row_string, config)
-          row_string.lstrip.start_with?(config.fetch(:comment_character)) &&
-            row_string.match?(config.deep_fetch(:regex, :formats)) &&
-            row_string.count(config.fetch(:column_separator)) <= column_classes.count - 1
+        def self.match?(row_string)
+          row_string.lstrip.start_with?(Config.hash.fetch(:comment_character)) &&
+            row_string.match?(Config.hash.deep_fetch(:regex, :formats)) &&
+            row_string.count(Config.hash.fetch(:column_separator)) <= column_classes.count - 1
         end
       end
     end

data/lib/reading/parsing/rows/compact_planned_columns/head.rb

@@ -15,7 +15,7 @@ module Reading
                 \\ # comment character
                 \s*
                 (
-                  (?<genres>[^a-z]+)?
+                  (?<genres>[^a-z@]+)?
                   \s*
                   (?<sources>@.+)?
                   \s*:
@@ -49,7 +49,7 @@ module Reading
                 )?
                 (?<title>[^@]+)
                 (?<sources>@.+)?
-              \z}x if  segment_index.zero?),
+              \z}x if segment_index.zero?),
               *Column::SHARED_REGEXES[:series_and_extra_info],
             ].compact
           end

data/lib/reading/parsing/rows/custom_config.rb

@@ -0,0 +1,42 @@
+module Reading
+  module Parsing
+    module Rows
+      # A row that declares custom config.
+      module CustomConfig
+        using Util::HashArrayDeepFetch
+
+        # No columns; parsed as if the row were blank.
+        # @return [Array]
+        def self.column_classes
+          []
+        end
+
+        # Starts with a comment character and opening curly brace, and ends with
+        # a closing curly brace.
+        # @param row_string [String]
+        # @return [Boolean]
+        def self.match?(row_string)
+          row_string.match?(
+            %r{\A
+              \s*
+              #{Regexp.escape(Config.hash.fetch(:comment_character))}
+              \s*
+              \{.+\}
+              \s*
+            \z}x
+          )
+        end
+
+        # Adds this row's custom config to the singleton config.
+        # @param row_string [String]
+        # @param config [Hash] an entire config.
+        def self.merge_custom_config!(row_string)
+          stripped_row = row_string.strip.delete_prefix(Config.hash.fetch(:comment_character))
+          custom_config = eval(stripped_row)
+
+          Config.hash.merge!(custom_config)
+        end
+      end
+    end
+  end
+end

data/lib/reading/parsing/rows/regular.rb

@@ -1,13 +1,13 @@
-require_relative "column"
-require_relative "regular_columns/rating"
-require_relative "regular_columns/head"
-require_relative "regular_columns/sources"
-require_relative "regular_columns/start_dates"
-require_relative "regular_columns/end_dates"
-require_relative "regular_columns/genres"
-require_relative "regular_columns/length"
-require_relative "regular_columns/notes"
-require_relative "regular_columns/history"
+require_relative 'column'
+require_relative 'regular_columns/rating'
+require_relative 'regular_columns/head'
+require_relative 'regular_columns/sources'
+require_relative 'regular_columns/start_dates'
+require_relative 'regular_columns/end_dates'
+require_relative 'regular_columns/genres'
+require_relative 'regular_columns/length'
+require_relative 'regular_columns/notes'
+require_relative 'regular_columns/history'
 
 module Reading
   module Parsing
@@ -20,12 +20,13 @@ module Reading
           [Rating, Head, Sources, StartDates, EndDates, Genres, Length, Notes, History]
         end
 
-        # Does not start with a comment character.
+        # Does not start with a comment character. Note: this must be called
+        # *after* calling ::match? on Rows::Blank, because that one catches
+        # blank lines.
         # @param row_string [String]
-        # @param config [Hash]
         # @return [Boolean]
-        def self.match?(row_string, config)
-          !row_string.lstrip.start_with?(config.fetch(:comment_character))
+        def self.match?(row_string)
+          !row_string.lstrip.start_with?(Config.hash.fetch(:comment_character))
         end
       end
     end

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

@@ -15,16 +15,16 @@ module Reading
                 )
                 (\s+|\z)
               )
-              # each or repetitions, used in conjunction with the History column
+              # each and repetitions are used in conjunction with the History column
+              # each
               (
-                # each
                 (?<each>each)
-                |
-                # repetitions
-                (
-                  x
-                  (?<repetitions>\d+)
-                )
+                (\s+|\z)
+              )?
+              # repetitions
+              (
+                x
+                (?<repetitions>\d+)
               )?
             \z}x]
           end

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

@@ -6,17 +6,12 @@ module Reading
         # and https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#sources-column-variants
         class Sources < Column
           SOURCES_PARSING_ERRORS = {
-            "Missing comma before URL(s) in the Sources column" =>
-              ->(source) {
-                source.match?(/\shttps?:\/\//) || source.scan(/https?:\/\//).count > 1
-              },
-            "The ISBN/ASIN must be placed after sources in the Sources column" =>
+            "The ISBN/ASIN must be placed last in the Sources column" =>
               ->(source) {
                 source.match?(/\A#{ISBN_REGEX}/o) || source.match(/\A#{ASIN_REGEX}/o)
               },
           }
 
-
           def self.split_by_format?
             true
           end
@@ -32,7 +27,18 @@ module Reading
           def self.tweaks
             {
               sources: -> {
-                sources = _1.split(/\s*,\s*/)
+                comma = /\s*,\s*/
+                space_before_url = / (?=https?:\/\/)/
+                sources = _1.split(Regexp.union(comma, space_before_url))
+
+                # Split by space after URL.
+                sources = sources.flat_map { |src|
+                  if src.match?(/\Ahttps?:\/\//)
+                    src.split(" ", 2)
+                  else
+                    src
+                  end
+                }
 
                 SOURCES_PARSING_ERRORS.each do |message, check|
                   if sources.any? { |source| check.call(source) }
@@ -58,7 +64,7 @@ module Reading
                   |
                   (?<length_time>\d+:\d\d)
                 )?
-              \z}x if  segment_index.zero?),
+              \z}x if segment_index.zero?),
               # sources, ISBN/ASIN, length
               (%r{\A
                 (
@@ -78,14 +84,14 @@ module Reading
                   |
                   (?<length_time>\d+:\d\d)
                 )?
-              \z}xo if  segment_index.zero?),
+              \z}xo if segment_index.zero?),
               *Column::SHARED_REGEXES[:series_and_extra_info],
             ].compact
           end
 
           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/parsing/transformer.rb

@@ -1,12 +1,12 @@
-require_relative "attributes/shared"
-require_relative "attributes/attribute"
-require_relative "attributes/rating"
-require_relative "attributes/author"
-require_relative "attributes/title"
-require_relative "attributes/genres"
-require_relative "attributes/variants"
-require_relative "attributes/experiences"
-require_relative "attributes/notes"
+require_relative 'attributes/shared'
+require_relative 'attributes/attribute'
+require_relative 'attributes/rating'
+require_relative 'attributes/author'
+require_relative 'attributes/title'
+require_relative 'attributes/genres'
+require_relative 'attributes/variants'
+require_relative 'attributes/experiences'
+require_relative 'attributes/notes'
 
 module Reading
   module Parsing
@@ -20,13 +20,9 @@ module Reading
       using Util::HashArrayDeepFetch
       using Util::HashCompactByTemplate
 
-      attr_reader :config
       private attr_reader :attributes
 
-      # @param config [Hash] an entire config.
-      def initialize(config)
-        @config = config
-
+      def initialize
         set_attributes
       end
 
@@ -40,7 +36,7 @@ module Reading
           raise InvalidHeadError, "Blank or missing Head column"
         end
 
-        template = config.deep_fetch(:item, :template)
+        template = Config.hash.deep_fetch(:item, :template)
 
         parsed_row[:head].map.with_index { |_head, head_index|
           template.map { |attribute_name, default_value|
@@ -58,11 +54,11 @@ module Reading
       # Sets the attributes classes which do all the transforming work.
       # See parsing/attributes/*.
       def set_attributes
-        @attributes ||= config.deep_fetch(:item, :template).map { |attribute_name, _default|
+        @attributes ||= Config.hash.deep_fetch(:item, :template).map { |attribute_name, _default|
           attribute_name_camelcase = attribute_name.to_s.split("_").map(&:capitalize).join
           attribute_class = Attributes.const_get(attribute_name_camelcase)
 
-          [attribute_name, attribute_class.new(config)]
+          [attribute_name, attribute_class.new]
         }.to_h
       end
     end