dev 2.1.153 → 2.1.154

data/lib/base/timeout.rb

@@ -1,25 +1,27 @@
+# frozen_string_literal: true
+
 ############################################################################
-# The following code is based on code originally copied from 
+# The following code is based on code originally copied from
 # https://gist.github.com/lpar/1032297
 # Gist title: lpar/timeout.rb
 ############################################################################
 # Runs a specified shell command in a separate thread.
 # If it exceeds the given timeout in seconds, kills it.
 # Returns any output produced by the command (stdout or stderr) as a String.
-# Uses Kernel.select to wait up to the tick length (in seconds) between 
+# Uses Kernel.select to wait up to the tick length (in seconds) between
 # checks on the command's status
 #
 # If you've got a cleaner way of doing this, I'd be interested to see it.
 # If you think you can do it with Ruby's Timeout module, think again.
-def run_with_timeout(directory,command, timeout, tick)
-  output = ''
-  exit_code=1
+def run_with_timeout(directory, command, timeout, tick)
+  output = ""
+  exit_code = 1
 
-  Open3.popen2e(command, :chdir=>directory) { |stdin,stderrout,thread|
+  Open3.popen2e(command, chdir: directory) do |_stdin, stderrout, thread|
     pid = thread.pid
 
     start = Time.now
-    while (Time.now - start) < timeout and thread.alive?
+    while ((Time.now - start) < timeout) && thread.alive?
       # Wait up to `tick` seconds for output/error data
       Kernel.select([stderrout], nil, nil, tick)
       # Try to read the data
@@ -29,14 +31,14 @@ def run_with_timeout(directory,command, timeout, tick)
         # A read would block, so loop around for another select
       rescue EOFError
         # Command has completed, not really an error...
-        exit_code=wait_thread.value
+        exit_code = wait_thread.value
         break
       end
 
       sleep(0.5)
     end
 
-    exit_code=wait_thread.value
+    exit_code = wait_thread.value
 
     # Give Ruby time to clean up the other thread
     sleep 1
@@ -45,14 +47,13 @@ def run_with_timeout(directory,command, timeout, tick)
       # We need to kill the process, because killing the thread leaves
       # the process alive but detached, annoyingly enough.
       Process.kill("TERM", pid)
-      exit_code=5
+      exit_code = 5
     end
+  end
 
-    
-  }
+  [output, exit_code]
+end
 
-  return [output,exit_code]
-end  
 #  begin
 #    # Start task in another thread, which spawns a process
 #    stdin, stderrout, thread = Open3.popen2e(command, :chdir=>directory)
@@ -79,8 +80,8 @@ end
 #    sleep 1
 
 #    if thread.alive?
-      # We need to kill the process, because killing the thread leaves
-      # the process alive but detached, annoyingly enough.
+# We need to kill the process, because killing the thread leaves
+# the process alive but detached, annoyingly enough.
 #      Process.kill("TERM", pid)
 #      exit_code=5
 #    else
@@ -92,30 +93,30 @@ end
 #    stderrout.close if stderrout
 #  end
 #  return [output,exit_code]
-#end
+# end
+
+require "timeout"
 
-require 'timeout'
-def run_with_timeout2(directory,command,timeout)
+def run_with_timeout2(directory, command, timeout)
   # stdout, stderr pipes
   rout, wout = IO.pipe
   rerr, werr = IO.pipe
-  output=''
-  error=''
-  exit_code=1
-  pid = Process.spawn(command, :chdir => directory, :out => wout, :err => werr)
+  output = ""
+  error = ""
+  exit_code = 1
+  pid = Process.spawn(command, chdir: directory, out: wout, err: werr)
   begin
     Timeout.timeout(timeout) do
       exit_code = Process.wait2(pid)
       output = rout.readlines.join("\n")
       error = rerr.readlines.join("\n")
     end
-  rescue
-    Proces.kill('TERM',pid)
-    output = output + 'timeout occurred.'
+  rescue StandardError
+    Proces.kill("TERM", pid)
+    output = "#{output}timeout occurred."
   ensure
     rout.close
     rerr.close
   end
-  [output,exit_code]
+  [output, exit_code]
 end
-

data/lib/base/timer.rb

@@ -1,45 +1,49 @@
+# frozen_string_literal: true
+
 puts __FILE__ if defined?(DEBUG)
 
 class Timer
   attr_accessor :start_time
 
   def initialize
-    @start_time=Time.now
+    @start_time = Time.now
   end
 
-  def elapsed # in seconds
-    return Time.now-@start_time
+  # in seconds
+  def elapsed
+    Time.now - @start_time
   end
 
   def elapsed_str
-    elapsed_str="[" + "%.0f" %(elapsed) + "s]"
+    elapsed_str = "[#{"%.0f" % elapsed}s]"
   end
 
-  def self.elapsed_exceeds?(name,duration_seconds)
-    if(Timer.get_elapsed(name).nil? || Timer.get_elapsed(name) > duration_seconds)
-	  return true
-	end
-	return false
+  def self.elapsed_exceeds?(name, duration_seconds)
+    return true if Timer.get_elapsed(name).nil? || Timer.get_elapsed(name) > duration_seconds
+
+    false
   end
 
   def self.get_elapsed(name)
-    timestamp=get_timestamp(name)
-	return Time.now-timestamp if(!timestamp.nil?)
-	nil
+    timestamp = get_timestamp(name)
+    return Time.now - timestamp unless timestamp.nil?
+
+    nil
   end
 
   def self.get_timestamp(name)
-    dir=Rake.application.original_dir
-    if(File.exists?("#{DEV[:dev_root]}/log/#{name}.timestamp"))
+    dir = Rake.application.original_dir
+    if File.exist?("#{DEV[:dev_root]}/log/#{name}.timestamp")
       return Time.parse(File.read("#{DEV[:dev_root]}/log/#{name}.timestamp").strip)
-	end
-	nil
+    end
+
+    nil
   end
 
   def self.set_timestamp(name)
-    Dir.mkdir("#{DEV_TASKS[:dev_root]}/log") if(!Dir.exists?("#{DEV_TASKS[:dev_root]}/log"))
-    File.open("#{DEV_TASKS[:dev_root]}/log/#{name}.timestamp",'w'){|f|f.puts(Time.now.to_s)}
+    Dir.mkdir("#{DEV_TASKS[:dev_root]}/log") unless Dir.exist?("#{DEV_TASKS[:dev_root]}/log")
+    File.open("#{DEV_TASKS[:dev_root]}/log/#{name}.timestamp", "w") { |f| f.puts(Time.now.to_s) }
   end
 end
 
-TIMER=Timer.new
+TIMER = Timer.new

data/lib/base/version.rb

@@ -1,83 +1,79 @@
+# frozen_string_literal: true
+
 class Version
-	def self.extract text
-		[/VERSION\s*=\s*['"]([\d.]+)['"]/,
-		 /[Vv]ersion\s*=\s*['"]([\d.]+)['"]/,
-		 /Version\(\s*"([\d.]+)"\s*\)/].each{|regex|
-			scan=text.scan(regex)
-			if(!scan.nil?)
-				return scan[0][0] if(scan.length > 0 && !scan[0].nil? && scan[0].length > 0)
-			end
-		}
-		nil
-	end
+  def self.extract(text)
+    [/VERSION\s*=\s*['"]([\d.]+)['"]/,
+     /[Vv]ersion\s*=\s*['"]([\d.]+)['"]/,
+     /Version\(\s*"([\d.]+)"\s*\)/].each do |regex|
+      scan = text.scan(regex)
+      return scan[0][0] if !scan.nil? && (scan.length.positive? && !scan[0].nil? && scan[0].length.positive?)
+    end
+    nil
+  end
+
+  def self.extract_from_file(filename)
+    Version.extract IO.read(filename)
+  end
+
+  def self.extract_from_filelist(filelist)
+    version = nil
+    filelist.each do |f|
+      version = extract_from_file f
+      return version unless version.nil?
+    end
+    nil
+  end
 
-	def self.extract_from_file filename
-		Version.extract IO.read(filename)
-	end
+  def self.update_text(text, version)
+    text = text.gsub(/version\s*=\s*'[\d.]+'/, "version='#{version}'")
+    text = text.gsub(/VERSION\s*=\s*'[\d.]+'/, "VERSION='#{version}'")
+    text = text.gsub(/version\s*=\s*"[\d.]+"/, "version=\"#{version}\"")
+    text = text.gsub(/Version\s*=\s*'[\d.]+'/, "Version='#{version}'")
+    text = text.gsub(/Version\s*=\s*"[\d.]+"/, "Version=\"#{version}\"")
+    text = text.gsub(/Version\(\s*"[\d.]+"\s*\)/, "Version(\"#{version}\")")
+    text = text.gsub(/Name\s*=\s*"Version"\s*Value\s*=\s*"[\d.]+"/, "Name=\"Version\" Value=\"#{version}\"")
+  end
 
-	def self.extract_from_filelist filelist
-		version=nil
-		filelist.each{|f|
-			version=extract_from_file f
-			return version if !version.nil?
-		}
-		nil
-	end
+  def self.update_file(filename, version)
+    if File.exist?(filename)
+      orig = IO.read(filename)
+      text = Version.update_text orig, version
+      File.open(filename, "w") { |f| f.write(text) } if orig != text
+    end
+  end
 
-    def self.update_text text, version
-    	text=text.gsub(/version\s*=\s*'[\d.]+'/,"version='#{version}'")
-		text=text.gsub(/VERSION\s*=\s*'[\d.]+'/,"VERSION='#{version}'")
-    	text=text.gsub(/version\s*=\s*"[\d.]+"/,"version=\"#{version}\"")
-    	text=text.gsub(/Version\s*=\s*'[\d.]+'/,"Version='#{version}'")
-    	text=text.gsub(/Version\s*=\s*"[\d.]+"/,"Version=\"#{version}\"")
-    	text=text.gsub(/Version\(\s*"[\d.]+"\s*\)/,"Version(\"#{version}\")")
-    	text=text.gsub(/Name\s*=\s*"Version"\s*Value\s*=\s*"[\d.]+"/,"Name=\"Version\" Value=\"#{version}\"")
+  def self.update_filelist(filelist, version)
+    filelist.each do |f|
+      Version.update_file f, version
     end
+  end
 
-	def self.update_file filename, version
-		if(File.exists?(filename))
-			orig=IO.read(filename)
-			text=Version.update_text orig,version
-			File.open(filename,'w'){|f|f.write(text)} if(orig!=text)
-		end
-	end
+  def self.read(filename)
+    return Gem::Specification.load(filename).version.to_s if filename.include?(".gemspec")
 
-	def self.update_filelist filelist,version
-		filelist.each{|f|
-			Version.update_file f,version
-		}
-	end
+    if filename.include?("AssemblyInfo.cs")
+      scan = IO.read(filename).scan(/Version\("([\d.]+)"\)/)
+      return scan[0][0] if !scan.nil? && (scan.length.positive? && !scan[0].nil? && scan[0].length.positive?)
 
-	def self.read filename
-		return "#{Gem::Specification.load(filename).version.to_s}" if filename.include?('.gemspec') 
-		if filename.include?('AssemblyInfo.cs')  
-			scan=IO.read(filename).scan(/Version\(\"([\d.]+)\"\)/)
-			if(!scan.nil?)
-				return scan[0][0] if(scan.length > 0 && !scan[0].nil? && scan[0].length > 0)
-			end
-		   #return IO.read(filename).scan(/Version\(\"([\d.]+)\"\)/)[0][0] 
-		   scan=IO.read(filename).scan(/Version=\"([\d.]+)\"/)
-		   if(!scan.nil?)
-		        return scan[0][0] if(scan.length > 0 && !scan[0].nil? && scan[0].length > 0)
-		   end
-	    end
-		'0.0'
-	end
+      # return IO.read(filename).scan(/Version\(\"([\d.]+)\"\)/)[0][0]
+      scan = IO.read(filename).scan(/Version="([\d.]+)"/)
+      return scan[0][0] if !scan.nil? && (scan.length.positive? && !scan[0].nil? && scan[0].length.positive?)
+    end
+    "0.0"
+  end
 
-	def self.get_version
-		Dir.glob('**/*.gemspec').each{|gemspec|
-			return Version.read gemspec
-		}
-		Dir.glob('**/AssemblyInfo.cs').each{|assemblyInfo|
-			return Version.read assemblyInfo
-		}
-		Dir.glob('**/*.wxs').each{|wxs|
-			return Version.read wxs
-		}
-		'0.0'
-	end
+  def self.get_version
+    Dir.glob("**/*.gemspec").each do |gemspec|
+      return Version.read gemspec
+    end
+    Dir.glob("**/AssemblyInfo.cs").each do |assemblyInfo|
+      return Version.read assemblyInfo
+    end
+    Dir.glob("**/*.wxs").each do |wxs|
+      return Version.read wxs
+    end
+    "0.0"
+  end
 end
 
-if(!defined?(VERSION))
-  VERSION=Version.get_version
-end
+VERSION = Version.get_version unless defined?(VERSION)

data/lib/base.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 puts __FILE__ if defined?(DEBUG)
 
-['array','command','dir','environment','file','gemspec',
- 'hash','history','internet','project','projects','source',
- 'string','text','timeout','timer','version'].each{|name| require_relative("base/#{name}.rb")}
+%w[array command dir environment file gemspec
+   hash history internet project projects source
+   string text timeout timer version].each { |name| require_relative("base/#{name}.rb") }

data/lib/commands.rb

@@ -1,51 +1,55 @@
+# frozen_string_literal: true
+
 if defined?(DEBUG)
-    puts DELIMITER
-    puts __FILE__
+  puts DELIMITER
+  puts __FILE__
 end
 
-require_relative('apps.rb')
+require_relative("apps")
+
+require "json"
+require "rake/clean"
+require "pp"
 
-require 'json'
-require 'rake/clean'
-require 'pp'
+Dir.glob("#{File.dirname(__FILE__)}/tasks/*.rb").sort.each do |rb|
+  require(rb) unless rb.include?("default")
+end
 
-Dir.glob("#{File.dirname(__FILE__)}/tasks/*.rb").each{|rb| 
-  require(rb) if !rb.include?('default')
-}
 class Commands < Hash
-	attr_accessor :env
-	def initialize env=nil,directory=Rake.application.original_dir
-		@env=env
-		@env=Environment.new() if @env.nil?
-		Dir.chdir(directory) do
-		  self[:pull]=Pull.new
-		  self[:update]=Update.new
-		  self[:setup]=Setup.new
-		  self[:build]=Build.new
-		  self[:test]=Test.new
-		  self[:analyze]=Analyze.new
-		  self[:doc]=Doc.new
-		  self[:package]=Package.new
-		  self[:publish]=Publish.new
-		  self[:add]=Add.new
-		  self[:commit]=Commit.new
-		  self[:push]=Push.new
-	    end
-	end
-
-	def info
-		puts "Commands"
-		self.each{|k,v|
-			v.update if v.respond_to? 'update'
-			if v.length > 0
-				puts " #{k}"
-				v.each{|c|
-					puts "  #{c[:input]}" if(!c.kind_of?(Hash))
-				}
-			end
-		}
-	end
+  attr_accessor :env
+
+  def initialize(env = nil, directory = Rake.application.original_dir)
+    @env = env
+    @env = Environment.new if @env.nil?
+    Dir.chdir(directory) do
+      self[:pull] = Pull.new
+      self[:update] = Update.new
+      self[:setup] = Setup.new
+      self[:build] = Build.new
+      self[:test] = Test.new
+      self[:analyze] = Analyze.new
+      self[:doc] = Doc.new
+      self[:package] = Package.new
+      self[:publish] = Publish.new
+      self[:add] = Add.new
+      self[:commit] = Commit.new
+      self[:push] = Push.new
+    end
+  end
+
+  def info
+    puts "Commands"
+    each do |k, v|
+      v.update if v.respond_to? "update"
+      next unless v.length.positive?
+
+      puts " #{k}"
+      v.each do |c|
+        puts "  #{c[:input]}" unless c.is_a?(Hash)
+      end
+    end
+  end
 end
 
-COMMANDS=Commands.new
-MSBUILD=MSBuild.new
+COMMANDS = Commands.new
+MSBUILD = MSBuild.new

data/lib/dev.config.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 #
 # dev.config.rb
 #
 # SOURCE.include('**/*.svg')
-# 
+#
 # CLEAN.include('bin')
 #
-# 
+#

data/lib/dev.rb

@@ -1,81 +1,80 @@
-DELIMITER='==================================================================================='
+# frozen_string_literal: true
+
+DELIMITER = "==================================================================================="
 puts DELIMITER if defined?(DEBUG)
 puts __FILE__ if defined?(DEBUG)
 
-require_relative('base.rb')
-require_relative('base/string.rb')
-require_relative('base/environment.rb')
-require_relative('base/giturl.rb')
-require_relative('base/projects.rb')
-require_relative('commands.rb')
+require_relative("base")
+require_relative("base/string")
+require_relative("base/environment")
+require_relative("base/giturl")
+require_relative("base/projects")
+require_relative("commands")
 
 class Dev
-	attr_accessor :env,:projects,:commands
+  attr_accessor :env, :projects, :commands
+
+  def initialize(env = nil)
+    @env = Environment.new(env) if !env.nil? && env.is_a?(Hash)
+    @env = Environment.new if @env.nil?
+    @projects = Projects.new(@env)
+    @commands = Commands.new(@env)
+    @output = ""
+  end
 
-	def initialize env=nil
-		@env=Environment.new(env) if !env.nil? && env.kind_of?(Hash)
-		@env=Environment.new() if @env.nil?
-		@projects=Projects.new(@env)
-		@commands=Commands.new(@env)
-		@output=''
-	end
-    
-	def execute args
-		args=args.split(' ') if(args.kind_of?(String))
+  def execute(args)
+    args = args.split(" ") if args.is_a?(String)
 
-        # parse arguments that are of the form KEY=VALUE
-		args.each{|arg|
-		 	if(arg.include?('='))
-		 		words=arg.split('=')
-		 		if(words.length==2)
-		 			ENV[words[0]]=words[1]
-		 		end
-		 	end
-		}
+    # parse arguments that are of the form KEY=VALUE
+    args.each do |arg|
+      next unless arg.include?("=")
 
-		if args.length == 0
-	       return usage
-	    else
-		   subcommand=args[0] if args.length > 0
-		   subargs=Array.new
-		   subargs=args[1,args.length-1] if args.length > 1
+      words = arg.split("=")
+      ENV[words[0]] = words[1] if words.length == 2
+    end
 
-		   return projects.add(subargs) if subcommand=='add'
-		   return projects.clobber(subargs) if subcommand=='clobber'
-		   return projects.import(subargs) if subcommand=='import'
-		   return projects.list(subargs) if subcommand=='list'
-		   return projects.make(subargs) if subcommand=='make'
-		   return projects.info(subargs) if subcommand=='info'
-		   return projects.remove(subargs) if subcommand=='remove'
-		   return projects.work(subargs) if subcommand=='work'
-		   return projects.update(subargs) if subcommand=='update'
+    if args.length.zero?
+      usage
+    else
+      subcommand = args[0] if args.length.positive?
+      subargs = []
+      subargs = args[1, args.length - 1] if args.length > 1
 
-		   @env.out "unknown command: '#{subcommand}'"
-		   1
-		end
-	end
+      return projects.add(subargs) if subcommand == "add"
+      return projects.clobber(subargs) if subcommand == "clobber"
+      return projects.import(subargs) if subcommand == "import"
+      return projects.list(subargs) if subcommand == "list"
+      return projects.make(subargs) if subcommand == "make"
+      return projects.info(subargs) if subcommand == "info"
+      return projects.remove(subargs) if subcommand == "remove"
+      return projects.work(subargs) if subcommand == "work"
+      return projects.update(subargs) if subcommand == "update"
 
-	def usage
-		return 0
-		@env.out 'usage: dev <subcommand> [options]'
-		@env.out ''
-		@env.out 'available subcommands'
-		@env.out ' help'
-		@env.out ' list'
-		@env.out ' make'
-		@env.out ' info'
-		@env.out ' work'
-		@env.out ''
-		@env.out "Type 'dev help <subcommand>' for help on a specific subcommand.'"
-		0
-	end
+      @env.out "unknown command: '#{subcommand}'"
+      1
+    end
+  end
+
+  def usage
+    return 0
+    @env.out "usage: dev <subcommand> [options]"
+    @env.out ""
+    @env.out "available subcommands"
+    @env.out " help"
+    @env.out " list"
+    @env.out " make"
+    @env.out " info"
+    @env.out " work"
+    @env.out ""
+    @env.out "Type 'dev help <subcommand>' for help on a specific subcommand.'"
+    0
+  end
 end
 
-require_relative('base.rb')
-require_relative('tasks.rb')
-require_relative('commands.rb')
+require_relative("base")
+require_relative("tasks")
+require_relative("commands")
 
 puts "defining DEV" if Environment.default.debug?
-DEV=Dev.new
-require_relative('tasks/default.rb')
-
+DEV = Dev.new
+require_relative("tasks/default")