Merge pull request #408 from stephenplusplus/spp--storage-combine

storage: support file.compose - fixes #401

lib/common/util.js

@@ -208,6 +208,52 @@ function getType(value) {
  return Object.prototype.toString.call(value).match(/\s(\w+)\]/)[1];
 }
 
+/**
+ * Used in an Array iterator usually, this will return the value of a property
+ * in an object by its name.
+ *
+ * @param {string} name - Name of the property to return.
+ * @return {function}
+ *
+ * @example
+ * var people = [
+ * {
+ * name: 'Stephen',
+ * origin: 'USA',
+ * beenToNYC: false
+ * },
+ * {
+ * name: 'Ryan',
+ * origin: 'Canada',
+ * beenToNYC: true
+ * }
+ * ];
+ *
+ * var names = people.map(prop('name'));
+ * // [
+ * // 'Stephen',
+ * // 'Ryan'
+ * // ]
+ *
+ * var peopleInUSA = people.filter(prop('beenToNYC'));
+ * // [
+ * // {
+ * // name: 'Ryan',
+ * // origin: 'Canada',
+ * // beenToNYC: true
+ * // }
+ * // ]
+ */
+function prop(name) {
+ return function(item) {
+ if (name in item) {
+ return item[name];
+ }
+ };
+}
+
+module.exports.prop = prop;
+
 /**
  * Assign a value to a property in an Array iterator.
  *

lib/storage/bucket.js

@@ -202,6 +202,100 @@ function Bucket(storage, name) {
  /* jshint ignore:end */
 }
 
+/**
+ * Combine mutliple files into one new file.
+ *
+ * @throws if a non-array is provided as sources argument.
+ * @throws if less than two sources are provided.
+ * @throws if no destination is provided.
+ * @throws if a content type cannot be determined for the destination file.
+ *
+ * @param {string[]|module:storage/file[]} sources - The source files that will
+ * be combined.
+ * @param {string|module:storage/file} destination - The file you would like the
+ * source files combined into.
+ * @param {function=} callback - The callback function.
+ *
+ * @example
+ * var 2013logs = bucket.file('2013-logs.txt');
+ * var 2014logs = bucket.file('2014-logs.txt');
+ *
+ * var allLogs = bucket.file('all-logs.txt');
+ *
+ * bucket.combine([
+ * 2013logs,
+ * 2014logs
+ * ], allLogs, function(err, newFile) {
+ * // newFile === allLogs
+ * });
+ */
+Bucket.prototype.combine = function(sources, destination, callback) {
+ if (!util.is(sources, 'array') || sources.length < 2) {
+ throw new Error('You must provide at least two source files.');
+ }
+
+ if (!destination) {
+ throw new Error('A destination file must be specified.');
+ }
+
+ var self = this;
+
+ sources = sources.map(convertToFile);
+ destination = convertToFile(destination);
+ callback = callback || util.noop;
+
+ if (!destination.metadata.contentType) {
+ var destinationContentType = mime.contentType(destination.name);
+
+ if (destinationContentType) {
+ destination.metadata.contentType = destinationContentType;
+ } else {
+ throw new Error(
+ 'A content type could not be detected for the destination file.');
+ }
+ }
+
+ this.storage.makeAuthorizedRequest_({
+ method: 'POST',
+ uri: util.format('{base}/{destBucket}/o/{destFile}/compose', {
+ base: STORAGE_BASE_URL,
+ destBucket: destination.bucket.name,
+ destFile: encodeURIComponent(destination.name)
+ }),
+ json: {
+ destination: {
+ contentType: destination.metadata.contentType
+ },
+ sourceObjects: sources.map(function (source) {
+ var sourceObject = {
+ name: source.name
+ };
+
+ if (source.metadata && source.metadata.generation) {
+ sourceObject.generation = source.metadata.generation;
+ }
+
+ return sourceObject;
+ })
+ }
+ }, function(err) {
+ if (err) {
+ callback(err);
+ return;
+ }
+
+ callback(null, destination);
+ });
+
+ function convertToFile(file) {
+ if (file instanceof File) {
+ return file;
+ } else {
+ return self.file(file);
+ }
+ }
+};
+
 /**
  * Delete the bucket.
  *

regression/storage.js

@@ -25,8 +25,11 @@ var fs = require('fs');
 var request = require('request');
 var through = require('through2');
 var tmp = require('tmp');
+var util = require('../lib/common/util');
 var uuid = require('node-uuid');
 
+var prop = util.prop;
+
 var env = require('./env.js');
 var storage = require('../lib/storage')(env);
 
@@ -47,12 +50,14 @@ function deleteFiles(bucket, callback) {
  callback(err);
  return;
  }
- async.map(files, function(file, next) {
- file.delete(next);
- }, callback);
+ async.map(files, deleteFile, callback);
  });
 }
 
+function deleteFile(file, callback) {
+ file.delete(callback);
+}
+
 function generateBucketName() {
  return 'gcloud-test-bucket-temp-' + uuid.v1();
 }
@@ -493,6 +498,41 @@ describe('storage', function() {
  });
  });
 
+ describe('combine files', function() {
+ it('should combine multiple files into one', function(done) {
+ var files = [
+ { file: bucket.file('file-one.txt'), contents: '123' },
+ { file: bucket.file('file-two.txt'), contents: '456' }
+ ];
+
+ async.each(files, createFile, function(err) {
+ assert.ifError(err);
+
+ var sourceFiles = files.map(prop('file'));
+ var destinationFile = bucket.file('file-one-and-two.txt');
+
+ bucket.combine(sourceFiles, destinationFile, function(err) {
+ assert.ifError(err);
+
+ destinationFile.download(function(err, contents) {
+ assert.ifError(err);
+
+ assert.equal(contents, files.map(prop('contents')).join(''));
+
+ async.each(sourceFiles.concat([destinationFile]), deleteFile, done);
+ });
+ });
+ });
+
+ function createFile(fileObject, cb) {
+ var ws = fileObject.file.createWriteStream();
+ ws.on('error', cb);
+ ws.on('complete', cb.bind(null, null));
+ ws.end(fileObject.contents);
+ }
+ });
+ });
+
  describe('list files', function() {
  var filenames = ['CloudLogo1', 'CloudLogo2', 'CloudLogo3'];
 

test/common/util.js

@@ -449,6 +449,18 @@ describe('common/util', function() {
  });
  });
 
+ describe('prop', function() {
+ it('should return objects that match the property name', function() {
+ var people = [
+ { name: 'Stephen', origin: 'USA', beenToNYC: false },
+ { name: 'Ryan', origin: 'Canada', beenToNYC: true }
+ ];
+
+ assert.deepEqual(people.map(util.prop('name')), ['Stephen', 'Ryan']);
+ assert.deepEqual(people.filter(util.prop('beenToNYC')), [people[1]]);
+ });
+ });
+
  describe('propAssign', function() {
  it('should assign a property and value to an object', function() {
  var obj = {};