<commit_before># Route generator

Projeto destinado a criar um gerador de rotas segundo um padrão onde as rotas sejam geradas automaticamente à partir dos controllers disponíveis.

Antes de mais nada, precisamos entender como funciona a definição de rotas. Nesse exemplo utilizaremos o `restify-route` em conjunto com o `restify`, que é um framework Node focado em APIs REST.


```js
var restify = require('restify')
var router = require('restify-route')

var server = restify.createServer()

router
	.use(server)
	.set('/users', 'get', function(req, res, next){
		res.send({
			'usuarios' : 'Lista de usuários',
			'version' : '1.0.2'
		})
		return next()
	})
	.set('/users/:id', 'get', function(req, res, next){
    const id = req.params.id
		res.send({
			'user' : id
		})
		return next()
	})
```
Na definição de rotas acima podemos perceber os seguintes elementos:

- router: `restify-route`
- path: `/, /:id`
- method: `get`
- callback: `function(req, res, next)`

Antes de seguirmos em frente, vamos refatorar o código acima usando ES6

```js
var restify = require('restify')
var router = require('restify-route')

var server = restify.createServer()

router
	.use(server)
	.set('/', 'get', (req, res, next) => {
		res.send({
			'api' : 'api-rest',
			'version' : '1.0.2'
		})
		return next()
	})
	.set('/:id', 'get', (req, res, next) =>{
    const id = req.params.id
		res.send({
			'user' : id
		})
		return next()
	})
```

Agora vamos imaginar que nosso projeto segue a seguinte estrutura de pastas.

```
|-- src/
|   |-- index.js
|   |-- controller/
|   |   |-- UserController.js
```
Vamos refatorar o nosso código para utilizar o `UserController` e simplificar a definição das nossas rotas.

```js
//index.js
router
	.use(server)
	.set('/users', 'get', (req, res, next) => {
		var Users = require('./controller/UserController').listar

		Users(req.params, (code, data) => {
			res.send(code, data)
		})
		return next()
	})
	.set('/users/:id', 'get', (req, res, next) => {
		var Users = require('./controller/UserController').obter

		Users(req.params, (code, data) => {
			res.send(code, data)
		})
		return next()
	})
```
Note que a definição das duas rotas é basicamente a mesma, mudando apenas o método utilizado do `controller`.

Abaixo o conteúdo do nosso `UserController`

```js
//UserController.js
var listUsers = (data, callback) => {
    return callback(200, { 'usuarios' : 'Lista de usuarios'})
}

var getUsers = (data, callback) => {

    return callback(200,  data )
}

module.exports = {
    listar : listUsers,
    obter : getUsers
}
```

Nessa estrutura podemos ter uma infinidade de rotas a serem definidas para um único `controller`.

Antes de pensar em automatizar definição das rotas, precisamos estabelecer um padrão para definição dessas rotas dentro dos `controllers`. Para isso vamos refatorar nosso `UserController` da seguinte forma.

```js
var listUsers = (data, callback) => {
    return callback(200, { 'usuarios' : 'Lista de usuarios'})
}

var getUsers = (data, callback) => {

    return callback(200,  data )
}

module.exports = [
    {
        path : '/users',
        method : 'get',
        action : listUsers
    },
    {
        path : '/users/:id',
        method : 'get',
        action : getUsers
    }
]
```
Note que agora o nosso `module.exports` do `UserController` define suas rotas possíveis e todas as informações necessárias para executa-las.

Agora podemos pensar em automatizar a criação dessas rotas, utilizando o módulo `fs`, nativo do Node.
```js
var fs = require('fs')
```
À partir do uso desse módulo, podemos fazer a leitura do conteúdo da pasta `controller` e identificar quais os `controllers` disponíveis. Algo como:

```js
fs.readdir(__dirname + '/controller', (err, files) => {
  //Arquivos presentes na pasta controller
})
```<commit_msg>Correção de erros e formatação do readme<commit_after># Route generator

Projeto destinado a criar um gerador de rotas segundo um padrão onde as rotas sejam geradas automaticamente à partir dos `controllers` disponíveis.

Antes de mais nada, precisamos entender como funciona a definição de rotas. Nesse exemplo utilizaremos o `restify-route` em conjunto com o `restify`, que é um framework Node focado em APIs REST.


```js
var restify = require('restify')
var router = require('restify-route')

var server = restify.createServer()

router
	.use(server)
	.set('/users', 'get', function(req, res, next){
		res.send({
			'usuarios' : 'Lista de usuários',
			'version' : '1.0.2'
		})
		return next()
	})
	.set('/users/:id', 'get', function(req, res, next){
    const id = req.params.id
		res.send({
			'user' : id
		})
		return next()
	})
```
Na definição de rotas acima podemos perceber os seguintes elementos:

- router: `restify-route`
- path: `/, /:id`
- method: `get`
- callback: `function(req, res, next)`

Antes de seguirmos em frente, vamos refatorar o código acima usando ES6

```js
var restify = require('restify')
var router = require('restify-route')

var server = restify.createServer()

router
	.use(server)
	.set('/', 'get', (req, res, next) => {
		res.send({
			'api' : 'api-rest',
			'version' : '1.0.2'
		})
		return next()
	})
	.set('/:id', 'get', (req, res, next) =>{
    const id = req.params.id
		res.send({
			'user' : id
		})
		return next()
	})
```

Agora vamos imaginar que nosso projeto segue a seguinte estrutura de pastas.

```
|-- src/
|   |-- index.js
|   |-- controller/
|   |   |-- UserController.js
```
Vamos refatorar o nosso código para utilizar o `UserController` e simplificar a definição das nossas rotas.

```js
//index.js
router
	.use(server)
	.set('/users', 'get', (req, res, next) => {
		var Users = require('./controller/UserController').listar

		Users(req.params, (code, data) => {
			res.send(code, data)
		})
		return next()
	})
	.set('/users/:id', 'get', (req, res, next) => {
		var Users = require('./controller/UserController').obter

		Users(req.params, (code, data) => {
			res.send(code, data)
		})
		return next()
	})
```
Note que a definição das duas rotas é basicamente a mesma, mudando apenas o método utilizado do `controller`.

Abaixo o conteúdo do nosso `UserController`

```js
//UserController.js
var listUsers = (data, callback) => {
    return callback(200, { 'usuarios' : 'Lista de usuarios'})
}

var getUsers = (data, callback) => {

    return callback(200,  data )
}

module.exports = {
    listar : listUsers,
    obter : getUsers
}
```

Nessa estrutura podemos ter uma infinidade de rotas a serem definidas para um único `controller`.

Antes de pensar em automatizar definição das rotas, precisamos estabelecer um padrão para definição dessas rotas dentro dos `controllers`. Para isso vamos refatorar nosso `UserController` da seguinte forma.

```js
var listUsers = (data, callback) => {
    return callback(200, { 'usuarios' : 'Lista de usuarios'})
}

var getUsers = (data, callback) => {

    return callback(200,  data )
}

module.exports = [
    {
        path : '/users',
        method : 'get',
        action : listUsers
    },
    {
        path : '/users/:id',
        method : 'get',
        action : getUsers
    }
]
```
Note que agora o nosso `module.exports` do `UserController` define suas rotas possíveis e todas as informações necessárias para executa-las.

Agora podemos pensar em automatizar a criação dessas rotas, utilizando o módulo `fs`, nativo do Node.
```js
var fs = require('fs')
```
A partir do uso desse módulo, podemos fazer a leitura do conteúdo da pasta `controller` e identificar quais os `controllers` disponíveis. Algo como:

```js
fs.readdir(__dirname + '/controller', (err, files) => {
  //Arquivos presentes na pasta controller
})
```
{'fraction_non_alphanumeric': 0.1412318556296587, 'fraction_numerical': 0.00496926899437688, 'mean_word_length': 3.5334914048606993, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 25, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '1609099', 'n_tokens_mistral': 2825, 'n_tokens_neox': 2682, 'n_words': 854}