reading 0.7.0 → 0.9.0

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

@@ -1,4 +1,4 @@
-require_relative "spans_validator"
+require_relative 'spans_validator'
 
 module Reading
   module Parsing
@@ -16,18 +16,18 @@ module Reading
           # many days, for example.
           AVERAGE_DAYS_IN_A_MONTH = 30.437r
 
-          private attr_reader :parsed_row, :config
+          private attr_reader :parsed_row, :head_index
 
           # @param parsed_row [Hash] a parsed row (the intermediate hash).
-          # @param config [Hash] an entire config
-          def initialize(parsed_row, config)
+          # @param head_index [Integer] current item's position in the Head column.
+          def initialize(parsed_row, head_index)
             @parsed_row = parsed_row
-            @config = config
+            @head_index = head_index
           end
 
           # Extracts experiences from the parsed row.
           # @return [Array<Hash>] an array of experiences; see
-          #   Config#default_config[:item_template][:experiences]
+          #   Config#default_config[:item][:template][:experiences]
           def transform
             experiences = parsed_row[:history].map { |entries|
               {
@@ -37,8 +37,7 @@ module Reading
               }
             }
 
-            # Raises an error if experiences overlap or are out of order.
-            Experiences::SpansValidator.validate(experiences, config, history_column: true)
+            Experiences::SpansValidator.validate(experiences, history_column: true)
 
             experiences
           end
@@ -48,13 +47,13 @@ module Reading
           # A shortcut to the span template.
           # @return [Hash]
           def span_template
-            @span_template ||= config.deep_fetch(:item_template, :experiences, 0, :spans).first
+            @span_template ||= Config.hash.deep_fetch(:item, :template, :experiences, 0, :spans).first
           end
 
           # The :spans sub-attribute for the given History column entries.
           # @param entries [Array<Hash>] History entries for one experience.
           # @return [Array<Hash>] an array of spans; see
-          #   Config#default_config[:item_template][:experiences].first[:spans]
+          #   Config#default_config[:item][:template][:experiences].first[:spans]
           def spans_from_history_entries(entries)
             daily_spans = {}
             active = {
@@ -154,6 +153,12 @@ module Reading
               raise InvalidHistoryError, "Missing or incomplete first date"
             end
 
+            if entry[:planned] || (active[:planned] && !start_day)
+              active[:planned] = true
+            elsif active[:planned] && start_day
+              active[:planned] = false
+            end
+
             duplicate_open_range = !start_day && active[:open_range]
             date_range = date_range(entry, active, duplicate_open_range:)
 
@@ -165,9 +170,13 @@ module Reading
             end
             active[:after_single_date] = !date_range
 
+            variant_index = (entry[:variant_index] || 1).to_i - 1
+            format = parsed_row[:sources]&.dig(variant_index)&.dig(:format) ||
+              parsed_row[:head][head_index][:format]
+
             amount =
-              Attributes::Shared.length(entry, key_name: :amount, ignore_repetitions: true) ||
-              Attributes::Shared.length(parsed_row[:length], episodic: true)
+              Attributes::Shared.length(entry, format:, key_name: :amount, ignore_repetitions: true) ||
+              Attributes::Shared.length(parsed_row[:length], format:, episodic: true)
             active[:amount] = amount if amount
 
             progress = Attributes::Shared.progress(entry)
@@ -178,7 +187,7 @@ module Reading
             # https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#history-pages-and-stopping-points-books
             if !amount && progress
               if progress.is_a? Float
-                total_length = Attributes::Shared.length(parsed_row[:length])
+                total_length = Attributes::Shared.length(parsed_row[:length], format:)
                 amount = total_length * progress
               else
                 amount = progress
@@ -202,7 +211,9 @@ module Reading
               span_without_dates = {
                 dates: nil,
                 amount: daily_amount || span_template[:amount],
-                progress: (progress unless amount_from_progress) || span_template[:progress],
+                progress: (progress unless amount_from_progress) ||
+                  (0.0 if entry[:planned] || active[:planned]) ||
+                  span_template[:progress],
                 name: entry[:name] || span_template[:name],
                 favorite?: !!entry[:favorite] || span_template[:favorite?],
                 # Temporary keys (not in the final item data) for marking
@@ -213,17 +224,15 @@ module Reading
                 amount_from_progress: amount_from_progress,
               }
 
-              if entry[:planned] || (active[:planned] && !start_day)
+              if entry[:planned] || active[:planned]
                 date = nil
-                active[:planned] = true
               end
 
               key = [date, span_without_dates[:name]]
 
-              # When any entry in an open range lacks a name, add a random
-              # number to the key so that it does not overwrite a different
-              # entry in the open range that also lacks a name.
-              if in_open_range && !entry[:name]
+              # For entries in an open range, add a random number to the key to
+              # avoid overwriting entries with the same name, or lacking a name.
+              if in_open_range
                 key << rand
               end
 
@@ -304,11 +313,11 @@ module Reading
           # Distributes an amount across the given date(s).
           # @param date_or_range [Date, Range<Date>] the date or range across
           #   which the amount will be split up.
-          # @param amount [Float, Integer, Reading::Item::TimeLength] amount in
+          # @param amount [Float, Integer, Item::TimeLength] amount in
           #   pages or time.
           # @param repetitions [Integer] e.g. "x4" in a History entry.
           # @param frequency [Integer] e.g. "/week" in a History entry.
-          # @return [Hash{Date => Float, Integer, Reading::Item::TimeLength}]
+          # @return [Hash{Date => Float, Integer, Item::TimeLength}]
           def distribute_amount_across_date_range(date_or_range, amount, repetitions, frequency)
             unless amount
               raise InvalidHistoryError, "Missing length or amount"

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,28 +38,28 @@ 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
             # if there is more than one more start date than end dates.
             # @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) }
+              _both_dates, not_both_dates = experiences
+                .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
@@ -13,13 +13,13 @@ module Reading
         # @param parsed_row [Hash] a parsed row (the intermediate hash).
         # @param head_index [Integer] current item's position in the Head column.
         # @return [Array<Hash>] an array of experiences; see
-        #   Config#default_config[:item_template][:experiences]
+        #   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/notes.rb

@@ -6,7 +6,7 @@ module Reading
         # @param parsed_row [Hash] a parsed row (the intermediate hash).
         # @param _head_index [Integer] current item's position in the Head column.
         # @return [Array<Hash>] an array of notes; see
-        #   Config#default_config[:item_template][:notes]
+        #   Config#default_config[:item][:template][:notes]
         def transform_from_parsed(parsed_row, _head_index)
           parsed_row[:notes]&.map { |note|
             {

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

@@ -1,16 +1,19 @@
 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.
-        # @return [Float, Integer, Reading::Item::TimeLength]
+        # @return [Float, Integer, Item::TimeLength]
         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
@@ -29,16 +34,16 @@ module Reading
         #   that e.g. "1:00 x14" gives a length of 1 hour instead of 14 hours.
         #   This is useful for the History column, where that 1 hour can be used
         #   as the default amount.
-        # @return [Float, Integer, Reading::Item::TimeLength]
-        def self.length(hash, key_name: :length, episodic: false, ignore_repetitions: false)
+        # @return [Float, Integer, Item::TimeLength]
+        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,23 +4,26 @@ 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.
         # @return [Array<Hash>] an array of variants; see
-        #   Config#default_config[:item_template][:variants]
+        #   Config#default_config[:item][:template][:variants]
         def transform_from_parsed(parsed_row, head_index)
           head = parsed_row[:head][head_index]
 
           # || [{}] 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,24 +1,13 @@
-# 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_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 "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
-    # parses it into item data (an array of Structs).
+    # 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:
     #   (1) Parse a row string into an intermediate hash representing the columns.
@@ -31,69 +20,94 @@ module Reading
     # inspired by the Parslet gem: https://kschiess.github.io/parslet/transform.html
     #
     class CSV
-      using Util::HashToStruct
-
-      private attr_reader :parser, :transformer
+      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; if nil, stream is used instead.
-      # @param stream [Object] an object responding to #each_linewith CSV row(s);
-      #   used if no path is given.
-      # @param config [Hash] a custom config which overrides the defaults,
+      # @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, Config] a custom config which overrides the defaults,
       #   e.g. { errors: { styling: :html } }
-      def initialize(path = nil, stream: nil, config: {})
-        validate_path_or_stream(path, stream)
-        full_config = Config.new(config).hash
+      # @param hash_output [Boolean] whether an array of raw Hashes should be
+      #   returned, without Items being created from them.
+      # @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.
+      # @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
-        @parser = Parser.new(full_config)
-        @transformer = Transformer.new(full_config)
+        @lines = lines
+        @hash_output = hash_output
+        @item_view = item_view
+        @parser = Parser.new
+        @transformer = Transformer.new
+        @error_handler = error_handler
+        @pastel = Pastel.new
       end
 
       # Parses and transforms the reading log into item data.
-      # @return [Array<Struct>] an array of Structs like the template in
-      #   Config#default_config[:item_template]. The Structs are identical in
-      #   structure to that Hash (with every inner Hash replaced by a Struct).
+      # @return [Array<Item>] an array of Items like the template in
+      #   Config#default_config[:item][:template]. The Items are identical in
+      #   structure to that Hash (with every inner Hash replaced by a Data for
+      #   dot access).
       def parse
-        input = @path ? File.open(@path) : @stream
+        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
         end
 
-        items.map(&:to_struct)
+        if hash_output
+          items
+        else
+          items.map { |item_hash| Item.new(item_hash, view: item_view) }
+        end
       ensure
         input&.close if input.respond_to?(:close)
       end
 
       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 path
+      # @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)
             raise FileError, "File not found! #{path}"
           elsif File.directory?(path)
             raise FileError, "A file is expected, but the path given is a directory: #{path}"
           end
-        elsif stream && stream.respond_to?(:each_line)
-          return true
         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
 
@@ -75,15 +69,20 @@ module Reading
       # @return [Hash{Class => String}] a hash whose keys are classes inheriting
       #   Parsing::Rows::Column.
       def extract_columns(string)
-        clean_string = string.dup.force_encoding(Encoding::UTF_8)
-        column_strings = clean_string.split(config.fetch(:column_separator))
+        string = string.dup.force_encoding(Encoding::UTF_8)
+        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