rb-appscript 0.2.0

data/test/README

@@ -0,0 +1 @@
+Some of the code in these tests may not yet be 100% portable (hardcoded paths, etc) so may currently fail for some users, although they have passed for Ruby 1.8.x on OS X 10.3.9 and OS X 10.4.x (PPC & i386).

data/test/test_aemreference.rb

@@ -0,0 +1,112 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'
+require "_aem/aemreference"
+require "_aem/typewrappers"
+require "_aem/codecs"
+
+
+class TC_AEMReferences < Test::Unit::TestCase
+
+	def test_reference_forms
+		[
+			[AEMReference::App.property('ctxt'), 'AEM.app.property("ctxt")', nil],
+			
+			[AEMReference::App.elements('docu'), 'AEM.app.elements("docu")', nil],
+			
+			[AEMReference::App.elements('docu').by_index(1), 
+					'AEM.app.elements("docu").by_index(1)', nil],
+			[AEMReference::App.elements('docu').by_name('foo'), 
+					'AEM.app.elements("docu").by_name("foo")', nil],
+			[AEMReference::App.elements('docu').by_id(300), 
+					'AEM.app.elements("docu").by_id(300)', nil],
+			
+			[AEMReference::App.elements('docu').next('docu'), 
+					'AEM.app.elements("docu").next("docu")', nil],
+			[AEMReference::App.elements('docu').previous('docu'), 
+					'AEM.app.elements("docu").previous("docu")', nil],
+			
+			[AEMReference::App.elements('docu').first, 'AEM.app.elements("docu").first', nil],
+			[AEMReference::App.elements('docu').middle, 'AEM.app.elements("docu").middle', nil],
+			[AEMReference::App.elements('docu').last, 'AEM.app.elements("docu").last', nil],
+			[AEMReference::App.elements('docu').any, 'AEM.app.elements("docu").any', nil],
+			
+			[AEMReference::Con.elements("docu").by_index(3), 'AEM.con.elements("docu").by_index(3)', nil],
+			
+			[AEMReference::App.elements('docu').by_range(
+					AEMReference::Con.elements('docu').by_index(3),
+					AEMReference::Con.elements('docu').by_name('foo')), 
+					'AEM.app.elements("docu").by_range(' +
+					'AEM.con.elements("docu").by_index(3), ' +
+					'AEM.con.elements("docu").by_name("foo"))', nil],
+			
+			
+			[AEMReference::Its.property('name').eq('foo').and(AEMReference::Its.elements('cwor').eq([])), 
+					'AEM.its.property("name").eq("foo").and(AEM.its.elements("cwor").eq([]))', nil],
+			
+			[AEMReference::Its.elements('cwor').ne([]), 
+					'AEM.its.elements("cwor").ne([])', 
+					AEMReference::Its.elements("cwor").eq([]).not], # i.e. there isn't a KAENotEqual operator, so not-equal tests are actually packed as an equal test followed by not test
+					
+			[AEMReference::Its.elements('cwor').eq(nil), 'AEM.its.elements("cwor").eq(nil)', nil],
+			[AEMReference::Its.elements('cwor').property('leng').gt(0), 
+					'AEM.its.elements("cwor").property("leng").gt(0)', nil],
+			[AEMReference::Its.elements('cwor').le(''), 'AEM.its.elements("cwor").le("")', nil],
+			[AEMReference::Its.elements('cwor').starts_with('foo').not, 
+					'AEM.its.elements("cwor").starts_with("foo").not', nil],
+			
+			
+			[AEMReference::Its.elements('cwor').contains('foo'), 'AEM.its.elements("cwor").contains("foo")', nil],
+			[AEMReference::Its.elements('cwor').is_in('foo'), 'AEM.its.elements("cwor").is_in("foo")', nil],
+			
+			[AEMReference::App.elements('docu').by_filter(AEMReference::Its.property('size').ge(42)), 
+					'AEM.app.elements("docu").by_filter(AEM.its.property("size").ge(42))', nil],
+					
+			[AEMReference::App.elements('docu').by_index(1).property('ctxt') \
+					.elements('cpar').elements('cha ').by_range(
+							AEMReference::Con.elements('cha ').by_index(3), 
+							AEMReference::Con.elements('cha ').by_index(55)
+					).next('cha ').after,
+					'AEM.app.elements("docu").by_index(1).property("ctxt").elements("cpar").elements("cha ")' +
+					'.by_range(AEM.con.elements("cha ").by_index(3), AEM.con.elements("cha ").by_index(55))' +
+					'.next("cha ").after', nil],
+			
+			[AEMReference::Its.property('pnam').ne('foo').and(AEMReference::Its.elements('cfol').eq([])).not,
+					'AEM.its.property("pnam").ne("foo").and(AEM.its.elements("cfol").eq([])).not',
+					AEMReference::Its.property('pnam').eq('foo').not.and(AEMReference::Its.elements('cfol').eq([])).not],
+			
+			[AEMReference::App.elements('docu').start, 'AEM.app.elements("docu").start', nil],
+			[AEMReference::App.elements('docu').end, 'AEM.app.elements("docu").end', nil],
+			[AEMReference::App.elements('docu').by_index(3).before, 'AEM.app.elements("docu").by_index(3).before', nil],
+			[AEMReference::App.elements('docu').by_name('foo').after, 'AEM.app.elements("docu").by_name("foo").after', nil],
+			
+		].each do |val, res, unpacked_version|
+			begin
+				assert_equal(res, val.to_s)
+				d = DefaultCodecs.pack(val)
+				val = unpacked_version ? unpacked_version : val
+				val2 = DefaultCodecs.unpack(d)
+				assert_equal(val, val2)
+				val2 = DefaultCodecs.unpack(d)
+				assert_block { val.eql?(val2) }
+				val2 = DefaultCodecs.unpack(d)
+				assert_equal(val2, val)
+				val2 = DefaultCodecs.unpack(d)
+				assert_block { val2.eql?(val) }
+			rescue
+				puts 'EXPECTED: ' + res
+				raise
+			end
+		end
+		assert_not_equal(AEMReference::App.property('ctxt').property('ctxt'), AEMReference::Con.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.property('foob').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.elements('ctxt').property('ctxt'), AEMReference::App.property('ctxt').property('ctxt'))
+		assert_not_equal(AEMReference::App.elements('ctxt').property('ctxt'), 333)
+		assert_not_equal(333, AEMReference::App.property('ctxt').property('ctxt'))
+		# by-range and by-filter references do basic type checking to ensure a reference is given
+		assert_raises(TypeError) { AEMReference::App.elements('docu').by_range(1, 2) }
+		assert_raises(TypeError) { AEMReference::App.elements('docu').by_filter(1) }
+		
+	end
+end
+

data/test/test_appscriptreference.rb

@@ -0,0 +1,102 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'
+require "appscript"
+
+
+class TC_AppscriptReferences < Test::Unit::TestCase
+
+	def setup
+		@te = AS.app('TextEdit')
+		@s = @te.to_s
+	end
+
+	def test_reference_forms
+		[
+			[@te.text, @s+'.text', nil],
+			
+			[@te.documents, @s+'.documents', nil],
+			
+			[@te.documents[1], 
+					@s+'.documents[1]', nil],
+			[@te.documents['foo'], 
+					@s+'.documents["foo"]', nil],
+			[@te.documents.ID(300), 
+					@s+'.documents.ID(300)', nil],
+			
+			[@te.documents.next(:document), 
+					@s+'.documents.next(:document)', nil],
+			[@te.documents.previous(:document), 
+					@s+'.documents.previous(:document)', nil],
+			
+			[@te.documents.first, @s+'.documents.first', nil],
+			[@te.documents.middle, @s+'.documents.middle', nil],
+			[@te.documents.last, @s+'.documents.last', nil],
+			[@te.documents.any, @s+'.documents.any', nil],
+			
+			[AS.con.documents[3], 'AS.con.documents[3]', nil],
+			
+			[@te.documents[
+					AS.con.documents[3],
+					AS.con.documents['foo']], 
+					@s+'.documents[' +
+					'AS.con.documents[3], ' +
+					'AS.con.documents["foo"]]', nil],
+			
+			
+			[AS.its.name.eq('foo').and(AS.its.words.eq([])), 
+					'AS.its.name.eq("foo").and(AS.its.words.eq([]))', nil],
+			
+			[AS.its.words.ne([]), 
+					'AS.its.words.ne([])', 
+					AS.its.words.eq([]).not], # i.e. there isn't a KAENotEqual operator, so not-equal tests are actually packed as an equal test followed by not test
+					
+			[AS.its.words.eq(nil), 'AS.its.words.eq(nil)', nil],
+			[AS.its.words.size.gt(0), 
+					'AS.its.words.size.gt(0)', nil],
+			[AS.its.words.le(''), 'AS.its.words.le("")', nil],
+			[AS.its.words.starts_with('foo').not, 
+					'AS.its.words.starts_with("foo").not', nil],
+			
+			
+			[AS.its.words.contains('foo'), 'AS.its.words.contains("foo")', nil],
+			[AS.its.words.is_in('foo'), 'AS.its.words.is_in("foo")', nil],
+			
+			[@te.documents[AS.its.size.ge(42)], 
+					@s+'.documents[AS.its.size.ge(42)]', nil],
+			
+			[@te.documents[1, 'foo'], 
+					@s+'.documents[AS.con.documents[1], AS.con.documents["foo"]]', 
+					@te.documents[AS.con.documents[1], AS.con.documents['foo']]],
+			
+			[@te.documents[1].text \
+					.paragraphs.characters[
+							AS.con.characters[3], 
+							AS.con.characters[55]
+					].next(:character).after,
+					@s+'.documents[1].text.paragraphs.characters' +
+					'[AS.con.characters[3], AS.con.characters[55]]' +
+					'.next(:character).after', nil],
+			
+			[AS.its.name.ne('foo').and(AS.its.words.eq([])).not,
+					'AS.its.name.ne("foo").and(AS.its.words.eq([])).not',
+					AS.its.name.eq('foo').not.and(AS.its.words.eq([])).not],
+			
+			[@te.documents.start, @s+'.documents.start', nil],
+			[@te.documents.end, @s+'.documents.end', nil],
+			[@te.documents[3].before, @s+'.documents[3].before', nil],
+			[@te.documents['foo'].after, @s+'.documents["foo"].after', nil],
+			
+		].each do |val, res, unpacked_version|
+			assert_equal(res, val.to_s)
+			d = @te.AS_app_data.pack(val)
+			val = unpacked_version ? unpacked_version : val
+			val2 = @te.AS_app_data.unpack(d)
+			if val.class == @te.AS_app_data.unpack(d).class # note: AS::Reference and AS::GenericReference currently aren't comparable with each other, so the next test would always fail for those
+				assert_equal(val, val2)
+				assert_block { val.eql?(val2) }
+			end
+		end
+	end
+end
+

data/test/test_codecs.rb

@@ -0,0 +1,159 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'
+require 'aem'
+require 'kae'
+require 'ae'
+
+def num(s)
+	if [1].pack('s') == "\001\000" # host system is i386
+		s.reverse
+	else
+		s
+	end
+end
+
+def ut16(s)
+	if [1].pack('s') == "\001\000" # host system is i386
+		i = 0
+		s2 = ''
+		(s.length / 2).times do
+			s2 += s[i, 2].reverse
+			i+=2
+		end
+		s2
+	else
+		s
+	end
+end
+
+
+
+
+class TC_Codecs < Test::Unit::TestCase
+	
+	def setup
+		@c = AEM::Codecs.new
+	end
+	
+	def test_nil
+		d = @c.pack(nil)
+		assert_equal(KAE::TypeNull, d.type)
+		assert_equal('', d.data)
+		assert_nil(@c.unpack(d))
+	end
+	
+	def test_bool
+		[
+			[true, KAE::TypeTrue],
+			[false, KAE::TypeFalse]
+		].each do |val, type|
+			d = @c.pack(val)
+			assert_equal(type, d.type)
+			assert_equal('', d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+		assert_equal(true, @c.unpack(AE::AEDesc.new(KAE::TypeBoolean, "\xfe")))
+		assert_equal(true, @c.unpack(AE::AEDesc.new(KAE::TypeTrue, '')))
+		assert_equal(false, @c.unpack(AE::AEDesc.new(KAE::TypeFalse, '')))
+	end
+	
+	def test_num
+		[ # (mostly testing at threshold points where Codecs switches types when packing integers)
+			[0, "\x00\x00\x00\x00", KAE::TypeInteger],
+			[2, "\x00\x00\x00\x02", KAE::TypeInteger],
+			[-9, "\xff\xff\xff\xf7", KAE::TypeInteger],
+			[2**31-1, "\x7f\xff\xff\xff", KAE::TypeInteger],
+			[-2**31, "\x80\x00\x00\x00", KAE::TypeInteger],
+			[2**31, "\x00\x00\x00\x00\x80\x00\x00\x00", KAE::TypeSInt64],
+			[2**32-1, "\x00\x00\x00\x00\xff\xff\xff\xff", KAE::TypeSInt64],
+			[2**32, "\x00\x00\x00\x01\x00\x00\x00\x00", KAE::TypeSInt64], 
+			[-2**32, "\xff\xff\xff\xff\x00\x00\x00\x00", KAE::TypeSInt64],
+			[2**63-1, "\x7f\xff\xff\xff\xff\xff\xff\xff", KAE::TypeSInt64], 
+			[-2**63, "\x80\x00\x00\x00\x00\x00\x00\x00", KAE::TypeSInt64],
+			[-2**63+1, "\x80\x00\x00\x00\x00\x00\x00\x01", KAE::TypeSInt64],
+			[2**63, "C\xe0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+			[-2**63-1, "\xc3\xe0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+			[0.1, "?\xb9\x99\x99\x99\x99\x99\x9a", KAE::TypeFloat],
+			[-0.9e-9, "\xbe\x0e\xec{\xd5\x12\xb5r", KAE::TypeFloat],
+			[2**300, "R\xb0\x00\x00\x00\x00\x00\x00", KAE::TypeFloat],
+		].each do |val, data, type|
+			data = num(data)
+			d = @c.pack(val)
+			assert_equal(type, d.type)
+			assert_equal(data, d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+	end
+	
+	def test_str
+		[
+			# note: aem has to pack UTF8 data as typeUnicodeText (UTF16) as stupid apps expect that type and will error on typeUTF8Text instead of just asking AEM to coerce it to the desired type in advance.
+			# note: UTF16 BOM must be omitted when packing UTF16 data into typeUnicodeText AEDescs, as a BOM will upset stupid apps like iTunes 7 that don't recognise it as a BOM and treat it as character data instead
+			['', ''],
+			['hello', "\000h\000e\000l\000l\000o"],
+			["\xc6\x92\xe2\x88\x82\xc2\xae\xd4\xb7\xd5\x96\xd4\xb9\xe0\xa8\x89\xe3\x82\xa2\xe3\x84\xbb",
+				"\x01\x92\"\x02\x00\xae\x057\x05V\x059\n\t0\xa21;"],
+		].each do |val, data, type|
+			data = ut16(data)
+			d = @c.pack(val)
+			assert_equal(KAE::TypeUnicodeText, d.type)
+			assert_equal(data, d.data)
+			assert_equal(val, @c.unpack(d))
+		end
+		assert_raises(TypeError) { @c.pack("\x88") } # non-valid UTF8 strings should raise error when coercing from typeUTF8Text to typeUnicodeText
+	end
+	
+	def test_date
+		# note: not testing on ST-DST boundaries; this is known to have out-by-an-hour problems due to LongDateTime type being crap
+		[
+			[Time.local(2005, 12, 11, 15, 40, 43), "\x00\x00\x00\x00\xbf\xc1\xf8\xfb"],
+			[Time.local(2005, 5, 1, 6, 51, 7), "\x00\x00\x00\x00\xbe\x9a\x2c\xdb"],
+		].each do |t, data|
+			data = num(data)
+			d = @c.pack(t)
+			assert_equal(KAE::TypeLongDateTime, d.type)
+			assert_equal(data, d.data)
+			assert_equal(t, @c.unpack(AE::AEDesc.new(KAE::TypeLongDateTime, data)))
+		end
+	end
+	
+	def test_file
+		path = '/Applications/TextEdit.app/'
+		d = @c.pack(MacTypes::Alias.path(path))
+		assert_equal(path, @c.unpack(d).to_s)
+		
+		path = '/Applications/TextEdit.app'
+		d = @c.pack(MacTypes::FileURL.path(path))
+		assert_equal(path, @c.unpack(d).to_s)
+	end
+	
+	def test_typewrappers
+		[
+			AEM::AEType.new("docu"),
+			AEM::AEEnum.new('yes '),
+			AEM::AEProp.new('pnam'),
+			AEM::AEKey.new('ABCD'),
+		].each do |val|
+			d = @c.pack(val)
+			val2 = @c.unpack(d)
+			assert_equal(val, val2)
+			assert_block { val.eql?(val2) }
+			val2 = @c.unpack(d)
+			assert_equal(val2, val)
+			assert_block { val2.eql?(val) }
+		end
+		assert_raises(ArgumentError) { AEM::AEType.new(3) }
+		assert_raises(ArgumentError) { AEM::AEType.new("docum") }
+	end
+	
+	def test_list
+	end
+	
+	def test_hash
+		val = {'foo' => 1, AEM::AEType.new('foob') => 2, AEM::AEProp.new('barr') => 3} # TO DO: also need to test appscript codecs (in separate test) to check String, AEType and Symbol keys all pack and unpack correctly
+		expected_val = {'foo' => 1, AEM::AEType.new('foob') => 2, AEM::AEType.new('barr') => 3} # note that four-char-code keys are always unpacked as AEType
+		d = @c.pack(val)
+		assert_equal(expected_val, @c.unpack(d))
+	end
+end

data/test/test_findapp.rb

@@ -0,0 +1,24 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'
+require "_aem/findapp"
+
+
+class TC_FindApp < Test::Unit::TestCase
+
+	def test_find
+		[
+			['/Applications/iCal.app', '/Applications/iCal.app'],
+			['ical.app', '/Applications/iCal.app'],
+			['ICAL', '/Applications/iCal.app'],
+		].each do |val, res|
+			assert_equal(res, FindApp.by_name(val))
+		end
+		assert_equal('/Applications/TextEdit.app', FindApp.by_creator('ttxt'))
+		assert_equal('/System/Library/CoreServices/Finder.app', FindApp.by_id('com.apple.finder'))
+		assert_raises(FindApp::ApplicationNotFoundError) { FindApp.by_name('NON-EXISTENT-APP') }
+
+		# assert_equal("/Users/has/\306\222\303\270u\314\210.app", FindApp.by_name("\306\222\303\270u\314\210.app")) # utf8 paths work ok
+	end
+end
+		

data/test/test_mactypes.rb

@@ -0,0 +1,67 @@
+#!/usr/local/bin/ruby
+
+require 'test/unit'
+require "_aem/mactypes"
+
+
+class TC_MacTypes < Test::Unit::TestCase
+	
+	def setup
+		@path1 = `mktemp -t codecs-test`.chomp
+		dir, fname = File.split(@path1)
+		@path2 = File.join(dir, 'moved-' + fname)
+		# puts "path: #{@path1}" # e.g. /tmp/codecs-test.HWr1EnE3
+	end
+	
+	def test_alias
+		# make alias
+		f = MacTypes::Alias.path(@path1)
+		
+		
+		assert_equal(MacTypes::Alias.path(@path1), f)
+		
+		# get path
+		# note that initial /tmp/codecs-test... path will automatically change to /private/tmp/codecs-test...
+		p1 = '/private'+@path1
+		p2 = '/private'+@path2
+		
+		assert_equal("MacTypes::Alias.path(#{p1.inspect})", f.inspect)
+		
+		#puts "alias path 1: #{f}" # e.g. /private/tmp/codecs-test.HWr1EnE3
+		assert_equal(p1, f.to_s)
+		
+		# get desc
+		#puts f.desc.type, f.desc.data # alis, [binary data]
+		assert_equal('alis', f.desc.type)
+
+		
+		# check alias keeps track of moved file
+		`mv #{@path1} #{@path2}`
+		# puts "alias path 2: #{f}" # /private/tmp/moved-codecs-test.HWr1EnE3
+		assert_equal(p2, f.to_s)
+
+		assert_equal("MacTypes::Alias.path(#{p2.inspect})", f.inspect)
+		
+		# check a FileNotFoundError is raised if getting path/FileURL for a filesystem object that no longer exists
+		`rm #{@path2}`
+		assert_raises(MacTypes::FileNotFoundError) { f.to_s } # File not found.
+		assert_raises(MacTypes::FileNotFoundError) { f.to_file_url } # File not found.
+	end
+
+
+	def test_file_url
+
+		g = MacTypes::FileURL.path('/non/existent path')
+
+		assert_equal('/non/existent path', g.to_s)
+		
+		assert_equal('furl', g.desc.type)
+		assert_equal('file://localhost/non/existent%20path', g.desc.data)
+
+		assert_equal('MacTypes::FileURL.path("/non/existent path")', g.to_file_url.inspect)
+
+		# check a not-found error is raised if getting Alias for a filesystem object that doesn't exist
+		assert_raises(MacTypes::FileNotFoundError) { g.to_alias } # File "/non/existent path" not found.
+
+	end
+end

data/test/testall.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+for f in `ls | grep test_`;
+do
+	/usr/local/bin/ruby $f
+	echo
+	echo
+done
+

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: rb-appscript
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2006-11-21 00:00:00 +00:00
+summary: Ruby appscript (rb-appscript) is a high-level, user-friendly Apple event bridge that allows you to control scriptable Mac OS X applications using ordinary Ruby scripts.
+require_paths: 
+- lib
+email: 
+homepage: http://rb-appscript.rubyforge.org/
+rubyforge_project: rb-appscript
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- HAS
+files: 
+- CHANGES
+- doc
+- extconf.rb
+- LICENSE
+- misc
+- rb-appscript.gemspec
+- README
+- sample
+- src
+- test
+- TODO
+- doc/aem-manual
+- doc/appscript-manual
+- doc/index.html
+- doc/mactypes-manual
+- doc/osax-manual
+- doc/aem-manual/01_introduction.html
+- doc/aem-manual/02_apioverview.html
+- doc/aem-manual/03_packingandunpackingdata.html
+- doc/aem-manual/04_references.html
+- doc/aem-manual/05_targettingapplications.html
+- doc/aem-manual/06_buildingandsendingevents.html
+- doc/aem-manual/07_findapp.html
+- doc/aem-manual/08_examples.html
+- doc/aem-manual/09_notes.html
+- doc/aem-manual/aemreferenceinheritance.gif
+- doc/aem-manual/full.css
+- doc/aem-manual/index.html
+- doc/appscript-manual/01_introduction.html
+- doc/appscript-manual/02_aboutappscripting.html
+- doc/appscript-manual/03_quicktutorial.html
+- doc/appscript-manual/04_gettinghelp.html
+- doc/appscript-manual/05_keywordconversion.html
+- doc/appscript-manual/06_classesandenums.html
+- doc/appscript-manual/07_applicationobjects.html
+- doc/appscript-manual/08_realvsgenericreferences.html
+- doc/appscript-manual/09_referenceforms.html
+- doc/appscript-manual/10_referenceexamples.html
+- doc/appscript-manual/11_applicationcommands.html
+- doc/appscript-manual/12_commandexamples.html
+- doc/appscript-manual/13_performanceissues.html
+- doc/appscript-manual/14_problemapps.html
+- doc/appscript-manual/15_notes.html
+- doc/appscript-manual/application_architecture.gif
+- doc/appscript-manual/application_architecture2.gif
+- doc/appscript-manual/finder_to_textedit_event.gif
+- doc/appscript-manual/full.css
+- doc/appscript-manual/index.html
+- doc/appscript-manual/relationships_example.gif
+- doc/appscript-manual/ruby_to_itunes_event.gif
+- doc/mactypes-manual/index.html
+- doc/osax-manual/index.html
+- misc/adobeunittypes.rb
+- misc/dump.rb
+- sample/AB_list_people_with_emails.rb
+- sample/Create_daily_iCal_todos.rb
+- sample/Hello_world.rb
+- sample/iTunes_top40_to_html.rb
+- sample/List_iTunes_playlist_names.rb
+- sample/Make_Mail_message.rb
+- sample/Open_file_in_TextEdit.rb
+- sample/Organize_Mail_messages.rb
+- sample/Print_folder_tree.rb
+- sample/Select_all_HTML_files.rb
+- sample/Set_iChat_status.rb
+- sample/Simple_Finder_GUI_Scripting.rb
+- sample/Stagger_Finder_windows.rb
+- sample/TextEdit_demo.rb
+- src/lib
+- src/rbae.c
+- src/lib/_aem
+- src/lib/_appscript
+- src/lib/aem.rb
+- src/lib/appscript.rb
+- src/lib/kae.rb
+- src/lib/osax.rb
+- src/lib/_aem/aemreference.rb
+- src/lib/_aem/codecs.rb
+- src/lib/_aem/connect.rb
+- src/lib/_aem/findapp.rb
+- src/lib/_aem/mactypes.rb
+- src/lib/_aem/send.rb
+- src/lib/_aem/typewrappers.rb
+- src/lib/_appscript/defaultterminology.rb
+- src/lib/_appscript/referencerenderer.rb
+- src/lib/_appscript/reservedkeywords.rb
+- src/lib/_appscript/terminology.rb
+- test/README
+- test/test_aemreference.rb
+- test/test_appscriptreference.rb
+- test/test_codecs.rb
+- test/test_findapp.rb
+- test/test_mactypes.rb
+- test/testall.sh
+test_files: 
+- test/test_aemreference.rb
+- test/test_appscriptreference.rb
+- test/test_codecs.rb
+- test/test_findapp.rb
+- test/test_mactypes.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+