Reformatted code to Gobo standard.

json/json_array.e

@@ -52,8 +52,6 @@ feature -- Change Element
 	add(value:JSON_VALUE) is
 			require
 				not_null:value /= void
-			local
-			 l_json_value:JSON_VALUE
 			do
 				values.extend(value)
 			ensure

json/json_boolean.e

@@ -5,36 +5,40 @@ indexing
 	revision: "$Revision$"
 
 class
+
 	JSON_BOOLEAN
-		inherit
+
+inherit
 	JSON_VALUE
 
 create
+
 	make_boolean
+
 feature -- Initialization
 
-	make_boolean(a_value:BOOLEAN) is
+	make_boolean (an_item: BOOLEAN) is
 			--
 		do
-				value:=a_value
+			item := an_item
 		end
 
 feature -- Access
 
-	to_json:STRING is
+	item: BOOLEAN
+
+	to_json: STRING is
 			--
 		do
-				Result:=value.out
+			Result := item.out
 		end
 
-	hash_code:INTEGER is
+	hash_code: INTEGER is
 			--
 		do
-				Result:=value.hash_code
+			Result := item.hash_code
 		end
 
 
- 	value:BOOLEAN
-
 
 end

json/json_number.e

@@ -1,4 +1,5 @@
 indexing
+
 	description: "JSON Numbers, octal and hexadecimal formats are not used."
 	author: "Javier Velilla"
 	date: "$Date$"
@@ -7,54 +8,73 @@ indexing
 
 class
 	JSON_NUMBER
-	inherit
+
+inherit
+
 	JSON_VALUE
-			rename is_equal as is_equal_json_value
+		rename
+			is_equal as is_equal_json_value
 		end
 create
+
 	make_integer,
 	make_real
 
 feature -- initialization
-	make_integer(argument:INTEGER) is
+
+	make_integer (argument: INTEGER) is
 		do
-				value:= argument.out
+			item:= argument.out
 			internal_hash_code:=argument.hash_code
-				numeric_type:="INTEGER"
+			numeric_type:= "INTEGER"
 		end
 
-	make_real(argument:REAL) is
+	make_real (argument: REAL) is
 		do
-				value:= argument.out
+			item:= argument.out
 			internal_hash_code:=argument.hash_code
-				numeric_type:="REAL"
+			numeric_type:= "REAL"
 		end
 
 
 feature -- Access
-	to_json:STRING is
-			--
-			do
-				Result:=value
-			end
 
-	hash_code:INTEGER is
+	item: STRING
+
+	hash_code: INTEGER is
 			--
 		do
 			Result:=internal_hash_code
 		end
 
 
+feature -- Status
+
 	is_equal (other: like Current): BOOLEAN is
 			-- Is `other' attached to an object of the same type
 			-- as current object and identical to it?
 		do
-			Result:=value.is_equal(other.to_json)
+			Result:=item.is_equal (other.to_json)
+		end
+
+feature -- Conversion
+
+	to_json: STRING is
+			--
+		do
+			Result := item
 		end
 
 
 feature -- Implementation
-	value:STRING
+
-	internal_hash_code:INTEGER
+	internal_hash_code: INTEGER
-	numeric_type:STRING  -- REAL or INTEGER
+
+	numeric_type: STRING  -- REAL or INTEGER
+
+
+invariant
+
+	item_not_void: item /= Void
+
 end

json/json_object.e

@@ -1,7 +1,8 @@
 indexing
+
 	description: "[
-			An JSON_OBJECT represent an object in JSON.
+An JSON_OBJECT represent an object in JSON.
-			An object is an unordered set of name/value pairs
+An object is an unordered set of name/value pairs
 
 			Examples:
 
@@ -10,7 +11,7 @@ indexing
 			{"key","value"}
 
 
-		]"
+]"
 			author: "Javier Velilla"
 			date: "$Date$"
 			revision: "$Revision$"
@@ -18,15 +19,19 @@ indexing
 
 
 class
+
 	JSON_OBJECT
 
 inherit
+
 	JSON_VALUE
 
 create
+
 	make
 
 feature -- Initialization
+
 	make is
 			--
 		do
@@ -36,44 +41,45 @@ feature -- Initialization
 feature -- Change Element
 
 
-	put(value:JSON_VALUE ; key:JSON_STRING) is
+	put (value: JSON_VALUE ; key: JSON_STRING) is
 			-- Assuming there is no item of key `key',
 			-- insert `value' with `key'.
 		require
 			not_present: not has_key (key)
 		local
-				l_json_null:JSON_NULL
+			l_json_null: JSON_NULL
-				l_value:JSON_VALUE
+			l_value: JSON_VALUE
 		do
 			l_value:=value
 			if value = void then
 				create l_json_null
 				l_value:=l_json_null
 			end
-				object.extend(l_value,key)
+			object.extend (l_value,key)
 		end
 
 
 feature -- Access
-	has_key(key:JSON_STRING):BOOLEAN is
+
+	has_key (key: JSON_STRING):BOOLEAN is
 			-- has the JSON_OBJECT contains a specific key 'key'.
 		do
 			Result := object.has (key)
 		end
 
-	has_item(value:JSON_VALUE):BOOLEAN is
+	has_item (value: JSON_VALUE):BOOLEAN is
 			-- has the JSON_OBJECT contain a specfic item 'value'
 		do
 			Result := object.has_item (value)
 		end
 
-	item(key:JSON_STRING):JSON_VALUE is
+	item (key: JSON_STRING):JSON_VALUE is
 			-- the json_value associated with a key.
 		do
 			Result:= object.item (key)
 		end
 
-	current_keys:ARRAY[JSON_STRING] is
+	current_keys: ARRAY [JSON_STRING] is
 			-- array containing actually used keys
 		do
 			Result:=object.current_keys
@@ -81,7 +87,8 @@ feature -- Access
 
 
 feature -- Report
-	to_json:STRING is
+
+	to_json: STRING is
 			--  Printable json representation
 			-- {} or {member}
 			-- see documentation
@@ -104,8 +111,6 @@ feature -- Report
 			Result.append ("}")
 		end
 
-
-
 	hash_code: INTEGER is
 			-- Hash code value
 		local
@@ -125,5 +130,7 @@ feature -- Report
 
 
 feature {NONE} -- Implementation
-	object:HASH_TABLE[JSON_VALUE,JSON_STRING]
+
+	object: HASH_TABLE[JSON_VALUE,JSON_STRING]
+
 end

json/json_string.e

@@ -1,4 +1,5 @@
 indexing
+
 	description:"[
 		A JSON_STRING represent a string in JSON.
 		A string is a collection of zero or more Unicodes characters, wrapped in double
@@ -10,59 +11,76 @@ indexing
 	revision: "$Revision$"
 	license:"MIT (see http://www.opensource.org/licenses/mit-license.php)"
 
+
 class
+
 	JSON_STRING
-	inherit
+
+inherit
+
 	JSON_VALUE
 		redefine
 			is_equal
 		end
 
-	create
+create
+
 	make_json
+
 feature -- Initialization
-	make_json(value:STRING) is
+
-			--
+	make_json (an_item: STRING) is
+			-- Initialize.
+		require
+			item_not_void: an_item /= Void
 		do
-				create buffer.make(256)
+			item := an_item
-				buffer.append (value)
 		end
 
 
 feature -- Access
 
+	item: STRING
+			-- Contents
+
+
 feature -- Comparison
+
 	is_equal (other: like Current): BOOLEAN is
 			-- Is JSON_STRING  made of same character sequence as `other'
 			-- (possibly with a different capacity)?
 		do
-			Result:= Current.to_json.is_equal (other.to_json)
+			Result := Current.to_json.is_equal (other.to_json)
 		end
 
 feature -- Change Element
-	append(value:STRING)is
+
+	append (an_item: STRING)is
 			--
 		do
-				buffer.append (value)
+			item.append_string (an_item)
 		end
 
 
 feature -- Status report
-	to_json:STRING is
+
+	to_json: STRING is
 			--
 		do
 			create	Result.make_empty
 			Result.append ("%"")
-				Result.append (buffer)
+			Result.append (item)
 			Result.append ("%"")
 		end
 
-	hash_code:INTEGER is
+	hash_code: INTEGER is
 			--
 		do
-				Result:= buffer.hash_code + buffer.count
+			Result := item.hash_code
 		end
 
-feature {NONE} -- Implementation
+invariant
-	buffer:STRING
+
+	value_not_void: item /= Void
+
 end

json/scanner/json_parser.e

@@ -1,82 +1,95 @@
 indexing
-	description: "Objects that ..."
+
+	description: "Parse serialized JSON data"
 	author: ""
 	date: "$Date$"
 	revision: "$Revision$"
 
 class
+
 	JSON_PARSER
-		inherit
+inherit
 	JSON_READER
 	JSON_TOKENS
 
 create
+
 	make_parser
-feature -- Access
-    is_parsed:BOOLEAN
 
-    current_errors:STRING
+feature {NONE} -- Initialize
 
-	make_parser(a_json:STRING) is
+	make_parser (a_json: STRING) is
-			--
+			-- Initialize.
+		require
+			json_not_empty: a_json /= Void and then not a_json.is_empty
 		do
-				make(a_json)
+			make (a_json)
-				is_parsed:=true
+			is_parsed := True
 			create current_errors.make_empty
 		end
 
-    parse_json:JSON_VALUE is
+
+feature -- Access
+
+	is_parsed: BOOLEAN
+
+	current_errors: STRING
+
+
+feature -- Commands
+
+	parse_json: JSON_VALUE is
 			--
 		do
-    		Result:=parse
+			Result := parse
 			if extra_elements then
-    			is_parsed:=false
+				is_parsed := false
 			end
 		end
 
-	parse:JSON_VALUE is
+	parse: JSON_VALUE is
 			--
 		local
-				c:CHARACTER
+			c: CHARACTER
 		do
 			if is_parsed then
 				skip_withe_spaces
-					c:=actual
+				c := actual
 				if c.is_equal (j_object_open) then
-						Result:=parse_object
+					Result := parse_object
 				elseif c.is_equal (j_string) then
-						Result:=parse_string
+					Result := parse_string
 				elseif c.is_equal (j_array_open) then
-						Result:=parse_array
+					Result := parse_array
 				elseif c.is_digit or c.is_equal (j_minus)  then
-						Result:=parse_number
+					Result := parse_number
 				elseif is_null  then
 					--
-						Result:=create {JSON_NULL}
+					Result := create {JSON_NULL}
-						next;next;next;
+						next;next;next
 				elseif is_true then
-						Result:=create {JSON_BOOLEAN}.make_boolean (true)
+					Result := create {JSON_BOOLEAN}.make_boolean (true)
-						next;next;next;
+					next;next;next
 				elseif is_false then
-						Result:=create {JSON_BOOLEAN}.make_boolean (false)
+					Result := create {JSON_BOOLEAN}.make_boolean (false)
-						next;next;next;next;
+					next;next;next;next
 				else
-						is_parsed:=false
+					is_parsed := false
-						current_errors.append("JSON is not well formed in parse")
+					current_errors.append ("JSON is not well formed in parse")
-						Result:=void
+					Result := void
 				end
 			end
 		end
 
-	parse_object:JSON_OBJECT is
+	parse_object: JSON_OBJECT is
 			-- object
 			-- {}
 			-- {"key" : "value" [,]}
 
 		local
-				has_more:BOOLEAN
+			has_more: BOOLEAN
-				l_json_string:JSON_STRING
+			l_json_string: JSON_STRING
-				l_value:JSON_VALUE
+			l_value: JSON_VALUE
 		do
 			create Result.make
 			-- check if is an empty object {}
@@ -87,75 +100,75 @@ feature -- Access
 			else
 				-- a complex object {"key" : "value"}
 				previous
-					from has_more:=true until not has_more
+				from has_more := true until not has_more
 				loop
 					next
 					skip_withe_spaces
-						l_json_string:=parse_string
+					l_json_string := parse_string
 					next
 					skip_withe_spaces
 					if actual.is_equal (':') then
 						next
 						skip_withe_spaces
 					else
-						  is_parsed:=false
+						is_parsed := false
-						  current_errors.append("%N Input string is a not well formed JSON, expected: : found:" + actual.out +"%N")
+						current_errors.append ("%N Input string is a not well formed JSON, expected: : found: " + actual.out +"%N")
-						  has_more:=false
+						has_more := false
 					end
 
-						l_value:=parse
+					l_value := parse
 					if is_parsed then
 						Result.put (l_value,l_json_string)
 						next
 						skip_withe_spaces
 						if actual.is_equal (j_object_close) then
-								has_more:=false
+							has_more := false
 						elseif not actual.is_equal (',') then
-								has_more:=false
+							has_more := false
-								is_parsed:=false
+							is_parsed := false
-				  			    current_errors.append("JSON Object sintactically malformed expected , found:[" + actual.out + "] %N")
+							current_errors.append ("JSON Object sintactically malformed expected , found: [" + actual.out + "] %N")
 						end
 					else
-					    	has_more:=false
+						has_more := false
 						-- explain the error
 					end
 				end
 			end
 		end
 
-	parse_string:JSON_STRING is
+	parse_string: JSON_STRING is
 			--
 		local
-				has_more:BOOLEAN
+			has_more: BOOLEAN
-				l_json_string:STRING
+			l_json_string: STRING
-				l_unicode:STRING
+			l_unicode: STRING
 		do
 			create l_json_string.make_empty
 			if actual.is_equal (j_string) then
 				from
-						has_more:=true
+					has_more := true
 				until not has_more
 
 				loop
 					next
 					if actual.is_equal (j_string) then
-							has_more:=false
+						has_more := false
 					elseif actual.is_equal ('%H') then
 						next
 						if actual.is_equal ('u') then
 							create l_unicode.make_from_string ("\u")
 							l_unicode.append (read_unicode)
-								if is_a_valid_unicode(l_unicode) then
+							if is_a_valid_unicode (l_unicode) then
 								l_json_string.append (l_unicode)
 							else
-									has_more:=false
+								has_more := false
-									is_parsed:=false
+								is_parsed := false
-									current_errors.append("Input String is not well formed JSON, expected a Unicode value, found [" + actual.out + " ] %N")
+								current_errors.append ("Input String is not well formed JSON, expected a Unicode value, found [" + actual.out + " ] %N")
 							end
 						elseif (not special_characters.has (actual) and  not special_controls.has (actual)) or actual.is_equal ('%N') then
-								has_more:=false
+							has_more := false
-								is_parsed:=false
+							is_parsed := false
-								current_errors.append("Input String is not well formed JSON, found [" + actual.out + " ] %N")
+							current_errors.append ("Input String is not well formed JSON, found [" + actual.out + " ] %N")
 
 						else
 							l_json_string.append ("\")
@@ -165,9 +178,9 @@ feature -- Access
 
 					else
 						if special_characters.has (actual) and not actual.is_equal ('/') then
-								has_more:=false
+							has_more := false
-								is_parsed:=false
+							is_parsed := false
-								current_errors.append("Input String is not well formed JSON, found [" + actual.out + " ] %N")
+							current_errors.append ("Input String is not well formed JSON, found [" + actual.out + " ] %N")
 						else
 							l_json_string.append (actual.out)
 						end
@@ -179,13 +192,13 @@ feature -- Access
 			end
 		end
 
-		parse_array:JSON_ARRAY is
+	parse_array: JSON_ARRAY is
 			-- array
 			-- []
 			-- [elements [,]]
 		local
-				flag:BOOLEAN
+			flag: BOOLEAN
-				l_value:JSON_VALUE
+			l_value: JSON_VALUE
 		do
 			create Result.make_array
 			--check if is an empty array []
@@ -196,7 +209,7 @@ feature -- Access
 			else
 				previous
 				from
-						flag:=true
+					flag := true
 				until
 					not flag
 				loop
@@ -208,174 +221,166 @@ feature -- Access
 						next
 						skip_withe_spaces
 						if  not actual.is_equal (j_array_close) and not actual.is_equal (',')then
-								flag:=false
+							flag := false
-								is_parsed:=false
+							is_parsed := false
-								current_errors.append("Array is not well formed JSON,  found [" + actual.out + " ] %N")
+							current_errors.append ("Array is not well formed JSON,  found [" + actual.out + " ] %N")
 						elseif actual.is_equal (j_array_close)	then
-							    flag:= false
+							flag := false
 						end
 					else
-							flag:=false
+						flag := false
-								current_errors.append("Array is not well formed JSON,  found [" + actual.out + " ] %N")
+						current_errors.append ("Array is not well formed JSON,  found [" + actual.out + " ] %N")
 					end
 				end
 			end
 		end
 
-	parse_number:JSON_NUMBER is
+	parse_number: JSON_NUMBER is
 			--
 		local
-				sb:STRING
+			sb: STRING
-				flag:BOOLEAN
+			flag: BOOLEAN
-			    is_integer:BOOLEAN
+			is_integer: BOOLEAN
 		do
 			create sb.make_empty
 			sb.append (actual.out)
 
 			from
-					flag:=true
+				flag := true
 			until not flag
 			loop
 				next
 				if not has_next or close_tokens.has (actual) or actual.is_equal (',')
 					or actual.is_equal ('%N')  or actual.is_equal ('%R') then
-					    flag:=false
+					flag := false
 					previous
 				else
 					sb.append (actual.out)
 				end
 			end
 
-			    if is_a_valid_number(sb) then
+			if is_a_valid_number (sb) then
 				if sb.is_integer then
 					create Result.make_integer (sb.to_integer)
-						is_integer:=true;
+					is_integer := true
 				elseif sb.is_double and not is_integer then
 					create Result.make_real (sb.to_double)
 				end
 			else
-				    is_parsed:=false
+				is_parsed := false
-				    current_errors.append("Expected a number, found: [ " + sb  + " ]")
+				current_errors.append ("Expected a number, found: [ " + sb  + " ]")
 			end
 		end
 
-
+	is_null: BOOLEAN is
-
-		is_null:BOOLEAN is
 			--
 		local
-				l_null:STRING
+			l_null: STRING
-				l_string:STRING
+			l_string: STRING
 		do
-				l_null:="null"
+			l_null := "null"
-				l_string:=json_substring (index,index + l_null.count - 1)
+			l_string := json_substring (index,index + l_null.count - 1)
 			if l_string.is_equal (l_null) then
 				Result := true
 			end
 		end
 
-		is_false:BOOLEAN is
+	is_false: BOOLEAN is
 			--
 		local
-			l_false:STRING
+			l_false: STRING
-			l_string:STRING
+			l_string: STRING
 		do
-				l_false:="false"
+			l_false := "false"
-				l_string:=json_substring (index,index + l_false.count - 1)
+			l_string := json_substring (index,index + l_false.count - 1)
 			if l_string.is_equal (l_false) then
 				Result := true
 			end
 		end
 
-		is_true:BOOLEAN is
+	is_true: BOOLEAN is
 			--
 		local
-					l_true:STRING
+			l_true: STRING
-					l_string:STRING
+			l_string: STRING
 		do
-					l_true:="true"
+			l_true := "true"
-					l_string:=json_substring (index,index + l_true.count - 1)
+			l_string := json_substring (index,index + l_true.count - 1)
 			if l_string.is_equal (l_true) then
 				Result := true
 			end
 		end
 
-		read_unicode:STRING is
+	read_unicode: STRING is
 			--
 		local
-			i:INTEGER
+			i: INTEGER
 		do
 			create Result.make_empty
 			from
-					i:=1
+				i := 1
 			until i > 4 or not has_next
 
 			loop
 				next
-				    Result.append(actual.out)
+				Result.append (actual.out)
-				    i:= i + 1
+				i := i + 1
 			end
 		end
 
-feature {NONE}
 
-         is_a_valid_number(a_number:STRING):BOOLEAN is
+feature {NONE} -- Implementation
+
+	is_a_valid_number (a_number: STRING): BOOLEAN is
 			-- is 'a_number' a valid number based on this regular expression
-    		-- "-?(?:0|[1-9]\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?\b"?
+			-- "-?(?: 0|[1-9]\d+)(?: \.\d+)?(?: [eE][+-]?\d+)?\b"?
 		local
-    		case_mapping: RX_CASE_MAPPING
 			word_set: RX_CHARACTER_SET
 			regexp: RX_PCRE_REGULAR_EXPRESSION
-    		number_regex:STRING
+			number_regex: STRING
-    		l_number:STRING
 		do
 			create regexp.make
 			create word_set.make_empty
 			word_set.add_string ("0123456789.eE+-")
 			regexp.set_word_set (word_set)
-		      number_regex:="-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\b"
+			number_regex := "-?(?: 0|[1-9]\d*)(?: \.\d+)?(?: [eE][+-]?\d+)?\b"
-		      regexp.compile(number_regex)
+			regexp.compile (number_regex)
 			if regexp.matches (a_number) then
 				a_number.right_adjust
-	               if  a_number.is_equal(regexp.captured_substring (0)) then
+				if  a_number.is_equal (regexp.captured_substring (0)) then
 					Result := true
 				end
 			end
 		end
 
-	  is_a_valid_unicode(a_unicode:STRING):BOOLEAN is
+	is_a_valid_unicode (a_unicode: STRING): BOOLEAN is
 			-- is 'a_unicode' a valid unicode based on this regular expression
 			-- "\\u[0-9a-fA-F]{4}"
 		local
-    		case_mapping: RX_CASE_MAPPING
-			word_set: RX_CHARACTER_SET
 			regexp: RX_PCRE_REGULAR_EXPRESSION
-    		unicode_regex:STRING
+			unicode_regex: STRING
 		do
 			create regexp.make
-		      unicode_regex:="\\u[0-9a-fA-F]{4}"
+			unicode_regex := "\\u[0-9a-fA-F]{4}"
-		      regexp.compile(unicode_regex)
+			regexp.compile (unicode_regex)
 			if regexp.matches (a_unicode) then
 				Result := true
 					check
-                   	   is_valid: a_unicode.is_equal(regexp.captured_substring (0))
+						is_valid: a_unicode.is_equal (regexp.captured_substring (0))
 					end
 			end
 		end
 
-
+	extra_elements: BOOLEAN is
-
-		extra_elements:BOOLEAN is
 			--has more elements?
-				local
-					l_string:STRING
 		do
 
 			if has_next then
 				next
 			end
 			from
-					until not actual.is_space or  not actual.is_equal ('%R') or
+			until
+				not actual.is_space or  not actual.is_equal ('%R') or
 				not actual.is_equal ('%U') or  not actual.is_equal ('%T')
 				or not actual.is_equal ('%N') or not has_next
 			loop
@@ -383,7 +388,7 @@ feature {NONE}
 			end
 
 			if has_next then
-                    	Result:=True
+				Result := True
 			end
 
 		end