From c0b741c9a6be42ff2f76e2ba671d8b36de313fb1 Mon Sep 17 00:00:00 2001
From: JotaPe
Date: Sun, 10 Sep 2017 16:05:49 -0300
Subject: [PATCH 001/101] updated the base of the project
---
docs/LANGS.md | 1 +
docs/pt_BR/README.md | 82 +++++++++++++++++++++++
docs/pt_BR/SUMMARY.md | 28 ++++++++
docs/pt_BR/book.json | 3 +
docs/pt_BR/building_your_app.md | 11 ++++
docs/pt_BR/contributing.md | 7 ++
docs/pt_BR/development.md | 14 ++++
docs/pt_BR/end-to-end_testing.md | 50 ++++++++++++++
docs/pt_BR/entry_indexhtml.md | 47 +++++++++++++
docs/pt_BR/faqs.md | 66 +++++++++++++++++++
docs/pt_BR/file-tree.md | 61 +++++++++++++++++
docs/pt_BR/getting_started.md | 32 +++++++++
docs/pt_BR/global_configuration.md | 35 ++++++++++
docs/pt_BR/main-process.md | 36 ++++++++++
docs/pt_BR/meta.md | 9 +++
docs/pt_BR/migration-guide.md | 14 ++++
docs/pt_BR/miscellaneous.md | 0
docs/pt_BR/new-releases.md | 28 ++++++++
docs/pt_BR/npm_scripts.md | 44 +++++++++++++
docs/pt_BR/project_structure.md | 23 +++++++
docs/pt_BR/renderer-process.md | 53 +++++++++++++++
docs/pt_BR/savingreading-local-files.md | 41 ++++++++++++
docs/pt_BR/testing.md | 30 +++++++++
docs/pt_BR/unittesting.md | 42 ++++++++++++
docs/pt_BR/using-electron-builder.md | 87 +++++++++++++++++++++++++
docs/pt_BR/using-electron-packager.md | 71 ++++++++++++++++++++
docs/pt_BR/using-static-assets.md | 53 +++++++++++++++
docs/pt_BR/using_css_frameworks.md | 34 ++++++++++
docs/pt_BR/using_pre-processors.md | 82 +++++++++++++++++++++++
docs/pt_BR/using_the_file_structure.md | 12 ++++
docs/pt_BR/vue_accessories.md | 35 ++++++++++
docs/pt_BR/webpack-configurations.md | 20 ++++++
32 files changed, 1151 insertions(+)
create mode 100644 docs/pt_BR/README.md
create mode 100644 docs/pt_BR/SUMMARY.md
create mode 100644 docs/pt_BR/book.json
create mode 100644 docs/pt_BR/building_your_app.md
create mode 100644 docs/pt_BR/contributing.md
create mode 100644 docs/pt_BR/development.md
create mode 100644 docs/pt_BR/end-to-end_testing.md
create mode 100644 docs/pt_BR/entry_indexhtml.md
create mode 100644 docs/pt_BR/faqs.md
create mode 100644 docs/pt_BR/file-tree.md
create mode 100644 docs/pt_BR/getting_started.md
create mode 100644 docs/pt_BR/global_configuration.md
create mode 100644 docs/pt_BR/main-process.md
create mode 100644 docs/pt_BR/meta.md
create mode 100644 docs/pt_BR/migration-guide.md
create mode 100644 docs/pt_BR/miscellaneous.md
create mode 100644 docs/pt_BR/new-releases.md
create mode 100644 docs/pt_BR/npm_scripts.md
create mode 100644 docs/pt_BR/project_structure.md
create mode 100644 docs/pt_BR/renderer-process.md
create mode 100644 docs/pt_BR/savingreading-local-files.md
create mode 100644 docs/pt_BR/testing.md
create mode 100644 docs/pt_BR/unittesting.md
create mode 100644 docs/pt_BR/using-electron-builder.md
create mode 100644 docs/pt_BR/using-electron-packager.md
create mode 100644 docs/pt_BR/using-static-assets.md
create mode 100644 docs/pt_BR/using_css_frameworks.md
create mode 100644 docs/pt_BR/using_pre-processors.md
create mode 100644 docs/pt_BR/using_the_file_structure.md
create mode 100644 docs/pt_BR/vue_accessories.md
create mode 100644 docs/pt_BR/webpack-configurations.md
diff --git a/docs/LANGS.md b/docs/LANGS.md
index ba102e18..3c28d071 100644
--- a/docs/LANGS.md
+++ b/docs/LANGS.md
@@ -1,3 +1,4 @@
* [English](en/)
* [日本語](ja/)
* [中文](cn/)
+* [Português](pt_BR/)
diff --git a/docs/pt_BR/README.md b/docs/pt_BR/README.md
new file mode 100644
index 00000000..b65015e2
--- /dev/null
+++ b/docs/pt_BR/README.md
@@ -0,0 +1,82 @@
+
+
+> Um template para criar aplicações electron usando vue \(como o nome diz\).
+
+[](https://semaphoreci.com/simulatedgreg/electron-vue)
+
+[](https://github.com/feross/standard)
+
+[](http://forthebadge.com) [](http://forthebadge.com) [](http://forthebadge.com)
+
+## Resumo
+
+O foco do template é remover a nescessidade de criar manualmente todo a organização do projeto usando electron e o vue. electron-vue tira vantagem da `vue-cli` para receber arquivos, `webpack` com `vue-loader`, `electron-packager` ou `electron-builder`, e também os plugins mais utilizados como `vue-router`, `vuex` e muito mais.
+
+#### De uma olhada na documentação em português [aqui](https://simulatedgreg.gitbooks.io/electron-vue/content/index.html).
+
+Coisas que você vai achar no projeto...
+
+* Estrutura basica de projeto, com arquivo um **unico** `package.json`
+* [Documentação](https://simulatedgreg.gitbooks.io/electron-vue/content/) detalhada
+* O projeto retira seus arquivos de vue da [vue-cli](https://github.com/vuejs/vue-cli)
+* Pronto para uso de plugins de vue como \([axios](https://github.com/mzabriskie/axios), [vue-electron](https://github.com/SimulatedGREG/vue-electron), [vue-router](https://github.com/vuejs/vue-router), [vuex](https://github.com/vuejs/vuex)\)\*
+* Instalado [vue-devtools](https://github.com/vuejs/vue-devtools) e [devtron](https://github.com/electron/devtron) ferramentas para desenvolvimento
+* Habilidade para facilmente compilar e criar o arquivo final para instalar sua aplicação usando [electron-packager](https://github.com/electron-userland/electron-packager) ou [electron-builder](https://github.com/electron-userland/electron-builder)\*
+* `appveyor.yml` e `.travis.yml` configurados para automatizar o deploy com [electron-builder](https://github.com/electron-userland/electron-builder)\*
+* Habilidade para produzir saidas para browsers
+* Acessivel [NPM scripts](/npm_scripts.md)
+* Usa o [webpack](https://github.com/webpack/webpack) e [vue-loader](https://github.com/vuejs/vue-loader) com Hot Module Replacement
+* Automatização do reinicio dos processos `main` do electron
+* HTML/CSS/JS pre-processor suporte com [vue-loader](https://github.com/vuejs/vue-loader/)
+* ES6 com [`stage-0`](https://babeljs.io/docs/plugins/preset-stage-0/) by default
+* Uso de [`babili`](https://github.com/babel/babili) para remover a nescessidade de fazer transpiling completo para o ES5
+* ESLint \(com suporte ao [`standard`](https://github.com/feross/standard) e [`airbnb-base`](https://github.com/airbnb/javascript)\)\*
+* Teste unitario com \(with [`karma`](https://github.com/karma-runner/karma) + [`mocha`](https://github.com/mochajs/mocha)\)\*
+* End-to-end Testing \(with [`spectron`](https://github.com/electron/spectron) + [`mocha`](https://github.com/mochajs/mocha)\)\*
+
+\*Customizavel durante o uso da `vue-cli`
+
+### Introdução
+
+Esse template foi construído utilizando [`vue-cli`](https://github.com/vuejs/vue-cli) e inclui opções para customizar a estrutura final do seu app. O template utiliza `node@^7` ou superior como mínimo. electron-vue também recomenda utilizar o [`yarn`](https://yarnpkg.org), gerenciador de pacotes que manipula seus pacotes de uma forma muito melhor e vai ajudar a reduzir o peso final do projeto `yarn clean`.
+
+```bash
+# Instala o vue-cli e o template do projeto
+npm install -g vue-cli
+vue init simulatedgreg/electron-vue my-project
+
+# Instala as dependencias e executa seu app (your app)
+cd my-project
+yarn # ou npm install
+yarn run dev # ou npm run dev
+```
+
+##### Você e um usuario de Windows
+
+Por favor olhe a [**Uma Nota Para Usuarios de Windows**](https://simulatedgreg.gitbooks.io/electron-vue/content/en/getting_started.html#a-note-for-windows-users) para que você tenha certeza que esta com todas as dependencias instaladas para conseguir fazer deploy e construir a aplicação.
+
+##### Querendo usar Vue 1?
+
+So um ponto a ser dado, a suporte ao Vue 1 foi oficialmente descontinuado então a estrutura do projeto, features e documentação vão refletir essas mudanças \([**documentação legado**](https://github.com/SimulatedGREG/electron-vue/tree/1.0/docs)\).
+
+```bash
+vue init simulatedgreg/electron-vue#1.0 my-project
+```
+
+### Proximos Passos
+
+Certifique-se de olhar a [documentação](https://simulatedgreg.gitbooks.io/electron-vue/content/). Aqui você vai achar informação util sobre a configuração, estrutura do projeto, e construção de sua aplicação. Tambe tem a acessivel [FAQs](https://simulatedgreg.gitbooks.io/electron-vue/content/en/faqs.html), que ajuda a responder questões ja respondidas.
+
+## Criado usando electron-vue
+
+De uma olhada nesses projetos impressionantes, usando electron-vue. Que que seu projeto seja listado ? Se sinta livre de enviar um pull request.
+
+* [**Surfbird**](https://github.com/surfbirdapp/surfbird): Um Twitter client criado usando Electron e Vue
+* [**Lulumi-browser**](https://github.com/qazbnm456/lulumi-browser): Lulumi-browser e um browser leve programado usando Vue.js 2 e Electron
+* [**Space-Snake**](https://github.com/ilyagru/Space-Snake): Um jogo para computador de criado usando Electron e Vue.js.
+* [**Forrest**](https://github.com/stefanjudis/forrest): An npm scripts desktop client
+* [**miikun**](https://github.com/hiro0218/miikun): Um simples editor de Markdown.
+* [**Dakika**](https://github.com/Madawar/Dakika): A minute taking application that makes writing minutes a breeze
+* [**Dynamoc**](https://github.com/ieiayaobb/dynamoc): Dynamoc is a GUI client for dynamodb-local, dynalite and AWS dynamodb
+* [**Dockeron**](https://github.com/dockeron/dockeron): A dockeron project, built on Electron + Vue.js for Docker
+* [**Easysubs**](https://github.com/matiastucci/easysubs): Download subtitles in a very fast and simple way
diff --git a/docs/pt_BR/SUMMARY.md b/docs/pt_BR/SUMMARY.md
new file mode 100644
index 00000000..51364cd0
--- /dev/null
+++ b/docs/pt_BR/SUMMARY.md
@@ -0,0 +1,28 @@
+# Sumário
+
+* [Introdução](./README.md)
+* [Início "Rápido"](getting_started.md)
+* [Estrutura de Projeto](project_structure.md)
+ * [Árvore de Arquivos](file-tree.md)
+ * [Processo de Renderização](renderer-process.md)
+ * [Processo Primário](main-process.md)
+ * [Configurações Webpack](webpack-configurations.md)
+* [Desenvolvimento](development.md)
+ * [Acesso index.html](entry_indexhtml.md)
+ * [Vue Plugins](vue_accessories.md)
+ * [NPM Scripts](npm_scripts.md)
+ * [Utilizando CSS Frameworks](using_css_frameworks.md)
+ * [Utilizando Pre-Processors](using_pre-processors.md)
+ * [Utilizando Arquivos (imagens e coisas parecidas) Estáticos](using-static-assets.md)
+ * [Lendo & Escrevendo Arquivos Locais](savingreading-local-files.md)
+* [ Seu App](building_your_app.md)
+ * [Usando electron-packager](using-electron-packager.md)
+ * [Usando electron-builder](using-electron-builder.md)
+* [Testando](testing.md)
+ * [Teste unitário](unittesting.md)
+ * [End-to-End teste](end-to-end_testing.md)
+* [Meta](meta.md)
+ * [Perguntas Frequentes](faqs.md)
+ * [Novas Atualizações](new-releases.md)
+ * [Guia de Migração](migration-guide.md)
+ * [Contribuindo](contributing.md)
diff --git a/docs/pt_BR/book.json b/docs/pt_BR/book.json
new file mode 100644
index 00000000..08b5e020
--- /dev/null
+++ b/docs/pt_BR/book.json
@@ -0,0 +1,3 @@
+{
+ "root": ""
+}
diff --git a/docs/pt_BR/building_your_app.md b/docs/pt_BR/building_your_app.md
new file mode 100644
index 00000000..aecdde9a
--- /dev/null
+++ b/docs/pt_BR/building_your_app.md
@@ -0,0 +1,11 @@
+# Construindo seu App
+
+electron-vue dá suporte aos dois [electron-packager](https://github.com/electron-userland/electron-packager) e [electron-builder](https://github.com/electron-userland/electron-builder) para construir e distruibir sua aplicação pronta para produção. As duas ferrametas para buildar são apoiadas pela incrível comunidade [@electron-userland](https://github.com/electron-userland) e tem uma documentação detalhada. Durante `vue-cli` a estruturação você será perguntado quanto ao builder que deseja usar.
+
+## [`electron-packager`](using-electron-packager.md)
+
+Se você está contruindo uma nova aplicação electron ou apenas precisa criar um simples executável, então `electron-packager` é perfeito para você.
+
+## [`electron-builder`](using-electron-builder.md)
+
+Se você está olhando para instaladores completos, auto-update suporte, construtores CI com Travis CI & AppVeyor, ou automação de reconstrução nativa de node modules, então `electron-builder` é o que você precisa.
diff --git a/docs/pt_BR/contributing.md b/docs/pt_BR/contributing.md
new file mode 100644
index 00000000..720443fd
--- /dev/null
+++ b/docs/pt_BR/contributing.md
@@ -0,0 +1,7 @@
+# Contribuindo
+Gostaria de ajudar nesse template ? Sinta-se livre para enviar um pull request. Antes de enviar qualquer coisa, verifique se está tudo em ordem...
+
+### JavaScript Standard Style
+Para garantir que todo seu código siga os padrões básicos ***style standards*** certifique-se de que os mesmos sigam: [rules](http://standardjs.com/#rules).
+
+[](https://github.com/feross/standard)
diff --git a/docs/pt_BR/development.md b/docs/pt_BR/development.md
new file mode 100644
index 00000000..874d018a
--- /dev/null
+++ b/docs/pt_BR/development.md
@@ -0,0 +1,14 @@
+# Desenvolvimento
+
+### Configurando ambiente de desenvolvimento
+
+Depois de instalar dependências com `yarn` ou `npm install`, então rode...
+
+```bash
+yarn run dev # or npm run dev
+```
+
+...e boom! Agora você pode rodar seu electron-vue app.
+
+
+Esse template vem com a poucos componentes landing-page que podem ser removidos de forma fácil.
diff --git a/docs/pt_BR/end-to-end_testing.md b/docs/pt_BR/end-to-end_testing.md
new file mode 100644
index 00000000..6092ab37
--- /dev/null
+++ b/docs/pt_BR/end-to-end_testing.md
@@ -0,0 +1,50 @@
+# Teste End-to-End
+
+O electron-vue utiliza o [Spectron](http://electron.atom.io/spectron/) o [Mocha](https://mochajs.org/) \(com o [Chai](http://chaijs.com/)\) frameworks de teste do tipo end-to-end. Mocha & Chai APIs, incluem `expect`, `should`, e `assert`, que estão disponíveis no escopo global.
+
+### Rodando testes
+
+```bash
+# Executando o mochajs
+npm run e2e
+```
+
+##### Nota
+
+Antes de ser executado os testes end-to end, o comando `npm run pack` é chamado para criar uma build de produção que o Spectron consome durante os testes.
+
+### Estrutura de arquivos
+
+```
+my-project
+├─ test
+| ├─ e2e
+│ │ ├─ specs/
+│ │ ├─ index.js
+└─ └─ └─ utils.js
+```
+
+**Na maior parte, você pode ignorar o **`index.js`** e focar somente na escrita **`specs/`**.**
+
+#### `specs/`
+
+Dentro deste diretório é onde os testes são configurados. Graças ao `babel-register`, você possui acesso total ao ES2015.
+
+#### `index.js`
+
+Este arquivo atua como a entrada principal para o Mocha e reunir todos os testes escritos no `specs/` para os testes.
+
+#### `utils.js`
+
+Aqui você poderá encontrar funções genéricas
+Here you will find generic functions that could be of use throughout your `specs/`. Base functions include a `beforeEach` and `afterEach` that handle the electron creation/destruction process.
+
+### On the subject of Spectron
+
+Spectron é o framework de teste oficial do [electron](http://electron.atom.io) e é utilizado no [ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/) e [WebDriverIO](http://webdriver.io/) para manipulação dos elementos DOM.
+
+#### Using WebDriverIO
+
+As stated in the Spectron [documentation](https://github.com/electron/spectron#client), access to [WebDriverIO APIs](http://webdriver.io/api.html) can be accessed through `this.app.client`. Since electron-vue uses Mocha, the context of `this` is shared between `afterEach`, `beforeEach`, and `it`. Because of this, it is important to note that ES2015 arrow functions cannot not be used in certain situations as the context of `this` will be overwritten \([more info](https://mochajs.org/#arrow-functions)\).
+
+Como ja declardo na [documentação](https://github.com/electron/spectron#client) do Spectron, o acesso a [WebDriverIO APIs](http://webdriver.io/api.html) ele pode ser acessadp peçlo `this.app.client`. Desde que electron-vue começou a usar o mocha, no contexto de `this` e dividido entre `afterEach`, `beforeEach`, e `it`. Por conta disso, e importante saber que em certas condições as arrow functions não podem ser usadas onde o contexto de `this` vai ser sobreescrito \([mais informa](https://mochajs.org/#arrow-functions)\).
diff --git a/docs/pt_BR/entry_indexhtml.md b/docs/pt_BR/entry_indexhtml.md
new file mode 100644
index 00000000..c02c6251
--- /dev/null
+++ b/docs/pt_BR/entry_indexhtml.md
@@ -0,0 +1,47 @@
+# `index.html` de entrada
+
+electron-vue se utiliza do [**`html-webpack-plugin`**](https://github.com/ampedandwired/html-webpack-plugin) para criar o `index.html` nas builds de produção. Durante o desenvolviment você ira encontrar o `index.ejs` na pasta `src/`. E aqui que você faz as mudanças no HTML de entrada.
+
+Se vocês esta desfamiliarizado sobre como o plugin funciona, então eu encorajo você dar uma olhada nisso [documentação](https://www.npmjs.com/package/html-webpack-plugin). Resumindo, esse plugin vai automaticamente injetar os assets da produção incluindo `renderer.js` e `styles.css` no arquivo minificado no `index.html`.
+
+### `index.ejs` durante desenvolvimento
+
+```html
+
+
+
+
+ <%= htmlWebpackPlugin.options.title %>
+ <%= ... %>
+
+
+
+
+
+
+```
+
+### `index.html` em produção \(não minificado\)
+
+```html
+
+
+
+
+ app
+
+
+
+
+
+
+
+```
+
+### No assunto de usar CDNs
+
+Sabendo dos beneficios de usar assets servido pelas CDNs pode ser otimo para suas aplicaçãos finais em quesito de espaço usado, eu vou avisar o uso contra eles. A razão principal e que fazendo isso você esta assumindo que a aplicação sempre sera acessada pela internet, o que as vezes não e o caso da maioria dos Electron apps. Isto esta sendo um grande problema com frameworks CSS atualmente como o bootstrap, e seus apps vão se tornando bagunça não estilizada.
+
+> "Eu não ligo, eu ainda quero usar CDNs"
+
+Se você esta mesmo assim determinado a usar as CDNs, então você pode adicionar toda as tags ao seu arquivo `src/index.ejs`. So faça um app que tenha uma UI/UX estando offline.
diff --git a/docs/pt_BR/faqs.md b/docs/pt_BR/faqs.md
new file mode 100644
index 00000000..5e9816c5
--- /dev/null
+++ b/docs/pt_BR/faqs.md
@@ -0,0 +1,66 @@
+# FAQs
+## Perguntas frequentes...
+
+* [Por que meu app em electron esta branco sem nada depois de rodar `npm run dev` ?](#why-is-my-electron-app-blank-after-running-npm-run-dev)
+* [Por que o meu electron app mostra um explorador de arquivos ?](#why-does-my-electron-app-show-a-file-explorer)
+* [Por que `vue-devtools`/`devtron` esta faltando ?](#why-is-vue-devtoolsdevtron-missing)
+* [Onde eu coloco meus assets estaticos ?](#where-do-i-put-static-assets)
+* [Por que o `npm run lint` resulta em um erro ?](#why-did-npm-run-lint-end-with-an-error)
+* [Por que quando eu rodo `npm run lint` ele termina com um erro ?](#why-did-npm-run-lint-end-with-an-error)
+* [Por que eu não consigo carregar meu app no browser ?](#why-cant-i-load-my-app-in-a-web-browser)
+* [Como eu importo o `jquery` ?](#how-do-import-jquery)
+* [Como eu debugo o processo `main` ?](#how-can-i-debug-the-main-process)
+
+---
+
+## Por que meu app em electron esta branco sem nada depois de rodar `npm run dev` ?
+
+#### TL;DR (Muito longo não lerei)
+
+Tenha certeza que você não tenha uma **proxy** pessoal que possa estar atrapalhando o `webpack-dev-server`.
+
+## Por que o meu electron app mostra um explorador de arquivos ?
+
+#### TL;DR (Muito longo não lerei)
+
+Your `src/renderer` contains error\(s\). Check console, fix errors, then refresh electron with `CommandOrControl+R`.
+
+Seu `src/renderer` contem erro\(s\). Olha o console, para corrigir, e depois da um recarregar com o comando `CommandOrControl+R`.
+
+##### Resposta longa
+
+If error\(s\) are present in you `src/renderer` this creates conflicts with ESLint on first run. In turn, an INVALID webpack `renderer.js` is produced which interrupts `HtmlWebpackPlugin` from creating `index.html`. Since `webpack-dev-server` doesn't have the `index.html` ready to serve, the server falls back to the file explorer.
+
+Se um erro\(s\) esta presente no seu `src/renderer` pode criar conflitos com o ESLint quando você executa na primeira vez. Enquanto isso o webpack gera um arquivo `renderer.js` o que interrompe o `HtmlWebpackPlugin` de funcionar e criar o arquivo `index.html`. Quando o `webpack-dev-server` não tem o `index.html` para servir, o servidor utiliza o explorador de arquivos como fallback.
+
+## Por que `vue-devtools`/`devtron` esta faltando ?
+
+Make sure to close and reopen the developer tools panel on first launch if they are missing. Also check your terminal check for any error messages that may occur during installation.
+
+## Onde eu coloco meus assets estaticos ?
+
+[**Usando Static(estatico) Assets**](/using-static-assets.md)
+
+## Por que o `npm run lint` resulta em um erro ?
+
+The default nature of eslint is to print linting errors to console, and if there is any found the script will end with a non-zero exit \(which produces npm errors\). This is normal behavior.
+
+O natural e que o ESLint vai imprimir os error de linting para o console, e se ele achar qualquer script ele ira terminar com um non-zeo exit \(o que produz erro\(s\) de npm\). Isto e um comportamento normal.
+
+## Por que eu não consigo carregar meu app no browser ?
+
+[\#195](https://github.com/SimulatedGREG/electron-vue/issues/195) (Desculpa não temos como traduzir esta parte.)
+
+## Como eu importo o `jquery`?
+
+If you are wanting to use `bootstrap`, I'm going to have to stop you right there. Using both `vue` and `jquery` in the same environment is a bad practice and leads to the two frameworks colliding with each other. I would highly recommend using a `bootstrap` alternative that uses `vue` for its JavaScript functionality. Some recommendations include [`bootstrap-vue`](https://github.com/bootstrap-vue/bootstrap-vue) and [`vue-strap`](https://github.com/yuche/vue-strap). For whatever reason you must use `jquery`, seek guidance from `webpack`'s documentation about the `ProvidePlugin` or see [\#192](https://github.com/SimulatedGREG/electron-vue/issues/192).
+
+Se você esta querendo usar o `bootstrap`, Eu vou ter que parar você exatamente aqui. Usar os dois `vue` e `jquery` no mesmo ambiente de desenvolvimento e uma má pratica e leva a duas frameworks se colidindo, causando erros `bootstrap` procure uma alternativa `vue` para essa função do JavaScript. Algumas recomendações são: [`bootstrap-vue`](https://github.com/bootstrap-vue/bootstrap-vue) e [`vue-strap`](https://github.com/yuche/vue-strap). Mas se por qualquer razão vocês esta sendo obrigado a usar o `jquery`, procure ajuda documentação do `webpack` sobre como e `ProvidePlugin` ou veja [\#192](https://github.com/SimulatedGREG/electron-vue/issues/192). (Problemas como issues não tem como nos traduzirmos por enquano, mas se alguem se oferecer em traduzir parte importantes da isse seria uma bela contribuição)
+
+## Como eu debugo o processo `main` ?
+
+When using `electron@^1.7.2` you can open up Google Chrome, head to `chrome://inspect`, and then pop open the remote electron process while your application is running in development mode.
+
+Quando usamos o `electron@^1.7.2` você pode abrir o Google Chrome, você vai direto em `chrome://inspect`, e você abre um pop up com as informações do processo enquanto ele esta sendo usado em modo de desenvolvimento.
+
+[Documentação Electron](https://github.com/electron/electron/blob/master/docs/tutorial/debugging-main-process.md)
diff --git a/docs/pt_BR/file-tree.md b/docs/pt_BR/file-tree.md
new file mode 100644
index 00000000..374217a8
--- /dev/null
+++ b/docs/pt_BR/file-tree.md
@@ -0,0 +1,61 @@
+# Árvore de Arquivos
+
+### Durante desenvolvimento
+
+**Nota**: Alguns arquivos/pastas podem estar diferentes das configurações "da base" escolhidos durante a estruturação na `vue-cli`.
+
+```
+my-project
+├─ .electron-vue
+│ └─ .js files
+├─ build
+│ └─ icons/
+├─ dist
+│ ├─ electron/
+│ └─ web/
+├─ node_modules/
+├─ src
+│ ├─ main
+│ │ ├─ index.dev.js
+│ │ └─ index.js
+│ ├─ renderer
+│ │ ├─ components/
+│ │ ├─ router/
+│ │ ├─ store/
+│ │ ├─ App.vue
+│ │ └─ main.js
+│ └─ index.ejs
+├─ static/
+├─ test
+│ ├─ e2e
+│ │ ├─ specs/
+│ │ ├─ index.js
+│ │ └─ utils.js
+│ ├─ unit
+│ │ ├─ specs/
+│ │ ├─ index.js
+│ │ └─ karma.config.js
+│ └─ .eslintrc
+├─ .babelrc
+├─ .eslintignore
+├─ .eslintrc.js
+├─ .gitignore
+├─ package.json
+└─ README.md
+```
+
+#### "Build" de produção
+
+```
+app.asar
+├─ dist
+│ └─ electron
+│ ├─ static/
+│ ├─ index.html
+│ ├─ main.js
+│ └─ renderer.js
+├─ node_modules/
+└─ package.json
+```
+
+Como provavelmente você sabe, todas as coisas que são colocadas e como são colocadas, podem (e provavelmente iram) influenciar no build final do projeto. Isso é praticamente obrigatório quando se está distribuindo electron apps e você não vai querer que seu usuários faça download de software pesado.
diff --git a/docs/pt_BR/getting_started.md b/docs/pt_BR/getting_started.md
new file mode 100644
index 00000000..1f3f640e
--- /dev/null
+++ b/docs/pt_BR/getting_started.md
@@ -0,0 +1,32 @@
+# Começando Agora
+
+## Scaffolding
+### Quais ferramentas usamos para montar esse projeto/template.
+
+Esse template é construído com [vue-cli](https://github.com/vuejs/vue-cli) e inclui opção para customizar o scaffolded da sua aplicação. O uso de `node@^7` ou superior é requerido. electron-vue também recomenda oficialmente o uso do [`yarn`](https://yarnpkg.org) package manager ele maneja as dependências muito melhor e pode ajudar a reduzir o tamanho da build final com `yarn clean`.
+
+```bash
+# Instalando vue-cli e estrutura do template
+npm install -g vue-cli
+vue init simulatedgreg/electron-vue my-project
+
+# Instalando dependências e rodando seu app
+cd meu-projeto
+yarn # ou npm install
+yarn run dev # ou npm run dev
+```
+
+#### Sobre o tema electron
+
+Apesar de opcional, isso é recomendado para bloquear versão do electron depois de estruturar seu projeto. Isso ajuda a prevenir que outros desenvolvedores trabalhem no mesmo projeto desenvolvendo com diferentes versões. Electron solta releases que as vezes modificam features que estão sempre em mudanças. [Mais informações](http://electron.atom.io/docs/tutorial/electron-versioning/).
+
+#### Uma nota para usuários Windows
+
+Se você está tendo erros durante o `npm install` por conta do `node-gyp`, então você provavelmente não tem as ferramentas ideiais instalandas no seu sistema. Ferramentas para build incluem itens como Python e Visual Studio. Um agradecimento ao [@felixrieseberg](https://github.com/felixrieseberg), existem alguns pacotes que ajudam a diminuir esse processo.
+
+O primeiro item que precisamos verificar é a nossa versão do npm e assegurar que não está desatualizado. Nós conseguimos fazer isso usando [`npm-windows-upgrade`](https://github.com/felixrieseberg/npm-windows-upgrade). Se você está usando o `yarn`, então você pode pular essa verificação.
+
+Uma vez que esteja completo, nós podemos então continuar configurando as ferramentas que precisamos. Usando [`windows-build-tools`](https://github.com/felixrieseberg/windows-build-tools), a maior parte do trabalho sujo é feito por nós. Instalando isso globalmente nós por sua vez configure o Visual com os pacotes C++, Python, e mais.
+
+Até esse ponto as coisas devem estar instaladas com sucesso, mas se não, faça uma instalação limpa do Visual Studio Code. Por favor, note que estes não são problemas diretos com o próprio electron-vue \(Windows
+pode ter dificuldades as vezes ¯\\\_\(ツ\)\_/¯\).
diff --git a/docs/pt_BR/global_configuration.md b/docs/pt_BR/global_configuration.md
new file mode 100644
index 00000000..d5f15850
--- /dev/null
+++ b/docs/pt_BR/global_configuration.md
@@ -0,0 +1,35 @@
+# Configuração Global
+
+electron-vue usa o [webpack](https://github.com/webpack/webpack) module loader system for pre-processing, bundling, and building your app. The default settings are rather common and should meet most of your needs. An additional `config.js` is provided in the root directory for quick adjustments. Further customization can be made by directly adjusting `webpack.main.config.js` and `webpack.renderer.config.js`.
+
+#### `config.js`
+**Note**: Some options may differ based on the settings choosen during `vue-cli` scaffolding.
+
+```js
+{
+ // Name of electron app
+ // Will be used in production builds
+ name: 'app',
+
+ // Use ESLint
+ // Further changes can be made in `.eslintrc.js`
+ eslint: true,
+
+ // webpack-dev-server port
+ port: 9080,
+
+ // electron-packager options
+ // See `Building you app` for more info
+ building: {
+ arch: 'x64',
+ asar: true,
+ dir: path.join(__dirname, 'app'),
+ icon: path.join(__dirname, 'app/icons/icon'),
+ ignore: /\b(src|index\.ejs|icons)\b/,
+ name: pkg.name,
+ out: path.join(__dirname, 'builds'),
+ overwrite: true,
+ platform: process.env.PLATFORM_TARGET || 'all'
+ }
+}
+```
diff --git a/docs/pt_BR/main-process.md b/docs/pt_BR/main-process.md
new file mode 100644
index 00000000..45c4f275
--- /dev/null
+++ b/docs/pt_BR/main-process.md
@@ -0,0 +1,36 @@
+# Main Process
+
+> No Electron, o processo que roda o package.json's script primario e chamado pelo processo principal. O script que roda no processo principal pode mostrar uma interface grafica, criando paginas web.
+
+**Tirado da **[**documentação do Electron**](http://electron.atom.io/docs/tutorial/quick-start/#main-process)
+
+---
+
+Desde que o `processo` principal e essencial para um ambiente completo node, não se tem uma estrutura incial a não ser dois arquivos.
+
+#### `src/main/index.js`
+
+Este arquivo e o principal de sua aplicação, esse arquivo que o `electron` começa com. Ele tambem pode ser usado pelo `webpack` como arquivo de entrada pra produção. Todo arquivo no processo `principal` principal começar daqui.
+
+#### `app/src/main/index.dev.js`
+
+Este arquivo e usado especificamente e unicamente para desenvolvimento e ele instala o `electron-debug` & `vue-devtools`. Não se precisa modificar esse arquivo, mas isso pode ser usado para extender suas nescessidades de desenvolvimento.
+
+## No caso de usar o `__dirname` & `__filename`
+
+Desde que o processo `principal` e empacotado usando `webpack`, o uso de `__dirname` & `__filename` **não vai** prover nenhum valor para a produção. Se referindo a [**Arvore de Arquivos**](/file-tree.md), você vai notar que na produção o `main.js` e colocado dentro da pasta `dist/electron`. Baseado no nesse conhecimento, use `__dirname` & `__filename` de acordo.
+
+**Se você precisa usar o caminho para o `static/` assets directory, tenha atenção de ler o **[**Usando Assets Estaticos**](/using-static-assets.md)** para saber como usar esta variavel super acessivel `__static`.**
+
+
+```
+app.asar
+├─ dist
+│ └─ electron
+│ ├─ static/
+│ ├─ index.html
+│ ├─ main.js
+│ └─ renderer.js
+├─ node_modules/
+└─ package.json
+```
diff --git a/docs/pt_BR/meta.md b/docs/pt_BR/meta.md
new file mode 100644
index 00000000..6782d52b
--- /dev/null
+++ b/docs/pt_BR/meta.md
@@ -0,0 +1,9 @@
+# Meta
+
+### Obrigado
+
+Wow, muito obrigado a vocês pessoal por ajudar a fazer o electron-vue uma das top 3 `vue-cli`templates \(que você consegue achar\) no GitHub. Eu nunca pensei que este projeto iria ser o que é hoje em dia. Pensando a tempos atras, eu originalmente criei este {tradução de boilerplate} \(em **May 2016**\) para um projeto pessoal de codigo fechado e decidi deixa-lo open source \(o {tradução de boilerplate} por si só\) quando eu notei que a maioria das peças estavam juntas. Mas voltanddo ao presente tem se implementado novas features e um suporte incrivel pela comunidade. Eu tambem quero especialmente dizer um obrigado as pessoas ajudando a responder problemas enquanto eu não podia. Vocês não tinham nenhuma obrigação de fazer, mas fizeram mesmo assim, e eu sou muito grato por isso.
+
+Se você esta lendo isso, então eu posso assumir que vocês esta realmente gostando do electron-vue. Muito tempo foi gasto para criar esse {tradução de boilerplate}. Se você esta se sentindo generoso, então se sinta livre de deixar uma doação. Certamente desenvolvimento futuro do electron-vue não e dependente de doações, mas isso sempre foi uma opção se você se decidir usa-la.
+
+#### [**PayPal.me**](https://www.paypal.me/simulatedgreg/5)
diff --git a/docs/pt_BR/migration-guide.md b/docs/pt_BR/migration-guide.md
new file mode 100644
index 00000000..208a05cc
--- /dev/null
+++ b/docs/pt_BR/migration-guide.md
@@ -0,0 +1,14 @@
+# Guia de migração
+
+The following documentation attempts to explain how migrating your project _should_ be accomplished, but may not be a full proof method as overall project structure is always up for change.
+
+A documentação a seguir tenta te explicar a migração do seu projeto que _should_ precisa ser completado, mas não e a prova de falhas o metodo ja que a estrutura do projeto esta sempre aberto a mudanças.
+
+1. Inicie uma versão nova do electron-vue usando `vue init simulatedgreg/electron-vue my-project`
+2. Copie por cima o projeto atual para a pasta `src` para a nova pasta do {tradução de scaffold} `src`
+3. Copie sobre o `package.json` as dependencias do projeto atual para o novo {tradução de scaffold} `package.json`
+4. Instale as dependencias com `yarn` ou `npm install`
+5. Rode o projeto no modo de desenvolvimento com \(`yarn run dev` ou `npm run dev`\)
+6. Olhe para o terminal para encontrar erros e resolver.
+
+Como previamente mencionaddo acima, não tem metodo sem erros para fazer a migração para o novo {tradução de scaffold}, mas isso vai se tornar grandes passos para chegar o mais perto de ter tudo feito. Qualquer modificação pessoal para a estrutura do projeto ou assets vai ser totalmente problema seu e de sua equipe para migrar. Tenha total certeza de olhar toda a outra documentação, e ve se isso reflete a versão atual do electron-vue da branch `master`.
diff --git a/docs/pt_BR/miscellaneous.md b/docs/pt_BR/miscellaneous.md
new file mode 100644
index 00000000..e69de29b
diff --git a/docs/pt_BR/new-releases.md b/docs/pt_BR/new-releases.md
new file mode 100644
index 00000000..e92bf471
--- /dev/null
+++ b/docs/pt_BR/new-releases.md
@@ -0,0 +1,28 @@
+# Novas versões
+
+electron-vue has evolved greatly since its initial creation in May of 2016 and has introduced many new fantastic features. Can you believe there was a time `vue-cli` scaffolding wasn't support? Development of new features is not planned to end anytime soon. The only down side to new bells & whistles every now and then is having your project stuck on an older scaffold. Since electron-vue takes advantage of `vue-cli` there unfortunately isn't a structured way to _version_ the boilerplate or make it _updatable_.
+
+Major updates of electron-vue will be made through GitHub Milestones and will include many new features/bug fixes at a time, making these releases the optimal time to [migrate](/migration-guide.md) any existing projects to a newer scaffold. These milestones are not usually planned, but arise as feature requests add up in the issue tracker.
+
+### Objetivos passados
+
+#### [Multiplex](https://github.com/SimulatedGREG/electron-vue/milestone/1?closed=1)
+
+* Migração para o `webpack` 2
+* Suporte para o `electron-builder`
+* Supoerte para a contrução de processo `main`
+* Resolvendo problemas gerais
+
+#### [Minimizar](https://github.com/SimulatedGREG/electron-vue/issues/171)
+
+* Migração para um unico arquivo `package.json`
+* Travis CI / AppVeyor configs for `electron-builder` users
+* Configuraçẽos para Travis CI / AppVeyor para os usuarios de `electron-builder`
+* Saida web minima no processo `renderer`
+
+* Migração para o `axios`
+* Suporte completo para agrupar o processo `main`
+* Reescrevendo os scripts de desenvolvimento e construção
+* Migration to `babili` to remove the need of transpiling down completely to ES5
+* Migração para o `babili` para remover a nescessidade de transpilar completamente para o ES5
+* Suporte para `static/` assets enquanto usam modulos que nescessitam de prover um caminho completo \([`__static`](/using-static-assets.md)\)
diff --git a/docs/pt_BR/npm_scripts.md b/docs/pt_BR/npm_scripts.md
new file mode 100644
index 00000000..925b3550
--- /dev/null
+++ b/docs/pt_BR/npm_scripts.md
@@ -0,0 +1,44 @@
+# NPM Scripts
+
+To help eliminate redundant tasks around the development process, please take note of some of the NPM scripts available to you. The following commands should be ran from your project's root directory. And of course, you can run any of the below commands using `yarn run `.
+
+### `npm run build`
+
+Build your app for production and package. More info can be found in the [**Building Your App**](building_your_app.md) section.
+
+### `npm run dev`
+
+Run app in development.
+
+### `npm run lint`
+
+Lint all your `src/`'s and `test/`'s JS & Vue component files.
+
+### `npm run lint:fix`
+
+Lint all your `src/`'s and `test/`'s JS & Vue component files and attempt to fix issues.
+
+### `npm run pack`
+
+Run both `npm run pack:main` & `npm run pack:renderer`. Although these commands are available, there are not many cases where you will need to manually do this as `npm run build` will handle this step.
+
+### `npm run pack:main`
+
+Run webpack to bundle `main` process source code.
+
+### `npm run pack:renderer`
+
+Run webpack to bundle `renderer` process source code.
+
+### `npm run unit`
+
+Run unit tests with Karma + Jasmine. More information on [**Unit Testing**](unittesting.md).
+
+### `npm run e2e`
+
+Run end-to-end tests with Spectron + Mocha. More information on [**End-to-end Testing**](end-to-end_testing.md).
+
+### `npm test`
+
+Runs both `npm run unit` & `npm run e2e`. More information on [**Testing**](testing.md).
+
diff --git a/docs/pt_BR/project_structure.md b/docs/pt_BR/project_structure.md
new file mode 100644
index 00000000..d35b03dd
--- /dev/null
+++ b/docs/pt_BR/project_structure.md
@@ -0,0 +1,23 @@
+# Project Structure
+
+When it comes to making electron apps, project structure is a little different. If you have used the official [`vuejs-templates/webpack`](https://github.com/vuejs-templates/webpack) setup before, then the structure should feel quite familiar. The documentation in this section attempts to explain a general overview of how the boilerplate works and the differences when your application in built.
+
+### Single `package.json` Setup
+
+There was a time not too long ago where a two `package.json` setup was neccessary, but thanks to efforts from [@electron-userland](https://github.com/electron-userland), both [`electron-packager`](https://github.com/electron-userland/electron-packager) and [`electron-builder`](https://github.com/electron-userland/electron-builder) now fully support a single `package.json` setup.
+
+#### `dependencies`
+
+These dependencies **will** be included in your final production app. So if your application needs a certain module to function, then install it here!
+
+#### `devDependencies`
+
+These dependencies **will not** be included in your final production app. Here you can install modules needed specifically for development like build scripts, `webpack` loaders, etc.
+
+#### Installing Native NPM Modules
+
+We need to make sure our native npm modules are built against electron. To do that, we can use [`electron-rebuild`](https://github.com/electron/electron-rebuild), but to make things simpler, it is highly recommended to use [`electron-builder`](https://github.com/electron-userland/electron-builder) for your build tool as a lot of these tasks are handled for you.
+
+### On the subject of the `main` process
+
+During development you may notice `src/main/index.dev.js`. This file is used specifically for development and is used to install dev-tools. This file should not have to be modified, but can be used to extend your development needs. Upon building, `webpack` will step in and create a bundle with `src/main/index.js` as its entry file.
diff --git a/docs/pt_BR/renderer-process.md b/docs/pt_BR/renderer-process.md
new file mode 100644
index 00000000..9970228d
--- /dev/null
+++ b/docs/pt_BR/renderer-process.md
@@ -0,0 +1,53 @@
+# Processo de Renderização
+
+> Since Electron uses Chromium for displaying web pages, Chromium’s multi-process architecture is also used. Each web page in Electron runs in its own process, which is called the renderer process.
+>
+> In normal browsers, web pages usually run in a sandboxed environment and are not allowed access to native resources. Electron users, however, have the power to use Node.js APIs in web pages allowing lower level operating system interactions.
+
+**From the **[**Electron Documentation**](http://electron.atom.io/docs/tutorial/quick-start/#renderer-process)
+
+---
+
+## On the subject of `vue` and `vuex`
+
+### vue components
+
+If you are unfamiliar with Vue components, please give [this](http://vuejs.org/v2/guide/single-file-components.html) a read. Using components gives our large complex applications more organization. Each component has the ability to encapsulate its own CSS, template, and JavaScript functionality.
+
+Components are stored in `src/renderer/components`. When creating child components, a common organization practice is to place them inside a new folder with the name of its parent component. This is especially useful when coordinating different routes.
+
+```
+src/renderer/components
+├─ ParentComponentA
+│ ├─ ChildComponentA.vue
+│ └─ ChildComponentB.vue
+└─ ParentComponentA.vue
+```
+
+### vue routes
+
+For more information about `vue-router` click [here](https://github.com/vuejs/vue-router). In short, it is encouraged to use `vue-router` as creating a Single Page Application is much more practical when making electron applications. Do you really want to manage a bunch of BrowserWindows and then communicating information between everything? Probably not.
+
+Routes are held in `src/renderer/router/index.js` and defined like so...
+
+```js
+{
+ path: '',
+ name: '',
+ component: require('@/components/View')
+}
+```
+
+...where both `` and `` are variables. These routes are then attached to the component tree using the `` directive in `src/renderer/App.vue`.
+
+##### Notice
+
+When using `vue-router`, do not use [**HTML5 History Mode**](http://router.vuejs.org/en/essentials/history-mode.html). This mode is strictly meant for serving files over the `http` protocol and does not work properly with the `file` protocol that electron serves files with in production builds. The default `hash` mode is just what we need.
+
+### vuex modules
+
+Describing `vuex` is not the easiest thing to do, so please read [this](http://vuex.vuejs.org/en/intro.html) for a better understanding of what problem it tries to solve and how it works.
+
+electron-vue takes advantage of `vuex`'s module structure to create multiple data stores and are saved in `src/renderer/store/modules`.
+
+Having multiple data stores can be great for organization, but can also be annoying to have to import each and every one. But don't fret, as `src/renderer/store/modules/index.js` does the dirty work for us! This little script let's `src/renderer/store/index.js` import all of our modules in a one-shot manner. If all that didn't make since, just know you can easily duplicate the given `Counter.js` module and it will be loaded in "magically".
diff --git a/docs/pt_BR/savingreading-local-files.md b/docs/pt_BR/savingreading-local-files.md
new file mode 100644
index 00000000..0c445fb9
--- /dev/null
+++ b/docs/pt_BR/savingreading-local-files.md
@@ -0,0 +1,41 @@
+# Read & Write Local Files
+
+One great benefit of using `electron` is the ability to access the user's file system. This enables you to read and write files on the local system. To help avoid Chromium restrictions and writing to your application's internal files, make sure to take use of `electron`'s APIs, specifically the [`app.getPath(name)`](https://electron.atom.io/docs/api/app/#appgetpathname) function. This helper method can get you file paths to system directories such as the user's desktop, system temporary files, etc.
+
+### Use Case
+
+Let's say we want to have a local database store for our application. In this example we'll demonstrate with [`nedb`](https://github.com/louischatriot/nedb).
+
+```bash
+yarn add nedb # or npm install nedb --save
+```
+
+**src/renderer/datastore.js**
+
+Here we setup NeDB and point it to our `userData` directory. This space is reserved specifically for our application, so we can have confidence other programs or other user interactions should not tamper with this file space. From here we can import `datastore.js` in our `renderer` process and consume it.
+
+```js
+import Datastore from 'nedb'
+import path from 'path'
+import { remote } from 'electron'
+
+export default new Datastore({
+ autoload: true,
+ filename: path.join(remote.app.getPath('userData'), '/data.db')
+})
+```
+
+**src/renderer/main.js**
+
+To take this a step further, we can then import our datastore into `src/renderer/main.js` and attach it to the Vue prototype. Doing so, we are now able to access the datastore API through the usage of `this.$db` in all component files.
+
+```js
+import db from './datastore'
+
+/* Other Code */
+
+Vue.prototype.$db = db
+```
+
+
+
diff --git a/docs/pt_BR/testing.md b/docs/pt_BR/testing.md
new file mode 100644
index 00000000..bcf7acb4
--- /dev/null
+++ b/docs/pt_BR/testing.md
@@ -0,0 +1,30 @@
+# Testing
+
+electron-vue supports both unit testing and end-to-end testing for the `renderer` process and is heavily inspired by the testing setup provided with the official `vuejs-templates/webpack` boilerplate. During `vue-cli` scaffolding you will have the option to include testing support.
+
+## [Unit testing](unittesting.md)
+
+Run unit tests with Karma + Mocha
+
+```bash
+npm run unit
+```
+
+## [End-to-end testing](end-to-end_testing.md)
+
+Run end-to-end tests with Spectron + Mocha
+
+```bash
+npm run e2e
+```
+
+## Running all tests
+
+```bash
+npm test
+```
+
+### On the subject of CI testing
+
+If your decided to use `electron-builder` as your build tool when scaffolding, then you can easily test your application on both Travis CI & AppVeyor for `darwin`, `linux`, and `win32`. Inside both `.travis.yml` and `appveyor.yml` you will find commented sections you can quickly un-comment to enable testing. Make sure to read up on [**Automated Deployments using CI**](/using-electron-builder.md#automated-deployments-using-ci)** **for further information.
+
diff --git a/docs/pt_BR/unittesting.md b/docs/pt_BR/unittesting.md
new file mode 100644
index 00000000..9ae6b85f
--- /dev/null
+++ b/docs/pt_BR/unittesting.md
@@ -0,0 +1,42 @@
+# Unit Testing
+
+electron-vue makes use of the [Karma](https://karma-runner.github.io/1.0/index.html) test runner and the [Mocha](https://mochajs.org/) test framework \(with [Chai](http://chaijs.com/)\) for unit testing.
+
+Both Mocha and Chai are integrated using `karma-mocha` and `karma-chai` respectively, so all APIs such as `expect` are globally available in test files.
+
+### Running Tests
+
+```bash
+# Begin Karma
+npm run unit
+```
+
+### File Structure
+
+```
+my-project
+├─ test
+| ├─ unit
+│ │ ├─ specs/
+│ │ ├─ index.js
+└─ └─ └─ karma.conf.js
+```
+
+**For the most part, you can ignore both **`index.js`** and **`karma.conf.js`** and focus solely on writing **`specs/`**.**
+
+#### `specs/`
+
+Inside this directory is where actual tests are written. Thanks to the power of webpack, you have full access to ES2015 and supported loaders.
+
+#### `index.js`
+
+This is the entry file used by `karma-webpack`. The purpose of this file is to gather all test and source code in a "one-shot" manner.
+
+#### `karma.conf.js`
+
+Here you will find the actual `karma` configuration, set up with spec/coverage reporters. Further customization can be made in accordance to the [official karma documentation](http://karma-runner.github.io/1.0/config/configuration-file.html).
+
+### Mocking Dependencies
+
+electron-vue comes with [`inject-loader`](https://github.com/plasticine/inject-loader) installed by default. For usage with Vue component files see [`vue-loader` docs on testing with mocks](http://vue-loader.vuejs.org/en/workflow/testing-with-mocks.html).
+
diff --git a/docs/pt_BR/using-electron-builder.md b/docs/pt_BR/using-electron-builder.md
new file mode 100644
index 00000000..4185d22e
--- /dev/null
+++ b/docs/pt_BR/using-electron-builder.md
@@ -0,0 +1,87 @@
+# Using [`electron-builder`](https://github.com/electron-userland/electron-builder)
+
+All builds produced by `electron-builder` can be found within the `build` directory.
+
+#### Building
+
+```bash
+npm run build
+```
+
+#### Building unpacked directory
+
+Produce simple executable without full installer. Useful for quick testing.
+
+```bash
+npm run build:dir
+```
+
+### Default building configuration
+
+Further customization can be made at `package.json` in accordance to `electron-builders`'s options found [here](https://github.com/electron-userland/electron-builder/wiki/Options).
+
+```js
+"build": {
+ "productName": "ElectronVue",
+ "appId": "org.simulatedgreg.electron-vue",
+ "dmg": {
+ "contents": [
+ {
+ "x": 410,
+ "y": 150,
+ "type": "link",
+ "path": "/Applications"
+ },
+ {
+ "x": 130,
+ "y": 150,
+ "type": "file"
+ }
+ ]
+ },
+ "directories": {
+ "output": "build"
+ },
+ "files": [
+ "dist/electron",
+ "node_modules/",
+ "package.json"
+ ],
+ "mac": {
+ "icon": "build/icons/icon.icns"
+ },
+ "win": {
+ "icon": "build/icons/icon.ico"
+ },
+ "linux": {
+ "icon": "build/icons"
+ }
+}
+```
+
+## Automated Deployments using CI
+
+When using electron-vue's `electron-builder` configuration, you are also provided a `appveyor.yml` and `.travis.yml` for automated deployments. Both config files are setup for building your electron application and pushing artifacts to a GitHub release, Bintray, etc. Travis CI is used to build both `linux` and `darwin` \(macOS\) while AppVeyor is used to build `win32`. Both services are free for OSS projects.
+
+#### Setting up Travis CI/AppVeyor
+
+1. Create an account over at [Travis CI](https://travis-ci.org/getting_started) / [AppVeyor](https://www.appveyor.com/)
+2. Link your GitHub repository that has your electron-vue project
+3. Visit [https://github.com/settings/tokens](https://github.com/settings/tokens) and hit **Generate new token **\(the same token can be used for both Travis CI & AppVeyor\)
+ 1. Set a **Token description**
+ 2. Check the **public\_repo **scope
+ 3. Hit **Generate token**
+4. Copy your new token and save for later
+5. Open your repository settings on Travis CI / AppVeyor to add a new **Environment Variable**
+ 1. Set the name of the variable to `GH_TOKEN`
+ 2. Set the value of the variable to the GitHub access token you just created
+ 3. **Save** the new variable and ensure encryption is enabled
+
+At this point, everything should be setup. Travis CI/AppVeyor by default will watch for any pushes to your `master` branch. When a push is made, Travis CI/AppVeyor will then clone down your repository to its server and begin the build process. During the final stages, `electron-builder` with see the `GH_TOKEN` environment variable and create a draft release and upload the artifacts to your public GitHub repository. From this point, you can edit the draft release and then publish it to the world. After publishing your release, make sure future releases are marked with a new version number by updating your `package.json`.
+
+#### Auto Updating
+
+Enabling your application to receive automatic updates is a super nice feature to have, but know that [**Code Signing**](https://github.com/electron-userland/electron-builder/wiki/Code-Signing) is required. You can setup code signing by adding a few more environment variables based on what `electron-builder` needs described [here](https://github.com/electron-userland/electron-builder/wiki/Code-Signing). Once you have your certificates setup, you can then install `electron-updater` and comment out the chunk of code at the bottom of `src/main/index.js` to enable auto updating.
+
+If you are like most people and do not have a fancy code signing certificate, then you can always use the GitHub API to check for new releases. When a new release is detected, provide a notification within your application to point users to a download page where they can download and install the new build. Thanks to the amazing installer that `electron-builder` provides, user's do not have to uninstall the current version and the new installation will replace the old while still persisting any web storage or `userData` files.
+
diff --git a/docs/pt_BR/using-electron-packager.md b/docs/pt_BR/using-electron-packager.md
new file mode 100644
index 00000000..5c3b441f
--- /dev/null
+++ b/docs/pt_BR/using-electron-packager.md
@@ -0,0 +1,71 @@
+# Using [`electron-packager`](https://github.com/electron-userland/electron-packager)
+
+All builds produced by `electron-packager` can be found within the `build` folder.
+
+#### Building for all platforms
+
+Please know that not all Operating Systems can build for all other platforms.
+
+```bash
+npm run build
+```
+
+#### Building for a specific platform
+
+Platforms include `darwin`, `mas`, `linux` and `win32`.
+
+```bash
+# build for darwin (macOS)
+npm run build:darwin
+```
+
+#### Cleaning
+
+Delete all builds from `build`.
+
+```bash
+npm run build:clean
+```
+
+### A note for non-Windows users
+
+If you are wanting to build for Windows **with a custom icon** using a non-Windows platform, you must have [wine](https://www.winehq.org/) installed. [More Info](https://github.com/electron-userland/electron-packager#building-windows-apps-from-non-windows-platforms).
+
+### Default building configurations
+
+Further customization can be made at `.electron-vue/build.config.js` in accordance to `electron-packager`'s options found [here](https://github.com/electron-userland/electron-packager/blob/master/docs/api.md#options). The name applied to your built application is set with the `productName` value in your `package.json`.
+
+```js
+{
+ // Target 'x64' architecture
+ arch: 'x64',
+
+ // Compress app using 'electron/asar'
+ asar: true,
+
+ // Directory of the app
+ dir: path.join(__dirname, '../'),
+
+ // Set electron app icon
+ // File extensions are added based on platform
+ //
+ // If building for Linux, please read
+ // https://github.com/electron-userland/electron-packager/blob/master/docs/api.md#icon
+ icon: path.join(__dirname, '../build/icons/icon'),
+
+ // Ignore files that would bloat final build size
+ ignore: /(^\/(src|test|\.[a-z]+|README|yarn|static|dist\/web))|\.gitkeep/,
+
+ // Save builds to `builds`
+ out: path.join(__dirname, '../build'),
+
+ // Overwrite existing builds
+ overwrite: true,
+
+ // Environment variable that sets platform
+ platform: process.env.BUILD_TARGET || 'all'
+}
+```
+
+
+
diff --git a/docs/pt_BR/using-static-assets.md b/docs/pt_BR/using-static-assets.md
new file mode 100644
index 00000000..65769413
--- /dev/null
+++ b/docs/pt_BR/using-static-assets.md
@@ -0,0 +1,53 @@
+# Using Static Assets
+
+If you have used the official `vuejs-templates/webpack` boilerplate before, then you should be familiar with the `static/` directory. It is here where you can place static assets that both the `main` and `renderer` process can consume. Using these assets within your Vue application is simple, but usage with `fs` and other modules that need a full path can be a little tricky. Thankfully, electron-vue provides a `__static` variable that yields the path to the `static/` directory in both development and production.
+
+### Use Case within `src` tags in Vue Components
+
+Let's say I have a component that loads an image, but the image's path isn't known until some other task is completed. To keep things simple, let's just use a `data` variable to bind our ``'s src.
+
+**SomeComponent.vue**
+
+```html
+
+
+
+
+
+```
+
+Here `webpack` will not bundle the `unsplash.png` image and the application will look inside the `static/imgs/unsplash.png` directory for the asset. Thanks to `vue-loader`, all of the dirty work is done for us.
+
+### Use Case within JS with `fs`,`path` and `__static`
+
+Let's say we have a static asset that we need to read into our application using `fs`, but how do we get a reliable path, in both development and production, to the `static/` directory? electron-vue provides a global variable named `__static` that will yield a proper path to the `static/` directory. Here's how we can use it to read a simple text file in both development and production.
+
+**static/someFile.txt**
+
+```txt
+foobar
+```
+
+**SomeFile.js \(**`main`** or **`renderer`** process\)**
+
+```js
+import fs from 'fs'
+import path from 'path'
+
+let fileContents = fs.readFileSync(path.join(__static, '/someFile.txt'), 'utf8')
+
+console.log(fileContents)
+// => "foobar"
+```
+
+Please note that in production all files are packed with [`asar`](https://github.com/electron/asar) by default as it is highly recommended. Because of this, assets within the `static/` folder can only be accessed within `electron` since it is aware of this behavior. So if you are planning to distribute files to your users, that can for example open in a external program, you would first need to copy those assets from your application into the user's document space or desktop. From there you could use the [`shell.openItem()`](https://electron.atom.io/docs/api/shell/#shellopenitemfullpath) electron API to open those assets.
+
+An alternative method to this situation would be to configure `electron-packager`/`electron-builder` to set specific files to "unpack" from the `asar` archive in production. electron-vue has no plans to support this method; any issues related to this or how to set this up will be closed.
+
diff --git a/docs/pt_BR/using_css_frameworks.md b/docs/pt_BR/using_css_frameworks.md
new file mode 100644
index 00000000..f4ca7671
--- /dev/null
+++ b/docs/pt_BR/using_css_frameworks.md
@@ -0,0 +1,34 @@
+# Using CSS Frameworks
+
+Although this may seem like a no brainer, I'd suggest you import your third-party CSS libraries into webpack using the [`style-loader`](https://github.com/webpack/style-loader), which is already setup for you.
+
+## Use Case
+
+Say you want to use [bootstrap](http://getbootstrap.com/), [bulma](http://bulma.io/), or [materialize](http://materializecss.com/) for your application. Go ahead and install your library from `npm` like you normally would, but instead of attaching the asset to `index.ejs` we will import the CSS in our JavaScript, specifically in `src/renderer/main.js`.
+
+#### Example
+
+Let's install `bulma`
+
+```bash
+npm install bulma --save
+```
+
+Then inside `src/renderer/main.js` let's add this line.
+
+```bash
+import 'bulma/css/bulma.css'
+```
+
+Alternatively, you can also include `bulma` from inside a component file.
+
+**App.vue**
+
+```html
+
+```
+
+Now `webpack` will know to load in `bulma` for our application and make it available in our production builds.
+
diff --git a/docs/pt_BR/using_pre-processors.md b/docs/pt_BR/using_pre-processors.md
new file mode 100644
index 00000000..05f2682d
--- /dev/null
+++ b/docs/pt_BR/using_pre-processors.md
@@ -0,0 +1,82 @@
+# Using Pre-Processors
+
+One of the great benefits of using [`vue-loader`](https://github.com/vuejs/vue-loader) with [`webpack`](https://github.com/webpack/webpack) is the ability to pre-process your HTML/CSS/JS directly in your Vue components files without much effort at all. For more information about this check [**here**](https://vuejs.org/v2/guide/single-file-components.html).
+
+## Use Case
+
+Let's say we need to use Sass/SCSS for pre-processing our CSS. First, we need to install the proper `webpack` loader to handle this syntax.
+
+#### Installing `sass-loader`
+
+```bash
+npm install --save-dev sass-loader node-sass
+```
+
+Once the loader we need is installed, everything is pretty much finished. `vue-loader` will magically take care of the rest. Now we can easily add `lang="sass"` or `lang="scss"` to our Vue component files. Notice we also installed `node-sass` as it is a dependent package for `sass-loader`.
+
+#### Applying the `lang` attribute
+
+So...
+
+```html
+
+```
+
+...now becomes...
+
+```html
+
+```
+
+The same principles apply for just about any other pre-processor. So maybe you need coffeescript for your JS? Simply install the [coffeescript-loader](https://github.com/webpack/coffee-loader) and apply the `lang="coffeescript"` attribute to your `
+