readme:
  headers:
    installation:
      title: "Local installation"
      body: |
        Assuming you've just cloned the repo, run this script to setup the project in your
        machine:

            $ ./bin/setup

        It assumes you have a machine equipped with Ruby, Node.js, Docker and make.

        The script will do the following among other things:

        - Install the dependecies
        - Create a docker container for your database
        - Prepare your database
        - Adds heroku remotes

        After the app setup is done you can run it with [Heroku Local]

            $ heroku local

        [Heroku Local]: https://devcenter.heroku.com/articles/heroku-local
    webpack:
      title: "Development"
      body: |
        For hot-reloading and fast webpacker compilation you need to run webpack's dev server along with the rails server:

            $ ./bin/webpack-dev-server

        Running the dev server will also solve problems with the cache not refreshing between changes and provide better error messages if something fails to compile.

        For even faster in-place component refreshing (with no page reloads), you can enable Hot Module Reloading in `config/webpacker.yml`

            development:
              dev_server:
                hmr: true
    ci:
      title: "Continuous Integrations"
      body: |
        The project is setup to run tests
        in [CircleCI](https://circleci.com/gh/platanus/<%= get(:dasherized_app_name) %>/tree/master)

        You can also run the test locally simulating the production environment using docker.
        Just make sure you have docker installed and run:

            bin/cibuild
    deployment:
      title: "Deployment"
      body: |
        This project is pre-configured to be (easily) deployed to Heroku servers, but needs you to have the Potassium binary installed. If you don't, then run:

            $ gem install potassium

        Then, make sure you are logged in to the Heroku account where you want to create the app and run

            $ potassium install heroku --force

        this will create the app on heroku, create a pipeline and link the app to the pipeline.

        You'll still have to manually log in to the heroku dahsboard, go to the new pipeline and 'configure automatic deploys' using Github
        You can run the following command to open the dashboard in the pipeline page

            $ heroku pipelines:open

        ![Hint](https://cloud.githubusercontent.com/assets/313750/13019759/fa86c8ca-d1af-11e5-8869-cd2efb5513fa.png)

        Remember to connect each stage to the corresponding branch:

        1. Staging -> Master
        2. Production -> Production

        That's it. You should already have a running app and each time you push to the corresponding branch, the system will (hopefully) update accordingly.
    style_guide:
      title: "Style Guides"
      body: |
        Style guides are enforced through a CircleCI [job](.circleci/config.yml) with [reviewdog](https://github.com/reviewdog/reviewdog) as a reporter, using per-project dependencies and style configurations.
        Please note that this reviewdog implementation requires a GitHub user token to comment on pull requests. A token can be generated [here](https://github.com/settings/tokens), and it should have at least the `repo` option checked.
        The included `config.yml` assumes your CircleCI organization has a context named `org-global` with the required token under the environment variable `REVIEWDOG_GITHUB_API_TOKEN`.

        The project comes bundled with configuration files available in this repository.

        Linting dependencies like `rubocop` or `rubocop-rspec` must be locked in your `Gemfile`. Similarly, packages like `eslint` or `eslint-plugin-vue` must be locked in your `package.json`.

        You can add or modify rules by editing the [`.rubocop.yml`](.rubocop.yml), [`.eslintrc.json`](.eslintrc.json) or [`.stylelintrc.json`](.stylelintrc.json) files.

        You can (and should) use linter integrations for your text editor of choice, using the project's configuration.
    mailing:
      title: "Sending Emails"
      body: |
        The emails can be send through the gem `<%= get(:mailer_gem_name) %>` using the `<%= get(:mailer_delivery_method) %>` delivery method.
        All the `action_mailer` configuration can be found at `config/mailer.rb`, which is loaded only on production environments.

        All emails should be sent using background jobs, by default we install `sidekiq` for that purpuse.

        #### Testing in staging

        If you add the `EMAIL_RECIPIENTS=` environmental variable, the emails will be intercepted and redirected to the email in the variable.
    internal_dependencies:
      title: "Internal dependencies"
      sections:
        devise:
          title: "Authentication"
          body: "We are using the great [Devise](https://github.com/plataformatec/devise) library by [PlataformaTec](http://plataformatec.com.br/)"
        active_storage:
          title: "File Storage"
          body: "For managing uploads, this project uses [Active Storage](https://github.com/rails/rails/tree/master/activestorage)."
        shrine:
          title: "File Storage"
          body: "For managing uploads, this project uses [Shrine](https://github.com/shrinerb/shrine)."
        pundit:
          title: "Authorization"
          body: "For defining which parts of the system each user has access to, we have chosen to include the [Pundit](https://github.com/elabs/pundit) gem, by [Elabs](http://elabs.se/)."
        delayed_job:
          title: "Queue System"
          body: "For managing tasks in the background, this project uses [DelayedJob](https://github.com/collectiveidea/delayed_job)"
        sidekiq:
          title: "Queue System"
          body: "For managing tasks in the background, this project uses [Sidekiq](https://github.com/mperham/sidekiq)"
        sidekiq_scheduler:
          title: "Scheduled Tasks"
          body: "To schedule recurring work at particular times or dates, this project uses [Sidekiq Scheduler](https://github.com/moove-it/sidekiq-scheduler)"
        sentry:
          title: "Error Reporting"
          body: "To report our errors we use [Sentry](https://github.com/getsentry/raven-ruby)"
        draper:
          title: "Presentation Layer"
          body: "This project uses [Draper](https://github.com/drapergem/draper) to add an object-oriented layer of presentation logic"
        power_types:
          title: "Rails pattern enforcing types"
          body: "This projects uses [Power-Types](https://github.com/platanus/power-types) to generate Services, Commands, Utils and Values."
        power_api:
          title: "API Support"
          body: "This projects uses [Power API](https://github.com/platanus/power_api). It's a Rails engine that gathers a set of gems and configurations designed to build incredible REST APIs."
        graphql:
          title: "API Support"
          body: "This projects uses [graphql-ruby](https://graphql-ruby.org/) to generate a GraphQL API."
        active_admin:
          title: "Administration"
          body: |
            This project uses [Active Admin](https://github.com/activeadmin/activeadmin) which is a Ruby on Rails framework for creating elegant backends for website administration.
            <% if get(:vue_admin) %>
            This project supports Vue inside ActiveAdmin
            - The main package is located in `app/javascript/packs/admin_application.js`, here you will declare the components you want to include in your ActiveAdmin views as you would in a normal Vue App.
            - Additionally, to be able to use Vue components as [Arbre](https://github.com/activeadmin/arbre) Nodes the component names are also declared in `config/initializers/active_admin.rb`
            - The generator includes an example component called `admin_component`, you can use this component inside any ActiveAdmin view by just writing `admin_component` as you would with any `html` tag.
              - For example:
                ```
                admin_component(class:"myCustomClass",id:"myCustomId") do
                  admin_component(id:"otherCustomId")
                end
                ```
              - (Keep in mind that the example works with ruby blocks because `AdminComponent` has a `<slot>` tag defined, therefore children can be added to the component)
            - The integration supports passing props to the components and converts them to their corresponing javascript objects.
              - For example, the following works
              ```
              admin_component(testList:[1,2,3,4],testObject:{"name":"Vue component"})
              ```
              - You can also use **any** vue bindings such as `v-for` , `:key` etc.
            <% end %>
    seeds:
      title: "Seeds"
      body: |
        To populate your database with initial data you can add, inside the `/db/seeds.rb` file, the code to generate **only the necessary data** to run the application.
        If you need to generate data with **development purposes**, you can customize the `lib/fake_data_loader.rb` module and then to run the `rake load_fake_data` task from your terminal.