raykit 0.0.309 → 0.0.310

data/lib/raykit/environment.rb

@@ -1,89 +1,89 @@
 # frozen_string_literal: true
 
-require "pathname"
+require 'pathname'
 
 module Raykit
   # Provides functionality related to the development environment
   class Environment
     # Normalize a directory or filename to use forward slashes
     def self.normalize_path(name)
-      name.gsub('\\', "/")
+      name.gsub('\\', '/')
     end
 
     # The root directory for the development environment.
     # May be set using the environment variable DEV_ROOT,
     # otherwise defaults to the user home directory
     def self.root_dir
-      if ENV["DEV_ROOT"].nil?
+      if ENV['DEV_ROOT'].nil?
         Environment.home_dir
       else
-        normalize_path(ENV["DEV_ROOT"])
+        normalize_path(ENV['DEV_ROOT'])
       end
     end
 
     # The user home directory
     def self.home_dir
-      return normalize_path(ENV["USERPROFILE"]) if ENV.include?("USERPROFILE")
+      return normalize_path(ENV['USERPROFILE']) if ENV.include?('USERPROFILE')
 
-      normalize_path(ENV["HOME"])
+      normalize_path(ENV['HOME'])
     end
 
     def self.log_dir
-      get_dev_dir("log")
+      get_dev_dir('log')
     end
 
     # Get, and create if it does not exist, a specific development directory
     def self.get_dev_dir(name)
       dir = Pathname.new("#{Environment.root_dir}/#{name}")
       dir.mkpath
-      dir.to_s.gsub("//", "/")
+      dir.to_s.gsub('//', '/')
     end
 
     def self.get_work_dir(url)
-      "#{Raykit::Environment.get_dev_dir("work")}/#{url.gsub("://", "/").gsub(".git", "")}"
+      "#{Raykit::Environment.get_dev_dir('work')}/#{url.gsub('://', '/').gsub('.git', '')}"
     end
 
     # Get the size of a directory and its contents
     def self.get_dir_size(dir)
-      Dir.glob(File.join(dir, "**", "*"))
+      Dir.glob(File.join(dir, '**', '*'))
          .map { |f| File.size(f) }
          .inject(:+)
     end
 
     def self.machine
-      return ENV["COMPUTERNAME"] unless ENV["COMPUTERNAME"].nil?
+      return ENV['COMPUTERNAME'] unless ENV['COMPUTERNAME'].nil?
 
       machine = `hostname`
-      machine = machine.split(".")[0] if machine.include?(".")
+      machine = machine.split('.')[0] if machine.include?('.')
       machine.strip
     end
 
     def self.user
-      ENV["USERNAME"]
+      ENV['USERNAME']
     end
 
     def self.local_application_data
-      "#{ENV["USERPROFILE"]}/AppData/Local".gsub('\\', "/")
+      "#{ENV['USERPROFILE']}/AppData/Local".gsub('\\', '/')
     end
 
     def self.admin?
       rights = `whoami /priv`
-      rights.include?("SeCreateGlobalPrivilege")
+      rights.include?('SeCreateGlobalPrivilege')
     end
 
     def self.which(name)
       return name if File.exist?(name)
 
-      ["", ".exe", ".bat", ".cmd"].each do |ext|
+      ['', '.exe', '.bat', '.cmd'].each do |ext|
         aname = name + ext
         return aname if File.exist?(aname)
 
-        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
-          apath = "#{path.gsub('\\', "/")}/#{aname}".gsub("//", "/")
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          apath = "#{path.gsub('\\', '/')}/#{aname}".gsub('//', '/')
           return apath if File.exist?(apath)
         end
       end
-      ""
+      ''
     end
   end
 end

data/lib/raykit/git/directory.rb

@@ -16,7 +16,7 @@ module Raykit
       def outstanding_commit?
         Dir.chdir(directory) do
           if user_can_commit
-            return !`git status`.include?("nothing to commit,")
+            return !`git status`.include?('nothing to commit,')
           else
             return false
           end
@@ -26,7 +26,7 @@ module Raykit
       def detached?
         Dir.chdir(directory) do
           status = `git status`.strip
-          if status.include?("detached")
+          if status.include?('detached')
             true
           else
             false
@@ -38,43 +38,43 @@ module Raykit
         Dir.chdir(directory) do
           diff = `git diff`.strip
           status = `git status`.strip
-          PROJECT.run("git pull", false) if diff.length.zero? && status.include?("nothing to commit")
+          PROJECT.run('git pull', false) if diff.length.zero? && status.include?('nothing to commit')
         end
       end
 
       def rake(task)
         unless Dir.exist?(@directory)
-          puts "directory not found."
+          puts 'directory not found.'
           return 1
         end
         debug = false
-        sub_dir = "work"
-        sub_dir = "make" if @directory.include?("/make/")
-        rake_log = repository.get_dev_dir("log") + "/#{sub_dir}.rake.#{task}.json"
+        sub_dir = 'work'
+        sub_dir = 'make' if @directory.include?('/make/')
+        rake_log = repository.get_dev_dir('log') + "/#{sub_dir}.rake.#{task}.json"
 
         puts "log filename #{rake_log}" if debug
         if File.exist?(rake_log) && (File.mtime(rake_log) > last_modified_time)
-          puts "using logged data" if debug
+          puts 'using logged data' if debug
           cmd = Raykit::Command.parse(File.read(rake_log))
           cmd.summary
           return
         end
 
         Dir.chdir(@directory) do
-          if File.exist?("rakefile.rb")
+          if File.exist?('rakefile.rb')
             cmd = Raykit::Command.new("rake #{task}")
             cmd.summary
             FileUtils.mkdir_p(File.dirname(rake_log))
-            File.open(rake_log, "w") { |f| f.write(JSON.generate(cmd.to_hash)) }
+            File.open(rake_log, 'w') { |f| f.write(JSON.generate(cmd.to_hash)) }
           else
-            puts "rakefile.rb not found"
+            puts 'rakefile.rb not found'
           end
         end
       end
 
       def last_modified_time
         Dir.chdir(@directory) do
-          File.mtime(Dir.glob("**/*.*").select { |f| File.file?(f) }.max_by { |f| File.mtime(f) })
+          File.mtime(Dir.glob('**/*.*').select { |f| File.file?(f) }.max_by { |f| File.mtime(f) })
         end
       end
 
@@ -83,15 +83,24 @@ module Raykit
         Dir.chdir(directory) do
           return `git describe --abbrev=0`.strip
         end
-        ""
+        ''
       end
 
       def get_tag_commit_id(name)
         cmd = Raykit::Command.new("git rev-parse \"#{name}\"", 0, nil, false)
-        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
+        if !cmd.output.include?('fatal') && !cmd.error.include?('fatal')
           cmd.output.strip
         else
-          ""
+          ''
+        end
+      end
+
+      def has_tag(name)
+        cmd = Raykit::Command.new("git rev-parse \"#{name}\"", 0, nil, false)
+        if !cmd.output.include?('fatal') && !cmd.error.include?('fatal')
+          true
+        else
+          false
         end
       end
 
@@ -124,7 +133,7 @@ module Raykit
           scan = `git branch`.scan(/\*\s([\w.-]+)/)
           return scan[0][0].to_s if !scan.nil? && scan.length.positive? && scan[0].length.positive?
         end
-        "master"
+        'master'
       end
 
       def repository
@@ -135,10 +144,10 @@ module Raykit
       def remote
         if Dir.exist?(directory)
           Dir.chdir(directory) do
-            return Command.new("git config --get remote.origin.url").output.strip if Dir.exist?(".git")
+            return Command.new('git config --get remote.origin.url').output.strip if Dir.exist?('.git')
           end
         end
-        ""
+        ''
       end
     end
   end

data/lib/raykit/git/files.rb

@@ -6,7 +6,6 @@ module Raykit
     class Files
       @url
       @commit_id
-
       def initialize(url, commit_id)
         @url = url
         @commit_id = commit_id
@@ -19,7 +18,7 @@ module Raykit
       def get(name)
         puts "commit_path(): #{commit_path}"
         unless Dir.exist?(commit_path)
-          puts "cloning commit path..."
+          puts 'cloning commit path...'
           clone = Raykit::Command.new("git clone #{@url} #{commit_path}")
           puts clone.output
           puts clone.error
@@ -30,12 +29,12 @@ module Raykit
 
         return filename(name) if File.exist?(filename(name))
 
-        ""
+        ''
       end
 
       def commit_path
-        Dir.tmpdir + File::SEPARATOR + "Raykit.Git.Files" + File::SEPARATOR + @url.gsub("://",
-                                                                                        ".") + File::SEPARATOR + @commit_id
+        Dir.tmpdir + File::SEPARATOR + 'Raykit.Git.Files' + File::SEPARATOR + @url.gsub('://',
+                                                                                        '.') + File::SEPARATOR + @commit_id
       end
 
       def filename(name)

data/lib/raykit/git/repositories.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative("./directory")
+require_relative('./directory')
 
 module Raykit
   module Git
@@ -24,7 +24,7 @@ module Raykit
       end
 
       def save(_filename)
-        File.open(@filename, "w") do |f|
+        File.open(@filename, 'w') do |f|
           # json = JSON.pretty_generate(self)
           f.write(JSON.pretty_generate(self))
           # f.write(self.to_json)
@@ -32,12 +32,12 @@ module Raykit
       end
 
       def work_dir
-        Environment.get_dev_dir("work")
+        Environment.get_dev_dir('work')
       end
 
       def is_remote_url(pattern)
-        return true if pattern.include?("http://")
-        return true if pattern.include?("https://")
+        return true if pattern.include?('http://')
+        return true if pattern.include?('https://')
 
         false
       end
@@ -60,8 +60,8 @@ module Raykit
         else
           git_dirs = []
           Dir.chdir(work_dir) do
-            Dir.glob("**/.git") do |git_dir|
-              dir = File.expand_path("..", git_dir)
+            Dir.glob('**/.git') do |git_dir|
+              dir = File.expand_path('..', git_dir)
               git_dirs.insert(0, dir) if dir.length.positive?
             end
           end

data/lib/raykit/git/repository.rb

@@ -10,22 +10,22 @@ module Raykit
 
       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"))
+        @clone_directory = Raykit::Git::Directory.new(get_dev_dir('clone'))
+        @work_directory = Raykit::Git::Directory.new(get_dev_dir('work'))
       end
 
       def to_json(*_args)
-        JSON.generate({ "url" => @url })
+        JSON.generate({ 'url' => @url })
       end
 
       def self.parse(json)
         hash = JSON.parse(json)
-        Repository.new(hash["url"])
+        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://", "")
+        @url.gsub('https://', '').gsub('.git', '').gsub('http://', '')
       end
 
       def get_dev_dir(dir)
@@ -49,7 +49,7 @@ module Raykit
         if Dir.exist?(local_clone_directory)
           Dir.chdir(local_clone_directory) do
             `git branch`.split('\n').each do |line|
-              branch = line.gsub("*", "").strip
+              branch = line.gsub('*', '').strip
               results.insert(-1, branch) if branch.length.positive?
             end
           end
@@ -64,24 +64,24 @@ module Raykit
           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)
         return `git describe --abbrev=0`.strip if checkout_local_clone_directory_branch(branch)
 
-        ""
+        ''
       end
 
       private def local_clone_directory
-        clone_dir = "#{Environment.get_dev_dir("clone")}/#{relative_path}"
+        clone_dir = "#{Environment.get_dev_dir('clone')}/#{relative_path}"
       end
 
       private def update_local_clone_directory
         if Dir.exist?(local_clone_directory)
           Dir.chdir(local_clone_directory) do
-            Raykit::Command.new("git pull")
+            Raykit::Command.new('git pull')
             # t = `git pull`
           end
         else

data/lib/raykit/log.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require "json"
-
+require 'json'
 module Raykit
   class Log < Hash
     @filename
-
     def initialize(filename)
       @filename = filename
       dir = File.dirname(@filename)
@@ -22,21 +20,21 @@ module Raykit
     end
 
     def save
-      File.open(@filename, "w") { |f| f.write(JSON.generate(self)) }
+      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 = 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
+      self['command_times'] = command_times
       save
     end
 
     def get_command_time(command)
-      if key?("command_times")
-        command_times = self["command_times"]
+      if key?('command_times')
+        command_times = self['command_times']
         return DateTime.parse(command_times[command]) if command_times.key?(command)
       end
       nil

data/lib/raykit/logevent.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require "json"
-
+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
+      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']
-      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|
+      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---'

data/lib/raykit/logging.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "json"
-require "logger"
+require 'json'
+require 'logger'
 
 module Raykit
   class Logging
@@ -18,15 +18,15 @@ module Raykit
     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"
+      @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
+        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

data/lib/raykit/msbuild.rb

@@ -3,20 +3,14 @@
 module Raykit
   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)
+      ['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|
+        path = "C:/Program Files (x86)/Microsoft Visual Studio/#{relative_path}"
+        return path if Dir.exist?(path)
       end
-      ""
+      ''
     end
   end
 end