parser.js ➔ getViewForSwagger1 - Code Metrics - Inspection of "fix parser" - sonrac/swagger-vue-doc-generator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e73aee...4c1815 )

by Sergii

created 2017-12-22 13:31 UTC

parser.js ➔ getViewForSwagger1 A

↳ Parent: src/2.0/generator-api/parser.js

Complexity

Conditions	2
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	2
c	1
b	1
f	0
nc	4
nop	1
dl	0
loc	61
rs	9.5147

1 Function

Rating	Name	Duplication	Size	Complexity
A	parser.js ➔ ... ➔ swagger.apis.forEach	0	50	1

How to fix Long Method

/**
 * @author Donii Sergii <[email protected]>
 */

'use strict'
let _ = require('lodash')
let normalizeName = function (id) {
    /* eslint-disable */
    return id.replace(/\.|\-|\{|\}/g, '_').split(" ").join("_")
    /* eslint-enable */
}

let getPathToMethodName = function (opts, m, path) {
    if (path === '/' || path === '') {
        return m
    }

    // clean url path for requests ending with '/'
    let cleanPath = path.replace(/\/$/, '')

    let segments = cleanPath.split('/').slice(1)
    segments = _.transform(segments, function (result, segment) {
        if (segment[0] === '{' && segment[segment.length - 1] === '}') {
            segment = 'by' + segment[1].toUpperCase() + segment.substring(2, segment.length - 1)
        }
        result.push(segment)
    })
    let result = _.camelCase(segments.join('-'))
    return m.toLowerCase() + result[0].toUpperCase() + result.substring(1)
}

let getViewForSwagger2 = function (opts) {
    let swagger = opts.swagger
    let authorizedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'COPY', 'HEAD', 'OPTIONS', 'LINK', 'UNLIK', 'PURGE', 'LOCK', 'UNLOCK', 'PROPFIND']
    let data = {
        description: swagger.info.description,
        isSecure: swagger.securityDefinitions !== undefined,
        moduleName: opts.moduleName,
        className: opts.className,
        imports: opts.imports,
        domain: (swagger.schemes && swagger.schemes.length > 0 && swagger.host && swagger.basePath) ? swagger.schemes[0] + '://' + swagger.host + swagger.basePath.replace(/\/+$/g, '') : '',
        methods: [],
        definitions: []
    }

    _.forEach(swagger.paths, function (api, path) {
        let globalParams = []
        /**
         * @param {Object} op - meta data for the request
         * @param {string} m - HTTP method name - eg: 'get', 'post', 'put', 'delete'
         */
        _.forEach(api, function (op, m) {
            if (m.toLowerCase() === 'parameters') {
                globalParams = op
            }
        })
        _.forEach(api, function (op, m) {
            if (authorizedMethods.indexOf(m.toUpperCase()) === -1) {
                return
            }
            let method = {
                path: path,
                className: opts.className,
                methodName: op.operationId ? normalizeName(op.operationId) : getPathToMethodName(opts, m, path),
                method: m.toUpperCase(),
                isGET: m.toUpperCase() === 'GET',
                isPOST: m.toUpperCase() === 'POST',
                summary: op.description || op.summary,
                tags: op.tags,
                externalDocs: op.externalDocs,
                isSecure: swagger.security !== undefined || op.security !== undefined,
                parameters: [],
                headers: []
            }

            if (op.produces) {
                let headers = []
                headers.value = []

                headers.name = 'Accept'
                headers.value.push(op.produces.map(function (value) { return '\'' + value + '\'' }).join(', '))

                method.headers.push(headers)
            }

            let consumes = op.consumes || swagger.consumes
            if (consumes) {
                method.headers.push({ name: 'Content-Type', value: '\'' + consumes + '\'' })
            }

            let params = []
            if (_.isArray(op.parameters)) {
                params = op.parameters
            }
            params = params.concat(globalParams)
            _.forEach(params, function (parameter) {
                // Ignore parameters which contain the x-exclude-from-bindings extension
                if (parameter['x-exclude-from-bindings'] === true) {
                    return
                }

                // Ignore headers which are injected by proxies & app servers
                // eg: https://cloud.google.com/appengine/docs/go/requests#Go_Request_headers
                if (parameter['x-proxy-header'] && !data.isNode) {
                    return
                }
                if (_.isString(parameter.$ref)) {
                    let segments = parameter.$ref.split('/')
                    parameter = swagger.parameters[segments.length === 1 ? segments[0] : segments[2]]
                }
                parameter.camelCaseName = _.camelCase(parameter.name)
                if (parameter.enum && parameter.enum.length === 1) {
                    parameter.isSingleton = true
                    parameter.singleton = parameter.enum[0]
                }
                if (parameter.in === 'body') {
                    parameter.isBodyParameter = true
                } else if (parameter.in === 'path') {
                    parameter.isPathParameter = true
                } else if (parameter.in === 'query') {
                    if (parameter['x-name-pattern']) {
                        parameter.isPatternType = true
                        parameter.pattern = parameter['x-name-pattern']
                    }
                    parameter.isQueryParameter = true
                } else if (parameter.in === 'header') {
                    parameter.isHeaderParameter = true
                } else if (parameter.in === 'formData') {
                    parameter.isFormParameter = true
                }
                parameter.cardinality = parameter.required ? '' : '?'
                method.parameters.push(parameter)
            })
            data.methods.push(method)
        })
    })

    _.forEach(swagger.definitions, function (definition, name) {
        data.definitions.push({
            name: name
        })
    })

    return data
}

let getViewForSwagger1 = function (opts) {
    let swagger = opts.swagger
    let data = {
        description: swagger.description,
        moduleName: opts.moduleName,
        className: opts.className,
        domain: swagger.basePath ? swagger.basePath : '',
        methods: []
    }
    swagger.apis.forEach(function (api) {
        api.operations.forEach(function (op) {
            let method = {
                path: api.path,
                className: opts.className,
                methodName: op.nickname,
                method: op.method,
                isGET: op.method === 'GET',
                isPOST: op.method.toUpperCase() === 'POST',
                summary: op.summary,
                parameters: op.parameters,
                headers: []
            }

            if (op.produces) {
                let headers = []
                headers.value = []

                headers.name = 'Accept'
                headers.value.push(op.produces.map(function (value) { return '\'' + value + '\'' }).join(', '))

                method.headers.push(headers)
            }

            op.parameters = op.parameters ? op.parameters : []
            op.parameters.forEach(function (parameter) {
                parameter.camelCaseName = _.camelCase(parameter.name)
                if (parameter.enum && parameter.enum.length === 1) {
                    parameter.isSingleton = true
                    parameter.singleton = parameter.enum[0]
                }
                if (parameter.paramType === 'body') {
                    parameter.isBodyParameter = true
                } else if (parameter.paramType === 'path') {
                    parameter.isPathParameter = true
                } else if (parameter.paramType === 'query') {
                    if (parameter['x-name-pattern']) {
                        parameter.isPatternType = true
                        parameter.pattern = parameter['x-name-pattern']
                    }
                    parameter.isQueryParameter = true
                } else if (parameter.paramType === 'header') {
                    parameter.isHeaderParameter = true
                } else if (parameter.paramType === 'form') {
                    parameter.isFormParameter = true
                }
            })
            data.methods.push(method)
        })
    })
    return data
}

let parse = function (opts) {
    let data = opts.swagger.swagger === '2.0' ? getViewForSwagger2(opts) : getViewForSwagger1(opts)
    return data
}

module.exports = parse


1			/**
2			* @author Donii Sergii <[email protected]>
3			*/
4
5			'use strict'
6			let _ = require('lodash')
7			let normalizeName = function (id) {
8			/* eslint-disable */
9			return id.replace(/\.\|\-\|\{\|\}/g, '_').split(" ").join("_")
10			/* eslint-enable */
11			}
12
13			let getPathToMethodName = function (opts, m, path) {
14			if (path === '/' \|\| path === '') {
15			return m
16			}
17
18			// clean url path for requests ending with '/'
19			let cleanPath = path.replace(/\/$/, '')
20
21			let segments = cleanPath.split('/').slice(1)
22			segments = _.transform(segments, function (result, segment) {
23			if (segment[0] === '{' && segment[segment.length - 1] === '}') {
24			segment = 'by' + segment[1].toUpperCase() + segment.substring(2, segment.length - 1)
25			}
26			result.push(segment)
27			})
28			let result = _.camelCase(segments.join('-'))
29			return m.toLowerCase() + result[0].toUpperCase() + result.substring(1)
30			}
31
32			let getViewForSwagger2 = function (opts) {
33			let swagger = opts.swagger
34			let authorizedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'COPY', 'HEAD', 'OPTIONS', 'LINK', 'UNLIK', 'PURGE', 'LOCK', 'UNLOCK', 'PROPFIND']
35			let data = {
36			description: swagger.info.description,
37			isSecure: swagger.securityDefinitions !== undefined,
38			moduleName: opts.moduleName,
39			className: opts.className,
40			imports: opts.imports,
41			domain: (swagger.schemes && swagger.schemes.length > 0 && swagger.host && swagger.basePath) ? swagger.schemes[0] + '://' + swagger.host + swagger.basePath.replace(/\/+$/g, '') : '',
42			methods: [],
43			definitions: []
44			}
45
46			_.forEach(swagger.paths, function (api, path) {
47			let globalParams = []
48			/**
49			* @param {Object} op - meta data for the request
50			* @param {string} m - HTTP method name - eg: 'get', 'post', 'put', 'delete'
51			*/
52			_.forEach(api, function (op, m) {
53			if (m.toLowerCase() === 'parameters') {
54			globalParams = op
55			}
56			})
57			_.forEach(api, function (op, m) {
58			if (authorizedMethods.indexOf(m.toUpperCase()) === -1) {
59			return
60			}
61			let method = {
62			path: path,
63			className: opts.className,
64			methodName: op.operationId ? normalizeName(op.operationId) : getPathToMethodName(opts, m, path),
65			method: m.toUpperCase(),
66			isGET: m.toUpperCase() === 'GET',
67			isPOST: m.toUpperCase() === 'POST',
68			summary: op.description \|\| op.summary,
69			tags: op.tags,
70			externalDocs: op.externalDocs,
71			isSecure: swagger.security !== undefined \|\| op.security !== undefined,
72			parameters: [],
73			headers: []
74			}
75
76			if (op.produces) {
77			let headers = []
78			headers.value = []
79
80			headers.name = 'Accept'
81			headers.value.push(op.produces.map(function (value) { return '\'' + value + '\'' }).join(', '))
82
83			method.headers.push(headers)
84			}
85
86			let consumes = op.consumes \|\| swagger.consumes
87			if (consumes) {
88			method.headers.push({ name: 'Content-Type', value: '\'' + consumes + '\'' })
89			}
90
91			let params = []
92			if (_.isArray(op.parameters)) {
93			params = op.parameters
94			}
95			params = params.concat(globalParams)
96			_.forEach(params, function (parameter) {
97			// Ignore parameters which contain the x-exclude-from-bindings extension
98			if (parameter['x-exclude-from-bindings'] === true) {
99			return
100			}
101
102			// Ignore headers which are injected by proxies & app servers
103			// eg: https://cloud.google.com/appengine/docs/go/requests#Go_Request_headers
104			if (parameter['x-proxy-header'] && !data.isNode) {
105			return
106			}
107			if (_.isString(parameter.$ref)) {
108			let segments = parameter.$ref.split('/')
109			parameter = swagger.parameters[segments.length === 1 ? segments[0] : segments[2]]
110			}
111			parameter.camelCaseName = _.camelCase(parameter.name)
112			if (parameter.enum && parameter.enum.length === 1) {
113			parameter.isSingleton = true
114			parameter.singleton = parameter.enum[0]
115			}
116			if (parameter.in === 'body') {
117			parameter.isBodyParameter = true
118			} else if (parameter.in === 'path') {
119			parameter.isPathParameter = true
120			} else if (parameter.in === 'query') {
121			if (parameter['x-name-pattern']) {
122			parameter.isPatternType = true
123			parameter.pattern = parameter['x-name-pattern']
124			}
125			parameter.isQueryParameter = true
126			} else if (parameter.in === 'header') {
127			parameter.isHeaderParameter = true
128			} else if (parameter.in === 'formData') {
129			parameter.isFormParameter = true
130			}
131			parameter.cardinality = parameter.required ? '' : '?'
132			method.parameters.push(parameter)
133			})
134			data.methods.push(method)
135			})
136			})
137
138			_.forEach(swagger.definitions, function (definition, name) {
139			data.definitions.push({
140			name: name
141			})
142			})
143
144			return data
145			}
146
147			let getViewForSwagger1 = function (opts) {
148			let swagger = opts.swagger
149			let data = {
150			description: swagger.description,
151			moduleName: opts.moduleName,
152			className: opts.className,
153			domain: swagger.basePath ? swagger.basePath : '',
154			methods: []
155			}
156			swagger.apis.forEach(function (api) {
157			api.operations.forEach(function (op) {
158			let method = {
159			path: api.path,
160			className: opts.className,
161			methodName: op.nickname,
162			method: op.method,
163			isGET: op.method === 'GET',
164			isPOST: op.method.toUpperCase() === 'POST',
165			summary: op.summary,
166			parameters: op.parameters,
167			headers: []
168			}
169
170			if (op.produces) {
171			let headers = []
172			headers.value = []
173
174			headers.name = 'Accept'
175			headers.value.push(op.produces.map(function (value) { return '\'' + value + '\'' }).join(', '))
176
177			method.headers.push(headers)
178			}
179
180			op.parameters = op.parameters ? op.parameters : []
181			op.parameters.forEach(function (parameter) {
182			parameter.camelCaseName = _.camelCase(parameter.name)
183			if (parameter.enum && parameter.enum.length === 1) {
184			parameter.isSingleton = true
185			parameter.singleton = parameter.enum[0]
186			}
187			if (parameter.paramType === 'body') {
188			parameter.isBodyParameter = true
189			} else if (parameter.paramType === 'path') {
190			parameter.isPathParameter = true
191			} else if (parameter.paramType === 'query') {
192			if (parameter['x-name-pattern']) {
193			parameter.isPatternType = true
194			parameter.pattern = parameter['x-name-pattern']
195			}
196			parameter.isQueryParameter = true
197			} else if (parameter.paramType === 'header') {
198			parameter.isHeaderParameter = true
199			} else if (parameter.paramType === 'form') {
200			parameter.isFormParameter = true
201			}
202			})
203			data.methods.push(method)
204			})
205			})
206			return data
207			}
208
209			let parse = function (opts) {
210			let data = opts.swagger.swagger === '2.0' ? getViewForSwagger2(opts) : getViewForSwagger1(opts)
211			return data
212			}
213
214			module.exports = parse
215

sonrac / swagger-vue-doc-generator

Push — master ( e73aee...4c1815 )

parser.js ➔ getViewForSwagger1 A

Complexity

Size

Duplication

Importance

1 Function

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like