update from master

Author: germanattanasio

.travis.yml

@@ -1,7 +1,10 @@
 language: node_js
+sudo: false # causes tests to be run in Travis CI's newer, faster build infrastructure
 node_js:
   - "0.10"
+  - "0.12"
+  - "stable"
 script:
   - npm test
 after_success:
-  - npm run coveralls
+  - npm run coveralls

README.md

@@ -252,7 +252,7 @@ language_translation.translate({
       console.log(JSON.stringify(translation, null, 2));
 });
 
-language_identification.identify({
+language_translation.identify({
   text: 'The language translation service takes text input and identifies the language used.' },
   function (err, language) {
     if (err)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "watson-developer-cloud",
-  "version": "0.9.30",
+  "version": "0.10.1",
   "description": "Nodejs Client Wrapper to use the IBM Watson and Services",
   "main": "./lib/index",
   "repository": {

services/alchemy_vision/v1.js

@@ -20,6 +20,7 @@ var extend         = require('extend');
 var requestFactory = require('../../lib/requestwrapper');
 var endpoints      = require('../../lib/alchemy_endpoints.json');
 var helper         = require('../../lib/helper');
+var isStream       = require('isstream');
 var pick           = require('object.pick');
 var omit           = require('object.omit');
 var fs             = require('fs');
@@ -39,7 +40,7 @@ function errorFormatter(cb) {
         }, null);
     }
   };
-};
+}
 
 function createRequest(method) {
   return function(_params, callback ) {
@@ -78,31 +79,81 @@ function AlchemyVision(options) {
 }
 
 /**
- * Extracts images from a URL.
+ * Extracts images from a URL or html
  */
-AlchemyVision.prototype.imageLinks = createRequest('image_link');
+AlchemyVision.prototype.imageLinks = function(_params, callback ) {
+  var params = _params || {};
+  var accepted_formats = Object.keys(endpoints['image_link']);
+  var format = helper.getFormat(params, accepted_formats);
+
+  if (format === null) {
+    callback(new Error('Missing required parameters: ' +
+      accepted_formats.join(', ') + ' needs to be specified'));
+    return;
+  }
+
+  var parameters = {
+    options: {
+      url: endpoints['image_link'][format],
+      method: 'POST',
+      json: true,
+      qs: extend({outputMode: 'json'}, params) // change default output to json
+    },
+    defaultOptions: this._options
+  };
+
+  return requestFactory(parameters, errorFormatter(callback));
+};
 
 /**
  * Tags image with keywords
  */
-AlchemyVision.prototype.imageTags = function(_params, callback) {
+AlchemyVision.prototype.imageKeywords = function(_params, callback) {
   var params = _params || {};
-
-  if (typeof(params.image) !== 'undefined' && typeof(params.image) !== 'string') {
-    callback(new Error('Invalid arguments: image needs to be a filename or base64 image'));
+  var accepted_formats = Object.keys(endpoints['image_keywords']);
+  var format = helper.getFormat(params, accepted_formats);
+  var image = null;
+  if (format === null) {
+    callback(new Error('Missing required parameters: ' +
+      accepted_formats.join(', ') + ' needs to be specified'));
     return;
   }
 
-  if (typeof(params.image) !== 'string')
-    params.imagePostMode = 'raw';
 
-  return createRequest('image_keywords').call(this, params, callback);
+  if (typeof(params.image) !== 'undefined') {
+    // check if image is stream or string
+    if (typeof(params.image) !== 'string' && !isStream(params.image)) {
+      callback(new Error('Invalid arguments: image needs to be a stream or base64'));
+      return;
+    }
+
+    if (isStream(params.image)) {
+      params.imagePostMode = 'raw';
+      image = params.image;
+      delete params.image;
+    } else {
+      params.imagePostMode = 'not-raw';
+    }
+  }
+
+  var parameters = {
+    options: {
+      url: endpoints['image_links'][format],
+      method: 'POST',
+      json: true,
+      body: image,
+      qs: extend({outputMode: 'json'}, params) // change default output to json
+    },
+    defaultOptions: this._options
+  };
+
+  return requestFactory(parameters, errorFormatter(callback));
 };
 
 /**
  * Face detection and Recognition
  */
-AlchemyVision.prototype.imageFaces = function(_params, callback) {
+AlchemyVision.prototype.recognizeFaces = function(_params, callback) {
   var params = _params || {};
 
   if (typeof(params.image) !== 'string')

services/tone_analyzer/v2.js

@@ -0,0 +1,129 @@
+/**
+ * Copyright 2015 IBM Corp. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+var extend         = require('extend');
+var requestFactory = require('../../lib/requestwrapper');
+
+function ToneAnalyzer(options) {
+  // Default URL
+  var defaultOptions = {
+    url: 'https://gateway.watsonplatform.net/tone-analyzer-experimental/api'
+  };
+
+  // Replace default options with user provided
+  this._options = extend(defaultOptions, options);
+}
+
+/**
+ * Main API call. Returns the different tone dimensions of a text.
+ *
+ * @param params: An object with a string 'text' element. This is the
+ * only field used. By this API call
+ *
+ * @return upon success, the callback function is called with an object
+ * containing the different tones (emotion, writing and social), traits
+ * and the evidence words found in the text.
+ *
+ * @see the API docs for a the full documentation.
+ *
+ */
+ToneAnalyzer.prototype.tone = function(params, callback) {
+  if (!params || !params.text){
+    callback(new Error('Missing required parameters: text'));
+    return;
+  }
+
+  var parameters = {
+    options: {
+      url: '/v2/tone',
+      method: 'POST',
+      body: params.text
+    },
+    defaultOptions: extend(this._options, {
+      headers: {
+        'accept':'application/json',
+        'content-type': 'text/plain'
+      }
+    })
+  };
+
+  return requestFactory(parameters, callback);
+};
+
+/**
+ * Returns related words for a given word (or set of words).
+ *
+ * @param params: An object to build the query string. It normally contains
+ * a property "word", the term to look up.
+ * Alternatively, one can specify a "context" (part of a phrase) and an
+ * "index" (of the word to lookup, within "context").
+ * A 'limit' parameter is also accepted to limit the number of related 
+ * words suggested.
+ *
+ * @return upon success, the callback function is called with an object
+ * containing related words to the ones given. Each word comes with
+ * the semantic type and the meaning and sense of the root word, and
+ * a weight associated to a trait. Positive weights would 'level up'
+ * that particular tone, while negative weights would level it down.
+ *
+ * For example, if one wants to sound less "angry" on a message, the
+ * suggestions with negative correlation with "Anger" (Emotion Tone)
+ * could be replaced in the txt.
+ *
+ * @see the API docs for a the full documentation.
+ *
+ */
+ToneAnalyzer.prototype.synonym = function(params, callback) {
+  var parameters = {
+    options: {
+      url: '/v2/synonyms',
+      method: 'GET',
+      qs: params,
+      json: true
+    },
+    defaultOptions: extend(this._options, {})
+  };
+
+  return requestFactory(parameters, callback);
+};
+
+
+
+/**
+ * Returns the different scorecards implemented by the service.
+ * This is an array of objects with a "name" and "description" properties.
+ * 
+ * As a first version, only a "business email" scorecard is implemented.
+ *
+ * @see the API docs for a the full documentation.
+ *
+ */
+ToneAnalyzer.prototype.scorecards = function(params, callback) {
+  var parameters = {
+    options: {
+      url: '/v2/scorecards',
+      method: 'GET',
+      json: true
+    },
+    defaultOptions: extend(this._options, {})
+  };
+
+  return requestFactory(parameters, callback);
+};
+
+module.exports = ToneAnalyzer;

test/test.tone_analyzer.v1.js

@@ -4,7 +4,7 @@ var assert = require('assert');
 var watson = require('../lib/index');
 var nock   = require('nock');
 
-describe('tone_analyzer', function() {
+describe('tone_analyzer.v1', function() {
 
   var noop = function() {};
 

test/test.tone_analyzer.v2.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var assert = require('assert');
+var watson = require('../lib/index');
+var nock   = require('nock');
+var qs = require('qs');
+
+describe('tone_analyzer.v2', function() {
+
+  var noop = function() {};
+
+  var tone_request = {
+    text: 'IBM Watson Developer Cloud'
+  };
+  var synonym_request = {
+	  'word': 'product'
+  };
+  var tone_response = {
+    tree: {}
+  };
+  var synonym_response = [ { headword: 'x' } ];
+
+  var tone_path = '/v2/tone',
+	synonym_path = '/v2/synonyms';
+
+  var service = {
+    username: 'batman',
+    password: 'bruce-wayne',
+    url: 'http://ibm.com:86',
+    version: 'v2'
+  };
+
+  before(function() {
+    nock.disableNetConnect();
+    nock(service.url)
+      .persist()
+      .post(tone_path, tone_request.text)
+      .reply(200, tone_response)
+      .get(synonym_path + '?' + qs.stringify(synonym_request))
+      .reply(200, synonym_response);
+  });
+
+  after(function() {
+    nock.cleanAll();
+  });
+
+  var tone_analyzer = watson.tone_analyzer(service);
+
+  var missingParameter = function(err) {
+    assert.ok((err instanceof Error) && /required parameters/.test(err));
+  };
+
+  // Tone API
+  it('tone API should check no parameters provided', function() {
+    tone_analyzer.tone({}, missingParameter);
+    tone_analyzer.tone(null, missingParameter);
+    tone_analyzer.tone(undefined, missingParameter);
+  });
+
+  it('tone API should generate a valid payload with text', function() {
+      var req = tone_analyzer.tone(tone_request, noop);
+      var body = new Buffer(req.body).toString('ascii');
+      assert.equal(req.uri.href, service.url + tone_path);
+      assert.equal(body, tone_request.text);
+      assert.equal(req.method, 'POST');
+      assert.equal(req.headers['content-type'], 'text/plain');
+  });
+
+  it('tone API should format the response', function(done) {
+    tone_analyzer.tone(tone_request, function(err, response) {
+      if (err)
+        done(err);
+      else {
+        assert.equal(JSON.stringify(response), JSON.stringify(tone_response));
+        done();
+      }
+    });
+  });
+
+  // Synonym API
+
+  it('synonym API should check no parameters provided', function() {
+    tone_analyzer.synonym({}, missingParameter);
+    tone_analyzer.synonym(null, missingParameter);
+    tone_analyzer.synonym(undefined, missingParameter);
+  });
+
+  it('synonym API should generate a valid payload with content', function() {      
+      var req = tone_analyzer.synonym(synonym_request, noop);
+      var myquery = qs.stringify(synonym_request);
+      assert.equal(req.uri.href, service.url + synonym_path + '?' + myquery);
+      assert.equal(req.uri.query, myquery);
+      assert.equal(req.method, 'GET');
+  });
+  it('synonym API should format the response', function(done) {
+    tone_analyzer.synonym(synonym_request, function(err, response) {
+      if (err)
+        done(err);
+      else {
+        assert.equal(JSON.stringify(response), JSON.stringify(synonym_response));
+        done();
+      }
+    });
+  });
+});