reading 0.6.1 → 0.8.0

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

data/lib/reading/util/hash_to_struct.rb

@@ -1,29 +0,0 @@
-module Reading
-  module Util
-    # Converts a Hash to a Struct. Converts inner hashes (and inner arrays of hashes) as well.
-    module HashToStruct
-      refine Hash do
-        def to_struct
-          MEMOIZED_STRUCTS[keys] ||= Struct.new(*keys)
-          struct_class = MEMOIZED_STRUCTS[keys]
-
-          struct_values = transform_values { |v|
-            if v.is_a?(Hash)
-              v.to_struct
-            elsif v.is_a?(Array) && v.all? { |el| el.is_a?(Hash) }
-              v.map(&:to_struct)
-            else
-              v
-            end
-          }.values
-
-          struct_class.new(*struct_values)
-        end
-      end
-
-      private
-
-      MEMOIZED_STRUCTS = {}
-    end
-  end
-end