buzzware-buzzcore 0.2.2

data/lib/buzzcore/ftp_extra.rb

@@ -0,0 +1,188 @@
+require 'net/ftp'
+
+this_path = File.dirname(__FILE__)
+require this_path+'/misc_utils'
+
+String.class_eval do    
+  def bite!(aValue=$/,aString=self)
+    if aString[0,aValue.length] == aValue
+      aString[0,aValue.length] = ''
+      return aString
+    else
+      return aString
+    end
+  end
+
+  def bite(aValue=$/)
+    bite!(aValue,self.clone)
+  end  
+end
+
+
+module Net
+  class FTP
+		def FTP.with_connect(aHost,aUsername,aPassword,aDir=nil)
+			open(aHost,aUsername,aPassword) do |f|
+				f.passive = true
+				f.chdir(aDir) if aDir
+				yield f
+			end
+		end
+
+		def self.crack_file_line(aString)
+			values = aString.scan(/(.{10}).{28}(.{13})(.*)$/).flatten
+			{
+				:bits => values[0],
+				:date => values[1],
+				:name => values[2]
+			}
+		end
+
+		# BEGIN BUGFIXES
+
+    #
+    # Returns the size of the given (remote) filename.
+    #
+    def size(filename)
+      voidcmd("TYPE I")
+      resp = sendcmd("SIZE " + filename)
+			code = resp[0, 3]
+      if code != "213" && code != "220"
+	raise FTPReplyError, resp
+      end
+      return resp[3..-1].strip.to_i
+    end
+
+		# END BUGFIXES
+
+		def subdirs(aPath)
+			list.delete_if {|line| line[0,1]=='d'}
+			return list
+		end
+
+		def files(aPath)
+			list.delete_if {|line| line[0,1]!='d'}
+			return list
+		end
+
+		def expand_dir(aPath,aBase=nil)
+			return aPath if aPath=='/'
+			return MiscUtils::path_relative?(aPath) ? File.expand_path(aPath,aBase || pwd()) : File.expand_path(aPath)
+		end
+
+		def dir_exists?(aPath)
+			aPath = expand_dir(aPath)
+			return true if aPath=='/'
+			dirname = File.basename(aPath)
+			parent = MiscUtils.path_parent(aPath)
+			dirname!='' && nlst(parent).include?(dirname)
+		end
+
+		def file_exists?(aPath)
+			aPath = expand_dir(aPath)
+			filename = File.basename(aPath)
+			parent = File.dirname(aPath)
+			filename!='' && nlst(parent).include?(filename)
+		end
+
+		def filelist_recurse(aPath=nil,aResult=nil,&block)
+			#puts "filelist_recurse: #{aPath.to_s}  #{aResult.inspect}"
+			orig_dir = !aResult ? pwd : nil	# assigned if called at top with aResult=nil
+			aResult ||= []
+			aPath ||= ''
+			chdir(aPath)
+			list('*').each do |f| 
+				is_dir = f[0,1]=='d'
+				details = FTP::crack_file_line(f)
+				full = File.join(aPath,details[:name])
+				if !block_given? || yield(full)
+					if is_dir
+						filelist_recurse(full,aResult)
+					else
+						aResult << full
+					end
+				end
+			end
+			chdir(orig_dir) if orig_dir
+			return aResult
+		end
+
+		def get_files(aRemoteDir,aLocalDir,aFiles,aOptions=nil)
+			aOptions = {:overwrite => true}.merge(aOptions || {})
+			aFiles.each do |r|
+				relative = r.bite(MiscUtils::append_slash(aRemoteDir))
+				d = File.join(aLocalDir,relative)
+				puts "getting #{relative}"
+				getbinaryfile(r, d) unless !aOptions[:overwrite] && File.exists?(d)
+			end
+		end
+
+		def get_dir(aRemoteDir,aLocalDir,aOptions=nil,&block)
+			remote_files = block_given? ? filelist_recurse(aRemoteDir,nil,&block) : filelist_recurse(aRemoteDir)
+			get_files(aRemoteDir,aLocalDir,remote_files,aOptions)
+		end
+
+		def highest_existing(aPath)
+			sep = MiscUtils::sniff_seperator(aPath)
+			path = MiscUtils::path_parts(File.expand_path(aPath)) if aPath.is_a?(String)
+			# now assume path is an Array
+			depth = path.length-1
+			depth.downto(0) do |i|	# from full path up to root
+				curr = (path[0]=='' && i==0) ? '/' : path[0..i].join(sep)
+				return curr if dir_exists?(curr)
+			end
+			return sep	# root
+		end
+
+		def ensure_dir(aPath,aThorough=false)
+			if !aThorough
+				mkdir(aPath) unless dir_exists?(aPath)
+			else
+				return if dir_exists?(aPath)
+				path = expand_dir(aPath)
+				hi_existing = highest_existing(path)
+				# path to create under hi_existing
+				to_create = MiscUtils::path_debase(path,hi_existing)
+				parts = MiscUtils::path_parts(to_create)
+				curr_path = hi_existing
+				
+				parts.each do |part|
+					curr_path = File.join(curr_path,part)
+					mkdir(curr_path)
+				end
+			end
+		end
+
+		def put_files(aLocalDir,aRemoteDir,aFiles,aOptions=nil)
+			aOptions = {:overwrite => true}.merge(aOptions || {})
+
+			# convert all files to relative to aLocalDir
+			aFiles = aFiles.map { |f| f.bite(MiscUtils::append_slash(aLocalDir)) }.sort
+			
+			filelist = nil
+			this_dir = last_dir = nil
+			aFiles.each do |r|
+				d = File.expand_path(r,aRemoteDir)
+				this_dir = File.dirname(d)
+				if this_dir!=last_dir
+					ensure_dir(this_dir,true)
+					filelist = files(this_dir) - ['.','..','.svn']
+				end
+				if aOptions[:overwrite] || !filelist.member?(File.basename(r))
+					puts "Putting #{r}"
+					putbinaryfile(File.expand_path(r,aLocalDir), d)
+				else
+					puts "Skipping #{relative}"
+				end
+				last_dir = this_dir
+			end
+		end
+
+		def put_dir(aLocalDir,aRemoteDir,&block)
+			local_files = block_given? ? MiscUtils::recursive_file_list(aLocalDir,true,&block) : MiscUtils::recursive_file_list(aLocalDir) 
+			put_files(aLocalDir,aRemoteDir,local_files)
+		end
+
+	end
+end
+

data/lib/buzzcore/logging.rb

@@ -0,0 +1,159 @@
+require 'logger'
+require 'buzzcore/misc_utils'
+
+class Logger
+  attr_reader :logdev
+end
+
+module LogUtils
+
+	# eg.
+	# {
+	# 	'destination' => 'STDERR|STDOUT|FILE',
+	# 	'filename' => '/path/to/file.ext',
+	# 	'level' => 'DEBUG|INFO|...',
+	#
+	# 	'age' = 'daily|weekly|monthly',
+	# 	OR
+	# 	'max_files' => 3,
+	# 	'max_bytes' => 1024000
+	# }
+	def self.create_logger_from_config(aConfigHash)
+		if not aConfigHash
+			result = Logger.new(STDERR)
+			result.level = Logger::INFO
+			return result
+		end
+	
+		result = nil
+		case aConfigHash['destination']
+			when 'STDERR' then
+				result = Logger.new(STDERR)
+			when 'STDOUT' then
+				result = Logger.new(STDOUT)
+			when 'FILE' then
+        result = aConfigHash['age'] ?
+          Logger.new(aConfigHash['filename'],aConfigHash['age']) :
+          Logger.new(
+            aConfigHash['filename'],
+						(aConfigHash['max_files'] || 3).to_i,
+						(aConfigHash['max_bytes'] || 1024000).to_i
+					)
+			else
+				result = Logger.new(STDERR)
+		end
+    puts valstr = "Logger::#{(aConfigHash['level'] || 'INFO').upcase}"
+		result.level = eval(valstr)
+		return result
+	end
+
+	# use this to trunc a log file to 0 bytes
+	def self.trunc(aFilename)
+		f = File.open(aFilename, "w")
+		f.close
+	end
+
+  class ReportFormatter < Logger::Formatter
+    def call(severity, time, progname, msg)
+     "|%s %1s %s\n" % [(time.strftime('%H%M%S.')<<"%03d" % (time.usec/1000)),severity[0..0],msg2str(msg)]
+    end
+  end
+
+  class Reporter < Logger
+    def initialize(logdev)
+      super(logdev)
+    end
+
+  end
+
+  def self.create_reporter(aFilename=nil)
+    aFilename ||= MiscUtils::temp_file()
+    result = Logger.new(aFilename)
+    result.formatter = ReportFormatter.new
+    result
+  end
+end
+
+
+
+class MultiLogger < Logger
+
+  attr_reader :loggers
+
+  def initialize(aLoggers)
+    @loggers = aLoggers.is_a?(Array) ? aLoggers : [aLoggers]
+  end
+
+  def add(severity, message = nil, progname = nil, &block)
+		return true if !@loggers
+		severity ||= UNKNOWN
+    @loggers.each do |lr|
+      block_given? ? lr.add(severity,message,progname,&block) : lr.add(severity,message,progname)
+    end
+    true
+  end
+  alias log add
+
+  def <<(msg)
+    @loggers.each do |lr|
+      lr << msg
+    end
+  end
+
+  def close
+    @loggers.each do |lr|
+      lr.close
+    end
+  end
+
+end
+
+#DEBUG D
+#INFO
+#WARN ?
+#ERROR !
+#FATAL F
+#UNKNOWN U
+
+# Logger that mostly works like a STDOUT logger, except that warnings and above get sent to STDERR instead
+class ConsoleLogger < Logger
+
+  class ReportFormatter < Logger::Formatter
+    def call(severity, time, progname, msg)
+     msg2str(msg)+"\n"
+    end
+  end
+
+  def initialize(aErrLevel = Severity::WARN)
+		super(STDOUT)
+    self.formatter = ReportFormatter.new
+		self.level = Severity::INFO
+		self << "\n"
+		@err_logger = Logger.new(STDERR)
+		@err_level = aErrLevel
+		@err_logger.formatter = ReportFormatter.new
+  end
+
+	alias_method :orig_add, :add
+  def add(severity, message = nil, progname = nil, &block)	
+		if severity >= @err_level
+			block_given? ? @err_logger.add(severity,message,progname,&block) : @err_logger.add(severity,message,progname)
+		else
+			block_given? ? orig_add(severity,message,progname,&block) : orig_add(severity,message,progname)
+		end
+  end
+  alias log add
+
+  #
+  # Close the logging device.
+  #
+  def close
+		begin
+			@logdev.close if @logdev
+		ensure
+			@err_logger.close
+		end
+  end
+	
+end
+

data/lib/buzzcore/misc_utils.rb

@@ -0,0 +1,382 @@
+require 'tmpdir'
+require 'logger'
+require 'pathname'
+
+require 'buzzcore/logging'
+
+module MiscUtils
+
+	def self.logger
+		@logger || @logger = Logger.new(STDERR)
+	end
+
+	# applies the given block to key/value pairs included/excluded by the given parameters
+	# aSource must be a hash, and may contain hashes which will be recursively processed.
+	# aInclude/aExclude may be nil, an array of selected keys, or a hash containing arrays of keys for inner hashes of aSource
+	# When aInclude/aExclude are a hash, non-hash source values may be selected by passing a value of true. Hash source values 
+	# will be selected as a whole (all keys) when true is passed.
+	# input = { 'a' => 1, 'b' => {'x' => 9, 'y' => 8}, 'c' => 3 }
+	# filter_multilevel_hash(input,['a','b'],{'b'=>['y']}) {|h,k,v| h[k] = true}
+	# input now = { 'a' => true, 'b' => {'x' => true, 'y' => 8}, 'c' => 3 }
+	def self.filter_multilevel_hash(aSource,aInclude=nil,aExclude=nil,&block)
+		aSource.each do |key,value|
+			next if aInclude.is_a?(Array) and !aInclude.include?(key)		# skip if not in aInclude array
+			next if aExclude.is_a?(Array) and aExclude.include?(key)		# skip if in aExclude array
+			next if aExclude.is_a?(Hash) and aExclude[key]==true				# skip if in aExclude hash with value=true
+			next if aInclude.is_a?(Hash) and !aInclude.include?(key)		# skip if not in aInclude hash at all
+			if value.is_a?(Hash)																				# value is hash so recursively apply filter 
+				filter_multilevel_hash(
+					value,
+					aInclude.is_a?(Hash) && (f = aInclude[key]) ? f : nil,	# pass include array if provided for key
+					aExclude.is_a?(Hash) && (f = aExclude[key]) ? f : nil,	# pass exclude array if provided for key
+					&block
+				)
+			else
+				yield(aSource,key,value)
+			end
+		end
+	end
+
+	# returns output string if succesful, or integer return code if not, or nil
+	def self.execute(aCommand,aWorkingDir=nil,aTimeout=nil,aTimeoutClass=nil)
+		return nil unless !aWorkingDir || File.exists?(aWorkingDir)
+		begin
+			orig_wd = Dir.getwd
+			pipe = nil
+			result = nil
+			Dir.chdir(aWorkingDir) if aWorkingDir
+			Timeout.timeout(aTimeout,aTimeoutClass || Timeout::Error) do	# nil aTimeout will not time out
+				pipe = IO.popen(aCommand)
+				logger.debug "command PID:"+pipe.pid.to_s
+				result = pipe.read
+			end
+		ensure
+			pipe.close if pipe
+			Dir.chdir(orig_wd)
+		end
+		return result
+	end
+
+	def self.execute_string(aCmdString,aWorkingDir=nil)
+		result = nil
+		begin
+			orig_dir = Dir.pwd
+			Dir.chdir(aWorkingDir) if aWorkingDir
+			result = `#{aCmdString}`
+		ensure
+			Dir.chdir(orig_dir) if aWorkingDir
+		end 
+		return result
+	end
+
+	def self.temp_file(aExt=nil,aDir=nil)
+		aExt ||= '.tmp'
+		File.expand_path(("%08X" % rand(0x3FFFFFFF)) + aExt, aDir||Dir.tmpdir)
+	end
+	
+	def self.make_temp_file(aName=nil,aDir=nil,aContent=nil)
+		filename = aName ? File.expand_path(aName,aDir || Dir.tmpdir) : temp_file(nil,aDir)
+    FileUtils.mkdir_p(File.dirname(filename))
+		aContent ||= "content of "+filename
+		string_to_file(aContent,filename)
+    filename
+	end
+
+	def self.make_temp_dir(aPrefix='')
+		new_dir = nil
+    begin
+			new_dir = File.join(Dir.tmpdir,aPrefix+("%08X" % rand(0x3FFFFFFF)))
+		end until new_dir && !File.exists?(new_dir)
+		Dir.mkdir new_dir
+		return new_dir
+	end
+	
+	def self.mkdir?(aPath,aPermissions)
+		if File.exists?(aPath)
+			File.chmod(aPermissions, aPath)
+		else
+			Dir.mkdir(aPath, aPermissions)
+    end
+  end
+
+	def self.string_to_file(aString,aFilename)
+		File.open(aFilename,'wb') {|file| file.puts aString }
+	end
+
+	def self.string_from_file(aFilename)
+		result = nil
+		File.open(aFilename, "rb") { |f| result = f.read }
+		return result && result[0..-2]  # quick hack to stop returning false \n at end
+	end
+
+	def self.sniff_seperator(aPath)
+		result = 0.upto(aPath.length-1) do |i|
+			char = aPath[i,1]
+			break char if char=='\\' || char=='/'
+		end
+		result = File::SEPARATOR if result==0
+		return result
+	end
+
+	def self.append_slash(aPath,aSep=nil)
+		aSep = sniff_seperator(aPath) unless aSep
+		last_char = aPath[-1,1]
+		aPath += aSep unless last_char=='\\' || last_char=='/'
+		return aPath
+	end
+
+	def self.remove_slash(aPath)
+		last_char = aPath[-1,1]
+		aPath = aPath[0..-2] if last_char=='\\' || last_char=='/'
+		return aPath
+	end
+
+	# Remove base dir from given path. Result will be relative to base dir and not have a leading or trailing slash
+	#'/a/b/c','/a' = 'b/c'
+	#'/a/b/c','/' = 'a/b/c'
+	#'/','/' = ''
+	def self.path_debase(aPath,aBase)
+		aBase = MiscUtils::append_slash(aBase)
+		aPath = MiscUtils::remove_slash(aPath) unless aPath=='/'
+		aPath[0,aBase.length]==aBase ? aPath[aBase.length,aPath.length-aBase.length] : aPath
+	end
+	
+	def self.path_rebase(aPath,aOldBase,aNewBase)
+		rel_path = path_debase(aPath,aOldBase)
+		append_slash(aNewBase)+rel_path
+	end
+	
+	def self.path_combine(aBasePath,aPath)
+		return aBasePath if !aPath
+		return aPath if !aBasePath
+		return path_relative?(aPath) ? File.join(aBasePath,aPath) : aPath	
+	end
+
+	def self.path_parent(aPath)
+		MiscUtils.append_slash(File.dirname(MiscUtils.remove_slash(File.expand_path(aPath))))
+	end
+
+	def self.simple_dir_name(aPath)
+		File.basename(remove_slash(aPath))
+	end
+
+	def self.path_parts(aPath)
+		sep = sniff_seperator(aPath)
+		aPath.split(sep)
+	end
+
+	def self.file_extension(aFile,aExtended=true)
+		f = File.basename(aFile)
+		dot = aExtended ? f.index('.') : f.rindex('.')
+		return dot ? f[dot+1..-1] : f
+	end
+
+	def self.file_no_extension(aFile,aExtended=true)
+		ext = file_extension(aFile,aExtended)
+		return aFile.chomp('.'+ext)
+	end
+
+	def self.file_change_ext(aFile,aExt,aExtend=false)
+		file_no_extension(aFile,false)+(aExtend ? '.'+aExt+'.'+file_extension(aFile,false) : '.'+aExt)
+	end
+
+	def self.platform
+		RUBY_PLATFORM.scan(/-(.+)$/).flatten.first
+	end
+
+	def self.windows_path(aPath)
+		aPath.gsub('/','\\')
+	end
+
+	def self.ruby_path(aPath)
+		aPath.gsub('\\','/')
+	end
+
+	def self.is_uri?(aString)
+		/^[a-zA-Z0-9+_]+\:\/\// =~ aString ? true : false
+	end
+
+	def self.native_path(aPath)
+		is_windows? ? windows_path(aPath) : ruby_path(aPath)
+	end
+
+	def self.path_relative?(aPath)
+		return false if aPath[0,1]=='/'
+		return false if aPath =~ /^[a-zA-Z]:/
+		return true
+	end
+
+	def self.path_absolute?(aPath)
+		!path_relative(aPath)
+	end
+
+	def self.is_windows?
+		platform=='mswin32'
+	end
+
+	# takes a path and combines it with a root path (which defaults to Dir.pwd) unless it is absolute
+	# the final result is then expanded
+	def self.canonize_path(aPath,aRootPath=nil)
+		path = Pathname.new(aPath)
+		path = Pathname.new(aRootPath || Dir.pwd)+path if path.relative?
+		File.expand_path(path)
+	end
+	
+	def self.get_files(aArray,aPath,aFullPath=true,aRootPath=nil,&block)
+		#puts "get_files: aPath='#{aPath}'"
+		if aRootPath
+			abssrcpath = path_combine(aRootPath,aPath)
+		else
+			abssrcpath = aRootPath = aPath
+			aPath = nil
+		end
+		return aArray if !File.exists?(abssrcpath)
+		#abssrcpath is real path to query
+		#aRootPath is highest level path
+		#aPath is current path relative to aRootPath
+		Dir.new(abssrcpath).to_a.each do |file|
+			next if ['.','..'].include? file
+			fullpath = File.join(abssrcpath,file)
+			resultpath = aFullPath ? fullpath : path_combine(aPath,file)
+			if !block_given? || yield(resultpath)
+				if FileTest.directory?(fullpath)
+					block_given? ? get_files(aArray,path_combine(aPath,file),aFullPath,aRootPath,&block) : get_files(aArray,path_combine(aPath,file),aFullPath,aRootPath)
+				else
+					aArray << resultpath
+				end
+			end
+		end
+		return aArray
+	end
+
+	def self.recursive_file_list(aPath,aFullPath=true,&block)
+		block_given? ? get_files([],aPath,aFullPath,nil,&block) : get_files([],aPath,aFullPath)
+  end
+	
+	# returns true if aPath1 and aPath2 are the same path (doesn't query file system)
+	# both must be absolute or both relative
+	def self.path_same(aPath1,aPath2)
+		return nil unless path_relative?(aPath1) == path_relative?(aPath2)
+		remove_slash(aPath1) == remove_slash(aPath2)
+	end
+	
+	# returns true if aPath is under aPathParent
+	# both must be absolute or both relative
+	def self.path_ancestor(aPathParent,aPath)
+		return nil unless path_relative?(aPathParent) == path_relative?(aPath)
+		aPath.index(append_slash(aPathParent))==0
+	end
+
+	# returns the lowest path containing all files (assumes aFiles contains only absolute paths)
+	def self.file_list_ancestor(aFiles)
+    files = aFiles.is_a?(Hash) ? aFiles.keys : aFiles
+		result = File.dirname(files.first)
+		files.each do |fp|
+			filedir = File.dirname(fp)
+			while path_same(result,filedir)==false && path_ancestor(result,filedir)==false
+				result = path_parent(result)
+			end
+		end		
+		result
+	end
+
+	def self.path_match(aPath,aPatterns)
+		aPatterns = [aPatterns] unless aPatterns.is_a? Array
+		aPatterns.any? do |pat|
+			case pat
+				when String then aPath[0,pat.length] == pat
+				when Regexp then aPath =~ pat
+				else false
+			end
+		end
+	end
+
+
+	# takes a hash and returns a single closed tag containing the hash pairs as attributes, correctly encoded
+	def self.hash_to_xml_tag(aName,aHash)
+		atts = ''
+		aHash.each do |k,v| 
+			atts += ' ' + k.to_s + "=\"#{v.to_s.to_xs}\""
+		end
+		"<#{aName}#{atts}/>"		
+	end
+
+	def self.filelist_from_patterns(aPatterns,aBasePath)
+		return [] unless aPatterns
+		aPatterns = [aPatterns] unless aPatterns.is_a? Array
+
+		aPatterns.map do |fp|
+			fp = File.expand_path(fp,aBasePath)		# relative to rails root
+			fp = FileList[fp] if fp['*'] || fp['?']
+			fp
+		end.flatten
+	end
+
+#:host
+#:port
+#:helodomain
+#:user
+#:password
+#:from
+#:from_alias
+#:to
+#:to_alias
+#:subject
+#:message
+#:auth : 'plain', 'login', 'cram_md5'
+
+	# send an email via an SMTP server
+  def self.send_email(aArgs)
+    msg = <<END_OF_MESSAGE
+From: #{aArgs[:from_alias]} <#{aArgs[:from]}>
+To: #{aArgs[:to_alias]} <#{aArgs[:to]}>
+Subject: #{aArgs[:subject]}
+
+#{aArgs[:message]}
+END_OF_MESSAGE
+
+    Net::SMTP.start(
+			aArgs[:host],
+			aArgs[:port],
+			aArgs[:helodomain],
+			aArgs[:user],
+			aArgs[:password],
+			aArgs[:auth]
+		) do |smtp|
+      smtp.send_message msg, aArgs[:from], aArgs[:to]
+    end
+  end
+
+end
+
+# include this at the top of a class to protect it from baddies.
+# eg. 
+# + nearly all ancestor public_instance_methods will be hidden
+# + inspect will only return the class name
+# + methods will return public methods
+module SecureThisClass
+	def self.hack(aClass,aOptions={})
+		include_actions = (aOptions[:include] || aClass.public_instance_methods.clone)
+		exclude_actions = ['class','public_methods'] | (aOptions[:exclude] || [])
+		actions_to_hide = include_actions-exclude_actions
+		aClass.class_eval do
+			actions_to_hide.each { |m| protected m.to_sym }
+
+			def inspect
+				return self.class.name
+			end
+
+			def methods
+				public_methods
+			end
+		end
+	end
+end
+
+
+module ::Kernel
+	def secure_class(aOptions={})
+		SecureThisClass::hack(self,aOptions)
+	end
+end
+