rb-appscript 0.5.3 → 0.6.0

data/src/lib/aem.rb

@@ -4,8 +4,6 @@
 # aem -- a mid-level object-oriented API for creating and sending Apple events
 #    using raw AE codes; may be used directly or via high-level appscript wrapper
 #
-# Copyright (C) 2006-2009 HAS. Released under MIT License.
-#
 
 require "ae"
 require "kae"
@@ -39,7 +37,8 @@ module AEM
 	AEProp = TypeWrappers::AEProp
 	AEKey = TypeWrappers::AEKey
 	
-	CommandError = Send::CommandError
+	EventError = Send::EventError	
+	CommandError = Send::EventError # deprecated class name; kept for backwards compatibility
 	
 	#######
 	# Reference roots
@@ -63,7 +62,7 @@ module AEM
 	#######
 	# Application class
 	
-	class Application < AEMReference::Base
+	class Application < AEMReference::Query
 		# Identifies an application and provides an #event method for constructing Apple events targetted at it.
 	
 		require "weakref"

data/src/lib/appscript.rb

@@ -4,8 +4,6 @@
 # appscript -- syntactically sugared wrapper around the mid-level aem API;
 #    provides a high-level, easy-to-use API for creating and sending Apple events
 #
-# Copyright (C) 2006-2009 HAS. Released under MIT License.
-#
 
 require "_aem/mactypes"
 
@@ -118,7 +116,7 @@ module Appscript
 						'aRef' => pack(ref),
 					}).send)
 				return nil
-			rescue AEM::CommandError => e
+			rescue AEM::EventError => e
 				return e
 			end
 		end
@@ -324,7 +322,8 @@ module Appscript
 	
 		def to_s
 			s= @_call[0]
-			@_call[1, @_call.length].each do |name, args|					if name == :[]
+			@_call[1, @_call.length].each do |name, args|
+				if name == :[]
 					if args.length == 1
 						s += "[#{args[0].inspect}]"
 					else
@@ -506,7 +505,7 @@ module Appscript
 			begin
 				return @AS_app_data.target.event(code, params, atts, 
 						KAE::KAutoGenerateReturnID, @AS_app_data).send(timeout, send_flags)
-			rescue AEM::CommandError => e
+			rescue AEM::EventError => e
 				if e.number == -1708 and code == 'ascrnoop'
 					return # 'launch' events always return 'not handled' errors; just ignore these
 				elsif [-600, -609].include?(e.number) and @AS_app_data.constructor == :by_path 
@@ -535,7 +534,7 @@ module Appscript
 					begin
 						return @AS_app_data.target.event(code, params, atts, 
 								KAE::KAutoGenerateReturnID, @AS_app_data).send(timeout, send_flags)
-					rescue AEM::CommandError => e
+					rescue AEM::EventError => e
 						raise CommandError.new(self, name, args, e, @AS_app_data)
 					end
 				end
@@ -885,7 +884,7 @@ module Appscript
 		def AS_new_reference(ref)
 			if ref.is_a?(Appscript::GenericReference)
 				return ref.AS_resolve(@AS_app_data)
-			elsif ref.is_a?(AEMReference::Base)
+			elsif ref.is_a?(AEMReference::Query)
 				return Reference.new(@AS_app_data, ref)
 			elsif ref == nil
 				return  Reference.new(@AS_app_data, AEM.app)
@@ -913,7 +912,7 @@ module Appscript
 			else
 				begin
 					@AS_app_data.target.event('ascrnoop').send # will send launch event to app if already running; else will error
-				rescue AEM::CommandError => e
+				rescue AEM::EventError => e
 					raise if e.to_i != -1708
 				end
 			end
@@ -1021,7 +1020,7 @@ module Appscript
 		end
 		
 		def to_s
-			if @real_error.is_a?(AEM::CommandError)
+			if @real_error.is_a?(AEM::EventError)
 				err = "CommandError\n\t\tOSERROR: #{error_number}"
 				err += "\n\t\tMESSAGE: #{error_message}" if error_message != ''
 				[
@@ -1039,7 +1038,7 @@ module Appscript
 		end
 		
 		def error_number
-			if @real_error.is_a?(AE::MacOSError) or @real_error.is_a?(AEM::CommandError)
+			if @real_error.is_a?(AE::MacOSError) or @real_error.is_a?(AEM::EventError)
 				return @real_error.to_i
 			else
 				return -2700
@@ -1053,19 +1052,19 @@ module Appscript
 		end
 		
 		def offending_object
-			return nil if not @real_error.is_a?(AEM::CommandError)
+			return nil if not @real_error.is_a?(AEM::EventError)
 			desc = @real_error.raw[KAE::KOSAErrorOffendingObject]
 			return desc ? @codecs.unpack(desc) : nil
 		end
 		
 		def expected_type
-			return nil if not @real_error.is_a?(AEM::CommandError)
+			return nil if not @real_error.is_a?(AEM::EventError)
 			desc = @real_error.raw[KAE::KOSAErrorExpectedType]
 			return desc ? @codecs.unpack(desc) : nil
 		end
 		
 		def partial_result
-			return nil if not @real_error.is_a?(AEM::CommandError)
+			return nil if not @real_error.is_a?(AEM::EventError)
 			desc = @real_error.raw[KAE::KOSAErrorPartialResult]
 			return desc ? @codecs.unpack(desc) : nil
 		end

data/src/lib/osax.rb

@@ -3,20 +3,411 @@
 #
 # osax -- invoke scripting addition (OSAX) commands from Ruby
 #
-# Copyright (C) 2006-2009 HAS. Released under MIT License.
-#
 
 require "appscript"
 
 module OSAX
+
 	
 	######################################################################
 	# PRIVATE
 	######################################################################
 	
+	require 'rexml/document'
 	require "ae"
 	require "kae"
 	require "aem"
+	require "_appscript/reservedkeywords" # names of all existing methods on ASReference::Application
+	
+	StandardAdditionsEnums = [
+			["stop", "\000\000\000\000"],
+			["note", "\000\000\000\001"],
+			["caution", "\000\000\000\002"]]
+	
+	UTF8ToMacRoman = {
+			0 => 0,
+			1 => 1,
+			2 => 2,
+			3 => 3,
+			4 => 4,
+			5 => 5,
+			6 => 6,
+			7 => 7,
+			8 => 8,
+			9 => 9,
+			10 => 10,
+			11 => 11,
+			12 => 12,
+			13 => 13,
+			14 => 14,
+			15 => 15,
+			16 => 16,
+			17 => 17,
+			18 => 18,
+			19 => 19,
+			20 => 20,
+			21 => 21,
+			22 => 22,
+			23 => 23,
+			24 => 24,
+			25 => 25,
+			26 => 26,
+			27 => 27,
+			28 => 28,
+			29 => 29,
+			30 => 30,
+			31 => 31,
+			32 => 32,
+			33 => 33,
+			34 => 34,
+			35 => 35,
+			36 => 36,
+			37 => 37,
+			38 => 38,
+			39 => 39,
+			40 => 40,
+			41 => 41,
+			42 => 42,
+			43 => 43,
+			44 => 44,
+			45 => 45,
+			46 => 46,
+			47 => 47,
+			48 => 48,
+			49 => 49,
+			50 => 50,
+			51 => 51,
+			52 => 52,
+			53 => 53,
+			54 => 54,
+			55 => 55,
+			56 => 56,
+			57 => 57,
+			58 => 58,
+			59 => 59,
+			60 => 60,
+			61 => 61,
+			62 => 62,
+			63 => 63,
+			64 => 64,
+			65 => 65,
+			66 => 66,
+			67 => 67,
+			68 => 68,
+			69 => 69,
+			70 => 70,
+			71 => 71,
+			72 => 72,
+			73 => 73,
+			74 => 74,
+			75 => 75,
+			76 => 76,
+			77 => 77,
+			78 => 78,
+			79 => 79,
+			80 => 80,
+			81 => 81,
+			82 => 82,
+			83 => 83,
+			84 => 84,
+			85 => 85,
+			86 => 86,
+			87 => 87,
+			88 => 88,
+			89 => 89,
+			90 => 90,
+			91 => 91,
+			92 => 92,
+			93 => 93,
+			94 => 94,
+			95 => 95,
+			96 => 96,
+			97 => 97,
+			98 => 98,
+			99 => 99,
+			100 => 100,
+			101 => 101,
+			102 => 102,
+			103 => 103,
+			104 => 104,
+			105 => 105,
+			106 => 106,
+			107 => 107,
+			108 => 108,
+			109 => 109,
+			110 => 110,
+			111 => 111,
+			112 => 112,
+			113 => 113,
+			114 => 114,
+			115 => 115,
+			116 => 116,
+			117 => 117,
+			118 => 118,
+			119 => 119,
+			120 => 120,
+			121 => 121,
+			122 => 122,
+			123 => 123,
+			124 => 124,
+			125 => 125,
+			126 => 126,
+			127 => 127,
+			196 => 128,
+			197 => 129,
+			199 => 130,
+			201 => 131,
+			209 => 132,
+			214 => 133,
+			220 => 134,
+			225 => 135,
+			224 => 136,
+			226 => 137,
+			228 => 138,
+			227 => 139,
+			229 => 140,
+			231 => 141,
+			233 => 142,
+			232 => 143,
+			234 => 144,
+			235 => 145,
+			237 => 146,
+			236 => 147,
+			238 => 148,
+			239 => 149,
+			241 => 150,
+			243 => 151,
+			242 => 152,
+			244 => 153,
+			246 => 154,
+			245 => 155,
+			250 => 156,
+			249 => 157,
+			251 => 158,
+			252 => 159,
+			8224 => 160,
+			176 => 161,
+			162 => 162,
+			163 => 163,
+			167 => 164,
+			8226 => 165,
+			182 => 166,
+			223 => 167,
+			174 => 168,
+			169 => 169,
+			8482 => 170,
+			180 => 171,
+			168 => 172,
+			8800 => 173,
+			198 => 174,
+			216 => 175,
+			8734 => 176,
+			177 => 177,
+			8804 => 178,
+			8805 => 179,
+			165 => 180,
+			181 => 181,
+			8706 => 182,
+			8721 => 183,
+			8719 => 184,
+			960 => 185,
+			8747 => 186,
+			170 => 187,
+			186 => 188,
+			937 => 189,
+			230 => 190,
+			248 => 191,
+			191 => 192,
+			161 => 193,
+			172 => 194,
+			8730 => 195,
+			402 => 196,
+			8776 => 197,
+			8710 => 198,
+			171 => 199,
+			187 => 200,
+			8230 => 201,
+			160 => 202,
+			192 => 203,
+			195 => 204,
+			213 => 205,
+			338 => 206,
+			339 => 207,
+			8211 => 208,
+			8212 => 209,
+			8220 => 210,
+			8221 => 211,
+			8216 => 212,
+			8217 => 213,
+			247 => 214,
+			9674 => 215,
+			255 => 216,
+			376 => 217,
+			8260 => 218,
+			8364 => 219,
+			8249 => 220,
+			8250 => 221,
+			64257 => 222,
+			64258 => 223,
+			8225 => 224,
+			183 => 225,
+			8218 => 226,
+			8222 => 227,
+			8240 => 228,
+			194 => 229,
+			202 => 230,
+			193 => 231,
+			203 => 232,
+			200 => 233,
+			205 => 234,
+			206 => 235,
+			207 => 236,
+			204 => 237,
+			211 => 238,
+			212 => 239,
+			63743 => 240,
+			210 => 241,
+			218 => 242,
+			219 => 243,
+			217 => 244,
+			305 => 245,
+			710 => 246,
+			732 => 247,
+			175 => 248,
+			728 => 249,
+			729 => 250,
+			730 => 251,
+			184 => 252,
+			733 => 253,
+			731 => 254,
+			711 => 255}
+	
+	class SdefParser
+		@@_name_cache = {}
+		LegalFirst = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
+		LegalRest = LegalFirst + '0123456789'
+		@@_reserved_keywords = {} # ersatz set
+		ReservedKeywords.each { |name| @@_reserved_keywords[name] = nil }
+		
+		attr_reader :properties, :elements, :classes, :enumerators
+		
+		def commands
+			return @commands.values
+		end
+		
+		def initialize
+			# terminology tables; order is significant where synonym definitions occur
+			@commands = {}
+			@properties = []
+			@elements = []
+			@classes = []
+			@enumerators = []
+		end
+		
+		def _name(s)
+			# Read a MacRoman-encoded Pascal keyword string.
+			if not @@_name_cache.has_key?(s)
+				legal = LegalFirst
+				res = ''
+				s.split(//).each do |c|
+					if legal[c]
+						res += c
+					else
+						case c
+							when ' ', '-', '/'
+								res += '_'
+							when '&'
+								res += 'and'
+						else
+							if res == ''
+								res = '_'
+							end
+							res += "0x#{c.unpack('HXh')}"
+						end
+					end
+					legal = LegalRest
+				end
+				if res[0, 3] == 'AS_' or @@_reserved_keywords.has_key?(res) or res[0, 1] == '_'
+					res += '_'
+				end
+				@@_name_cache[s] = res
+			end
+			return @@_name_cache[s]
+		end
+		
+		def _code(s)
+			return s.unpack('U*').collect do |c| # unpack UTF8-encoded byte string
+				OSAX::UTF8ToMacRoman.fetch(c)
+			end .pack('C*') # pack as MacRoman-encoded byte string (four- or eight-char code)
+		end
+			
+		def _addnamecode(node, collection)
+			name = _name(node.attributes['name'])
+			code = _code(node.attributes['code'])
+			if name != '' and code.size == 4 and not collection.include?([name, code])
+				collection.push([name, code])
+			end
+		end
+		
+		def _addcommand(node)
+			name = _name(node.attributes['name'])
+			code = _code(node.attributes['code'])
+			parameters = []
+			# Note: overlapping command definitions (e.g. 'path to') should be processed as follows:
+			# - If their names and codes are the same, only the last definition is used; other definitions are ignored and will not compile.
+			# - If their names are the same but their codes are different, only the first definition is used; other definitions are ignored and will not compile.
+			if name != '' and code.size == 8 and (not @commands.has_key?(name) or @commands[name][1] == code)
+				@commands[name] = [name, code, parameters]
+				node.each_element('parameter') do |pnode|
+					_addnamecode(pnode, parameters)
+				end
+			end
+		end
+		
+		def parse(xml)
+			# Extract name-code mappings from an sdef.
+			#
+			#	xml : String -- sdef data
+			xml = REXML::Document.new(xml)
+			xml.root.each_element('suite/*') do |node| 
+				begin
+					if ['command', 'event'].include?(node.name)
+						_addcommand(node)
+					elsif ['class', 'record-type', 'value-type'].include?(node.name)
+						_addnamecode(node, @classes)
+						node.each_element('property') do |prop|
+							_addnamecode(prop, @properties)
+						end
+						if node.name == 'class' # elements
+							name = node.attributes['plural']
+							if name == nil
+								name = node.attributes['name']
+								name = "#{name}s" if name != nil
+							end
+							name = _name(name)
+							code = _code(node.attributes['code'])
+							if name != '' and code.size == 4
+								@elements.push([name, code])
+							end
+						end
+					elsif node.name == 'enumeration'
+						node.each_element('enumerator') do |enum|
+							_addnamecode(enum, @enumerators)
+						end
+					end
+				rescue # ignore problem definitions
+				end
+			end
+		end
+		
+		def parse_file(path)
+			# Extract name-code mappings from an sdef.
+			#
+			#	path :  String -- path to .sdef file
+			parse(AE.copy_scripting_definition(path))
+		end
+		
+	end
 	
 	#######
 	# cache; stores osax paths and previously parsed terminology (if any) by osax name
@@ -37,7 +428,7 @@ module OSAX
 			super
 			begin
 				@target.event('ascrgdut').send(60 * 60) # make sure target application has loaded event handlers for all installed OSAXen
-			rescue AEM::CommandError => e
+			rescue AEM::EventError => e
 				if e.number != -1708 # ignore 'event not handled' error
 					raise
 				end
@@ -147,13 +538,12 @@ module OSAX
 					raise ArgumentError, "Scripting addition not found: #{name.inspect}"
 				end
 				if not terminology_tables
-					begin
-						aetes_desc = AE.get_app_terminology(path) # will raise NotImplementedError in 64-bit processes
-					rescue NotImplementedError
-						raise RuntimeError, "OSAX::ScriptingAddition can't dynamically retrieve scripting addition terminology within a 64-bit process."
+					sp = OSAX::SdefParser.new
+					sp.parse_file(path)
+					if osax_name == 'standardadditions'
+						OSAX::StandardAdditionsEnums.each { |o| sp.enumerators.push(o)}
 					end
-					aetes = DefaultCodecs.unpack(aetes_desc.coerce(KAE::TypeAEList))
-					terminology_tables = Terminology.tables_for_aetes(aetes)
+					terminology_tables = Terminology.tables_for_parsed_sdef(sp)
 					OSAXCache[osax_name][1] = terminology_tables
 				end
 				@_terms = terminology_tables
@@ -228,5 +618,42 @@ module OSAX
 			return ScriptingAddition.new(@_osax_name, OSAXData.new(:current, nil, @_terms))
 		end
 	end
+
+	#######
 	
+	def OSAX.dump(osax_name, module_name, out_path)
+		# Export scripting addition terminology tables as a Ruby module
+		# osaxname : string -- name of installed scripting addition
+		# module_name : string -- name of generated module (must be a valid Ruby constant)
+		# out_path : string -- module file to write
+		# 			
+		# Generates a Ruby module containing a scripting addition's basic terminology 
+		# (names and codes).
+		# 
+		# Call the #dump method to dump faulty sdefs to Ruby module, e.g.:
+		# 
+		# 	dump('MyOSAX', 'MyOSAXGlue', '/path/to/site-packages/myosaxglue.py')
+		# 
+		# Patch any errors by hand, then import the patched module into your script 
+		# and pass it to OSAX.osax via its 'terms' argument, e.g.:
+		# 
+		# 	require 'osax'
+		# 	require 'MyOSAXGlue'
+		# 	
+		# 	myapp = OSAX.osax('MyOSAX', terms => MyOSAXGlue)
+		#
+		OSAX._init_caches if OSAXNames == []
+		original_name = osax_name
+		osax_name = osax_name.downcase
+		m = /^(.+).osax$/.match(osax_name)
+		osax_name = m[1] if m != nil
+		osax_path, terms = OSAXCache.fetch(osax_name) do
+			raise ArgumentError, "Scripting addition not found: #{original_name.inspect}"
+		end
+		sp = OSAX::SdefParser.new
+		sp.parsefile(osax_path)
+		Terminology.dump_tables([sp.classes, sp.enumerators, sp.properties, sp.elements, sp.commands], 
+				module_name, osax_path, out_path)
+	end
+
 end