yore 0.0.4 → 0.0.5

data/lib/ihl_ruby/config.rb

@@ -1,202 +0,0 @@
-require 'rubygems'
-gem 'RequirePaths'; require 'require_paths'
-require_paths '..'
-require 'ihl_ruby/xml_utils'
-
-class ConfigClass < Hash
-
-	attr_reader :default_values
-
-	def initialize(aDefaultValues,aNewValues=nil,&aBlock)
-    self.merge!(@default_values = aDefaultValues.clone)
-		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]
-		end
-		self
-	end
-	
-	# reset values back to defaults
-	def reset
-		self.clear
-		self.merge!(default_values)
-	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)
-		case default_values[aKey]
-			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 Error.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,'/Yore/SimpleItems'))
-	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/ihl_ruby/database_utils.rb

@@ -1,89 +0,0 @@
-require 'rubygems'
-gem 'RequirePaths'; require 'require_paths'
-require_paths '..'
-require 'ihl_ruby/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/ihl_ruby/enum.rb

@@ -1,50 +0,0 @@
-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/ihl_ruby/extend_base_classes.rb

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