🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →
Sign In

raml2code

Package Overview
Dependencies
Maintainers
1
Versions
44
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

raml2code - npm Package Compare versions

Comparing version
0.8.41
 to
1.8.0
+8
-1
History.md

@@ -0,2 +1,9 @@

1.8.0 / 2015-06-06
==================
* Making a refactor, separating generators to it's own module, updating reamde
0.8.41 / 2015-06-05
==================
* Adding default values to retrofit arguments
0.8.40 / 2015-02-09

@@ -13,3 +20,3 @@ ==================

==================
Changing Versioning, adding support to generate a js client
Changing version schema, adding support to generate a js client

@@ -16,0 +23,0 @@ - Moving retrofit client to src/generators/java this could break some already setup projects

+4
-9
package.json
{
"name": "raml2code",
"version": "0.8.41",
"version": "1.8.0",
"description": "Raml spec to code",

@@ -22,5 +22,3 @@ "main": "index.js",

},
"homepage":
"https://github.com/gextech/raml2code",
"homepage": "https://github.com/gextech/raml2code",
"dependencies": {

@@ -30,7 +28,3 @@ "data2code": "0.0.4",

"raml-parser": "0.8.7",
"through2": "0.6.3",
"lodash": "2.4.1",
"deref": "0.2.6",
"json-schema-2-groovy-pojo": "0.0.3",
"raml-client-generator" : "0.0.6"
"through2": "0.6.3"
},

@@ -45,4 +39,5 @@ "devDependencies": {

"mocha": "^2.0.1",
"raml2code-fixtures": "0.0.8",
"run-sequence": "^1.0.2"
}
}
+36
-35
README.md

@@ -22,9 +22,21 @@ # Raml to code generator

## It's a Gulp-plugin
## It's a Gulp-plugin so to try
1. Install gulp
```bash
npm install -G gulp
```
2. install the generators you needed
```bash
npm install --save-dev raml2code-groovy-pojo
```
3. configure the gulpfile.js
```js
var gulp = require('gulp');
var raml2code = require('raml2code');
var genDTO = require("raml2code/lib/generators/groovy/raml2DTO.js");
//Install a generators:
var genDTO = require("raml2code-groovy-pojo");
gulp.task("test", function(){
gulp.task("dtos", function(){
gulp.src('./test/cats.raml')

@@ -34,6 +46,10 @@ .pipe(raml2code({generator: genDTO, extra: {package:'com.gex'}}))

});
```
4. Run the generator
```bash
gulp dtos
```
## Sample gulpfile
## Sample gulpfile.js

@@ -44,5 +60,5 @@ ```js

var raml2code = require("raml2code");
var genPojos = require("raml2code/lib/generators/groovy/pojo");
var genJaxRS = require("raml2code/lib/generators/groovy/jaxrsInterface");
var genRetrofitClient = require("raml2code/lib/generators/groovy/retrofitClient");
var genPojos = require("raml2code-groovy-pojo");
var genJaxRS = require("raml2code-jaxrs-interfaces");
var genRetrofitClient = require("raml2code-retrofit");

@@ -89,3 +105,7 @@ var raml = require('gulp-raml');

## We use the Gradle with the gulp plugin to build or loved Java project
## A full example of using using raml2code could be found here:
[raml2code-Example](https://github.com/atomsfat/raml2code-example)
## We use the Gradle with the gulp plugin to build and integrate with Java.
[gradle](https://www.gradle.org/)

@@ -95,7 +115,5 @@

## And example of project could be found here:
[raml2code-Example](https://github.com/atomsfat/raml2code-example)
## You don't like our generators, DIY
## You can make your own generators, DIY

@@ -111,30 +129,13 @@ A generator is a simple object with the following properties:

* helpers -> Handlebars helpers.
* partials -> Handlebars partials.
* partials -> Handlebars partials.
## Generators included and tested
* Groovy POJO
This generator use json-schema spec heavily, when using $ref certain rules apply:
* If the json schema has $ref and the schema referred has title we will use it to make a reference. For
example the property owner on:
[cat.schema.json](src/test/raml/cat.schema.json)
it will result on the property Owner in [CatDTO.groovy](src/test/examples/CatDTO.groovy)
* if the json schema has a property of type object like food on :
[cat.schema.json](src/test/raml/cat.schema.json)
it will result on a inner class called Food in [CatDTO.groovy](src/test/examples/CatDTO.groovy)
## Generators create and in use by GEX.
* [raml2code-groovy-pojo](https://www.npmjs.com/package/raml2code-pojo)
* [raml2code-jaxrs-interfaces](https://www.npmjs.com/package/raml2code-jaxrs-interfaces)
* [raml2code-js-client-mulesoft](https://www.npmjs.com/package/raml2code-js-client-mulesoft)
* [raml2code-retrofit](https://www.npmjs.com/package/raml2code-retrofit)
More info on $ref definitions, http://json-schema.org/latest/json-schema-core.html#anchor30
* JAX-RS Interface
We use the optional resource.displayName to name resource classes, if you use this generator don't forget to provide it.
Example:
```groovy
/cats:
displayName: Gatitos
```
Will generate GatitosResource
If you create a generator let us know to add to this list.
* RETROFIT Client java interface
* raml-client-generator javascript client generator from mulesoft
[raml-client-generator](https://github.com/mulesoft/raml-client-generator)

@@ -141,0 +142,0 @@ 

-75
lib/generators/groovy/jaxrsInterface.js
var commonHelpers, customAdapter, generator, parseResource, utilSchemas, _;
_ = require('lodash');
utilSchemas = require('../util/schemas');
parseResource = require('../util/parseResource');
commonHelpers = require("../helpers/common").helpers();
generator = {};
generator.helpers = commonHelpers;
generator.template = require("./tmpl/jaxrsResources.hbs");
customAdapter = function(method, methodParsed) {
if (methodParsed.formData) {
return methodParsed.consumes = "MediaType.MULTIPART_FORM_DATA";
}
};
generator.parser = function(data) {
var first, k, methodParse, model, options, parsed, resource, resourceGroup, result, schemas, v, version, _i, _len, _ref;
parsed = [];
schemas = utilSchemas.loadSchemas(data);
options = {
annotations: {
path: "@PathParam",
query: "@QueryParam",
body: "",
multiPart: "@FormDataParam",
form: "@FormDataParam"
},
mapping: {
'string': "String",
'boolean': "Boolean",
'number': "BigDecimal",
'integer': "Long",
'array': "List",
'object': "Map",
'file': "InputStream"
}
};
methodParse = [];
_ref = data.resources;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
resource = _ref[_i];
methodParse.push(parseResource(resource, options, schemas, customAdapter));
}
methodParse = _.flatten(methodParse);
resourceGroup = _.groupBy(methodParse, function(method) {
return method.displayName;
});
if (data.extra) {
data.extra["package"] = "" + data.extra["package"] + "." + data.version;
data.extra.importPojos = "" + data.extra.importPojos + "." + data.version;
}
for (k in resourceGroup) {
v = resourceGroup[k];
model = {};
model.extra = data.extra;
first = _.first(v);
model.uri = first.uri;
model.className = "" + first.displayName + "Resource";
model.methods = v;
result = {};
version = data.version ? "" + data.version + "/" : "";
result["" + version + model.className + ".groovy"] = model;
parsed.push(result);
}
return parsed;
};
module.exports = generator;
-14
lib/generators/groovy/pojo.js
var originalParser, schema2groovy, utilSchemas;
schema2groovy = require('json-schema-2-groovy-pojo/lib/generators/pojo');
utilSchemas = require('../util/schemas');
originalParser = schema2groovy.parser;
schema2groovy.parser = function(datos) {
datos.schemas = utilSchemas.loadSchemas(datos);
return originalParser(datos);
};
module.exports = schema2groovy;
-12
lib/generators/groovy/tmpl/classMembersPartial.hbs
{{#classMembers}}
{{#if comment}}/* {{comment}} */{{/if}}{{#if ../extra.enableAnnotations}}{{#if required}}
@NotNull{{/if}}{{#if min}}
@Min({{min}}l){{/if}}{{#if max}}
@Max({{max}}l){{/if}}{{#if decimalMin}}
@DecimalMin("{{decimalMin}}"){{/if}}{{#if decimalMax}}
@DecimalMax("{{decimalMax}}"){{/if}}{{#if size}}
@Size({{#each size}}{{#if @index}}, {{/if}}{{this.name}}={{value}}{{/each}}){{/if}}{{/if}}
{{{type}}} {{name}}
{{/classMembers}}
-27
lib/generators/groovy/tmpl/jaxrsResources.hbs
package {{extra.package}}
import javax.ws.rs.*
import javax.ws.rs.core.*
import java.util.List
import java.util.Map{{debug extra}}
{{#if extra.importPojos}}import {{extra.importPojos}}.*{{/if}}
import org.glassfish.jersey.media.multipart.*
import static javax.ws.rs.core.MediaType.APPLICATION_JSON
@Path("{{{uri}}}")
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
interface {{className}} {
{{#methods}}
/***
* @return Response This must be a valid {{{respondComment}}} JSON object.
*/
@{{annotation}}{{#if consumes}}
@Consumes({{consumes}}){{/if}}
Response {{{name}}}({{#each args}}{{#if @index}},{{/if}}
{{{kind}}}{{{type}}} {{name}}{{/each}});
{{/methods}}
}
-18
lib/generators/groovy/tmpl/pojo.hbs
package {{extra.package}}
import groovy.transform.*{{#if extra.enableAnnotations}}
import javax.validation.constraints.*{{/if}}
{{#if classDescription}}
/**
*{{{classDescription}}}
**/{{/if}}
@CompileStatic
@Canonical
public class {{{className}}} implements Serializable {
{{>classMembers}}
}
{{#innerClasses}}
class {{{className}}} implements Serializable {
{{>classMembers}}
}
{{/innerClasses}}
-14
lib/generators/helpers/common.js
module.exports.helpers = function() {
return {
'debug': function(optionalValue) {
console.log("Current Context");
console.log("====================");
console.log(this);
if (optionalValue) {
console.log("Value");
console.log("====================");
console.log(optionalValue);
}
}
};
};
-138
lib/generators/java/retrofitClient.js
var arrayFromMask, commonHelpers, customAdapter, generator, parseResource, resolveArrayByMask, utilSchemas, utilText, _;
commonHelpers = require("../helpers/common").helpers();
utilSchemas = require('../util/schemas');
utilText = require('../util/text');
parseResource = require('../util/parseResource');
_ = require('lodash');
generator = {};
generator.helpers = commonHelpers;
generator.template = require("./tmpl/retrofitClient.hbs");
customAdapter = function(method, methodParsed) {
var mediaType;
if (methodParsed.formData) {
methodParsed.additionalAnnotation = "Multipart";
}
if (methodParsed.formEncoded) {
methodParsed.additionalAnnotation = "FormUrlEncoded";
}
mediaType = "application/json";
if (method.body && Object.keys(method.body)[0]) {
mediaType = Object.keys(method.body)[0];
}
if (methodParsed.annotation === "DELETE") {
return methodParsed.additionalAnnotation = "Headers({\"Content-type: " + mediaType + "\"})";
}
};
generator.parser = function(data) {
var arg, d, method, methodParse, methodParsePermuted, model, name, newArgs, notReqArgs, options, parsed, permutations, permuted, reqArgs, resource, result, schemas, shallowMethod, version, _i, _j, _k, _len, _len1, _len2, _ref;
parsed = [];
schemas = utilSchemas.loadSchemas(data);
options = {
annotations: {
path: "@Path",
query: "@Query",
body: "@Body",
multiPart: "@Part",
form: "@Field"
},
mapping: {
'string': "String",
'boolean': "Boolean",
'number': "BigDecimal",
'integer': "Long",
'array': "List",
'object': "Map",
'file': "TypedFile"
}
};
methodParse = [];
_ref = data.resources;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
resource = _ref[_i];
methodParse.push(parseResource(resource, options, schemas, customAdapter));
}
methodParse = _.flatten(methodParse);
methodParsePermuted = [];
for (_j = 0, _len1 = methodParse.length; _j < _len1; _j++) {
method = methodParse[_j];
notReqArgs = _.filter(method.args, function(it) {
return it.required === false;
});
if (notReqArgs && notReqArgs.length > 0) {
reqArgs = _.difference(method.args, notReqArgs);
permutations = (Math.pow(2, notReqArgs.length)) - 1;
while (permutations >= 0) {
shallowMethod = _.cloneDeep(method);
d = arrayFromMask(permutations);
permuted = resolveArrayByMask(d, notReqArgs);
name = shallowMethod.name;
for (_k = 0, _len2 = permuted.length; _k < _len2; _k++) {
arg = permuted[_k];
name = name + ("And" + (utilText.capitalize(arg.name)));
}
newArgs = reqArgs.concat(permuted);
shallowMethod.args = newArgs;
shallowMethod.name = name;
methodParsePermuted.push(shallowMethod);
permutations--;
}
} else {
methodParsePermuted.push(method);
}
}
model = {};
model.methods = methodParsePermuted;
model.version = data.version;
if (data.extra) {
data.extra["package"] = "" + data.extra["package"] + "." + data.version;
data.extra.importPojos = "" + data.extra.importPojos + "." + data.version;
model.extra = data.extra;
}
result = {};
version = data.version ? "" + data.version + "/" : "";
model.className = data.title.split(" ").join("");
result["" + version + model.className + ".java"] = model;
parsed.push(result);
return parsed;
};
arrayFromMask = function(nMask) {
var aFromMask, nShifted;
if (nMask > 0x7fffffff || nMask < -0x80000000) {
throw new TypeError("arrayFromMask - out of range");
}
nShifted = nMask;
aFromMask = [];
while (nShifted) {
aFromMask.push(Boolean(nShifted & 1));
nShifted >>>= 1;
}
return aFromMask;
};
resolveArrayByMask = function(mask, array) {
var i, j, res;
res = [];
i = array.length - 1;
j = 0;
while (i >= 0) {
if (mask[j]) {
res.push(array[i]);
}
i--;
j++;
}
return res;
};
module.exports = generator;
-25
lib/generators/java/tmpl/retrofitClient.hbs
package {{extra.package}};
import retrofit.http.*;
import retrofit.client.Response;
import java.util.List;
import java.util.Map;
import rx.Observable;
import retrofit.mime.TypedFile;
{{#if extra.importPojos}}
import {{extra.importPojos}}.*;
{{/if}}
public interface {{{className}}} {
{{#methods}}
@{{annotation}}("/{{{../version}}}{{{uri}}}")
{{#if additionalAnnotation}}
@{{{additionalAnnotation}}}
{{/if}}
Observable<{{{respond}}}> {{{name}}}({{#each args}}{{#if @index}},{{/if}}
{{{kind}}} {{{type}}} {{name}}{{/each}});
{{/methods}}
}
-49
lib/generators/javascript/jsClient.js
var camelCase, context, defaultHelpers, extend, generator, helpers, languages;
extend = require('raml-client-generator/node_modules/extend');
languages = require('raml-client-generator/languages');
context = require('raml-client-generator/lib/compile/context');
defaultHelpers = require('raml-client-generator/lib/compile/helpers');
generator = {};
generator.partials = {
auth: require('raml-client-generator/languages/javascript/partials/auth.js.hbs'),
utils: require('raml-client-generator/languages/javascript/partials/utils.js.hbs'),
client: require('raml-client-generator/languages/javascript/partials/client.js.hbs'),
resources: require('raml-client-generator/languages/javascript/partials/resources.js.hbs')
};
helpers = {
stringify: require('raml-client-generator/node_modules/javascript-stringify'),
dependencies: require('raml-client-generator/languages/javascript/helpers/dependencies'),
requestSnippet: require('raml-client-generator/languages/javascript/helpers/request-snippet'),
parametersSnippet: require('raml-client-generator/languages/javascript/helpers/parameters-snippet')
};
generator.helpers = extend({}, defaultHelpers, helpers);
generator.template = require('raml-client-generator/languages/javascript//templates/index.js.hbs');
camelCase = require('raml-client-generator/node_modules/camel-case');
generator.parser = function(data) {
var model, parsed, result, spec, version;
parsed = [];
spec = {
format: {
variable: camelCase
}
};
model = context(data, spec);
result = {};
version = data.version ? "" + data.version + "/" : "";
result["" + version + (camelCase(model.title)) + "Client.js"] = model;
parsed.push(result);
return parsed;
};
module.exports = generator;
-165
lib/generators/util/mapProperty.js
var Deref, resolveInnerClass, resolveType, resolveTypeByRef, util, utilText, _;
Deref = require('deref');
_ = require('lodash');
utilText = require('../util/text');
util = {};
util.mapProperties = function(expandedSchema, refMap, mapping) {
var data, key, keyRef, propParsed, property;
data = {};
data.classMembers = [];
data.innerClasses = [];
if (expandedSchema.properties && expandedSchema.properties.$ref) {
keyRef = expandedSchema.properties.$ref;
expandedSchema.properties = Deref.util.findByRef(keyRef, refMap);
}
for (key in expandedSchema.properties) {
property = expandedSchema.properties[key];
if (typeof property !== 'string') {
if (expandedSchema.required && _.contains(expandedSchema.required, key)) {
property.required = true;
}
propParsed = util.mapProperty(property, key, '', mapping, refMap);
data.classMembers.push(propParsed.property);
if (propParsed.innerClass) {
data.innerClasses.push(propParsed.innerClass);
}
}
}
return data;
};
util.mapProperty = function(property, name, annotation, mapping, refMap) {
var auxType, data, innerClass, keyRef, keyRefData, primitiveType, _ref;
data = {};
data.property = {};
data.property.name = name;
data.property.required = property.required !== void 0 ? property.required : false;
data.property.size = [];
if (property.minLength) {
data.property.size.push({
"name": "min",
"value": property.minLength
});
}
if (property.maxLength) {
data.property.size.push({
"name": "max",
"value": property.maxLength
});
}
data.property.comment = property.description;
if (property.items && property.items["$ref"]) {
keyRef = property.items["$ref"];
keyRefData = resolveTypeByRef(keyRef, refMap, name, true);
} else if (property["$ref"]) {
keyRef = property["$ref"];
keyRefData = resolveTypeByRef(keyRef, refMap, name);
data.property.type = keyRefData.type;
if (keyRefData.innnerSchema.type) {
property.type = keyRefData.innnerSchema.type;
} else {
property.properties = keyRefData.innnerSchema;
data.innerClass = resolveInnerClass(keyRefData.type, property, refMap, mapping);
property.type = resolveType(data.innerClass, name);
}
}
data.property.comment = property.description;
switch (property.type) {
case 'array':
auxType = "List";
if (keyRefData && keyRefData.innnerSchema.items !== void 0) {
primitiveType = mapping[keyRefData.innnerSchema.items.type];
if (keyRefData.innnerSchema.items.title) {
auxType += "<" + keyRefData.type + ">";
} else if (primitiveType) {
auxType += "<" + primitiveType + ">";
}
}
data.property.type = auxType;
break;
case 'object':
if (property.properties) {
if (keyRefData && keyRefData.type) {
data.property.type = keyRefData.type;
} else {
data.property.type = resolveType(property, name);
innerClass = resolveInnerClass(data.property.type, property, refMap, mapping);
data.innerClass = innerClass;
}
} else if (keyRefData && keyRefData.innnerSchema && keyRefData.innnerSchema.properties) {
data.property.type = keyRefData.type;
property.properties = keyRefData.innnerSchema;
data.innerClass = resolveInnerClass(keyRefData.type, property, refMap, mapping);
} else {
data.property.type = 'Map';
}
break;
default:
data.property.type = (_ref = mapping[property.type]) != null ? _ref : property.type;
}
if (data.property.type === "BigDecimal") {
data.property.decimalMax = property.maximum;
data.property.decimalMin = property.minimum;
} else if (data.property.type === "Long") {
data.property.max = property.maximum;
data.property.min = property.minimum;
}
data.property.kind = annotation + ("(\"" + data.property.name + "\")");
return data;
};
resolveTypeByRef = function(keyRef, refMap, propertyName, isArray) {
var data, innerSchema;
if (isArray == null) {
isArray = false;
}
data = {};
data.type = "";
innerSchema = Deref.util.findByRef(keyRef, refMap);
if (innerSchema) {
if (isArray) {
data.innnerSchema = {};
data.innnerSchema.items = innerSchema;
} else {
data.innnerSchema = innerSchema;
}
data.type = resolveType(innerSchema, propertyName);
} else if (keyRef) {
console.error("$ref not found: " + keyRef + " RefMap.keys -> [" + (Object.keys(refMap)) + "]");
console.error(JSON.stringify(refMap));
}
return data;
};
resolveType = function(schema, propertyName) {
var type;
type = "";
if (schema) {
if (schema.title) {
type = utilText.capitalize(schema.title);
} else {
type = utilText.capitalize(propertyName);
}
}
return type;
};
resolveInnerClass = function(name, property, refMap, mapping) {
var aux, data;
data = null;
if (property && !property.properties.title) {
data = {};
data.className = name;
data.classDescription = property.description;
aux = util.mapProperties(property, refMap, mapping);
data.classMembers = aux.classMembers;
}
return data;
};
module.exports = util;
-53
lib/generators/util/mapRequestResponse.js
var Deref, util, utilText, _;
utilText = require('../util/text');
_ = require('lodash');
Deref = require('deref');
util = {};
util.mapRequestResponse = function(scheme, schemas, mapping) {
var dataRef, deref, normSchema, primitiveType, type;
type = "";
switch (scheme.type) {
case "array":
if (scheme.items) {
type = "List<Maps>";
if (scheme.items.$ref) {
deref = Deref();
normSchema = deref(scheme, schemas);
dataRef = deref.util.findByRef(normSchema.items.$ref, deref.refs);
if (dataRef && dataRef.title) {
type = "List<" + (utilText.capitalize(dataRef.title)) + ">";
} else {
type = "List";
}
} else if (scheme.items.title) {
type = "List<" + (util.capitalize(scheme.title)) + ">";
} else if (scheme.items.type) {
primitiveType = mapping[scheme.items.type];
if (primitiveType) {
type = "List<" + primitiveType + ">";
}
}
} else {
type = "List";
}
break;
case "object":
if (scheme.properties) {
type = utilText.capitalize(scheme.title);
} else {
type = "Map";
}
break;
default:
console.warn("-------WARNING the following scheme doesn't have type: -------");
console.warn("" + (JSON.stringify(scheme)) + " ");
}
return type;
};
module.exports = util.mapRequestResponse;
-131
lib/generators/util/parseResource.js
var getBestValidResponse, getQueryParams, getUriParameter, mapRequestResponse, parseForm, util, utilMapProperty, utilSchemas, utilText, _;
utilMapProperty = require('../util/mapProperty');
utilSchemas = require('../util/schemas');
mapRequestResponse = require('../util/mapRequestResponse');
utilText = require('../util/text');
_ = require('lodash');
util = {};
util.parseResource = function(resource, options, schemas, customAdapter, parentUri, parentUriArgs) {
var innerResource, m, methodDef, parsed, request, respond, responseType, type, uriArgs, _i, _j, _len, _len1, _ref, _ref1, _ref2, _ref3;
if (customAdapter == null) {
customAdapter = null;
}
if (parentUri == null) {
parentUri = "";
}
if (parentUriArgs == null) {
parentUriArgs = [];
}
parsed = [];
_ref = resource.methods;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
m = _ref[_i];
methodDef = {};
methodDef.uri = parentUri + resource.relativeUri;
methodDef.annotation = m.method.toUpperCase();
methodDef.name = m.method + resource.displayName;
methodDef.displayName = resource.displayName;
uriArgs = getUriParameter(resource, options.annotations.path, options.mapping);
methodDef.args = parentUriArgs.concat(uriArgs);
methodDef.args = methodDef.args.concat(getQueryParams(m.queryParameters, options.annotations.query, options.mapping));
methodDef.args = methodDef.args.concat(parseForm(m.body, options.annotations, options.mapping));
request = utilSchemas.parseBodyJson(m.body, "" + methodDef.uri + " body");
respond = utilSchemas.parseBodyJson(getBestValidResponse(m.responses).body, "" + methodDef.uri + " response");
if (request.title) {
methodDef.args = (_ref1 = methodDef.args) != null ? _ref1 : [];
type = mapRequestResponse(request, schemas, options.mapping);
methodDef.args.push({
'kind': options.annotations.body,
'type': type,
'name': request.title.toLowerCase()
});
}
methodDef.request = (_ref2 = request.title) != null ? _ref2 : null;
responseType = mapRequestResponse(respond, schemas, options.mapping);
methodDef.respondComment = respond.title;
if (responseType) {
methodDef.respond = responseType;
} else {
methodDef.respond = "Response";
}
methodDef.formData = _.find(methodDef.args, function(arg) {
return arg.type === "InputStream" || arg.type === "TypedFile";
});
methodDef.formEncoded = _.find(methodDef.args, function(arg) {
return arg.kind.indexOf("@Field") > -1 || arg.kind.indexOf("@FormDataParam") > -1;
});
if (customAdapter && typeof customAdapter === 'function') {
customAdapter(m, methodDef);
}
parsed.push(methodDef);
}
if (resource.resources) {
_ref3 = resource.resources;
for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
innerResource = _ref3[_j];
parsed = parsed.concat(util.parseResource(innerResource, options, schemas, customAdapter, methodDef.uri, uriArgs));
}
}
return parsed;
};
getUriParameter = function(resource, annotation, mapping) {
var key, p, uriParameters;
uriParameters = [];
for (key in resource.uriParameters) {
p = resource.uriParameters[key];
uriParameters.push(utilMapProperty.mapProperty(p, key, annotation, mapping).property);
}
return uriParameters;
};
getQueryParams = function(queryParams, annotation, mapping) {
var key, p, params;
params = [];
for (key in queryParams) {
p = queryParams[key];
params.push(utilMapProperty.mapProperty(p, key, annotation, mapping).property);
}
return params;
};
parseForm = function(body, annotations, mapping) {
var annotation, args, data, form, key, p, parsedProperty;
args = [];
form = body ? body["multipart/form-data"] || body["application/x-www-form-urlencoded"] : void 0;
if (form) {
if (body["multipart/form-data"] !== void 0) {
annotation = annotations.multiPart;
} else {
annotation = annotations.form;
}
data = form.formParameters || form.formParameters;
for (key in data) {
p = data[key];
parsedProperty = utilMapProperty.mapProperty(p, key, annotation, mapping).property;
args.push(parsedProperty);
if (parsedProperty.type === "InputStream") {
args.push({
name: parsedProperty.name + "Data",
type: "FormDataContentDisposition",
kind: annotation + ("(\"" + parsedProperty.name + "\")")
});
}
}
}
return args;
};
getBestValidResponse = function(responses) {
var response, _ref, _ref1, _ref2, _ref3;
return response = (_ref = responses["304"]) != null ? _ref : response = (_ref1 = responses["204"]) != null ? _ref1 : response = (_ref2 = responses["201"]) != null ? _ref2 : response = (_ref3 = responses["200"]) != null ? _ref3 : response;
};
module.exports = util.parseResource;
-49
lib/generators/util/schemas.js
var util;
util = {};
util.parseBodyJson = function(body, meta) {
var schema;
if (meta == null) {
meta = '';
}
schema = {};
if (body && body['application/json']) {
schema = util.parseSchema(body['application/json'].schema, meta);
}
return schema;
};
util.parseSchema = function(raw, meta) {
var e, schema;
if (meta == null) {
meta = '';
}
schema = {};
if (raw) {
try {
schema = JSON.parse(raw);
} catch (_error) {
e = _error;
console.log("-----JSON ERROR on " + meta + "---------");
throw e;
}
}
return schema;
};
util.loadSchemas = function(data) {
var row, schema, schemaName, schemas, _i, _len, _ref;
schemas = [];
_ref = data.schemas;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
row = _ref[_i];
for (schemaName in row) {
schema = util.parseSchema(row[schemaName], "Trouble parsing schema: " + schemaName);
schemas.push(schema);
}
}
return schemas;
};
module.exports = util;
-19
lib/generators/util/text.js
var text;
text = {};
text.capitalize = function(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
};
text.sanitize = function(str) {
var aux, res;
aux = str.split(".");
res = '';
aux.forEach(function(it) {
return res += text.capitalize(it);
});
return res;
};
module.exports = text;