raykit 0.0.304 → 0.0.305

data/lib/raykit/runner.rb

@@ -1,42 +1,42 @@
-require 'yaml'
+# frozen_string_literal: true
+
+require "yaml"
 
 module Raykit
-    class Runner
-        def self.run(git_url)
-            commands=Array.new()
-            local_dir=Dir.mktmpdir('runner') 
-            puts 'local_dir : ' + local_dir
-            commands << Raykit::Command.new("git clone #{git_url} #{local_dir}")
-            Dir.chdir(local_dir) do
-                commands << Raykit::Command.new("git log -n 1")
-                yaml=get_build_yaml(local_dir)
-                build_hash=YAML.load(yaml)
-                build_commands=Raykit::Command.parse_yaml_commands(yaml)
-                if(build_hash.key?('image'))
-                    image=build_hash['image']
-                    build_commands.insert(0,'cd home')
-                    build_commands.insert(1,"git clone #{git_url} build")
-                    build_commands.insert(2,'cd build')
-                    build_commands_string=build_commands.join(';');
-                    commands << Raykit::Command.new("docker run #{image} sh -c \"#{build_commands_string}\"")
-                else
-                    build_commands.each{|cmd_string|
-                        commands << Rakkit::Command.new(cmd_string)
-                    }
-                end
-            end
-            FileUtils.rm_rf(local_dir)
-            commands
+  class Runner
+    def self.run(git_url)
+      commands = []
+      local_dir = Dir.mktmpdir("runner")
+      puts "local_dir : #{local_dir}"
+      commands << Raykit::Command.new("git clone #{git_url} #{local_dir}")
+      Dir.chdir(local_dir) do
+        commands << Raykit::Command.new("git log -n 1")
+        yaml = get_build_yaml(local_dir)
+        build_hash = YAML.safe_load(yaml)
+        build_commands = Raykit::Command.parse_yaml_commands(yaml)
+        if build_hash.key?("image")
+          image = build_hash["image"]
+          build_commands.insert(0, "cd home")
+          build_commands.insert(1, "git clone #{git_url} build")
+          build_commands.insert(2, "cd build")
+          build_commands_string = build_commands.join(";")
+          commands << Raykit::Command.new("docker run #{image} sh -c \"#{build_commands_string}\"")
+        else
+          build_commands.each do |cmd_string|
+            commands << Rakkit::Command.new(cmd_string)
+          end
         end
+      end
+      FileUtils.rm_rf(local_dir)
+      commands
+    end
 
-        def self.get_build_yaml(directory)
-            yaml=''
-            Dir.chdir(directory) do
-                if(File.exist?('.gitlab-ci.yml'))
-                    yaml = File.open('.gitlab-ci.yml').read
-                end
-            end
-            yaml
-        end
+    def self.get_build_yaml(directory)
+      yaml = ""
+      Dir.chdir(directory) do
+        yaml = File.open(".gitlab-ci.yml").read if File.exist?(".gitlab-ci.yml")
+      end
+      yaml
     end
-end
+  end
+end

data/lib/raykit/secrets.rb

@@ -1,38 +1,38 @@
-require 'time'
+# frozen_string_literal: true
+
+require "time"
 
 module Raykit
-    # Provides functionality to record the time execution times
-    class Secrets < Hash
-        def initialize()
-            if ENV.has_key?('RAYKIT_SECRETS_PATH')
-                secrets_file = ENV['RAYKIT_SECRETS_PATH']
-                if File.exists?(secrets_file)
-                    text = IO.read(secrets_file)
-                    if (text.length > 7 )
-                        data = JSON.parse(text)
-                        data.each{|key,value|
-                            self[key] = value
-                        }
-                    end
-                end
+  # Provides functionality to record the time execution times
+  class Secrets < Hash
+    def initialize
+      if ENV.key?("RAYKIT_SECRETS_PATH")
+        secrets_file = ENV["RAYKIT_SECRETS_PATH"]
+        if File.exist?(secrets_file)
+          text = IO.read(secrets_file)
+          if text.length > 7
+            data = JSON.parse(text)
+            data.each do |key, value|
+              self[key] = value
             end
+          end
         end
+      end
+    end
 
-        def hide(text)
-            hidden=text
-            self.each{|k,v|
-                if(!v.nil? && v.length > 0)
-                    hidden=hidden.gsub(v,'****')
-                end
-            }
-            hidden
-        end
+    def hide(text)
+      hidden = text
+      each do |_k, v|
+        hidden = hidden.gsub(v, "****") if !v.nil? && v.length.positive?
+      end
+      hidden
+    end
 
-        def save() 
-            if ENV.has_key?('RAYKIT_SECRETS_PATH')
-                secrets_file = ENV['RAYKIT_SECRETS_PATH']
-                File.open(secrets_file,"w") { |f| f.puts self.to_json }
-            end
-        end
+    def save
+      if ENV.key?("RAYKIT_SECRETS_PATH")
+        secrets_file = ENV["RAYKIT_SECRETS_PATH"]
+        File.open(secrets_file, "w") { |f| f.puts to_json }
+      end
     end
+  end
 end

data/lib/raykit/sourceImport.rb

@@ -1,75 +1,74 @@
+# frozen_string_literal: true
 
 module Raykit
-    class SourceImport < Hash
-        def initialize(url,source,glob,target,commit)
-            self['remote'] = url
-            self['source'] = source
-            self['glob'] = glob
-            self['target'] = target
-            self['commit']=commit
-        end
+  class SourceImport < Hash
+    def initialize(url, source, glob, target, commit)
+      self["remote"] = url
+      self["source"] = source
+      self["glob"] = glob
+      self["target"] = target
+      self["commit"] = commit
+    end
 
-        def remote
-            self['remote']
-        end
+    def remote
+      self["remote"]
+    end
 
-        def source
-            self['source']
-        end
+    def source
+      self["source"]
+    end
 
-        def target
-            self['target']
-        end
+    def target
+      self["target"]
+    end
+
+    def glob
+      self["glob"]
+    end
 
-        def glob
-            self['glob']
+    def update
+      work = self["remote"].work_dir
+      work_parent = File.dirname(work)
+      FileUtils.mkdir_p(work_parent) unless Dir.exist?(work_parent)
+      if Dir.exist?(work)
+        Dir.chdir(work) do
+          cmd = Command.new("git pull")
         end
+      else
+        PROJECT.run("git clone #{remote} #{work}")
+      end
 
-        def update
-            work=self['remote'].work_dir
-            work_parent=File.dirname(work)
-            FileUtils.mkdir_p(work_parent) if(!Dir.exist?(work_parent))
-            if(Dir.exist?(work))
-                Dir.chdir(work) do
-                    cmd = Command.new('git pull')
-                end
-            else
-                PROJECT.run("git clone #{remote} #{work}")
-            end
+      Dir.chdir(work) do
+        text = `git log -n 1`
+        scan = text.scan(/commit (\w+)\s/)
+        self["commit"] = scan[0][0].to_s
+      end
+    end
 
-            Dir.chdir(work) do
-                text=`git log -n 1`
-                scan=text.scan(/commit ([\w]+)\s/)
-                self['commit'] = scan[0][0].to_s 
-            end
+    def copy
+      if target.length.zero?
+        puts "target has not been specified"
+      else
+        FileUtils.remove_dir(target) if Dir.exist?(target)
+        count = 0
+        source_names = []
+        work = self["remote"].work_dir
+        Dir.chdir(work) do
+          cmd = Command.new("rake clean") if File.exist?("rakefile.rb")
+          Dir.chdir(source) do
+            source_names = Dir.glob(self["glob"])
+          end
         end
-
-        def copy
-            if(target.length == 0)
-                puts 'target has not been specified'
-            else
-                FileUtils.remove_dir(target) if(Dir.exist?(target))
-                count=0
-                source_names = []
-                work=self['remote'].work_dir
-                Dir.chdir(work) do
-                    if(File.exist?('rakefile.rb'))
-                        cmd = Command.new('rake clean')
-                    end
-                    Dir.chdir(self.source) do
-                        source_names=Dir.glob(self['glob'])
-                    end
-                end
-                source_names.each{|source_name|
-                    source_file =work + "/" + self.source + "/" + source_name
-                    target_name = target + "/" + source_name
-                    target_parent = File.dirname(target_name)
-                    FileUtils.mkdir_p(target_parent) if(!Dir.exist?(target_parent))
-                    FileUtils.copy(source_file,target_name)
-                    count += 1
-                }
-                puts '        copied ' + count.to_s + ' files to ' + target
-            end
+        source_names.each do |source_name|
+          source_file = "#{work}/#{source}/#{source_name}"
+          target_name = "#{target}/#{source_name}"
+          target_parent = File.dirname(target_name)
+          FileUtils.mkdir_p(target_parent) unless Dir.exist?(target_parent)
+          FileUtils.copy(source_file, target_name)
+          count += 1
         end
+        puts "        copied #{count} files to #{target}"
+      end
     end
-end
+  end
+end

data/lib/raykit/sourceImports.rb

@@ -1,46 +1,43 @@
+# frozen_string_literal: true
 
 module Raykit
-    class SourceImports < Array
-
-        def initialize(urls)
-            urls.each{|url|
-                self << SourceImport.new(url,'src','**/*.cs','dep','')
-            }
-        end
+  class SourceImports < Array
+    def initialize(urls)
+      urls.each do |url|
+        self << SourceImport.new(url, "src", "**/*.cs", "dep", "")
+      end
+    end
 
-        def update
-            self.each{|si|
-                si.update
-            }
-        end
+    def update
+      each(&:update)
+    end
 
-        def copy
-            self.each{|si|
-                si.copy
-            }
-        end
+    def copy
+      each(&:copy)
+    end
 
-        def targets_exist?
-            self.each{|si|
-                return false if(!Dir.exist?(si.target))
-            }
-            true
-        end
+    def targets_exist?
+      each do |si|
+        return false unless Dir.exist?(si.target)
+      end
+      true
+    end
 
-        def save(filename)
-            File.open(filename,'w'){|f|
-                f.write(JSON.pretty_generate(self))
-            }
-        end
+    def save(filename)
+      File.open(filename, "w") do |f|
+        f.write(JSON.pretty_generate(self))
+      end
+    end
 
-        def self.load(filename)
-            sourceImports = SourceImports.new([])
-            array=JSON.parse(IO.read(filename))
-            array.each{|hash|
-                sourceImport = SourceImport.new(hash['remote'],hash['source'],hash['glob'],hash['target'],hash['commit'])
-                sourceImports << sourceImport
-            }
-            sourceImports
-        end
+    def self.load(filename)
+      sourceImports = SourceImports.new([])
+      array = JSON.parse(IO.read(filename))
+      array.each do |hash|
+        sourceImport = SourceImport.new(hash["remote"], hash["source"], hash["glob"], hash["target"],
+                                        hash["commit"])
+        sourceImports << sourceImport
+      end
+      sourceImports
     end
-end
+  end
+end

data/lib/raykit/string.rb

@@ -1,16 +1,18 @@
-require_relative('./environment.rb')
+# frozen_string_literal: true
+
+require_relative("./environment")
 
 class String
-    def work_dir
-        rel_name=self.sub('https://','').gsub('http://','').gsub('.git','')
-        Raykit::Environment.get_dev_dir('work') + '/' + rel_name
-    end
+  def work_dir
+    rel_name = sub("https://", "").gsub("http://", "").gsub(".git", "")
+    "#{Raykit::Environment.get_dev_dir("work")}/#{rel_name}"
+  end
 
-    def latest_commit
-        Dir.chdir(self) do
-            text=`git log -n 1`
-            scan=text.scan(/commit ([\w]+)\s/)
-            return scan[0][0].to_s 
-        end
+  def latest_commit
+    Dir.chdir(self) do
+      text = `git log -n 1`
+      scan = text.scan(/commit (\w+)\s/)
+      return scan[0][0].to_s
     end
-end
+  end
+end

data/lib/raykit/tasks.rb

@@ -1,76 +1,74 @@
+# frozen_string_literal: true
 
 desc "Display project information"
 task :info do
-    PROJECT.info
+  PROJECT.info
 end
 
 desc "integrate changes into the git repository"
 task :integrate do
-    puts Rainbow(':integrate').blue.bright
+  puts Rainbow(":integrate").blue.bright
 
-    git_dir=Raykit::Git::Directory.new(Rake.application.original_dir)
-    if(git_dir.detached?)
-        puts "detached head state, skipping integrate operations"
+  git_dir = Raykit::Git::Directory.new(Rake.application.original_dir)
+  if git_dir.detached?
+    puts "detached head state, skipping integrate operations"
+  else
+    if PROJECT.outstanding_commit?
+      Rake::Task["test"].invoke if Rake::Task.task_defined?("test")
     else
-        if(PROJECT.outstanding_commit?)
-            if(Rake::Task.task_defined?("test"))
-                Rake::Task["test"].invoke
-            end 
-        else
-            puts "no outstanding commits detected"
-        end
+      puts "no outstanding commits detected"
+    end
 
-        
-        if(!File.exist?('.gitignore'))
-            puts "warning: .gitignore does not exist."
-        else
-            PROJECT.run('git add --all')
-            if(!`git status`.include?('nothing to commit'))
-            #if(PROJECT.outstanding_commit?)
-                commit_message='integrate'
-                PROJECT.run("git commit -m\"#{commit_message}\"") if(PROJECT.outstanding_commit?)
-                PROJECT.run("git pull")
-                #PROJECT.run("git push")
-                #PROJECT.run("git push --tags")
-            end
-        end
+    if !File.exist?(".gitignore")
+      puts "warning: .gitignore does not exist."
+    else
+      PROJECT.run("git add --all")
+      unless `git status`.include?("nothing to commit")
+        # if(PROJECT.outstanding_commit?)
+        commit_message = "integrate"
+        PROJECT.run("git commit -m\"#{commit_message}\"") if PROJECT.outstanding_commit?
+        PROJECT.run("git pull")
+        # PROJECT.run("git push")
+        # PROJECT.run("git push --tags")
+      end
     end
+  end
 end
 
 desc "push changes including tags"
 task :push do
-    git_dir=Raykit::Git::Directory.new(Rake.application.original_dir)
-    if(git_dir.detached?)
-        puts "detached head state, skipping push operations"
-    else
-        PROJECT.run("git push")
-        PROJECT.run("git push --tags")
-    end
+  git_dir = Raykit::Git::Directory.new(Rake.application.original_dir)
+  if git_dir.detached?
+    puts "detached head state, skipping push operations"
+  else
+    PROJECT.run("git push")
+    PROJECT.run("git push --tags")
+  end
 end
 
 desc "clean files not tracked by git"
 task :clean do
-    puts Rainbow(':clean').blue.bright
-    PROJECT.run('git clean -dXf')
+  puts Rainbow(":clean").blue.bright
+  PROJECT.run("git clean -dXf")
 end
 
 desc "update_source from sourceImports.json"
 task :update_source do
-    if(File.exist?('sourceImports.json'))
-        puts Rainbow(':update_source').blue.bright
-        sourceImports = Raykit::SourceImports.load('sourceImports.json')
-        json=sourceImports.to_json
-        sourceImports.update
+  if File.exist?("sourceImports.json")
+    puts Rainbow(":update_source").blue.bright
+    sourceImports = Raykit::SourceImports.load("sourceImports.json")
+    json = sourceImports.to_json
+    sourceImports.update
 
-        json2=sourceImports.to_json
-        if(json2 != json || !sourceImports.targets_exist?)
-            sourceImports.save('sourceImports.json')
-            sourceImports.copy
-        else
-            puts '        no update required.'
-        end
+    json2 = sourceImports.to_json
+    if json2 != json || !sourceImports.targets_exist?
+      sourceImports.save("sourceImports.json")
+      sourceImports.copy
+    else
+      puts "        no update required."
     end
+  end
 end
 
 desc "update source files"
-task :update => [:update_source]
+task update: [:update_source]

data/lib/raykit/text.rb

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+
 module Raykit
-    class Text
-    def self.replace_in_glob(glob,search,replace)
-        Dir.glob(glob).each{ |f| replace_in_file(f,search,replace) }
+  class Text
+    def self.replace_in_glob(glob, search, replace)
+      Dir.glob(glob).each { |f| replace_in_file(f, search, replace) }
     end
-    
-    def self.replace_in_file(filename,search,replace)
-        text1 = IO.read(filename)
-        text2 = text1.gsub(search) { |str| str=replace }
-        unless text1==text2
-        File.open(filename,"w") { |f| f.puts text2 }
+
+    def self.replace_in_file(filename, search, replace)
+      text1 = IO.read(filename)
+      text2 = text1.gsub(search) { |_str| str = replace }
+      unless text1 == text2
+        File.open(filename, "w") { |f| f.puts text2 }
         return true
-        end
-        false
+      end
+      false
     end
 
-    def self.copy_if_different(source,destination)
-        if(!File.exists?(destination))
+    def self.copy_if_different(source, destination)
+      if !File.exist?(destination)
         FileUtils.cp source, destination
-        else
-        source_text=IO.read(source)
-        destination_text=IO.read(destination)
-        if(source_text != destination_text)
-            FileUtils.rm destination
-            FileUtils.cp source, destination
+      else
+        source_text = IO.read(source)
+        destination_text = IO.read(destination)
+        if source_text != destination_text
+          FileUtils.rm destination
+          FileUtils.cp source, destination
         end
-        end
-    end
+      end
     end
-end
+  end
+end

data/lib/raykit/timer.rb

@@ -1,29 +1,31 @@
-require 'time'
+# frozen_string_literal: true
+
+require "time"
 
 module Raykit
-    # Provides functionality to record the time execution times
-    class Timer
-        # The time at which start occurred
-        attr_accessor :start_time
+  # Provides functionality to record the time execution times
+  class Timer
+    # The time at which start occurred
+    attr_accessor :start_time
 
-        def initialize
-            @start_time=Time.now
-        end
+    def initialize
+      @start_time = Time.now
+    end
 
-        # The elapsed time, in seconds, since the timer started
-        def elapsed
-            return Time.now-@start_time
-        end
+    # The elapsed time, in seconds, since the timer started
+    def elapsed
+      Time.now - @start_time
+    end
 
-        # The elapsed time, in seconds, as a formatted string
-        def elapsed_str(pad=0)
-            Timer.get_elapsed_str(elapsed,pad)
-        end
+    # The elapsed time, in seconds, as a formatted string
+    def elapsed_str(pad = 0)
+      Timer.get_elapsed_str(elapsed, pad)
+    end
 
-        # Converts a time span in seconds to a formatted string
-        def self.get_elapsed_str(elapsed,pad=0)
-            #"[" + "%.0f" % (elapsed) + "s]".ljust(pad)
-            "%.0f" % (elapsed) + "s".ljust(pad)
-        end
+    # Converts a time span in seconds to a formatted string
+    def self.get_elapsed_str(elapsed, pad = 0)
+      # "[" + "%.0f" % (elapsed) + "s]".ljust(pad)
+      format("%.0f", elapsed) + "s".ljust(pad)
     end
-end
+  end
+end