Context Navigation

← Previous Changeset
Next Changeset →

Changeset 8247

Timestamp:

04/23/07 10:46:44 (21 months ago)

Author:

peller

Message:

Fixes #2769

Location:

Files:

: 4 modified

data/api/Read.js (modified) (2 diffs)
data/JsonItemStore.js (modified) (4 diffs)
data/util/simpleFetch.js (modified) (1 diff)
tests/data/JsonItemStore.js (modified) (43 diffs)

Legend:

: Unmodified
: Added
: Removed

dojo/trunk/data/api/Read.js

r7971	r8247
128	128	},
129	129
130		loadItem: function(/* ~~item */ item~~){
	130	loadItem: function(/* object */ keywordArgs){
131	131	// summary:
132	132	// Given an item, this method loads the item so that a subsequent call
133	133	// to store.isItemLoaded(item) will return true. If a call to
134	134	// to isItemLoaded() returns true before loadItem() is even called,
135		// then loadItem() need not do any work at all. A call to loadItem()
136		// will block until the loadItem() implementation has loaded the item.
137		if (this.isItemLoaded(item)) {
138		return item;
139		} else {
140		dojo.unimplemented('dojo.data.api.Read.loadItem');
141		return item; // item
	135	// then loadItem() need not do any work at all and will not even invoke
	136	// the callback handlers. So, before invoking this method, check that
	137	// the item has not already been loaded..
	138	// keywordArgs:
	139	// An anonymous object that defines the item to load and callbacks to invoke when the
	140	// load has completed. The format of the object is as follows:
	141	// {
	142	// item: object,
	143	// onItem: Function,
	144	// onError: Function,
	145	// scope: object
	146	// }
	147	// The item parameter.
	148	// The item parameter is an object that represents the item in question that should be
	149	// contained by the store. This attribute is required.
	150
	151	// The onItem parameter.
	152	// Function(item)
	153	// The onItem parameter is the callback to invoke when the item has been loaded. It takes only one
	154	// parameter, the fully loaded item.
	155	//
	156	// The onError parameter.
	157	// Function(error)
	158	// The onError parameter is the callback to invoke when the item load encountered an error. It takes only one
	159	// parameter, the error object
	160	//
	161	// The scope parameter.
	162	// If a scope object is provided, all of the callback functions (onItem,
	163	// onItem, onError, etc) will be invoked in the context of the scope
	164	// object. In the body of the callback function, the value of the "this"
	165	// keyword will be the scope object. If no scope object is provided,
	166	// the callback functions will be called in the context of dojo.global().
	167	// For example, onItem.call(scope, item, request) vs.
	168	// onItem.call(dojo.global(), item, request)
	169	if (!this.isItemLoaded(keywordArgs.item)) {
	170	dojo.unimplemented('dojo.data.api.Read.loadItem');
142	171	}
143	172	},
…	…
232	261	// object. In the body of the callback function, the value of the "this"
233	262	// keyword will be the scope object. If no scope object is provided,
234		// the callback functions will be called in the context of d~~j_global~~.
	263	// the callback functions will be called in the context of dojo.global().
235	264	// For example, onItem.call(scope, item, request) vs.
236		// onItem.call(d~~j_global~~, item, request)
	265	// onItem.call(dojo.global(), item, request)
237	266	//
238	267	// The start parameter.

dojo/trunk/data/JsonItemStore.js

r8025	r8247
131	131	},
132	132
133		loadItem: function(/* ~~item */ item~~){
	133	loadItem: function(/* object */ keywordArgs){
134	134	// summary:
135	135	// See dojo.data.api.Read.loadItem()
136		this._assertIsItem(item);
137		return item; //object
	136	this._assertIsItem(keywordArgs.item);
138	137	},
139	138
…	…
174	173	}
175	174	}
176		findCallback(~~resultArgs, item~~s);
	175	findCallback(items, resultArgs);
177	176	}else{
178	177	// We want a copy to pass back in case the parent wishes to sort the array. We shouldn't allow resort
…	…
181	180	items = self._arrayOfAllItems.slice(0,self._arrayOfAllItems.length);
182	181	}
183		findCallback(~~resultArgs, item~~s);
	182	findCallback(items, resultArgs);
184	183	}
185	184	};
…	…
196	195	getHandler.addCallback(function(data){
197	196	self._loadFinished = true;
198		self._arrayOfAllItems = self._getItemsFromLoadedData(data);
199		filter(keywordArgs, self._arrayOfAllItems);
	197	try{
	198	self._arrayOfAllItems = self._getItemsFromLoadedData(data);
	199	filter(keywordArgs, self._arrayOfAllItems);
	200	}catch(e){
	201	errorCallback(e, keywordArgs);
	202	}
	203
200	204	});
201	205	getHandler.addErrback(function(error){
202		~~throw error~~;
	206	errCallback(keywordArgs, error);
203	207	});
204	208	}else if(this._jsonData){
205		this._loadFinished = true;
206		this._arrayOfAllItems = this._getItemsFromLoadedData(this._jsonData);
207		this._jsonData = null;
208		filter(keywordArgs, this._arrayOfAllItems);
	209	try{
	210	this._loadFinished = true;
	211	this._arrayOfAllItems = this._getItemsFromLoadedData(this._jsonData);
	212	this._jsonData = null;
	213	filter(keywordArgs, this._arrayOfAllItems);
	214	}catch(e){
	215	errorCallback(e, keywordArgs);
	216	}
209	217	}else{
210		~~throw new Error("dojo.data.JsonItemStore: No JSON source data was provided as either URL or a nested Javascript object."~~);
	218	errorCallback(new Error("dojo.data.JsonItemStore: No JSON source data was provided as either URL or a nested Javascript object."), keywordArgs);
211	219	}
212	220	}

dojo/trunk/data/util/simpleFetch.js

r7989	r8247
35	35	var self = this;
36	36
37		var _errorHandler = function(errorData){
38		if(request.onError){
39		var scope = request.scope \|\| dojo.global;
40		request~~.onError.call(scope, errorData~~);
	37	var _errorHandler = function(errorData, requestObject){
	38	if(requestObject.onError){
	39	var scope = requestObject.scope \|\| dojo.global;
	40	requestObject.onError.call(scope, errorData, requestObject);
41	41	}
42	42	};
43	43
44		var _fetchHandler = function(~~requestObject, items~~){
	44	var _fetchHandler = function(items, requestObject){
45	45	var oldAbortFunction = requestObject.abort \|\| null;
46	46	var aborted = false;

dojo/trunk/tests/data/JsonItemStore.js

r8154	r8247
28	28
29	29	var d = new tests.Deferred();
30		function completedAll(items){
	30	function completedAll(items, request){
31	31	t.is(7, items.length);
32	32	d.callback(true);
33	33	}
34		function error(errData){
35		// t.assertTrue(false);
	34	function error(errData, request){
	35	t.assertTrue(false);
36	36	d.errback(errData);
37	37	}
…	…
66	66	var d = new tests.Deferred();
67	67	function onComplete(items, request){
68		t.assert~~True((items.length === 1)~~);
	68	t.assertEqual(items.length, 1);
69	69	d.callback(true);
70	70	}
71	71	function onError(errData, request){
72	72	t.assertTrue(false);
73		d.errback(~~false~~);
	73	d.errback(errData);
74	74	}
75	75	jsonItemStore.fetch({ query: {abbr: "ec"},
…	…
106	106
107	107	function onBegin(size, requestObj){
108		t.assert~~True(size ===~~ 7);
	108	t.assertEqual(size, 7);
109	109	}
110	110	function onItem(item, requestObj){
…	…
113	113	}
114	114	function onComplete(items, request){
115		t.assert~~True(count ===~~ 7);
	115	t.assertEqual(count, 7);
116	116	t.assertTrue(items === null);
117	117	d.callback(true);
118	118	}
119		function onError(errData){
120		t.assertTrue(false);
121		d.errback(~~false~~);
	119	function onError(errData, request){
	120	t.assertTrue(false);
	121	d.errback(errData);
122	122	}
123	123
…	…
155	155	var d = new tests.Deferred();
156	156	function dumpFirstFetch(items, request){
157		t.assert~~True(items.length ===~~ 5);
	157	t.assertEqual(items.length, 5);
158	158	request.start = 3;
159	159	request.count = 1;
…	…
163	163
164	164	function dumpSecondFetch(items, request){
165		t.assert~~True(items.length ===~~ 1);
	165	t.assertEqual(items.length, 1);
166	166	request.start = 0;
167	167	request.count = 5;
…	…
171	171
172	172	function dumpThirdFetch(items, request){
173		t.assert~~True(items.length ===~~ 5);
	173	t.assertEqual(items.length, 5);
174	174	request.start = 2;
175	175	request.count = 20;
…	…
179	179
180	180	function dumpFourthFetch(items, request){
181		t.assert~~True(items.length ===~~ 5);
	181	t.assertEqual(items.length, 5);
182	182	request.start = 9;
183	183	request.count = 100;
…	…
187	187
188	188	function dumpFifthFetch(items, request){
189		t.assert~~True(items.length ===~~ 0);
	189	t.assertEqual(items.length, 0);
190	190	request.start = 2;
191	191	request.count = 20;
…	…
195	195
196	196	function dumpSixthFetch(items, request){
197		t.assert~~True(items.length ===~~ 5);
	197	t.assertEqual(items.length, 5);
198	198	d.callback(true);
199	199	}
200	200
201	201	function completed(items, request){
202		t.assert~~True(items.length ===~~ 7);
	202	t.assertEqual(items.length, 7);
203	203	request.start = 1;
204	204	request.count = 5;
…	…
207	207	}
208	208
209		function error(){
210		t.assertTrue(false);
211		d.errback(~~false~~);
	209	function error(errData, request){
	210	t.assertTrue(false);
	211	d.errback(errData);
212	212	}
213	213	jsonItemStore.fetch({onComplete: completed, onError: error});
…	…
303	303	var names = jsonItemStore.getValues(item,"name");
304	304	t.assertTrue(dojo.isArray(names));
305		t.assert~~True(names.length ===~~ 1);
306		t.assert~~True(names[0] ===~~ "El Salvador");
	305	t.assertEqual(names.length, 1);
	306	t.assertEqual(names[0], "El Salvador");
307	307	},
308	308	function testReadAPI_getValues_byattributeItem(t){
…	…
340	340	var attrValues = jsonItemStore.getValues(item,itemAttribute);
341	341	t.assertTrue(dojo.isArray(attrValues));
342		t.assert~~True(attrValues.length ===~~ 1);
343		t.assert~~True(attrValues[0] ===~~ "ec");
	342	t.assertEqual(attrValues.length, 1);
	343	t.assertEqual(attrValues[0], "ec");
344	344	},
345	345	function testReadAPI_getItemByIdentity(t){
…	…
373	373	if(item !== null){
374	374	var name = jsonItemStore.getValue(item,"name");
375		t.assert~~True(name ===~~ "El Salvador");
	375	t.assertEqual(name, "El Salvador");
376	376	}
377	377	item = jsonItemStore.getItemByIdentity("sv_not");
…	…
474	474	if(itemAttribute !== null){
475	475	var name = jsonItemStore.getValue(itemAttribute,"name");
476		t.assert~~True(name ===~~ "abbr");
	476	t.assertEqual(name, "abbr");
477	477	}
478	478	var item = jsonItemStore.getItemByIdentity("Ecuador");
479	479	t.assertTrue(jsonItemStore.hasAttribute(item,itemAttribute));
480	480	var attrValue = jsonItemStore.getValue(item,itemAttribute);
481		t.assert~~True(attrValue ===~~ "ec");
	481	t.assertEqual(attrValue, "ec");
482	482	},
483	483	function testReadAPI_containsValue(t){
…	…
581	581
582	582	var attributes = jsonItemStore.getAttributes(item);
583		t.assert~~True(attributes.length ===~~ 3);
	583	t.assertEqual(attributes.length, 3);
584	584	for(var i = 0; i < attributes.length; i++){
585	585	t.assertTrue((attributes[i] === "name" \|\| attributes[i] === "abbr" \|\| attributes[i] === "capital"));
…	…
615	615	count++;
616	616	}
617		t.assert~~True(count ===~~ 2);
	617	t.assertEqual(count, 2);
618	618	},
619	619	function testReadAPI_fetch_patternMatch0(t){
…	…
642	642	var d = new tests.Deferred();
643	643	function completed(items, request) {
644		t.assert~~True(items.length ===~~ 5);
	644	t.assertEqual(items.length, 5);
645	645	var passed = true;
646	646	for(var i = 0; i < items.length; i++){
…	…
655	655	d.callback(true);
656	656	}else{
657		d.errback(~~false~~);
658		}
659		}
660		function error() {
661		t.assertTrue(false);
662		d.errback(~~false~~);
	657	d.errback(new Error("Unexpected abbreviation found, match failure."));
	658	}
	659	}
	660	function error(error, request) {
	661	t.assertTrue(false);
	662	d.errback(error);
663	663	}
664	664	jsonItemStore.fetch({query: {abbr: "e*"}, onComplete: completed, onError: error});
…	…
687	687	var d = new tests.Deferred();
688	688	function completed(items, request){
689		t.assert~~True(items.length ===~~ 2);
	689	t.assertEqual(items.length, 2);
690	690	var passed = true;
691	691	for(var i = 0; i < items.length; i++){
…	…
700	700	d.callback(true);
701	701	}else{
702		d.errback(~~false~~);
703		}
704		}
705		function error(){
706		t.assertTrue(false);
707		d.errback(~~false~~);
	702	d.errback(new Error("Unexpected pattern matched. Filter failure."));
	703	}
	704	}
	705	function error(error, request){
	706	t.assertTrue(false);
	707	d.errback(error);
708	708	}
709	709	jsonItemStore.fetch({query: {value: "$"}, onComplete: completed, onError: error});
…	…
732	732	var d = new tests.Deferred();
733	733	function completed(items, request){
734		t.assert~~True(items.length ===~~ 1);
	734	t.assertEqual(items.length, 1);
735	735	var passed = true;
736	736	for(var i = 0; i < items.length; i++){
…	…
745	745	d.callback(true);
746	746	}else{
747		d.errback(~~false~~);
748		}
749		}
750		function error(){
751		t.assertTrue(false);
752		d.~~callback(false~~);
	747	d.errback(new Error("Unexpected abbreviation found, match failure."));
	748	}
	749	}
	750	function error(error, request){
	751	t.assertTrue(false);
	752	d.errback(error);
753	753	}
754	754	jsonItemStore.fetch({query: {value: "bar\*foo"}, onComplete: completed, onError: error});
…	…
779	779	var d = new tests.Deferred();
780	780	function completed(items, request){
781		t.assert~~True(items.length ===~~ 11);
	781	t.assertEqual(items.length, 11);
782	782	var passed = true;
783	783	for(var i = 0; i < items.length; i++){
…	…
792	792	d.callback(true);
793	793	}else{
794		d.errback(~~false~~);
795		}
796		}
797
798		function error(){
799		t.assertTrue(false);
800		d.errback(~~false~~);
	794	d.errback(new Error("Unexpected sorting order found, sort failure."));
	795	}
	796	}
	797
	798	function error(error, request){
	799	t.assertTrue(false);
	800	d.errback(error);
801	801	}
802	802
…	…
828	828	var d = new tests.Deferred();
829	829	function completed(items, request){
830		t.assert~~True(items.length ===~~ 11);
	830	t.assertEqual(items.length, 11);
831	831	var passed = true;
832	832	for(var i = 0; i < items.length; i++){
…	…
841	841	d.callback(true);
842	842	}else{
843		d.errback(~~false~~);
844		}
845		}
846
847		function error(){
848		t.assertTrue(false);
849		d.errback(~~false~~);
	843	d.errback(new Error("Unexpected sorting order found, sort failure."));
	844	}
	845	}
	846
	847	function error(error, request){
	848	t.assertTrue(false);
	849	d.errback(error);
850	850	}
851	851
…	…
878	878	var d = new tests.Deferred();
879	879	function completed(items, request){
880		t.assert~~True(items.length ===~~ 5);
	880	t.assertEqual(items.length, 5);
881	881	var itemId = 10;
882	882	var passed = true;
…	…
893	893	d.callback(true);
894	894	}else{
895		d.errback(~~false~~);
896		}
897		}
898
899		function error(){
900		t.assertTrue(false);
901		d.errback(~~false~~);
	895