reading 0.6.1 → 0.7.0

data/lib/reading/attribute/variants/length_subattribute.rb

@@ -1,45 +0,0 @@
-module Reading
-  class Row
-    class LengthSubattribute
-      using Util::HashArrayDeepFetch
-
-      private attr_reader :item_head, :bare_variant, :columns, :config
-
-      # @param bare_variant [String] the variant string before series / extra info.
-      # @param columns [Array<String>]
-      # @param config [Hash]
-      def initialize(bare_variant:, columns:, config:)
-        @bare_variant = bare_variant
-        @columns = columns
-        @config = config
-      end
-
-      def parse
-        in_variant = length_in(
-          bare_variant,
-          time_regex: config.deep_fetch(:csv, :regex, :time_length_in_variant),
-          pages_regex: config.deep_fetch(:csv, :regex, :pages_length_in_variant),
-        )
-        in_length = length_in(
-          columns[:length],
-          time_regex: config.deep_fetch(:csv, :regex, :time_length),
-          pages_regex: config.deep_fetch(:csv, :regex, :pages_length),
-        )
-
-        in_variant || in_length ||
-          (raise InvalidLengthError, "Missing length" unless columns[:length].blank?)
-      end
-
-      private
-
-      def length_in(str, time_regex:, pages_regex:)
-        return nil if str.blank?
-
-        time_length = str.strip.match(time_regex)&.captures&.first
-        return time_length unless time_length.nil?
-
-        str.strip.match(pages_regex)&.captures&.first&.to_i
-      end
-    end
-  end
-end

data/lib/reading/attribute/variants/series_subattribute.rb

@@ -1,57 +0,0 @@
-module Reading
-  class Row
-    class SeriesSubattribute
-      using Util::HashArrayDeepFetch
-
-      private attr_reader :item_head, :variant_with_extras, :config
-
-      # @param item_head [String] see Row#item_heads for a definition.
-      # @param variant_with_extras [String] the full variant string.
-      # @param config [Hash]
-      def initialize(item_head:, variant_with_extras: nil, config:)
-        @item_head = item_head
-        @variant_with_extras = variant_with_extras
-        @config = config
-      end
-
-      def parse
-        (
-          Array(series(item_head)) +
-            Array(series(variant_with_extras))
-        ).presence
-      end
-
-      def parse_head
-        series(item_head)
-      end
-
-      private
-
-      def template
-        config.deep_fetch(:item, :template, :variants, 0, :series).first
-      end
-
-      def series(str)
-        separated = str
-          .split(config.deep_fetch(:csv, :long_separator))
-          .map(&:strip)
-          .map(&:presence)
-          .compact
-
-        separated.delete_at(0) # everything before the series/extra info
-
-        separated.map { |str|
-          volume = str.match(config.deep_fetch(:csv, :regex, :series_volume))
-          prefix = "#{config.deep_fetch(:csv, :series_prefix)} "
-
-          if volume || str.start_with?(prefix)
-            {
-              name: str.delete_suffix(volume.to_s).delete_prefix(prefix) || template[:name],
-              volume: volume&.captures&.first&.to_i                      || template[:volume],
-            }
-          end
-        }.compact.presence
-      end
-    end
-  end
-end

data/lib/reading/attribute/variants/sources_subattribute.rb

@@ -1,78 +0,0 @@
-module Reading
-  class Row
-    class SourcesSubattribute
-      using Util::StringRemove
-      using Util::HashArrayDeepFetch
-
-      private attr_reader :item_head, :bare_variant, :config
-
-      # @param bare_variant [String] the variant string before series / extra info.
-      # @param config [Hash]
-      def initialize(bare_variant:, config:)
-        @bare_variant = bare_variant
-        @config = config
-      end
-
-      def parse
-        urls = sources_urls(bare_variant).map { |url|
-          {
-            name: url_name(url) || template.deep_fetch(:sources, 0, :name),
-            url: url,
-          }
-        }
-
-        names = sources_names(bare_variant).map { |name|
-          {
-            name: name,
-            url: template.deep_fetch(:sources, 0, :url),
-          }
-        }
-
-        (urls + names).presence
-      end
-
-      private
-
-      def template
-        @template ||= config.deep_fetch(:item, :template, :variants).first
-      end
-
-      def sources_urls(str)
-        str.scan(config.deep_fetch(:csv, :regex, :url))
-      end
-
-      # Turns everything that is not a source name (ISBN, source URL, length) into
-      # a separator, then splits by that separator and removes empty elements
-      # and format emojis. What's left is source names.
-      def sources_names(str)
-        not_names = [:isbn, :url, :time_length_in_variant, :pages_length_in_variant]
-        names_and_separators = str
-
-        not_names.each do |regex_type|
-          names_and_separators = names_and_separators.gsub(
-            config.deep_fetch(:csv, :regex, regex_type),
-            config.deep_fetch(:csv, :separator),
-          )
-        end
-
-        names_and_separators
-          .split(config.deep_fetch(:csv, :separator))
-          .map { |name| name.remove(/\A\s*#{config.deep_fetch(:csv, :regex, :formats)}\s*/) }
-          .map(&:strip)
-          .reject(&:empty?)
-      end
-
-      def url_name(url)
-        config
-          .deep_fetch(:item, :sources, :names_from_urls)
-          .each do |url_part, name|
-            if url.include?(url_part)
-              return name
-            end
-          end
-
-        config.deep_fetch(:item, :sources, :default_name_for_url)
-      end
-    end
-  end
-end

data/lib/reading/attribute/variants/variants_attribute.rb

@@ -1,69 +0,0 @@
-require_relative "series_subattribute"
-require_relative "sources_subattribute"
-require_relative "length_subattribute"
-require_relative "extra_info_subattribute"
-
-module Reading
-  class Row
-    class VariantsAttribute < Attribute
-      using Util::HashArrayDeepFetch
-
-      def parse
-        sources_str = columns[:sources]&.presence || " "
-
-        format_as_separator = config.deep_fetch(:csv, :regex, :formats_split)
-
-        sources_str.split(format_as_separator).map { |variant_with_extras|
-          # without extra info or series
-          bare_variant = variant_with_extras
-            .split(config.deep_fetch(:csv, :long_separator))
-            .first
-
-          series_attr = SeriesSubattribute.new(item_head:, variant_with_extras:, config:)
-          sources_attr = SourcesSubattribute.new(bare_variant:, config:)
-          # Length, despite not being very complex, is still split out into a
-          # subattribute because it needs to be accessible to
-          # ExperiencesAttribute (more specifically SpansSubattribute) which
-          # uses length as a default value for amount.
-          length_attr = LengthSubattribute.new(bare_variant:, columns:, config:)
-          extra_info_attr = ExtraInfoSubattribute.new(item_head:, variant_with_extras:, config:)
-
-          variant =
-            {
-              format: format(bare_variant) || format(item_head) || template.fetch(:format),
-              series: series_attr.parse                         || template.fetch(:series),
-              sources: sources_attr.parse                       || template.fetch(:sources),
-              isbn: isbn(bare_variant)                          || template.fetch(:isbn),
-              length: length_attr.parse                         || template.fetch(:length),
-              extra_info: extra_info_attr.parse                 || template.fetch(:extra_info)
-            }
-
-          if variant != template
-            variant
-          else
-            nil
-          end
-        }.compact.presence
-      end
-
-      private
-
-      def template
-        @template ||= config.deep_fetch(:item, :template, :variants).first
-      end
-
-      def format(str)
-        emoji = str.match(/^#{config.deep_fetch(:csv, :regex, :formats)}/).to_s
-        config.deep_fetch(:item, :formats).key(emoji)
-      end
-
-      def isbn(str)
-        isbns = str.scan(config.deep_fetch(:csv, :regex, :isbn))
-        if isbns.count > 1
-          raise InvalidSourceError, "Only one ISBN/ASIN is allowed per item variant"
-        end
-        isbns[0]&.to_s
-      end
-    end
-  end
-end

data/lib/reading/csv.rb

@@ -1,76 +0,0 @@
-# Used throughout, in other files.
-require_relative "util/blank"
-require_relative "util/string_remove"
-require_relative "util/string_truncate"
-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 "line"
-
-module Reading
-  class CSV
-    using Util::HashDeepMerge
-    using Util::HashArrayDeepFetch
-    using Util::HashToStruct
-
-    attr_reader :config
-
-    # @param feed [Object] the input source, which must respond to #each_line;
-    #   if nil, the file at the given path is used.
-    # @param path [String] the path of the source file.
-    # @param config [Hash] a custom config which overrides the defaults,
-    #   e.g. { errors: { styling: :html } }
-    def initialize(feed = nil, path: nil, config: {})
-      validate_feed_or_path(feed, path)
-
-      @feed = feed
-      @path = path
-      @config ||= Config.new(config).hash
-    end
-
-    # Parses a CSV reading log into item data (an array of Structs).
-    # For what the Structs look like, see the Hash at @default_config[:item][:template]
-    # in config.rb. The Structs are identical in structure to that Hash (with
-    # every inner Hash replaced with a Struct).
-    # @return [Array<Struct>] an array of Structs like the template in config.rb
-    def parse
-      feed = @feed || File.open(@path)
-      items = []
-
-      feed.each_line do |string|
-        line = Line.new(string, self)
-        row = line.to_row
-
-        items += row.parse
-      end
-
-      items.map(&:to_struct)
-    ensure
-      feed&.close if feed.respond_to?(:close)
-    end
-
-    private
-
-    # Checks on the given feed and path (arguments to #initialize).
-    # @raise [FileError] if the given path is invalid.
-    # @raise [ArgumentError] if both feed and path are nil.
-    def validate_feed_or_path(feed, path)
-      return true if feed
-
-      if path
-        if !File.exist?(path)
-          raise FileError, "File not found! #{path}"
-        elsif File.directory?(path)
-          raise FileError, "The reading log must be a file, but the path given is a directory: #{path}"
-        end
-      else
-        raise ArgumentError, "Either a feed (String, File, etc.) or a file path must be provided."
-      end
-    end
-  end
-end

data/lib/reading/line.rb

@@ -1,23 +0,0 @@
-require_relative "row/compact_planned_row"
-require_relative "row/blank_row"
-require_relative "row/regular_row"
-
-module Reading
-  # A bridge between rows as strings and as parsable Rows, used whenever the
-  # context of the line in the CSV is needed, e.g. converting a line to a Row,
-  # or adding a CSV line to a Row parsing error.
-  class Line
-    attr_reader :string, :csv
-
-    def initialize(string, csv)
-      @string = string.dup.force_encoding(Encoding::UTF_8).strip
-      @csv = csv
-    end
-
-    def to_row
-      return CompactPlannedRow.new(self) if CompactPlannedRow.match?(self)
-      return BlankRow.new(self) if BlankRow.match?(self)
-      RegularRow.new(self)
-    end
-  end
-end

data/lib/reading/row/blank_row.rb

@@ -1,23 +0,0 @@
-require_relative "row"
-
-module Reading
-  # An empty or commented-out row. A null object which returns an empty array.
-  class BlankRow < Row
-    using Util::HashArrayDeepFetch
-
-    # Whether the given CSV line is a blank row.
-    # @param line [Reading::Line]
-    # @return [Boolean]
-    def self.match?(line)
-      comment_char = line.csv.config.deep_fetch(:csv, :comment_character)
-
-      line.string.strip.empty? ||
-        line.string.strip.start_with?(comment_char)
-    end
-
-    # Overrides Row#parse.
-    def parse
-      []
-    end
-  end
-end

data/lib/reading/row/compact_planned_row.rb

@@ -1,130 +0,0 @@
-require_relative "row"
-require "debug"
-
-module Reading
-  # Parses a row of compactly listed planned items into an array of hashes of
-  # item data.
-  class CompactPlannedRow < Row
-    using Util::StringRemove
-    using Util::HashDeepMerge
-    using Util::HashArrayDeepFetch
-
-    # Whether the given CSV line is a compact planned row.
-    # @param line [Reading::Line]
-    # @return [Boolean]
-    def self.match?(line)
-      comment_char = line.csv.config.deep_fetch(:csv, :comment_character)
-
-      line.string.strip.start_with?(comment_char) &&
-        line.string.match?(line.csv.config.deep_fetch(:csv, :regex, :compact_planned_row_start))
-    end
-
-    private
-
-    def skip?
-      config.deep_fetch(:csv, :skip_compact_planned)
-    end
-
-    def before_parse
-      to_ignore = config.deep_fetch(:csv, :regex, :compact_planned_ignored_chars)
-      start_regex = config.deep_fetch(:csv, :regex, :compact_planned_row_start)
-
-      string_without_ignored_chars = string.remove_all(to_ignore)
-      start = string_without_ignored_chars.match(start_regex)
-
-      @genres = Array(start[:genres]&.downcase&.strip&.split(",")&.map(&:strip))
-      @sources = sources(start[:sources])
-      @row_without_genre = string_without_ignored_chars.remove(start.to_s)
-    end
-
-    def string_to_be_split_by_format_emojis
-      @row_without_genre
-    end
-
-    def item_hash(item_head)
-      item_match = item_head.match(config.deep_fetch(:csv, :regex, :compact_planned_item))
-      unless item_match
-        raise InvalidHeadError, "Title missing after #{item_head} in compact planned row"
-      end
-
-      author = AuthorAttribute.new(item_head: item_match[:author_title], config:).parse
-
-      begin
-        title = TitleAttribute.new(item_head: item_match[:author_title], config:).parse
-      rescue InvalidHeadError
-        raise InvalidHeadError, "Title missing after #{item_head} in compact planned row"
-      end
-
-      if item_match[:sources_column]
-        if item_match[:sources_column].include?(config.deep_fetch(:csv, :column_separator))
-          raise TooManyColumnsError, "Too many columns (only Sources allowed) " \
-            "after #{item_head} in compact planned row"
-        end
-
-        variants_attr = VariantsAttribute.new(
-          item_head: item_match[:format_emoji] + item_match[:author_title],
-          columns: { sources: item_match[:sources_column], length: nil },
-          config:,
-        )
-        variants = variants_attr.parse
-      else
-        variants = [parse_variant(item_match)]
-      end
-
-      template.deep_merge(
-        author: author || template.fetch(:author),
-        title: title,
-        genres: @genres.presence || template.fetch(:genres),
-        variants:,
-      )
-    end
-
-    def template
-      @template ||= config.deep_fetch(:item, :template)
-    end
-
-    def parse_variant(item_match)
-      item_head = item_match[:format_emoji] + item_match[:author_title]
-      series_attr = SeriesSubattribute.new(item_head:, config:)
-      extra_info_attr = ExtraInfoSubattribute.new(item_head:, config:)
-      sources = (@sources + sources(item_match[:sources])).uniq.presence
-
-      {
-        format: format(item_match[:format_emoji]),
-        series: series_attr.parse_head          || template.deep_fetch(:variants, 0, :series),
-        sources: sources                        || template.deep_fetch(:variants, 0, :sources),
-        isbn:                                   template.deep_fetch(:variants, 0, :isbn),
-        length:                                 template.deep_fetch(:variants, 0, :length),
-        extra_info: extra_info_attr.parse_head  || template.deep_fetch(:variants, 0, :extra_info),
-      }
-    end
-
-    def format(format_emoji)
-      config.deep_fetch(:item, :formats).key(format_emoji)
-    end
-
-    def sources(sources_str)
-      return [] if sources_str.nil?
-
-      sources_str
-        .split(config.deep_fetch(:csv, :compact_planned_source_prefix))
-        .map { |source| source.remove(/\s*,\s*/) }
-        .map(&:strip)
-        .reject(&:empty?)
-        .map { |source_name|
-          if valid_url?(source_name)
-            source_name = source_name.chop if source_name.chars.last == "/"
-            { name: config.deep_fetch(:item, :sources, :default_name_for_url),
-              url: source_name }
-          else
-            { name: source_name,
-              url: nil }
-          end
-        }
-    end
-
-    def valid_url?(str)
-      str&.match?(/http[^\s,]+/)
-    end
-  end
-end

data/lib/reading/row/regular_row.rb

@@ -1,99 +0,0 @@
-require_relative "row"
-require_relative "../attribute/all_attributes"
-
-module Reading
-  # Parses a normal CSV row into an array of hashes of item data. Typically
-  # a normal row describes one item and so it's parsed into an array containing
-  # a single hash, but it's also possible for a row to describe multiple items.
-  class RegularRow < Row
-    using Util::HashArrayDeepFetch
-
-    private attr_reader :columns, :attribute_classes
-
-    private
-
-    def after_initialize
-      set_attribute_classes
-    end
-
-    def before_parse
-      set_columns
-      ensure_head_column_present
-    end
-
-    def string_to_be_split_by_format_emojis
-      columns[:head]
-    end
-
-    def set_attribute_classes
-      @attribute_classes ||= config.deep_fetch(:item, :template).map { |attribute_name, _default|
-        attribute_name_camelcase = attribute_name.to_s.split("_").map(&:capitalize).join
-        attribute_class_name = "#{attribute_name_camelcase}Attribute"
-        attribute_class = self.class.const_get(attribute_class_name)
-
-        [attribute_name, attribute_class]
-      }.to_h
-      .merge(custom_attribute_classes)
-    end
-
-    def custom_attribute_classes
-      numeric = custom_attribute_classes_of_type(:numeric) do |value|
-        Float(value, exception: false)
-      end
-
-      text = custom_attribute_classes_of_type(:text) do |value|
-        value
-      end
-
-      (numeric + text).to_h
-    end
-
-    def custom_attribute_classes_of_type(type, &process_value)
-      config.deep_fetch(:csv, :"custom_#{type}_columns").map { |attribute, _default_value|
-        custom_class = Class.new(Attribute)
-
-        custom_class.define_method(:parse) do
-          value = columns[attribute.to_sym]&.strip&.presence
-          process_value.call(value)
-        end
-
-        [attribute.to_sym, custom_class]
-      }
-    end
-
-    def set_columns
-      column_names = config.deep_fetch(:csv, :enabled_columns) +
-        config.deep_fetch(:csv, :custom_numeric_columns).keys +
-        config.deep_fetch(:csv, :custom_text_columns).keys
-
-      columns_count = string.count(config.deep_fetch(:csv, :column_separator))
-      if columns_count >= column_names.count
-        raise TooManyColumnsError, "Too many columns"
-      end
-
-      column_contents = string.split(config.deep_fetch(:csv, :column_separator))
-
-      @columns = column_names.zip(column_contents).to_h
-    end
-
-    def ensure_head_column_present
-      if columns[:head].nil? || columns[:head].strip.empty?
-        raise InvalidHeadError, "The Head column must not be blank"
-      end
-    end
-
-    def item_hash(item_head)
-      config
-        .deep_fetch(:item, :template)
-        .merge(config.deep_fetch(:csv, :custom_numeric_columns))
-        .merge(config.deep_fetch(:csv, :custom_text_columns))
-        .map { |attribute_name, default_value|
-          attribute_class = attribute_classes.fetch(attribute_name)
-          attribute_parser = attribute_class.new(item_head:, columns:, config:)
-          parsed = attribute_parser.parse
-
-          [attribute_name, parsed || default_value]
-        }.to_h
-    end
-  end
-end

data/lib/reading/row/row.rb

@@ -1,88 +0,0 @@
-module Reading
-  # A base class that contains behaviors common to ___Row classes.
-  class Row
-    using Util::StringRemove
-    using Util::HashArrayDeepFetch
-    using Util::HashCompactByTemplate
-
-    private attr_reader :line
-
-    # @param line [Reading::Line] the Line that this Row represents.
-    def initialize(line)
-      @line = line
-
-      after_initialize
-    end
-
-    # Parses a CSV row into an array of hashes of item data. How this is done
-    # depends on how the template methods (further below) are implemented in
-    # subclasses of Row.
-    # @return [Array<Hash>] an array of hashes like the template in config.rb
-    def parse
-      return [] if skip?
-
-      before_parse
-
-      items = item_heads.map { |item_head|
-        item_hash(item_head)
-          .compact_by(template: config.deep_fetch(:item, :template))
-      }.compact
-
-      items
-
-    rescue Reading::Error => e
-      e.handle(line:)
-      []
-    end
-
-    private
-
-    def string
-      @line.string
-    end
-
-    def config
-      @line.csv.config
-    end
-
-    # A "head" is a string in the Head column containing a chunk of item
-    # information, starting with a format emoji. A typical row describes one
-    # item and so contains one head, but a row describing multiple items (with
-    # multiple heads in the Head column) is possible. Also, a row of compact
-    # planned items is essentially a list of heads, though with different
-    # elements than a normal row's head.
-    # @return [Array<String>]
-    def item_heads
-      string_to_be_split_by_format_emojis
-        .split(config.deep_fetch(:csv, :regex, :formats_split))
-        .tap { |item_heads|
-          item_heads.first.remove!(config.deep_fetch(:csv, :regex, :dnf))
-          item_heads.first.remove!(config.deep_fetch(:csv, :regex, :progress))
-        }
-        .map { |item_head| item_head.strip }
-        .partition { |item_head| item_head.match?(/\A#{config.deep_fetch(:csv, :regex, :formats)}/) }
-        .reject(&:empty?)
-        .first
-    end
-
-    # Below: template methods that can (or must) be overridden.
-
-    def after_initialize
-    end
-
-    def before_parse
-    end
-
-    def skip?
-      false
-    end
-
-    def string_to_be_split_by_format_emojis
-      raise NotImplementedError, "#{self.class} should have implemented #{__method__}"
-    end
-
-    def item_hash(item_head)
-      raise NotImplementedError, "#{self.class} should have implemented #{__method__}"
-    end
-  end
-end