pdfh 0.2.1 → 3.0.1

data/lib/pdfh/{settings.rb → models/settings.rb}

@@ -1,26 +1,31 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module Pdfh
   # Handles the config yaml data mapping, and associates a file name with a doc type
   class Settings
-    attr_reader :lookup_dirs, :base_path, :document_types
+    attr_reader :lookup_dirs, :base_path
 
-    # @param config_file [String]
+    # @param config_data [Hash]
     # @return [self]
-    def initialize(config_file)
-      file_hash = YAML.load_file(config_file)
-      Pdfh.verbose_print "Loaded configuration file: #{config_file}"
+    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
 
-      process_lookup_dirs(file_hash["lookup_dirs"])
-      process_destination_base(file_hash["destination_base_path"])
+      load_doc_types(config_data[:document_types])
+    end
 
-      Pdfh.verbose_print "Configured Look up directories:"
-      lookup_dirs.each_with_index { |dir, idx| Pdfh.verbose_print "  #{idx + 1}. #{dir}" }
-      Pdfh.verbose_print
+    # @return [Array<DocumentType>]
+    def document_types
+      @document_types.values
+    end
 
-      @document_types = load_doc_types(file_hash["document_types"])
+    # @return [DocumentType]
+    def document_type(id)
+      @document_types[id]
     end
 
     private
@@ -30,7 +35,7 @@ module Pdfh
       @lookup_dirs = lookup_dirs_list.filter_map do |dir|
         expanded = File.expand_path(dir)
         unless File.directory?(expanded)
-          Pdfh.verbose_print "  ** Error, Directory #{dir} does not exists."
+          Pdfh.debug "  ** Error, Directory #{dir} does not exists."
           next
         end
         expanded
@@ -47,7 +52,10 @@ module Pdfh
 
     # @return [Array<DocumentType>]
     def load_doc_types(doc_types)
-      doc_types.map { |data| DocumentType.new(data) }
+      @document_types = doc_types.each_with_object({}) do |data, result|
+        doc_type = DocumentType.new(data)
+        result.store(doc_type.gid, doc_type)
+      end
     end
   end
 end

data/lib/pdfh/settings_template.rb

@@ -2,20 +2,20 @@
 
 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" => [
-      {
-        "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
-    ].freeze
+    "document_types" => [DOCUMENT_TYPE_TEMPLATE].freeze
   }.freeze
   # rubocop:enable Layout/HashAlignment
 end

data/lib/pdfh/utils/console.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pdfh
+  # All console output formats
+  class Console
+    # @return [self]
+    def initialize(verbose)
+      @verbose = verbose
+    end
+
+    # @return [void]
+    def debug(message = nil)
+      msg = message.to_s
+      msg = msg.colorize(:cyan) unless msg.colorized?
+      output(msg) if verbose?
+    end
+
+    # @return [void]
+    def info(message)
+      output(message)
+    end
+
+    # Prints visual separator in shell for easier reading for humans
+    # @example output
+    # ——— Title ——————————————— ... ——————
+    # @param title [String]
+    # @return [void]
+    def headline(title)
+      _, cols = console_size
+      line_length = cols - (title.size + 5)
+      left  = ("—" * 3).to_s.red
+      right = ("—" * line_length).to_s.red
+      output "\n#{left} #{title.colorize(color: :blue, mode: :bold)} #{right}"
+    end
+
+    # @param message [String]
+    # @param exit_app [Boolean] exit application if true (default)
+    # @return [void]
+    def error_print(message, exit_app: true)
+      output "Error, #{message}".colorize(:red)
+      exit 1 if exit_app
+    end
+
+    # @param message [String]
+    # @return [void]
+    def warn_print(message)
+      output "Warning, #{message}".colorize(:yellow)
+    end
+
+    # @example usage
+    #   ident_print("Name", "iax")
+    #   # =>     Name: "iax"
+    # @return [void]
+    def ident_print(field, value, color: :green, width: 3)
+      field_str = field.to_s.rjust(width)
+      value_str = value.colorize(color)
+      output "#{" " * 4}#{field_str}: #{value_str}"
+    end
+
+    # Show options used to run the current sync job
+    # @param options [Hash]
+    # @return [void]
+    def print_options(options) # rubocop:disable Metrics/CyclomaticComplexity
+      max_size = options.keys.map(&:size).max + 3
+      options.each do |key, value|
+        left  = key.inspect.rjust(max_size).cyan
+        right = case value
+                when NilClass   then value.inspect.colorize(color: :black, mode: :bold)
+                when TrueClass  then value.inspect.colorize(color: :green, mode: :bold)
+                when FalseClass then value.inspect.colorize(color: :red, mode: :bold)
+                when Symbol     then value.inspect.yellow
+                when String     then value.inspect.light_magenta
+                else
+                  value.inspect.red
+                end
+        debug "#{left} => #{right}"
+      end
+
+      nil
+    end
+
+    private
+
+    # @return [boolean]
+    def verbose?
+      @verbose
+    end
+
+    # @return [void]
+    def output(msg)
+      puts(msg)
+    end
+
+    # Returns rows, cols
+    # TODO: review https://gist.github.com/nixpulvis/6025433
+    # @return [Array<Integer, Integer>]
+    def console_size
+      `stty size`.split.map(&:to_i)
+    end
+  end
+end

data/lib/pdfh/utils/opt_parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Pdfh
+  # Handles Argument options
+  class OptParser
+    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 = SettingsBuilder.build
+        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}  #{"—" * 23}"
+        settings.document_types.each do |type|
+          puts "#{" " * ident}#{type.gid.ljust(max_width).yellow}  #{type.name.inspect}"
+        end
+        exit
+      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
+
+    class << self
+      # @return [Hash]
+      def parse_argv
+        Pdfh.instance_variable_set(:@console, Console.new(false))
+
+        options = { dry: false, verbose: false }
+        OPT_PARSER.parse!(into: options)
+        options[:files] = ARGV if ARGV.any?
+        options.transform_keys { |key| key.to_s.tr("-", "_").to_sym }
+      rescue OptionParser::InvalidOption => e
+        error_print e.message, exit_app: false
+        puts OPT_PARSER.help
+        exit 1
+      end
+    end
+  end
+end

data/lib/pdfh/utils/options.rb

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,121 @@
+# 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.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 expresion 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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pdfh
+  # Loads or creates a default settings yaml file
+  class SettingsBuilder
+    CONFIG_FILE_LOCATIONS = [Dir.pwd, File.expand_path("~")].freeze
+    SUPPORTED_EXTENSIONS = %w[yml yaml].freeze
+
+    class << self
+      # @return [Pdfh::Settings]
+      def build
+        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|
+          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

data/lib/pdfh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pdfh
-  VERSION = "0.2.1"
+  VERSION = "3.0.1"
 end

data/lib/pdfh.rb

@@ -1,18 +1,31 @@
 # frozen_string_literal: true
 
-require "ext/string"
+require "base64"
 require "colorize"
-
-require "pdfh/version"
-require "pdfh/document_period"
-require "pdfh/document_type"
-require "pdfh/document"
-require "pdfh/month"
-require "pdfh/opt_parser"
-require "pdfh/pdf_handler"
-require "pdfh/settings"
-require "pdfh/settings_template"
-require "pdfh/document_processor"
+require "fileutils"
+require "forwardable"
+require "tempfile"
+require "yaml"
+
+require_relative "ext/string"
+
+# Models
+require_relative "pdfh/models/document"
+require_relative "pdfh/models/document_period"
+require_relative "pdfh/models/document_type"
+require_relative "pdfh/models/settings"
+
+# Utils
+require_relative "pdfh/utils/console"
+require_relative "pdfh/utils/month"
+require_relative "pdfh/utils/opt_parser"
+require_relative "pdfh/utils/options"
+require_relative "pdfh/utils/pdf_file_handler"
+require_relative "pdfh/utils/settings_builder"
+
+require_relative "pdfh/main"
+require_relative "pdfh/settings_template"
+require_relative "pdfh/version"
 
 # Gem entry point
 module Pdfh
@@ -21,117 +34,15 @@ module Pdfh
 
   # Regular Date Error, when there is not match
   class ReDateError < StandardError
+    # @return [self]
     def initialize(msg = "Date regular expression did not find a match in document.")
       super
     end
   end
 
   class << self
-    attr_writer :verbose, :dry, :mode
-
-    # @return [Boolean]
-    def verbose?
-      @verbose
-    end
-
-    # @return [Boolean]
-    def dry?
-      @dry
-    end
-
-    # @return [Boolean]
-    def file_mode?
-      @mode == :file
-    end
-
-    # Returns rows, cols
-    # TODO: review https://gist.github.com/nixpulvis/6025433
-    # @return [Array<Integer, Integer>]
-    def console_size
-      `stty size`.split.map(&:to_i)
-    end
-
-    # Prints visual separator in shell for easier reading for humans
-    # @example output
-    #   [Title Text] -----------------------
-    # @param msg [String]
-    # @return [void]
-    def headline(msg)
-      _, cols = console_size
-      line_length = cols - (msg.size + 5)
-      left  = "\033[31m#{"—" * 3}\033[0m"
-      right = "\033[31m#{"—" * line_length}\033[0m"
-      puts "\n#{left} \033[1;34m#{msg}\033[0m #{right}"
-    end
-
-    # @param msg [Object]
-    # @return [void]
-    def verbose_print(msg = nil)
-      puts msg.to_s.colorize(:cyan) if verbose?
-    end
-
-    # @param message [String]
-    # @param exit_app [Boolean] exit application if true (default)
-    # @return [void]
-    def error_print(message, exit_app: true)
-      puts "Error, #{message}".colorize(:red)
-      exit 1 if exit_app
-    end
-
-    # @param message [String]
-    # @return [void]
-    def warn_print(message)
-      puts message.colorize(:yellow)
-    end
-
-    # @return [void]
-    def ident_print(field, value, color: :green, width: 3)
-      field_str = field.to_s.rjust(width)
-      value_str = value.colorize(color)
-      puts "#{" " * 4}#{field_str}: #{value_str}"
-    end
-
-    # @return [Hash]
-    def parse_argv
-      options = {}
-      OPT_PARSER.parse!(into: options)
-      options[:files] = ARGV if ARGV.any?
-      options.transform_keys { |key| key.to_s.tr("-", "_").to_sym }
-    rescue OptionParser::InvalidOption => e
-      error_print e.message, exit_app: false
-      puts OPT_PARSER.help
-      exit 1
-    end
-
-    # @return [String]
-    def config_file_name
-      File.basename($PROGRAM_NAME)
-    end
-
-    # @return [void]
-    def create_settings_file
-      full_path = File.join(File.expand_path("~"), "#{config_file_name}.yml")
-      return if File.exist?(full_path) # double check
-
-      File.write(full_path, Pdfh::SETTINGS_TEMPLATE.to_yaml)
-      puts "Settings #{full_path.inspect.colorize(:green)} was created."
-    end
-
-    # @raise [SettingsIOError] if no file is found
-    # @return [String]
-    def search_config_file
-      names_to_look = %W[#{config_file_name}.yml #{config_file_name}.yaml]
-      dir_order = [Dir.pwd, File.expand_path("~")]
-
-      dir_order.each do |dir|
-        names_to_look.each do |file|
-          path = File.join(dir, file)
-          return path if File.exist?(path)
-        end
-      end
-
-      raise SettingsIOError, "no configuration file (#{names_to_look.join(" or ")}) was found\n"\
-                             "       within paths: #{dir_order.join(", ")}"
-    end
+    extend Forwardable
+    def_delegators :@options, :verbose?, :dry?, :file_mode?
+    def_delegators :@console, :ident_print, :warn_print, :error_print, :headline, :debug, :info, :print_options
   end
 end

data/pdfh.gemspec

@@ -10,11 +10,11 @@ Gem::Specification.new do |spec|
   spec.email         = ["iax7@users.noreply.github.com"]
 
   spec.summary       = "Organize PDF files"
-  spec.description   = "Examine all PDF files in Look up directories, remove password (if has one), "\
+  spec.description   = "Examine all PDF files in Look up directories, remove password (if has one), " \
                        "rename and copy to a new directory using regular expressions."
   spec.homepage      = "https://github.com/iax7/pdfh"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"