opensecret 0.0.913 → 0.0.941

data/lib/opensecret/plugins.io/logs/log.object.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/ruby
-
-# --
-# -- Log common objects such as
-# --
-# --  - files
-# --  - maps
-# --
-# --
-class LogObject
-
-  # --
-  # -- Log the file whose full path is given in the 1st parameter.
-  # -- The string context is included in the logs which should explain
-  # -- the whys and wherefores of the file.
-  # --
-  # -- An exception is thrown if the file is not found.
-  # --
-  def self.file file_path, file_context
-
-    Throw.if_not_exists file_path
-
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-    log.debug(ere) { "# -- The File Path to Log => #{file_path}" }
-
-    hr_file_size = PrettyPrint.byte_size( File.size(file_path) )
-    dotless_extension = File.extname( file_path )[1..-1]
-    parent_dir_name = File.basename( File.dirname( file_path ) )
-    file_name = File.basename file_path
-    is_zip = dotless_extension.eql? "zip"
-
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-    log.debug(ere) { "# -- File Name => #{file_name}" }
-    log.debug(ere) { "# -- File Size => #{hr_file_size}" }
-    log.debug(ere) { "# -- File Type => #{file_context}" }
-    log.debug(ere) { "# -- In Folder => #{parent_dir_name}" }
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-
-    log.debug(ere) { "File #{file_name} is a zip (binary) file." } if is_zip
-    return if is_zip
-
-    File.open( file_path, "r") do | file_obj |
-      line_no = 1
-      file_obj.each_line do | file_line |
-        line_num = sprintf '%03d', line_no
-        clean_line = file_line.chomp.strip
-        log.debug(ere) { "# -- [#{line_num}] - #{clean_line}" }
-        line_no += 1
-      end
-    end
-
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-    log.debug(ere) { "# -- [#{file_context}] End of File [ #{File.basename(file_path)} ]" }
-    log.debug(ere) { "# -- ------------------------------------------------------------------------ #" }
-
-  end
-
-
-  # --
-  # -- Log map with a key-value pair on each line.
-  # --
-  # -- Parameter
-  # --   the_map : the map to log
-  # --
-  # -- Dependencies and Assumptions
-  # --   the map has been instantiated (not nil)
-  # --
-  def self.map the_map
-
-    return if the_map.nil?
-
-    log.debug(ere) { "# --- ----------------------------------------------" }
-    log.debug(ere) { "# --- Map has [#{the_map.length}] key/value pairs." }
-    log.debug(ere) { "# --- ----------------------------------------------" }
-
-    the_map.each do |the_key, the_value|
-
-      padded_key = sprintf '%-33s', the_key
-      log.debug(ere) { "# --- #{padded_key} => #{the_value}" }
-
-    end
-
-    log.debug(ere) { "# --- ----------------------------------------------" }
-
-  end
-
-
-end

data/lib/opensecret/plugins.io/logs/logging.rb

@@ -1,203 +0,0 @@
-# --
-# -- [MIXIN] magic is deployed to hand out DevOps quality logging
-# -- features to any class that includes the logging module.
-# --
-# -- When logging facilities are not ready we need to log just to
-# -- stdout but when they are we need to use them.
-# --
-# -- mixin power enables one class to give the logfile path and all
-# -- classes will suddenly retrieve a another logger and use that.
-# --
-# --   include Logging
-# --   def doImportant
-# --     log.warn(ere) "unhappy about doing this"
-# --     do_anyway
-# --     log.debug(ere) "all good it was okay"
-# --   end
-# --
-# -- -----------------------
-# -- What are Mixins?
-# -- -----------------------
-# --
-# -- Refer to the below link for excellent coverage of mixins.
-# -- http://ruby-doc.com/docs/ProgrammingRuby/html/tut_modules.html
-# --
-module Logging
-
-  @@log_path = nil
-  @@log_class = nil
-
-  # --
-  # -- Classes that include (MIXIN) this logging module will
-  # -- have access to this logger method.
-  # --
-  # -- [memoization] is implemented here for performance and
-  # -- will only initiate a logger under 2 circumstances
-  # --
-  # --   [1] - the first call (returns a STDOUT logger)
-  # --   [2] - the call after the logfile path is set
-  # --          (returns a more sophisticated logger)
-  # --
-  def log
-
-    @@log_class ||= get_logger
-
-  end
-
-
-  # --
-  # -- log.info(ere) {i woz ere}
-  # --
-  # -- [ere] is borrowed from the common graffiti phrase (i woz ere)
-  # --
-  # -- In software terms it allows the logger to print 3 crucial
-  # -- pieces of information for the troubleshooter (detective) to
-  # -- determine who called the logger (who was here). The
-  # --
-  # --  [1] - [module name] of the caller
-  # --  [2] - [method name] the call came from
-  # --  [3] - [line number] of the call
-  # --
-  # --
-  def ere
-
-    module_name = File.basename caller_locations(1,1).first.absolute_path, ".rb"
-    method_name = caller_locations(1,1).first.base_label
-    line_number = caller_locations(1,1).first.lineno
-
-    "#{module_name} | #{method_name} | (line #{line_number}) "
-
-  end
-
-  # --
-  # -- If logger is used at the [BEGINNING] when
-  # -- the runtime logfile path has not yet been
-  # -- ascertained then STDOUT is used.
-  # --
-  # -- However if we have been informed (via the
-  # -- set_logfile_path) that the logfile path is
-  # -- now known the logger returned will be set
-  # -- to log to the specified file.
-  # --
-  # -- [memoization] should be used so that this
-  # -- method gets called only [TWICE].
-  # --
-  # --   [1] - at the [beginning] when the logfile path is not known
-  # --   [2] - just [after] the logfile dir is evaluated and created
-  # --
-  def get_logger
-
-    expensive_initializr = "EXPENSIVE(x2) => This log message should only appear [TWICE]."
-    Logger.new(STDOUT).warn "#{expensive_initializr}"
-
-    return get_stdout_logger if @@log_path.nil?
-
-    file_logger = Logger.new( Logging.initializr_str )
-    original_formatter = Logger::Formatter.new
-
-    file_logger.formatter = proc { |severity, datetime, progname, msg|
-########      original_formatter.call(severity, datetime, progname, msg.dump.chomp.strip.delete("\"\\"))
-      original_formatter.call( severity, datetime, progname, msg.dump.chomp.strip )
-    }
-
-    if CmdLine.has? "--debug" then
-      file_logger.level = Logger::DEBUG
-    else
-      file_logger.level = Logger::INFO
-    end
-
-    return file_logger
-
-  end
-
-
-  # --
-  # -- Get the logger class initiaze string.
-  # -- The OS platform "Windows" vs "Linux" dictates
-  # -- what is returned as the "tee" command used to
-  # -- redirect logging output bot the console and a
-  # -- standard log file is not available on Windows.
-  # --
-  # -- Return the initializer for the logging statement.
-  # --
-  # -- ------------
-  # -- Windows
-  # -- ------------
-  # --
-  # -- Continue logging solely to STANDARD OUT.
-  # -- We could log to a file but not to both.
-  # --
-  # -- ------------
-  # -- Linux
-  # -- ------------
-  # --
-  # -- Send back TEE command so that logs pipe to
-  # -- both standard out and the designated logfile.
-  # --
-  def self.initializr_str
-
-    return STDOUT if Gem.win_platform?
-    return "| tee #{@@log_path}"
-
-  end
-
-
-  # --
-  # -- Get a simple STDOUT logger using the
-  # -- designated log level.
-  # --
-  # -- As the early stage when we do not have a
-  # -- log file destination the logs are set to
-  # -- the DEBUG (max) level.
-  # --
-  # -- If you need just INFO level logs right
-  # -- from the get go - go amend this method.
-  # --
-  def get_stdout_logger
-
-    stdout_logger = Logger.new(STDOUT)
-    stdout_logger.level = Logger::DEBUG
-    return stdout_logger
-
-  end
-
-
-  #--
-  #-- Set logfile path and [INVALIDATE] the
-  #-- cache so that memoization reads the new
-  #-- @log_class object.
-  #--
-  def set_logfile_path path_to_set
-
-    @@log_path = path_to_set
-    @@log_class = nil
-
-  end
-
-
-  #--
-  #-- Return the filename and its two immediate
-  #-- parent folders (parent and grandparent).
-  #--
-  #-- When this is not possible when the filepath
-  #-- is near the filesystem's root - it returns
-  #-- whatever is possible.
-  #--
-  #-- IMPLEMENT ABOVE FUNCTIONALITY WHEN NEEDED.
-  #-- CURRENTLY IT JUST BLUNDERS IN WITH NEITHER
-  #-- RHYME NOR REASON.
-  #--
-  def nickname object_path
-
-    object_name   = File.basename object_path
-    parent_folder = File.dirname  object_path
-    parent_name   = File.basename parent_folder
-    granny_folder = File.dirname  parent_folder
-    granny_name   = File.basename granny_folder
-
-    return [granny_name,parent_name,object_name].join("/")
-
-  end
-
-
-end