dev 2.1.75 → 2.1.76

data/lib/base/string.rb

@@ -1,7 +1,7 @@
-puts __FILE__ if defined?(DEBUG)
-
-class String
-	def fix(size,padstr=' ')
-		self[0...size].rjust(size,padstr)
-	end
+puts __FILE__ if defined?(DEBUG)
+
+class String
+	def fix(size,padstr=' ')
+		self[0...size].rjust(size,padstr)
+	end
 end

data/lib/base/text.rb

@@ -1,30 +1,30 @@
-puts __FILE__ if defined?(DEBUG)
-
-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 }
-      return true
-    end
-    false
-  end
-
- def self.copy_if_different(source,destination)
-    if(!File.exists?(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
+puts __FILE__ if defined?(DEBUG)
+
+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 }
+      return true
+    end
+    false
+  end
+
+ def self.copy_if_different(source,destination)
+    if(!File.exists?(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

data/lib/base/timeout.rb

@@ -1,121 +1,121 @@
-############################################################################
-# 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 
-# 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
-
-  Open3.popen2e(command, :chdir=>directory) { |stdin,stderrout,thread|
-    pid = thread.pid
-
-    start = Time.now
-    while (Time.now - start) < timeout and thread.alive?
-      # Wait up to `tick` seconds for output/error data
-      Kernel.select([stderrout], nil, nil, tick)
-      # Try to read the data
-      begin
-        output << stderrout.read_nonblock(BUFFER_SIZE)
-      rescue IO::WaitReadable
-        # A read would block, so loop around for another select
-      rescue EOFError
-        # Command has completed, not really an error...
-        exit_code=wait_thread.value
-        break
-      end
-
-      sleep(0.5)
-    end
-
-    exit_code=wait_thread.value
-
-    # Give Ruby time to clean up the other thread
-    sleep 1
-
-    if thread.alive?
-      # 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
-    end
-
-    
-  }
-
-  return [output,exit_code]
-end  
-#  begin
-#    # Start task in another thread, which spawns a process
-#    stdin, stderrout, thread = Open3.popen2e(command, :chdir=>directory)
-#    # Get the pid of the spawned process
-#    pid = thread[:pid]
-#    start = Time.now
-#
-#    while (Time.now - start) < timeout and thread.alive?
-#      # Wait up to `tick` seconds for output/error data
-#      Kernel.select([stderrout], nil, nil, tick)
-#      # Try to read the data
-#      begin
-#        output << stderrout.read_nonblock(BUFFER_SIZE)
-#      rescue IO::WaitReadable
-#        # A read would block, so loop around for another select
-#      rescue EOFError
-#        # Command has completed, not really an error...
-#        exit_code=$?.exitstatus
-#        break
-#      end
-#    end
-#
-#    # Give Ruby time to clean up the other thread
-#    sleep 1
-
-#    if thread.alive?
-      # 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
-#      sleep 1
-#    end
-
-#  ensure
-#    stdin.close if stdin
-#    stderrout.close if stderrout
-#  end
-#  return [output,exit_code]
-#end
-
-require '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)
-  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.'
-  ensure
-    rout.close
-    rerr.close
-  end
-  [output,exit_code]
-end
-
+############################################################################
+# 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 
+# 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
+
+  Open3.popen2e(command, :chdir=>directory) { |stdin,stderrout,thread|
+    pid = thread.pid
+
+    start = Time.now
+    while (Time.now - start) < timeout and thread.alive?
+      # Wait up to `tick` seconds for output/error data
+      Kernel.select([stderrout], nil, nil, tick)
+      # Try to read the data
+      begin
+        output << stderrout.read_nonblock(BUFFER_SIZE)
+      rescue IO::WaitReadable
+        # A read would block, so loop around for another select
+      rescue EOFError
+        # Command has completed, not really an error...
+        exit_code=wait_thread.value
+        break
+      end
+
+      sleep(0.5)
+    end
+
+    exit_code=wait_thread.value
+
+    # Give Ruby time to clean up the other thread
+    sleep 1
+
+    if thread.alive?
+      # 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
+    end
+
+    
+  }
+
+  return [output,exit_code]
+end  
+#  begin
+#    # Start task in another thread, which spawns a process
+#    stdin, stderrout, thread = Open3.popen2e(command, :chdir=>directory)
+#    # Get the pid of the spawned process
+#    pid = thread[:pid]
+#    start = Time.now
+#
+#    while (Time.now - start) < timeout and thread.alive?
+#      # Wait up to `tick` seconds for output/error data
+#      Kernel.select([stderrout], nil, nil, tick)
+#      # Try to read the data
+#      begin
+#        output << stderrout.read_nonblock(BUFFER_SIZE)
+#      rescue IO::WaitReadable
+#        # A read would block, so loop around for another select
+#      rescue EOFError
+#        # Command has completed, not really an error...
+#        exit_code=$?.exitstatus
+#        break
+#      end
+#    end
+#
+#    # Give Ruby time to clean up the other thread
+#    sleep 1
+
+#    if thread.alive?
+      # 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
+#      sleep 1
+#    end
+
+#  ensure
+#    stdin.close if stdin
+#    stderrout.close if stderrout
+#  end
+#  return [output,exit_code]
+#end
+
+require '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)
+  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.'
+  ensure
+    rout.close
+    rerr.close
+  end
+  [output,exit_code]
+end
+

data/lib/base/timer.rb

@@ -1,45 +1,45 @@
-puts __FILE__ if defined?(DEBUG)
-
-class Timer
-  attr_accessor :start_time
-
-  def initialize
-    @start_time=Time.now
-  end
-
-  def elapsed # in seconds
-    return Time.now-@start_time
-  end
-
-  def elapsed_str
-    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
-  end
-
-  def self.get_elapsed(name)
-    timestamp=get_timestamp(name)
-	return Time.now-timestamp if(!timestamp.nil?)
-	nil
-  end
-
-  def self.get_timestamp(name)
-    dir=Rake.application.original_dir
-    if(File.exists?("#{DEV[:dev_root]}/log/#{name}.timestamp"))
-      return Time.parse(File.read("#{DEV[:dev_root]}/log/#{name}.timestamp").strip)
-	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)}
-  end
-end
-
+puts __FILE__ if defined?(DEBUG)
+
+class Timer
+  attr_accessor :start_time
+
+  def initialize
+    @start_time=Time.now
+  end
+
+  def elapsed # in seconds
+    return Time.now-@start_time
+  end
+
+  def elapsed_str
+    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
+  end
+
+  def self.get_elapsed(name)
+    timestamp=get_timestamp(name)
+	return Time.now-timestamp if(!timestamp.nil?)
+	nil
+  end
+
+  def self.get_timestamp(name)
+    dir=Rake.application.original_dir
+    if(File.exists?("#{DEV[:dev_root]}/log/#{name}.timestamp"))
+      return Time.parse(File.read("#{DEV[:dev_root]}/log/#{name}.timestamp").strip)
+	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)}
+  end
+end
+
 TIMER=Timer.new

data/lib/base/version.rb

@@ -1,83 +1,83 @@
-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_from_file filename
-		Version.extract IO.read(filename)
-	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_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.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.update_filelist filelist,version
-		filelist.each{|f|
-			Version.update_file f,version
-		}
-	end
-
-	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
-
-	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
-end
-
-if(!defined?(VERSION))
-  VERSION=Version.get_version
+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_from_file filename
+		Version.extract IO.read(filename)
+	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_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.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.update_filelist filelist,version
+		filelist.each{|f|
+			Version.update_file f,version
+		}
+	end
+
+	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
+
+	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
+end
+
+if(!defined?(VERSION))
+  VERSION=Version.get_version
 end