rb-appscript 0.2.1 → 0.3.0

data/src/lib/_aem/codecs.rb

@@ -56,7 +56,7 @@ class UnitTypeCodecs
 		[:degrees_Kelvin, KAE::TypeDegreesK],
 	]
 	
-	DefaultPacker = proc { |value, code| AE::AEDesc.new(code, [value].pack('d')) }
+	DefaultPacker = proc { |units, code| AE::AEDesc.new(code, [units.value].pack('d')) }
 	DefaultUnpacker = proc { |desc, name| MacTypes::Units.new(desc.data.unpack('d')[0], name) }
 
 	def initialize
@@ -69,7 +69,7 @@ class UnitTypeCodecs
 		# type_defs is a list of lists, where each sublist is of form:
 		#	[typename, typecode, packproc, unpackproc]
 		# or:
-		#	[typename, typecode, packproc, unpackproc]
+		#	[typename, typecode]
 		# If optional packproc and unpackproc are omitted, default pack/unpack procs
 		# are used instead; these pack/unpack AEDesc data as a double precision float.
 		type_defs.each do |name, code, packer, unpacker|
@@ -81,7 +81,7 @@ class UnitTypeCodecs
 	def pack(val)
 		if val.is_a?(MacTypes::Units)
 			code, packer = @type_by_name.fetch(val.type) { |val| raise IndexError, "Unknown unit type: #{val.inspect}" }
-			return [true, packer.call(val.value, code)]
+			return [true, packer.call(val, code)]
 		else
 			return [false, val]
 		end
@@ -166,19 +166,9 @@ class Codecs
 	def pack(val) # clients may override this to replace existing packers
 		case val
 			when AEMReference::Base then val.AEM_pack_self(self)
-			when NilClass then NullDesc
-			when TrueClass then TrueDesc
-			when FalseClass then FalseDesc
+			
 			when Fixnum then AE::AEDesc.new(KAE::TypeSInt32, [val].pack('l'))
-			when Bignum
-				if SInt32Bounds === val
-					AE::AEDesc.new(KAE::TypeSInt32, [val].pack('l')) 
-				elsif SInt64Bounds === val
-					AE::AEDesc.new(KAE::TypeSInt64, [val].pack('q'))
-				else
-					AE::AEDesc.new(KAE::TypeFloat, [val.to_f].pack('d'))
-				end
-			when Float then AE::AEDesc.new(KAE::TypeFloat, [val].pack('d'))
+			
 			when String then 
 				begin
 					# Note: while typeUnicodeText is deprecated (see AEDataModel.h), it's still the
@@ -197,12 +187,21 @@ class Codecs
 						raise
 					end
 				end
+			
+			when TrueClass then TrueDesc
+			when FalseClass then FalseDesc
+			
+			when Float then AE::AEDesc.new(KAE::TypeFloat, [val].pack('d'))
+			
 			when Time
 				AE::AEDesc.new(KAE::TypeLongDateTime,
 						[AE.convert_unix_seconds_to_long_date_time(val.to_i)].pack('q'))
+			
 			when Array then pack_array(val)
 			when Hash then pack_hash(val)
+			
 			when MacTypes::FileBase then val.desc
+			
 			when TypeWrappers::AEType then
 				AE::AEDesc.new(KAE::TypeType, Codecs.four_char_code(val.code))
 			when TypeWrappers::AEEnum then
@@ -211,7 +210,19 @@ class Codecs
 				AE::AEDesc.new(KAE::TypeProperty, Codecs.four_char_code(val.code))
 			when TypeWrappers::AEKey then
 				AE::AEDesc.new(KAE::TypeKeyword, Codecs.four_char_code(val.code))
+			
 			when AE::AEDesc then val
+			
+			when Bignum
+				if SInt32Bounds === val
+					AE::AEDesc.new(KAE::TypeSInt32, [val].pack('l')) 
+				elsif SInt64Bounds === val
+					AE::AEDesc.new(KAE::TypeSInt64, [val].pack('q'))
+				else
+					AE::AEDesc.new(KAE::TypeFloat, [val.to_f].pack('d'))
+				end
+				
+			when NilClass then NullDesc
 		else
 			did_pack, desc = @unit_type_codecs.pack(val)
 			if did_pack
@@ -237,7 +248,7 @@ class Codecs
 		usrf = nil
 		val.each do | key, value |
 			if key.is_a?(TypeWrappers::AETypeBase)
-				if key.code == 'pcls' # AS packs records that contain a 'class' property by coercing the packed record to that type at the end
+				if key.code == KAE::PClass # AS packs records that contain a 'class' property by coercing the packed record to that type at the end
 					begin
 						record = record.coerce(value.code)
 					rescue
@@ -255,7 +266,7 @@ class Codecs
 			end
 		end
 		if usrf
-			record.put_param('usrf', usrf)
+			record.put_param(KAE::KeyASUserRecordFields, usrf)
 		end
 		return record
 	end
@@ -266,7 +277,7 @@ class Codecs
 	def unpack_unknown(desc) # clients may override this to provide additional unpackers
 		if desc.is_record? # if it's a record-like structure with an unknown/unsupported type then unpack it as a hash, including the original type info as a 'class' property
 			rec = desc.coerce(KAE::TypeAERecord)
-			rec.put_param('pcls', pack(TypeWrappers::AEType.new(desc.type)))
+			rec.put_param(KAE::PClass, pack(TypeWrappers::AEType.new(desc.type)))
 			unpack(rec)
 		else # else return unchanged
 			desc
@@ -277,37 +288,24 @@ class Codecs
 	def unpack(desc) # clients may override this to replace existing unpackers
 		return case desc.type
 			
-			when KAE::TypeNull then nil
-			when KAE::TypeBoolean then desc.data != "\000"
-			when KAE::TypeFalse then false
-			when KAE::TypeTrue then true
+			when KAE::TypeObjectSpecifier then unpack_object_specifier(desc)
 			
-			when KAE::TypeSInt16 then desc.data.unpack('s')[0]
 			when KAE::TypeSInt32 then desc.data.unpack('l')[0]
-			when KAE::TypeUInt32 then desc.data.unpack('L')[0]
-			when KAE::TypeSInt64 then desc.data.unpack('q')[0]
-			when KAE::TypeIEEE32BitFloatingPoint then desc.data.unpack('f')[0]
 			when KAE::TypeIEEE64BitFloatingPoint then desc.data.unpack('d')[0]
-			when KAE::Type128BitFloatingPoint then 
-				desc.coerce(KAE::TypeIEEE64BitFloatingPoint).data.unpack('d')[0]
 			
-			when KAE::TypeUTF8Text then desc.data
 			when 
 					KAE::TypeUnicodeText,
 					KAE::TypeChar, 
 					KAE::TypeIntlText, 
 					KAE::TypeUTF16ExternalRepresentation,
-					KAE::TypeStyledText, 
-					KAE::TypeStyledUnicodeText
+					KAE::TypeStyledText
 				desc.coerce(KAE::TypeUTF8Text).data
+				
+			when KAE::TypeFalse then false
+			when KAE::TypeTrue then true
 			
 			when KAE::TypeLongDateTime then
 				Time.at(AE.convert_long_date_time_to_unix_seconds(desc.data.unpack('q')[0]))
-				
-			when KAE::TypeVersion
-				vers, lo = desc.data.unpack('CC')
-				subvers, patch = lo.divmod(16)
-				"#{vers}.#{subvers}.#{patch}"
 			
 			when KAE::TypeAEList then unpack_aelist(desc)
 			when KAE::TypeAERecord then unpack_aerecord(desc)
@@ -319,26 +317,41 @@ class Codecs
 					KAE::TypeFSS
 				MacTypes::FileURL.desc(desc)
 			
-			when KAE::TypeQDPoint then desc.data.unpack('ss').reverse
-			when KAE::TypeQDRectangle then
-				x1, y1, x2, y2 = desc.data.unpack('ssss')
-				[y1, x1, y2, x2]
-			when KAE::TypeRGBColor then desc.data.unpack('SSS')
-			
 			when KAE::TypeType then unpack_type(desc)
 			when KAE::TypeEnumerated then unpack_enumerated(desc)
 			when KAE::TypeProperty then unpack_property(desc)
 			when KAE::TypeKeyword then unpack_keyword(desc)
 			
+			when KAE::TypeSInt16 then desc.data.unpack('s')[0]
+			when KAE::TypeUInt32 then desc.data.unpack('L')[0]
+			when KAE::TypeSInt64 then desc.data.unpack('q')[0]
+			
+			when KAE::TypeNull then nil
+			
+			when KAE::TypeUTF8Text then desc.data
+			
 			when KAE::TypeInsertionLoc then unpack_insertion_loc(desc)
-			when KAE::TypeObjectSpecifier then unpack_object_specifier(desc)
-			when KAE::TypeAbsoluteOrdinal then unpack_absolute_ordinal(desc)
 			when KAE::TypeCurrentContainer then unpack_current_container(desc)
 			when KAE::TypeObjectBeingExamined then unpack_object_being_examined(desc)
 			when KAE::TypeCompDescriptor then unpack_comp_descriptor(desc)
 			when KAE::TypeLogicalDescriptor then unpack_logical_descriptor(desc)
-			when KAE::TypeRangeDescriptor then unpack_range_descriptor(desc)
 			
+			when KAE::TypeIEEE32BitFloatingPoint then desc.data.unpack('f')[0]
+			when KAE::Type128BitFloatingPoint then 
+				desc.coerce(KAE::TypeIEEE64BitFloatingPoint).data.unpack('d')[0]
+			
+			when KAE::TypeQDPoint then desc.data.unpack('ss').reverse
+			when KAE::TypeQDRectangle then
+				x1, y1, x2, y2 = desc.data.unpack('ssss')
+				[y1, x1, y2, x2]
+			when KAE::TypeRGBColor then desc.data.unpack('SSS')
+				
+			when KAE::TypeVersion
+				vers, lo = desc.data.unpack('CC')
+				subvers, patch = lo.divmod(16)
+				"#{vers}.#{subvers}.#{patch}"
+				
+			when KAE::TypeBoolean then desc.data != "\000"
 		else
 			did_unpack, val = @unit_type_codecs.unpack(desc)
 			if did_unpack
@@ -354,7 +367,7 @@ class Codecs
 	def unpack_aelist(desc)
 		lst = []
 		desc.length().times do |i|
-			lst.push(unpack(desc.get(i + 1, KAE::TypeWildCard)[1]))
+			lst.push(unpack(desc.get_item(i + 1, KAE::TypeWildCard)[1]))
 		end
 		return lst
 	end
@@ -362,8 +375,8 @@ class Codecs
 	def unpack_aerecord(desc)
 		dct = {}
 		desc.length().times do |i|
-			key, value = desc.get(i + 1, KAE::TypeWildCard)
-			if key == 'usrf'
+			key, value = desc.get_item(i + 1, KAE::TypeWildCard)
+			if key == KAE::KeyASUserRecordFields
 				lst = unpack_aelist(value)
 				(lst.length / 2).times do |i|
 					dct[lst[i * 2]] = lst[i * 2 + 1]
@@ -394,51 +407,22 @@ class Codecs
 	end
 	
 	#######
-	
-	class Range
-		attr_reader :range
-		
-		def initialize(range)
-			@range = range
-		end
-	end
-	
-	class Ordinal
-		attr_reader :code
-		
-		def initialize(code)
-			@code = code
-		end
-	end
-	
-	def _desc_to_hash(desc)
-		desc = desc.coerce(KAE::TypeAERecord)
-		h = {}
-		desc.length.times do |i|
-			k, v = desc.get(i + 1, KAE::TypeWildCard)
-			h[k] = v
-		end
-		return h
-	end
-	
-	#######
-	
-	FullUnpackOrdinals = {
-			KAE::KAEFirst => 'first', 
-			KAE::KAELast => 'last', 
-			KAE::KAEMiddle => 'middle', 
-			KAE::KAEAny => 'any',
+	# Lookup tables for converting enumerator, ordinal codes to aem reference method names.
+	# Used by unpack_object_specifier, fully_unpack_object_specifier to construct aem references.
+	
+	AbsoluteOrdinals = {
+			Codecs.four_char_code(KAE::KAEFirst) => 'first', 
+			Codecs.four_char_code(KAE::KAELast) => 'last', 
+			Codecs.four_char_code(KAE::KAEMiddle) => 'middle', 
+			Codecs.four_char_code(KAE::KAEAny) => 'any',
 			}
 	
-	DeferredUnpackOrdinals = {
-			KAE::KAEFirst => ['first', AEMReference::MultipleElements::First],
-			KAE::KAELast => ['last', AEMReference::MultipleElements::Last],
-			KAE::KAEMiddle => ['middle', AEMReference::MultipleElements::Middle],
-			KAE::KAEAny => ['any', AEMReference::MultipleElements::Any],
-			}
+	AllAbsoluteOrdinal = Codecs.four_char_code(KAE::KAEAll)
 	
-	# InsertionLoc keys and comparison and logic comparison operators aren't unpacked before use,
-	# so need to call four_char_codes to swap bytes here.
+	RelativePositionEnums = {
+			Codecs.four_char_code(KAE::KAEPrevious) => 'previous', 
+			Codecs.four_char_code(KAE::KAENext) => 'next', 
+			}
 	
 	InsertionLocEnums = {
 			Codecs.four_char_code(KAE::KAEBefore) => 'before', 
@@ -466,105 +450,98 @@ class Codecs
 	
 	#######
 	
-	def fully_unpack_object_specifier(desc) 
-		# Codecs.unpack_object_specifier and DeferredSpecifier._real_ref will call this when needed
+	def fully_unpack_object_specifier(desc)
+		# Recursively unpack an object specifier and all of its container descs.
+		# (Note: Codecs#unpack_object_specifier and AEMReference::DeferredSpecifier#_real_ref will call this when needed.)
 		case desc.type
+			when KAE::TypeObjectSpecifier
+				want = Codecs.four_char_code(desc.get_param(KAE::KeyAEDesiredClass, KAE::TypeType).data)
+				key_form = Codecs.four_char_code(desc.get_param(KAE::KeyAEKeyForm, KAE::TypeEnumeration).data)
+				key = desc.get_param(KAE::KeyAEKeyData, KAE::TypeWildCard)
+				ref = fully_unpack_object_specifier(desc.get_param(KAE::KeyAEContainer, KAE::TypeWildCard))
+				case key_form
+					when KAE::FormPropertyID
+						return ref.property(Codecs.four_char_code(key.data))
+					when KAE::FormUserPropertyID
+						return ref.userproperty(unpack(key))
+					when KAE::FormRelativePosition
+						return ref.send(RelativePositionEnums[key.data], want)
+				else
+					ref = ref.elements(want)
+					case key_form
+						when KAE::FormAbsolutePosition
+							if key.type == KAE::TypeAbsoluteOrdinal
+								if key.data == AllAbsoluteOrdinal
+									return ref
+								else
+									return ref.send(AbsoluteOrdinals[key.data])
+								end
+							else
+								return ref.by_index(unpack(key))
+							end
+						when KAE::FormName
+							return ref.by_name(unpack(key))
+						when KAE::FormUniqueID
+							return ref.by_id(unpack(key))
+						when KAE::FormRange
+							return ref.by_range(
+									unpack(key.get_param(KAE::KeyAERangeStart, KAE::TypeWildCard)),
+									unpack(key.get_param(KAE::KeyAERangeStop, KAE::TypeWildCard)))
+						when KAE::FormTest
+							return ref.by_filter(unpack(key))
+					end
+				end
+				raise TypeError
 			when KAE::TypeNull then return self.class::App
 			when KAE::TypeCurrentContainer then return self.class::Con
 			when KAE::TypeObjectBeingExamined then return self.class::Its
-		end
-		rec = _desc_to_hash(desc)
-		want = unpack(rec[KAE::KeyAEDesiredClass]).code 
-		key_form = unpack(rec[KAE::KeyAEKeyForm]).code
-		key = unpack(rec[KAE::KeyAEKeyData])
-		ref = unpack(rec[KAE::KeyAEContainer])
-		if ref == nil
-			ref = self.class::App
-		end
-		if key_form == KAE::FormPropertyID
-			return ref.property(key.code)
-		elsif key_form == 'usrp'
-			return ref.userproperty(key)
-		elsif key_form == KAE::FormRelativePosition
-			if key.code == KAE::KAEPrevious
-				return ref.previous(want)
-			elsif key.code == KAE::KAENext
-				return ref.next(want)
-			else
-				raise RuntimeError, "Bad relative position selector: #{key}"
-			end
 		else
-			ref = ref.elements(want)
-			if key_form == KAE::FormName
-				return ref.by_name(key)
-			elsif key_form == KAE::FormAbsolutePosition
-				if key.is_a?(Ordinal)
-					if key.code == KAE::KAEAll
-						return ref
-					else
-						return ref.send(FullUnpackOrdinals[key.code])
-					end
-				else
-					return ref.by_index(key)
-				end
-			elsif key_form == KAE::FormUniqueID
-				return ref.by_id(key)
-			elsif key_form == KAE::FormRange
-				return ref.by_range(*key.range)
-			elsif key_form == KAE::FormTest
-				return ref.by_filter(key)
-			end
+			return unpack(desc)
 		end
-		raise TypeError
 	end
 	
 	##
 	
-	def unpack_object_specifier(desc) 
-		# defers full unpacking of [most] object specifiers for efficiency
-		rec = _desc_to_hash(desc)
-		key_form = unpack(rec[KAE::KeyAEKeyForm]).code
+	def unpack_object_specifier(desc)
+		# Shallow-unpack an object specifier, retaining the container AEDesc as-is.
+		# (i.e. Defers full unpacking of [most] object specifiers for efficiency.)
+		key_form = Codecs.four_char_code(desc.get_param(KAE::KeyAEKeyForm, KAE::TypeEnumeration).data)
 		if [KAE::FormPropertyID, KAE::FormAbsolutePosition, KAE::FormName, KAE::FormUniqueID].include?(key_form)
-			want = unpack(rec[KAE::KeyAEDesiredClass]).code
-			key = unpack(rec[KAE::KeyAEKeyData])
-			container = AEMReference::DeferredSpecifier.new(rec[KAE::KeyAEContainer], self)
-			if key_form == KAE::FormPropertyID
-				ref = AEMReference::Property.new(want, container, key.code)
-			elsif key_form == KAE::FormAbsolutePosition
-				if key.is_a?(Ordinal)
-					if key.code == KAE::KAEAll
-						ref = AEMReference::AllElements.new(want, container)
+			want = Codecs.four_char_code(desc.get_param(KAE::KeyAEDesiredClass, KAE::TypeType).data)
+			key = desc.get_param(KAE::KeyAEKeyData, KAE::TypeWildCard)
+			container = AEMReference::DeferredSpecifier.new(desc.get_param(KAE::KeyAEContainer, KAE::TypeWildCard), self)
+			case key_form
+				when KAE::FormPropertyID
+					ref = AEMReference::Property.new(want, container, Codecs.four_char_code(key.data))
+				when KAE::FormAbsolutePosition
+					if key.type == KAE::TypeAbsoluteOrdinal
+						if key.data == AllAbsoluteOrdinal
+							ref = AEMReference::AllElements.new(want, container)
+						else
+							ref = fully_unpack_object_specifier(desc) # do a full unpack of rarely returned reference forms
+						end
 					else
-						keyname, key = DeferredUnpackOrdinals[key.code]
-						ref = AEMReference::ElementByOrdinal.new(want, AEMReference::UnkeyedElements.new(want, container), key, keyname)
+						ref = AEMReference::ElementByIndex.new(want, AEMReference::UnkeyedElements.new(want, container), unpack(key))
 					end
-				else
-					ref = AEMReference::ElementByIndex.new(want, AEMReference::UnkeyedElements.new(want, container), key)
-				end
-			elsif key_form == KAE::FormName
-				ref = AEMReference::ElementByName.new(want, AEMReference::UnkeyedElements.new(want, container), key)
-			elsif key_form == KAE::FormUniqueID
-				ref = AEMReference::ElementByID.new(want, AEMReference::UnkeyedElements.new(want, container), key)
+				when KAE::FormName
+					ref = AEMReference::ElementByName.new(want, AEMReference::UnkeyedElements.new(want, container), unpack(key))
+				when KAE::FormUniqueID
+					ref = AEMReference::ElementByID.new(want, AEMReference::UnkeyedElements.new(want, container), unpack(key))
 			end
-			ref.AEM_set_desc(desc) # retain existing AEDesc for efficiency
-			return ref
-		else # do full unpack of more complex, rarely returned reference forms
-			return fully_unpack_object_specifier(desc)
+		else
+			ref = fully_unpack_object_specifier(desc) # do a full unpack of more complex, rarely returned reference forms
 		end
+		ref.AEM_set_desc(desc) # retain existing AEDesc for efficiency
+		return ref
 	end
 			
 	
 	def unpack_insertion_loc(desc)
-		rec = _desc_to_hash(desc)
-		return unpack_object_specifier(rec[KAE::KeyAEObject]).send(InsertionLocEnums[rec[KAE::KeyAEPosition].data])
+		return unpack_object_specifier(desc.get_param(KAE::KeyAEObject, KAE::TypeWildCard)).send(InsertionLocEnums[desc.get_param(KAE::KeyAEPosition, KAE::TypeEnumeration).data])
 	end
 	
 	##
 	
-	def unpack_absolute_ordinal(desc)
-		return Ordinal.new(Codecs.four_char_code(desc.data))
-	end
-	
 	def unpack_current_container(desc)
 		return Con
 	end
@@ -588,10 +565,9 @@ class Codecs
 	end
 	
 	def unpack_comp_descriptor(desc)
-		rec = _desc_to_hash(desc)
-		operator = ComparisonEnums[rec[KAE::KeyAECompOperator].data]
-		op1 = unpack(rec[KAE::KeyAEObject1])
-		op2 = unpack(rec[KAE::KeyAEObject2])
+		operator = ComparisonEnums[desc.get_param(KAE::KeyAECompOperator, KAE::TypeEnumeration).data]
+		op1 = unpack(desc.get_param(KAE::KeyAEObject1, KAE::TypeWildCard))
+		op2 = unpack(desc.get_param(KAE::KeyAEObject2, KAE::TypeWildCard))
 		if operator == 'contains'
 			return unpack_contains_comp_descriptor(op1, op2)
 		else
@@ -600,17 +576,11 @@ class Codecs
 	end
 	
 	def unpack_logical_descriptor(desc)
-		rec = _desc_to_hash(desc)
-		operator = LogicalEnums[rec[KAE::KeyAELogicalOperator].data]
-		operands = unpack(rec[KAE::KeyAELogicalTerms])
+		operator = LogicalEnums[desc.get_param(KAE::KeyAELogicalOperator, KAE::TypeEnumeration).data]
+		operands = unpack(desc.get_param(KAE::KeyAELogicalTerms, KAE::TypeAEList))
 		return operands[0].send(operator, *operands[1, operands.length])
 	end
 	
-	def unpack_range_descriptor(desc)
-		rec = _desc_to_hash(desc)
-		return Range.new([unpack(rec[KAE::KeyAERangeStart]), unpack(rec[KAE::KeyAERangeStop])])
-	end
-	
 end
 
 DefaultCodecs = Codecs.new