reading 0.8.0 → 0.9.0

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

@@ -11,24 +11,23 @@ module Reading
             # Checks the dates in the given experiences hash, and raises an error
             # at the first invalid date found.
             # @param experiences [Array<Hash>] experience hashes.
-            # @param config [Hash] an entire config.
             # @param history_column [Boolean] whether this validation is for
             #   experiences from the History column.
             # @raise [InvalidDateError] if any date is invalid.
-            def validate(experiences, config, history_column: false)
-              if both_date_columns?(config)
+            def validate(experiences, history_column: false)
+              if both_date_columns?
                 validate_number_of_start_dates_and_end_dates(experiences)
               end
 
-              if start_dates_column?(config) || history_column
+              if start_dates_column? || history_column
                 validate_start_dates_are_in_order(experiences)
               end
 
-              if end_dates_column?(config) || history_column
+              if end_dates_column? || history_column
                 validate_end_dates_are_in_order(experiences)
               end
 
-              if both_date_columns?(config) || history_column
+              if both_date_columns? || history_column
                 validate_experiences_of_same_variant_do_not_overlap(experiences)
               end
 
@@ -39,20 +38,20 @@ module Reading
 
             # Whether the Start Dates column is enabled.
             # @return [Boolean]
-            def start_dates_column?(config)
-              config.fetch(:enabled_columns).include?(:start_dates)
+            def start_dates_column?
+              Config.hash.fetch(:enabled_columns).include?(:start_dates)
             end
 
             # Whether the End Dates column is enabled.
             # @return [Boolean]
-            def end_dates_column?(config)
-              config.fetch(:enabled_columns).include?(:end_dates)
+            def end_dates_column?
+              Config.hash.fetch(:enabled_columns).include?(:end_dates)
             end
 
             # Whether both the Start Dates and End Dates columns are enabled.
             # @return [Boolean]
-            def both_date_columns?(config)
-              start_dates_column?(config) && end_dates_column?(config)
+            def both_date_columns?
+              start_dates_column? && end_dates_column?
             end
 
             # Raises an error if there are more end dates than start dates, or
@@ -60,7 +59,7 @@ module Reading
             # @raise [InvalidDateError]
             def validate_number_of_start_dates_and_end_dates(experiences)
               _both_dates, not_both_dates = experiences
-                .filter { |exp| exp[:spans].first&.dig(:dates) }
+                .select { |exp| exp[:spans].first&.dig(:dates) }
                 .map { |exp| [exp[:spans].first[:dates].begin, exp[:spans].last[:dates].end] }
                 .partition { |start_date, end_date| start_date && end_date }
 
@@ -76,7 +75,7 @@ module Reading
             # @raise [InvalidDateError]
             def validate_start_dates_are_in_order(experiences)
               experiences
-                .filter { |exp| exp[:spans].first&.dig(:dates) }
+                .select { |exp| exp[:spans].first&.dig(:dates) }
                 .map { |exp| exp[:spans].first[:dates].begin }
                 .each_cons(2) do |a, b|
                   if (a.nil? && b.nil?) || (a && b && a > b )
@@ -89,8 +88,8 @@ module Reading
             # @raise [InvalidDateError]
             def validate_end_dates_are_in_order(experiences)
               experiences
-                .filter { |exp| exp[:spans].first&.dig(:dates) }
-                .map { |exp| exp[:spans].last[:dates].end }
+                .select { |exp| exp[:spans].first&.dig(:dates) }
+                .map { |exp| exp[:spans].last[:dates]&.end }
                 .each_cons(2) do |a, b|
                   if (a.nil? && b.nil?) || (a && b && a > b )
                     raise InvalidDateError, "End dates are not in order"
@@ -104,7 +103,7 @@ module Reading
               experiences
                 .group_by { |exp| exp[:variant_index] }
                 .each do |_variant_index, exps|
-                  exps.filter { |exp| exp[:spans].any? }.each_cons(2) do |a, b|
+                  exps.select { |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) ||
@@ -116,11 +115,11 @@ module Reading
             end
 
             # Raises an error if the spans within an experience are out of order
-            # or if the spans overlap.
+            # or if the spans overlap. Spans with nil dates are not considered.
             # @raise [InvalidDateError]
             def validate_spans_are_in_order_and_not_overlapping(experiences)
               experiences
-                .filter { |exp| exp[:spans].first&.dig(:dates) }
+                .select { |exp| exp[:spans].first&.dig(:dates) }
                 .each do |exp|
                   exp[:spans]
                     .map { |span| span[:dates] }

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

@@ -1,6 +1,6 @@
-require "date"
-require_relative "experiences/history_transformer"
-require_relative "experiences/dates_and_head_transformer"
+require 'date'
+require_relative 'experiences/history_transformer'
+require_relative 'experiences/dates_and_head_transformer'
 
 module Reading
   module Parsing
@@ -16,10 +16,10 @@ module Reading
         #   Config#default_config[:item][:template][:experiences]
         def transform_from_parsed(parsed_row, head_index)
           if !parsed_row[:history].blank?
-            return HistoryTransformer.new(parsed_row, config).transform
+            return HistoryTransformer.new(parsed_row, head_index).transform
           end
 
-          DatesAndHeadTransformer.new(parsed_row, head_index, config).transform
+          DatesAndHeadTransformer.new(parsed_row, head_index).transform
         end
       end
     end

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

@@ -1,8 +1,11 @@
 module Reading
   module Parsing
     module Attributes
-      # Shared
+      # Sub-attributes that are shared across multiple attributes.
       module Shared
+        using Util::HashArrayDeepFetch
+        using Util::NumericToIIfWhole
+
         # Extracts the :progress sub-attribute (percent, pages, or time) from
         # the given hash.
         # @param hash [Hash] any parsed hash that contains progress.
@@ -10,7 +13,7 @@ module Reading
         def self.progress(hash)
           hash[:progress_percent]&.to_f&./(100) ||
             hash[:progress_pages]&.to_i ||
-            hash[:progress_time]&.then { Item::TimeLength.parse _1 } ||
+            hash[:progress_time]&.then { Item::TimeLength.parse(_1) } ||
             (0 if hash[:progress_dnf]) ||
             (1.0 if hash[:progress_done]) ||
             nil
@@ -18,6 +21,8 @@ module Reading
 
         # Extracts the :length sub-attribute (pages or time) from the given hash.
         # @param hash [Hash] any parsed hash that contains length.
+        # @param format [Symbol] the item format, which affects length in cases
+        #   where Config.hash[:speed][:format] is customized.
         # @param key_name [Symbol] the first part of the keys to be checked.
         # @param episodic [Boolean] whether to look for episodic (not total) length.
         #   If false, returns nil if hash contains :each. If true, returns a
@@ -30,15 +35,15 @@ module Reading
         #   This is useful for the History column, where that 1 hour can be used
         #   as the default amount.
         # @return [Float, Integer, Item::TimeLength]
-        def self.length(hash, key_name: :length, episodic: false, ignore_repetitions: false)
+        def self.length(hash, format:, key_name: :length, episodic: false, ignore_repetitions: false)
           return nil unless hash
 
           length = hash[:"#{key_name}_pages"]&.to_i ||
-            hash[:"#{key_name}_time"]&.then { Item::TimeLength.parse _1 }
+            hash[:"#{key_name}_time"]&.then { Item::TimeLength.parse(_1) }
 
           return nil unless length
 
-          if hash[:each]
+          if hash[:each] && !hash[:repetitions]
             # Length is calculated based on History column in this case.
             if episodic
               return length
@@ -54,7 +59,9 @@ module Reading
             return nil if episodic && !hash[:each]
           end
 
-          length
+          speed = Config.hash.deep_fetch(:speed, :format)[format] || 1.0
+
+          (length / speed).to_i_if_whole
         end
       end
     end

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