home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 233 / Computer Shopper 233 / ComputerShopperDVD233.iso / Toolkit / Internet / Firefox / Firefox Setup 2.0.0.3.exe / nonlocalized / components / FeedProcessor.js < prev    next >
Encoding:
JavaScript  |  2007-03-10  |  59.0 KB  |  1,800 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is Robert Sayre.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Ben Goodger <beng@google.com>
  23.  *   Myk Melez <myk@mozilla.org>
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. function LOG(str) {
  40.   dump("*** " + str + "\n");
  41. }
  42.  
  43. const Ci = Components.interfaces;
  44. const Cc = Components.classes;
  45. const Cr = Components.results;
  46.  
  47. const IO_CONTRACTID = "@mozilla.org/network/io-service;1"
  48. const BAG_CONTRACTID = "@mozilla.org/hash-property-bag;1"
  49. const ARRAY_CONTRACTID = "@mozilla.org/array;1";
  50. const SAX_CONTRACTID = "@mozilla.org/saxparser/xmlreader;1";
  51. const UNESCAPE_CONTRACTID = "@mozilla.org/feed-unescapehtml;1";
  52.  
  53. var gIoService = Cc[IO_CONTRACTID].getService(Ci.nsIIOService);
  54. var gUnescapeHTML = Cc[UNESCAPE_CONTRACTID].
  55.                     getService(Ci.nsIScriptableUnescapeHTML);
  56.  
  57. const XMLNS = "http://www.w3.org/XML/1998/namespace";
  58. const RSS090NS = "http://my.netscape.com/rdf/simple/0.9/";
  59.  
  60. /***** Some general utils *****/
  61. function strToURI(link, base) {
  62.   var base = base || null;
  63.   try {
  64.     return gIoService.newURI(link, null, base);
  65.   }
  66.   catch(e) {
  67.     return null;
  68.   }
  69. }
  70.  
  71. function isArray(a) {
  72.   return isObject(a) && a.constructor == Array;
  73. }
  74.  
  75. function isObject(a) {
  76.   return (a && typeof a == "object") || isFunction(a);
  77. }
  78.  
  79. function isFunction(a) {
  80.   return typeof a == "function";
  81. }
  82.  
  83. function isIID(a, iid) {
  84.   var rv = false;
  85.   try {
  86.     a.QueryInterface(iid);
  87.     rv = true;
  88.   }
  89.   catch(e) {
  90.   }
  91.   return rv;
  92. }
  93.  
  94. function isIArray(a) {
  95.   return isIID(a, Ci.nsIArray);
  96. }
  97.  
  98. function isIFeedContainer(a) {
  99.   return isIID(a, Ci.nsIFeedContainer);
  100. }
  101.  
  102. function stripTags(someHTML) {
  103.   return someHTML.replace(/<[^>]+>/g,"");
  104. }
  105.  
  106. /**
  107.  * Searches through an array of links and returns a JS array 
  108.  * of matching property bags.
  109.  */
  110. const IANA_URI = "http://www.iana.org/assignments/relation/";
  111. function findAtomLinks(rel, links) {
  112.   var rvLinks = [];
  113.   for (var i = 0; i < links.length; ++i) {
  114.     var linkElement = links.queryElementAt(i, Ci.nsIPropertyBag2);
  115.     // atom:link MUST have @href
  116.     if (bagHasKey(linkElement, "href")) {
  117.       var relAttribute = null;
  118.       if (bagHasKey(linkElement, "rel"))
  119.         relAttribute = linkElement.getPropertyAsAString("rel")
  120.       if ((!relAttribute && rel == "alternate") || relAttribute == rel) {
  121.         rvLinks.push(linkElement);
  122.         continue;
  123.       }
  124.       // catch relations specified by IANA URI 
  125.       if (relAttribute == IANA_URI + rel) {
  126.         rvLinks.push(linkElement);
  127.       }
  128.     }
  129.   }
  130.   return rvLinks;
  131. }
  132.  
  133. function xmlEscape(s) {
  134.   s = s.replace(/&/g, "&");
  135.   s = s.replace(/>/g, ">");
  136.   s = s.replace(/</g, "<");
  137.   s = s.replace(/"/g, """);
  138.   s = s.replace(/'/g, "'");
  139.   return s;
  140. }
  141.  
  142. function arrayContains(array, element) {
  143.   for (var i = 0; i < array.length; ++i) {
  144.     if (array[i] == element) {
  145.       return true;
  146.     }
  147.   }
  148.   return false;
  149. }
  150.  
  151. // XXX add hasKey to nsIPropertyBag
  152. function bagHasKey(bag, key) {
  153.   try {
  154.     bag.getProperty(key);
  155.     return true;
  156.   }
  157.   catch (e) {
  158.     return false;
  159.   }
  160. }
  161.  
  162. function makePropGetter(key) {
  163.   return function FeedPropGetter(bag) {
  164.     try {
  165.       return value = bag.getProperty(key);
  166.     }
  167.     catch(e) {
  168.     }
  169.     return null;
  170.   }
  171. }
  172.  
  173.  
  174.  
  175. /**
  176.  * XXX Thunderbird's W3C-DTF function
  177.  *
  178.  * Converts a W3C-DTF (subset of ISO 8601) date string to an IETF date
  179.  * string.  W3C-DTF is described in this note:
  180.  * http://www.w3.org/TR/NOTE-datetime IETF is obtained via the Date
  181.  * object's toUTCString() method.  The object's toString() method is
  182.  * insufficient because it spells out timezones on Win32
  183.  * (f.e. "Pacific Standard Time" instead of "PST"), which Mail doesn't
  184.  * grok.  For info, see
  185.  * http://lxr.mozilla.org/mozilla/source/js/src/jsdate.c#1526.
  186.  */
  187. const HOURS_TO_MINUTES = 60;
  188. const MINUTES_TO_SECONDS = 60;
  189. const SECONDS_TO_MILLISECONDS = 1000;
  190. const MINUTES_TO_MILLISECONDS = MINUTES_TO_SECONDS * SECONDS_TO_MILLISECONDS;
  191. const HOURS_TO_MILLISECONDS = HOURS_TO_MINUTES * MINUTES_TO_MILLISECONDS;
  192. function W3CToIETFDate(dateString) {
  193.  
  194.   var parts = dateString.match(/(\d\d\d\d)(-(\d\d))?(-(\d\d))?(T(\d\d):(\d\d)(:(\d\d)(\.(\d+))?)?(Z|([+-])(\d\d):(\d\d))?)?/);
  195.  
  196.   // Here's an example of a W3C-DTF date string and what .match returns for it.
  197.   // 
  198.   // date: 2003-05-30T11:18:50.345-08:00
  199.   // date.match returns array values:
  200.   //
  201.   //   0: 2003-05-30T11:18:50-08:00,
  202.   //   1: 2003,
  203.   //   2: -05,
  204.   //   3: 05,
  205.   //   4: -30,
  206.   //   5: 30,
  207.   //   6: T11:18:50-08:00,
  208.   //   7: 11,
  209.   //   8: 18,
  210.   //   9: :50,
  211.   //   10: 50,
  212.   //   11: .345,
  213.   //   12: 345,
  214.   //   13: -08:00,
  215.   //   14: -,
  216.   //   15: 08,
  217.   //   16: 00
  218.  
  219.   // Create a Date object from the date parts.  Note that the Date
  220.   // object apparently can't deal with empty string parameters in lieu
  221.   // of numbers, so optional values (like hours, minutes, seconds, and
  222.   // milliseconds) must be forced to be numbers.
  223.   var date = new Date(parts[1], parts[3] - 1, parts[5], parts[7] || 0,
  224.                       parts[8] || 0, parts[10] || 0, parts[12] || 0);
  225.  
  226.   // We now have a value that the Date object thinks is in the local
  227.   // timezone but which actually represents the date/time in the
  228.   // remote timezone (f.e. the value was "10:00 EST", and we have
  229.   // converted it to "10:00 PST" instead of "07:00 PST").  We need to
  230.   // correct that.  To do so, we're going to add the offset between
  231.   // the remote timezone and UTC (to convert the value to UTC), then
  232.   // add the offset between UTC and the local timezone //(to convert
  233.   // the value to the local timezone).
  234.  
  235.   // Ironically, W3C-DTF gives us the offset between UTC and the
  236.   // remote timezone rather than the other way around, while the
  237.   // getTimezoneOffset() method of a Date object gives us the offset
  238.   // between the local timezone and UTC rather than the other way
  239.   // around.  Both of these are the additive inverse (i.e. -x for x)
  240.   // of what we want, so we have to invert them to use them by
  241.   // multipying by -1 (f.e. if "the offset between UTC and the remote
  242.   // timezone" is -5 hours, then "the offset between the remote
  243.   // timezone and UTC" is -5*-1 = 5 hours).
  244.  
  245.   // Note that if the timezone portion of the date/time string is
  246.   // absent (which violates W3C-DTF, although ISO 8601 allows it), we
  247.   // assume the value to be in UTC.
  248.  
  249.   // The offset between the remote timezone and UTC in milliseconds.
  250.   var remoteToUTCOffset = 0;
  251.   if (parts[13] && parts[13] != "Z") {
  252.     var direction = (parts[14] == "+" ? 1 : -1);
  253.     if (parts[15])
  254.       remoteToUTCOffset += direction * parts[15] * HOURS_TO_MILLISECONDS;
  255.     if (parts[16])
  256.       remoteToUTCOffset += direction * parts[16] * MINUTES_TO_MILLISECONDS;
  257.   }
  258.   remoteToUTCOffset = remoteToUTCOffset * -1; // invert it
  259.  
  260.   // The offset between UTC and the local timezone in milliseconds.
  261.   var UTCToLocalOffset = date.getTimezoneOffset() * MINUTES_TO_MILLISECONDS;
  262.   UTCToLocalOffset = UTCToLocalOffset * -1; // invert it
  263.   date.setTime(date.getTime() + remoteToUTCOffset + UTCToLocalOffset);
  264.  
  265.   return date.toUTCString();
  266. }
  267.  
  268. const RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
  269. // namespace map
  270. var gNamespaces = {
  271.   "http://webns.net/mvcb/":"admin",
  272.   "http://backend.userland.com/rss":"",
  273.   "http://blogs.law.harvard.edu/tech/rss":"",
  274.   "http://www.w3.org/2005/Atom":"atom",
  275.   "http://purl.org/atom/ns#":"atom03",
  276.   "http://purl.org/rss/1.0/modules/content/":"content",
  277.   "http://purl.org/dc/elements/1.1/":"dc",
  278.   "http://purl.org/dc/terms/":"dcterms",
  279.   "http://www.w3.org/1999/02/22-rdf-syntax-ns#":"rdf",
  280.   "http://purl.org/rss/1.0/":"rss1",
  281.   "http://my.netscape.com/rdf/simple/0.9/":"rss1",
  282.   "http://wellformedweb.org/CommentAPI/":"wfw",                              
  283.   "http://purl.org/rss/1.0/modules/wiki/":"wiki", 
  284.   "http://www.w3.org/XML/1998/namespace":"xml"
  285. }
  286.  
  287.  
  288. function FeedResult() {}
  289. FeedResult.prototype = {
  290.   bozo: false,
  291.   doc: null,
  292.   version: null,
  293.   headers: null,
  294.   uri: null,
  295.   stylesheet: null,
  296.  
  297.   registerExtensionPrefix: function FR_registerExtensionPrefix(ns, prefix) {
  298.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  299.   },
  300.  
  301.   QueryInterface: function FR_QI(iid) {
  302.     if (iid.equals(Ci.nsIFeedResult) ||
  303.         iid.equals(Ci.nsISupports))
  304.       return this;
  305.  
  306.     throw Cr.NS_ERROR_NOINTERFACE;
  307.   },
  308. }  
  309.  
  310. function Feed() {
  311.   this.subtitle = null;
  312.   this.title = null;
  313.   this.items = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  314.   this.link = null;
  315.   this.id = null;
  316.   this.generator = null;
  317.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  318.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  319.   this.baseURI = null;
  320. }
  321.  
  322. Feed.prototype = {
  323.   searchLists: {
  324.     subtitle: ["description","dc:description","rss1:description",
  325.                "atom03:tagline","atom:subtitle"],
  326.     items: ["items","atom03_entries","entries"],
  327.     id: ["atom:id","rdf:about"],
  328.     generator: ["generator"],
  329.     authors : ["authors"],
  330.     contributors: ["contributors"],
  331.     title: ["title","rss1:title", "atom03:title","atom:title"],
  332.     link:  [["link",strToURI],["rss1:link",strToURI]],
  333.     categories: ["categories", "dc:subject"],
  334.     rights: ["atom03:rights","atom:rights"],
  335.     cloud: ["cloud"],
  336.     image: ["image", "rss1:image"],
  337.     textInput: ["textInput", "rss1:textinput"],
  338.     skipDays: ["skipDays"],
  339.     skipHours: ["skipHours"],
  340.     updated: ["pubDate", "lastBuildDate", "atom03:modified", "dc:date",
  341.               "dcterms:modified", "atom:updated"]
  342.   },
  343.  
  344.   normalize: function Feed_normalize() {
  345.     fieldsToObj(this, this.searchLists);
  346.     if (this.skipDays)
  347.       this.skipDays = this.skipDays.getProperty("days");
  348.     if (this.skipHours)
  349.       this.skipHours = this.skipHours.getProperty("hours");
  350.  
  351.     if (this.updated)
  352.       this.updated = dateParse(this.updated);
  353.  
  354.     // Assign Atom link if needed
  355.     if (bagHasKey(this.fields, "links"))
  356.       this._atomLinksToURI();
  357.  
  358.     this._resetBagMembersToRawText([this.searchLists.subtitle, 
  359.                                     this.searchLists.title]);
  360.   },
  361.  
  362.   _atomLinksToURI: function Feed_linkToURI() {
  363.     var links = this.fields.getPropertyAsInterface("links", Ci.nsIArray);
  364.     var alternates = findAtomLinks("alternate", links);
  365.     if (alternates.length > 0) {
  366.       try {
  367.         var href = alternates[0].getPropertyAsAString("href");
  368.         var base;
  369.         if (bagHasKey(alternates[0], "xml:base"))
  370.           base = strToURI(alternates[0].getPropertyAsAString("xml:base"),
  371.                           this.baseURI);
  372.         else
  373.           base = this.baseURI;
  374.         this.link = strToURI(alternates[0].getPropertyAsAString("href"), base);
  375.       }
  376.       catch(e) {
  377.         LOG(e);
  378.       }
  379.     }
  380.   },
  381.  
  382.   // reset the bag to raw contents, not text constructs
  383.   _resetBagMembersToRawText: function Feed_resetBagMembers(fieldLists) {
  384.     for (var i=0; i<fieldLists.length; i++) {      
  385.       for (var j=0; j<fieldLists[i].length; j++) {
  386.         if (bagHasKey(this.fields, fieldLists[i][j])) {
  387.           var textConstruct = this.fields.getProperty(fieldLists[i][j]);
  388.           this.fields.setPropertyAsAString(fieldLists[i][j],
  389.                                            textConstruct.text);
  390.         }
  391.       }
  392.     }
  393.   },
  394.    
  395.   QueryInterface: function Feed_QI(iid) {
  396.     if (iid.equals(Ci.nsIFeed) ||
  397.         iid.equals(Ci.nsIFeedContainer) ||
  398.         iid.equals(Ci.nsISupports))
  399.     return this;
  400.     throw Cr.NS_ERROR_NOINTERFACE;
  401.   }
  402. }
  403.  
  404. function Entry() {
  405.   this.summary = null;
  406.   this.content = null;
  407.   this.title = null;
  408.   this.fields = Cc["@mozilla.org/hash-property-bag;1"].
  409.     createInstance(Ci.nsIWritablePropertyBag2);
  410.   this.link = null;
  411.   this.id = null;
  412.   this.baseURI = null;
  413.   this.updated = null;
  414.   this.published = null;
  415.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  416.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  417. }
  418.   
  419. Entry.prototype = {
  420.   fields: null,
  421.   enclosures: null,
  422.   mediaContent: null,
  423.   
  424.   searchLists: {
  425.     title: ["title", "rss1:title", "atom03:title", "atom:title"],
  426.     link: [["link",strToURI],["rss1:link",strToURI]],
  427.     id: [["guid", makePropGetter("guid")], "rdf:about",
  428.          "atom03:id", "atom:id"],
  429.     authors : ["authors"],
  430.     contributors: ["contributors"],
  431.     summary: ["description", "rss1:description", "dc:description",
  432.               "atom03:summary", "atom:summary"],
  433.     content: ["content:encoded","atom03:content","atom:content"],
  434.     rights: ["atom03:rights","atom:rights"],
  435.     published: ["atom03:issued", "dcterms:issued", "atom:published"],
  436.     updated: ["pubDate", "atom03:modified", "dc:date", "dcterms:modified",
  437.               "atom:updated"]
  438.   },
  439.   
  440.   normalize: function Entry_normalize() {
  441.     fieldsToObj(this, this.searchLists);
  442.  
  443.     // Assign Atom link if needed
  444.     if (bagHasKey(this.fields, "links"))
  445.       this._atomLinksToURI();
  446.  
  447.     // The link might be a guid w/ permalink=true
  448.     if (!this.link && bagHasKey(this.fields, "guid")) {
  449.       var guid = this.fields.getProperty("guid");
  450.       var isPermaLink = true;
  451.       
  452.       if (bagHasKey(guid, "isPermaLink"))
  453.         isPermaLink = new Boolean(guid.getProperty("isPermaLink"));
  454.       
  455.       if (guid && isPermaLink)
  456.         this.link = strToURI(guid.getProperty("guid"));
  457.     }
  458.  
  459.     if (this.updated)
  460.       this.updated = dateParse(this.updated);
  461.     if (this.published)
  462.       this.published = dateParse(this.published);
  463.  
  464.     this._resetBagMembersToRawText([this.searchLists.content, 
  465.                                     this.searchLists.summary, 
  466.                                     this.searchLists.title]);
  467.   },
  468.   
  469.   QueryInterface: function(iid) {
  470.     if (iid.equals(Ci.nsIFeedEntry) ||
  471.         iid.equals(Ci.nsIFeedContainer) ||
  472.         iid.equals(Ci.nsISupports))
  473.     return this;
  474.  
  475.     throw Cr.NS_ERROR_NOINTERFACE;
  476.   }
  477. }
  478.  
  479. Entry.prototype._atomLinksToURI = Feed.prototype._atomLinksToURI;
  480. Entry.prototype._resetBagMembersToRawText = 
  481.    Feed.prototype._resetBagMembersToRawText;
  482.  
  483. // TextConstruct represents and element that could contain (X)HTML
  484. function TextConstruct() {
  485.   this.lang = null;
  486.   this.base = null;
  487.   this.type = "text";
  488.   this.text = null;
  489. }
  490.  
  491. TextConstruct.prototype = {
  492.   plainText: function TC_plainText() {
  493.     if (this.type != "text") {
  494.       return gUnescapeHTML.unescape(stripTags(this.text));
  495.     }
  496.     return this.text;
  497.   },
  498.  
  499.   createDocumentFragment: function TC_createDocumentFragment(element) {
  500.     if (this.type == "text") {
  501.       var doc = element.ownerDocument;
  502.       var docFragment = doc.createDocumentFragment();
  503.       var node = doc.createTextNode(this.text);
  504.       docFragment.appendChild(node);
  505.       return docFragment;
  506.     }
  507.     var isXML;
  508.     if (this.type == "xhtml")
  509.       isXML = true
  510.     else if (this.type == "html")
  511.       isXML = false;
  512.     else
  513.       return null;
  514.  
  515.     return gUnescapeHTML.parseFragment(this.text, isXML, this.base, element);
  516.   },
  517.  
  518.   QueryInterface: function(iid) {
  519.     if (iid.equals(Ci.nsIFeedTextConstruct) ||
  520.         iid.equals(Ci.nsISupports))
  521.     return this;
  522.  
  523.     throw Cr.NS_ERROR_NOINTERFACE;
  524.   }
  525. }
  526.  
  527. // Generator represents the software that produced the feed
  528. function Generator() {
  529.   this.lang = null;
  530.   this.agent = null;
  531.   this.version = null;
  532.   this.uri = null;
  533.  
  534.   // nsIFeedElementBase
  535.   this._attributes = null;
  536.   this.baseURI = null;
  537. }
  538.  
  539. Generator.prototype = {
  540.  
  541.   get attributes() {
  542.     return this._attributes;
  543.   },
  544.  
  545.   set attributes(value) {
  546.     this._attributes = value;
  547.     this.version = this._attributes.getValueFromName("","version");
  548.     var uriAttribute = this._attributes.getValueFromName("","uri") ||
  549.                        this._attributes.getValueFromName("","url");
  550.     this.uri = strToURI(uriAttribute, this.baseURI);
  551.  
  552.     // RSS1
  553.     uriAttribute = this._attributes.getValueFromName(RDF_NS,"resource");
  554.     if (uriAttribute) {
  555.       this.agent = uriAttribute;
  556.       this.uri = strToURI(uriAttribute, this.baseURI);
  557.     }
  558.   },
  559.  
  560.   QueryInterface: function(iid) {
  561.     if (iid.equals(Ci.nsIFeedGenerator) ||
  562.         iid.equals(Ci.nsIFeedElementBase) ||
  563.         iid.equals(Ci.nsISupports))
  564.     return this;
  565.  
  566.     throw Cr.NS_ERROR_NOINTERFACE;
  567.   }
  568. }
  569.  
  570. function Person() {
  571.   this.name = null;
  572.   this.uri = null;
  573.   this.email = null;
  574.  
  575.   // nsIFeedElementBase
  576.   this.attributes = null;
  577.   this.baseURI = null;
  578. }
  579.  
  580. Person.prototype = {
  581.   QueryInterface: function(iid) {
  582.     if (iid.equals(Ci.nsIFeedPerson) ||
  583.         iid.equals(Ci.nsIFeedElementBase) ||
  584.         iid.equals(Ci.nsISupports))
  585.     return this;
  586.  
  587.     throw Cr.NS_ERROR_NOINTERFACE;
  588.   }
  589. }
  590.  
  591. /** 
  592.  * Map a list of fields into properties on a container.
  593.  *
  594.  * @param container An nsIFeedContainer
  595.  * @param fields A list of fields to search for. List members can
  596.  *               be a list, in which case the second member is 
  597.  *               transformation function (like parseInt).
  598.  */
  599. function fieldsToObj(container, fields) {
  600.   var props,prop,field,searchList;
  601.   for (var key in fields) {
  602.     searchList = fields[key];
  603.     for (var i=0; i < searchList.length; ++i) {
  604.       props = searchList[i];
  605.       prop = null;
  606.       field = isArray(props) ? props[0] : props;
  607.       try {
  608.         prop = container.fields.getProperty(field);
  609.       } 
  610.       catch(e) { 
  611.       }
  612.       if (prop) {
  613.         prop = isArray(props) ? props[1](prop) : prop;
  614.         container[key] = prop;
  615.       }
  616.     }
  617.   }
  618. }
  619.  
  620. /**
  621.  * Lower cases an element's localName property
  622.  * @param   element A DOM element.
  623.  *
  624.  * @returns The lower case localName property of the specified element
  625.  */
  626. function LC(element) {
  627.   return element.localName.toLowerCase();
  628. }
  629.  
  630. // TODO move these post-processor functions
  631. // create a generator element
  632. function atomGenerator(s, generator) {
  633.   generator.QueryInterface(Ci.nsIFeedGenerator);
  634.   generator.agent = trimString(s);
  635.   return generator;
  636. } 
  637.  
  638. // post-process an RSS category, map it to the Atom fields.
  639. function rssCatTerm(s, cat) {
  640.   // add slash handling?
  641.   cat.setPropertyAsAString("term", trimString(s));
  642.   return cat;
  643. } 
  644.  
  645. // post-process a GUID 
  646. function rssGuid(s, guid) {
  647.   guid.setPropertyAsAString("guid", trimString(s));
  648.   return guid;
  649. }
  650.  
  651. // post-process an RSS author element
  652. //
  653. // It can contain a field like this:
  654. // 
  655. //  <author>lawyer@boyer.net (Lawyer Boyer)</author>
  656. //
  657. // or, delightfully, a field like this:
  658. //
  659. //  <dc:creator>Simon St.Laurent (mailto:simonstl@simonstl.com)</dc:creator>
  660. //
  661. // We want to split this up and assign it to corresponding Atom
  662. // fields.
  663. //
  664. function rssAuthor(s,author) {
  665.   author.QueryInterface(Ci.nsIFeedPerson);
  666.   // check for RSS2 string format
  667.   var chars = trimString(s);
  668.   var matches = chars.match(/(.*)\((.*)\)/);
  669.   var emailCheck = 
  670.     /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
  671.   if (matches) {
  672.     var match1 = trimString(matches[1]);
  673.     var match2 = trimString(matches[2]);
  674.     if (match2.indexOf("mailto:") == 0)
  675.       match2 = match2.substring(7);
  676.     if (emailCheck.test(match1)) {
  677.       author.email = match1;
  678.       author.name = match2;
  679.     }
  680.     else if (emailCheck.test(match2)) {
  681.       author.email = match2;
  682.       author.name = match1;
  683.     }
  684.     else {
  685.       // put it back together
  686.       author.name = match1 + " (" + match2 + ")";
  687.     }
  688.   }
  689.   else {
  690.     author.name = chars;
  691.     if (chars.indexOf('@'))
  692.       author.email = chars;
  693.   }
  694.   return author;
  695. }
  696.  
  697. //
  698. // skipHours and skipDays map to arrays, so we need to change the
  699. // string to an nsISupports in order to stick it in there.
  700. //
  701. function rssArrayElement(s) {
  702.   var str = Cc["@mozilla.org/supports-string;1"].
  703.               createInstance(Ci.nsISupportsString);
  704.   str.data = s;
  705.   str.QueryInterface(Ci.nsISupportsString);
  706.   return str;
  707. }
  708.  
  709. /***** Some feed utils from TBird *****/
  710.  
  711. /**
  712.  * Tests a RFC822 date against a regex.
  713.  * @param aDateStr A string to test as an RFC822 date.
  714.  *
  715.  * @returns A boolean indicating whether the string is a valid RFC822 date.
  716.  */
  717. function isValidRFC822Date(aDateStr) {
  718.   var regex = new RegExp(RFC822_RE);
  719.   return regex.test(aDateStr);
  720. }
  721.  
  722. /**
  723.  * Removes leading and trailing whitespace from a string.
  724.  * @param s The string to trim.
  725.  *
  726.  * @returns A new string with whitespace stripped.
  727.  */
  728. function trimString(s) {
  729.   return(s.replace(/^\s+/, "").replace(/\s+$/, ""));
  730. }
  731.  
  732. // Regular expression matching RFC822 dates 
  733. const RFC822_RE = "^(((Mon)|(Tue)|(Wed)|(Thu)|(Fri)|(Sat)|(Sun)), *)?\\d\\d?"
  734. + " +((Jan)|(Feb)|(Mar)|(Apr)|(May)|(Jun)|(Jul)|(Aug)|(Sep)|(Oct)|(Nov)|(Dec))"
  735. + " +\\d\\d(\\d\\d)? +\\d\\d:\\d\\d(:\\d\\d)? +(([+-]?\\d\\d\\d\\d)|(UT)|(GMT)"
  736. + "|(EST)|(EDT)|(CST)|(CDT)|(MST)|(MDT)|(PST)|(PDT)|\\w)$";
  737.  
  738. /**
  739.  * XXX -- need to decide what this should return. 
  740.  * XXX -- Is there a Date class usable from C++?
  741.  *
  742.  * Tries tries parsing various date formats.
  743.  * @param dateString
  744.  *        A string that is supposedly an RFC822 or RFC3339 date.
  745.  * @returns A Date.toString XXX--fixme
  746.  */
  747. function dateParse(dateString) {
  748.   var date = trimString(dateString);
  749.  
  750.   if (date.search(/^\d\d\d\d/) != -1) //Could be a ISO8601/W3C date
  751.     return W3CToIETFDate(dateString);
  752.  
  753.   if (isValidRFC822Date(date))
  754.     return date; 
  755.   
  756.   if (!isNaN(parseInt(date, 10))) { 
  757.     //It's an integer, so maybe it's a timestamp
  758.     var d = new Date(parseInt(date, 10) * 1000);
  759.     var now = new Date();
  760.     var yeardiff = now.getFullYear() - d.getFullYear();
  761.     if ((yeardiff >= 0) && (yeardiff < 3)) {
  762.       // it's quite likely the correct date. 3 years is an arbitrary cutoff,
  763.       // but this is an invalid date format, and there's no way to verify
  764.       // its correctness.
  765.       return d.toString();
  766.     }
  767.   }
  768.   // Can't help.
  769.   return null;
  770. } 
  771.  
  772.  
  773. const XHTML_NS = "http://www.w3.org/1999/xhtml";
  774.  
  775. // The XHTMLHandler handles inline XHTML found in things like atom:summary
  776. function XHTMLHandler(processor, isAtom) {
  777.   this._buf = "";
  778.   this._processor = processor;
  779.   this._depth = 0;
  780.   this._isAtom = isAtom;
  781. }
  782.  
  783. // The fidelity can be improved here, to allow handling of stuff like
  784. // SVG and MathML. XXX
  785. XHTMLHandler.prototype = {
  786.   startDocument: function XH_startDocument() {
  787.   },
  788.   endDocument: function XH_endDocument() {
  789.   },
  790.   startElement: function XH_startElement(uri, localName, qName, attributes) {
  791.     ++this._depth;
  792.  
  793.     // RFC4287 requires XHTML to be wrapped in a div that is *not* part of 
  794.     // the content. This prevents people from screwing up namespaces, but
  795.     // we need to skip it here.
  796.     if (this._isAtom && this._depth == 1 && localName == "div")
  797.       return;
  798.  
  799.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  800.     if (uri == XHTML_NS) {
  801.       this._buf += "<" + localName;
  802.       for (var i=0; i < attributes.length; ++i) {
  803.         // XHTML attributes aren't in a namespace
  804.         if (attributes.getURI(i) == "") { 
  805.           this._buf += (" " + attributes.getLocalName(i) + "='" +
  806.                         xmlEscape(attributes.getValue(i)) + "'");
  807.         }
  808.       }
  809.       this._buf += ">";
  810.     }
  811.   },
  812.   endElement: function XH_endElement(uri, localName, qName) {
  813.     --this._depth;
  814.     
  815.     // We need to skip outer divs in Atom. See comment in startElement.
  816.     if (this._isAtom && this._depth == 0 && localName == "div")
  817.       return;
  818.  
  819.     // When we peek too far, go back to the main processor
  820.     if (this._depth < 0) {
  821.       this._processor.returnFromXHTMLHandler(trimString(this._buf),
  822.                                              uri, localName, qName);
  823.       return;
  824.     }
  825.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  826.     if (uri == XHTML_NS) {
  827.       this._buf += "</" + localName + ">";
  828.     }
  829.   },
  830.   characters: function XH_characters(data) {
  831.     this._buf += xmlEscape(data);
  832.   },
  833.   startPrefixMapping: function XH_startPrefixMapping() {
  834.   },
  835.   endPrefixMapping: function XH_endPrefixMapping() {
  836.   },
  837.   processingInstruction: function XH_processingInstruction() {
  838.   }, 
  839. }
  840.  
  841. /**
  842.  * The ExtensionHandler deals with elements we haven't explicitly
  843.  * added to our transition table in the FeedProcessor.
  844.  */
  845. function ExtensionHandler(processor) {
  846.   this._buf = "";
  847.   this._depth = 0;
  848.   this._hasChildElements = false;
  849.  
  850.   // The FeedProcessor
  851.   this._processor = processor;
  852.  
  853.   // Fields of the outermost extension element.
  854.   this._localName = null;
  855.   this._uri = null;
  856.   this._qName = null;
  857.   this._attrs = null;
  858. }
  859.  
  860. ExtensionHandler.prototype = {
  861.   startDocument: function EH_startDocument() {
  862.   },
  863.   endDocument: function EH_endDocument() {
  864.   },
  865.   startElement: function EH_startElement(uri, localName, qName, attrs) {
  866.     ++this._depth;
  867.     var prefix = gNamespaces[uri] ? gNamespaces[uri] + ":" : "";
  868.     var key =  prefix + localName;
  869.     
  870.     if (this._depth == 1) {
  871.       this._uri = uri;
  872.       this._localName = localName;
  873.       this._qName = qName;
  874.       this._attrs = attrs;
  875.     }
  876.     
  877.     // if we descend into another element, we won't send text
  878.     this._hasChildElements = (this._depth > 1);
  879.     
  880.   },
  881.   endElement: function EH_endElement(uri, localName, qName) {
  882.     --this._depth;
  883.     if (this._depth == 0) {
  884.       var text = this._hasChildElements ? null : trimString(this._buf);
  885.       this._processor.returnFromExtHandler(this._uri, this._localName, 
  886.                                            text, this._attrs);
  887.     }
  888.   },
  889.   characters: function EH_characters(data) {
  890.     if (!this._hasChildElements)
  891.       this._buf += data;
  892.   },
  893.   startPrefixMapping: function EH_startPrefixMapping() {
  894.   },
  895.   endPrefixMapping: function EH_endPrefixMapping() {
  896.   },
  897.   processingInstruction: function EH_processingInstruction() {
  898.   }, 
  899. };
  900.  
  901.  
  902. /**
  903.  * ElementInfo is a simple container object that describes
  904.  * some characteristics of a feed element. For example, it
  905.  * says whether an element can be expected to appear more
  906.  * than once inside a given entry or feed.
  907.  */ 
  908. function ElementInfo(fieldName, containerClass, closeFunc, isArray) {
  909.   this.fieldName = fieldName;
  910.   this.containerClass = containerClass;
  911.   this.closeFunc = closeFunc;
  912.   this.isArray = isArray;
  913.   this.isWrapper = false;
  914. }
  915.  
  916. /**
  917.  * FeedElementInfo represents a feed element, usually the root.
  918.  */
  919. function FeedElementInfo(fieldName, feedVersion) {
  920.   this.isWrapper = false;
  921.   this.fieldName = fieldName;
  922.   this.feedVersion = feedVersion;
  923. }
  924.  
  925. /**
  926.  * Some feed formats include vestigial wrapper elements that we don't
  927.  * want to include in our object model, but we do need to keep track
  928.  * of during parsing.
  929.  */
  930. function WrapperElementInfo(fieldName) {
  931.   this.isWrapper = true;
  932.   this.fieldName = fieldName;
  933. }
  934.  
  935. /***** The Processor *****/
  936. function FeedProcessor() {
  937.   this._reader = Cc[SAX_CONTRACTID].createInstance(Ci.nsISAXXMLReader);
  938.   this._buf =  "";
  939.   this._feed = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  940.   this._handlerStack = [];
  941.   this._xmlBaseStack = []; // sparse array keyed to nesting depth
  942.   this._depth = 0;
  943.   this._state = "START";
  944.   this._result = null;
  945.   this._extensionHandler = null;
  946.   this._xhtmlHandler = null;
  947.  
  948.   // The nsIFeedResultListener waiting for the parse results
  949.   this.listener = null;
  950.  
  951.   // These elements can contain (X)HTML or plain text.
  952.   // We keep a table here that contains their default treatment
  953.   this._textConstructs = {"atom:title":"text",
  954.                           "atom:summary":"text",
  955.                           "atom:rights":"text",
  956.                           "atom:content":"text",
  957.                           "atom:subtitle":"text",
  958.                           "description":"html",
  959.                           "rss1:description":"html",
  960.                           "dc:description":"html",
  961.                           "content:encoded":"html",
  962.                           "title":"text",
  963.                           "rss1:title":"text",
  964.                           "atom03:title":"text",
  965.                           "atom03:tagline":"text",
  966.                           "atom03:summary":"text",
  967.                           "atom03:content":"text"};
  968.   this._stack = [];
  969.  
  970.   this._trans = {   
  971.     "START": {
  972.       //If we hit a root RSS element, treat as RSS2.
  973.       "rss": new FeedElementInfo("RSS2", "rss2"),
  974.  
  975.       // If we hit an RDF element, if could be RSS1, but we can't
  976.       // verify that until we hit a rss1:channel element.
  977.       "rdf:RDF": new WrapperElementInfo("RDF"),
  978.  
  979.       // If we hit a Atom 1.0 element, treat as Atom 1.0.
  980.       "atom:feed": new FeedElementInfo("Atom", "atom"),
  981.  
  982.       // Treat as Atom 0.3
  983.       "atom03:feed": new FeedElementInfo("Atom03", "atom03"),
  984.     },
  985.     
  986.     /********* RSS2 **********/
  987.     "IN_RSS2": {
  988.       "channel": new WrapperElementInfo("channel")
  989.     },
  990.  
  991.     "IN_CHANNEL": {
  992.       "item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  993.       "managingEditor": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  994.                                         rssAuthor, true),
  995.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  996.                                     rssAuthor, true),
  997.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  998.                                    rssAuthor, true),
  999.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1000.                                          rssAuthor, true),
  1001.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1002.       "cloud": new ElementInfo("cloud", null, null, false),
  1003.       "image": new ElementInfo("image", null, null, false),
  1004.       "textInput": new ElementInfo("textInput", null, null, false),
  1005.       "skipDays": new ElementInfo("skipDays", null, null, false),
  1006.       "skipHours": new ElementInfo("skipHours", null, null, false),
  1007.       "generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1008.                                    atomGenerator, false),
  1009.     },
  1010.  
  1011.     "IN_ITEMS": {
  1012.       "author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1013.                                 rssAuthor, true),
  1014.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1015.                                     rssAuthor, true),
  1016.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1017.                                    rssAuthor, true),
  1018.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1019.                                          rssAuthor, true),
  1020.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1021.       "enclosure": new ElementInfo("enclosure", null, null, true),
  1022.       "guid": new ElementInfo("guid", null, rssGuid, false)
  1023.     },
  1024.  
  1025.     "IN_SKIPDAYS": {
  1026.       "day": new ElementInfo("days", null, rssArrayElement, true)
  1027.     },
  1028.  
  1029.     "IN_SKIPHOURS":{
  1030.       "hour": new ElementInfo("hours", null, rssArrayElement, true)
  1031.     },
  1032.  
  1033.     /********* RSS1 **********/
  1034.     "IN_RDF": {
  1035.       // If we hit a rss1:channel, we can verify that we have RSS1
  1036.       "rss1:channel": new FeedElementInfo("rdf_channel", "rss1"),
  1037.       "rss1:image": new ElementInfo("image", null, null, false),
  1038.       "rss1:textinput": new ElementInfo("textInput", null, null, false),
  1039.       "rss1:item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  1040.     },
  1041.  
  1042.     "IN_RDF_CHANNEL": {
  1043.       "admin:generatorAgent": new ElementInfo("generator",
  1044.                                               Cc[GENERATOR_CONTRACTID],
  1045.                                               null, false),
  1046.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1047.                                     rssAuthor, true),
  1048.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1049.                                    rssAuthor, true),
  1050.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1051.                                          rssAuthor, true),
  1052.     },
  1053.  
  1054.     /********* ATOM 1.0 **********/
  1055.     "IN_ATOM": {
  1056.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1057.                                      null, true),
  1058.       "atom:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1059.                                         atomGenerator, false),
  1060.       "atom:contributor": new ElementInfo("contributors",  Cc[PERSON_CONTRACTID],
  1061.                                           null, true),
  1062.       "atom:link": new ElementInfo("links", null, null, true),
  1063.       "atom:entry": new ElementInfo("entries", Cc[ENTRY_CONTRACTID],
  1064.                                     null, true)
  1065.     },
  1066.  
  1067.     "IN_ENTRIES": {
  1068.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1069.                                      null, true),
  1070.       "atom:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1071.                                           null, true),
  1072.       "atom:link": new ElementInfo("links", null, null, true),
  1073.     },
  1074.  
  1075.     /********* ATOM 0.3 **********/
  1076.     "IN_ATOM03": {
  1077.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1078.                                        null, true),
  1079.       "atom03:contributor": new ElementInfo("contributors",
  1080.                                             Cc[PERSON_CONTRACTID],
  1081.                                             null, true),
  1082.       "atom03:link": new ElementInfo("links", null, null, true),
  1083.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1084.                                       null, true),
  1085.       "atom03:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1086.                                           atomGenerator, false),
  1087.     },
  1088.  
  1089.     "IN_ATOM03_ENTRIES": {
  1090.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1091.                                        null, true),
  1092.       "atom03:contributor": new ElementInfo("contributors",
  1093.                                             Cc[PERSON_CONTRACTID],
  1094.                                             null, true),
  1095.       "atom03:link": new ElementInfo("links", null, null, true),
  1096.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1097.                                       null, true)
  1098.     }
  1099.   }
  1100. }
  1101.  
  1102. // See startElement for a long description of how feeds are processed.
  1103. FeedProcessor.prototype = { 
  1104.   
  1105.   // Set ourselves as the SAX handler, and set the base URI
  1106.   _init: function FP_init(uri) {
  1107.     this._reader.contentHandler = this;
  1108.     this._reader.errorHandler = this;
  1109.     this._result = Cc[FR_CONTRACTID].createInstance(Ci.nsIFeedResult);
  1110.     if (uri) {
  1111.       this._result.uri = uri;
  1112.       this._reader.baseURI = uri;
  1113.       this._xmlBaseStack[0] = uri;
  1114.     }
  1115.   },
  1116.  
  1117.   // This function is called once we figure out what type of feed
  1118.   // we're dealing with. Some feed types require digging a bit further
  1119.   // than the root.
  1120.   _docVerified: function FP_docVerified(version) {
  1121.     this._result.doc = Cc[FEED_CONTRACTID].createInstance(Ci.nsIFeed);
  1122.     this._result.doc.baseURI = 
  1123.       this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1124.     this._result.doc.fields = this._feed;
  1125.     this._result.version = version;
  1126.   },
  1127.  
  1128.   // When we're done with the feed, let the listener know what
  1129.   // happened.
  1130.   _sendResult: function FP_sendResult() {
  1131.     try {
  1132.       // Can be null when a non-feed is fed to us
  1133.       if (this._result.doc)
  1134.         this._result.doc.normalize();
  1135.     }
  1136.     catch (e) {
  1137.       LOG("FIXME: " + e);
  1138.     }
  1139.  
  1140.     try {
  1141.       if (this.listener != null)
  1142.         this.listener.handleResult(this._result);
  1143.     }
  1144.     finally {
  1145.       this._result = null;
  1146.       this._reader = null;
  1147.     }
  1148.   },
  1149.  
  1150.   // Parsing functions
  1151.   parseFromStream: function FP_parseFromStream(stream, uri) {
  1152.     this._init(uri);
  1153.     this._reader.parseFromStream(stream, null, stream.available(), 
  1154.                                  "application/xml");
  1155.     this._reader = null;
  1156.   },
  1157.  
  1158.   parseFromString: function FP_parseFromString(inputString, uri) {
  1159.     this._init(uri);
  1160.     this._reader.parseFromString(inputString, "application/xml");
  1161.     this._reader = null;
  1162.   },
  1163.  
  1164.   parseAsync: function FP_parseAsync(requestObserver, uri) {
  1165.     this._init(uri);
  1166.     this._reader.parseAsync(requestObserver);
  1167.   },
  1168.  
  1169.   // nsIStreamListener 
  1170.  
  1171.   // The XMLReader will throw sensible exceptions if these get called
  1172.   // out of order.
  1173.   onStartRequest: function FP_onStartRequest(request, context) {
  1174.     this._reader.onStartRequest(request, context);
  1175.   },
  1176.  
  1177.   onStopRequest: function FP_onStopRequest(request, context, statusCode) {
  1178.     this._reader.onStopRequest(request, context, statusCode);
  1179.   },
  1180.  
  1181.   onDataAvailable:
  1182.   function FP_onDataAvailable(request, context, inputStream, offset, count) {
  1183.     this._reader.onDataAvailable(request, context, inputStream, offset, count);
  1184.   },
  1185.  
  1186.   // nsISAXErrorHandler
  1187.  
  1188.   // We only care about fatal errors. When this happens, we may have
  1189.   // parsed through the feed metadata and some number of entries. The
  1190.   // listener can still show some of that data if it wants, and we'll
  1191.   // set the bozo bit to indicate we were unable to parse all the way
  1192.   // through.
  1193.   fatalError: function FP_reportError() {
  1194.     this._result.bozo = true;
  1195.     //XXX need to QI to FeedProgressListener
  1196.     this._sendResult();
  1197.   },
  1198.  
  1199.   // nsISAXContentHandler
  1200.  
  1201.   startDocument: function FP_startDocument() {
  1202.     //LOG("----------");
  1203.   },
  1204.  
  1205.   endDocument: function FP_endDocument() {
  1206.     this._sendResult();
  1207.   },
  1208.  
  1209.   // The transitions defined above identify elements that contain more
  1210.   // than just text. For example RSS items contain many fields, and so
  1211.   // do Atom authors. The only commonly used elements that contain
  1212.   // mixed content are Atom Text Constructs of type="xhtml", which we
  1213.   // delegate to another handler for cleaning. That leaves a couple
  1214.   // different types of elements to deal with: those that should occur
  1215.   // only once, such as title elements, and those that can occur
  1216.   // multiple times, such as the RSS category element and the Atom
  1217.   // link element. Most of the RSS1/DC elements can occur multiple
  1218.   // times in theory, but in practice, the only ones that do have
  1219.   // analogues in Atom. 
  1220.   //
  1221.   // Some elements are also groups of attributes or sub-elements,
  1222.   // while others are simple text fields. For the most part, we don't
  1223.   // have to pay explicit attention to the simple text elements,
  1224.   // unless we want to post-process the resulting string to transform
  1225.   // it into some richer object like a Date or URI.
  1226.   //
  1227.   // Elements that have more sophisticated content models still end up
  1228.   // being dictionaries, whether they are based on attributes like RSS
  1229.   // cloud, sub-elements like Atom author, or even items and
  1230.   // entries. These elements are treated as "containers". It's
  1231.   // theoretically possible for a container to have an attribute with 
  1232.   // the same universal name as a sub-element, but none of the feed
  1233.   // formats allow this by default, and I don't of any extension that
  1234.   // works this way.
  1235.   //
  1236.   startElement: function FP_startElement(uri, localName, qName, attributes) {
  1237.     this._buf = "";
  1238.     ++this._depth;
  1239.     var elementInfo;
  1240.  
  1241.     //LOG("<" + localName + ">");
  1242.  
  1243.     // Check for xml:base
  1244.     var base = attributes.getValueFromName(XMLNS, "base");
  1245.     if (base) {
  1246.       this._xmlBaseStack[this._depth] =
  1247.         strToURI(base, this._xmlBaseStack[this._xmlBaseStack.length - 1]);
  1248.     }
  1249.  
  1250.     // To identify the element we're dealing with, we look up the
  1251.     // namespace URI in our gNamespaces dictionary, which will give us
  1252.     // a "canonical" prefix for a namespace URI. For example, this
  1253.     // allows Dublin Core "creator" elements to be consistently mapped
  1254.     // to "dc:creator", for easy field access by consumer code. This
  1255.     // strategy also happens to shorten up our state table.
  1256.     var key =  this._prefixForNS(uri) + localName;
  1257.  
  1258.     // Check to see if we need to hand this off to our XHTML handler.
  1259.     // The elements we're dealing with will look like this:
  1260.     // 
  1261.     // <title type="xhtml">
  1262.     //   <div xmlns="http://www.w3.org/1999/xhtml">
  1263.     //     A title with <b>bold</b> and <i>italics</i>.
  1264.     //   </div>
  1265.     // </title>
  1266.     //
  1267.     // When it returns in returnFromXHTMLHandler, the handler should
  1268.     // give us back a string like this: 
  1269.     // 
  1270.     //    "A title with <b>bold</b> and <i>italics</i>."
  1271.     //
  1272.     // The Atom spec explicitly says the div is not part of the content,
  1273.     // and explicitly allows whitespace collapsing.
  1274.     // 
  1275.     if ((this._result.version == "atom" || this._result.version == "atom03") &&
  1276.         this._textConstructs[key] != null) {
  1277.       var type = attributes.getValueFromName("","type");
  1278.       if (type != null && type.indexOf("xhtml") >= 0) {
  1279.         this._xhtmlHandler = 
  1280.           new XHTMLHandler(this, (this._result.version == "atom"));
  1281.         this._reader.contentHandler = this._xhtmlHandler;
  1282.         return;
  1283.       }
  1284.     }
  1285.  
  1286.     // Check our current state, and see if that state has a defined
  1287.     // transition. For example, this._trans["atom:entry"]["atom:author"]
  1288.     // will have one, and it tells us to add an item to our authors array.
  1289.     if (this._trans[this._state] && this._trans[this._state][key]) {
  1290.       elementInfo = this._trans[this._state][key];
  1291.     }
  1292.     else {
  1293.       // If we don't have a transition, hand off to extension handler
  1294.       this._extensionHandler = new ExtensionHandler(this);
  1295.       this._reader.contentHandler = this._extensionHandler;
  1296.       this._extensionHandler.startElement(uri, localName, qName, attributes);
  1297.       return;
  1298.     }
  1299.       
  1300.     // This distinguishes wrappers like 'channel' from elements
  1301.     // we'd actually like to do something with (which will test true).
  1302.     this._handlerStack[this._depth] = elementInfo; 
  1303.     if (elementInfo.isWrapper) {
  1304.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1305.       this._stack.push([this._feed, this._state]);
  1306.     } 
  1307.     else if (elementInfo.feedVersion) {
  1308.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1309.  
  1310.       // Check for the older RSS2 variants
  1311.       if (elementInfo.feedVersion == "rss2")
  1312.         elementInfo.feedVersion = this._findRSSVersion(attributes);
  1313.       else if (uri == RSS090NS)
  1314.         elementInfo.feedVersion = "rss090";
  1315.  
  1316.       this._docVerified(elementInfo.feedVersion);
  1317.       this._stack.push([this._feed, this._state]);
  1318.       this._mapAttributes(this._feed, attributes);
  1319.     }
  1320.     else {
  1321.       this._state = this._processComplexElement(elementInfo, attributes);
  1322.     }
  1323.   },
  1324.  
  1325.   // In the endElement handler, we decrement the stack and look
  1326.   // for cleanup/transition functions to execute. The second part
  1327.   // of the state transition works as above in startElement, but
  1328.   // the state we're looking for is prefixed with an underscore
  1329.   // to distinguish endElement events from startElement events.
  1330.   endElement:  function FP_endElement(uri, localName, qName) {
  1331.     var elementInfo = this._handlerStack[this._depth];
  1332.     //LOG("</" + localName + ">");
  1333.     if (elementInfo && !elementInfo.isWrapper)
  1334.       this._closeComplexElement(elementInfo);
  1335.   
  1336.     // cut down xml:base context
  1337.     if (this._xmlBaseStack.length == this._depth + 1)
  1338.       this._xmlBaseStack = this._xmlBaseStack.slice(0, this._depth);
  1339.  
  1340.     // our new state is whatever is at the top of the stack now
  1341.     if (this._stack.length > 0)
  1342.       this._state = this._stack[this._stack.length - 1][1];
  1343.     this._handlerStack = this._handlerStack.slice(0, this._depth);
  1344.     --this._depth;
  1345.   },
  1346.  
  1347.   // Buffer up character data. The buffer is cleared with every
  1348.   // opening element.
  1349.   characters: function FP_characters(data) {
  1350.     this._buf += data;
  1351.   },
  1352.  
  1353.   // TODO: It would be nice to check new prefixes here, and if they
  1354.   // don't conflict with the ones we've defined, throw them in a 
  1355.   // dictionary to check.
  1356.   startPrefixMapping: function FP_startPrefixMapping() {
  1357.   },
  1358.   endPrefixMapping: function FP_endPrefixMapping() {
  1359.   },
  1360.   processingInstruction: function FP_processingInstruction(target, data) {
  1361.     if (target == "xml-stylesheet") {
  1362.       var hrefAttribute = data.match(/href=[\"\'](.*?)[\"\']/);
  1363.       if (hrefAttribute && hrefAttribute.length == 2) 
  1364.         this._result.stylesheet = gIoService.newURI(hrefAttribute[1], null,
  1365.                                                     this._result.uri);
  1366.     }
  1367.   },
  1368.  
  1369.   // end of nsISAXContentHandler
  1370.  
  1371.   // Handle our more complicated elements--those that contain
  1372.   // attributes and child elements.
  1373.   _processComplexElement:
  1374.   function FP__processComplexElement(elementInfo, attributes) {
  1375.     var obj, key, prefix;
  1376.  
  1377.     // If the container is an entry/item, it'll need to have its 
  1378.     // more esoteric properties put in the 'fields' property bag.
  1379.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID]) {
  1380.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedEntry);
  1381.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1382.       this._mapAttributes(obj.fields, attributes);
  1383.     }
  1384.     else if (elementInfo.containerClass) {
  1385.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedElementBase);
  1386.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1387.       obj.attributes = attributes; // just set the SAX attributes
  1388.     }
  1389.     else {
  1390.       obj = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  1391.       this._mapAttributes(obj, attributes);
  1392.     }
  1393.  
  1394.     // We should have a container/propertyBag that's had its
  1395.     // attributes processed. Now we need to attach it to its
  1396.     // container.
  1397.     var newProp;
  1398.  
  1399.     // First we'll see what's on top of the stack.
  1400.     var container = this._stack[this._stack.length - 1][0];
  1401.  
  1402.     // Check to see if it has the property
  1403.     var prop;
  1404.     try {
  1405.       prop = container.getProperty(elementInfo.fieldName);
  1406.     }
  1407.     catch(e) {
  1408.     }
  1409.     
  1410.     if (elementInfo.isArray) {
  1411.       if (!prop) {
  1412.         container.setPropertyAsInterface(elementInfo.fieldName,
  1413.                                          Cc[ARRAY_CONTRACTID].
  1414.                                          createInstance(Ci.nsIMutableArray));
  1415.       }
  1416.  
  1417.       newProp = container.getProperty(elementInfo.fieldName);
  1418.       // XXX This QI should not be necessary, but XPConnect seems to fly
  1419.       // off the handle in the browser, and loses track of the interface
  1420.       // on large files. Bug 335638.
  1421.       newProp.QueryInterface(Ci.nsIMutableArray);
  1422.       newProp.appendElement(obj,false);
  1423.       
  1424.       // If new object is an nsIFeedContainer, we want to deal with
  1425.       // its member nsIPropertyBag instead.
  1426.       if (isIFeedContainer(obj))
  1427.         newProp = obj.fields; 
  1428.  
  1429.     }
  1430.     else {
  1431.       // If it doesn't, set it.
  1432.       if (!prop) {
  1433.         container.setPropertyAsInterface(elementInfo.fieldName,obj);
  1434.       }
  1435.       newProp = container.getProperty(elementInfo.fieldName);
  1436.     }
  1437.     
  1438.     // make our new state name, and push the property onto the stack
  1439.     var newState = "IN_" + elementInfo.fieldName.toUpperCase();
  1440.     this._stack.push([newProp, newState, obj]);
  1441.     return newState;
  1442.   },
  1443.  
  1444.   // Sometimes we need reconcile the element content with the object
  1445.   // model for a given feed. We use helper functions to do the
  1446.   // munging, but we need to identify array types here, so the munging
  1447.   // happens only to the last element of an array.
  1448.   _closeComplexElement: function FP__closeComplexElement(elementInfo) {
  1449.     var stateTuple = this._stack.pop();
  1450.     var container = stateTuple[0];
  1451.     var containerParent = stateTuple[2];
  1452.     var element = null;
  1453.     var isArray = isIArray(container);
  1454.  
  1455.     // If it's an array and we have to post-process,
  1456.     // grab the last element
  1457.     if (isArray)
  1458.       element = container.queryElementAt(container.length - 1, Ci.nsISupports);
  1459.     else
  1460.       element = container;
  1461.  
  1462.     // Run the post-processing function if there is one.
  1463.     if (elementInfo.closeFunc)
  1464.       element = elementInfo.closeFunc(this._buf, element);
  1465.  
  1466.     // If an nsIFeedContainer was on top of the stack,
  1467.     // we need to normalize it
  1468.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID])
  1469.       containerParent.normalize();
  1470.  
  1471.     // If it's an array, re-set the last element
  1472.     if (isArray)
  1473.       container.replaceElementAt(element, container.length - 1, false);
  1474.   },
  1475.   
  1476.   _prefixForNS: function FP_prefixForNS(uri) {
  1477.     if (!uri)
  1478.       return "";
  1479.     var prefix = gNamespaces[uri];
  1480.     if (prefix)
  1481.       return prefix + ":";
  1482.     if (uri.toLowerCase().indexOf("http://backend.userland.com") == 0)
  1483.       return "";
  1484.     else
  1485.       return null;
  1486.   },
  1487.  
  1488.   _mapAttributes: function FP__mapAttributes(bag, attributes) {
  1489.     // Cycle through the attributes, and set our properties using the
  1490.     // prefix:localNames we find in our namespace dictionary.
  1491.     for (var i = 0; i < attributes.length; ++i) {
  1492.       var key = this._prefixForNS(attributes.getURI(i)) + attributes.getLocalName(i);
  1493.       var val = attributes.getValue(i);
  1494.       bag.setPropertyAsAString(key, val);
  1495.     }
  1496.   },
  1497.  
  1498.   // Only for RSS2esque formats
  1499.   _findRSSVersion: function FP__findRSSVersion(attributes) {
  1500.     var versionAttr = trimString(attributes.getValueFromName("", "version"));
  1501.     var versions = { "0.91":"rss091",
  1502.                      "0.92":"rss092",
  1503.                      "0.93":"rss093",
  1504.                      "0.94":"rss094" }
  1505.     if (versions[versionAttr])
  1506.       return versions[versionAttr];
  1507.     if (versionAttr.substr(0,2) != "2.")
  1508.       return "rssUnknown";
  1509.     return "rss2";
  1510.   },
  1511.  
  1512.   // unknown element values are returned here. See startElement above
  1513.   // for how this works.
  1514.   returnFromExtHandler:
  1515.   function FP_returnExt(uri, localName, chars, attributes) {
  1516.     --this._depth;
  1517.  
  1518.     // take control of the SAX events
  1519.     this._reader.contentHandler = this;
  1520.     if (localName == null && chars == null)
  1521.       return;
  1522.  
  1523.     // we don't take random elements inside rdf:RDF
  1524.     if (this._state == "IN_RDF")
  1525.       return;
  1526.     
  1527.     // Grab the top of the stack
  1528.     var top = this._stack[this._stack.length - 1];
  1529.     if (!top) 
  1530.       return;
  1531.  
  1532.     var container = top[0];
  1533.     // Grab the last element if it's an array
  1534.     if (isIArray(container)) {
  1535.       var contract = this._handlerStack[this._depth].containerClass;
  1536.       // check if it's something specific, but not an entry
  1537.       if (contract && contract != Cc[ENTRY_CONTRACTID]) {
  1538.         var el = container.queryElementAt(container.length - 1, 
  1539.                                           Ci.nsIFeedElementBase);
  1540.         // XXX there must be a way to flatten these interfaces
  1541.         if (contract == Cc[PERSON_CONTRACTID]) 
  1542.           el.QueryInterface(Ci.nsIFeedPerson);
  1543.         else
  1544.           return; // don't know about this interface
  1545.  
  1546.         var propName = localName;
  1547.         var prefix = gNamespaces[uri];
  1548.  
  1549.         // synonyms
  1550.         if ((uri == "" || 
  1551.              prefix &&
  1552.              ((prefix.indexOf("atom") > -1) ||
  1553.               (prefix.indexOf("rss") > -1))) && 
  1554.             (propName == "url" || propName == "href"))
  1555.           propName = "uri";
  1556.         
  1557.         try {
  1558.           if (el[propName] !== "undefined") {
  1559.             var propValue = chars;
  1560.             // convert URI-bearing values to an nsIURI
  1561.             if (propName == "uri") {
  1562.               var base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1563.               propValue = strToURI(chars, base);
  1564.             }
  1565.             el[propName] = propValue;
  1566.           }
  1567.         }
  1568.         catch(e) {
  1569.           // ignore XPConnect errors
  1570.         }
  1571.         // the rest of the function deals with entry- and feed-level stuff
  1572.         return; 
  1573.       } 
  1574.       else {
  1575.         container = container.queryElementAt(container.length - 1, 
  1576.                                              Ci.nsIWritablePropertyBag2);
  1577.       }
  1578.     }
  1579.     
  1580.     // Make the buffer our new property
  1581.     var propName = this._prefixForNS(uri) + localName;
  1582.  
  1583.     // But, it could be something containing HTML. If so,
  1584.     // we need to know about that.
  1585.     if (this._textConstructs[propName] != null &&
  1586.         this._handlerStack[this._depth].containerClass !== null) {
  1587.       var newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1588.                     createInstance(Ci.nsIFeedTextConstruct);
  1589.       newProp.text = chars;
  1590.       // Look up the default type in our table
  1591.       var type = this._textConstructs[propName];
  1592.       var typeAttribute = attributes.getValueFromName("","type");
  1593.       if (this._result.version == "atom" && typeAttribute != null) {
  1594.         type = typeAttribute;
  1595.       }
  1596.       else if (this._result.version == "atom03" && typeAttribute != null) {
  1597.         if (typeAttribute.toLowerCase().indexOf("xhtml") >= 0) {
  1598.           type = "xhtml";
  1599.         }
  1600.         else if (typeAttribute.toLowerCase().indexOf("html") >= 0) {
  1601.           type = "html";
  1602.         }
  1603.         else if (typeAttribute.toLowerCase().indexOf("text") >= 0) {
  1604.           type = "text";
  1605.         }
  1606.       }
  1607.       
  1608.       // If it's rss feed-level description, it's not supposed to have html
  1609.       if (this._result.version.indexOf("rss") >= 0 &&
  1610.           this._handlerStack[this._depth].containerClass != ENTRY_CONTRACTID) {
  1611.         type = "text";
  1612.       }
  1613.  
  1614.       newProp.type = type;
  1615.       newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1616.       container.setPropertyAsInterface(propName, newProp);
  1617.     }
  1618.     else {
  1619.       container.setPropertyAsAString(propName, chars);
  1620.     }
  1621.     
  1622.   },
  1623.  
  1624.   // Sometimes, we'll hand off SAX handling duties to an XHTMLHandler
  1625.   // (see above) that will scrape out non-XHTML stuff, normalize
  1626.   // namespaces, and remove the wrapper div from Atom 1.0. When the
  1627.   // XHTMLHandler is done, it'll callback here.
  1628.   returnFromXHTMLHandler:
  1629.   function FP_returnFromXHTMLHandler(chars, uri, localName, qName) {
  1630.     // retake control of the SAX content events
  1631.     this._reader.contentHandler = this;
  1632.  
  1633.     // Grab the top of the stack
  1634.     var top = this._stack[this._stack.length - 1];
  1635.     if (!top) 
  1636.       return;
  1637.     var container = top[0];
  1638.  
  1639.     // Assign the property
  1640.     var newProp =  newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1641.                    createInstance(Ci.nsIFeedTextConstruct);
  1642.     newProp.text = chars;
  1643.     newProp.type = "xhtml";
  1644.     newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1645.     container.setPropertyAsInterface(this._prefixForNS(uri) + localName,
  1646.                                      newProp);
  1647.     
  1648.     // XHTML will cause us to peek too far. The XHTML handler will
  1649.     // send us an end element to call. RFC4287-valid feeds allow a
  1650.     // more graceful way to handle this. Unfortunately, we can't count
  1651.     // on compliance at this point.
  1652.     this.endElement(uri, localName, qName);
  1653.   },
  1654.  
  1655.   // nsISupports
  1656.   QueryInterface: function FP_QueryInterface(iid) {
  1657.     if (iid.equals(Ci.nsIFeedProcessor) ||
  1658.         iid.equals(Ci.nsISAXContentHandler) ||
  1659.         iid.equals(Ci.nsISAXErrorHandler) ||
  1660.         iid.equals(Ci.nsIStreamListener) ||
  1661.         iid.equals(Ci.nsIRequestObserver) ||
  1662.         iid.equals(Ci.nsISupports))
  1663.       return this;
  1664.  
  1665.     throw Cr.NS_ERROR_NOINTERFACE;
  1666.   },
  1667. }
  1668.  
  1669. const FP_CONTRACTID = "@mozilla.org/feed-processor;1";
  1670. const FP_CLASSID = Components.ID("{26acb1f0-28fc-43bc-867a-a46aabc85dd4}");
  1671. const FP_CLASSNAME = "Feed Processor";
  1672. const FR_CONTRACTID = "@mozilla.org/feed-result;1";
  1673. const FR_CLASSID = Components.ID("{072a5c3d-30c6-4f07-b87f-9f63d51403f2}");
  1674. const FR_CLASSNAME = "Feed Result";
  1675. const FEED_CONTRACTID = "@mozilla.org/feed;1";
  1676. const FEED_CLASSID = Components.ID("{5d0cfa97-69dd-4e5e-ac84-f253162e8f9a}");
  1677. const FEED_CLASSNAME = "Feed";
  1678. const ENTRY_CONTRACTID = "@mozilla.org/feed-entry;1";
  1679. const ENTRY_CLASSID = Components.ID("{8e4444ff-8e99-4bdd-aa7f-fb3c1c77319f}");
  1680. const ENTRY_CLASSNAME = "Feed Entry";
  1681. const TEXTCONSTRUCT_CONTRACTID = "@mozilla.org/feed-textconstruct;1";
  1682. const TEXTCONSTRUCT_CLASSID =
  1683.   Components.ID("{b992ddcd-3899-4320-9909-924b3e72c922}");
  1684. const TEXTCONSTRUCT_CLASSNAME = "Feed Text Construct";
  1685. const GENERATOR_CONTRACTID = "@mozilla.org/feed-generator;1";
  1686. const GENERATOR_CLASSID =
  1687.   Components.ID("{414af362-9ad8-4296-898e-62247f25a20e}");
  1688. const GENERATOR_CLASSNAME = "Feed Generator";
  1689. const PERSON_CONTRACTID = "@mozilla.org/feed-person;1";
  1690. const PERSON_CLASSID = Components.ID("{95c963b7-20b2-11db-92f6-001422106990}");
  1691. const PERSON_CLASSNAME = "Feed Person";
  1692.  
  1693. function GenericComponentFactory(ctor) {
  1694.   this._ctor = ctor;
  1695. }
  1696.  
  1697. GenericComponentFactory.prototype = {
  1698.  
  1699.   _ctor: null,
  1700.  
  1701.   // nsIFactory
  1702.   createInstance: function(outer, iid) {
  1703.     if (outer != null)
  1704.       throw Cr.NS_ERROR_NO_AGGREGATION;
  1705.     return (new this._ctor()).QueryInterface(iid);
  1706.   },
  1707.  
  1708.   // nsISupports
  1709.   QueryInterface: function(iid) {
  1710.     if (iid.equals(Ci.nsIFactory) ||
  1711.         iid.equals(Ci.nsISupports))
  1712.       return this;
  1713.     throw Cr.NS_ERROR_NO_INTERFACE;
  1714.   },
  1715.  
  1716. };
  1717.  
  1718. var Module = {
  1719.   QueryInterface: function(iid) {
  1720.     if (iid.equals(Ci.nsIModule) || 
  1721.         iid.equals(Ci.nsISupports))
  1722.       return this;
  1723.  
  1724.     throw Cr.NS_ERROR_NO_INTERFACE;
  1725.   },
  1726.  
  1727.   getClassObject: function(cm, cid, iid) {
  1728.     if (!iid.equals(Ci.nsIFactory))
  1729.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  1730.  
  1731.     if (cid.equals(FP_CLASSID))
  1732.       return new GenericComponentFactory(FeedProcessor);
  1733.     if (cid.equals(FR_CLASSID))
  1734.       return new GenericComponentFactory(FeedResult);
  1735.     if (cid.equals(FEED_CLASSID))
  1736.       return new GenericComponentFactory(Feed);
  1737.     if (cid.equals(ENTRY_CLASSID))
  1738.       return new GenericComponentFactory(Entry);
  1739.     if (cid.equals(TEXTCONSTRUCT_CLASSID))
  1740.       return new GenericComponentFactory(TextConstruct);
  1741.     if (cid.equals(GENERATOR_CLASSID))
  1742.       return new GenericComponentFactory(Generator);
  1743.     if (cid.equals(PERSON_CLASSID))
  1744.       return new GenericComponentFactory(Person);
  1745.  
  1746.     throw Cr.NS_ERROR_NO_INTERFACE;
  1747.   },
  1748.  
  1749.   registerSelf: function(cm, file, location, type) {
  1750.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1751.     // Feed Processor
  1752.     cr.registerFactoryLocation(FP_CLASSID, FP_CLASSNAME,
  1753.       FP_CONTRACTID, file, location, type);
  1754.     // Feed Result
  1755.     cr.registerFactoryLocation(FR_CLASSID, FR_CLASSNAME,
  1756.       FR_CONTRACTID, file, location, type);
  1757.     // Feed
  1758.     cr.registerFactoryLocation(FEED_CLASSID, FEED_CLASSNAME,
  1759.       FEED_CONTRACTID, file, location, type);
  1760.     // Entry
  1761.     cr.registerFactoryLocation(ENTRY_CLASSID, ENTRY_CLASSNAME,
  1762.       ENTRY_CONTRACTID, file, location, type);
  1763.     // Text Construct
  1764.     cr.registerFactoryLocation(TEXTCONSTRUCT_CLASSID, TEXTCONSTRUCT_CLASSNAME,
  1765.       TEXTCONSTRUCT_CONTRACTID, file, location, type);
  1766.     // Generator
  1767.     cr.registerFactoryLocation(GENERATOR_CLASSID, GENERATOR_CLASSNAME,
  1768.       GENERATOR_CONTRACTID, file, location, type);
  1769.     // Person
  1770.     cr.registerFactoryLocation(PERSON_CLASSID, PERSON_CLASSNAME,
  1771.       PERSON_CONTRACTID, file, location, type);
  1772.   },
  1773.  
  1774.   unregisterSelf: function(cm, location, type) {
  1775.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1776.     // Feed Processor
  1777.     cr.unregisterFactoryLocation(FP_CLASSID, location);
  1778.     // Feed Result
  1779.     cr.unregisterFactoryLocation(FR_CLASSID, location);
  1780.     // Feed
  1781.     cr.unregisterFactoryLocation(FEED_CLASSID, location);
  1782.     // Entry
  1783.     cr.unregisterFactoryLocation(ENTRY_CLASSID, location);
  1784.     // Text Construct
  1785.     cr.unregisterFactoryLocation(TEXTCONSTRUCT_CLASSID, location);
  1786.     // Generator
  1787.     cr.unregisterFactoryLocation(GENERATOR_CLASSID, location);
  1788.     // Person
  1789.     cr.unregisterFactoryLocation(PERSON_CLASSID, location);
  1790.   },
  1791.  
  1792.   canUnload: function(cm) {
  1793.     return true;
  1794.   },
  1795. };
  1796.  
  1797. function NSGetModule(cm, file) {
  1798.   return Module;
  1799. }
  1800.