raykit 0.0.518 → 0.0.520

data/lib/raykit/installer.rb

@@ -1,17 +1,17 @@
-# frozen_string_literal: true
-
-module Raykit
-  class Installer
-    def self.make_msi(wxs_file, source_dir, msi_filename)
-      name = "#{File.basename(wxs_file, ".wxs")}"
-      FileUtils.cp(wxs_file, "#{source_dir}/#{File.basename(wxs_file)}")
-      Dir.chdir(source_dir) do
-        run("candle #{File.basename(wxs_file)}")
-        run("light #{name}.wixobj")
-        FileUtils.cp("#{name}.msi", msi_filename)
-        raise "#{msi_filename} does not exist" if !File.exist?(msi_filename)
-        File.delete("#{name}.wixobj")
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Raykit
+  class Installer
+    def self.make_msi(wxs_file, source_dir, msi_filename)
+      name = "#{File.basename(wxs_file, ".wxs")}"
+      FileUtils.cp(wxs_file, "#{source_dir}/#{File.basename(wxs_file)}")
+      Dir.chdir(source_dir) do
+        run("candle #{File.basename(wxs_file)}")
+        run("light #{name}.wixobj")
+        FileUtils.cp("#{name}.msi", msi_filename)
+        raise "#{msi_filename} does not exist" if !File.exist?(msi_filename)
+        File.delete("#{name}.wixobj")
+      end
+    end
+  end
+end

data/lib/raykit/log.rb

@@ -1,80 +1,80 @@
-require "json"
-
-module Raykit
-  class Log < Hash
-    @filename
-
-    def initialize(filename)
-      @filename = filename
-      dir = File.dirname(@filename)
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-      if File.exist?(@filename)
-        begin
-          data = JSON.parse(File.read(filename))
-          data.each do |k, v|
-            self[k] = v
-          end
-        rescue StandardError
-        end
-      end
-    end
-
-    def save
-      File.open(@filename, "w") { |f| f.write(JSON.generate(self)) }
-    end
-
-    def update_command_time(command, timestamp)
-      command_times = {}
-      command_times = self["command_times"] if key?("command_times")
-      command_times.delete(command) if command_times.key?(command)
-      command_times[command] = timestamp.iso8601
-      self["command_times"] = command_times
-      save
-    end
-
-    def get_command_time(command)
-      if key?("command_times")
-        command_times = self["command_times"]
-        return DateTime.parse(command_times[command]) if command_times.key?(command)
-      end
-      nil
-    end
-
-    def self.start_task(task_name)
-      puts Rainbow(": #{task_name}").blue.bright
-      MARKDOWN.puts(": #{task_name}")
-    end
-
-    def self.show_value(name, value)
-      puts "  " + Rainbow(name).cyan + " " + Rainbow("#{value}").white.bold
-      MARKDOWN.puts("#{name} #{value}")
-    end
-
-    def self.name_value_pair(symbol, the_binding)
-      [symbol.to_s, eval(symbol.to_s, the_binding)]
-    end
-
-    def self.show_table(symbols)
-      max_name_width = 0
-      max_value_width = 0
-      symbols.each { |s|
-        nvp = name_value_pair(s, binding)
-        name = nvp[0]
-        value = nvp[1]
-        max_name_width = name.length if (name.length > max_name_width)
-        if (!value.nil?)
-          max_value_width = value.length if (value.length > max_value_width)
-        end
-      }
-      header = "  =".ljust(max_name_width + max_value_width + 5, "=")
-      puts header
-      symbols.each { |s|
-        nvp = name_value_pair(s, binding)
-        name = nvp[0].rjust(max_name_width, " ")
-        value = nvp[1]
-        puts "  " + Rainbow(name).cyan + " | " + Rainbow("#{value}").white.bold
-      }
-      puts header
-    end
-  end
-end
+require "json"
+
+module Raykit
+  class Log < Hash
+    @filename
+
+    def initialize(filename)
+      @filename = filename
+      dir = File.dirname(@filename)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      if File.exist?(@filename)
+        begin
+          data = JSON.parse(File.read(filename))
+          data.each do |k, v|
+            self[k] = v
+          end
+        rescue StandardError
+        end
+      end
+    end
+
+    def save
+      File.open(@filename, "w") { |f| f.write(JSON.generate(self)) }
+    end
+
+    def update_command_time(command, timestamp)
+      command_times = {}
+      command_times = self["command_times"] if key?("command_times")
+      command_times.delete(command) if command_times.key?(command)
+      command_times[command] = timestamp.iso8601
+      self["command_times"] = command_times
+      save
+    end
+
+    def get_command_time(command)
+      if key?("command_times")
+        command_times = self["command_times"]
+        return DateTime.parse(command_times[command]) if command_times.key?(command)
+      end
+      nil
+    end
+
+    def self.start_task(task_name)
+      puts Rainbow(": #{task_name}").blue.bright
+      MARKDOWN.puts(": #{task_name}")
+    end
+
+    def self.show_value(name, value)
+      puts "  " + Rainbow(name).cyan + " " + Rainbow("#{value}").white.bold
+      MARKDOWN.puts("#{name} #{value}")
+    end
+
+    def self.name_value_pair(symbol, the_binding)
+      [symbol.to_s, eval(symbol.to_s, the_binding)]
+    end
+
+    def self.show_table(symbols)
+      max_name_width = 0
+      max_value_width = 0
+      symbols.each { |s|
+        nvp = name_value_pair(s, binding)
+        name = nvp[0]
+        value = nvp[1]
+        max_name_width = name.length if (name.length > max_name_width)
+        if (!value.nil?)
+          max_value_width = value.length if (value.length > max_value_width)
+        end
+      }
+      header = "  =".ljust(max_name_width + max_value_width + 5, "=")
+      puts header
+      symbols.each { |s|
+        nvp = name_value_pair(s, binding)
+        name = nvp[0].rjust(max_name_width, " ")
+        value = nvp[1]
+        puts "  " + Rainbow(name).cyan + " | " + Rainbow("#{value}").white.bold
+      }
+      puts header
+    end
+  end
+end

data/lib/raykit/logevent.rb

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Raykit
-  # :verbose, :debug, :information, :error, :fatal
-  class LogEvent < Hash
-    def initialize(level, messageTemplate, properties)
-      self["Timestamp"] = DateTime.now.iso8601
-      self["Level"] = level
-      self["Message"] = messageTemplate
-      self["MessageTemplate"] = messageTemplate
-      properties["MachineName"] = Raykit::Environment.machine unless properties.key?("MachineName")
-      properties["UserName"] = Raykit::Environment.user unless properties.key?("UserName")
-      properties["RakeDirectory"] = ::Rake.application.original_dir
-      self["Properties"] = properties
-    end
-
-    def to_seq
-      unless ENV["SEQ_SERVER"].nil?
-        cmd_str = "seqcli log -m \"#{self["Message"].gsub('"', "")}\" -l #{self["Level"]} -s #{ENV["SEQ_SERVER"]}"
-        self["Properties"].each do |k, v|
-          cmd_str += " -p \"#{k}=#{v}\""
-        end
-        puts `#{cmd_str}`
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+
+module Raykit
+  # :verbose, :debug, :information, :error, :fatal
+  class LogEvent < Hash
+    def initialize(level, messageTemplate, properties)
+      self["Timestamp"] = DateTime.now.iso8601
+      self["Level"] = level
+      self["Message"] = messageTemplate
+      self["MessageTemplate"] = messageTemplate
+      properties["MachineName"] = Raykit::Environment.machine unless properties.key?("MachineName")
+      properties["UserName"] = Raykit::Environment.user unless properties.key?("UserName")
+      properties["RakeDirectory"] = ::Rake.application.original_dir
+      self["Properties"] = properties
+    end
+
+    def to_seq
+      unless ENV["SEQ_SERVER"].nil?
+        cmd_str = "seqcli log -m \"#{self["Message"].gsub('"', "")}\" -l #{self["Level"]} -s #{ENV["SEQ_SERVER"]}"
+        self["Properties"].each do |k, v|
+          cmd_str += " -p \"#{k}=#{v}\""
+        end
+        puts `#{cmd_str}`
+      end
+    end
+  end
+end

data/lib/raykit/logger.rb

@@ -1,100 +1,100 @@
-require "logger"
-require "rainbow"
-
-module Raykit
-  class Logger
-    def initialize(logger_array)
-      @logger_array = logger_array
-      #@loggerB = loggerB
-    end
-
-    def level=(level)
-      @logger_array.each do |logger|
-        logger.level = level
-      end
-    end
-
-    def debug(message)
-      @logger_array.each do |logger|
-        logger.debug(message)
-      end
-    end
-
-    def info(message)
-      @logger_array.each do |logger|
-        logger.info(message)
-      end
-    end
-
-    def warn(message)
-      @logger_array.each do |logger|
-        logger.warn(message)
-      end
-    end
-
-    def error(message)
-      @logger_array.each do |logger|
-        logger.error(message)
-      end
-    end
-
-    def fatal(message)
-      @logger_array.each do |logger|
-        logger.fatal(message)
-      end
-    end
-
-    def self.strip_ansi_codes(str) # Strips ANSI color codes
-      str.gsub(/\e\[[0-9;]*m/, "")
-    end
-
-    def self.default
-      Raykit::Logger.new([Raykit::Logger::console_logger]) #, Raykit::Logger::file_logger])
-    end
-
-    def self.console_logger
-      console_logger = ::Logger.new(STDOUT)
-      console_logger.formatter = proc do |_severity, _datetime, _progname, msg|
-        "#{Raykit::Symbols::get_severity_symbol(_severity)} #{msg}\n"
-      end
-      console_logger
-    end
-
-    def self.file_logger
-      log_dir = Environment::log_dir
-      FileUtils.mkdir_p(log_dir) if (!Dir.exist?(log_dir))
-      #FileUtils.mkdir("log") if (!Dir.exist?("log"))
-      file_logger = ::Logger.new(File.new(LOG_FILENAME, "w"))
-      file_logger.formatter = proc do |_severity, _datetime, _progname, msg|
-        "#{strip_ansi_codes(msg)}\n"
-      end
-      file_logger
-    end
-  end # class Logger
-end # module Raykit
-
-DEFAULT_LOGGER = Raykit::Logger::default
-
-def set_log_level(level)
-  DEFAULT_LOGGER.level = level
-end
-
-def log_debug(message)
-  DEFAULT_LOGGER.debug(message)
-end
-
-def log_info(message)
-  DEFAULT_LOGGER.info(message)
-end
-
-def log_warn(message)
-  DEFAULT_LOGGER.warn(message)
-end
-
-def log_error(message)
-  DEFAULT_LOGGER.error(message)
-end
-
-def log_fatal(message)
-  DEFAULT_LOGGER.fatal(message)
-end
+require "logger"
+require "rainbow"
+
+module Raykit
+  class Logger
+    def initialize(logger_array)
+      @logger_array = logger_array
+      #@loggerB = loggerB
+    end
+
+    def level=(level)
+      @logger_array.each do |logger|
+        logger.level = level
+      end
+    end
+
+    def debug(message)
+      @logger_array.each do |logger|
+        logger.debug(message)
+      end
+    end
+
+    def info(message)
+      @logger_array.each do |logger|
+        logger.info(message)
+      end
+    end
+
+    def warn(message)
+      @logger_array.each do |logger|
+        logger.warn(message)
+      end
+    end
+
+    def error(message)
+      @logger_array.each do |logger|
+        logger.error(message)
+      end
+    end
+
+    def fatal(message)
+      @logger_array.each do |logger|
+        logger.fatal(message)
+      end
+    end
+
+    def self.strip_ansi_codes(str) # Strips ANSI color codes
+      str.gsub(/\e\[[0-9;]*m/, "")
+    end
+
+    def self.default
+      Raykit::Logger.new([Raykit::Logger::console_logger]) #, Raykit::Logger::file_logger])
+    end
+
+    def self.console_logger
+      console_logger = ::Logger.new(STDOUT)
+      console_logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{Raykit::Symbols::get_severity_symbol(_severity)} #{msg}\n"
+      end
+      console_logger
+    end
+
+    def self.file_logger
+      log_dir = Environment::log_dir
+      FileUtils.mkdir_p(log_dir) if (!Dir.exist?(log_dir))
+      #FileUtils.mkdir("log") if (!Dir.exist?("log"))
+      file_logger = ::Logger.new(File.new(LOG_FILENAME, "w"))
+      file_logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{strip_ansi_codes(msg)}\n"
+      end
+      file_logger
+    end
+  end # class Logger
+end # module Raykit
+
+DEFAULT_LOGGER = Raykit::Logger::default
+
+def set_log_level(level)
+  DEFAULT_LOGGER.level = level
+end
+
+def log_debug(message)
+  DEFAULT_LOGGER.debug(message)
+end
+
+def log_info(message)
+  DEFAULT_LOGGER.info(message)
+end
+
+def log_warn(message)
+  DEFAULT_LOGGER.warn(message)
+end
+
+def log_error(message)
+  DEFAULT_LOGGER.error(message)
+end
+
+def log_fatal(message)
+  DEFAULT_LOGGER.fatal(message)
+end

data/lib/raykit/logging.rb

@@ -1,57 +1,57 @@
-# frozen_string_literal: true
-
-require "json"
-require "logger"
-
-module Raykit
-  class Logging
-    attr_accessor :enabled, :loggers
-
-    # Logger::Severity DEBUG,ERROR,FATAL,INFO,UNKOWN,WARN
-    # defaults to WARN
-    attr_accessor :severity
-
-    def initialize
-      @enabled = true
-      @loggers = {}
-      @severity = ::Logger::Severity::WARN
-    end
-
-    def set_severity_as_string(severity)
-      @severity = ::Logger::Severity::DEBUG if severity == "debug"
-      @severity = ::Logger::Severity::INFO if severity == "info"
-      @severity = ::Logger::Severity::WARN if severity == "warn"
-      @severity = ::Logger::Severity::ERROR if severity == "error"
-    end
-
-    def get_logger(context)
-      unless loggers.key?(context)
-        Dir.chdir(Environment.get_dev_dir("log")) do
-          # start the log over whenever the log exceeds 100 megabytes in size
-          loggers[context] = Logger.new("#{context}.log", 0, 100 * 1024 * 1024)
-        end
-      end
-      loggers[context]
-    end
-
-    def log(context, level, message)
-      if @enabled
-        logger = get_logger(context)
-        case level
-        when Logger::Severity::DEBUG
-          logger.debug(message)
-        when Logger::Severity::INFO
-          logger.info(message)
-        when Logger::Severity::WARN
-          logger.warn(message)
-        when Logger::Severity::ERROR
-          logger.error(message)
-        when Logger::Severity::FATAL
-          logger.fatal(message)
-        else
-          logger.unknown(message)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+require "logger"
+
+module Raykit
+  class Logging
+    attr_accessor :enabled, :loggers
+
+    # Logger::Severity DEBUG,ERROR,FATAL,INFO,UNKOWN,WARN
+    # defaults to WARN
+    attr_accessor :severity
+
+    def initialize
+      @enabled = true
+      @loggers = {}
+      @severity = ::Logger::Severity::WARN
+    end
+
+    def set_severity_as_string(severity)
+      @severity = ::Logger::Severity::DEBUG if severity == "debug"
+      @severity = ::Logger::Severity::INFO if severity == "info"
+      @severity = ::Logger::Severity::WARN if severity == "warn"
+      @severity = ::Logger::Severity::ERROR if severity == "error"
+    end
+
+    def get_logger(context)
+      unless loggers.key?(context)
+        Dir.chdir(Environment.get_dev_dir("log")) do
+          # start the log over whenever the log exceeds 100 megabytes in size
+          loggers[context] = Logger.new("#{context}.log", 0, 100 * 1024 * 1024)
+        end
+      end
+      loggers[context]
+    end
+
+    def log(context, level, message)
+      if @enabled
+        logger = get_logger(context)
+        case level
+        when Logger::Severity::DEBUG
+          logger.debug(message)
+        when Logger::Severity::INFO
+          logger.info(message)
+        when Logger::Severity::WARN
+          logger.warn(message)
+        when Logger::Severity::ERROR
+          logger.error(message)
+        when Logger::Severity::FATAL
+          logger.fatal(message)
+        else
+          logger.unknown(message)
+        end
+      end
+    end
+  end
+end

data/lib/raykit/markdown.rb

@@ -1,21 +1,21 @@
-module Raykit
-  class Markdown
-    attr_accessor :text
-
-    def initialize()
-      @text = ""
-    end
-
-    def puts(line)
-      @text = @text + "\n" + line
-    end
-
-    def to_s()
-      @text
-    end
-
-    def save_as(filename)
-      File.write("rake.md", @text)
-    end
-  end
-end
+module Raykit
+  class Markdown
+    attr_accessor :text
+
+    def initialize()
+      @text = ""
+    end
+
+    def puts(line)
+      @text = @text + "\n" + line
+    end
+
+    def to_s()
+      @text
+    end
+
+    def save_as(filename)
+      #File.write("rake.md", @text)
+    end
+  end
+end