pdfh 0.1.9 → 0.2.0

data/lib/pdfh/document_period.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pdfh
+  # Calculate correct period from the extracted document date and subtype month offset
+  class DocumentPeriod
+    attr_reader :month, :year
+
+    # @return [self]
+    def initialize(month:, month_offset:, year:, day: nil)
+      @day = day
+      @raw_month = month
+      @raw_year = year
+      normalized_month = Month.normalize_to_i(month) + (month_offset || 0)
+      year_offset = 0
+      @month = case normalized_month
+               when 0
+                 year_offset = -1
+                 12
+               when 13
+                 year_offset = 1
+                 1
+               else normalized_month
+               end
+      @year = (year.size == 2 ? "20#{year}" : year).to_i + year_offset
+    end
+
+    # @return [String]
+    def to_s
+      "#{year}-#{month.to_s.rjust(2, "0")}"
+    end
+  end
+end

data/lib/pdfh/document_processor.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Pdfh
+  # Main functionality. This class is intended to manage the pdf documents
+  class DocumentProcessor
+    # @return [self]
+    def initialize
+      @options = Pdfh.parse_argv
+      Pdfh.verbose = options[:verbose]
+      Pdfh.dry = options[:dry]
+      Pdfh.verbose_print(options)
+      @mode = options.key?(:type) ? :file : :directory
+    end
+
+    # @return [void]
+    def start
+      @settings = Settings.new(Pdfh.search_config_file)
+      puts "Destination path: #{@settings.base_path.colorize(:light_blue)}" if Pdfh.verbose?
+
+      @mode == :file ? process_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.error_print e.message
+    end
+
+    private
+
+    attr_reader :options
+
+    # @param [String] file_name
+    # @return [DocumentType]
+    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 [DocumentType]
+    def doc_type_by_id(id)
+      @settings.document_types.find { |t| t.gid == id }
+    end
+
+    # @return [void]
+    def process_files
+      type_id = options[:type]
+      raise ArgumentError, "No files provided to process #{type_id.inspect} type." unless options[:files]
+
+      type = doc_type_by_id(type_id)
+      puts
+      options[:files].each do |file|
+        unless File.exist?(file)
+          Pdfh.warn_print "File #{file.inspect} does not exist."
+          next
+        end
+        unless File.extname(file) == ".pdf"
+          Pdfh.warn_print "File #{file.inspect} is not a pdf."
+          next
+        end
+        process_document(file, type)
+      end
+    end
+
+    # @return [void]
+    def process_lookup_dirs
+      @settings.lookup_dirs.each do |work_directory|
+        process_directory(work_directory)
+      end
+    end
+
+    # @param [String] work_directory
+    # @return [Enumerator]
+    def process_directory(work_directory)
+      Pdfh.headline(work_directory)
+      processed_count = 0
+      ignored_files = []
+      files = Dir["#{work_directory}/*.pdf"]
+      files.each do |pdf_file|
+        type = match_doc_type(pdf_file)
+        if type
+          processed_count += 1
+          process_document(pdf_file, type)
+        else
+          ignored_files << basename_without_ext(pdf_file)
+        end
+      end
+      puts "  (No files processed)".colorize(:light_black) if processed_count.zero?
+      return unless Pdfh.verbose?
+
+      puts "\n  No document type found for these PDF files:" if ignored_files.any?
+      ignored_files.each.with_index(1) { |file, index| Pdfh.ident_print index, file, color: :magenta }
+    end
+
+    ##
+    # Generate document, and process actions
+    # @param [String] file
+    # @param [DocumentType] type
+    # @return [void]
+    def process_document(file, type)
+      base = File.basename(file)
+      puts "Working on #{base.colorize(:light_green)}"
+      pad = 12
+      Pdfh.ident_print "Type", type.name, color: :light_blue, width: pad
+      doc = Document.new(file, type)
+      Pdfh.ident_print "Sub-Type", doc.sub_type, color: :light_blue, width: pad
+      Pdfh.ident_print "Period", doc.period, color: :light_blue, width: pad
+      Pdfh.ident_print "New Name", doc.new_name, color: :light_blue, width: pad
+      Pdfh.ident_print "Store Path", doc.store_path, color: :light_blue, width: pad
+      Pdfh.ident_print "Other files", doc.companion_files(join: true), color: :light_blue, width: pad
+      Pdfh.ident_print "Print CMD", doc.print_cmd, color: :light_blue, width: pad
+      Pdfh.ident_print "Processed?", "No (in Dry mode)", color: :red, width: pad if Pdfh.dry?
+      write_pdf(doc)
+    rescue StandardError => e
+      Pdfh.ident_print "Doc Error", e.message, color: :red, width: pad
+    end
+
+    def write_pdf(document)
+      base_path = @settings.base_path
+      full_path = File.join(base_path, document.store_path, document.new_name)
+      dir_path = File.join(base_path, document.store_path)
+
+      FileUtils.mkdir_p(dir_path) unless File.exist?(dir_path)
+
+      document.pdf_doc.write_new_pdf(dir_path, full_path)
+      make_document_backup(document)
+      copy_companion_files(dir_path, document)
+    end
+
+    # Create a backup of original document
+    def make_document_backup(document)
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Creating PDF backup"
+      Dir.chdir(document.home_dir) do
+        Pdfh.verbose_print "  Working on: #{document.home_dir.inspect} directory"
+        Pdfh.verbose_print "    mv #{document.file_name.inspect} -> #{document.backup_name.inspect}"
+        File.rename(document.file_name, document.backup_name) unless Pdfh.dry?
+      end
+    end
+
+    def copy_companion_files(destination, document)
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Writing Companion files"
+      document.companion_files.each do |file|
+        Pdfh.verbose_print "  Working on #{file.inspect}..."
+        src_name = File.join(document.home_dir, file)
+        src_ext = File.extname(file)
+        dest_name = File.basename(document.new_name, ".pdf")
+        dest_full = File.join(destination, "#{dest_name}#{src_ext}")
+        Pdfh.verbose_print "    cp #{src_name} --> #{dest_full}"
+        FileUtils.cp(src_name, dest_full) unless Pdfh.dry?
+      end
+    end
+
+    # @return [String]
+    def basename_without_ext(file)
+      File.basename(file, File.extname(file))
+    end
+  end
+end

data/lib/pdfh/document_type.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Pdfh
+  DocumentSubType = Struct.new(:name, :month_offset, keyword_init: true)
+
+  DocumentType = Struct.new(:name, :re_file, :re_date, :pwd, :store_path, :name_template, :sub_types, :print_cmd,
+                            keyword_init: true) do
+    # @return [self]
+    def initialize(args)
+      super
+      self.name_template ||= "{original}"
+      self.re_file = Regexp.new(re_file)
+      self.re_date = Regexp.new(re_date)
+      self.pwd = Base64.decode64(pwd) if pwd
+      self.sub_types = extract_subtype(sub_types) if sub_types
+    end
+
+    # @return [String]
+    def gid
+      name.downcase.gsub(/[^0-9A-Za-z\s]/, "").tr(" ", "-")
+    end
+
+    # @return [DocumentSubType]
+    def sub_type(text)
+      # Regexp.new(st.name).match?(name)
+      sub_types&.find { |st| /#{st.name}/i.match?(text) }
+    end
+
+    private
+
+    # @param sub_types [Array]
+    # @return [DocumentSubType]
+    def extract_subtype(sub_types)
+      sub_types.map do |st|
+        name = st["name"]
+        offset = st["month_offset"].to_i
+        DocumentSubType.new(name: name, month_offset: offset)
+      end
+    end
+  end
+end

data/lib/pdfh/month.rb

@@ -1,41 +1,51 @@
 # frozen_string_literal: true
 
 module Pdfh
-  ##
-  # Handles Month convertions
+  # Handles Month conversions
   class Month
-    MONTHS = {
-      enero: 1,
-      febrero: 2,
-      marzo: 3,
-      abril: 4,
-      mayo: 5,
-      junio: 6,
-      julio: 7,
-      agosto: 8,
-      septiembre: 9,
-      octubre: 10,
-      noviembre: 11,
-      diciembre: 12
-    }.freeze
-
-    ##
-    # @param [String] month
-    # @return [Integer]
-    def self.normalize(month)
-      # When param is a number
-      month_num = month.to_i
-      return month_num if month_num.between?(1, 12) # (1..12).include?(month_num)
-
-      # When param is a 3 char month: 'mar', 'nov'
-      if month.size == 3
-        MONTHS.each_key do |mon|
-          return MONTHS[mon] if mon.to_s[0, 3] == month
-        end
+    class << self
+      FINDER_3L = proc { |name_search, month| month[0, 3].casecmp?(name_search) }
+      FINDER_FL = proc { |name_search, month| month.casecmp?(name_search) }
+
+      # rubocop:disable Layout/SpaceInsideArrayPercentLiteral
+      MONTHS_EN = %w[january february march april may  june  july  august september  october november  december].freeze
+      MONTHS_ES = %w[enero   febrero  marzo abril mayo junio julio agosto septiembre octubre noviembre diciembre].freeze
+      # rubocop:enable Layout/SpaceInsideArrayPercentLiteral
+
+      # @param [String] month
+      # @return [Integer]
+      def normalize_to_i(month)
+        # When param is a number
+        month_num = month.to_i
+        raise ArgumentError, "Month #{month.inspect} is not a valid month number" if month_num > 12
+
+        return month_num if month_num.between?(1, 12)
+
+        # When param is a 3 char month: 'mar', 'nov'
+        return find_month(month, FINDER_3L) if month.size == 3
+
+        # When param has a direct match
+        find_month(month, FINDER_FL)
       end
 
-      # When param has a direct match
-      MONTHS[month.to_sym]
+      private
+
+      # @return [Integer]
+      def find_month(name, finder)
+        find_by_name = finder.curry[name]
+        match = MONTHS_ES.find(&find_by_name)
+        return month_number(MONTHS_ES, match) if match
+
+        match = MONTHS_EN.find(&find_by_name)
+        return month_number(MONTHS_EN, match) if match
+
+        raise ArgumentError, "Month #{name.inspect} is not valid"
+      end
+
+      # @return [Integer]
+      def month_number(month_array, name)
+        month_array.rindex(name) + 1
+      end
     end
   end
 end

data/lib/pdfh/opt_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Pdfh
+  OPT_PARSER = OptionParser.new do |opts|
+    opts.default_argv
+    # Process ARGV
+    opts.banner = "Usage: #{opts.program_name} [options] [file1 ...]"
+    opts.separator ""
+    opts.separator "Specific options:"
+
+    opts.on("-tID", "--type=ID", "Document type id (requires a trailing file list)")
+    opts.on_tail("-T", "--list-types", "List document types in configuration") do
+      settings = Settings.new(Pdfh.search_config_file)
+      ident = 4
+      max_width = settings.document_types.map { |t| t.gid.size }.max
+      puts "#{" " * ident}#{"ID".ljust(max_width)}  Type Name"
+      puts "#{" " * ident}#{"-" * max_width}  -----------------------"
+      settings.document_types.each do |type|
+        puts "#{" " * ident}#{type.gid.ljust(max_width)}  #{type.name.inspect}"
+      end
+      exit
+    rescue SettingsIOError => e
+      Pdfh.error_print(e.message, exit_app: false)
+      Pdfh.create_settings_file
+      exit(1)
+    end
+    opts.on_tail("-V", "--version", "Show version") do
+      puts "#{opts.program_name} v#{Pdfh::VERSION}"
+      exit
+    end
+    opts.on_tail("-h", "--help", "help (this dialog)") do
+      puts opts
+      exit
+    end
+
+    opts.on("-v", "--verbose", "Show more output. Useful for debug")
+    opts.on("-d", "--dry", "Dry run, does not write new pdf")
+  end
+end

data/lib/pdfh/pdf_handler.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Pdfh
-  ##
   # Handles the Pdf document text extraction and password removal
   # TODO: Replace command utils with this gem
   #  require 'pdf-reader'
@@ -11,44 +10,46 @@ module Pdfh
   #      @text << page.text
   #  end
   class PdfHandler
-    attr_reader :file, :password
+    attr_reader :file
 
+    # @return [self]
     def initialize(file, password)
       @file = file
-      @password = password
+      @password_option = password ? "--password=#{password.inspect} " : ""
     end
 
     ##
     # Gets the text from the pdf in order to execute
-    # the regular expresiom matches
+    # the regular expresion matches
+    # @return [String]
     def extract_text
       temp = `mktemp`.chomp
-      Verbose.print "  --> #{temp} temporal file assigned."
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Extract PDF text"
+      Pdfh.verbose_print "  --> #{temp.inspect} temporal file assigned."
 
-      password_opt = "--password='#{@password}'" if @password
-      cmd = %(qpdf #{password_opt} --decrypt --stream-data=uncompress '#{@file}' '#{temp}')
-      Verbose.print "  Command: #{cmd}"
+      cmd = %(qpdf #{@password_option}--decrypt --stream-data=uncompress #{@file.inspect} #{temp.inspect})
+      Pdfh.verbose_print "  DeCrypt Command: #{cmd}"
       _result = `#{cmd}`
 
-      cmd2 = %(pdftotext -enc UTF-8 '#{temp}' -)
-      Verbose.print "  Command: #{cmd2}"
+      cmd2 = %(pdftotext -enc UTF-8 #{temp.inspect} -)
+      Pdfh.verbose_print "  Extract Command: #{cmd2}"
       text = `#{cmd2}`
-      Verbose.print "  Text extracted: #{text}"
+      Pdfh.verbose_print "  Text: #{text.inspect}"
       text
     end
 
-    def write_pdf(dir_path, full_path)
-      Verbose.print "~~~~~~~~~~~~~~~~~~ Writing PDFs"
+    # @return [void]
+    def write_new_pdf(dir_path, full_path)
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Writing PDFs"
       raise IOError, "Path #{dir_path} not found." unless Dir.exist?(dir_path)
 
-      password_opt = "--password='#{@password}'" if @password
-      cmd = %(qpdf #{password_opt} --decrypt '#{@file}' '#{full_path}')
-      Verbose.print "  Write pdf command: #{cmd}"
+      cmd = %(qpdf #{@password_option}--decrypt #{@file.inspect} #{full_path.inspect})
+      Pdfh.verbose_print "  Write PDF Command: #{cmd}"
 
-      return if Dry.active?
+      return if Pdfh.dry?
 
       _result = `#{cmd}`
-      raise IOError, "File #{full_path} was not created." unless File.file?(full_path)
+      raise IOError, "New PDF file #{full_path.inspect} was not created." unless File.file?(full_path)
     end
   end
 end

data/lib/pdfh/settings.rb

@@ -1,61 +1,53 @@
 # frozen_string_literal: true
 
 require "yaml"
-require "ostruct"
-require "base64"
 
 module Pdfh
-  ##
   # Handles the config yaml data mapping, and associates a file name with a doc type
   class Settings
-    attr_reader :scrape_dirs, :base_path, :document_types
+    attr_reader :lookup_dirs, :base_path, :document_types
 
-    def initialize(file)
-      file_hash = YAML.load_file(file)
-      Verbose.print "Loaded configuration file: #{file}"
+    # @param config_file [String]
+    # @return [self]
+    def initialize(config_file)
+      file_hash = YAML.load_file(config_file)
+      Pdfh.verbose_print "Loaded configuration file: #{config_file}"
 
-      @scrape_dirs = process_scrape_dirs(file_hash["scrape_dirs"])
-      @base_path = File.expand_path(file_hash["base_path"])
-      @document_types = process_doc_types(file_hash["document_types"])
+      process_lookup_dirs(file_hash["lookup_dirs"])
+      process_destination_base(file_hash["destination_base_path"])
 
-      Verbose.print "Processing directories:"
-      scrape_dirs.each { |dir| Verbose.print "  - #{dir}" }
-      Verbose.print
-    end
+      Pdfh.verbose_print "Configured Look up directories:"
+      lookup_dirs.each_with_index { |dir, idx| Pdfh.verbose_print "  #{idx + 1}. #{dir}" }
+      Pdfh.verbose_print
 
-    ##
-    # @param [String] file_name
-    # @return [OpenStruct]
-    def match_doc_type(file_name)
-      document_types.each do |type|
-        match = type.re_file.match(file_name)
-        return type if match
-      end
-      nil
+      @document_types = load_doc_types(file_hash["document_types"])
     end
 
     private
 
-    def process_scrape_dirs(scrape_dirs_list)
-      scrape_dirs_list.map do |dir|
+    # @return [void]
+    def process_lookup_dirs(lookup_dirs_list)
+      @lookup_dirs = lookup_dirs_list.filter_map do |dir|
         expanded = File.expand_path(dir)
-        dir_exists = File.directory?(expanded)
-        if dir_exists
-          expanded
-        else
-          Verbose.print "  ** Directory #{dir} does not exists."
+        unless File.directory?(expanded)
+          Pdfh.verbose_print "  ** Error, Directory #{dir} does not exists."
+          next
         end
-      end.compact
+        expanded
+      end
+      raise ArgumentError, "No valid Look up directories configured." if lookup_dirs.empty?
     end
 
-    def process_doc_types(doc_types)
-      doc_types.map do |x|
-        object = OpenStruct.new(x)
-        object.re_file = Regexp.new(object.re_file)
-        object.re_date = Regexp.new(object.re_date)
-        object.pwd = object.pwd ? Base64.decode64(object.pwd) : nil
-        object
-      end
+    # @return [void]
+    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
+
+    # @return [Array<DocumentType>]
+    def load_doc_types(doc_types)
+      doc_types.map { |data| DocumentType.new(data) }
     end
   end
 end