buzzcore 0.2.5

data/lib/buzzcore/xml_utils.rb

@@ -0,0 +1,203 @@
+require 'net/http'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'buzzcore/misc_utils'
+
+module XmlUtils
+
+	BASIC_HEADER = '<?xml version="1.0"?>'
+
+  def self.get_url_root(url)
+    xml = Net::HTTP.get(URI(url))
+    return nil if !xml
+    xdoc = REXML::Document.new(xml)
+    return nil if !xdoc
+    root = xdoc.root
+  end
+
+  def self.get_xml_root(xml)
+    xdoc = REXML::Document.new(xml)
+    return nil if !xdoc
+    root = xdoc.root
+  end
+	
+	def self.get_file_root(aFilename)
+		return nil unless File.exists?(aFilename)
+		get_xml_root(MiscUtils.string_from_file(aFilename))
+  end
+
+  def self.single_node(node,xpath,default=nil)
+    return default if node.nil? || xpath.nil? || xpath==''
+    val = REXML::XPath.first(node,xpath)
+    return val.nil? ? default : val
+  end
+
+  def self.peek_node(node,xpath,default=nil)
+    return default if node.nil? || xpath.nil? || xpath==''
+    val = REXML::XPath.first(node,xpath)
+    return val.nil? ? default : val.to_s
+  end
+
+  def self.peek_node_value(aNode,aXPath,aDefault=nil)
+		node = single_node(aNode,aXPath)
+		return node.to_s if node.is_a?(REXML::Attribute)
+		return node.nil? ? aDefault : node.text()
+	end
+
+	# convert <root><a>one</a><b>two</b></root> to {'a' => 'one', 'b' => 'two'}
+	def self.hash_from_elements(aXMLRoot)
+		result = {}
+		aXMLRoot.elements.each{|e| result[e.name] = e.text}
+		return result
+	end
+
+	# given '<tag a="1" b="2">textblah</tag>' returns {:name=>"tag", :text=>"textblah", "a"=>"1", "b"=>"2"}
+	def self.hash_from_tag(aTagString)
+		result = {}
+		tag = get_xml_root(aTagString)
+		return nil if !tag
+		tag.attributes.each_attribute {|attr| result[attr.expanded_name]  = attr.value }
+		result[:name] = tag.name
+		result[:text] = tag.text if tag.text
+		return result
+	end
+
+	# given {:name=>"tag", :text=>"textblah", "a"=>"1", "b"=>"2"} returns '<tag a="1" b="2">textblah</tag>'
+	def self.tag_from_hash(aHash,aName=nil,aText=nil)
+		aName ||= aHash[:name]
+		aText ||= aHash[:text]
+		result = "<#{aName}"
+		aHash.each {|k,v| result += " #{k}=\"#{encode(v.to_s)}\"" if k.is_a? String}
+		result += aText ? " >#{aText}</#{aName}>" : " />"
+	end
+
+	# returns first node added
+	def self.add_xml_from_string(aString,aNode)
+		return nil unless xdoc = REXML::Document.new('<?xml version="1.0" encoding="UTF-8"?><root>'+aString+'</root>')
+		result = nil
+		r = xdoc.root
+		while r.has_elements? do
+			e = r.delete_element(1)
+			result = e unless result 
+			e.parent = nil
+			aNode.add_element(e)
+		end
+		return result
+	end
+
+	def self.hash_to_xml(aHash,aRootName,aDocHeader=true)
+    xdoc = REXML::Document.new(BASIC_HEADER)
+		root = xdoc.add_element(aRootName)
+		aHash.each do |n,v| 
+			root.add_element(n).add_text(v)
+		end
+		return xdoc
+	end
+
+	def self.read_simple_items(aRoot,aParentXPath=nil)
+		result = {}
+		xp = aParentXPath ? File.join(aParentXPath,'Item') : 'Item'
+		REXML::XPath.each(aRoot, xp) do |item|
+			result[item.attribute('Name').to_s] = item.text
+    end
+		return result
+	end
+
+	def self.quick_write_simple_items(aHash,aParent)
+		return "<#{aParent} />\n" if !aHash || aHash.empty?
+		result = "<#{aParent}>\n"
+		aHash.each {|key,value| result += "\t<Item Name=\"#{key.to_s}\">#{value.to_s}</Item>\n" }
+		result += "<#{aParent}/>\n"
+		return result
+	end
+
+	# reads the simple items format given either a filename or xml node
+	def self.read_config_values(aXmlConfig)
+		xmlRoot = aXmlConfig.is_a?(REXML::Element) ? aXmlConfig : get_file_root(aXmlConfig)
+		return read_simple_items(xmlRoot,'SimpleItems')
+  end
+
+	# Takes a node or xml string and writes it out formatted nicely.
+	# aOutput may be given eg. a stream or nil can be given to get a returned string
+	def self.format_nicely(aXml,aOutput=nil)
+		aXml = REXML::Document.new(aXml) unless aXml.is_a?(REXML::Element)
+		f = REXML::Formatters::Pretty.new(2,true)
+		f.compact = true
+		f.width = 120
+		aOutput ||= ''
+		f.write(aXml,aOutput)
+		return aOutput
+	end
+
+	def self.encode(aString)
+		result = aString.clone;
+		result.gsub!('&','&amp;')
+		result.gsub!('<','&lt;')
+		result.gsub!('>','&gt;')
+		result.gsub!('"','&quot;')
+		result.gsub!("'",'&apos;')
+		result.gsub!(/[\x80-\xFF]/) {|c| "&#x#{'%X' % c[0]};"}
+		return result
+	end
+	
+	def self.hash_to_deflist(aHash,aBuilder=nil)
+		aBuilder ||= Builder::XmlMarkup.new(:indent => 2)
+		aBuilder.dl do
+			aHash.each do |k,v|
+				aBuilder.dt(k.to_s)
+				aBuilder.dd(v.to_s)
+			end
+		end		
+	end
+	
+	def self.data_to_table(aRowHashes,aCaption=nil,aColNames=nil,aBuilder=nil)
+		aBuilder ||= Builder::XmlMarkup.new(:indent => 2)
+		aBuilder.table do
+			if aCaption.is_a? String
+				aBuilder.caption(aCaption)
+			elsif aCaption.is_a? Hash
+				aBuilder.caption do
+					XmlUtils.hash_to_deflist(aCaption,aBuilder)
+				end
+			end
+			aColNames ||= aRowHashes.first.keys
+			aBuilder.thead do
+				aBuilder.tr do
+					aColNames.each do |name|
+						aBuilder.td(name.to_s)
+					end
+				end
+			end
+			aBuilder.tbody do
+				aRowHashes.each do |row|
+					aBuilder.tr do
+						aColNames.each do |name|
+							aBuilder.td(row[name].to_s)
+						end
+					end
+				end
+			end
+		end
+	end
+	
+	# given a tag string, extracts the contents of an attribute using only a regex
+	def self.quick_att_from_tag(aTagStr,aAtt)
+		aTagStr.scan(/#{aAtt}=['"](.*?)['"]/).flatten.pop
+	end
+	
+	def self.quick_remove_att(aTagStr,aAtt)
+		aTagStr.sub(/#{aAtt}=['"](.*?)['"]/,'')
+	end
+	
+	def self.quick_append_att(aTagStr,aAtt,aValue)
+		# replace first > or /> with att + ending
+		aTagStr.sub(/(>|\/>)/," #{aAtt}=\"#{aValue}\""+' \1')
+	end
+	
+	def self.quick_set_att(aTagStr,aAtt,aValue)
+		result = quick_remove_att(aTagStr,aAtt)
+		quick_append_att(result,aAtt,aValue)
+	end
+
+end
+

data/lib/buzzcore.rb

@@ -0,0 +1,2 @@
+Dir.chdir(File.dirname(__FILE__)) { Dir['buzzcore/*'] }.each {|f| require f }
+

data/lib/buzzcore_dev.rb

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

data/test/buzzcore_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class BuzzcoreTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,201 @@
+require 'rubygems'
+require 'buzzcore/misc_utils'
+require 'buzzcore/config'
+require 'buzzcore/shell_extras'
+require 'test/unit'
+gem 'Shoulda'; require 'shoulda'
+require 'fileutils'
+
+class ConfigTest < Test::Unit::TestCase
+
+	#def setup
+	#	@temp_dir = MiscUtils.make_temp_dir('CredentialsTest')
+	#	@user_dir = File.join(@temp_dir,'home/fred')
+	#	FileUtils.mkdir_p(@user_dir)
+	#	@project_dir = File.join(@temp_dir,'projects/moon')
+	#	@current_dir = File.join(@project_dir,'source')
+	#	FileUtils.mkdir_p(@current_dir)
+	#	::Credentials.const_set('HOME_PATH',@user_dir)
+  #end
+	
+	def config_xml
+		return XmlUtils.get_xml_root('<?xml version="1.0" encoding="UTF-8"?><Config></Config>')
+	end
+	
+	should "read values of same type as default value classes" do 
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => String,
+			:b => Fixnum,
+			:c => Float,
+			:d => TrueClass,
+			:e => FalseClass,
+		}
+		values = {
+			:a => '1',
+			:b => 3,
+			:c => 2.3,
+			:d => true,
+			:e => false,
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		puts config.inspect
+		assert_equal config[:a],'1'
+		assert_equal config[:b],3
+		assert_equal config[:c],2.3
+		assert_equal config[:d],true
+		assert_equal config[:e],false
+	end
+	
+	should "read values of different type as default value classes" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => String,
+			:b => Fixnum,
+			:c => Float,
+			:d => TrueClass,
+			:e => FalseClass,
+		}
+		values = {
+			:a => 1,
+			:b => 3.2,
+			:c => 2,
+			:d => 'false',
+			:e => 0,
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'1'
+		assert_equal config[:b],3
+		assert_equal config[:c],2.0
+		assert_equal config[:d],false
+		assert_equal config[:e],false
+	end
+
+	should "read values when defaults are actual values, and values of correct type" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => 'X',
+			:b => 6,
+			:c => 7.8,
+			:d => true,
+			:e => false,
+		}
+		values = {
+			:a => 'why',
+			:b => 3,
+			:c => 2.9,
+			:d => false,
+			:e => true,
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'why'
+		assert_equal config[:b],3
+		assert_equal config[:c],2.9
+		assert_equal config[:d],false
+		assert_equal config[:e],true
+	end
+
+	should "read values when defaults are actual values, and values of other type" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => 'X',
+			:b => 6,
+			:c => 7.8,
+			:d => true,
+			:e => false,
+		}
+		values = {
+			:a => 123.4,
+			:b => '7',
+			:c => '9',
+			:d => 0,
+			:e => 'yes',
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'123.4'
+		assert_equal config[:b],7
+		assert_equal config[:c],9.0
+		assert_equal config[:d],false
+		assert_equal config[:e],true
+	end
+		
+	should "let value defaults through, exclude values not in defaults" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => 'X',
+			:b => 6,
+			:c => 7.8,
+			:d => true,
+			:e => false,
+		}
+		values = {
+			:x => 89
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'X'
+		assert_equal config[:b],6
+		assert_equal config[:c],7.8
+		assert_equal config[:d],true
+		assert_equal config[:e],false
+		assert_equal config[:x],nil
+	end
+	
+	should "let value defaults through, exclude values not in defaults" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => 'X',
+			:b => 6,
+			:c => 7.8,
+			:d => true,
+			:e => false,
+		}
+		values = {
+			:x => 89
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'X'
+		assert_equal config[:b],6
+		assert_equal config[:c],7.8
+		assert_equal config[:d],true
+		assert_equal config[:e],false
+		assert_equal config[:x],nil
+	end
+	
+	should "let Class defaults through, exclude values not in defaults" do
+		xml = config_xml
+		# values given of native type
+		defaults = {
+			:a => String,
+			:b => Fixnum,
+			:c => Float,
+			:d => TrueClass,
+			:e => FalseClass,
+		}
+		values = {
+			'x' => 89,
+			:a => 89
+		}
+		config = ConfigClass.new(defaults)
+		config.read(values)
+		assert_equal config[:a],'89'
+		assert_equal config[:b],nil
+		assert_equal config[:c],nil
+		assert_equal config[:d],nil
+		assert_equal config[:e],nil
+		assert_equal config[:x],nil
+	end
+	
+	
+end

data/test/credentials_test.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'buzzcore/misc_utils'
+require 'buzzcore/config'
+require 'buzzcore/shell_extras'
+require 'test/unit'
+gem 'Shoulda'; require 'shoulda'
+require 'fileutils'
+
+class CredentialsTest < Test::Unit::TestCase
+
+	def setup
+		@temp_dir = MiscUtils.make_temp_dir('CredentialsTest')
+		@user_dir = File.join(@temp_dir,'home/fred')
+		FileUtils.mkdir_p(@user_dir)
+		@project_dir = File.join(@temp_dir,'projects/moon')
+		@current_dir = File.join(@project_dir,'source')
+		FileUtils.mkdir_p(@current_dir)
+		::Credentials.const_set('HOME_PATH',@user_dir)
+  end
+	
+	def cred_xml
+		return XmlUtils.get_xml_root('<?xml version="1.0" encoding="UTF-8"?><Credentials></Credentials>')
+	end
+	
+	def add_namespace_xml(aCredentialsXml,aNamespace,aItems=nil)
+		result = XmlUtils.add_xml_from_string("<SimpleItems Namespace=\"#{aNamespace.to_s}\"></SimpleItems>",aCredentialsXml)
+		return result unless aItems
+		aItems.each do |n,v|
+			XmlUtils.add_xml_from_string("<Item Name=\"#{n.to_s}\">#{v.to_s}</Item>",result)
+		end
+		return result
+	end
+	
+	should "read SimpleItems" do
+		xml = XmlUtils.get_xml_root('<?xml version="1.0"?><Credentials><SimpleItems Namespace="global"><Item Name="a">5</Item><Item Name="b">hello</Item></SimpleItems></Credentials>')
+		si = REXML::XPath.first(xml,'/Credentials/SimpleItems')
+		values = XmlUtils.read_simple_items(si)
+		assert_equal values['a'],'5'
+		assert_equal values['b'],'hello'
+	end
+
+	should "load local credentials file" do
+		xml = cred_xml()
+		add_namespace_xml(xml.root,:global,{:a=>5,'b'=>'hello'})
+		MiscUtils.string_to_file(xml.document.to_s,File.join(@project_dir,Credentials::CRED_FILENAME))
+		cred = Credentials.new(:moon,@current_dir)
+		assert_equal cred[:a],'5'
+		assert_equal cred[:b],'hello'
+	end
+	
+	should "load user credentials file" do
+		xml = cred_xml()
+		add_namespace_xml(xml,:global,{:a=>7,'b'=>'apples'})
+		MiscUtils.string_to_file(xml.document.to_s,File.join(@user_dir,Credentials::CRED_FILENAME))
+		cred = Credentials.new(:moon,@current_dir)
+		assert_equal cred[:a],'7'
+		assert_equal cred[:b],'apples'
+	end
+
+	should "specified namespace values should override global, and other namespace doesn't interfere" do
+		xml = cred_xml()
+		add_namespace_xml(xml,:global,{:a=>1,'b'=>'green'})
+		add_namespace_xml(xml,:moon,{'b'=>'red'})
+		add_namespace_xml(xml,:blah,{'a'=>'yellow','b'=>20})
+		MiscUtils.string_to_file(xml.document.to_s,File.join(@user_dir,Credentials::CRED_FILENAME))
+		cred = Credentials.new(:moon,@current_dir)
+		assert_equal cred[:a],'1'
+		assert_equal cred[:b],'red'
+	end
+	
+end

data/test/shell_test.rb

@@ -0,0 +1,54 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+
+require 'test/unit'
+gem 'Shoulda'; require 'shoulda'
+
+require 'buzzcore/shell_extras'
+require 'yore/yore_core'
+
+class ShellTest < Test::Unit::TestCase
+  should "raise exception on timeout"
+  
+  should "not raise exception on non-zero return code, fixed in block. Check result contents"
+  
+  should "return values from succesfult system call" do
+    result = POpen4::shell('ls .')
+    assert_instance_of Hash, result
+    assert_instance_of String, result[:stdout]
+    assert_instance_of String, result[:stderr]
+    assert result[:stdout].length > 0
+    assert_equal(0, result[:exitcode])
+  end
+
+  context "fail correctly" do
+
+    should "raise exception on invalid ls" do
+      begin
+        result = POpen4::shell('ls asdsadasdasdasdasd')
+      rescue ::StandardError => e
+        assert_instance_of(POpen4::ExecuteError, e)
+        assert_equal 1, e.result[:exitcode]
+        assert_instance_of String,e.result[:stdout]
+        assert_instance_of String,e.result[:stderr]
+        return
+      end
+      flunk 'should have raised an exception'
+    end
+
+    should "not raise exception when fixed in block" do
+      result = POpen4::shell('ls asdsadasdasdasdasd') do |r|
+        r[:exitcode] = 0
+      end
+      assert_instance_of Hash, result
+      assert_instance_of String, result[:stdout]
+      assert_instance_of String, result[:stderr]
+      assert_equal(0, result[:exitcode])
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'buzzcore'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: buzzcore
+version: !ruby/object:Gem::Version 
+  version: 0.2.5
+platform: ruby
+authors: 
+- buzzware
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-06 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: buzzcore is the ruby core library developed and used by Buzzware Solutions.
+email: contact@buzzware.com.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- buzzcore.gemspec
+- buzzcore.vpj
+- buzzcore.vpw
+- lib/buzzcore.rb
+- lib/buzzcore/config.rb
+- lib/buzzcore/database_utils.rb
+- lib/buzzcore/enum.rb
+- lib/buzzcore/extend_base_classes.rb
+- lib/buzzcore/html_utils.rb
+- lib/buzzcore/logging.rb
+- lib/buzzcore/misc_utils.rb
+- lib/buzzcore/require_paths.rb
+- lib/buzzcore/shell_extras.rb
+- lib/buzzcore/string_utils.rb
+- lib/buzzcore/text_doc.rb
+- lib/buzzcore/thread_utils.rb
+- lib/buzzcore/xml_utils.rb
+- lib/buzzcore_dev.rb
+- test/buzzcore_test.rb
+- test/config_test.rb
+- test/credentials_test.rb
+- test/shell_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/buzzware/buzzcore
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: buzzcore is the ruby core library developed and used by Buzzware Solutions.
+test_files: 
+- test/buzzcore_test.rb
+- test/config_test.rb
+- test/credentials_test.rb
+- test/shell_test.rb
+- test/test_helper.rb