reading 0.6.0 → 0.7.0

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

@@ -0,0 +1,143 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#history-column
+        class History < Column
+          def self.segment_separator
+            /\s*--\s*/
+          end
+
+          def self.segment_group_separator
+            /\s*----\s*/
+          end
+
+          def self.tweaks
+            {
+              except_dates: ->(dates_list) {
+                dates_list
+                  .split(/\s*,\s*/)
+                  .map { |date|
+                    date.match(
+                      %r{\A
+                        #{START_END_DATES_REGEX}
+                      \z}xo
+                    )
+                    &.named_captures
+                    &.compact
+                    &.transform_keys(&:to_sym)
+                    &.presence
+                  }
+                  .compact
+              },
+            }
+          end
+
+          def self.regexes(segment_index)
+            [
+              # entry of exception dates ("but not on these dates")
+              %r{\A
+                not
+                \s+
+                (?<except_dates>.+)
+              \z}x,
+              # normal entry
+              %r{\A
+                \(?\s*
+                # variant, group before first start date
+                (
+                  (
+                    v(?<variant>\d)
+                    (\s+|\z)
+                  )?
+                  (
+                    🤝🏼(?<group>.+?)
+                  )?
+                  (?=(\d{4}/)?\d\d?/\d\d?)
+                )?
+                # planned or dates
+                (
+                  (
+                    (?<planned>\?\?)
+                    |
+                    (#{START_END_DATES_REGEX})
+                  )
+                  (\s*\)?\s*\z|\s+)
+                )?
+                # progress
+                (
+                  # requires the at symbol, unlike the shared progress regex in Column
+                  # and also adds the done option
+                  (
+                    (DNF\s+)?@?(?<progress_percent>\d\d?)%
+                    |
+                    (DNF\s+)?@p?(?<progress_pages>\d+)p?
+                    |
+                    (DNF\s+)?@(?<progress_time>\d+:\d\d)
+                    |
+                    # just DNF
+                    (?<progress_dnf>DNF)
+                    |
+                    # done
+                    (?<progress_done>done)
+                  )
+                  (\s*\)?\s*\z|\s+)
+                )?
+                # amount, repetitions, frequency
+                (
+                  (
+                    p?(?<amount_pages>\d+)p?
+                    |
+                    (?<amount_time>\d+:\d\d)
+                  )?
+                  (
+                    \s*
+                    x(?<repetitions>\d+)
+                  )?
+                  (
+                    /(?<frequency>day|week|month)
+                  )?
+                  (\s*\)?\s*\z|\s+)
+                )?
+                # favorite, name
+                (
+                  (?<favorite>⭐)?
+                  \s*
+                  (?<name>[^\d].*)
+                )?
+              \z}xo,
+            ]
+          end
+
+          private
+
+          START_END_DATES_REGEX =
+            %r{
+              (
+                (?<start_year>\d{4})
+                /
+              )?
+              (
+                (?<start_month>\d\d?)
+                /
+              )?
+              (?<start_day>\d\d?)?
+              (?<range>\.\.)?
+              (
+                (?<=\.\.)
+                (
+                  (?<end_year>\d{4})
+                  /
+                )?
+                (
+                  (?<end_month>\d\d?)
+                  /
+                )?
+                (?<end_day>\d\d?)?
+              )?
+            }x
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See  https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#length-column
+        class Length < Column
+          def self.regexes(segment_index)
+            [%r{\A
+              # length
+              (
+                (
+                  (?<length_pages>\d+)p?
+                  |
+                  (?<length_time>\d+:\d\d)
+                )
+                (\s+|\z)
+              )
+              # each or repetitions, used in conjunction with the History column
+              (
+                # each
+                (?<each>each)
+                |
+                # repetitions
+                (
+                  x
+                  (?<repetitions>\d+)
+                )
+              )?
+            \z}x]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#notes-column
+        # and https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#notes-column-special-notes
+        class Notes < Column
+          def self.segment_separator
+            /\s*--\s*/
+          end
+
+          def self.regexes(segment_index)
+            [
+              # blurb note
+              %r{\A
+                💬\s*(?<note_blurb>.+)
+              \z}x,
+              # private note
+              %r{\A
+                🔒\s*(?<note_private>.+)
+              \z}x,
+              # regular note
+              %r{\A
+                (?<note_regular>.+)
+              \z}x,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#rating-column
+        class Rating < Column
+          def self.regexes(segment_index)
+            # integer or float
+            [/\A(?<number>\d+\.?\d*)?\z/]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#sources-column
+        # 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" =>
+              ->(source) {
+                source.match?(/\A#{ISBN_REGEX}/o) || source.match(/\A#{ASIN_REGEX}/o)
+              },
+          }
+
+
+          def self.split_by_format?
+            true
+          end
+
+          def self.segment_separator
+            /\s*--\s*/
+          end
+
+          def self.flatten_into_arrays
+            %i[extra_info series_names series_volumes]
+          end
+
+          def self.tweaks
+            {
+              sources: -> {
+                sources = _1.split(/\s*,\s*/)
+
+                SOURCES_PARSING_ERRORS.each do |message, check|
+                  if sources.any? { |source| check.call(source) }
+                    raise ParsingError, message
+                  end
+                end
+
+                sources
+              },
+            }
+          end
+
+          def self.regexes(segment_index)
+            [
+              # ISBN/ASIN and length (without sources)
+              (%r{\A
+                (
+                  (?<isbn>(\d{3}[-\s]?)?[A-Z\d]{10})
+                  ,?(\s+|\z)
+                )?
+                (
+                  (?<length_pages>\d+)p?
+                  |
+                  (?<length_time>\d+:\d\d)
+                )?
+              \z}x if  segment_index.zero?),
+              # sources, ISBN/ASIN, length
+              (%r{\A
+                (
+                  (?<sources>.+?)
+                  ,?(\s+|\z)
+                )?
+                (
+                  (
+                    (?<isbn>#{ISBN_REGEX})
+                    |
+                    (?<asin>#{ASIN_REGEX})
+                  )
+                  ,?(\s+|\z)
+                )?
+                (
+                  (?<length_pages>\d+)p?
+                  |
+                  (?<length_time>\d+:\d\d)
+                )?
+              \z}xo if  segment_index.zero?),
+              *Column::SHARED_REGEXES[:series_and_extra_info],
+            ].compact
+          end
+
+          private
+
+          ISBN_REGEX = /(\d{3}[-\s]?)?\d{10}/
+          ASIN_REGEX = /B0[A-Z\d]{8}/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Reading
+  module Parsing
+    module Rows
+      module Regular
+        # See https://github.com/fpsvogel/reading/blob/main/doc/csv-format.md#start-dates-and-end-dates-columns
+        class StartDates < Column
+          def self.segment_separator
+            /,\s*/
+          end
+
+          def self.regexes(segment_index)
+            # dnf/progress, date, variant number, group
+            [%r{\A
+              (
+                #{Column::SHARED_REGEXES[:progress]}
+                (\s+|\z)
+              )?
+              (
+                (?<date>\d{4}/\d\d?/\d\d?)
+                (\s+|\z)
+              )?
+              (
+                v(?<variant>\d)
+                (\s+|\z)
+              )?
+              (
+                🤝🏼(?<group>.+)
+              )?
+            \z}x]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reading/parsing/transformer.rb

@@ -0,0 +1,70 @@
+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
+    #
+    # Transforms an intermediate hash (parsed from a CSV row) into item data.
+    # While the intermediate hash mirrors the structure of a row, the output of
+    # Transformer is based around item attributes, which are listed in
+    # Config#default_config[:item_template] and in the files in parsing/attributes.
+    #
+    class Transformer
+      using Util::HashArrayDeepFetch
+      using Util::HashCompactByTemplate
+
+      attr_reader :config
+      private attr_reader :attributes
+
+      # @param config [Hash] an entire config.
+      def initialize(config)
+        @config = config
+
+        set_attributes
+      end
+
+      # Transforms the intermediate hash of a row into item data.
+      # @param parsed_row [Hash{Symbol => Hash, Array}] output from
+      #   Parsing::Parser#parse_row_to_intermediate_hash.
+      # @return [Array<Hash>] an array of Hashes like the template in
+      #   Config#default_config[:item_template].
+      def transform_intermediate_hash_to_item_hashes(parsed_row)
+        if parsed_row[:head].blank?
+          raise InvalidHeadError, "Blank or missing Head column"
+        end
+
+        template = config.fetch(:item_template)
+
+        parsed_row[:head].map.with_index { |_head, head_index|
+          template.map { |attribute_name, default_value|
+            attribute = attributes.fetch(attribute_name)
+            transformed_value = attribute.transform_from_parsed(parsed_row, head_index)
+
+            [attribute_name, transformed_value || default_value]
+          }.to_h
+          .compact_by(template:)
+        }
+      end
+
+      private
+
+      # Sets the attributes classes which do all the transforming work.
+      # See parsing/attributes/*.
+      def set_attributes
+        @attributes ||= config.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)]
+        }.to_h
+      end
+    end
+  end
+end

data/lib/reading/util/hash_compact_by_template.rb

@@ -9,6 +9,7 @@ module Reading
         # If no parsed data has been added to the template values for these, they
         # are considered blank, and are replaced with an empty array so that their
         # emptiness is more apparent, e.g. item[:experiences].empty? will return true.
+        # @return [Hash]
         def compact_by(template:)
           map { |key, val|
             if is_array_of_hashes?(val)

data/lib/reading/util/hash_deep_merge.rb

@@ -32,7 +32,7 @@ module Reading
                 end
               }
             elsif block_given?
-              block.call(key, this_val, other_val)
+              yield key, this_val, other_val
             else
               other_val
             end

data/lib/reading/util/hash_to_struct.rb

@@ -3,6 +3,7 @@ module Reading
     # Converts a Hash to a Struct. Converts inner hashes (and inner arrays of hashes) as well.
     module HashToStruct
       refine Hash do
+        # @return [Struct]
         def to_struct
           MEMOIZED_STRUCTS[keys] ||= Struct.new(*keys)
           struct_class = MEMOIZED_STRUCTS[keys]

data/lib/reading/util/numeric_to_i_if_whole.rb

@@ -0,0 +1,12 @@
+module Reading
+  module Util
+    # Same as #to_i but only applies if the result is equal to the original number.
+    module NumericToIIfWhole
+      refine Numeric do
+        def to_i_if_whole
+          to_i == self ? to_i : self
+        end
+      end
+    end
+  end
+end

data/lib/reading/util/string_truncate.rb

@@ -1,13 +1,22 @@
 module Reading
   module Util
+    # Shortens the String to a given length.
     module StringTruncate
       refine String do
-        def truncate(max, padding: 0, min: 30)
-          end_index = max - padding
-          end_index = min if end_index < min
-          self.length + padding > max ? "#{self[0...end_index]}..." : self
+        # @param length [Integer]
+        # @return [String]
+        def truncate(length)
+          if length < self.length - ELLIPSIS.length
+            "#{self[0...length]}#{ELLIPSIS}"
+          else
+            self
+          end
         end
       end
+
+      private
+
+      ELLIPSIS = "...".freeze
     end
   end
 end

data/lib/reading/version.rb

@@ -1,3 +1,3 @@
 module Reading
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/reading.rb

@@ -0,0 +1,18 @@
+require_relative "reading/parsing/csv"
+require_relative "reading/item/time_length.rb"
+
+# The gem's public API. See https://github.com/fpsvogel/reading#usage
+
+module Reading
+  # Parses a CSV file or string. See Parsing::CSV#initialize and #parse for details.
+  def self.parse(...)
+    csv = Parsing::CSV.new(...)
+    csv.parse
+  end
+
+  # @param string [String] a time duration in "h:mm" format.
+  # @return [Reading::Item::TimeLength]
+  def self.time(string)
+    Reading::Item::TimeLength.parse(string)
+  end
+end