pdfh 0.1.9 → 0.2.0

data/lib/ext/string.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-##
-# Extends String class when required
-module Extensions
-  ##
-  # Adds new functionality to string Class
-  refine String do
-    def titleize
-      split.map(&:capitalize).join(" ")
-    end
+# Adds :titleize to string Class
+class String
+  # @return [String]
+  def titleize
+    split.map(&:capitalize).join(" ")
   end
 end

data/lib/pdfh.rb

@@ -1,97 +1,134 @@
 # frozen_string_literal: true
 
+require "ext/string"
+require "colorize"
+
 require "pdfh/version"
-require "pdfh/settings"
+require "pdfh/document_period"
+require "pdfh/document_type"
 require "pdfh/document"
-require "pdfh/utils"
+require "pdfh/month"
+require "pdfh/opt_parser"
+require "pdfh/pdf_handler"
+require "pdfh/settings"
+require "pdfh/settings_template"
+require "pdfh/document_processor"
 
-##
 # Gem entry point
 module Pdfh
-  def self.main(options = {})
-    Verbose.active = options[:verbose]
-    Dry.active = options[:dry]
-
-    @settings = Settings.new(search_config_file)
-    puts "Destination path: #{@settings.base_path.light_blue}"
-    @settings.scrape_dirs.each do |work_directory|
-      process_directory(work_directory)
+  # Settings not found
+  class SettingsIOError < StandardError; end
+
+  # Regular Date Error, when there is not match
+  class ReDateError < StandardError
+    def initialize(msg = "No data matched your date regular expression")
+      super
     end
-  rescue StandardError => e
-    print_error e
   end
 
-  def self.search_config_file
-    name = File.basename($PROGRAM_NAME)
-    names_to_look = ["#{name}.yml", "#{name}.yaml"]
-    dir_order = [Dir.pwd, File.expand_path("~")]
+  class << self
+    attr_writer :verbose, :dry
 
-    dir_order.each do |dir|
-      names_to_look.each do |file|
-        f = File.join(dir, file)
-        return f if File.file?(f)
-      end
+    # @return [Boolean]
+    def verbose?
+      @verbose
     end
 
-    raise StandardError, "no configuraton file (#{names_to_look.join(" or ")}) was found\n"\
-                         "       within paths: #{dir_order.join(", ")}"
-  end
+    # @return [Boolean]
+    def dry?
+      @dry
+    end
 
-  ##
-  # @param [String] work_directory
-  def self.process_directory(work_directory)
-    print_separator work_directory
-    ignored_files = []
-    Dir["#{work_directory}/*.pdf"].each do |pdf_file|
-      type = @settings.match_doc_type(pdf_file)
-      if type
-        process_document(pdf_file, type)
-      else
-        ignored_files << basename_without_ext(pdf_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
 
-    puts "\nNo account was matched for these PDF files:" unless ignored_files.empty?
-    ignored_files.each.with_index(1) { |file, index| print_ident index, file, :magenta }
-  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
 
-  ##
-  # Generate document, and process actions
-  # @param [String] file
-  # @param [Type] type
-  # rubocop:disable Metrics/AbcSize
-  def self.process_document(file, type)
-    puts "Working on #{basename_without_ext(file).colorize(:light_green)}"
-    pad = 12
-    print_ident "Type", type.name, :light_blue, width: pad
-    doc = Document.new(file, type)
-    print_ident "Sub-Type", doc.sub_type, :light_blue, width: pad
-    print_ident "Period", doc.period, :light_blue, width: pad
-    print_ident "New Name", doc.new_name, :light_blue, width: pad
-    print_ident "Store Path", doc.store_path, :light_blue, width: pad
-    print_ident "Other files", doc.companion_files(join: true), :light_blue, width: pad
-    print_ident "Print CMD", doc.print_cmd, :light_blue, width: pad
-    doc.write_pdf(@settings.base_path)
-  rescue StandardError => e
-    puts "       Doc Error: #{e.message}".colorize(:red)
-  end
-  # rubocop:enable Metrics/AbcSize
-
-  def self.print_separator(title)
-    _rows, cols = `stty size`.split.map(&:to_i)
-    sep = "\n#{"-" * 40} #{title} "
-    remaining_cols = cols - sep.size
-    sep += "-" * remaining_cols if remaining_cols.positive?
-    puts sep.colorize(:light_yellow)
-  end
+    # @param msg [Object]
+    # @return [void]
+    def verbose_print(msg = nil)
+      puts msg.to_s.colorize(:cyan) if verbose?
+    end
 
-  def self.print_ident(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
+    # @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
 
-  def self.basename_without_ext(file)
-    File.basename(file, File.extname(file))
+    # @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.open(full_path, "w") do |f|
+        f.write Pdfh::SETTINGS_TEMPLATE.to_yaml
+      end
+      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
   end
 end

data/lib/pdfh/document.rb

@@ -1,107 +1,64 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "pdfh/month"
-require "pdfh/pdf_handler"
-require "ext/string"
-
-##
-# main module
 module Pdfh
-  using Extensions
-
-  ##
-  # Regular Date Error, when there is not match
-  class ReDateError < StandardError
-    def initialize(message = "No data matched your date regular expression")
-      super(message)
-    end
-  end
-
-  ##
   # Handles the PDF detected by the rules
   class Document
-    attr_reader :text, :type, :file, :extra
+    attr_reader :text, :type, :file, :extra, :pdf_doc
 
-    def initialize(file, type, _options = {})
+    # @param file [String]
+    # @param type [DocumentType]
+    # @return [self]
+    def initialize(file, type)
       raise IOError, "File #{file} not found" unless File.exist?(file)
 
       @file = file
       @type = type
-      @month_offset = 0
-      @year_offset = 0
-
-      @pdf_doc = PdfHandler.new(file, @type.pwd)
-
-      Verbose.print "=== Type: #{type_name} =================="
+      Pdfh.verbose_print "=== Type: #{type.name} =============================="
+      @pdf_doc = PdfHandler.new(file, type.pwd)
       @text = @pdf_doc.extract_text
-      @sub_type = extract_subtype(@type.sub_types)
-      Verbose.print "  SubType: #{@sub_type}"
-      @month, @year, @extra = match_data
-      Verbose.print "==== Assigned: #{@month}, #{@year}, #{@extra} ==( Month, Year, Extra )================"
-      find_companion_files
-    end
-
-    def write_pdf(base_path)
-      full_path = File.join(base_path, store_path, new_name)
-      dir_path = File.join(base_path, store_path)
-
-      FileUtils.mkdir_p(dir_path) unless File.exist?(dir_path)
-
-      @pdf_doc.write_pdf(dir_path, full_path)
-
-      return if Dry.active?
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Finding a subtype"
+      @sub_type = type.sub_type(@text)
+      Pdfh.verbose_print "  SubType: #{@sub_type}"
+      @companion = search_companion_files
 
-      make_document_backup
-      copy_companion_files(dir_path)
-    end
-
-    def period
-      formated_month = month.to_s.rjust(2, "0")
-      "#{year}-#{formated_month}"
-    end
-
-    def month
-      month = Month.normalize(@month) + @month_offset
-
-      case month
-      when 0
-        @year_offset = -1
-        12
-      when 13
-        @year_offset = 1
-        1
-      else month
-      end
-    end
-
-    def year
-      tmp = @year.size == 2 ? "20#{@year}" : @year
-      tmp.to_i + @year_offset
+      month, year, @extra = match_data
+      @period = DocumentPeriod.new(day: extra, month: month, month_offset: @sub_type&.month_offset, year: year)
+      Pdfh.verbose_print "  Period: #{@period.inspect}"
     end
 
+    # @return [String]
     def file_name_only
       File.basename(@file, File.extname(@file))
     end
 
+    # @return [String]
     def file_name
       File.basename(@file)
     end
 
+    # @return [String]
     def backup_name
       "#{file_name}.bkp"
     end
 
+    # @return [String]
     def type_name
-      @type ? @type.name.titleize : "N/A"
+      @type&.name&.titleize || "N/A"
     end
 
+    # @return [String]
     def sub_type
-      @sub_type ? @sub_type.name.titleize : "N/A"
+      @sub_type&.name&.titleize || "N/A"
+    end
+
+    # @return [String]
+    def period
+      @period.to_s
     end
 
+    # @return [String]
     def new_name
-      template = @type.to_h.key?(:name_template) ? @type.name_template : "{original}"
+      template = @type.name_template
       new_name = template
                  .sub("{original}", file_name_only)
                  .sub("{period}", period)
@@ -111,10 +68,12 @@ module Pdfh
       "#{new_name}.pdf"
     end
 
+    # @return [String]
     def store_path
-      @type.store_path.gsub(/\{YEAR\}/, year.to_s)
+      @type.store_path.gsub("{YEAR}", @period.year.to_s)
     end
 
+    # @return [String]
     def print_cmd
       return "N/A" if type.print_cmd.nil? || type.print_cmd.empty?
 
@@ -122,62 +81,35 @@ module Pdfh
       "#{type.print_cmd} #{relative_path}"
     end
 
-    def to_s
-      <<~STR
-        Name:      #{file_name_only}
-        Type:      #{type_name}
-        Sub Type:  #{sub_type}
-        Period:    #{period}
-        File Path: #{file}
-        File Name: #{file_name}
-        New Name:  #{new_name}
-        StorePath: #{store_path}
-        Companion: #{companion_files(join: true)}
-        Print Cmd: #{print_cmd}
-      STR
-    end
-
     def companion_files(join: false)
-      @companion unless join
+      return @companion unless join
 
       @companion.empty? ? "N/A" : @companion.join(", ")
     end
 
-    private
-
-    ##
-    # @param sub_types [Array]
-    # @return [OpenStruct]
-    def extract_subtype(sub_types)
-      return nil if sub_types.nil? || sub_types.empty?
-
-      sub_types.each do |st|
-        is_matched = Regexp.new(st["name"]).match?(@text)
-        next unless is_matched
-
-        sub = OpenStruct.new(st)
-        @month_offset = sub.month_offset || 0
-        return sub
-      end
-      nil
-    end
-
+    # @return [String]
     def home_dir
       File.dirname(@file)
     end
 
-    ##
+    # @return [String]
+    def to_s
+      @file
+    end
+
+    private
+
     # named matches can appear in any order with names 'd', 'm' and 'y'
-    # unamed matches needs to be in order month, year
+    # unnamed matches needs to be in order month, year
     # @return [Array] - format [month, year, day]
     def match_data
-      Verbose.print "~~~~~~~~~~~~~~~~~~ RegEx"
-      Verbose.print "  Using regex: #{@type.re_date}"
-      Verbose.print "        named:   #{@type.re_date.named_captures}"
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ RegEx"
+      Pdfh.verbose_print "  Using regex: #{@type.re_date}"
+      Pdfh.verbose_print "        named:   #{@type.re_date.named_captures}"
       matched = @type.re_date.match(@text)
       raise ReDateError unless matched
 
-      Verbose.print "     captured: #{matched.captures}"
+      Pdfh.verbose_print "     captured: #{matched.captures}"
 
       return matched.captures.map(&:downcase) if @type.re_date.named_captures.empty?
 
@@ -185,36 +117,16 @@ module Pdfh
       [matched[:m].downcase, matched[:y], extra]
     end
 
-    ##
-    # Create a backup of original document
-    def make_document_backup
+    # @return [Array]
+    def search_companion_files
+      Pdfh.verbose_print "~~~~~~~~~~~~~~~~~~ Searching Companion files"
+      Pdfh.verbose_print "  Searching on: #{home_dir.inspect}"
       Dir.chdir(home_dir) do
-        File.rename(file, backup_name)
-      end
-    end
-
-    def find_companion_files
-      Verbose.print "~~~~~~~~~~~~~~~~~~ Searching Companion files"
-      Verbose.print "   Working on dir: #{home_dir}"
-      Dir.chdir(home_dir) do
-        all_files = Dir["#{file_name_only}.*"]
-        companion = all_files.reject { |file| file.include? "pdf" }
-        Verbose.print "     - #{companion.join(", ")}"
-
-        @companion = companion || []
-      end
-    end
+        files_matching = Dir["#{file_name_only}.*"]
+        companion = files_matching.reject { |file| file.include? ".pdf" }
+        Pdfh.verbose_print "    Found: #{companion.inspect}"
 
-    def copy_companion_files(destination)
-      Verbose.print "~~~~~~~~~~~~~~~~~~ Writing Companion files"
-      @companion.each do |file|
-        Verbose.print "  Working on #{file}..."
-        src_name = File.join(home_dir, file)
-        src_ext = File.extname(file)
-        dest_name = File.basename(new_name, ".pdf")
-        dest_full = File.join(destination, "#{dest_name}#{src_ext}")
-        Verbose.print "    cp #{src_name} --> #{dest_full}"
-        FileUtils.cp(src_name, dest_full)
+        companion
       end
     end
   end