reading 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e839c46251c307a65a234a9a374ad964f68d934d974005d6aa38cbb35e10f756
-  data.tar.gz: fa20c0b78f3fd1194495e1e604bb1d95b37e0334ac12c745d6508e026cd6fe97
+  metadata.gz: 45b4a37abfdadf33aafc7cd1af59affdd341ebc006d07797c38fcde27d1f2198
+  data.tar.gz: 6214d4783c4b861e162d6df141c991a324072b1ad749bc1370d400c6b6d860f1
 SHA512:
-  metadata.gz: 2bbca1450b2f6ae4c0d2b6d4cfeec495bf30b20639fcb3a5b121711e1d995a8b13a5ca64100d7a5e11d00d60c3808d61d25583510e3cd19902d412eca216154f
-  data.tar.gz: 74a676238941cdd5a0a7ecf8b2a4ed3c705883daadc25b3710a17eb9e325ec294d8b9fad71e653779af1ea9e01d0e8fed6423592dbe750b4f37c79f0f690387d
+  metadata.gz: 999323aac5ada251e74eec14107200e570fa52bf829ef35c52101647b81b1245888b0d50dca3c7eec0c1b1bcd3442f320085d46b28fcff3b1c3e0e8953fe797d
+  data.tar.gz: fcfd05d49225306a73ad3f3dbdae29aa311d9b2e29a05118e2b0cbd02ac7948a6b8781849d5680ceb4ea7a2e219bffc410cbd771d07e27d3b81621e0db6e67d9

data/bin/reading

@@ -13,12 +13,12 @@
 #   reading '3|📕Trying|Little Library 1970147288'
 #   reading '📕Trying|Little Library 1970147288' 'head, sources'
 
-require 'debug'
-require_relative '../lib/reading'
-require_relative '../lib/reading/stats/terminal_result_formatters'
-require 'amazing_print'
-require 'readline'
-require 'pastel'
+require_relative "../lib/reading"
+require_relative "../lib/reading/stats/result_formatters"
+require "debug"
+require "amazing_print"
+require "readline"
+require "pastel"
 
 EXIT_COMMANDS = %w[exit e quit q]
 PASTEL = Pastel.new
@@ -38,26 +38,33 @@ GROUP_HEADING_FORMATTERS = [
 def print_grouped_results(grouped_results, group_heading_formatters)
   indent_level = GROUP_HEADING_FORMATTERS.count - group_heading_formatters.count
 
-  if grouped_results.nil? || grouped_results.empty?
+  if grouped_results.nil? || (grouped_results.respond_to?(:empty?) && grouped_results.empty?)
     puts "  " * indent_level + PASTEL.bright_black("none") + "\n"
     return
-  elsif !grouped_results.is_a? Hash
-    puts "  " * indent_level + grouped_results.gsub("\n", "\n" + "  " * indent_level) + "\n"
-    return
   end
 
-  grouped_results.each do |group_name, grouped|
-    puts "  " * indent_level + group_heading_formatters.first.call(group_name)
-    print_grouped_results(grouped, group_heading_formatters[1..])
+  if grouped_results.is_a?(Hash) ||
+    (grouped_results.is_a?(Array) && grouped_results.first.length == 2)
+
+    grouped_results.each do |group_name, grouped|
+      puts "  " * indent_level + group_heading_formatters.first.call(group_name)
+      print_grouped_results(grouped, group_heading_formatters[1..])
+    end
+  elsif grouped_results.is_a?(Array)
+    numbered_results = grouped_results.map.with_index { |v, i| "#{i + 1}. #{v}" }
+
+    puts "  " * indent_level + numbered_results.join("\n" + "  " * indent_level) + "\n"
+  else
+    puts "  " * indent_level + grouped_results.to_s + "\n"
   end
 end
 
 input = ARGV[0]
 unless input
   raise ArgumentError,
-    "Argument required, either a CSV file path or a CSV string. Examples:\n" \
-    "parsereading /home/felipe/reading.csv\n" \
-    "parsereading '3|📕Trying|Little Library 1970147288'"
+    "Argument required, either a CSV file path or a CSV string.\nExamples:\n" \
+    "reading /home/felipe/reading.csv\n" \
+    "reading '3|📕Trying|Little Library 1970147288'"
 end
 
 if ARGV[1]
@@ -65,7 +72,7 @@ if ARGV[1]
   Reading::Config.build(enabled_columns:)
 end
 
-input_is_csv_path = input.end_with?('.csv')
+input_is_csv_path = input.end_with?(".csv") || input.end_with?(".txt")
 
 if input_is_csv_path
   error_handler = ->(e) { puts "Skipped a row due to a parsing error: #{e}" }
@@ -86,11 +93,19 @@ if input_is_csv_path
       result_formatters: Reading::Stats::ResultFormatters::TERMINAL,
     )
 
-    print_grouped_results(results, GROUP_HEADING_FORMATTERS)
+    if results.is_a?(Array) && results.first.is_a?(Reading::Item) # `debug` operation
+      r = results
+      puts PASTEL.red.bold("Enter 'c' to leave the debugger.")
+      debugger
+    else
+      print_grouped_results(results, GROUP_HEADING_FORMATTERS)
+    end
   rescue Reading::Error => e
     puts e
   end
 else # CSV string arg
+  input = input.gsub("\\|", "|") # because some pipes are escaped when pasting into the terminal
+
   begin
     item_hashes = Reading.parse(lines: input, hash_output: true, item_view: false)
   rescue Reading::Error => e

data/lib/reading/config.rb

@@ -1,4 +1,4 @@
-require_relative 'errors'
+require_relative "errors"
 
 module Reading
   # Builds a singleton hash config.
@@ -178,8 +178,8 @@ module Reading
                     spans:
                       [{
                         dates: nil,
-                        progress: 1.0,
                         amount: 0,
+                        progress: 1.0,
                         name: nil,
                         favorite?: false,
                       }],

data/lib/reading/item/time_length.rb

@@ -18,7 +18,7 @@ module Reading
       def self.parse(string)
         return nil unless string.match? /\A\d+:\d\d\z/
 
-        hours, minutes = string.split(':').map(&:to_i)
+        hours, minutes = string.split(":").map(&:to_i)
         new((hours * 60) + minutes)
       end
 
@@ -51,7 +51,7 @@ module Reading
       # A string in "h:mm" format.
       # @return [String]
       def to_s
-        "#{hours}:#{minutes.round.to_s.rjust(2, '0')} or #{(value / 60.0 * Config.hash.fetch(:pages_per_hour)).round} pages"
+        "#{hours}:#{minutes.round.to_s.rjust(2, "0")} or #{(value / 60.0 * Config.hash.fetch(:pages_per_hour)).round} pages"
       end
 
       # To pages.

data/lib/reading/item/view.rb

@@ -47,7 +47,7 @@ module Reading
         item.variants.map { |variant|
           isbn = variant.isbn
           if isbn
-            url = Config.hash.deep_fetch(:item, :view, :url_from_isbn).sub('%{isbn}', isbn)
+            url = Config.hash.deep_fetch(:item, :view, :url_from_isbn).sub("%{isbn}", isbn)
           else
             url = variant.sources.map { |source| source.url }.compact.first
           end
@@ -108,7 +108,7 @@ module Reading
         if item.done?
           item.last_end_date&.strftime("%Y-%m-%d")
         else
-          item.status.to_s.gsub('_', ' ')
+          item.status.to_s.gsub("_", " ")
         end
       end
     end

data/lib/reading/item.rb

@@ -1,6 +1,6 @@
-require 'forwardable'
+require "forwardable"
 
-require_relative 'item/view'
+require_relative "item/view"
 
 module Reading
   # A wrapper for an item parsed from a CSV reading log, providing convenience
@@ -119,12 +119,11 @@ module Reading
       before_index = nil
       middle_indices = experiences.map.with_index { |experience, i|
         if experience.spans.first.dates &&
-          experience.spans.first.dates.begin < date &&
-          experience.last_end_date
+          experience.spans.first.dates.begin < date
 
           before_index = i
 
-          if experience.last_end_date >= date
+          if (experience.last_end_date || Date.today) >= date
             i
           else
             nil
@@ -133,15 +132,14 @@ module Reading
       }
       .compact
 
-      # There are no experiences with done spans that overlap the date.
+      # There are no experiences with spans that overlap the date.
       if middle_indices.none?
         # The Item is planned.
         return [] if experiences.none? { _1.spans.first.dates }
         # date is after all spans.
         return [self, nil] if experiences.all? { _1.last_end_date && date > _1.last_end_date }
-        # date is before all spans, or overlaps with an in-progress span.
-        return [nil, self] if experiences.all? { _1.spans.first.dates.begin >= date } ||
-          experiences.any? { _1.spans.first.dates.begin < date && _1.last_end_date.nil? }
+        # date is before all spans.
+        return [nil, self] if experiences.all? { _1.spans.first.dates.begin >= date }
 
         # Date is in between experiences.
         if before_index
@@ -173,7 +171,7 @@ module Reading
             if span.dates && span.dates.begin < date
               before_index = i
 
-              span.dates.end >= date
+              (span.dates.end || Date.today) >= date
             end
           }
 
@@ -183,15 +181,20 @@ module Reading
         else
           span_middle = experience_middle.spans[span_middle_index]
 
+          unless span_middle.dates.end
+            end_today_instead_of_endless = { dates: span_middle.dates.begin..Date.today }
+            span_middle = span_middle.to_h.merge(end_today_instead_of_endless).to_data
+          end
+
           dates_before = span_middle.dates.begin..date.prev_day
-          amount_before = span_middle.amount * (dates_before.count / span_middle.dates.count.to_f)
+          amount_before = (span_middle.amount || 0) * (dates_before.count / span_middle.dates.count.to_f)
           span_middle_before = span_middle.with(
             dates: dates_before,
             amount: amount_before,
           )
 
           dates_after = date..span_middle.dates.end
-          amount_after = span_middle.amount * (dates_after.count / span_middle.dates.count.to_f)
+          amount_after = (span_middle.amount || 0) * (dates_after.count / span_middle.dates.count.to_f)
           span_middle_after = span_middle.with(
             dates: dates_after,
             amount: amount_after,

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

@@ -1,4 +1,4 @@
-require_relative 'spans_validator'
+require_relative "spans_validator"
 
 module Reading
   module Parsing
@@ -29,7 +29,10 @@ module Reading
             start_dates = Array.new(size) { |i| parsed_row[:start_dates]&.dig(i) || {} }
             end_dates = Array.new(size) { |i| parsed_row[:end_dates]&.dig(i) || nil }
 
-            start_end_dates = start_dates.zip(end_dates).presence || [[{}, nil]]
+            start_end_dates = start_dates
+              .reject { _1[:planned] }
+              .zip(end_dates)
+              .presence || [[{}, nil]]
 
             experiences_with_dates = start_end_dates.map { |start_entry, end_entry|
               {
@@ -85,12 +88,14 @@ module Reading
               parsed_row[:head][head_index][:format]
             length = Attributes::Shared.length(parsed_row[:sources]&.dig(variant_index), format:) ||
               Attributes::Shared.length(parsed_row[:length], format:)
+            no_end_date = !dates.end if dates &&
+              Config.hash.fetch(:enabled_columns).include?(:end_dates)
 
             [
               {
                 dates: dates,
                 amount: (length if dates),
-                progress: Attributes::Shared.progress(start_entry) ||
+                progress: Attributes::Shared.progress(start_entry, no_end_date:) ||
                   Attributes::Shared.progress(parsed_row[:head][head_index]) ||
                   (1.0 if end_entry),
                 name: span_template.fetch(:name),

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

@@ -1,5 +1,16 @@
-require_relative 'spans_validator'
-
+require_relative "spans_validator"
+
+# TODO Refactor! This entire file has become 🤢🤮 with the accumulation of new
+# features in the History column.
+#
+# Goals of the refactor:
+#   - if possible, avoid daily_spans; build spans with date ranges directly.
+#   - validate spans at every step; that way the origin of bugs will be easier
+#     to find, e.g. for the bug fixed in 6310639, spans became invalid in
+#     #fix_open_ranges! and led to an error elsewhere that didn't give a trace
+#     back to the origin.
+#   - to facilitate the points above, create a class ExperienceBuilder to
+#     contain much of the logic that is currently in this file.
 module Reading
   module Parsing
     module Attributes
@@ -16,13 +27,14 @@ module Reading
           # many days, for example.
           AVERAGE_DAYS_IN_A_MONTH = 30.437r
 
-          private attr_reader :parsed_row, :head_index
+          private attr_reader :parsed_row, :head_index, :next_open_range_id
 
           # @param parsed_row [Hash] a parsed row (the intermediate hash).
           # @param head_index [Integer] current item's position in the Head column.
           def initialize(parsed_row, head_index)
             @parsed_row = parsed_row
             @head_index = head_index
+            @next_open_range_id = 0
           end
 
           # Extracts experiences from the parsed row.
@@ -61,16 +73,21 @@ module Reading
               month: nil,
               day: nil,
               after_single_date: false,
-              open_range: false,
+              open_range_id: nil,
               planned: false,
               amount: nil,
+              repetitions: nil,
+              frequency: nil,
               last_start_year: nil,
               last_start_month: nil,
             }
 
+            # Dates after "not" entries.
+            except_dates = []
+
             entries.each do |entry|
               if entry[:except_dates]
-                reject_exception_dates!(entry, daily_spans, active)
+                except_dates += reject_exception_dates!(entry, daily_spans, active)
                 next
               end
 
@@ -79,10 +96,14 @@ module Reading
 
             spans = merge_daily_spans(daily_spans)
 
-            fix_open_ranges!(spans)
+            spans = fix_open_ranges(spans, except_dates)
 
             relativize_amounts_from_progress!(spans)
 
+            remove_last_end_date_of_today_if_open_range!(spans)
+
+            remove_temporary_keys!(spans)
+
             spans
           end
 
@@ -92,6 +113,7 @@ module Reading
           #   date-and-name combination.
           # @param active [Hash] variables that persist across entries, such as
           #   amount and implied date.
+          # @return [Array<Date>] the rejected dates.
           def reject_exception_dates!(entry, daily_spans, active)
             except_active = {
               year: active[:last_start_year],
@@ -122,6 +144,8 @@ module Reading
             daily_spans.reject! do |(date, _name), _span|
               except_dates.include?(date)
             end
+
+            except_dates
           end
 
           # Expands the given entry into one span per day, then adds them to daily_spans.
@@ -145,7 +169,7 @@ module Reading
             active[:month] = start_month if start_month
             active[:last_start_month] = active[:month]
             if start_day
-              active[:open_range] = false
+              active[:open_range_id] = nil
               active[:day] = start_day
             end
 
@@ -159,8 +183,8 @@ module Reading
               active[:planned] = false
             end
 
-            duplicate_open_range = !start_day && active[:open_range]
-            date_range = date_range(entry, active, duplicate_open_range:)
+            duplicate_open_range_id = active[:open_range_id] if !start_day
+            date_range = date_range(entry, active, duplicate_open_range: !!duplicate_open_range_id)
 
             # A startless date range (i.e. with an implied start date) appearing
             # immediately after a single date has its start date bumped forward
@@ -174,13 +198,15 @@ module Reading
             format = parsed_row[:sources]&.dig(variant_index)&.dig(:format) ||
               parsed_row[:head][head_index][:format]
 
-            amount =
-              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)
 
+            amount_from_entry =
+              Attributes::Shared.length(entry, format:, key_name: :amount, ignore_repetitions: true)
+            amount_from_length =
+              Attributes::Shared.length(parsed_row[:length], format:, episodic: progress.nil? || parsed_row.dig(:length, :repetitions).nil?)
+            amount = amount_from_entry || amount_from_length
+            active[:amount] = amount if amount
+
             # If the entry has no amount and the item has no episodic length,
             # then use progress as amount instead. The typical scenario for this
             # is when tracking fixed-length items such as books. See
@@ -195,17 +221,27 @@ module Reading
               amount_from_progress = true
             end
 
-            repetitions = entry[:repetitions]&.to_i || 1
+            repetitions = entry[:repetitions]&.to_i
             frequency = entry[:frequency]
 
+            # If the entry has no amount or progress, default to the previous
+            # repetitions and frequency.
+            unless amount_from_entry || progress || repetitions
+              repetitions = active[:repetitions]
+              frequency = active[:frequency]
+            end
+
+            active[:repetitions] = repetitions if repetitions
+            active[:frequency] = frequency if frequency
+
             amounts_by_date = distribute_amount_across_date_range(
               date_range || Date.new(active[:year], active[:month], active[:day]),
               amount || active[:amount],
-              repetitions,
+              repetitions || 1,
               frequency,
             )
 
-            in_open_range = active[:open_range] || duplicate_open_range
+            open_range_id = active[:open_range_id] || duplicate_open_range_id
 
             daily_spans_from_entry = amounts_by_date.map { |date, daily_amount|
               span_without_dates = {
@@ -219,9 +255,11 @@ module Reading
                 # Temporary keys (not in the final item data) for marking
                 # spans to ...
                 # ... be distributed evenly across an open date range.
-                in_open_range: in_open_range,
+                open_range_id:,
                 # ... have their amounts adjusted to be relative to previous progress.
-                amount_from_progress: amount_from_progress,
+                amount_from_progress?: amount_from_progress,
+                amount_from_frequency?: !!frequency,
+                implied_date_range?: !date_range && !!frequency,
               }
 
               if entry[:planned] || active[:planned]
@@ -232,7 +270,7 @@ module Reading
 
               # 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
+              if open_range_id
                 key << rand
               end
 
@@ -285,7 +323,7 @@ module Reading
             return nil unless entry[:range] || duplicate_open_range
 
             if entry[:end_day]
-              active[:open_range] = false
+              active[:open_range_id] = nil
 
               end_year = entry[:end_year]&.to_i
               end_month = entry[:end_month]&.to_i
@@ -299,11 +337,17 @@ module Reading
               date_range = Date.new(active[:year], active[:month], active[:day])..
                 Date.new(end_year || active[:year], end_month || active[:month], end_day)
 
-              active[:day] = end_day + 1
-              active[:month] = end_month if end_month
-              active[:year] = end_year if end_year
+              date_after_end = date_range.end.next_day
+
+              active[:day] = date_after_end.day
+              active[:month] = date_after_end.month if end_month
+              active[:year] = date_after_end.year if end_year
             else # either starting or continuing (duplicating) an open range
-              active[:open_range] ||= true
+              unless active[:open_range_id]
+                active[:open_range_id] = next_open_range_id
+                @next_open_range_id += 1
+              end
+
               date_range = Date.new(active[:year], active[:month], active[:day])..Date.today
             end
 
@@ -316,7 +360,7 @@ module Reading
           # @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.
+          # @param frequency [String] e.g. "/week" in a History entry.
           # @return [Hash{Date => Float, Integer, Item::TimeLength}]
           def distribute_amount_across_date_range(date_or_range, amount, repetitions, frequency)
             unless amount
@@ -366,33 +410,64 @@ module Reading
           # Set each open date range's last end date (wherever it's today, i.e.
           # it wasn't defined) to the day before the next entry's start date.
           # At the same time, distribute each open range's spans evenly.
-          # Lastly, remove the :in_open_range key from spans.
+          # Lastly, remove the :open_range_id key from spans.
           # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @param except_dates [Date] dates after "not" entries which were
+          #   rejected from spans.
           # @return [Array<Hash>]
-          def fix_open_ranges!(spans)
+          def fix_open_ranges(spans, except_dates)
             chunked_by_open_range = spans.chunk_while { |a, b|
               a[:dates] && b[:dates] && # in case of planned entry
-              a[:dates].begin == b[:dates].begin &&
-                a[:in_open_range] == b[:in_open_range]
+                a[:open_range_id] == b[:open_range_id]
             }
 
-            next_chunk_start_date = nil
+            next_start_date = nil
             chunked_by_open_range
-              .reverse_each { |chunk|
-                unless chunk.first[:in_open_range] && chunk.any? { _1[:dates].end == Date.today }
+              .to_a.reverse.map { |chunk|
+                unless chunk.first[:open_range_id]
                   # safe nav. in case of planned entry
-                  next_chunk_start_date = chunk.first[:dates]&.begin
-                  next
+                  next_start_date = chunk.first[:dates]&.begin
+                  next chunk
                 end
 
-                # Set last end date.
-                if chunk.last[:dates].end == Date.today && next_chunk_start_date
-                  chunk.last[:dates] = chunk.last[:dates].begin..next_chunk_start_date.prev_day
+                # Filter out spans that begin after the next chunk's start date.
+                if next_start_date
+                  chunk.reject! do |span|
+                    span[:dates].begin >= next_start_date
+                  end
                 end
-                next_chunk_start_date = chunk.first[:dates].begin
+
+                # For the remaining spans (which begin before the next chunk's
+                # start date), bound each end date to that date.
+                chunk.reverse_each do |span|
+                  if !next_start_date
+                    next_start_date = span[:dates].begin
+                    next
+                  end
+
+                  if span[:dates].end >= next_start_date
+                    new_dates = span[:dates].begin..next_start_date.prev_day
+
+                    if span[:amount_from_frequency?]
+                      new_to_old_dates_ratio = new_dates.count / span[:dates].count.to_f
+                      span[:amount] = (span[:amount] * new_to_old_dates_ratio).to_i_if_whole
+                    end
+
+                    span[:dates] = new_dates
+                  end
+
+                  next_start_date = span[:dates].begin if span[:dates].begin < next_start_date
+                end
+
+                if !next_start_date || chunk.first[:dates].begin < next_start_date
+                  next_start_date = chunk.first[:dates].begin
+                end
+
+                next chunk if chunk.map { |span| span[:open_range_id] }.uniq.count == 1 &&
+                  chunk.map { |span| span[:dates].begin }.uniq.count > 1
 
                 # Distribute spans across the open date range.
-                total_amount = chunk.sum { |c| c[:amount] }
+                total_amount = chunk.sum { |span| span[:amount] }
                 dates = chunk.last[:dates]
                 amount_per_day = total_amount / dates.count.to_f
 
@@ -400,6 +475,7 @@ module Reading
                 last_end_date = chunk.last[:dates].end
 
                 span = nil
+                chunk_dup = chunk.dup
                 amount_acc = 0
                 span_needing_end = nil
                 dates.each do |date|
@@ -409,8 +485,8 @@ module Reading
                   end
 
                   while amount_acc < amount_per_day
-                    break if chunk.empty?
-                    span = chunk.shift
+                    break if chunk_dup.empty?
+                    span = chunk_dup.shift
                     amount_acc += span[:amount]
 
                     if amount_acc < amount_per_day
@@ -427,11 +503,11 @@ module Reading
                 end
 
                 span[:dates] = span[:dates].begin..last_end_date
-              }
 
-            spans.each do |span|
-              span.delete(:in_open_range)
-            end
+                chunk
+              }
+              .reverse
+              .flatten
           end
 
           # Changes amounts taken from progress, from absolute to relative,
@@ -443,15 +519,42 @@ module Reading
           def relativize_amounts_from_progress!(spans)
             amount_acc = 0
             spans.each do |span|
-              if span[:amount_from_progress]
+              if span[:amount_from_progress?]
                 span[:amount] -= amount_acc
               end
 
               amount_acc += span[:amount]
             end
+          end
+
+          # Removes the end date from the last span if it's today, and if it was
+          # written as an open range.
+          # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @return [Array<Hash>]
+          def remove_last_end_date_of_today_if_open_range!(spans)
+            if spans.last[:dates] &&
+              spans.last[:dates].end == Date.today &&
+              (spans.last[:open_range_id] || spans.last[:implied_date_range?])
+
+              spans.last[:dates] = spans.last[:dates].begin..
+            end
+          end
+
+          # Removes all keys that shouldn't be in the final item data.
+          # @param spans [Array<Hash>] spans after being merged from daily_spans.
+          # @return [Array<Hash>]
+          def remove_temporary_keys!(spans)
+            temporary_keys = %i[
+              open_range_id
+              amount_from_progress?
+              amount_from_frequency?
+              implied_date_range?
+            ]
 
             spans.each do |span|
-              span.delete(:amount_from_progress)
+              temporary_keys.each do |key|
+                span.delete(key)
+              end
             end
           end
         end

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

@@ -15,7 +15,7 @@ module Reading
             #   experiences from the History column.
             # @raise [InvalidDateError] if any date is invalid.
             def validate(experiences, history_column: false)
-              if both_date_columns?
+              if both_date_columns? && !history_column
                 validate_number_of_start_dates_and_end_dates(experiences)
               end
 
@@ -131,7 +131,7 @@ module Reading
                       end
                     end
                     .each_cons(2) do |a, b|
-                      if a.begin > b.begin || a.end > b.end
+                      if a.begin > b.begin || (a.end || Date.today) > (b.end || Date.today)
                         raise InvalidDateError, "Dates are not in order"
                       end
                       if a.cover?(b.begin + 1)