buzzware-buzzcore 0.2.2

data/lib/buzzcore/config.rb

@@ -0,0 +1,210 @@
+require 'buzzcore/xml_utils'
+require 'buzzcore/extend_base_classes'
+
+class ConfigClass < Hash
+
+	attr_reader :default_values
+
+	def initialize(aDefaultValues,aNewValues=nil,&aBlock)
+		@default_values = aDefaultValues.clone
+		reset()
+		if aNewValues
+			block_given? ? read(aNewValues,&aBlock) : read(aNewValues) 
+		end
+	end
+
+	# aBlock allows values to be filtered based on key,default and new values
+	def read(aSource,&aBlock)
+		default_values.each do |k,v|
+			done = false
+			if block_given? && ((newv = yield(k,v,aSource && aSource[k])) != nil)
+				self[k] = newv
+				done = true
+			end
+			copy_item(aSource,k) if !done && aSource && !aSource[k].nil?
+		end
+		self
+	end
+	
+	# reset values back to defaults
+	def reset
+		self.clear
+		me = self
+		@default_values.each {|n,v| me[n] = v.is_a?(Class) ? nil : v}
+	end
+
+	def set_int(aKey,aValue)
+		case aValue
+			when String then    self[aKey] = aValue.to_integer(self[aKey]);
+			when Fixnum then    self[aKey] = aValue;
+			when Float then     self[aKey] = aValue.to_i;
+		end
+	end
+
+	def set_float(aKey,aValue)
+		case aValue
+			when String then    self[aKey] = aValue.to_float(self[aKey]);
+			when Fixnum then    self[aKey] = aValue.to_f;
+			when Float then     self[aKey] = aValue;
+		end
+	end
+
+	def set_boolean(aKey,aValue)
+		case aValue
+			when TrueClass,FalseClass then   self[aKey] = aValue;
+			when String then    self[aKey] = (['1','yes','y','true','on'].include?(aValue.downcase))
+		else
+			set_boolean(aKey,aValue.to_s)
+		end
+	end
+	
+	def set_symbol(aKey,aValue)
+		case aValue
+			when String then    self[aKey] = (aValue.to_sym rescue nil);
+			when Symbol then    self[aKey] = aValue;
+		end
+	end
+
+	def copy_item(aHash,aKey)
+		d = default_values[aKey]
+		d_class = (d.is_a?(Class) ? d : d.class)
+		cname = d_class.name.to_sym
+		case cname
+			when :NilClass then ;
+			when :String then self[aKey] = aHash[aKey].to_s unless aHash[aKey].nil?
+			when :Float then set_float(aKey,aHash[aKey]);
+			when :Fixnum then set_int(aKey,aHash[aKey]);
+			when :TrueClass, :FalseClass then set_boolean(aKey,aHash[aKey]);
+			when :Symbol then self[aKey] = (aHash[aKey].to_sym rescue nil)
+			else
+				raise StandardError.new('unsupported type')
+		end
+	end
+
+	def copy_strings(aHash,*aKeys)
+		aKeys.each do |k|
+			self[k] = aHash[k].to_s unless aHash[k].nil?
+		end
+	end
+
+	def copy_ints(*aDb)
+		aHash = aDb.shift
+		aKeys = aDb
+		aKeys.each do |k|
+			set_int(k,aHash[k])
+		end
+	end
+
+	def copy_floats(aHash,*aKeys)
+		aKeys.each do |k|
+			set_float(k,aHash[k])
+		end
+	end
+
+	def copy_booleans(aHash,*aKeys)
+		aKeys.each do |k|
+			set_boolean(k,aHash[k])
+		end
+	end
+
+	def to_hash
+		{}.merge(self)
+	end
+
+end
+
+class ConfigXmlClass < ConfigClass
+	attr_accessor :xmlRoot
+	def initialize(aDefaultValues,aConfig)
+		return super(aDefaultValues,aConfig) unless aConfig.is_a?(REXML::Element)
+		@xmlRoot = aConfig.deep_clone
+		super(aDefaultValues,XmlUtils.read_simple_items(@xmlRoot,'SimpleItems').symbolize_keys)
+	end
+	
+	def self.from_file(aDefaultValues,aFile)
+		xml = XmlUtils.get_file_root(aFile)
+		return ConfigXmlClass.new(aDefaultValues,xml)
+	end
+end
+
+# credentials files look like :
+#<?xml version="1.0" encoding="UTF-8"?>
+#<Credentials>
+#	<SimpleItems namespace="global">
+#		<Item name=""></Item>
+#		<Item name=""></Item>
+#		<Item name=""></Item>
+#	</SimpleItems>
+#	<SimpleItems namespace="yore_test">
+#		<Item name=""></Item>
+#		<Item name=""></Item>
+#		<Item name=""></Item>
+#	</SimpleItems>
+#</Credentials>
+#
+# global .credentials.xml file  
+# local .credentials.xml file
+# cred = Credentials.new()	# optionally specify filename or path or hash. if nil then use Dir.pwd
+#
+# def initialize(aSource)
+#		# load global namespace from ~/.credentials.xml
+#		# load global namespace from local .credentials.xml
+#		# load given namespace from ~/.credentials.xml
+#		# load given namespace from local .credentials.xml
+#		# merge all top to bottom
+class Credentials < Hash
+
+	CRED_FILENAME = ".credentials.xml"
+
+	def find_file_upwards(aFilename,aStartPath=nil)
+		aStartPath ||= Dir.pwd
+		return nil if aFilename.nil? || aFilename.empty?
+		arrPath = aStartPath.split(File::SEPARATOR)
+		while arrPath.length > 0
+			path = File.join(arrPath.join(File::SEPARATOR),aFilename)
+			return path if File.exists?(path)
+			arrPath.pop
+		end
+		return nil
+	end
+	
+	def get_all_credentials(aXmlRoot)
+		return nil unless aXmlRoot
+		result = {}
+		REXML::XPath.each(aXmlRoot, '/Credentials/SimpleItems') do |si|
+			ns = si.attributes['Namespace']
+			values = XmlUtils.read_simple_items(si)
+			result[ns.to_sym] = values.symbolize_keys if ns && values
+		end
+		return result
+	end
+
+	#XmlUtils.read_simple_items(@xmlRoot,'/Yore/SimpleItems')
+	def get_user_credentials
+		return get_all_credentials(XmlUtils.get_file_root(File.join(HOME_PATH,CRED_FILENAME)))
+	end
+
+	def get_local_credentials(aSource=nil)
+		aSource ||= Dir.pwd
+		# assume source is a directory path, but other types could be supported later
+		return nil unless file=find_file_upwards(CRED_FILENAME,aSource)
+		return get_all_credentials(XmlUtils.get_file_root(file))
+	end
+
+	def initialize(aNamespace=nil,aSource=nil)
+		#HOME_PATH can be preset by tests eg. ::Credentials.const_set('HOME_PATH',@user_dir)
+		Credentials.const_set("HOME_PATH", ENV['HOME']) unless Credentials.const_defined? "HOME_PATH"
+		arrCredentials = []
+		user_credentials = get_user_credentials()
+		local_credentials = get_local_credentials(aSource)
+		arrCredentials << user_credentials[:global] if user_credentials
+		arrCredentials << local_credentials[:global] if local_credentials
+		arrCredentials << user_credentials[aNamespace.to_sym] if aNamespace && user_credentials
+		arrCredentials << local_credentials[aNamespace.to_sym] if aNamespace && local_credentials
+		arrCredentials.compact!
+		arrCredentials.each do |c|
+			self.merge!(c)
+		end
+	end
+end
+

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,320 @@
+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
+  
+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