hip: hip.js comparison

comparison hip.js @ 6:98935af12b04

Debugged the recursive part of the parsing algorithm, so it now recognizes multiple prepositions in any order. Still some bugs.

author	jonathandicarlo@jonathan-dicarlos-macbook-pro.local
date	Wed, 14 May 2008 13:25:17 -0700
parents	a049cb93db46
children	aab0d14248f5

comparison

equal deleted inserted replaced

-:a049cb93db46
+:98935af12b04
+function dictDeepCopy( dict ) {
+var newDict = {};
+for (var i in dict ) {
+newDict[i] = dict[i];
+}
+return newDict;
+};
+function dictKeys( dict ) {
+return [ key for ( key in dict ) ];
+}
 function NounType( name, expectedWords ) {
 this._init( name, expectedWords );
 }
 NounType.prototype = {
 var person = new NounType( "person", ["atul@mozilla.com", "aza@mozilla.com", "thunder@mozilla.com", "chris@mozilla.com", "myk@mozilla.com" ] );
 var anyWord = {
 // a singleton object which can be used in place of a NounType.
+_name: "text",
 match: function( fragment ) {
 return true;
 },
 suggest: function( fragment ) {
 return [ fragment ];
 this._DO = DO;
 this._modifiers = modifiers;
 },
 getCompletionText: function() {
-// returns completed and canonicalized sentence
+// return plain text that we should set the input box to if user hits
+// space bar on this sentence.
+var sentence = this._verb._name;
+if ( this._DO ) {
+sentence = sentence + " " + this._DO;
+}
+for ( var x in this._modifiers ) {
+sentence = sentence + " " + x + " " + this._modifiers[x];
+}
+return sentence;
+},
+getDisplayText: function() {
+// returns html formatted sentence for display in suggestion list
 var sentence = this._verb._name;
 if ( this._verb._DOType ) {
 if ( this._DO ) {
 	sentence = sentence + " " + this._DO;
 } else {
 	sentence = sentence + " <span class=\"needarg\">(" + this._verb._DOLabel + ")</span>";
 }
 }
-for ( var x in this._verb._modifiers ) {
+for ( var x in this._verb._modifiers ) {  // was this._verb._modifiers
 if ( this._modifiers[ x ] ) {
-	sentence = sentence + " " + x + " " + this._modifiers[x];
+	sentence = sentence + " <b>" +  x + " " + this._modifiers[x] + "</b>";
 } else {
-	sentence = sentence + " <span class=\"needarg\">(" + this._verb._modifiers[x]._name + ")</span>";
+	sentence = sentence + " <span class=\"needarg\">(" + x + " " + this._verb._modifiers[x]._name + ")</span>";
 }
 }
 return sentence;
 },
 getDescription: function() {
 // returns a string describing what the sentence will do if executed
+return this._verb.getDescription( this._DO, this._modifiers );
 }
 };
 // keys are prepositions
 // values are NounTypes.
 // example:  { "from" : City, "to" : City, "on" : Day }
 },
+getDescription: function() {
+// returns a string describing what the sentence will do if executed
+return this._verb.getDescription( this._DO, this._modifiers );
+}
 recursiveParse: function( unusedWords, filledMods, unfilledMods ) {
 var x;
 var suggestions = [];
 var completions = [];
 var directObject = "";
-if ( [key for (key in unfilledMods)].length == 0 ) {
+if ( dictKeys( unfilledMods ).length == 0 ) {
 // Done with modifiers, try to parse direct object.
 if ( unusedWords.length == 0 ) {
 	// No words left, no direct object.  Try parsing sentence
 	// without them.
 	return [ new ParsedSentence( this, "", filledMods ) ];
 	} else {
 	  // word is invalid direct object.  Fail!
 	  return [];
 	}
 }
-}
+} else {
-},
-/*
-else {
 // "pop" a preposition off of the properties of unfilledMods
-var preposition = [key for (key in unfilledMods)][0];
+var preposition = dictKeys( unfilledMods )[0];
-var newUnfilledMods = unfilledMods.splice();
+// newUnfilledMods is the same as unfilledMods without preposition
+var newUnfilledMods = dictDeepCopy( unfilledMods );
 delete newUnfilledMods[preposition];
 // Look for a match for this preposition
 var nounType = unfilledMods[ preposition ];
 var matchIndices = [];
 for ( var x = 0; x < unusedWords.length - 1; x++ ) {
 	if ( preposition.indexOf( unusedWords[x] ) == 0 ) {
-	  if ( nounType.match( unusedWords[ x + 1 ] ) == 0 ) {
+	  if ( nounType.match( unusedWords[ x + 1 ] ) ) {
 	    // Match for the preposition at index x followed by
 	    // an appropriate noun at index x+1
 	    matchIndices.push( x );
 	  }
 	}
 }
 if ( matchIndices.length == 0 ) {
 	// no match for this preposition.
 	// Leave it blank and try to parse the rest:
 	filledMods[preposition] = "";
-	return recursiveParse( unusedWords, filledMods, newUnfilledMods );
+	var directObject = unusedWords.join( " " );
+	return [ new ParsedSentence( this, directObject, filledMods ) ];
+	//return this.recursiveParse( unusedWords, filledMods, newUnfilledMods );
 } else {
+	// this is placeholder, destroy it.
 	for ( x in matchIndices ) {
-	  // remove the words that matched the preposition and following
-	  // noun:
 	  var noun = unusedWords[ matchIndices[x]+1 ];
 	  var newUnusedWords = unusedWords.slice();
-	  newUnusedWords.splice( possibilities[x], 2 );
+	  newUnusedWords.splice( matchIndices[x], 2 );
-	  // add every noun completion from every possibility...
+	  var directObject = newUnusedWords.join( " " );
 	  suggestions = nounType.suggest( noun );
 	  for ( var y in suggestions ) {
-	    var newFilledMods = filledMods.slice();
+	    var newFilledMods = dictDeepCopy( filledMods );
 	    newFilledMods[ preposition ] = suggestions[y];
-	    var newCompletions = recursiveParse( newUnusedWords,
+	    var newCompletions = this.recursiveParse( newUnusedWords,
-						 newFilledMods,
+						      newFilledMods,
-						 newUnfilledMods );
+						      newUnfilledMods );
 	    completions = completions.concat( newCompletions );
 	  }
 	}
 	return completions;
 }
 }
-}, */
+},
-parse: function( words ) {
+getCompletions: function( words ) {
 /* returns a list of ParsedSentences. */
 /* words is an array of words that were space-separated.
 The first word, which matched this verb, has already been removed.
 Everything after that is either:
 1. my direct object
 2. a preposition
 3. a noun following a preposition.
 */
 return this.recursiveParse( words, {}, this._modifiers );
-},
-getCompletions: function( words ) {
-var sentences = this.parse( words );
-return [ sentences[x].getCompletionText() for ( x in sentences ) ];
 },
 match: function( sentence ) {
 // returns a float from 0 to 1 telling how good of a match the input
 // is to this verb.
 }
 QuerySource.prototype = {
 _init: function( ) {
 this._lockedInSentence = null;
 this._hilitedSuggestion = 0;
-this._suggestionList = [];
+this._suggestionList = []; // a list of ParsedSentences.
 },
 updateSuggestionList: function( query ) {
 this._suggestionList = [];
 var completions = [];
 var verb = verbs[x];
 if ( verb.match( words[0] ) ) {
 	completions = verb.getCompletions( words.slice(1) );
 	this._suggestionList = this._suggestionList.concat( completions );
 }
-} // TODO sort in order of match quality
+}
+// TODO sort in order of match quality
 this._hilitedSuggestion = 0;
 },
-getSuggestions : function() {
+getSuggestionsAsHtml : function() {
-return this._suggestionList;
+return [ this._suggestionList[x].getDisplayText() for ( x in this._suggestionList ) ];
 },
 indicationDown: function( ) {
 this._hilitedSuggestion ++;
 if ( this._hilitedSuggestion > this._suggestionList.length ) {
 },
 autocomplete: function( query ) {
 var hilited = this.getHilitedSuggestion();
 if ( hilited > -1 ) {
-var newText = this._suggestionList[ hilited ] + " ";
+var newText = this._suggestionList[ hilited ].getCompletionText() + " ";
 } else {
 newText = query;
 }
 return newText;
 },
 }
 return result;
 }
 function updateDisplay( ) {
-var suggestions = gQs.getSuggestions();
+var suggestions = gQs.getSuggestionsAsHtml();
 var hilitedSuggestion = gQs.getHilitedSuggestion();
 var ac = $("#autocomplete-popup");
 ac.html( makeSuggestionHtml( "div", suggestions, hilitedSuggestion ) );
 ac.show();
 }
 updateDisplay();
 }
 $(document).ready( function() {
+$("#status-line").html( "Welcome to Ubiquity." );
 $("#search-box").focus();
 $("#search-box").keyup( searchBoxQuery );
 $("#autocomplete-popup").css(
 "width",
 $("#search-box").css("width")
 );
 });
 /* Minor problems:
-1. verbs with indirect objects are returning empty completion lists
 2. multiple word direct objects are truncated to single word
+3. prepositional phrases past the first don't get matched?
+4. sentences need to have descriptions
 */