pdfh 3.3.0 → 4.0.0

data/lib/pdfh/main.rb

@@ -7,137 +7,42 @@ module Pdfh
       # @param argv [Array<String>]
       # @return [void]
       def start(argv:)
-        arg_options = Pdfh::OptParser.new(argv: argv).parse_argv
-        @options = Options.new(arg_options)
-        assign_global_utils(@options)
-        Pdfh.print_options(arg_options)
+        arg_options = Services::OptParser.new(argv: argv).parse_argv
+        options = RunOptions.new(**arg_options)
 
-        @settings = SettingsBuilder.build
-        Pdfh.debug "Destination path: #{settings.base_path.colorize(:light_blue)}"
+        # Initialize the global logger
+        Pdfh.logger = Console.new(options.verbose?)
+        Pdfh.logger.print_options(arg_options)
 
-        options.file_mode? ? process_provided_files : process_lookup_dirs
-      rescue SettingsIOError => e
-        Pdfh.error_print(e.message, exit_app: false)
-        Pdfh.create_settings_file
-        exit(1)
-      rescue StandardError => e
-        Pdfh.backtrace_print e if Pdfh.verbose?
-        Pdfh.error_print(e.message)
-      end
-
-      private
-
-      attr_reader :options, :settings
-
-      # @param options [Options]
-      # @return [void]
-      def assign_global_utils(options)
-        Pdfh.instance_variable_set(:@options, options)
-        Pdfh.instance_variable_set(:@console, Console.new(options.verbose?))
-      end
-
-      # @param [String] file_name
-      # @return [DocumentType, nil]
-      def match_doc_type(file_name)
-        settings.document_types.each do |type|
-          match = type.re_file.match(file_name)
-          return type if match
-        end
-        nil
-      end
-
-      # @return [void]
-      def process_provided_files
-        type_id = options.type
-        raise ArgumentError, "No files provided to process #{type_id.inspect} type." unless options.files?
-
-        type = settings.document_type(type_id)
-        Pdfh.error_print "Type #{type_id.inspect} was not found." if type.nil?
-        options.files.each do |file|
-          next Pdfh.warn_print "File #{file.inspect} does not exist." unless File.exist?(file)
-          next Pdfh.warn_print "File #{file.inspect} is not a pdf." unless File.extname(file) == ".pdf"
-
-          PdfFileHandler.new(file, type).process_document(settings.base_path)
-        end
-      end
-
-      # @return [void]
-      def process_lookup_dirs
-        settings.lookup_dirs.each do |work_directory|
-          process_directory(work_directory)
-        end
-      end
+        settings = Services::SettingsBuilder.call
+        Pdfh.logger.debug "Destination path: #{settings.base_path.colorize(:light_blue)}"
 
-      # @param [String] work_directory
-      # @return [void]
-      def process_zip_files(work_directory)
-        @settings.zip_types&.each do |zip_type|
-          find_files(work_directory, :zip).each do |file|
-            next unless zip_type.re_file.match?(File.basename(file))
+        files = Services::DirectoryScanner.new(settings.lookup_dirs).scan
+        matcher = Services::DocumentMatcher.new(settings.document_types)
 
-            Pdfh.info " > Processing zip file: #{file.green}"
-            password_opt = "-P #{zip_type.password}" if zip_type.password?
-            `unzip -o #{password_opt} #{file} -d #{work_directory}`
-          end
-        end
-      end
+        files.each do |file_path|
+          Pdfh.logger.info "Working on: #{file_path.colorize(:green)}" if Pdfh.logger.verbose?
+          text = Services::PdfTextExtractor.call(file_path)
 
-      # @param directory [String]
-      # @param type [String, Symbol]
-      # @return [Array<String>]
-      def find_files(directory, type)
-        glob = File.join(directory, "*.#{type}")
-        Dir.glob(glob)
-      end
+          documents = matcher.match(file_path, text)
+          next Pdfh.logger.debug "No document type match found for #{file_path.colorize(:yellow)}" if documents.empty?
 
-      def process_directory(work_directory)
-        Pdfh.headline(work_directory)
-        process_zip_files(work_directory) if @settings.zip_types?
-        processed_result = RunResult.new
-        files = find_files(work_directory, :pdf)
-        files.each do |pdf_file|
-          type = match_doc_type(pdf_file)
-          if type
-            PdfFileHandler.new(pdf_file, type).process_document(settings.base_path)
-            processed_result.add_processed(pdf_file)
-          else
-            processed_result.add_ignored(pdf_file)
+          unless documents.one?
+            matches = documents.map { _1.type.name.inspect }.join(", ")
+            next Pdfh.logger.warn_print "Skipping #{file_path.inspect} as multiple matches found: #{matches}."
           end
-        end
-        print_processing_results(processed_result)
-      end
-
-      # @return [String]
-      def base_name_no_ext(file)
-        File.basename(file, File.extname(file))
-      end
-
-      def print_processing_results(result)
-        Pdfh.info "  (No files processed)".colorize(:light_black) if result.processed.empty?
-        return unless Pdfh.verbose?
 
-        Pdfh.info "\n  No document type found for these PDF files:" if result.ignored.any?
-        result.ignored.each.with_index(1) do |file, index|
-          Pdfh.ident_print index, base_name_no_ext(file), color: :magenta
+          Services::DocumentManager.new(documents.first, base_path: settings.base_path, dry_run: options.dry?).call
         end
-      end
-    end
-
-    # keeps track of the processed and ignored files
-    class RunResult
-      attr_reader :processed, :ignored
 
-      # @return [self]
-      def initialize
-        @processed = []
-        @ignored = []
+        nil
+      rescue SettingsIOError => e
+        Pdfh.logger.error_print(e.message, exit_app: false)
+        exit(1)
+      rescue StandardError => e
+        Pdfh.logger.backtrace_print(e) if Pdfh.logger.verbose?
+        Pdfh.logger.error_print(e.message)
       end
-
-      # @return [void]
-      def add_ignored(file) = @ignored << file
-
-      # @return [void]
-      def add_processed(file) = @processed << file
     end
   end
 end

data/lib/pdfh/models/document.rb

@@ -1,152 +1,67 @@
 # frozen_string_literal: true
 
 module Pdfh
-  # Handles the PDF detected by the rules
+  # Lightweight struct that connects a PDF file with its matched document type and
+  # extracted text. All file metadata, date interpretation, and rename resolution
+  # are accessible through dedicated value objects (FileInfo, DateInfo).
   class Document
-    attr_reader :text, :type, :file, :extra, :period
-
-    # @param file [String]
-    # @param type [DocumentType]
-    # @param text [String]
-    # @return [self]
-    def initialize(file, type, text)
-      @file = file
+    # @!attribute [r] file_info
+    #   @return [FileInfo] File metadata wrapper
+    # @!attribute [r] type
+    #   @return [DocumentType] Matched document type
+    # @!attribute [r] text
+    #   @return [String] Extracted text from the PDF
+    # @!attribute [r] date_info
+    #   @return [DateInfo] Parsed date value object
+    attr_reader :file_info, :type, :text, :date_info
+
+    # @param file [String] Path to the PDF file
+    # @param type [DocumentType] Type of the document
+    # @param text [String] Extracted text from the PDF
+    # @param date_captures [Hash{String => String}] Captured date components from regex
+    # @return [self] A new Document instance
+    def initialize(file, type, text, date_captures)
       @type = type
       @text = text
+      @file_info = FileInfo.new(file)
+      @date_info = DateInfo.new(date_captures)
     end
 
-    # @return [void]
-    def process
-      Pdfh.debug "=== Document Type: #{type.name} =============================="
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Finding a subtype"
-      @sub_type = type.sub_type(@text)
-      Pdfh.debug "  SubType: #{@sub_type}"
-      @companion = search_companion_files
-
-      month, year, @extra = match_date(@sub_type&.re_date || @type.re_date)
-      @period = DocumentPeriod.new(day: extra, month: month, month_offset: @sub_type&.month_offset, year: year)
-      Pdfh.debug "  Period: #{@period.inspect}"
-    end
-
-    # @return [void]
-    def print_info
-      print_info_line "Type", type.name
-      print_info_line "Sub-Type", sub_type
-      print_info_line "Period", period
-      print_info_line "New Name", new_name
-      print_info_line "Store Path", store_path
-      print_info_line "Extra files", companion_files(join: true)
-      print_info_line "Processed?", "No (in Dry mode)" if Pdfh.dry?
-    end
-
-    # @return [void]
-    def print_info_line(property, info)
-      Pdfh.ident_print property, info.to_s, color: :light_blue, width: 12
-    end
-
-    # @return [String]
-    def file_name_only
-      File.basename(@file, file_extension)
-    end
-
-    # @return [String]
-    def file_extension
-      File.extname(@file)
-    end
-
-    # @return [String]
-    def file_name
-      File.basename(@file)
-    end
-
-    # @return [String]
-    def backup_name
-      "#{file_name}.bkp"
-    end
-
-    # @return [String]
+    # @return [String] Document type name or "N/A" if type is nil
     def type_name
-      type&.name&.titleize || "N/A"
-    end
-
-    # @return [String]
-    def sub_type
-      @sub_type&.name&.titleize || "N/A"
+      type&.name || "N/A"
     end
 
-    # @return [Hash{Symbol->String}]
-    def rename_data
-      {
-        original: file_name_only,
-        period: period.to_s,
-        year: period.year.to_s,
-        month: period.month.to_s,
-        type: type_name,
-        subtype: sub_type,
-        extra: extra || ""
-      }.freeze
+    # @return [String] File name
+    def to_s
+      file_info.name
     end
 
-    # @return [String]
+    # @return [String] New file name with extension (e.g., "2024-01 Cuenta.pdf")
     def new_name
-      new_name = type.generate_new_name(rename_data)
-      "#{new_name}#{file_extension}"
+      "#{@type.name_validator.gsub(rename_data)}#{@file_info.extension}"
     end
 
-    # @return [String]
+    # @return [String] Storage path for the document (e.g., "2024/Edo Cuenta")
     def store_path
-      type.generate_path(rename_data)
-    end
-
-    # @return [String (frozen)]
-    def companion_files(join: false)
-      return @companion unless join
-
-      @companion.empty? ? "N/A" : @companion.join(", ")
-    end
-
-    # @return [String]
-    def home_dir
-      File.dirname(@file)
-    end
-
-    # @return [String]
-    def to_s
-      @file
+      @type.path_validator.gsub(rename_data)
     end
 
     private
 
-    # named matches can appear in any order with names 'd', 'm' and 'y'
-    # unnamed matches needs to be in order month, year
-    # @return [Array] - format [month, year, day]
-    # @param regex [RegularExpression]
-    def match_date(regex)
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Match Data RegEx"
-      Pdfh.debug "  Using regex: #{regex}"
-      Pdfh.debug "        named:   #{regex.named_captures}"
-      matched = regex.match(@text)
-      raise ReDateError unless matched
-
-      Pdfh.debug "     captured: #{matched.captures}"
-
-      return matched.captures.map(&:downcase) if regex.named_captures.empty?
-
-      extra = matched.captures.size > 2 ? matched[:d] : nil
-      [matched[:m].downcase, matched[:y], extra]
-    end
-
-    # @return [Array]
-    def search_companion_files
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Searching Companion files"
-      Pdfh.debug "  Searching on: #{home_dir.inspect}"
-      Dir.chdir(home_dir) do
-        files_matching = Dir["#{file_name_only}.*"]
-        companion = files_matching.reject { |file| file.include? ".pdf" }
-        Pdfh.debug "    Found: #{companion.inspect}"
-
-        companion
-      end
+    # Used to replace variables in the rename pattern i.e {original}, {period}, etc.
+    # @return [Hash{Symbol => String}] Hash containing rename variables
+    def rename_data
+      @rename_data ||= {
+        original: @file_info.stem,
+        period: @date_info.period,
+        year: @date_info.year.to_s,
+        month: @date_info.month.to_s,
+        quarter: "Q#{@date_info.quarter}",
+        bimester: "B#{@date_info.bimester}",
+        name: @type.name,
+        day: @date_info.day || ""
+      }.freeze
     end
   end
 end

data/lib/pdfh/models/document_type.rb

@@ -3,97 +3,65 @@
 module Pdfh
   # Represents a type of document that can be processed by pdfh
   class DocumentType
-    include Concerns::PasswordDecodable
+    REQUIRED_KEYS = %i[name re_date store_path].freeze
+    DEFAULT_NAME_TEMPLATE = "{name} {period}"
 
     # @!attribute [r] name
-    #   @return [String] The name of the document type.
-    # @!attribute [r] re_file
-    #   @return [Regexp] The regular expression to match file names.
+    #   @return [String] The name of the document type
+    # @!attribute [r] re_id
+    #   @return [Regexp] The regular expression to extract the document ID
     # @!attribute [r] re_date
-    #   @return [Regexp] The regular expression to extract dates and its information.
-    # @!attribute [r] pwd
-    #   @return [String, nil] The base64 password for the document type, if any.
+    #   @return [Regexp] The regular expression to extract dates
     # @!attribute [r] store_path
-    #   @return [String] The path where the document will be stored.
+    #   @return [String] The path where the document will be stored
     # @!attribute [r] name_template
-    #   @return [String] The template for generating document names.
-    # @!attribute [r] sub_types
-    #   @return [Array<DocumentSubType>, nil] The subtypes of the document, if any.
-    attr_reader :name, :re_file, :re_date, :pwd, :store_path, :name_template, :sub_types
+    #   @return [String] The template for generating document names
+    # @!attribute [r] path_validator
+    #   @return [RenameValidator] The validator for the storage path
+    # @!attribute [r] name_validator
+    #   @return [RenameValidator] The validator for the document name
+    attr_reader :name, :re_id, :re_date, :store_path, :name_template, :path_validator, :name_validator
 
-    # @param args [Hash]
-    # @return [self]
+    # @param args [Hash] The initialization arguments
+    # @return [DocumentType]
     def initialize(args)
       args.each { |k, v| instance_variable_set(:"@#{k}", v) }
-      @name_template ||= "{original}"
-      @re_file = Regexp.new(re_file)
+      return if missing_keys?
+
+      @name = name.to_s.strip
+      @re_id = Regexp.new(re_id || name)
       @re_date = Regexp.new(re_date)
-      @sub_types = extract_subtypes(sub_types) if sub_types&.any?
+      @name_template = name_template || DEFAULT_NAME_TEMPLATE
       @path_validator = RenameValidator.new(store_path)
-      @name_validator = RenameValidator.new(name_template)
-      return if @path_validator.valid? && @name_validator.valid?
+      @name_validator = RenameValidator.new(@name_template)
+    end
 
-      raise_validators_error
+    # @return [Boolean]
+    def valid?
+      missing_keys.empty? &&
+        @path_validator.valid? &&
+        @name_validator.valid?
     end
 
-    # @return [Hash{Symbol->any}]
+    # @return [Hash{String => Object}]
     def to_h
       instance_variables.to_h { |var| [var.to_s.delete_prefix("@"), instance_variable_get(var)] }
     end
 
     # removes special characters from string and replaces spaces with dashes
-    # @example usage
-    #   "Test This?%&".gid
-    #   # => "test-this"
+    # @example
+    #   "Test This?%&".gid # => "test-this"
     # @return [String]
     def gid
       name.downcase.gsub(/[^0-9A-Za-z\s]/, "").tr(" ", "-")
     end
 
-    # search the subtype name in the pdf document
-    # @return [DocumentSubType]
-    def sub_type(text)
-      # Regexp.new(st.name).match?(name)
-      sub_types&.find { |st| /#{st.name}/i.match?(text) }
+    # @return [Array<Symbol>]
+    def missing_keys
+      @missing_keys ||= REQUIRED_KEYS.select { |key| instance_variable_get(:"@#{key}").to_s.strip.empty? }
     end
 
-    # @param values [Hash{Symbol->String}
-    # @return [String]
-    def generate_new_name(values)
-      @name_validator.gsub(values)
-    end
-
-    # @param values [Hash{Symbol->String}
-    # @return [String]
-    def generate_path(values)
-      @path_validator.gsub(values)
-    end
-
-    private
-
-    attr_accessor :path_validator, :name_validator
-
-    # @param sub_types [Array<Hash{Symbol->String}>]
-    # @return [Array<DocumentSubType>]
-    def extract_subtypes(sub_types)
-      sub_types.map do |st|
-        data = {
-          name: st[:name],
-          month_offset: st[:month_offset].to_i,
-          re_date: st[:re_date] && Regexp.new(st[:re_date])
-        }.compact
-        DocumentSubType.new(data)
-      end
-    end
-
-    # @raise [ArgumentError] when called
-    # @return [void]
-    def raise_validators_error
-      template = "has invalid %<field>s[Unknown tokens=%<error>s]"
-      errors = []
-      errors << format(template, field: :store_path, error: path_validator.unknown_list) unless path_validator.valid?
-      errors << format(template, field: :name_template, error: name_validator.unknown_list) unless name_validator.valid?
-      raise ArgumentError, "Document type #{name.inspect} #{errors.join(", ")}"
-    end
+    # @return [Boolean]
+    def missing_keys? = missing_keys.any?
   end
 end

data/lib/pdfh/models/run_options.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pdfh
+  # Runtime options for the application
+  class RunOptions
+    # @param verbose [Boolean]
+    # @param dry [Boolean]
+    # @return [RunOptions]
+    def initialize(verbose: false, dry: false)
+      @verbose = verbose
+      @dry = dry
+    end
+
+    # @return [Boolean]
+    def verbose? = @verbose
+
+    # @return [Boolean]
+    def dry? = @dry
+  end
+end

data/lib/pdfh/models/settings.rb

@@ -1,87 +1,41 @@
 # frozen_string_literal: true
 
 module Pdfh
-  # Handles the config yaml data mapping, and associates a file name with a doc type
+  # Handles the config yaml data mapping, and associates a file name with a doc type.
+  # This is a pure data object — validation is handled by Services::SettingsValidator.
   class Settings
     # @!attribute [r] lookup_dirs
-    #   @return [Array<String>] List of directories to look up for processing.
+    #   @return [Array<String>] List of validated, expanded directories to look up for processing.
     # @!attribute [r] base_path
-    #   @return [String] The base directory path for storing processed files.
-    # @!attribute [r] zip_types
-    #   @return [Array<ZipType>, nil] List of zip types to process, or nil if none.
-    attr_reader :lookup_dirs, :base_path, :zip_types
+    #   @return [String] The validated, expanded base directory path for storing processed files.
+    attr_reader :lookup_dirs, :base_path
 
-    # @param config_data [Hash]
-    # @return [self]
-    def initialize(config_data)
-      process_lookup_dirs(config_data[:lookup_dirs])
-      process_destination_base(config_data[:destination_base_path])
-
-      Pdfh.debug "Configured Look up directories:"
-      lookup_dirs.each.with_index(1) { |dir, idx| Pdfh.debug "  #{idx}. #{dir}" }
-      Pdfh.debug
-
-      build_doc_types(config_data[:document_types])
-      build_zip_types(config_data[:zip_types]) if config_data.key?(:zip_types)
+    # @param lookup_dirs [Array<String>] Already validated and expanded directories
+    # @param base_path [String] Already validated and expanded base path
+    # @param document_types [Hash{String => DocumentType}] Already validated document types keyed by gid
+    # @return [Settings]
+    def initialize(lookup_dirs:, base_path:, document_types:)
+      @lookup_dirs = lookup_dirs
+      @base_path = base_path
+      @document_types = document_types
     end
 
     # @return [Array<DocumentType>]
-    def document_types
-      @document_types.values
+    def document_types = @document_types.values
+
+    # @example
+    #   # document_types.map(&:name) ['12345', '12', '123']
+    #   settings.document_types_name_max_size #=> 5
+    # @return [Integer]
+    def document_types_name_max_size
+      return 0 if document_types.empty?
+
+      document_types.map { _1.name.length }.max
     end
 
     # @return [DocumentType]
     def document_type(id)
       @document_types[id]
     end
-
-    # @return [Boolean]
-    def zip_types?
-      !!zip_types&.any?
-    end
-
-    private
-
-    # @param lookup_dirs_list [Array[String]]
-    # @return [void]
-    def process_lookup_dirs(lookup_dirs_list)
-      @lookup_dirs = lookup_dirs_list.filter_map do |dir|
-        expanded = File.expand_path(dir)
-        unless File.directory?(expanded)
-          Pdfh.debug "  ** Error, Directory #{dir} does not exists."
-          next
-        end
-        expanded
-      end
-      raise ArgumentError, "No valid Look up directories configured." if lookup_dirs.empty?
-    end
-
-    # @return [void]
-    # @param dir [String]
-    def process_destination_base(dir)
-      @base_path = File.expand_path(dir)
-      raise ArgumentError, "Destination base directory is not configured." if @base_path.nil?
-      raise ArgumentError, "Destination base directory #{@base_path} does not exist." unless File.directory?(@base_path)
-    end
-
-    # @param doc_types [Array<Hash>]
-    # @return [void]
-    def build_doc_types(doc_types)
-      @document_types = doc_types.each_with_object({}) do |data, result|
-        doc_type = DocumentType.new(data)
-        result.store(doc_type.gid, doc_type)
-      rescue ArgumentError => e
-        Pdfh.error_print e.message, exit_app: false
-        Pdfh.backtrace_print e if Pdfh.verbose?
-      end
-    end
-
-    # @param zip_types [Array<Hash>]
-    # @return [void]
-    def build_zip_types(zip_types)
-      exit(1) if Pdfh::Utils::DependencyValidator.missing?(:unzip)
-
-      @zip_types = zip_types.compact.map { ZipType.new(_1) }
-    end
   end
 end

data/lib/pdfh/services/directory_scanner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pdfh
+  module Services
+    # Scans lookup dirs and returns matched documents
+    class DirectoryScanner
+      # @param directories [Array<String>]
+      # @return [DirectoryScanner]
+      def initialize(directories)
+        @directories = directories
+      end
+
+      # @return [Array<String>]
+      def scan
+        @directories.flat_map { |dir| scan_dir(dir) }
+      end
+
+      private
+
+      # @param dir [String]
+      # @return [Array<String>]
+      def scan_dir(dir)
+        Dir.glob(File.join(dir, "*.pdf"))
+      end
+    end
+  end
+end