dev 2.0.99 → 2.0.100

data/lib/dev_commands.rb

@@ -1,1104 +0,0 @@
-require 'open3'
-#require_relative('./array.rb')
-#require_relative('./hash.rb')
-#require_relative('./timer.rb')
-
-BUFFER_SIZE=1024 if(!defined?(BUFFER_SIZE))
-            
-# = Command
-#
-# execution of system commands
-#
-# = Keys
-#
-# - :input The input of the commands.
-# - :timeout The timeout in seconds.
-#          a value of zero is to infinite timeout.
-#          defaults to zero
-# - :directory The working directory for the command.
-#             defaults to the current directory
-# - :exit_code The exit code of the command
-# - :output The output contains the stdout output of the command
-# - :error The error contains stderr output of the command
-# - :machine The name of the machine the command executed on
-# - :user The user name
-# - :start_time
-# - :end_time
-#
-class Command < Hash
-	def initialize command
-
-    self[:input] = ''
-		self[:timeout] = 0
-		self[:directory] = ''
-		self[:exit_code] = 0
-		self[:output] = ''
-		self[:error] = ''
-		self[:machine] = ''
-		self[:user] = ''
-		self[:start_time] = nil
-		self[:end_time] = nil
-
-		if(command.kind_of?(String))
-		  self[:input] = command
-        end
-
-        if(command.kind_of?(Hash))
-        	command.each{|k,v|
-        		self[k.to_sym]=v
-        	}
-        end
-	end
-
-  def quiet?
-    (self.has_key?(:quiet) && self[:quiet])
-  end
-
-	def execute value=nil
-
-    if(!value.nil? && value.is_a?(Hash))
-      value.each{|k,v|self[k]=v}
-    end
-
-		pwd=Dir.pwd
-		self[:directory] = pwd if(!self.has_key?(:directory) || self[:directory].length==0)
-
-    if(self[:timeout] > 0)
-      puts "#{self[:input]} (#{self[:directory]}) timeout #{self[:timeout].to_s}" if(!quiet?)
-    else
-		  puts "#{self[:input]} (#{self[:directory]})" if(!quiet?)
-    end
-
-		self[:machine] = Command.machine
-		self[:user] = Command.user
-
-		self[:start_time]=Time.now
-		timer=Timer.new
-
-    Dir.chdir(self[:directory]) do
-  		if self[:input].include?('<%') && self[:input].include?('%>')
-  		  ruby = self[:input].gsub("<%","").gsub("%>","")
-
-  		  begin
-  		    self[:output]=eval(ruby)
-  		  rescue 
-  		  	self[:exit_code]=1
-  		  	self[:error]="unable to eval(#{ruby})"
-  		  end
-
-  		  self[:elapsed] = timer.elapsed_str
-  		  self[:end_time] = Time.now
-  		else
-  			begin
-          if(self[:timeout] <= 0)
-            self[:output],self[:error],status= Open3.capture3(self[:input])
-            self[:exit_code]=status.to_i
-    			  self[:elapsed] = timer.elapsed_str
-    			  self[:end_time] = Time.now
-          else
-            require_relative 'timeout.rb'
-            #puts run_with_timeout(self[:input], self[:timeout], 1).to_s
-            #self[:output] = run_with_timeout(self[:input], self[:timeout], 1)
-            result=run_with_timeout2(self[:directory],self[:input], self[:timeout], 2)
-            self[:output]=result[0]
-            self[:error]=result[1]
-            self[:exit_code]=result[2]
-
-            self[:elapsed] = timer.elapsed_str
-            self[:end_time] = Time.now
-            
-            if(timer.elapsed >= self[:timeout])
-              self[:exit_code]=1 
-              self[:error] = self[:error] + "timed out"
-            end
-          end
-  			rescue Exception => e
-  			  self[:elapsed] = timer.elapsed_str
-  			  self[:end_time] = Time.now
-  			  self[:error] = "Exception: " + e.to_s
-  			  self[:exit_code]=1
-  		  end
-  		end
-    end
-       
-
-    if(self[:exit_code] != 0)
-      if(!quiet?)
-    	  puts "exit_code=#{self[:exit_code]}"
-    	  puts self[:output]
-    	  puts self[:error]
-      end
-    	if(!self.has_key?(:ignore_failure) || !self[:ignore_failure])
-    		raise "#{self[:input]} failed" 
-    	end #unless (self.has_key?(:ignore_failure) && self[:ignore_failure]==true)
-    end
-      
-	end
-
-    def self.machine
-      if !ENV['COMPUTERNAME'].nil? 
-	   return ENV['COMPUTERNAME']
-	  end
-
-      machine = `hostname`
-      machine = machine.split('.')[0] if machine.include?('.')
-	  return machine.strip
-    end
-
-    def self.user
-      ENV['USER'].nil? ? ENV['USERNAME'] : ENV['USER']
-    end 
-
-    def self.home 
-      ["USERPROFILE","HOME"].each {|v|
-        return ENV[v].gsub('\\','/') unless ENV[v].nil?
-      }
-      dir="~"
-      dir=ENV["HOME"] unless ENV["HOME"].nil?
-      dir=ENV["USERPROFILE"].gsub('\\','/') unless ENV["USERPROFILE"].nil?
-      return dir
-    end
-
-    def self.dev_root
-      ["DEV_HOME","DEV_ROOT"].each {|v|
-        return ENV[v].gsub('\\','/') unless ENV[v].nil?
-      }
-      dir=home
-      #dir=ENV["DEV_ROOT"].gsub('\\','/') unless ENV["DEV_ROOT"].nil?
-     return dir
-    end
-
-    def self.exit_code command
-    	cmd = Command.new(command)
-    	cmd[:ignore_failure]=true
-      cmd[:quiet]=true
-    	cmd.execute
-    	cmd[:exit_code]
-    end
-
-    def self.output command
-    	cmd = Command.new(command)
-    	cmd[:ignore_failure]=true
-      cmd[:quiet]=true
-    	cmd.execute
-    	cmd[:output]
-    end
-
-    def getFormattedTimeSpan timespan
-      seconds = timespan
-      seconds.to_s + " sec"
-    end
-
-    def summary
-      duration=""
-      duration=getFormattedTimeSpan(self[:end_time]-[:start_time]) + " - " if(!self[:end_time].nil?)
-      duration + "#{self[:exit_code].to_s} #{self[:input]} (#{self[:directory]})"
-    end
-
-    def to_html
-      if self[:exit_code] == 0
-      [
-      	'<div><table><tr><td width="20"></td><td><pre>',
-      	self[:input],
-      	'</pre></td></tr></table></div>'
-      ].join
-      else
-      [
-      	'<div><table><tr><td width="20"></td><td><pre>',
-      	self[:input],
-        '</pre><table><tr><td width="20"></td><td><table>',
-        map { |k, v| ["<tr><td><strong>#{k}</strong></td>", v.respond_to?(:to_html) ? v.to_html : "<td><span><pre>#{v}</pre></span></td></tr>"] },
-        '</table>',
-        '</td></tr></table></td></tr></table></div>'
-      ].join
-      end
-    end
-end
-class Add < Array
-	def update
-		if(File.exists?('.git') && File.exists?('.gitignore'))
-			add 'git add --all' 
-		else
-			if(defined?(SOURCE))
-				if(File.exists?('.svn'))
-					SOURCE.each{|f|
-
-						add "svn add #{f} --parents" if Command.output("svn status #{f}").include?('?')
-						add "svn add #{f} --parents" if Command.exit_code("svn status #{f}") != 0
-					}
-				end
-				if(File.exists?('.git'))
-					SOURCE.each{|f|
-						add "git add #{f} -v" if `git status #{f}`.include?('untracked')
-					}
-				end
-			end
-		end
-	end
-end
-class Analyze < Array
-	def update
-		if(`gem list countloc`.include?('countloc ('))
-			FileUtils.mkdir('doc') if(!File.exists?('doc'))
-			add 'countloc -r * --html doc/countloc.html'
-		end
-	end
-end
-class Array
-    def execute value=nil
-      i=0
-      while i < self.length
-        self[i]=Command.new(self[i]) if(self[i].is_a?(String))
-        self[i]=Command.new(self[i]) if(self[i].is_a?(Hash) && !self[i].is_a?(Command))
-
-        if(!value.nil? && value.is_a?(Hash))
-          value.each{|k,v|self[i][k]=v}
-        end
-
-        self[i].execute if(self[i].is_a?(Command))
-        i=i+1
-      end
-    end
-
-    def add command
-      self << command if(!include?(command))
-    end
-
-    def to_html
-      html=Array.new
-      html << '<div>'
-      self.each{|e|
-        html << e.to_html if e.respond_to?(:to_html)
-      }
-      html << '</div>'
-      html.join
-    end
-end
-require 'rake'
-
-SLN_FILES=FileList.new('*.sln','*/*.sln','*/*/*.sln')
-
-class Build < Array
-	def update
-
-		changed = true
-		#changed = Git.has_changes? if(File.exists?('.git') && defined?(Git))
-		#changed = Svn.has_changes? if(File.exists?('.svn') && defined?(Svn))
-        if(changed)
-			Dir.glob('*.gemspec'){|gemspec|
-	    		add "gem build #{gemspec}" if !File.exist?(Gemspec.gemfile gemspec)
-	    	}
-	    	
-	    	SLN_FILES.each{|sln_file|
-	    		vs_version=MSBuild.get_vs_version(sln_file)
-				if(MSBuild.has_version?(vs_version))
-					MSBuild.get_configurations(sln_file).each{ |configuration|
-		      			MSBuild.get_platforms(sln_file).each{|platform|
-			    			#Console.debug "configuration='#{configuration}', platform='#{platform}'"
-		        			self.add "\"#{MSBuild.get_version(vs_version)}\" \"#{sln_file}\" /nologo /p:Configuration=#{configuration} /p:Platform=\"#{platform}\""
-		      			}
-		    		}
-	            else
-	                "puts version #{vs_version} not found for MsBuild"
-				end
-	    	}
-	    end
-	end
-end
-class Clean < Array
-	def update
-		['.yardoc','log','tmp','obj'].each{|dir| 
-			CLEAN.include(dir) if File.exists?(dir)
-		}	
-		
-        CLEAN.include('*.{suo,sdf}')
-
-        #add '<%Rake::Task[:clean].reenable%>'
-        add '<%Rake::Task[:clean].invoke%>'
-	end
-end
-class Clobber < Array
-	def update
-		['bin'].each{|dir| 
-			CLOBBER.include(dir) if File.exists?(dir)
-		}	
-		
-		clean=Clean.new
-		clean.update
-
-		CLOBBER.include('*.gem')
-
-        #add '<%Rake::Task[:clobber].reenable%>'
-        add '<%Rake::Task[:clobber].invoke%>'
-	end
-end
-require 'open3'
-#require_relative('./array.rb')
-#require_relative('./hash.rb')
-#require_relative('./timer.rb')
-
-BUFFER_SIZE=1024 if(!defined?(BUFFER_SIZE))
-            
-# = Command
-#
-# execution of system commands
-#
-# = Keys
-#
-# - :input The input of the commands.
-# - :timeout The timeout in seconds.
-#          a value of zero is to infinite timeout.
-#          defaults to zero
-# - :directory The working directory for the command.
-#             defaults to the current directory
-# - :exit_code The exit code of the command
-# - :output The output contains the stdout output of the command
-# - :error The error contains stderr output of the command
-# - :machine The name of the machine the command executed on
-# - :user The user name
-# - :start_time
-# - :end_time
-#
-class Command < Hash
-	def initialize command
-
-    self[:input] = ''
-		self[:timeout] = 0
-		self[:directory] = ''
-		self[:exit_code] = 0
-		self[:output] = ''
-		self[:error] = ''
-		self[:machine] = ''
-		self[:user] = ''
-		self[:start_time] = nil
-		self[:end_time] = nil
-
-		if(command.kind_of?(String))
-		  self[:input] = command
-        end
-
-        if(command.kind_of?(Hash))
-        	command.each{|k,v|
-        		self[k.to_sym]=v
-        	}
-        end
-	end
-
-  def quiet?
-    (self.has_key?(:quiet) && self[:quiet])
-  end
-
-	def execute value=nil
-
-    if(!value.nil? && value.is_a?(Hash))
-      value.each{|k,v|self[k]=v}
-    end
-
-		pwd=Dir.pwd
-		self[:directory] = pwd if(!self.has_key?(:directory) || self[:directory].length==0)
-
-    if(self[:timeout] > 0)
-      puts "#{self[:input]} (#{self[:directory]}) timeout #{self[:timeout].to_s}" if(!quiet?)
-    else
-		  puts "#{self[:input]} (#{self[:directory]})" if(!quiet?)
-    end
-
-		self[:machine] = Command.machine
-		self[:user] = Command.user
-
-		self[:start_time]=Time.now
-		timer=Timer.new
-
-    Dir.chdir(self[:directory]) do
-  		if self[:input].include?('<%') && self[:input].include?('%>')
-  		  ruby = self[:input].gsub("<%","").gsub("%>","")
-
-  		  begin
-  		    self[:output]=eval(ruby)
-  		  rescue 
-  		  	self[:exit_code]=1
-  		  	self[:error]="unable to eval(#{ruby})"
-  		  end
-
-  		  self[:elapsed] = timer.elapsed_str
-  		  self[:end_time] = Time.now
-  		else
-  			begin
-          if(self[:timeout] <= 0)
-            self[:output],self[:error],status= Open3.capture3(self[:input])
-            self[:exit_code]=status.to_i
-    			  self[:elapsed] = timer.elapsed_str
-    			  self[:end_time] = Time.now
-          else
-            require_relative 'timeout.rb'
-            #puts run_with_timeout(self[:input], self[:timeout], 1).to_s
-            #self[:output] = run_with_timeout(self[:input], self[:timeout], 1)
-            result=run_with_timeout2(self[:directory],self[:input], self[:timeout], 2)
-            self[:output]=result[0]
-            self[:error]=result[1]
-            self[:exit_code]=result[2]
-
-            self[:elapsed] = timer.elapsed_str
-            self[:end_time] = Time.now
-            
-            if(timer.elapsed >= self[:timeout])
-              self[:exit_code]=1 
-              self[:error] = self[:error] + "timed out"
-            end
-          end
-  			rescue Exception => e
-  			  self[:elapsed] = timer.elapsed_str
-  			  self[:end_time] = Time.now
-  			  self[:error] = "Exception: " + e.to_s
-  			  self[:exit_code]=1
-  		  end
-  		end
-    end
-       
-
-    if(self[:exit_code] != 0)
-      if(!quiet?)
-    	  puts "exit_code=#{self[:exit_code]}"
-    	  puts self[:output]
-    	  puts self[:error]
-      end
-    	if(!self.has_key?(:ignore_failure) || !self[:ignore_failure])
-    		raise "#{self[:input]} failed" 
-    	end #unless (self.has_key?(:ignore_failure) && self[:ignore_failure]==true)
-    end
-      
-	end
-
-    def self.machine
-      if !ENV['COMPUTERNAME'].nil? 
-	   return ENV['COMPUTERNAME']
-	  end
-
-      machine = `hostname`
-      machine = machine.split('.')[0] if machine.include?('.')
-	  return machine.strip
-    end
-
-    def self.user
-      ENV['USER'].nil? ? ENV['USERNAME'] : ENV['USER']
-    end 
-
-    def self.home 
-      ["USERPROFILE","HOME"].each {|v|
-        return ENV[v].gsub('\\','/') unless ENV[v].nil?
-      }
-      dir="~"
-      dir=ENV["HOME"] unless ENV["HOME"].nil?
-      dir=ENV["USERPROFILE"].gsub('\\','/') unless ENV["USERPROFILE"].nil?
-      return dir
-    end
-
-    def self.dev_root
-      ["DEV_HOME","DEV_ROOT"].each {|v|
-        return ENV[v].gsub('\\','/') unless ENV[v].nil?
-      }
-      dir=home
-      #dir=ENV["DEV_ROOT"].gsub('\\','/') unless ENV["DEV_ROOT"].nil?
-     return dir
-    end
-
-    def self.exit_code command
-    	cmd = Command.new(command)
-    	cmd[:ignore_failure]=true
-      cmd[:quiet]=true
-    	cmd.execute
-    	cmd[:exit_code]
-    end
-
-    def self.output command
-    	cmd = Command.new(command)
-    	cmd[:ignore_failure]=true
-      cmd[:quiet]=true
-    	cmd.execute
-    	cmd[:output]
-    end
-
-    def getFormattedTimeSpan timespan
-      seconds = timespan
-      seconds.to_s + " sec"
-    end
-
-    def self.execute command
-      cmd = Command.new(command)
-      cmd.execute
-      cmd[:exit_code]
-    end
-
-    def summary
-      duration=""
-      duration=getFormattedTimeSpan(self[:end_time]-self[:start_time]) + " - " if(!self[:end_time].nil?)
-      duration + "#{self[:exit_code].to_s} #{self[:input]} (#{self[:directory]})"
-    end
-
-    def to_html
-      if self[:exit_code] == 0
-      [
-      	'<div><table><tr><td width="20"></td><td><pre>',
-      	self[:input],
-      	'</pre></td></tr></table></div>'
-      ].join
-      else
-      [
-      	'<div><table><tr><td width="20"></td><td><pre>',
-      	self[:input],
-        '</pre><table><tr><td width="20"></td><td><table>',
-        map { |k, v| ["<tr><td><strong>#{k}</strong></td>", v.respond_to?(:to_html) ? v.to_html : "<td><span><pre>#{v}</pre></span></td></tr>"] },
-        '</table>',
-        '</td></tr></table></td></tr></table></div>'
-      ].join
-      end
-    end
-end
-#require_relative('hash.rb')
-#require_relative('pull.rb')
-#require_relative('update.rb')
-#require_relative('setup.rb')
-#require_relative('build.rb')
-#require_relative('test.rb')
-#require_relative('analyze.rb')
-#require_relative('publish.rb')
-#require_relative('doc.rb')
-#require_relative('clean.rb')
-#require_relative('clobber.rb')
-#require_relative('add.rb')
-#require_relative('commit.rb')
-#require_relative('push.rb')
-
-class Commands < Hash
-
-	def initialize directory=Dir.pwd
-		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[:clean]=Clean.new
-		  self[:publish]=Publish.new
-		  self[:clobber]=Clobber.new
-		  self[:add]=Add.new
-		  self[:commit]=Commit.new
-		  self[:push]=Push.new
-	    end
-	end
-
-end
-#require_relative('internet.rb')
-
-class Commit < Array
-	def update
-		if(File.exists?('.git') && `git config --list`.include?('user.name='))
-			if(!`git status`.include?('nothing to commit') &&
-			   !`git status`.include?('untracked files present'))
-			  if(File.exists?('commit.message') && File.read('commit.message').gsub(/\s+/,"").length >0)
-			  	add "git commit -a -v -m \"#{File.read('commit.message')}\""
-			  else
-			    add "git commit -m'all'"
-			  end
-			  add "<%FileUtils.rm('commit.message')%>" if File.exists?('commit.message')
-		    end 		
-		end
-		if(File.exists?('.svn') && Internet.available?)
-			add 'svn commit -m"commit all"'
-		end
-	end
-end
-class Doc < Array
-	def update
-		#cmd=Command.new ({ :input => 'yard --version', :ignore_failure => true})
-		#cmd.execute
-		if(Command.exit_code('yard --version'))
-		  add 'yard doc - LICENSE' if File.exists?('README.md') && File.exists?('LICENSE')
-		end
-	end
-end
-class Gemspec
-	def self.update gemspec_file
-		Text.replace_in_file gemspec_file,
-                              /('\d{4}-\d{2}-\d{2}')/,
-                              "'#{Time.now.strftime('%Y-%m-%d')}'"
-	end
-
-	def self.gemfile gemspec_file
-		spec=Gem::Specification.load(gemspec_file)
-		return "#{spec.name}-#{spec.version}.gem" if !spec.nil?
-		return ""
-	end
-
-    def self.version gemspec_file
-    	spec=Gem::Specification.load(gemspec_file)
-		return spec.version.to_s
-    end
-
-    def self.published_version gemspec_file
-  		published_version=''
-    	spec=Gem::Specification.load(gemspec_file)
-		begin
-		  published_version = `gem list -r #{spec.name}`.scan(/\((\d+.\d+.\d+)\)/)[0][0]
-		rescue
-		  published_version=''
-		end
-		published_version
-    end
-	def self.published? gemspec_file
-		published_version(gemspec_file)==version(gemspec_file) ? true : false
-	end
-
-	def self.normalize gemspec_file
-		spec=Gem::Specification.load(gemspec_file)
-		File.open(gemspec_file,'w'){|f|f.write(spec.to_ruby)}
-	end
-
-	def self.upgrade gemspec_file
-	end
-end
-class Git
-	def self.branch
-		begin
-		  `git branch`.scan(/\* ([.\w-]+)/)[0][0]
-	    rescue
-	    	''
-	    end
-    end
-
-    def self.remote_origin directory=''
-    	url=''
-    	directory=Dir.pwd if directory.length == 0
-    	Dir.chdir(directory) do
-    		begin
-    			url=`git remote show origin`.scan(/Fetch URL: ([\.\-:\/\w\d]+)/)[0]
-    		rescue
-    			url=''
-    		end
-    	end
-    	url
-    end
-end
-class Hash
-	def execute value=nil
-	  self.each{|k,v|
-      v.update if v.respond_to?(:update)
-      if(v.is_a?(Array) && v.length==0)
-        self.delete k 
-      else
-        #puts "executing #{k}"
-
-	  	  v.execute(value) if v.respond_to?(:execute)
-      end
-	  }
-    end
-	def to_html
-      [
-      	'<div>',
-        map { |k, v| ["<br/><div><strong>#{k}</strong>", v.respond_to?(:to_html) ? v.to_html : "<span>#{v}</span></div><br/>"] },
-        '</div>'
-      ].join
-    end
-end
-#require_relative 'array.rb'
-INFO=Array.new
-
-require 'open-uri'
-#require 'net/http'
-require 'timeout'
-class Internet
-
-	@@available=true
-
-	def self.available?
-		return @@available if !@@available.nil?
-
-		begin
-			index=open('http://www.google.com').read 
-			if index.include?('<Title>Google')
-				@@available = true
-			else
-				puts "open('http://www.google.com') returned false"
-			end
-		rescue Exception => e
-			puts "open('http://www.google.com') raised an exception: #{e.to_s}"
-			@@available = false
-		end
-		@@available
-	end
-end
-# Visual Studio 2008 version 9.0,  solution format version 10.00
-# Visual Studio 2010 version 10.0, solution format version 11.00
-# Visual Studio 2012 version 11.0, solution format version 12.00
-# Visual Studio 2013 version 12.0, solution format version 12.00
-class MSBuild < Hash
-
-  def initialize
-    self[:vs9]="C:\\Windows\\Microsoft.NET\\Framework\\v3.5\\msbuild.exe"  if(File.exists?("C:\\Windows\\Microsoft.NET\\Framework\\v3.5\\msbuild.exe"))
-    self[:vs12]="C:\\Program Files (x86)\\MSBuild\\12.0\\bin\\msbuild.exe" if(File.exists?("C:\\Program Files (x86)\\MSBuild\\12.0\\bin\\msbuild.exe"))
-  end
-  
-  def self.has_version? version
-    if(defined?(MSBUILD))
-      MSBUILD.has_key?(version)
-    else
-      msb=MSBuild.new
-      return msb.has_key? version
-    end
-  end
-
-  def self.get_version version
-    if(defined?(MSBUILD))
-      MSBUILD[version]
-    else
-      msb=MSBuild.new
-      return msb[version]
-    end
-  end
-
-	def self.get_vs_version(sln_filename)
-   		sln_text=File.read(sln_filename,:encoding=>'UTF-8')
-    	return :vs9 if sln_text.include?('Format Version 10.00')
-    	return :vs12
-  	end
-
-  	def self.get_configurations(sln_filename)
-    	configs=Array.new
-	  	sln_text=File.read(sln_filename,:encoding=>'UTF-8')
-    	sln_text.scan( /= ([\w]+)\|/ ).each{|m|
-	  	c=m.first.to_s
-	  	configs << c if !configs.include?(c)
-		}
-		return configs
-  	end
-
-  	def self.get_platforms(sln_filename)
-    	platforms=Array.new
-	  	sln_text=File.read(sln_filename,:encoding=>"UTF-8")
-    	sln_text.scan( /= [\w]+\|([\w ]+)/ ).each{|m|
-	    	p=m.first.to_s
-	    	platforms << p if !platforms.include?(p)
-	  	}
-		return platforms
-  	end
-end
-
-#require_relative('internet.rb')
-class Publish < Array
-	def update
-		if(Internet.available?)
-			if(File.exists?('.git'))
-				if(`git branch`.include?('* master'))
-					Dir.glob('*.gemspec').each{|gemspec_file|
-						add "gem push #{Gemspec.gemfile(gemspec_file)}" if !Gemspec.published? gemspec_file
-					}
-				end
-			end
-			if(File.exists?('.svn'))
-				if(`svn info`.include?('/trunk'))
-					Dir.glob('*.gemspec').each{|gemspec_file|
-						add "gem push #{Gemspec.gemfile(gemspec_file)}" if !Gemspec.published? gemspec_file
-					}
-				end
-			end
-		end
-	end
-end
-#require_relative('git.rb')
-#require_relative('internet.rb')
-
-class Pull < Array
-	def update
-		if(Internet.available?)
-			if(File.exists?('.git') && `git config --list`.include?('user.name='))
-				self <<  'git pull' if Git.branch != 'develop'
-			end
-		end
-	end
-end
-class Push < Array
-	def update
-		if(File.exists?('.git') && `git config --list`.include?('user.name='))
-			self <<  'git push'
-			self <<  'git push --tags'# if Git.branch != 'develop' && Internet.available?
-		end
-	end
-end
-#
-# use the SVN_EXPORTS hash to define svn exports destined for DEV_ROOT/dep
-#
-# SVN_EXPORT={ 'System.Data.SQLite/1.0.93.0' => 'https://third-party.googlecode.com/svn/trunk/System.Data.SQLite/1.0.93.0' }
-#
-class Setup < Array
-	def update
-		add 'bundle install' if(File.exists?('Gemfile'))
-
-		Dir.glob('*.gemspec').each{|gemspec_file|
-			add "<%Gemspec.update('#{gemspec_file}')%>"
-		}
-
-		if(defined?(SVN_EXPORTS))
-			SVN_EXPORTS.each{|k,v|
-				if(!File.exists?("#{Command.dev_root}/dep/#{k}"))
-			      FileUtils.mkdir_p(File.dirname("#{Command.dev_root}/dep/#{k}")) if !File.exists?("#{Command.dev_root}/dep/#{k}")
-				  dest="#{Command.dev_root}/dep/#{k}"
-			      add "svn export #{v} #{Command.dev_root}/dep/#{k}" if !dest.include?("@")
-				  add "svn export #{v} #{Command.dev_root}/dep/#{k}@" if dest.include?("@")
-		        end
-			}
-		end
-
-		if(defined?(GIT_EXPORTS))
-			GIT_EXPORTS.each{|k,v|
-				directory = "#{Command.dev_root}/dep/#{k}"
-				if(!File.exists?(directory))
-					if(v.include?('@'))
-						puts `git clone #{v.split('@')[0]} #{directory}`
-						Dir.chdir(directory) do
-							puts `git reset --hard #{v.split('@')[1]}`
-						end
-					else
-						add "git clone #{v} #{directory}"
-					end
-				end
-			}
-		end
-	end
-end
-class Tag < Array
-	
-end
-#
-# nunit dlls may be specified with
-# NUNIT=FileList.new('**/*.Test.dll')
-#
-# for nunit dlls that must be run in x86 mode,
-# NUNIT_x86=FileList.new('**/*.x86.Test.dll')
-#
-
-
-class Test < Array
-	def update
-		add 'rspec' if File.exists?('spec')
-
-		if(defined?(NUNIT))
-			NUNIT.each{|nunit_dll|
-				add "\"#{Test.nunit_console}\" \"#{Rake.application.original_dir}\\#{nunit_dll}\" /xml:\"#{nunit_dll}.TestResults.xml\""
-			}
-		end
-
-		if(defined?(NUNIT_X86))
-			NUNIT_X86.each{|nunit_dll|
-				add "\"#{Test.nunit_console_x86}\" \"#{Rake.application.original_dir}\\#{nunit_dll}\" /xml:\"#{nunit_dll}.TestResults.xml\""
-			}
-		end
-
-		if(defined?(TESTS))
-			TEST.each{|t| add t}
-		end
-	end
-
-    @@nunit_console=''
-	def self.nunit_console
-		if(!File.exists?(@@nunit_console))
-			if(defined?(NUNIT_CONSOLE))
-				@@nunit_console = NUNIT_CONSOLE 
-			end
-			@@nunit_console = "C:\\Program Files (x86)\\NUnit 2.6.4\\bin\\nunit-console.exe" if(!File.exists?(@@nunit_console))
-			@@nunit_console = "C:\\Program Files (x86)\\NUnit 2.6.3\\bin\\nunit-console.exe" if(!File.exists?(@@nunit_console))
-		end
-		if(!File.exists?(@@nunit_console))
-			raise "unable to locate nunit-console.exe, assign NUNIT_CONSOLE to the correct location."
-		end
-		@@nunit_console
-	end
-
-	@@nunit_console_x86=''
-	def self.nunit_console_x86
-		if(!File.exists?(@@nunit_console_x86))
-			if(defined?(NUNIT_CONSOLE_X86))
-				@@nunit_console_x86 = NUNIT_CONSOLE_X86 
-			end
-			@@nunit_console_x86 = "C:\\Program Files (x86)\\NUnit 2.6.4\\bin\\nunit-console-x86.exe" if(!File.exists?(@@nunit_console_x86))
-			@@nunit_console_x86 = "C:\\Program Files (x86)\\NUnit 2.6.3\\bin\\nunit-console-x86.exe" if(!File.exists?(@@nunit_console_x86))
-		end
-		if(!File.exists?(@@nunit_console_x86))
-			raise "unable to locate nunit-console-x86.exe, assign NUNIT_CONSOLE_X86 to the correct location."
-		end
-		@@nunit_console_x86
-	end
-end
-
-NUNIT=FileList.new('bin/**/*.Test.dll')
-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
-
-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
-  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...
-        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)
-    else
-      exit_code=thread.value
-      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
-
-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
-class Update < Array
-	def update
-		self .add 'svn update' if File.exists?('.svn') && Internet.available?
-	end
-end
-class Upgrade < Array
-	def update
-		if(File.exists?('Gemfile'))
-		end
-	end
-end
-require 'json'
-require 'rake/clean'
-
-CLOBBER.include('*.gem')
-
-SOURCE=FileList.new('LICENSE','README','README.md',"Gemfile")
-SOURCE.include('*.{gitignore,yml,gemspec}')
-SOURCE.include('**/*.{rb}')
-SOURCE.include('**/*.{cs}')
-SOURCE.include('**/*.{c,h}')
-SOURCE.include('**/*.{cpp,hpp}')
-
-Dir.glob("#{File.dirname(__FILE__)}/commands/*.rb").each{|rb| 
-  require(rb)
-}
-
-
-COMMANDS=Commands.new
-MSBUILD=MSBuild.new