Notice we've gone to the trouble of setting a User-Agent header. This is due to the Twitter API policy, which penalizes a lack of User-Agent string by imposing a lower rate limit.

Our jsonHandler method on the trendingTopics object takes a reponse and cb (callback) parameter. trendingTopics.jsonHandler uses the response object from the http.get call to capture the incoming data stream into a variable (json). When the stream has ended, which is detected using the end event listener on response, cb is invoking converted JSON as the parameter. The callback from trendingTopics.jsonHandler finds its way up into the makeCall callback.

makeCall abstractly combines the GET request and JSON handling, and provides a callback with a single parameter which is the data returned by Twitter as parsed JSON (in this case, it is an array of objects).

In the outer makeCall invocation we call the parameter trendsArr, because Twitter returns its JSON data in an array wrapper. We use trendsArr to locate the query fragment representation of the Twitter's top trend and pass it to the final method of our trendingTopics object: trendingTopics.tweetPath. This method takes a query fragment (q) as its single parameter. It then uses this parameter along with the options in trendingTopics.tweets to build the final Search API path. It injects this path into the urlOpts object of trendingTopics.tweets, which is then passed through into the inner makeCall invocation.

In the inner makeCall invocation we name the parameter tweetsArr. This is an array of objects containing tweet data as returned from the Twitter Search API in response to a query searching for the top trend discovered via the former (outer) call to the Trend API. We loop through the array using the veritable forEach (ES5) looping function, handling each element passed through the loop as tweet.

The objects contained in the tweetsArr array contain lots of data, such as time information, amount of re-tweets, and so forth. However, we're just interested in the content of the tweet, and who tweeted. So we log the from_user and text properties of each tweet to the console:

This is also where the colors module comes in handy since, within console.log we have tweet.from_user.yellow.bold. The colors are not properties on the object returned by Twitter, but rather some trickery performed by the colors module to provide an easy interface for styling console text.

It may be noticed that trending tweets tend to have rather fad-like influences generated from within the Twitter community. Google Hot Trends is another source of trending information. It provides hourly updates of the highest trending searches.

We can extend our example to access and process Google's Hot Trends XML atom feed, and then integrate the top result into our Twitter Search API request. To do this, let's create a new file called google_trends.twitter.js. It's nice to work with XML data as a JavaScript object, so we'll require the non-core xml2js featured in the Converting an object to XML and back again recipe in this chapter, along with http, colors, and our own trendingTopics module.

var http = require('http'),
var xml2js = new (require('xml2js')).Parser();

var colors = require('colors'), //for prettifying the console output
var trendingTopics = require('./twitter_trends'), //load trendingTopics obj

Now we'll extend our trendingTopics object by inheriting from it using the EcmaScript 5 Object.create method.

var hotTrends = Object.create(trendingTopics, {trends: {value: {urlOpts: {
    host: 'www.google.com',
    path: '/trends/hottrends/atom/hourly',
    headers: {'User-Agent': 'Node Cookbook: Twitter Trends'}
  }
    }}});

hotTrends.xmlHandler = function (response, cb) {
  var hotTrendsfeed = '';
  response.on('data', function (chunk) {
    hotTrendsfeed += chunk;
  }).on('end', function () {
    xml2js.parseString(hotTrendsfeed, function (err, obj) {
      if (err) { throw (err.message); }
      xml2js.parseString(obj.entry.content['#'],
	function (err, obj) {
        if (err) { throw (err.message); }
        cb(encodeURIComponent(obj.li[0].span.a['#']));
      });
    });
  });
};

We declared a variable called hotTrends, and used Object.create to initialize an instance of trendingTopics, re-substantiating the trends property via the property declarations object (the second parameter of Object.create). This means that instead of trends being an inherited property, it now belongs to hotTrends and we haven't overwritten the trends property in trendingTopics when adding it to our new hotTrends object.

We then add a new method: hotTrends.xmlHandler. This combines all the incoming chunks into the hotTrendsfeed variable. Once the stream has ended, it invokes xml2js.parseString and passes the XML contained in hotTrendsfeed into it. In the callback of the first parseString method, we invoke xml2js.parseString again. Why? Because we have to parse two sets of XML, or rather one set of XML and one set of adequately formed HTML. (If we head to http://www.google.com/trends/hottrends/atom/hourly it will be rendered as HTML. If we view the source, we'll then see an XML document with embedded HTML content.)

Google's Hot Trends XML feed delivers the Hot Trends as HTML inside of its content XML node.

The HTML is wrapped within a CDATA section, so it isn't parsed by xml2js the first time round. Ergo, we create a new Parser and then parse the HTML via obj.entry.content['#'].

Finally, the hotTrends.xmlHandler method completes in the second embedded xml2js callback where it executes its own callback parameter (cb) with a query fragment generated from the top list item element in HTML.

Now all we have to do is make some adjustments to makeCall:

function makeCall(urlOpts, handler, cb) {
  http.get(urlOpts, function (response) { //make a call to the twitter api  
    handler(response, cb);
  }).on('error', function (e) {
    console.log("Connection Error: " + e.message);
  });
}

makeCall(hotTrends.trends.urlOpts, hotTrends.xmlHandler, function (query) {
  hotTrends.tweetPath(query);
  makeCall(hotTrends.tweets.urlOpts, hotTrends.jsonHandler, function (tweetsObj) {
    tweetsObj.results.forEach(function (tweet) {
      console.log("
" + tweet.from_user.yellow.bold + ': ' + tweet.text);
    });
  });
});

As we are now dealing with both JSON and XML, we slipped in another parameter to our makeCall function declaration: handler. The handler parameter allows us to specify whether to use the inherited jsonHander method or our supplemented xmlHandler method.

When we invoke the outer makeCall, we pass in hotTrends.xmlHandler, naming the parameter query. This is done because we are directly passing in the query fragment generated by xmlHandler instead of the array returned from Twitter. This is passed directly into the tweetPath method, which consequently updates the path property of the hotTrends.tweets.urlOpts object.

We pass hotTrends.tweets.urlOpts into the second makeCall, this time setting the handler parameter to hotTrends.jsonHandler.

The second makeCall callback behaves exactly the same as in the main recipe. It outputs the tweets to the console. This time, however, it outputs tweets based on Google Hot Trends.