dev 2.0.41 → 2.0.42

data/lib/msbuild.rb

@@ -0,0 +1,70 @@
+# 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
+
+    def self.get_build_commands sln_filename
+      build_commands=nil
+      vs_version=MSBuild.get_vs_version(sln_filename)
+      if(MSBuild.has_version?(vs_version))
+        MSBuild.get_configurations(sln_filename).each{ |configuration|
+          MSBuild.get_platforms(sln_filename).each{|platform|
+            build_commands=Array.new if build_commands.nil?
+            build_commands << "\"#{MSBuild.get_version(vs_version)}\" \"#{sln_filename}\" /nologo /p:Configuration=#{configuration} /p:Platform=\"#{platform}\""
+          }
+        }
+      end
+      build_commands
+    end
+end
+

data/lib/project.rb

@@ -0,0 +1,66 @@
+require 'json'
+#require 'dev_commands'
+
+class Project < Hash
+attr_accessor :filename
+	def initialize value=''
+		@filename=''
+		self[:url]=''
+		self[:url] = value if value.is_a?(String)
+		if(value.is_a?(Hash))
+			value.each{|k,v|self[k]=v}
+		end
+	end
+
+    def name
+    	self[:name]
+    end
+    
+	def get_latest_unique_id 
+		'51ed9c9d45ba3979c808740d75ba1831c85aff5d'
+	end
+
+	def wrk_dir
+		"#{Environment.dev_root}/wrk/#{self.name}"
+	end
+
+	def pull
+		if(File.exists?(wrk_dir) && File.exists?("#{wrk_dir}/.git"))
+			Dir.chdir(wrk_dir) do
+				puts "git pull (#{wrk_dir})"
+				puts `git pull`
+			end
+		end
+	end
+
+	def clone
+		if(!File.exists?(wrk_dir) && self[:url].include?('.git'))
+			puts "cloning #{self[:url]} to #{self.wrk_dir}"
+			puts `git clone #{self[:url]} #{self.wrk_dir}`
+		end
+	end
+
+	def checkout
+		if(!File.exists?(wrk_dir) && self[:url].include?('svn'))
+			puts "checkout #{self.url} to #{self.wrk_dir}"
+			puts `svn checkout #{self.url} #{self.wrk_dir}`
+		end
+	end
+
+	def rake
+		if(!File.exists?(self.wrk_dir))
+			clone
+			checkout
+		end
+		if(File.exists?(self.wrk_dir))
+			Dir.chdir(self.wrk_dir) do
+				rake = Command.new({ :input => 'rake', :timeout => 300, :ignore_failure => true })
+				#puts "rake (#{self.wrk_dir})"
+				#puts `rake`
+				rake.execute
+				puts rake.summary
+			end
+		end
+	end
+end
+

data/lib/projects.rb

@@ -0,0 +1,67 @@
+require 'json'
+require 'rake'
+#require 'dev_git'
+#require 'dev_svn'
+#require 'dev_msbuild'
+#require 'dev_environment'
+require_relative 'project.rb'
+
+class Projects < Hash
+	attr_accessor :filename
+
+	def initialize
+		@filename=''
+	end
+
+    def update
+    	self.each{|k,v|
+    		self[k]=Project.new(v) if(v.is_a?(String))
+    		self[k]=Project.new(v) if(!v.is_a?(Project) && v.is_a?(Hash))
+    		self[k][:name]=k
+    		#self[k].update if self[k].respond_to?("update".to_sym)
+    	}
+    end
+
+	def save filename=''
+		@filename=filename if !filename.nil? && filename.length > 0
+		File.open(@filename,'w'){|f|f.write(JSON.pretty_generate(self))} if @filename.length > 0
+	end
+
+	def open filename=''
+		@filename=filename if filename.length > 0
+		JSON.parse(IO.read(@filename)).each{|k,v| self[k]=v}
+		update
+	end
+
+	def self.user_projects_filename
+		FileUtils.mkdir("#{Environment.dev_root}/data") if(!File.exists?("#{Environment.dev_root}/data"))
+		"#{Environment.dev_root}/data/PROJECTS.json"
+	end
+
+	def self.current
+		project=nil
+		url=Git.remote_origin
+		url=Svn.url if url.length==0
+		if(Rake.application.original_dir.include?('/wrk/') &&
+			   url.length > 0)
+			project=Project.new(url)
+			name=Rake.application.original_dir.gsub("#{Environment.dev_root}/wrk/",'')
+			project[:name] = name if(name.length>0 && !name.include?(Environment.dev_root))
+			if(defined?(PROJECTS))
+				PROJECTS[name]=project if(!PROJECTS.has_key?(name))
+				project.each{|k,v|PROJECTS[name][k]=v}
+				PROJECTS.save
+			else
+				project[:name]=name
+			end
+		end			
+		project
+	end
+
+	def pull
+		self.each{|k,v| v.pull if v.respond_to?("pull".to_sym)}
+	end
+	def rake
+		self.each{|k,v| v.rake if v.respond_to?("rake".to_sym)}
+	end
+end

data/lib/publish.rb

@@ -0,0 +1,21 @@
+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

data/lib/pull.rb

@@ -0,0 +1,12 @@
+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

data/lib/push.rb

@@ -0,0 +1,9 @@
+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

data/lib/setup.rb

@@ -0,0 +1,25 @@
+#
+# 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

data/lib/svn.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+require 'tmpdir'
+class Svn
+
+	def self.latest_revision
+	    if(Dir.exists?(".svn"))
+	      `svn update`
+		  `svn info`.scan(/Last Changed Rev: ([\d]+)/).each{|m|
+		    return m.first.to_s
+		  }
+		end
+		"0"
+	end
+
+	def self.url
+		if(Dir.exists?(".svn"))
+		  `svn info`.scan(/URL: ([:\/\.\-\d\w]+)/).each{|m|
+		    return m.first.to_s
+		  }
+		end
+		''
+	end
+
+	def self.export url, destination
+		if(!File.exists?(destination.chomp('@')))
+			`svn export #{url} #{destination}`
+		end
+	end
+
+	def self.has_changes? directory=''
+        directory=Dir.pwd if directory.length==0
+        Dir.chdir(directory) do
+            if(File.exists?('.svn'))
+                return true if `svn status`.scan(/^[MA]/).length>0
+            end
+        end
+        false
+    end
+
+	# publish a directory to a new subversion path
+	# source_dir is the directory with the files to be published
+	# destination is the new subversion path URL
+	# source_glob is a string or array of glob directives to specify files in source_dir to be publish
+	# source_glob defaults to '**/*' to publish all files in the source_dir
+	def self.publish source_dir, destination, source_glob='**/*'
+
+		output = "\n"
+		raise "Svn.publish: destination #{destination} already exists" if(`svn info #{destination} 2>&1`.include?('Revision:'))
+
+		# create subversion directory
+		output = output + "svn mkdir #{destination} --parents --message mkdir_for_publishing"
+		if(!`svn mkdir #{destination} --parents --message mkdir_for_publishing`.include?('Committed'))
+			raise "failure 'svn mkdir #{destination} --parents --message mkdir_for_publishing'"
+		end
+
+		files=nil
+		Dir.chdir(source_dir) do
+			files=FileList.new(source_glob).to_a
+		end
+		output = output + "\nfiles: #{files}.to_s"
+
+		pwd=Dir.pwd
+		Dir.mktmpdir{|dir|
+
+			# checkout new subversion directory
+			output = output + "\nsvn checkout #{destination} #{dir}/to_publish_checkout"
+			if(!`svn checkout #{destination} #{dir}/to_publish_checkout`.include?('Checked out'))
+				raise "failure 'svn checkout #{destination} #{dir}/to_publish_checkout'"
+			end
+
+			# copy files into the checkout out subversion directory to_publish
+			raise "#{dir}/to_publish_checkout does not exist" if(!File.exists?("#{dir}/to_publish_checkout"))
+			Dir.chdir("#{dir}/to_publish_checkout") do
+				File.open('add.txt','w'){|add_file|
+
+					files.each{|f|
+						fdir=File.dirname(f)
+						FileUtils.mkdir_p(fdir) if(fdir.length > 0 && !File.exists?(fdir))
+						FileUtils.cp("#{source_dir}/#{f}","#{f}")
+						add_file.puts f
+					}
+					add_file.close
+				}
+
+				output = output + "\nsvn add --parents --targets add.txt 2>&1"
+                `svn add --parents --targets add.txt 2>&1`
+				commit_output = `svn commit -m"add" 2>&1`
+				output = output + "\n#{commit_output}"
+				if(!commit_output.include?("Committed"))
+					raise "failure 'svn commit -m'added files''"
+				end
+			end
+			
+			#begin
+			FileUtils.rm_r "#{dir}/to_publish_checkout"
+			output
+		}
+	end
+end

data/lib/tasks.rb

@@ -0,0 +1,82 @@
+require 'rake'
+require 'rake/clean'
+
+class Tasks
+	#@@commands=nil
+	@@quiet=false
+
+    def self.quiet
+    	@@quiet
+    end
+
+    def self.execute value
+	  if(value.respond_to?(:execute))
+	    value.update if value.respond_to?(:update)
+	    value.execute
+	  else
+	    if(value.is_a?(String))
+	      puts `#{value}`
+	    else
+	      if(value.is_a?(Array))
+	        value.each{|e| execute(e)}
+	      end
+	    end
+	    end
+	end
+
+	def self.execute_task task
+		if(defined?(COMMANDS))
+			if(COMMANDS.has_key?(task))
+				puts "[:#{task}]" if(!Tasks.quiet)
+		  		Tasks.execute(COMMANDS[task])
+		    end
+		end
+	end
+end
+
+desc 'performs a git pull'
+task :pull do Tasks.execute_task :pull; end
+
+desc 'performs svn update'
+task :update do Tasks.execute_task :update; end
+
+desc 'performs setup commands'
+task :setup do Tasks.execute_task :setup;end
+
+desc 'performs build commands'
+task :build do Tasks.execute_task :build;end
+
+desc 'performs test commands'
+task :test => [:build] do Tasks.execute_task :test;end
+
+desc 'performs analyze commands'
+task :analyze do Tasks.execute_task :analyze;end
+
+desc 'performs documentation commands'
+task :doc do Tasks.execute_task :doc;end
+
+desc 'performs clean commands'
+task :clean do Tasks.execute_task :clean;end
+
+desc 'performs publish commands'
+task :publish do Tasks.execute_task :publish; end
+
+desc 'performs clobber commands'
+task :clobber => [:clean] do Tasks.execute_task :clobber;end
+
+desc 'adds source files to git or subversion'
+task :add do Tasks.execute_task :add;end
+
+desc 'commits source files to git or subversion'
+task :commit do Tasks.execute_task :commit;end
+
+desc 'performs a git push'
+task :push do Tasks.execute_task :push;end
+
+desc 'displays project info'
+task :info do
+	if(defined?(INFO) && INFO.length > 0)
+		puts "[:info]" if(!Tasks.quiet)
+		INFO.each{|l|puts l}
+	end
+end

data/lib/test.rb

@@ -0,0 +1,58 @@
+#
+# 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

data/lib/text.rb

@@ -0,0 +1,16 @@
+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

data/lib/timeout.rb

@@ -0,0 +1,81 @@
+############################################################################
+# 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
+

data/lib/timer.rb

@@ -0,0 +1,41 @@
+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

data/lib/update.rb

@@ -0,0 +1,6 @@
+require_relative('internet.rb')
+class Update < Array
+	def update
+		self .add 'svn update' if File.exists?('.svn') && Internet.available?
+	end
+end

data/lib/upgrade.rb

@@ -0,0 +1,6 @@
+class Upgrade < Array
+	def update
+		if(File.exists?('Gemfile'))
+		end
+	end
+end