dev 2.0.46 → 2.0.47

data/lib/dev_commands.rb

@@ -1,3 +1,1066 @@
+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_relative('msbuild.rb')
+#require_relative('gemspec.rb')
+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
+#require_relative('internet.rb')
+class Push < Array
+	def update
+		if(File.exists?('.git') && `git config --list`.include?('user.name='))
+			add 'git config --global push.default simple'
+			self <<  'git push' 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
+	end
+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
+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
+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'