raykit 0.0.304 → 0.0.305

data/lib/raykit/git/repository.rb

@@ -1,109 +1,106 @@
+# frozen_string_literal: true
+
 module Raykit
-    module Git
-        # Functionality to manage a remote git repository
-        class Repository
-            # The url of the remote repository
-            attr_accessor :url
-            attr_accessor :clone_directory
-            attr_accessor :work_directory
+  module Git
+    # Functionality to manage a remote git repository
+    class Repository
+      # The url of the remote repository
+      attr_accessor :url
+      attr_accessor :clone_directory, :work_directory
 
-            def initialize(url)
-                @url=url
-                @clone_directory = Raykit::Git::Directory.new(get_dev_dir('clone'))
-                @work_directory = Raykit::Git::Directory.new(get_dev_dir('work'))
-            end
+      def initialize(url)
+        @url = url
+        @clone_directory = Raykit::Git::Directory.new(get_dev_dir("clone"))
+        @work_directory = Raykit::Git::Directory.new(get_dev_dir("work"))
+      end
 
-            def to_json
-                JSON.generate({"url" => @url})
-            end
+      def to_json(*_args)
+        JSON.generate({ "url" => @url })
+      end
 
-            def self.parse(json)
-                hash=JSON.parse(json)
-                repo=Repository.new(hash["url"])
-                repo
-            end
+      def self.parse(json)
+        hash = JSON.parse(json)
+        Repository.new(hash["url"])
+      end
 
-            # The relative path is a valid local path name derived from the url
-            def relative_path
-                @url.gsub('https://','').gsub('.git','').gsub('http://','')
-            end
+      # The relative path is a valid local path name derived from the url
+      def relative_path
+        @url.gsub("https://", "").gsub(".git", "").gsub("http://", "")
+      end
 
-            def get_dev_dir(dir)
-                dev_dir=Environment::get_dev_dir(dir)
-                return "#{dev_dir}/#{relative_path}"
-            end
+      def get_dev_dir(dir)
+        dev_dir = Environment.get_dev_dir(dir)
+        "#{dev_dir}/#{relative_path}"
+      end
 
-            # Clone the repository to a specific directory
-            def clone(directory,depth=0)
-                if(depth == 0)
-                    PROJECT.run("git clone #{@url} #{directory}") 
-                else
-                    PROJECT.run("git clone #{@url} #{directory} --depth #{depth}")
-                end
-            end
+      # Clone the repository to a specific directory
+      def clone(directory, depth = 0)
+        if depth.zero?
+          PROJECT.run("git clone #{@url} #{directory}")
+        else
+          PROJECT.run("git clone #{@url} #{directory} --depth #{depth}")
+        end
+      end
 
-            # The branches for the git repository
-            def branches
-                results = Array.new
-                update_local_clone_directory
-                if(Dir.exist?(local_clone_directory))
-                    Dir.chdir(local_clone_directory) do
-                        `git branch`.split('\n').each{|line|
-                            branch = line.gsub('*','').strip
-                            results.insert(-1,branch) if(branch.length > 0)
-                        }
-                    end
-                end
-                results
+      # The branches for the git repository
+      def branches
+        results = []
+        update_local_clone_directory
+        if Dir.exist?(local_clone_directory)
+          Dir.chdir(local_clone_directory) do
+            `git branch`.split('\n').each do |line|
+              branch = line.gsub("*", "").strip
+              results.insert(-1, branch) if branch.length.positive?
             end
+          end
+        end
+        results
+      end
 
-            # The latest commit id for a branch of the repostiory
-            def latest_commit(branch)
-                if(checkout_local_clone_directory_branch(branch))
-                    text=`git log -n 1`
-                    scan=text.scan(/commit ([\w]+)\s/)
-                    return scan[0][0].to_s 
-                end
-                ''
-            end
+      # The latest commit id for a branch of the repostiory
+      def latest_commit(branch)
+        if checkout_local_clone_directory_branch(branch)
+          text = `git log -n 1`
+          scan = text.scan(/commit (\w+)\s/)
+          return scan[0][0].to_s
+        end
+        ""
+      end
 
-            # The latest tag for a branch of the repository
-            def latest_tag(branch)
-                if(checkout_local_clone_directory_branch(branch))
-                    return `git describe --abbrev=0`.strip
-                end
-                ''
-            end
+      # The latest tag for a branch of the repository
+      def latest_tag(branch)
+        return `git describe --abbrev=0`.strip if checkout_local_clone_directory_branch(branch)
 
-            private def local_clone_directory
-                clone_dir="#{Environment::get_dev_dir('clone')}/#{relative_path}"
-            end
+        ""
+      end
 
-            private def update_local_clone_directory
-                if(Dir.exist?(local_clone_directory))
-                    Dir.chdir(local_clone_directory) do
-                        Raykit::Command.new('git pull')
-                        #t = `git pull`
-                    end
-                else
-                    PROJECT.run("git clone #{@url} #{local_clone_directory}")
-                end
-            end
+      private def local_clone_directory
+        clone_dir = "#{Environment.get_dev_dir("clone")}/#{relative_path}"
+      end
 
-            private def checkout_local_clone_directory_branch(branch)
-                update_local_clone_directory
-                if(Dir.exist?(local_clone_directory))
-                    Dir.chdir(local_clone_directory) do
-                        check=`git branch`
-                        if(!check.include?("* #{branch}"))
-                            t = `git checkout #{branch}`
-                        end
-                        check=`git branch`
-                        return check.include?("* #{branch}")
-                    end
-                end
-                false
-            end
+      private def update_local_clone_directory
+        if Dir.exist?(local_clone_directory)
+          Dir.chdir(local_clone_directory) do
+            Raykit::Command.new("git pull")
+            # t = `git pull`
+          end
+        else
+          PROJECT.run("git clone #{@url} #{local_clone_directory}")
+        end
+      end
+
+      private def checkout_local_clone_directory_branch(branch)
+        update_local_clone_directory
+        if Dir.exist?(local_clone_directory)
+          Dir.chdir(local_clone_directory) do
+            check = `git branch`
+            t = `git checkout #{branch}` unless check.include?("* #{branch}")
+            check = `git branch`
+            return check.include?("* #{branch}")
+          end
         end
+        false
+      end
     end
-end
+  end
+end

data/lib/raykit/log.rb

@@ -1,43 +1,45 @@
-require 'json'
+# frozen_string_literal: true
+
+require "json"
+
 module Raykit
-    class Log < Hash
-        @filename
-        def initialize(filename)
-            @filename=filename
-            dir=File.dirname(@filename)
-            FileUtils.mkdir_p(dir) if(!Dir.exist?(dir))
-            if(File.exist?(@filename))
-                begin
-                    data=JSON.parse(File.read(filename))
-                    data.each{|k,v|
-                        self[k] = v
-                    }
-                rescue
-                end
-            end
-        end
+  class Log < Hash
+    @filename
 
-        def save
-            File.open(@filename, 'w') {|f| f.write(JSON.generate(self)) }
+    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 update_command_time(command,timestamp)
-            command_times = Hash.new()
-            command_times = self["command_times"] if(self.has_key?("command_times"))
-            command_times.delete(command) if(command_times.has_key?(command))
-            command_times[command] = timestamp.iso8601()
-            self["command_times"] = command_times
-            save
-        end
+    def save
+      File.open(@filename, "w") { |f| f.write(JSON.generate(self)) }
+    end
 
-        def get_command_time(command)
-            if(self.has_key?("command_times"))
-                command_times = self["command_times"]
-                if(command_times.has_key?(command))
-                    return DateTime.parse(command_times[command])
-                end
-            end
-            nil
-        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
-end
+  end
+end

data/lib/raykit/logevent.rb

@@ -1,36 +1,38 @@
-require 'json'
+# 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 if !properties.has_key?('MachineName')
-            properties["UserName"] = Raykit::Environment::user if !properties.has_key?('UserName')
-            properties["RakeDirectory"] = ::Rake.application.original_dir
-            self["Properties"] = properties
-        end
+  # :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
-            #puts '---to_seq---'
-            #puts self['Message']
-            if !ENV['SEQ_SERVER'].nil?
-                cmd_str="seqcli log -m \"#{self['Message'].gsub("\"","")}\" -l #{self['Level']} -s #{ENV['SEQ_SERVER']}"
-                self["Properties"].each{|k,v|
-                    cmd_str=cmd_str + " -p \"#{k}=#{v}\""
-                }
-                #puts '---executing---'
-                #puts cmd_str
-                puts `#{cmd_str}`
-            end
+    def to_seq
+      # puts '---to_seq---'
+      # puts self['Message']
+      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 '---executing---'
+        # puts cmd_str
+        puts `#{cmd_str}`
+      end
     end
+  end
 end
 
-
-#{
+# {
 #	"Timestamp": "2021-10-06T06:09:25.5275817-06:00",
 #	"Level": "Information",
 #	"MessageTemplate": "MachineName     {machine}",
@@ -44,4 +46,4 @@ end
 #		"UserName": "\"loupa\"",
 #		"OS": "Windows_NT"
 #	}
-#}
+# }

data/lib/raykit/logging.rb

@@ -1,59 +1,59 @@
-require 'json'
-require 'logger'
+# frozen_string_literal: true
+
+require "json"
+require "logger"
 
 module Raykit
-    class Logging
-        attr_accessor :enabled,:loggers
+  class Logging
+    attr_accessor :enabled, :loggers
 
-        # Logger::Severity DEBUG,ERROR,FATAL,INFO,UNKOWN,WARN
-        # defaults to WARN
-        attr_accessor :severity
+    # Logger::Severity DEBUG,ERROR,FATAL,INFO,UNKOWN,WARN
+    # defaults to WARN
+    attr_accessor :severity
 
-        def initialize()
-            @enabled = true
-            @loggers = Hash.new
-            @severity= Logger::Severity::WARN
-        end
+    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 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)
-            if(!loggers.has_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]
+    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
+    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
 
-LOG = Raykit::Logging.new
+LOG = Raykit::Logging.new

data/lib/raykit/msbuild.rb

@@ -1,14 +1,22 @@
+# frozen_string_literal: true
+
 module Raykit
-    class MsBuild
-        def self.msbuild_path
-            ['2019/Enterprise/MSBuild/Current/Bin',
-             '2019/Professional/MSBuild/Current/Bin',
-             '2019/Community/MSBuild/Current/Bin',
-            '2017/BuildTools/MSBuild/15.0/Bin'].each{|relative_path|
-                path = 'C:/Program Files (x86)/Microsoft Visual Studio/' + relative_path
-                return path if(Dir.exists?(path))
-            }
-            ''
+  class MsBuild
+    def self.msbuild_path
+      ["2022/Community/MSBuild/Current/Bin",
+       "2019/Enterprise/MSBuild/Current/Bin",
+       "2019/Professional/MSBuild/Current/Bin",
+       "2019/Community/MSBuild/Current/Bin",
+       "2017/BuildTools/MSBuild/15.0/Bin"].each do |relative_path|
+        ["C:/Program Files/Microsoft Visual Studio/",
+         "C:/Program Files (x86)/Microsoft Visual Studio/"].each do |prog_path|
+          path = "#{prog_path}#{relative_path}"
+          return path if Dir.exist?(path)
         end
+        #path = "C:/Program Files (x86)/Microsoft Visual Studio/#{relative_path}"
+        #return path if Dir.exist?(path)
+      end
+      ""
     end
-end
+  end
+end

data/lib/raykit/nugetpackage.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
 
 module Raykit
-    class NugetPackage
-        attr_accessor :name
-        attr_accessor :version
+  class NugetPackage
+    attr_accessor :name, :version
 
-        def initialize(name,version)
-            @name=name
-            @version=version
-        end
+    def initialize(name, version)
+      @name = name
+      @version = version
     end
-end
+  end
+end