pdfh 3.3.1 → 4.0.1

data/lib/pdfh/models/document_type.rb

@@ -3,99 +3,65 @@
 module Pdfh
   # Represents a type of document that can be processed by pdfh
   class DocumentType
-    include Concerns::PasswordDecodable
-
-    REQUIRED_FIELDS = %i[name re_file re_date store_path].freeze
+    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) }
-    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)
+    # @return [Array<Symbol>]
+    def missing_keys
+      @missing_keys ||= REQUIRED_KEYS.select { |key| instance_variable_get(:"@#{key}").to_s.strip.empty? }
     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,101 +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|
-        next if missing_required_fields?(data)
-
-        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
-
-    def missing_required_fields?(data)
-      missing_fields = DocumentType::REQUIRED_FIELDS.select { |field| data[field].nil? || data[field].to_s.empty? }
-      if missing_fields.any?
-        type_name = data[:name] || "Unnamed type"
-        missing_fields_names = missing_fields.join(", ")
-        Pdfh.info format("Skipping document type %<type_name>s. Missing required fields: %<missing_fields>s",
-                         type_name: type_name.colorize(:green),
-                         missing_fields: missing_fields_names.colorize(:red))
-      end
-      missing_fields.any?
-    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

data/lib/pdfh/services/document_manager.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Pdfh
+  module Services
+    # Manages the documents, rename, move, etc.
+    class DocumentManager
+      PDF_UNLOCKED_MAGIC_SUFFIX = "_unlocked"
+
+      # @param document [Document]
+      # @param base_path [String]
+      # @param dry_run [Boolean]
+      # @return [DocumentManager]
+      def initialize(document, base_path:, dry_run:)
+        @document = document
+        @base_path = base_path
+        @dry_run = dry_run
+      end
+
+      # @return [void]
+      def call
+        destination_dir = File.join(@base_path, @document.store_path)
+        destination_file = File.join(destination_dir, @document.new_name)
+
+        print_info(destination_dir) if Pdfh.logger.verbose?
+        create_destination_dir(destination_dir)
+        copy_pdf(destination_file)
+        move_companion_files(destination_dir)
+        backup_original
+      end
+
+      private
+
+      # @!attribute [r] document
+      #   @return [Document]
+      attr_reader :document
+
+      # @return [Boolean]
+      def dry_run? = @dry_run
+
+      # @param dir [String]
+      # @return [void]
+      def create_destination_dir(dir)
+        return if Dir.exist?(dir)
+
+        Pdfh.logger.debug "Creating directory: #{dir}"
+        FileUtils.mkdir_p(dir) unless @dry_run
+      end
+
+      # @param destination_file [String]
+      # @return [void]
+      def copy_pdf(destination_file)
+        source_file = @document.file_info.path
+
+        companion_extensions = companion_files.map { File.extname(_1).delete(".") }
+        companion_str = companion_extensions.any? ? " [#{companion_extensions.join(", ").colorize(:magenta)}]" : ""
+        message = format("[%<type>s] %<file>s -> %<dest>s#{companion_str}",
+                         type: document.type.name.ljust(15).colorize(:green),
+                         file: document.file_info.name.colorize(:blue),
+                         dest: document.new_name.colorize(:cyan))
+        if @dry_run
+          Pdfh.logger.info "#{"dry".colorize(:red)} #{message}" unless Pdfh.logger.verbose?
+          return
+        end
+
+        Pdfh.logger.info "#{"".colorize(:green)} #{message}" unless Pdfh.logger.verbose?
+        FileUtils.cp(source_file, destination_file, preserve: true)
+      end
+
+      # @param destination_dir [String]
+      # @return [void]
+      def move_companion_files(destination_dir)
+        companion_files.each do |companion|
+          source = companion
+          dest_name = File.basename(@document.new_name, @document.file_info.extension) + File.extname(companion)
+          destination = File.join(destination_dir, dest_name)
+
+          FileUtils.cp(source, destination, preserve: true) unless dry_run?
+        end
+      end
+
+      # @return [void]
+      def backup_original
+        source_file = document.file_info.path
+        backup_file = "#{source_file}.bkp"
+
+        FileUtils.mv(source_file, backup_file) unless dry_run?
+      end
+
+      # Finds companion files by removing the _unlocked suffix from the PDF name if present.
+      # This allows PDFs unlock by qpdf to locate their original companion files (e.g., .xml, .txt)
+      # that were never renamed with the _unlocked suffix.
+      #
+      # @return [Array<String>] array of non-PDF files with the same base name
+      # @example
+      #   # If document is "cuenta_unlocked.pdf", searches for "cuenta.*"
+      #   # Returns ["cuenta.xml", "cuenta.txt"] (excluding "cuenta.pdf")
+      def companion_files
+        @companion_files ||= begin
+          base_name = document.file_info.stem.delete_suffix(PDF_UNLOCKED_MAGIC_SUFFIX)
+          Dir.glob(File.join(document.file_info.dir, "#{base_name}.*")).reject do |file|
+            File.extname(file) == ".pdf"
+          end
+        end
+      end
+
+      # @param property [String]
+      # @param info [String]
+      # @return [void]
+      def print_info_line(property, info)
+        Pdfh.logger.ident_print property, info.to_s, color: :light_blue, width: 12
+      end
+
+      # @param destination_dir [String]
+      # @return [void]
+      def print_info(destination_dir)
+        print_info_line "Type", document.type.name
+        print_info_line "Period", document.date_info.period
+        print_info_line "New Name", document.new_name
+        print_info_line "Store Path", destination_dir
+        print_info_line "Extra files", companion_files.any? ? companion_files.join(", ") : "—"
+        print_info_line "Processed?", "No (in Dry mode)" if dry_run?
+      end
+    end
+  end
+end

data/lib/pdfh/services/document_matcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pdfh
+  module Services
+    # Matches a PDF file against settings and builds a Document if valid
+    class DocumentMatcher
+      # @param document_types [Array<DocumentType>]
+      # @return [DocumentMatcher]
+      def initialize(document_types)
+        @document_types = document_types
+      end
+
+      # @param file [String] Path to the PDF file
+      # @param text [String] Extracted text from the PDF
+      # @return [Array<Document>]
+      def match(file, text)
+        @document_types.each_with_object([]) do |type, matches|
+          # Try to match the document type by ID (content)
+          next unless type.re_id.match?(text)
+
+          Pdfh.logger.debug "Matched document type: #{type.name}"
+
+          # Try to match the date in the text
+          date_match = type.re_date.match(text)
+          unless date_match
+            Pdfh.logger.debug "No date match found for #{type.name}"
+            next
+          end
+
+          # Extract date captures (handles both named and positional captures)
+          date_captures = extract_date_captures(date_match)
+
+          matches << Document.new(file, type, text, date_captures)
+        end
+      end
+
+      private
+
+      # Extracts date captures from MatchData, supporting both named and positional captures
+      # @param match_data [MatchData]
+      # @return [Hash{String => String}] Hash with keys 'm' (month), 'y' (year), 'd' (day)
+      def extract_date_captures(match_data)
+        if match_data.names.any?
+          Pdfh.logger.debug "Using #{"named".colorize(:green)} captures: #{match_data.named_captures.inspect}"
+          return match_data.named_captures
+        end
+
+        # Fall back to positional captures — assume order: [month, year, day?]
+        {}.tap do |c|
+          c["m"], c["y"], c["d"] = match_data.captures
+          c.compact!
+          Pdfh.logger.debug "Using #{"positional".colorize(:red)} captures: #{c.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/pdfh/services/opt_parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Pdfh
+  module Services
+    # Handles Argument options
+    class OptParser
+      # @param argv [Array<String>] command line arguments (ie. ARGV)
+      # @param console [Pdfh::Console, nil]
+      # @return [self]
+      def initialize(argv:, console: nil)
+        @argv = argv
+        @console = console || Console.new(false)
+        @options = {
+          verbose: false,
+          dry: false
+        }
+      end
+
+      # @return [Hash] Parsed options including flags and file arguments
+      def parse_argv
+        option_parser = build_option_parser
+        option_parser.parse!(@argv)
+        @options
+      rescue OptionParser::InvalidOption => e
+        @console.error_print(e.message, exit_app: false)
+        @console.info option_parser.help
+        exit 1
+      end
+
+      private
+
+      # @return [OptionParser] Configured OptionParser instance
+      def build_option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: #{opts.program_name} [options]"
+          opts.separator ""
+          opts.separator "Specific options:"
+
+          opts.on("-v", "--verbose", "Show more output. Useful for debug") { @options[:verbose] = true }
+          opts.on("-d", "--dry", "Dry run, does not write new pdf") { @options[:dry] = true }
+          opts.on_tail("-T", "--list-types", "List document types in configuration") { list_types && exit }
+          opts.on_tail("-V", "--version", "Show version") { version || exit }
+          opts.on_tail("-h", "--help", "help (this dialog)") { help || exit }
+        end
+      end
+
+      # @return [nil]
+      def version
+        @console.info "#{build_option_parser.program_name} v#{Pdfh::VERSION}"
+      end
+
+      # @return [nil]
+      def help
+        @console.info build_option_parser
+      end
+
+      # Lists the available document types
+      # @return [nil]
+      def list_types
+        # Temporarily set logger for loading settings
+        Pdfh.logger = @console
+
+        settings = SettingsBuilder.call
+        spacing = " " * 2
+        max_width = settings.document_types.map { |t| t.gid.size }.max
+        @console.info "#{spacing}#{"ID".ljust(max_width)}  Type Name"
+        @console.info "#{spacing}#{"—" * max_width}  #{"—" * 23}"
+        settings.document_types.each do |type|
+          @console.info "#{spacing}#{type.gid.ljust(max_width).yellow}  #{type.name}"
+        end
+      end
+    end
+  end
+end

data/lib/pdfh/services/pdf_text_extractor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "English"
+
+module Pdfh
+  module Services
+    # Extracts text from a PDF using pdftotext command
+    class PdfTextExtractor
+      # @param pdf_path [String]
+      # @return [String]
+      # @raise [ArgumentError] if file doesn't exist or is not a PDF
+      # @raise [RuntimeError] if extraction fails
+      def self.call(pdf_path)
+        validate_file!(pdf_path)
+
+        # Use Shellwords to properly escape the path for shell execution
+        safe_path = Shellwords.escape(pdf_path)
+        cmd = "pdftotext -enc UTF-8 -layout #{safe_path} - 2>/dev/null"
+
+        text = `#{cmd}`
+        exit_status = $CHILD_STATUS
+
+        # Check if command executed successfully
+        if exit_status.nil? || !exit_status.success?
+          Pdfh.logger.debug "Failed to extract text from: #{pdf_path}"
+          return ""
+        end
+
+        text
+      end
+
+      # @param pdf_path [String]
+      # @return [void]
+      # @raise [ArgumentError] if validation fails
+      def self.validate_file!(pdf_path)
+        raise ArgumentError, "PDF path cannot be nil" if pdf_path.nil?
+        raise ArgumentError, "PDF path cannot be empty" if pdf_path.empty?
+        raise ArgumentError, "File does not exist: #{pdf_path}" unless File.exist?(pdf_path)
+        raise ArgumentError, "Not a file: #{pdf_path}" unless File.file?(pdf_path)
+        raise ArgumentError, "Not a PDF file: #{pdf_path}" unless File.extname(pdf_path).casecmp?(".pdf")
+      end
+    end
+  end
+end