pdfh 3.3.1 → 4.0.0

data/lib/pdfh/models/document_period.rb

@@ -1,37 +0,0 @@
-# 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 (frozen)]
-    def to_s
-      "#{year}-#{month.to_s.rjust(2, "0")}"
-    end
-
-    # @return [String (frozen)]
-    def inspect
-      "<#{self.class} year=#{year} month=#{month}>"
-    end
-  end
-end

data/lib/pdfh/models/document_sub_type.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # Provides a way to divide document type by subtypes, for different name, and month adjustments
-  DocumentSubType = Struct.new(:name, :month_offset, :re_date, keyword_init: true)
-end

data/lib/pdfh/models/zip_types.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # Zip files which contains PDF files that need pre-processing
-  class ZipType
-    include Concerns::PasswordDecodable
-
-    attr_reader :name, :re_file, :pwd
-
-    # @param args [Hash]
-    # @return [self]
-    def initialize(args)
-      args.each { |k, v| instance_variable_set(:"@#{k}", v) }
-      @re_file = Regexp.new(re_file)
-    end
-  end
-end

data/lib/pdfh/settings_template.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # rubocop:disable Layout/HashAlignment
-  DOCUMENT_TYPE_TEMPLATE = {
-    "name"          => "Example Name",
-    "re_file"       => ".*file_name\.pdf",
-    "re_date"       => "(\d{2})\/(?<m>\w+)\/(?<y>\d{4})",
-    "pwd"           => "BASE64_STRING",
-    "store_path"    => "{YEAR}/sub folder",
-    "name_template" => "{period} {original}",
-    "sub_types"     => []
-  }.freeze
-
-  SETTINGS_TEMPLATE = {
-    "lookup_dirs" => ["~/Downloads"].freeze,
-    "destination_base_path" => "~/Documents",
-    "document_types" => [DOCUMENT_TYPE_TEMPLATE].freeze
-  }.freeze
-  # rubocop:enable Layout/HashAlignment
-end

data/lib/pdfh/utils/opt_parser.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module Pdfh
-  # 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,
-        type: nil,
-        files: []
-      }
-    end
-
-    # @return [Hash] Parsed options including flags and file arguments
-    def parse_argv
-      option_parser = build_option_parser
-      non_option_args = option_parser.parse!(@argv)
-      @options[:files] = non_option_args
-      @options.transform_keys { |key| key.to_s.tr("-", "_").to_sym }
-    rescue OptionParser::InvalidOption => e
-      @console.error_print(e.message, exit_app: false)
-      puts 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] [file1.pdf, ...]"
-        opts.separator ""
-        opts.separator "Specific options:"
-
-        opts.on("-tID", "--type=ID", "Document type id (requires a trailing file list)") { @options[:type] = _1 }
-        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
-      Pdfh.instance_variable_set(:@options, Options.new(@options))
-      Pdfh.instance_variable_set(:@console, @console)
-
-      settings = SettingsBuilder.build
-      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

data/lib/pdfh/utils/options.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # Argument Options object container
-  class Options
-    attr_reader :type, :files
-
-    # @param arg_options [Hash]
-    # @return [self]
-    def initialize(arg_options)
-      @verbose = arg_options[:verbose]
-      @dry = arg_options[:dry]
-      @type = arg_options[:type]
-      @files = arg_options[:files] || []
-      @mode = type ? :file : :directory
-    end
-
-    # @return [Boolean]
-    def verbose?
-      @verbose
-    end
-
-    # @return [Boolean]
-    def dry?
-      @dry
-    end
-
-    # @return [Boolean]
-    def file_mode?
-      @mode == :file
-    end
-
-    # @return [Boolean]
-    def files?
-      !!@files&.any?
-    end
-  end
-end

data/lib/pdfh/utils/pdf_file_handler.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # Handles the PDF file
-  class PdfFileHandler
-    attr_reader :file, :type, :document
-
-    # @param [String] file
-    # @param [DocumentType, nil] type
-    # @return [self]
-    def initialize(file, type)
-      @file = file
-      @type = type
-    end
-
-    # @return [boolean]
-    def type?
-      !!type
-    end
-
-    # Generate document, and process actions
-    # @return [void]
-    def process_document(base_path)
-      Pdfh.info "Working on #{base_name.colorize(:light_green)}"
-      raise IOError, "File #{file} not found" unless File.exist?(file)
-
-      @document = Document.new(file, type, extract_text)
-      document.process
-      document.print_info
-      write_pdf(base_path)
-
-      nil
-    rescue StandardError => e
-      Pdfh.ident_print "Doc Error", e.message, color: :red, width: 12
-    end
-
-    # Create a backup of original document
-    # @return [void]
-    def make_document_backup(document)
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Creating PDF backup"
-      Dir.chdir(document.home_dir) do
-        Pdfh.debug "  Working on: #{document.home_dir.inspect} directory"
-        Pdfh.debug "    mv #{document.file_name.inspect} -> #{document.backup_name.inspect}"
-        File.rename(document.file_name, document.backup_name) unless Pdfh.dry?
-      end
-    end
-
-    # @return [void]
-    def copy_companion_files(destination, document)
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Writing Companion files"
-      document.companion_files.each do |file|
-        Pdfh.debug "  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.debug "    cp #{src_name} --> #{dest_full}"
-        FileUtils.cp(src_name, dest_full) unless Pdfh.dry?
-      end
-    end
-
-    # @return [String]
-    def base_name
-      File.basename(file)
-    end
-
-    private
-
-    # @return [void]
-    def write_pdf(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)
-
-      write_new_pdf(dir_path, full_path)
-      make_document_backup(document)
-      copy_companion_files(dir_path, document)
-    rescue StandardError => e
-      Pdfh.ident_print "Doc Error", e.message, color: :red, width: IDENT
-    end
-
-    def qpdf_command(*args)
-      password_option = type&.password ? "--password=#{type&.password.inspect} " : ""
-
-      %(qpdf #{password_option}--decrypt #{args.join(" ")})
-    end
-
-    # Gets the text from the pdf in order to execute
-    # the regular expression matches
-    # @return [String]
-    def extract_text
-      temp = Tempfile.new("pdfh")
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Extract PDF text"
-      Pdfh.debug "  --> #{temp.path} temporal file assigned."
-
-      cmd1 = qpdf_command("--stream-data=uncompress", file.inspect, temp.path)
-      Pdfh.debug "  DeCrypt Command: #{cmd1}"
-      _result = `#{cmd1}`
-
-      cmd2 = %(pdftotext -enc UTF-8 #{temp.path} -)
-      Pdfh.debug "  Extract Command: #{cmd2}"
-      text = `#{cmd2}`
-      Pdfh.debug "  Text: #{text.inspect}"
-      text
-    end
-
-    # @return [void]
-    def write_new_pdf(dir_path, full_path)
-      Pdfh.debug "~~~~~~~~~~~~~~~~~~ Writing PDFs"
-      raise IOError, "Path #{dir_path} not found." unless Dir.exist?(dir_path)
-
-      cmd = qpdf_command(file.inspect, full_path.inspect)
-      Pdfh.debug "  Write PDF Command: #{cmd}"
-
-      return if Pdfh.dry?
-
-      _result = `#{cmd}`
-      raise IOError, "New PDF file #{full_path.inspect} was not created." unless File.file?(full_path)
-    end
-  end
-end

data/lib/pdfh/utils/settings_builder.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Pdfh
-  # Loads or creates a default settings yaml file
-  class SettingsBuilder
-    CONFIG_FILE_LOCATIONS = [Dir.pwd, ENV.fetch("XDG_CONFIG_HOME", "~/.config"), "~"].freeze
-    SUPPORTED_EXTENSIONS = %w[yml yaml].freeze
-    ENV_VAR = "PDFH_CONFIG_FILE"
-
-    class << self
-      # @return [Pdfh::Settings]
-      def build
-        env_config_file = ENV.fetch(ENV_VAR, nil)
-        raise "File path in #{ENV_VAR} not found" if env_config_file && !File.exist?(env_config_file)
-
-        config_file = env_config_file || search_config_file
-        file_hash = YAML.load_file(config_file, symbolize_names: true)
-        Pdfh.debug "Loaded configuration file: #{config_file}"
-
-        Settings.new(file_hash)
-      end
-
-      private
-
-      # @return [String]
-      def config_file_name
-        File.basename($PROGRAM_NAME)
-      end
-
-      # @return [String (frozen)]
-      def default_settings_name
-        "#{config_file_name}.#{SUPPORTED_EXTENSIONS.first}"
-      end
-
-      # @return [String]
-      def create_settings_file
-        full_path = File.join(File.expand_path("~"), default_settings_name)
-        return if File.exist?(full_path) # double check
-
-        File.write(full_path, Pdfh::SETTINGS_TEMPLATE.to_yaml)
-        Pdfh.info "Default settings file was created: #{full_path.colorize(:green)}"
-
-        full_path
-      end
-
-      # Gets the first settings file found, or creates a new one
-      # @return [String]
-      def search_config_file
-        CONFIG_FILE_LOCATIONS.each do |dir_string|
-          dir = File.expand_path(dir_string)
-          SUPPORTED_EXTENSIONS.each do |ext|
-            path = File.join(dir, "#{config_file_name}.#{ext}")
-            return path if File.exist?(path)
-          end
-        end
-
-        Pdfh.warn_print "No configuration file was found within paths: #{CONFIG_FILE_LOCATIONS.join(", ")}"
-        create_settings_file
-      end
-    end
-  end
-end