buzzcore 0.2.5

data/lib/buzzcore/database_utils.rb

@@ -0,0 +1,86 @@
+require 'buzzcore/shell_extras'
+
+module DatabaseUtils
+  def self.execute_sql_file(filename,aUser=nil,aPassword=nil)
+    conf = ActiveRecord::Base.configurations[RAILS_ENV]
+    pw = aPassword || conf['password'].to_s || ''
+    user = aUser || conf['username'].to_s || ''
+    cmd_line = "mysql -h #{conf['host']} -D #{conf['database']} #{user.empty? ? '' : '-u '+user} #{pw.empty? ? '' : '-p'+pw} <#{filename}"
+    if !system(cmd_line)
+      raise Exception, "Error executing "+cmd_line
+    end
+  end
+	
+	## http://www.cyberciti.biz/faq/how-do-i-empty-mysql-database/
+	#
+	#
+	## drop all tables :
+	##			mysqldump -uusername -ppassword -hhost \
+	##--add-drop-table --no-data database | grep ^DROP | \
+	##mysql -uusername -ppassword -hhost database
+	#
+
+	def self.database_exists(aDbDetails,aDatabase=nil)
+		aDbDetails[:database] = aDatabase if aDatabase
+		return false if !aDbDetails[:database]
+		response = POpen4::shell("mysql -u #{aDbDetails[:username]} -p#{aDbDetails[:password]} -e 'use #{aDbDetails[:database]}'") do |r|
+			if r[:stderr] && r[:stderr].index("ERROR 1049 ")==0		# Unknown database
+				r[:exitcode] = 0 
+				return false
+			end
+		end
+		return (response && response[:exitcode]==0)
+	end
+
+	def self.clear_database(aDbDetails)
+		response = POpen4::shell("mysqldump -u #{aDbDetails[:username]} -p#{aDbDetails[:password]} --add-drop-table --no-data #{aDbDetails[:database]} | grep ^DROP | mysql -u #{aDbDetails[:username]} -p#{aDbDetails[:password]} #{aDbDetails[:database]}")
+	end
+
+	def self.create_database(aDbDetails,aDatabase=nil)
+		aDbDetails[:database] = aDatabase if aDatabase
+		return false if !aDbDetails[:database]
+		response = POpen4::shell("mysqladmin -u #{aDbDetails[:username]} -p#{aDbDetails[:password]} create #{aDbDetails[:database]}")
+	end
+
+	def self.ensure_empty_database(aDbDetails,aDatabase=nil)
+		aDbDetails[:database] = aDatabase if aDatabase
+		if database_exists(aDbDetails)
+			clear_database(aDbDetails)
+		else
+			create_database(aDbDetails)
+		end
+	end
+	
+	def self.load_database(aDbDetails,aSqlFile)
+		ensure_empty_database(aDbDetails)
+		response = POpen4::shell("mysql -u #{aDbDetails[:username]} -p#{aDbDetails[:password]} #{aDbDetails[:database]} < #{aSqlFile}")
+	end
+
+	def self.save_database(aDbDetails,aSqlFile)
+		response = POpen4::shell("mysqldump --user=#{aDbDetails[:username]} --password=#{aDbDetails[:password]} --skip-extended-insert #{aDbDetails[:database]} > #{aSqlFile}")
+	end
+
+	#
+	## eg. rake metas:spree:data:load from=/tmp/spree_data.tgz to=mysql:fresco_server_d:root:password
+	#desc 'load spree data from a file'
+	#task :load do
+	#	from = ENV['from']
+	#	to=ENV['to']
+	#	db_server,db,user,password = to.split(':')
+	#	tmpdir = make_temp_dir('metas')
+	#	cmd = "tar -xvzf #{from} -C #{tmpdir}"
+	#	puts CapUtilsClass.shell(cmd)
+	#
+	#	ensure_empty_database(db_server,db,user,password)
+	#
+	#	puts CapUtilsClass.shell("mysql -u #{user} -p#{password} #{db} < #{File.join(tmpdir,'db/dumps/db.sql')}")
+	#	FileUtils.mkdir_p('public/assets')
+	#	puts CapUtilsClass.shell("cp -rf #{File.join(tmpdir,'public/assets/products')} public/assets/products")
+	#end
+
+
+
+
+end
+
+

data/lib/buzzcore/enum.rb

@@ -0,0 +1,50 @@
+module Kernel
+  # simple (sequential) enumerated values
+  # usage :
+  # 
+  # module Constants
+  #   module Gradient
+  #     enum :B, :A, :C
+  #   end
+  # end
+  #
+  # then :
+  #
+  # puts Constants::Gradient::B -> 0
+  # puts Constants::Gradient::C -> 2
+  # puts Constants::Gradient::MINVALUE -> 0
+  # puts Constants::Gradient::MAXVALUE -> 2
+  # puts Constants::Gradient::NAMES -> [:B, :A, :C]
+  # puts Constants::Gradient[0] -> :B
+  # puts Constants::Gradient[1] -> :A
+  # puts Constants::Gradient[2] -> :C
+  
+  def enum(*syms)
+    syms.each_index { |i| 
+      const_set(syms[i], i) 
+    }
+    const_set(:NAMES, syms || []) 
+    const_set(:MINVALUE, syms==nil ? nil : 0) 
+    const_set(:MAXVALUE, syms==nil ? nil : syms.length-1) 
+    const_set(:VALUECOUNT, syms==nil ? nil : syms.length) 
+    const_set(:ALL, syms==nil ? [] : (0..syms.length-1).to_a) 
+    const_set(:HUMAN_NAMES, syms.map{|n| n.to_s.humanize} || []) 
+
+    # this returns the enum name given the value
+    def self.[]( idx )
+      (idx.is_a? Integer) ? const_get(:NAMES)[idx] : nil
+    end
+
+    def self.valid?(idx)
+      (idx.is_a? Integer) && (idx >= 0) && (idx <= const_get(:MAXVALUE))
+    end
+
+    def self.parse(name,default=nil)
+      return default if name.nil? || name.empty?
+			return default if not name = name.to_sym
+      result = const_get(:NAMES).index(name)
+      return result==nil ? default : result
+    end
+  end
+end
+

data/lib/buzzcore/extend_base_classes.rb

@@ -0,0 +1,328 @@
+String.class_eval do    
+  def pad_left(value)
+    increase = value-self.length
+    return self if increase==0
+    if increase > 0
+      return self + ' '*increase
+    else
+      return self[0,value]
+    end
+  end   
+
+  def pad_right(value)
+    increase = value-self.length
+    return self if increase==0
+    if increase > 0
+      return ' '*increase + self
+    else
+      return self[0,value]
+    end
+  end
+
+  # Like chomp! but operates on the leading characters instead.
+  # The aString parameter would not normally be used.
+  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  
+
+	def begins_with?(aString)
+		self[0,aString.length]==aString
+	end
+
+	def ends_with?(aString)
+		self[-aString.length,aString.length]==aString
+	end
+
+# for future methods
+#   def centre_bar(aChar = '-', indent = 6)
+#     (' '*indent) + aChar*(@width-(indent*2)) + (' '*indent)
+#   end
+#   def replace_string(aString,aCol,aSubString)
+#     return aString if aSubString==nil || aSubString==''
+#
+#     aSubString = aSubString.to_s
+#     start_col = aCol < 0 ? 0 : aCol
+#     end_col = aCol+aSubString.length-1
+#     end_col = @width-1 if end_col >= @width
+#     source_len = end_col-start_col+1
+#     return aString if source_len <= 0 || end_col < 0 || start_col >= @width
+#     aString += ' '*((end_col+1) - aString.length) if aString.length < end_col+1
+#     aString[start_col,source_len] = aSubString[start_col-aCol,end_col-start_col+1]
+#     return aString
+#   end
+
+	def to_integer(aDefault=nil)
+		t = self.strip
+		return aDefault if t.empty? || !t.index(/^-{0,1}[0-9]+$/)
+		return t.to_i
+	end
+
+	def is_i?
+		self.to_integer(false) and true
+	end
+
+	def to_float(aDefault=nil)
+		t = self.strip
+		return aDefault if !t =~ /(\+|-)?([0-9]+\.?[0-9]*|\.[0-9]+)([eE](\+|-)?[0-9]+)?/
+		return t.to_f
+	end
+
+	def is_f?
+		self.to_float(false) and true
+	end
+	
+	# like scan but returns array of MatchData's.
+	# doesn't yet support blocks
+	def scan_md(aPattern)
+		result = []
+		self.scan(aPattern) {|s| result << $~ }		
+		result
+	end
+  
+end  
+
+
+Time.class_eval do
+
+  if !respond_to?(:change)  # no activesupport loaded
+    def change(options)
+      ::Time.send(
+        self.utc? ? :utc : :local,
+        options[:year]  || self.year,
+        options[:month] || self.month,
+        options[:day]   || self.day,
+        options[:hour]  || self.hour,
+        options[:min]   || (options[:hour] ? 0 : self.min),
+        options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+        options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+      )
+    end
+
+    def seconds_since_midnight
+      self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
+    end
+
+    def beginning_of_day
+      (self - self.seconds_since_midnight).change(:usec => 0)
+    end
+
+    alias :midnight :beginning_of_day
+    alias :at_midnight :beginning_of_day
+    alias :at_beginning_of_day :beginning_of_day
+
+  end
+
+	# offset of local machine from UTC, in seconds eg +9.hours
+	def self.local_offset
+		local(2000).utc_offset	
+	end
+
+  def date
+    self.at_beginning_of_day
+  end
+
+	# index number of this day, from Time.at(0) + utc_offset
+	def day_number
+		(self.to_i+self.utc_offset) / 86400
+	end
+
+	# index number of this utc day
+	def day_number_utc
+		self.to_i / 86400
+	end
+
+	# the last microsecond of the day
+	def day_end
+		self.at_beginning_of_day + 86399.999999
+	end
+
+	def date_numeric
+		self.strftime('%Y%m%d')
+	end
+	
+	# create a new Time from eg. "20081231"
+	def self.from_date_numeric(aString)
+		return nil unless aString
+		local(aString[0,4].to_i,aString[4,2].to_i,aString[6,2].to_i)
+	end
+
+	def time_numeric
+		self.strftime('%H%M%S')
+	end
+
+	def datetime_numeric
+		self.strftime('%Y%m%d-%H%M%S')
+	end
+
+	def to_sql
+		self.strftime('%Y-%m-%d %H:%M:%S')
+	end
+
+	def to_w3c
+		utc.strftime("%Y-%m-%dT%H:%M:%S+00:00") 
+	end
+end
+
+module HashUtils
+  def filter_include!(aKeys,aHash=nil)
+    aHash ||= self
+
+		if aKeys.is_a? Regexp
+      return aHash.delete_if {|k,v| not k =~ aKeys }
+		else
+			aKeys = [aKeys] unless aKeys.is_a? Array
+      return aHash.clear if aKeys.empty?
+      return aHash.delete_if {|key, value| !((aKeys.include?(key)) || (key.is_a?(Symbol) and aKeys.include?(key.to_s)) || (key.is_a?(String) and aKeys.include?(key.to_sym)))}
+      return aHash	# last resort
+		end
+  end
+
+  def filter_include(aKeys,aHash=nil)
+    aHash ||= self
+    filter_include!(aKeys,aHash.clone)
+  end
+
+  def filter_exclude!(aKeys,aHash=nil)
+    aHash ||= self
+
+		if aKeys.is_a? Regexp
+      return aHash.delete_if {|k,v| k =~ aKeys }
+		else
+			aKeys = [aKeys] unless aKeys.is_a? Array
+      return aHash if aKeys.empty?
+      return aHash.delete_if {|key, value| ((aKeys.include?(key)) || (key.is_a?(Symbol) and aKeys.include?(key.to_s)) || (key.is_a?(String) and aKeys.include?(key.to_sym)))}
+		end
+  end
+
+  def filter_exclude(aKeys,aHash=nil)
+    aHash ||= self
+    filter_exclude!(aKeys,aHash.clone)
+  end
+
+	def has_values_for?(aKeys,aHash=nil)
+    aHash ||= self
+		# check all keys exist in aHash and their values are not nil
+		aKeys.all? { |k,v| aHash[k] }
+	end
+
+	# give a block to execute without the given key in this hash
+	# It will be replaced after the block (guaranteed by ensure)
+	# eg. 
+	# hash.without_key(:blah) do |aHash|
+	#		puts aHash.inspect
+	# end
+	def without_key(aKey)
+		temp = nil
+		h = self
+		begin
+			if h.include?(aKey)
+				temp = [aKey,h.delete(aKey)]
+			end
+			result = yield(h)
+		ensure
+			h[temp[0]] = temp[1] if temp
+		end
+		return result
+	end
+	
+	def symbolize_keys
+		result = {}
+		self.each { |k,v| k.is_a?(String) ? result[k.to_sym] = v : result[k] = v  }
+		return result
+	end
+
+end
+
+Hash.class_eval do
+  include HashUtils
+end
+
+if defined? HashWithIndifferentAccess
+	HashWithIndifferentAccess.class_eval do
+		include HashUtils
+	end
+end
+
+module ArrayUtils
+  def filter_include!(aValues,aArray=nil)
+    aArray ||= self
+    if aValues.is_a? Array
+      return aArray if aValues.empty?
+      return aArray.delete_if {|v| not aValues.include? v }
+    elsif aValues.is_a? Regexp
+      return aArray.delete_if {|v| not v =~ aValues }
+    else
+      return filter_include!([aValues],aArray)
+    end
+  end
+
+  def filter_include(aValues,aArray=nil)
+    aArray ||= self
+    filter_include!(aValues,aArray.clone)
+  end
+
+  def filter_exclude!(aValues,aArray=nil)
+    aArray ||= self
+    if aValues.is_a? Array
+      return aArray if aValues.empty?
+      return aArray.delete_if {|v| aValues.include? v }
+    elsif aValues.is_a? Regexp
+      return aArray.delete_if {|v| v =~ aValues }
+    else
+      return filter_exclude!([aValues],aArray)
+    end
+  end
+
+  def filter_exclude(aValues,aArray=nil)
+    aArray ||= self
+    filter_exclude!(aValues,aArray.clone)
+  end
+end
+
+Array.class_eval do
+  include ArrayUtils
+
+	# fixes a memory leak in shift in Ruby 1.8 - should be fixed in 1.9
+	# see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/216055
+	def shift()
+		delete_at(0)
+	end
+
+end
+
+Kernel.class_eval do
+	def is_windows?
+		RUBY_PLATFORM =~ /(win|w)32$/ ? true : false
+	end
+end
+
+if defined? ActiveRecord
+	ActiveRecord::Base.class_eval do
+	
+		def self.find_any_id(aId)
+			with_exclusive_scope { find(:first, {:conditions => {:id => aId}}) }
+		end
+	
+		def self.find_any_all(aOptions={})
+			with_exclusive_scope { find(:all, aOptions) }
+		end
+	
+		def self.find_ids(aIds)
+			find(:all, {:conditions=> ["id in (?)",aIds.join(',')]})
+		end
+	
+		def self.find_any_ids(aIds)
+			with_exclusive_scope { find(:all, {:conditions=> ["id in (?)",aIds.join(',')]}) }
+		end
+	
+	end
+end

data/lib/buzzcore/html_utils.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+require 'buzzcore/misc_utils'
+require 'buzzcore/xml_utils'
+
+module HtmlUtils
+
+	#browser-safe inline block
+	INLINE_BLOCK_SAFE_STYLE = "display: -moz-inline-box; display: inline-block; zoom: 1; *display:inline"
+
+	# see fixed_frame_image
+	RIGID_CRR_BLOCK_STYLE = "margin: 0; padding: 0; position: relative; top: 0pt; left: 0pt; display: table-cell; vertical-align: middle; overflow: hidden"
+	IMAGE_CRD_STYLE = "display: block; margin: auto; vertical-align: middle;"
+	
+	def self.fixed_frame_image(aImgTag,aFrameW,aFrameH,aImgW=nil,aImgH=nil)
+		style = RIGID_CRR_BLOCK_STYLE+";width: #{aFrameW}px; height: #{aFrameH}px"
+		result = "<div style=\"#{INLINE_BLOCK_SAFE_STYLE}\"><div style=\"#{style}\">"
+		aImgTag = XmlUtils.quick_remove_att(aImgTag,'width') if aImgW
+		aImgTag = XmlUtils.quick_remove_att(aImgTag,'height') if aImgH
+		style = XmlUtils.quick_att_from_tag(aImgTag,'style').to_s
+		style += IMAGE_CRD_STYLE
+		style += ";width: #{aImgW}px; height: #{aImgH}px"
+		aImgTag = XmlUtils.quick_set_att(aImgTag,'style',style)
+		result << aImgTag
+		result << "</div></div>"
+		result
+	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
+