swagger-tools

#!/usr/bin/env node

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Apigee Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

'use strict';

var _ = require('lodash');
var async = require('async');
var fs = require('fs');
var helpers = require('../lib/helpers');
var knownCommands = ['convert', 'help', 'info', 'validate'];
var paddingAmount = 18;
var path = require('path');
var pkg = require('../package.json');
var program = require('commander');
var realArgs = process.argv.slice(2);
var request = require('superagent');
var S = require('string');
var YAML = require('yamljs');

var exitWithError = function exitWithError (msg) {
  console.error();
  console.error('  error: ' + msg);
  console.error(); // Here only to match the output of commander.js

  process.exit(1);
};
var getDocument = function getDocument (pathOrUrl, callback) {
  var parseContent = function parseContent (content) {
    var err;
    var response;

    switch (path.extname(pathOrUrl)) {
    case '.yaml':
    case '.yml':
      response = YAML.parse(content);

      break;

    default:
      try {
        response = JSON.parse(content);
      } catch (e) {
        err = e;
      }
    }

    callback(err, response);
  };

  if (!_.isString(pathOrUrl)) {
    callback();
  } else if (/^https?:\/\//.test(pathOrUrl)) {
    request.get(pathOrUrl)
      .set('user-agent', 'apigee-127/swagger-tools')
      .end(function (res) {
        parseContent(res.text);
      });
  } else {
    parseContent(fs.readFileSync(path.resolve(pathOrUrl), 'utf-8'));
  }
};
var getDocuments = function getDocuments (pathsAndOrUrls, callback) {
  var resolvedDocuments = {};

  async.map(pathsAndOrUrls, getDocument, function (err, documents) {
    _.each(documents, function (document, index) {
      if (!document) {
        return;
      }

      if (index === 0) {
        if (document.swagger) {
          resolvedDocuments.swaggerObject = document;
        } else if (document.swaggerVersion) {
          resolvedDocuments.resourceListing = document;
        } else {
          return exitWithError('Unable to identify the Swagger version for document: ' + program.args[index]);
        }
      } else if (_.isUndefined(resolvedDocuments.swaggerObject)) {
        if (!resolvedDocuments.apiDeclarations) {
          resolvedDocuments.apiDeclarations = [];
        }

        resolvedDocuments.apiDeclarations.push(document);
      }
    });

    callback(err, resolvedDocuments);
  }, function (err) {
    callback(err, resolvedDocuments);
  });
};

var handleUnknownCommand = function handleUnknownCommand (command) {
  console.error(program._name + ' does not support the ' + command + ' command.');

  program.outputHelp();
};

// Set name and version
program._name = 'swagger-tools';
program.version(pkg.version);

program
  .command('convert <resourceListing> [apiDeclarations...]')
  .description('Converts Swagger 1.2 documents to a Swagger 2.0 document')
  .option('-V, --no-validation', 'disable pre-conversion validation of the Swagger document(s)')
  .option('-y, --yaml', 'output as YAML instead of JSON')
  .action(function (resourceListing, apiDeclarations) {
    var doConvert = function doConvert (err, converted) {
      if (err) {
        if (err.failedValidation) {
          console.error(err.message + ' (Run with --no-validation to skip validation)');

          return helpers.printValidationResults('1.2', resourceListing, apiDeclarations,
                                                {
                                                  errors: err.errors,
                                                  warnings: err.warnings,
                                                  apiDeclarations: err.apiDeclarations
                                                }, true, true);
        } else {
          return exitWithError(err.message);
        }
      }

      console.log(this.yaml ? YAML.stringify(converted, 2) : JSON.stringify(converted, null, 2));
    }.bind(this);

    console.log();
    getDocuments([resourceListing].concat(apiDeclarations || []), function (err, documents) {
      helpers.getSpec('1.2').convert(documents.resourceListing, documents.apiDeclarations, !this.validation, doConvert);
    }.bind(this));
  });

program
  .command('help [command]')
  .description('Display help information')
  .action(function (command) {
    var theCommand;

    if (_.isUndefined(command)) {
      theCommand = this;
    } else {
      theCommand = _.find(this.parent.commands, function (cmd) {
        return cmd._name === command;
      });
    }

    if (_.isUndefined(theCommand)) {
      return handleUnknownCommand(command);
    }

    theCommand.help();
  });

program
  .command('info <version>')
  .description('Display information about the Swagger version requested')
  .action(function (version) {
    var spec = helpers.getSpec(version);

    console.log();
    console.log('Swagger ' + version + ' Information:');
    console.log();

    console.log('  ' + S('documentation url').padRight(paddingAmount).s + spec.docsUrl);
    console.log('  ' + S('schema(s) url').padRight(paddingAmount).s + spec.schemasUrl);
  });

// We have to use command+usage because commander.js does not handle the following properly:
//   .command('validate <resourceListingOrSwaggerDoc> [apiDeclarations ...]')

program
  .command('validate <resourceListingOrSwaggerDoc> [apiDeclarations...]')
  .description('Display validation results for the Swagger document(s)')
  .action(function (rlOrSO, apiDeclarations) {
    getDocuments([rlOrSO].concat(apiDeclarations || []), function (err, documents) {
      if (err) {
        throw err;
      }

      var apiDeclarations = documents.apiDeclarations;
      var resourceListing = documents.resourceListing;
      var soArgs = [];
      var swaggerObject = documents.swaggerObject;
      var spec;
      var version;

      if (swaggerObject && swaggerObject.swagger) {
        version = swaggerObject.swagger;
      } else {
        version = resourceListing.swaggerVersion;
      }

      spec = helpers.getSpec(version);

      if (_.isUndefined(spec)) {
	console.error('Unsupported Swagger version: %s', version);

	process.exit(1);
      }

      if (_.isUndefined(resourceListing)) {
        soArgs = [swaggerObject];
      } else {
        soArgs = [resourceListing, apiDeclarations];
      }

      soArgs.push(function (err, results) {
        if (helpers.formatResults(results)) {
          err = new Error('Swagger document(s) failed validation');

          err.results = results;
        }

        if (err) {
          if (process.env.NODE_ENV === 'test') {
            throw err;
          } else {
            return helpers.printValidationResults(version, resourceListing || swaggerObject, apiDeclarations, results,
                                                  true, true);
          }
        }
      });

      spec.validate.apply(spec, soArgs);
    });
  });

if (!realArgs.length) {
  program.outputHelp();
} else if (knownCommands.indexOf(realArgs[0]) === -1) {
  handleUnknownCommand(realArgs[0]);
} else {
  program.parse(process.argv);
}