mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/serialization/json/JSONDecoder.as

@@ -0,0 +1,303 @@
+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of Adobe Systems Incorporated nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.serialization.json
+{
+	public class JSONDecoder
+	{
+		/**
+		 * Flag indicating if the parser should be strict about the format
+		 * of the JSON string it is attempting to decode.
+		 */
+		private var strict:Boolean;
+		/** The value that will get parsed from the JSON string */
+		private var value:*;
+		/** The tokenizer designated to read the JSON string */
+		private var tokenizer:JSONTokenizer;
+		/** The current token from the tokenizer */
+		private var token:JSONToken;
+		/**
+		 * Constructs a new JSONDecoder to parse a JSON string
+		 * into a native object.
+		 *
+		 * @param s The JSON string to be converted
+		 *		into a native object
+		 * @param strict Flag indicating if the JSON string needs to
+		 * 		strictly match the JSON standard or not.
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONDecoder( s:String, strict:Boolean )
+		{
+			this.strict = strict;
+			tokenizer = new JSONTokenizer( s, strict );
+			nextToken();
+			value = parseValue();
+			// Make sure the input stream is empty
+			if ( strict && nextToken() != null )
+			{
+				tokenizer.parseError( "Unexpected characters left in input stream" );
+			}
+		}
+		/**
+		 * Gets the internal object that was created by parsing
+		 * the JSON string passed to the constructor.
+		 *
+		 * @return The internal object representation of the JSON
+		 * 		string that was passed to the constructor
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function getValue():*
+		{
+			return value;
+		}
+		/**
+		 * Returns the next token from the tokenzier reading
+		 * the JSON string
+		 */
+		private final function nextToken():JSONToken
+		{
+			return token = tokenizer.getNextToken();
+		}
+		/**
+		 * Returns the next token from the tokenizer reading
+		 * the JSON string and verifies that the token is valid.
+		 */
+		private final function nextValidToken():JSONToken
+		{
+			token = tokenizer.getNextToken();
+			checkValidToken();
+			return token;
+		}
+		/**
+		 * Verifies that the token is valid.
+		 */
+		private final function checkValidToken():void
+		{
+			// Catch errors when the input stream ends abruptly
+			if ( token == null )
+			{
+				tokenizer.parseError( "Unexpected end of input" );
+			}
+		}
+		/**
+		 * Attempt to parse an array.
+		 */
+		private final function parseArray():Array
+		{
+			// create an array internally that we're going to attempt
+			// to parse from the tokenizer
+			var a:Array = new Array();
+			// grab the next token from the tokenizer to move
+			// past the opening [
+			nextValidToken();
+			// check to see if we have an empty array
+			if ( token.type == JSONTokenType.RIGHT_BRACKET )
+			{
+				// we're done reading the array, so return it
+				return a;
+			}
+			// in non-strict mode an empty array is also a comma
+			// followed by a right bracket
+			else if ( !strict && token.type == JSONTokenType.COMMA )
+			{
+				// move past the comma
+				nextValidToken();
+				// check to see if we're reached the end of the array
+				if ( token.type == JSONTokenType.RIGHT_BRACKET )
+				{
+					return a;
+				}
+				else
+				{
+					tokenizer.parseError( "Leading commas are not supported.  Expecting ']' but found " + token.value );
+				}
+			}
+			// deal with elements of the array, and use an "infinite"
+			// loop because we could have any amount of elements
+			while ( true )
+			{
+				// read in the value and add it to the array
+				a.push( parseValue() );
+				// after the value there should be a ] or a ,
+				nextValidToken();
+				if ( token.type == JSONTokenType.RIGHT_BRACKET )
+				{
+					// we're done reading the array, so return it
+					return a;
+				}
+				else if ( token.type == JSONTokenType.COMMA )
+				{
+					// move past the comma and read another value
+					nextToken();
+					// Allow arrays to have a comma after the last element
+					// if the decoder is not in strict mode
+					if ( !strict )
+					{
+						checkValidToken();
+						// Reached ",]" as the end of the array, so return it
+						if ( token.type == JSONTokenType.RIGHT_BRACKET )
+						{
+							return a;
+						}
+					}
+				}
+				else
+				{
+					tokenizer.parseError( "Expecting ] or , but found " + token.value );
+				}
+			}
+			return null;
+		}
+		/**
+		 * Attempt to parse an object.
+		 */
+		private final function parseObject():Object
+		{
+			// create the object internally that we're going to
+			// attempt to parse from the tokenizer
+			var o:Object = new Object();
+			// store the string part of an object member so
+			// that we can assign it a value in the object
+			var key:String
+			// grab the next token from the tokenizer
+			nextValidToken();
+			// check to see if we have an empty object
+			if ( token.type == JSONTokenType.RIGHT_BRACE )
+			{
+				// we're done reading the object, so return it
+				return o;
+			}
+			// in non-strict mode an empty object is also a comma
+			// followed by a right bracket
+			else if ( !strict && token.type == JSONTokenType.COMMA )
+			{
+				// move past the comma
+				nextValidToken();
+				// check to see if we're reached the end of the object
+				if ( token.type == JSONTokenType.RIGHT_BRACE )
+				{
+					return o;
+				}
+				else
+				{
+					tokenizer.parseError( "Leading commas are not supported.  Expecting '}' but found " + token.value );
+				}
+			}
+			// deal with members of the object, and use an "infinite"
+			// loop because we could have any amount of members
+			while ( true )
+			{
+				if ( token.type == JSONTokenType.STRING )
+				{
+					// the string value we read is the key for the object
+					key = String( token.value );
+					// move past the string to see what's next
+					nextValidToken();
+					// after the string there should be a :
+					if ( token.type == JSONTokenType.COLON )
+					{
+						// move past the : and read/assign a value for the key
+						nextToken();
+						o[ key ] = parseValue();
+						// move past the value to see what's next
+						nextValidToken();
+						// after the value there's either a } or a ,
+						if ( token.type == JSONTokenType.RIGHT_BRACE )
+						{
+							// we're done reading the object, so return it
+							return o;
+						}
+						else if ( token.type == JSONTokenType.COMMA )
+						{
+							// skip past the comma and read another member
+							nextToken();
+							// Allow objects to have a comma after the last member
+							// if the decoder is not in strict mode
+							if ( !strict )
+							{
+								checkValidToken();
+								// Reached ",}" as the end of the object, so return it
+								if ( token.type == JSONTokenType.RIGHT_BRACE )
+								{
+									return o;
+								}
+							}
+						}
+						else
+						{
+							tokenizer.parseError( "Expecting } or , but found " + token.value );
+						}
+					}
+					else
+					{
+						tokenizer.parseError( "Expecting : but found " + token.value );
+					}
+				}
+				else
+				{
+					tokenizer.parseError( "Expecting string but found " + token.value );
+				}
+			}
+			return null;
+		}
+		/**
+		 * Attempt to parse a value
+		 */
+		private final function parseValue():Object
+		{
+			checkValidToken();
+			switch ( token.type )
+			{
+				case JSONTokenType.LEFT_BRACE:
+					return parseObject();
+				case JSONTokenType.LEFT_BRACKET:
+					return parseArray();
+				case JSONTokenType.STRING:
+				case JSONTokenType.NUMBER:
+				case JSONTokenType.TRUE:
+				case JSONTokenType.FALSE:
+				case JSONTokenType.NULL:
+					return token.value;
+				case JSONTokenType.NAN:
+					if ( !strict )
+					{
+						return token.value;
+					}
+					else
+					{
+						tokenizer.parseError( "Unexpected " + token.value );
+					}
+				default:
+					tokenizer.parseError( "Unexpected " + token.value );
+			}
+			return null;
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/serialization/json/JSONEncoder.as

@@ -0,0 +1,277 @@
+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of Adobe Systems Incorporated nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.serialization.json
+{
+	import flash.utils.describeType;
+	public class JSONEncoder
+	{
+		/** The string that is going to represent the object we're encoding */
+		private var jsonString:String;
+		/**
+		 * Creates a new JSONEncoder.
+		 *
+		 * @param o The object to encode as a JSON string
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONEncoder( value:* )
+		{
+			jsonString = convertToString( value );
+		}
+		/**
+		 * Gets the JSON string from the encoder.
+		 *
+		 * @return The JSON string representation of the object
+		 * 		that was passed to the constructor
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function getString():String
+		{
+			return jsonString;
+		}
+		/**
+		 * Converts a value to it's JSON string equivalent.
+		 *
+		 * @param value The value to convert.  Could be any
+		 *		type (object, number, array, etc)
+		 */
+		private function convertToString( value:* ):String
+		{
+			// determine what value is and convert it based on it's type
+			if ( value is String )
+			{
+				// escape the string so it's formatted correctly
+				return escapeString( value as String );
+			}
+			else if ( value is Number )
+			{
+				// only encode numbers that finate
+				return isFinite( value as Number ) ? value.toString() : "null";
+			}
+			else if ( value is Boolean )
+			{
+				// convert boolean to string easily
+				return value ? "true" : "false";
+			}
+			else if ( value is Array )
+			{
+				// call the helper method to convert an array
+				return arrayToString( value as Array );
+			}
+			else if ( value is Object && value != null )
+			{
+				// call the helper method to convert an object
+				return objectToString( value );
+			}
+			return "null";
+		}
+		/**
+		 * Escapes a string accoding to the JSON specification.
+		 *
+		 * @param str The string to be escaped
+		 * @return The string with escaped special characters
+		 * 		according to the JSON specification
+		 */
+		private function escapeString( str:String ):String
+		{
+			// create a string to store the string's jsonstring value
+			var s:String = "";
+			// current character in the string we're processing
+			var ch:String;
+			// store the length in a local variable to reduce lookups
+			var len:Number = str.length;
+			// loop over all of the characters in the string
+			for ( var i:int = 0; i < len; i++ )
+			{
+				// examine the character to determine if we have to escape it
+				ch = str.charAt( i );
+				switch ( ch )
+				{
+					case '"': // quotation mark
+						s += "\\\"";
+						break;
+					//case '/':	// solidus
+					//	s += "\\/";
+					//	break;
+					case '\\': // reverse solidus
+						s += "\\\\";
+						break;
+					case '\b': // bell
+						s += "\\b";
+						break;
+					case '\f': // form feed
+						s += "\\f";
+						break;
+					case '\n': // newline
+						s += "\\n";
+						break;
+					case '\r': // carriage return
+						s += "\\r";
+						break;
+					case '\t': // horizontal tab
+						s += "\\t";
+						break;
+					default: // everything else
+						// check for a control character and escape as unicode
+						if ( ch < ' ' )
+						{
+							// get the hex digit(s) of the character (either 1 or 2 digits)
+							var hexCode:String = ch.charCodeAt( 0 ).toString( 16 );
+							// ensure that there are 4 digits by adjusting
+							// the # of zeros accordingly.
+							var zeroPad:String = hexCode.length == 2 ? "00" : "000";
+							// create the unicode escape sequence with 4 hex digits
+							s += "\\u" + zeroPad + hexCode;
+						}
+						else
+						{
+							// no need to do any special encoding, just pass-through
+							s += ch;
+						}
+				} // end switch
+			} // end for loop
+			return "\"" + s + "\"";
+		}
+		/**
+		 * Converts an array to it's JSON string equivalent
+		 *
+		 * @param a The array to convert
+		 * @return The JSON string representation of <code>a</code>
+		 */
+		private function arrayToString( a:Array ):String
+		{
+			// create a string to store the array's jsonstring value
+			var s:String = "";
+			// loop over the elements in the array and add their converted
+			// values to the string
+			var length:int = a.length;
+			for ( var i:int = 0; i < length; i++ )
+			{
+				// when the length is 0 we're adding the first element so
+				// no comma is necessary
+				if ( s.length > 0 )
+				{
+					// we've already added an element, so add the comma separator
+					s += ","
+				}
+				// convert the value to a string
+				s += convertToString( a[ i ] );
+			}
+			// KNOWN ISSUE:  In ActionScript, Arrays can also be associative
+			// objects and you can put anything in them, ie:
+			//		myArray["foo"] = "bar";
+			//
+			// These properties aren't picked up in the for loop above because
+			// the properties don't correspond to indexes.  However, we're
+			// sort of out luck because the JSON specification doesn't allow
+			// these types of array properties.
+			//
+			// So, if the array was also used as an associative object, there
+			// may be some values in the array that don't get properly encoded.
+			//
+			// A possible solution is to instead encode the Array as an Object
+			// but then it won't get decoded correctly (and won't be an
+			// Array instance)
+			// close the array and return it's string value
+			return "[" + s + "]";
+		}
+		/**
+		 * Converts an object to it's JSON string equivalent
+		 *
+		 * @param o The object to convert
+		 * @return The JSON string representation of <code>o</code>
+		 */
+		private function objectToString( o:Object ):String
+		{
+			// create a string to store the object's jsonstring value
+			var s:String = "";
+			// determine if o is a class instance or a plain object
+			var classInfo:XML = describeType( o );
+			if ( classInfo.@name.toString() == "Object" )
+			{
+				// the value of o[key] in the loop below - store this
+				// as a variable so we don't have to keep looking up o[key]
+				// when testing for valid values to convert
+				var value:Object;
+				// loop over the keys in the object and add their converted
+				// values to the string
+				for ( var key:String in o )
+				{
+					// assign value to a variable for quick lookup
+					value = o[ key ];
+					// don't add function's to the JSON string
+					if ( value is Function )
+					{
+						// skip this key and try another
+						continue;
+					}
+					// when the length is 0 we're adding the first item so
+					// no comma is necessary
+					if ( s.length > 0 )
+					{
+						// we've already added an item, so add the comma separator
+						s += ","
+					}
+					s += escapeString( key ) + ":" + convertToString( value );
+				}
+			}
+			else // o is a class instance
+			{
+				// Loop over all of the variables and accessors in the class and
+				// serialize them along with their values.
+				for each ( var v:XML in classInfo..*.(
+					name() == "variable"
+					||
+					(
+						name() == "accessor"
+						// Issue #116 - Make sure accessors are readable
+						&& attribute( "access" ).charAt( 0 ) == "r" )
+					) )
+				{
+					// Issue #110 - If [Transient] metadata exists, then we should skip
+					if ( v.metadata && v.metadata.( @name == "Transient" ).length() > 0 )
+					{
+						continue;
+					}
+					// When the length is 0 we're adding the first item so
+					// no comma is necessary
+					if ( s.length > 0 )
+					{
+						// We've already added an item, so add the comma separator
+						s += ","
+					}
+					s += escapeString( v.@name.toString() ) + ":"
+						+ convertToString( o[ v.@name ] );
+				}
+			}
+			return "{" + s + "}";
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/com/adobe/serialization/json/JSONParseError.as

@@ -0,0 +1,79 @@
+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of Adobe Systems Incorporated nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.serialization.json
+{
+	/**
+	 *
+	 *
+	 */
+	public class JSONParseError extends Error
+	{
+		/** The location in the string where the error occurred */
+		private var _location:int;
+		/** The string in which the parse error occurred */
+		private var _text:String;
+		/**
+		 * Constructs a new JSONParseError.
+		 *
+		 * @param message The error message that occured during parsing
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONParseError( message:String = "", location:int = 0, text:String = "" )
+		{
+			super( message );
+			name = "JSONParseError";
+			_location = location;
+			_text = text;
+		}
+		/**
+		 * Provides read-only access to the location variable.
+		 *
+		 * @return The location in the string where the error occurred
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get location():int
+		{
+			return _location;
+		}
+		/**
+		 * Provides read-only access to the text variable.
+		 *
+		 * @return The string in which the error occurred
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get text():String
+		{
+			return _text;
+		}
+	}
+}