buzzcorej 0.0.1 → 0.0.2

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "buzzcorej"
+    gem.summary = %Q{buzzcorej is the JRuby core library developed and used by Buzzware Solutions.}
+    gem.description = %Q{buzzcorej is the JRuby core library developed and used by Buzzware Solutions.}
+    gem.email = "contact@buzzware.com.au"
+    gem.homepage = "http://github.com/buzzware/buzzcorej"
+    gem.authors = ["buzzware"]
+    gem.add_development_dependency "shoulda"
+		gem.files.include %w(
+			lib/buzzcorej.rb
+		)
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new	
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "buzzcorej #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1,2 @@
+0.0.2
+

data/buzzcorej.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{buzzcorej}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["buzzware"]
+  s.date = %q{2010-08-15}
+  s.description = %q{buzzcorej is the JRuby core library developed and used by Buzzware Solutions.}
+  s.email = %q{contact@buzzware.com.au}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "buzzcorej.gemspec",
+     "buzzcorej.vpj",
+     "buzzcorej.vpw",
+     "lib/buzzcorej.rb",
+     "lib/buzzcorej/enum.rb",
+     "lib/buzzcorej/extend_base_classes.rb",
+     "lib/buzzcorej/misc_utils.rb",
+     "lib/buzzcorej/require_paths.rb",
+     "lib/buzzcorej/string_utils.rb",
+     "lib/buzzcorej_dev.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/buzzware/buzzcorej}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{buzzcorej is the JRuby core library developed and used by Buzzware Solutions.}
+  s.test_files = [
+    "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+  end
+end
+

data/buzzcorej.vpj

@@ -0,0 +1,93 @@
+<!DOCTYPE Project SYSTEM "http://www.slickedit.com/dtd/vse/10.0/vpj.dtd">
+<Project
+	Version="10.0"
+	VendorName="SlickEdit"
+	WorkingDir=".">
+	<Config
+		Name="Release"
+		OutputFile=""
+		CompilerConfigName="Latest Version">
+		<Menu>
+			<Target
+				Name="Compile"
+				MenuCaption="&amp;Compile"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveCurrent"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Build"
+				MenuCaption="&amp;Build"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveWorkspaceFiles"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Rebuild"
+				MenuCaption="&amp;Rebuild"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveWorkspaceFiles"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Debug"
+				MenuCaption="&amp;Debug"
+				SaveOption="SaveNone"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Execute"
+				MenuCaption="E&amp;xecute"
+				SaveOption="SaveNone"
+				RunFromDir="%rw"
+				CaptureOutputWith="ProcessBuffer"
+				ClearProcessBuffer="1">
+				<Exec CmdLine="source actions.sh execute"/>
+			</Target>
+		</Menu>
+	</Config>
+	<CustomFolders>
+		<Folder
+			Name="Source Files"
+			Filters="*.c;*.C;*.cc;*.cpp;*.cp;*.cxx;*.c++;*.prg;*.pas;*.dpr;*.asm;*.s;*.bas;*.java;*.cs;*.sc;*.e;*.cob;*.html;*.rc;*.tcl;*.py;*.pl"/>
+		<Folder
+			Name="Header Files"
+			Filters="*.h;*.H;*.hh;*.hpp;*.hxx;*.inc;*.sh;*.cpy;*.if"/>
+		<Folder
+			Name="Resource Files"
+			Filters="*.ico;*.cur;*.dlg"/>
+		<Folder
+			Name="Bitmaps"
+			Filters="*.bmp"/>
+		<Folder
+			Name="Other Files"
+			Filters="">
+		</Folder>
+	</CustomFolders>
+	<Files AutoFolders="DirectoryView">
+		<Folder Name="lib">
+			<F
+				N="lib/*"
+				Recurse="1"
+				Refilter="0"
+				Excludes=""/>
+		</Folder>
+		<Folder Name="test">
+			<F
+				N="test/*"
+				Recurse="0"
+				Refilter="0"
+				Excludes=".svn/"/>
+		</Folder>
+		<F N="buzzcorej.gemspec"/>
+		<F N="History.txt"/>
+		<F N="Manifest.txt"/>
+		<F N="PostInstall.txt"/>
+		<F N="Rakefile"/>
+		<F N="README.rdoc"/>
+	</Files>
+</Project>

data/buzzcorej.vpw

@@ -0,0 +1,93 @@
+<!DOCTYPE Project SYSTEM "http://www.slickedit.com/dtd/vse/10.0/vpj.dtd">
+<Project
+	Version="10.0"
+	VendorName="SlickEdit"
+	WorkingDir=".">
+	<Config
+		Name="Release"
+		OutputFile=""
+		CompilerConfigName="Latest Version">
+		<Menu>
+			<Target
+				Name="Compile"
+				MenuCaption="&amp;Compile"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveCurrent"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Build"
+				MenuCaption="&amp;Build"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveWorkspaceFiles"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Rebuild"
+				MenuCaption="&amp;Rebuild"
+				CaptureOutputWith="ProcessBuffer"
+				SaveOption="SaveWorkspaceFiles"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Debug"
+				MenuCaption="&amp;Debug"
+				SaveOption="SaveNone"
+				RunFromDir="%rw">
+				<Exec/>
+			</Target>
+			<Target
+				Name="Execute"
+				MenuCaption="E&amp;xecute"
+				SaveOption="SaveNone"
+				RunFromDir="%rw"
+				CaptureOutputWith="ProcessBuffer"
+				ClearProcessBuffer="1">
+				<Exec CmdLine="source actions.sh execute"/>
+			</Target>
+		</Menu>
+	</Config>
+	<CustomFolders>
+		<Folder
+			Name="Source Files"
+			Filters="*.c;*.C;*.cc;*.cpp;*.cp;*.cxx;*.c++;*.prg;*.pas;*.dpr;*.asm;*.s;*.bas;*.java;*.cs;*.sc;*.e;*.cob;*.html;*.rc;*.tcl;*.py;*.pl"/>
+		<Folder
+			Name="Header Files"
+			Filters="*.h;*.H;*.hh;*.hpp;*.hxx;*.inc;*.sh;*.cpy;*.if"/>
+		<Folder
+			Name="Resource Files"
+			Filters="*.ico;*.cur;*.dlg"/>
+		<Folder
+			Name="Bitmaps"
+			Filters="*.bmp"/>
+		<Folder
+			Name="Other Files"
+			Filters="">
+		</Folder>
+	</CustomFolders>
+	<Files AutoFolders="DirectoryView">
+		<Folder Name="lib">
+			<F
+				N="lib/*"
+				Recurse="1"
+				Refilter="0"
+				Excludes=""/>
+		</Folder>
+		<Folder Name="test">
+			<F
+				N="test/*"
+				Recurse="0"
+				Refilter="0"
+				Excludes=".svn/"/>
+		</Folder>
+		<F N="buzzcorej.gemspec"/>
+		<F N="History.txt"/>
+		<F N="Manifest.txt"/>
+		<F N="PostInstall.txt"/>
+		<F N="Rakefile"/>
+		<F N="README.rdoc"/>
+	</Files>
+</Project>

data/lib/buzzcorej/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/buzzcorej/extend_base_classes.rb

@@ -0,0 +1,485 @@
+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
+	
+	def to_nil(aPattern=nil)
+		return nil if self.empty?
+		if aPattern
+			return nil if (aPattern.is_a? Regexp) && (self =~ aPattern)
+			return nil if aPattern.to_s == self			
+		end
+		self
+	end
+	
+	def to_b(aDefault=false)
+		return true if ['1','yes','y','true','on'].include?(self.downcase)
+		return false if ['0','no','n','false','off'].include?(self.downcase)
+		aDefault
+	end
+  
+	# uses 
+	#URLIZE_PATTERN = /[ \/\\\(\)\[\]]/
+	URLIZE_PATTERN_PS = /[ \\\(\)\[\]_]/
+	def urlize(aSlashChar='+')
+		return self if self.empty?
+		result = self.gsub(URLIZE_PATTERN_PS,'-').downcase.gsub(/[^a-z0-9_\-+,\.\/]/,'')
+		result.gsub!('/',aSlashChar) unless aSlashChar=='/'
+		result.gsub!(/-{2,}/,'-')
+		result
+	end	
+  
+	private
+  CRC_LOOKUP = [
+    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
+    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
+    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
+    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
+    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
+    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
+    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
+    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
+    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
+    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
+    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
+    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
+    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
+    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
+    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
+    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
+    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
+    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
+    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
+    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
+    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
+    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
+    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
+    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
+    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
+    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
+    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
+    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
+    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
+    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
+    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
+    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+  ]  
+  public
+	
+  def crc16
+    crc = 0x00
+    self.each_byte do |b|
+      crc = ((crc >> 8) & 0xff) ^ CRC_LOOKUP[(crc ^ b) & 0xff]
+    end
+    crc
+  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
+	
+	def to_universal
+		self.strftime("%d %b %Y")	
+	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
+
+	def to_nil
+		self.empty? ? nil : self
+	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
+	
+	def to_nil
+		self.empty? ? nil : self
+	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
+
+Fixnum.class_eval do
+
+	def to_nil
+		self==0 ? nil : self
+	end
+
+	def to_b(aDefault=false)
+		self==0 ? false : true
+	end
+
+end
+
+Bignum.class_eval do
+
+	def to_nil
+		self==0 ? nil : self
+	end
+	
+	def to_b(aDefault=false)
+		self==0 ? false : true
+	end
+
+end
+
+NilClass.class_eval do 
+
+	def to_nil
+		nil	
+	end
+	
+	def to_b(aDefault=false)
+		false
+	end
+	
+end
+
+TrueClass.class_eval do 
+
+	def to_nil
+		self	
+	end
+	
+	def to_b(aDefault=false)
+		self
+	end	
+	
+end
+
+FalseClass.class_eval do 
+
+	def to_nil
+		nil	
+	end
+	
+	def to_b(aDefault=false)
+		self
+	end	
+	
+end
+
+
+Math.module_eval do
+  def self.max(a, b)
+    a > b ? a : b
+  end
+
+  def self.min(a, b)
+    a < b ? a : b
+  end
+end
+

data/lib/buzzcorej/misc_utils.rb

@@ -0,0 +1,334 @@
+require 'tmpdir'
+require 'logger'
+require 'pathname'
+
+#require 'buzzcorej/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
+
+	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.set_permissions_cmd(aFilepath,aUser=nil,aGroup=nil,aMode=nil,aSetGroupId=false,aSudo=true)
+	#	cmd = []
+	#	if aGroup
+	#		cmd << (aUser ? "#{aSudo ? sudo : ''} chown #{aUser}:#{aGroup}" : "#{aSudo ? sudo : ''} chgrp #{aGroup}") + " #{aFilepath}"
+	#	else
+	#		cmd << "#{aSudo ? sudo : ''} chown #{aUser} #{aFilepath}" if aUser
+	#	end
+	#	cmd << "#{aSudo ? sudo : ''} chmod #{aMode.to_s} #{aFilepath}" if aMode
+	#	cmd << "#{aSudo ? sudo : ''} chmod g+s #{aFilepath}" if aSetGroupId
+	#	cmd.join(' && ')
+	#end
+
+	def self.string_to_file(aString,aFilename)
+		File.open(aFilename,'wb') {|file| file.write 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 UPDATE: this is causing problems now
+	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
+	
+	# make path real according to file system
+	def self.real_path(aPath)
+		(path = Pathname.new(File.expand_path(aPath))) && path.realpath.to_s
+	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 = path_combine(aRootPath,aPath)
+		path = real_path(path) if path
+		path
+	end
+	
+	def self.find_upwards(aStartPath,aPath)
+		curr_path = File.expand_path(aStartPath)
+		while curr_path && !(test_path_exists = File.exists?(test_path = File.join(curr_path,aPath))) do
+			curr_path = MiscUtils.path_parent(curr_path)
+		end
+		curr_path && test_path_exists ? test_path : nil
+	end
+
+
+	# allows special symbols in path
+	# currently only ... supported, which looks upward in the filesystem for the following relative path from the basepath
+	def self.expand_magic_path(aPath,aBasePath=nil)
+		aBasePath ||= Dir.pwd
+		path = aPath
+		if path.begins_with?('...')
+			rel_part = StringUtils.split3(path,/\.\.\.[\/\\]/)[2]
+			path = find_upwards(aBasePath,rel_part)
+		end
+	end
+
+	def self.path_parent(aPath)
+		return nil if is_root_path?(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.simple_file_name(aPath)
+		f = File.basename(aPath)
+		dot = f.index('.')
+		return dot ? f[0,dot] : f
+	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.is_root_path?(aPath)
+		if is_windows?
+			(aPath =~ /^[a-zA-Z]\:[\\\/]$/)==0
+		else
+			aPath == '/'
+		end
+	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
+	
+	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
+end
+

data/lib/buzzcorej/require_paths.rb

@@ -0,0 +1,39 @@
+# This sorts out the issues of require'ing files in Ruby
+#	1) on one line, you specify all the paths you need
+# 2) Relative paths will be relative to the file you are in, absolute paths also supported
+# 3) Paths will be expanded
+# 4) Paths will only be added if they don't already exist
+# 
+module ::Kernel
+
+	# returns full path given relative to $LOAD_PATH
+	def require_which(aFilepath)
+		aFilepath += '.rb'
+		$LOAD_PATH.each do |dir|
+			full_path = File.expand_path(File.join(dir,aFilepath))
+			return full_path if File.exist? full_path
+		end
+		return nil
+	end
+
+	def require_paths(*aArgs)
+	  caller_dir = File.dirname(File.expand_path(caller.first.sub(/:[0-9]+.*/,'')))
+		aArgs.each do |aPath|
+			aPath = File.expand_path(aPath,caller_dir)
+			$LOAD_PATH << aPath unless $LOAD_PATH.include?(aPath)
+		end
+	end
+	
+	def require_paths_first(*aArgs)
+	  caller_dir = File.dirname(File.expand_path(caller.first.sub(/:[0-9]+.*/,'')))
+		paths = []
+		aArgs.each do |aPath|
+			aPath = File.expand_path(aPath,caller_dir)
+			paths << aPath
+		end
+		paths.each do |p|
+			$LOAD_PATH.insert(0,p)
+		end
+	end
+end
+

data/lib/buzzcorej/string_utils.rb

@@ -0,0 +1,95 @@
+module StringUtils
+	def self.crop(aString,aLength,aEllipsis=true,aConvertNil=true)
+		return aConvertNil ? ' '*aLength : nil if !aString
+
+    increase = aLength-aString.length
+    return aString+' '*increase if increase>=0
+		return aEllipsis ? aString[0,aLength-3]+'...' : aString[0,aLength]
+  end
+
+	def self.simplify_whitespace(aText)
+		aText.gsub(/[ \n\t\r]+/,' ').strip
+	end
+
+	def self.crop_to_word_count(aText,aWordCount)
+		aText = simplify_whitespace(aText)
+		matches = aText.scan_md(/[^\w-]+/)
+		match = matches[aWordCount-1]
+		result = (match ? match.pre_match : aText)
+		result
+	end
+
+	# aTemplate is a string containing tokens like ${SOME_TOKEN}
+	# aValues is a hash of token names eg. 'SOME_TOKEN' and their values to substitute
+	def self.render_template(aTemplate,aValues)
+		# get positions of tokens
+		result = aTemplate.gsub(/\$\{(.*?)\}/) do |s| 
+			key = s[2..-2]
+			rep = (aValues[key] || s)
+			#puts "replacing #{s} with #{rep}"
+			rep
+    end
+		#puts "rendered :\n#{result}"
+		return result
+	end
+	
+	def self.clean_number(aString)
+		aString.gsub(/[^0-9.-]/,'')
+	end
+
+	# supply a block with 2 parameters, and it will get called for each char as an integer
+	def self.each_unicode_char(aString)
+		len = 1
+		index = 0
+		char = 0
+		aString.each_byte do |b|
+			if index==0
+				len = 1
+				len = 2 if b & 0b11000000 != 0
+				len = 3 if b & 0b11100000 != 0
+				len = 4 if b & 0b11110000 != 0
+				char = 0
+			end
+		
+			char |= b << index*8
+		
+			yield(char,len) if index==len-1 # last byte; char is complete
+		
+			index += 1
+			index = 0 if index >= len
+		end
+	end
+
+	# given ('abcdefg','c.*?e') returns ['ab','cde','fg'] so you can manipulate the head, match and tail seperately, and potentially rejoin
+	def self.split3(aString,aPattern,aOccurence=0)
+		matches = aString.scan_md(aPattern)
+		match = matches[aOccurence]
+		parts = (match ? [match.pre_match,match.to_s,match.post_match] : [aString,nil,''])
+
+		if !block_given?	# return head,match,tail
+			parts
+		else						# return string
+			parts[1] = yield *parts if match
+			parts.join
+		end
+	end
+
+	# truncates a string to the given length by looking for the previous space.
+	def self.word_safe_truncate(aString,aMaxLength)
+		return nil if !aString
+		return aString if aString.length <= aMaxLength
+		posLastSpace = aString.rindex(/[ \t]/,aMaxLength)
+		return aString[0,aMaxLength] if !posLastSpace
+		aString[0,posLastSpace]
+	end
+	
+	# replaces all tabs with spaces, and reduces multiple spaces to a single space	
+	def self.reduce_whitespace(aText)
+		aText = aText.gsub("\t"," ")	# replace tabs with spaces
+		aText.strip!
+		aText.squeeze!(' ')
+		aText
+	end
+
+end
+

data/lib/buzzcorej_dev.rb

@@ -0,0 +1,6 @@
+# when you want to load the live version of buzzcorej, not the gem :
+# require File.join(File.dirname(__FILE__),'../../../../../buzzcorej/lib/buzzcorej_dev.rb');
+require File.join(File.dirname(__FILE__),'buzzcorej/require_paths')	# load require_paths early for next line
+require_paths_first '.'
+require 'buzzcorej'
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: buzzcorej
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - buzzware
@@ -42,9 +42,20 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- lib/buzzcorej.rb
 - LICENSE
 - README.rdoc
+- Rakefile
+- VERSION
+- buzzcorej.gemspec
+- buzzcorej.vpj
+- buzzcorej.vpw
+- lib/buzzcorej.rb
+- lib/buzzcorej/enum.rb
+- lib/buzzcorej/extend_base_classes.rb
+- lib/buzzcorej/misc_utils.rb
+- lib/buzzcorej/require_paths.rb
+- lib/buzzcorej/string_utils.rb
+- lib/buzzcorej_dev.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/buzzware/buzzcorej