natra 0.0.7 → 2.0.0

data/README.md

@@ -1,61 +1,167 @@
 # Natra
-[![Coverage Status](https://coveralls.io/repos/github/thirunjuguna/natra/badge.svg?branch=master)](https://coveralls.io/github/thirunjuguna/natra?branch=master)
-[![Build Status](https://travis-ci.com/thirunjuguna/natra.svg?branch=master)](https://travis-ci.com/thirunjuguna/natra) 
-[![Maintainability](https://api.codeclimate.com/v1/badges/e76bbd27a1c4cb8911ae/maintainability)](https://codeclimate.com/github/thirunjuguna/natra/maintainability)
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/450f5da9d33d4adca897563ec759c1b2)](https://www.codacy.com/app/thirunjuguna/natra?utm_source=github.com&utm_medium=referral&utm_content=thirunjuguna/natra&utm_campaign=Badge_Grade)
+
+[![CI](https://github.com/jamesnjuguna0419/natra/actions/workflows/ci.yml/badge.svg)](https://github.com/jamesnjuguna0419/natra/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/natra.svg)](https://rubygems.org/gems/natra)
+[![Downloads](https://img.shields.io/gem/dt/natra.svg)](https://rubygems.org/gems/natra)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.txt)
+
+Natra is a command line generator for small Sinatra services. `natra new` creates a JSON API skeleton with ActiveRecord, PostgreSQL, Puma, RSpec, RuboCop and a Docker setup. Inside that app, `natra model`, `natra controller`, `natra scaffold` and `natra service_object` add models with migrations, controllers with views, and plain Ruby service objects.
+
+## Requirements
+
+- Ruby 3.3 or newer to run natra and the apps it generates.
+- PostgreSQL for the generated app's database.
+- Docker with Compose v2, only if you want the generated Docker setup. `natra new` runs `docker compose build --pull` as its last step. Without Docker that step prints an error, but the app is still generated and you can run it locally.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+```sh
+gem install natra
+```
+
+## Quick start
+
+```sh
+natra new my-api
+cd my-api
+```
+
+### Run with Docker
+
+`secrets.env` holds the database settings for the `web` and `db` containers.
 
-```ruby
-gem 'natra'
+```sh
+docker compose run --rm web bin/setup
+docker compose up
 ```
 
-And then execute:
+### Run locally
 
-    $ bundle
+Start PostgreSQL first. Without `DATABASE_URL`, `config/database.yml` uses the databases `development_my_api` and `test_my_api` (override them with `DEV_DATABASE` and `TEST_DATABASE`).
 
-Or install it yourself as:
+```sh
+bundle install
+bundle exec rake db:create db:migrate
+bundle exec puma -C config/puma.rb
+```
 
-    $ gem install natra
+Either way the app listens on http://localhost:9292. Run its specs with `bundle exec rspec` after `RACK_ENV=test bundle exec rake db:create db:migrate`.
 
 ## Commands
+
+| Command | What it does | Options |
+| --- | --- | --- |
+| `natra new APP_PATH` | Creates a new Sinatra application in `APP_PATH` | `--git` runs `git init` and `git add .`<br>`--bundle` runs `bundle install`<br>`--redis` adds the redis gem, `config/redis.yml` and a Redis initializer<br>`--capistrano` runs `cap install`<br>`--rvm` writes `.ruby-version` (the Ruby running natra) and `.ruby-gemset`, and skips `--bundle` |
+| `natra model NAME [field:type ...]` | Generates a model and a migration that creates its table | `--no-migration` skips the migration |
+| `natra controller NAME` | Generates a controller with routes, mounts it in `config.ru` and adds its views | `--no-views` skips the views |
+| `natra scaffold NAME [field:type ...]` | Runs `model` and `controller` for `NAME` | |
+| `natra service_object NAME` | Generates a service object in `app/services` | |
+| `natra -v`, `natra --version` | Prints the natra version | |
+| `natra help [COMMAND]` | Lists the commands, or describes one | |
+
+Run `model`, `controller`, `scaffold` and `service_object` from the root of a generated app.
+
+Naming rules:
+
+- `APP_PATH` is lowercased, and characters other than letters, `-` and `_` are dropped. `natra new My-Blog` creates `my-blog`.
+- Fields are written `name:type`, for example `title:string body:text published:boolean`. The type defaults to `string`, so `title` is the same as `title:string`.
+- Models are singular (a plural name is singularized with a warning). Controllers and service objects are pluralized: `natra controller post` creates `PostsController`, and `natra service_object payment` creates `PaymentsService`.
+
+## What you get
+
+`natra new blog` creates:
+
 ```
-natra -v              # Show Natra version number
-natra help [COMMAND]  # Describe available commands or one specific command
-natra new APP-NAME    # Creates a new Sinatra application
-natra model NAME      # Generate a model
-natra controller NAME # Generate a controller
-natra scaffold NAME   # Generate a model with its associated views and controllers
+blog/
+├── .gitignore
+├── .rspec
+├── .rubocop.yml
+├── Dockerfile
+├── Gemfile
+├── Guardfile
+├── README.md
+├── Rakefile
+├── config.ru
+├── docker-compose.yml
+├── secrets.env
+├── app/
+│   ├── controllers/application_controller.rb
+│   ├── models/
+│   ├── services/
+│   └── views/
+│       ├── layout.erb
+│       └── welcome.erb
+├── bin/setup
+├── config/
+│   ├── database.yml
+│   ├── environment.rb
+│   ├── puma.rb
+│   └── initializers/oj.rb
+├── db/
+│   ├── migrate/YYYYMMDD0000_add_extensions.rb
+│   └── seeds.rb
+├── lib/
+├── public/favicon.ico
+└── spec/
+    ├── application_controller_spec.rb
+    ├── spec_helper.rb
+    └── support/
 ```
-The controller generator also have an optional views flag `--no-views` to create controllers without views.
 
-## Using Natra
+The Gemfile uses Sinatra 4, ActiveRecord 8.1 through sinatra-activerecord, pg, Puma, Oj, rack-timeout and Scout APM, with RSpec, Capybara, FactoryBot, Faker, DatabaseCleaner, SimpleCov and Guard for tests. The first migration enables the `hstore`, `uuid-ossp` and `pgcrypto` PostgreSQL extensions. The Rakefile loads the sinatra-activerecord tasks, such as `db:create`, `db:migrate`, `db:seed` and `db:create_migration`.
 
-To generate your app:
+`natra scaffold post title:string body:text` then creates:
 
-    natra new APP-NAME
-
-After natra is done generating your app, run `bundle install` from your app's directory:
+```
+app/models/post.rb                          # class Post < ActiveRecord::Base
+db/migrate/YYYYMMDDHHMMSS_create_posts.rb   # posts table with a UUID id, title, body and timestamps
+app/controllers/posts_controller.rb         # index, new, create, show, edit, update and delete routes
+app/views/posts/index.html.erb
+app/views/posts/new.html.erb
+app/views/posts/show.html.erb
+app/views/posts/edit.html.erb
+```
 
-    cd APP-NAME
-    bundle install
+It also adds `use PostsController` to `config.ru`.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Natra is developed on Ruby 3.3.10 (see `.ruby-version`). CI runs on Ruby 3.3 and 3.4.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```sh
+bin/setup                    # install dependencies
+bundle exec rspec            # run the specs
+bundle exec rubocop          # lint
+bin/console                  # Pry session with natra loaded
+```
 
-## Contributing
+SimpleCov measures line and branch coverage and writes a report to `coverage/`. CI requires 100% line and branch coverage. Run `CI=true bundle exec rspec` to apply the same check locally.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/thirunjuguna/natra. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+To release a new version:
 
-## License
+1. Update the version number in `lib/natra/version.rb`.
+2. Move the entries under "Unreleased" in [CHANGELOG.md](CHANGELOG.md) to a section for the new version.
+3. Commit, then run `bundle exec rake release`. This builds the gem, tags the version, pushes the commit and tag, and pushes the gem to [rubygems.org](https://rubygems.org/gems/natra).
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+## Changelog
+
+Notable changes are listed in [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jamesnjuguna0419/natra.
+
+1. Open an issue first for larger changes, so the approach can be agreed before you write code.
+2. Fork the repository and create a branch from `master`.
+3. Make your change and add or update specs for it. If you change what a generator produces, update its spec under `spec/natra/generators/`.
+4. Check that `CI=true bundle exec rspec` passes with 100% line and branch coverage, and that `bundle exec rubocop` reports no offenses.
+5. Add a line to the "Unreleased" section of [CHANGELOG.md](CHANGELOG.md).
+6. Open a pull request that explains what changed and why.
 
 ## Code of Conduct
 
-Everyone interacting in the Natra project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/thirunjuguna/natra/blob/master/CODE_OF_CONDUCT.md).
+This project is intended to be a safe, welcoming space for collaboration. Everyone interacting in the Natra project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [Code of Conduct](CODE_OF_CONDUCT.md), which is adapted from the [Contributor Covenant](https://www.contributor-covenant.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -1,5 +1,7 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec

data/bin/console

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'natra'
 require 'pry'

data/bin/natra

@@ -1,4 +1,6 @@
-#!/usr/bin/env bash
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
-require "natra"
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'natra'
 Natra::CLI.start

data/lib/extensions/string.rb

@@ -1,34 +1,38 @@
+# frozen_string_literal: true
+
 module Natra
   module Extensions
+    # Naming helpers mixed into String for turning user input into Ruby names.
     module String
       def camel_case
-        return self.gsub(/^./) { |l| l.capitalize } if !match(/[_-]/)
-        altered_self = self.downcase.capitalize
+        return gsub(/^./, &:capitalize) unless match(/[_-]/)
+
+        altered_self = downcase.capitalize
         altered_self.scan(/[_-][a-zA-Z]/).each { |match| altered_self.gsub!(match, match[1].upcase) }
         altered_self
       end
 
       def camel_case!
-        self.replace camel_case
+        replace camel_case
       end
 
       def directory_name
-        self.downcase.gsub(/[^a-z|\-|\_]/, '')
+        downcase.gsub(/[^a-z|_-]/, '')
       end
 
       def file_name
-        self.gsub(/[\-| ]/, '_').
-             gsub(/([A-Z]+|[A-Z][a-z])/) { |x| "_#{x}" }.
-             sub(/^_/, "").
-             gsub(/_{2,}+/, "_").
-             downcase
+        gsub(/[-| ]/, '_')
+          .gsub(/([A-Z]+|[A-Z][a-z])/) { |x| "_#{x}" }
+          .sub(/^_/, '')
+          .gsub(/_{2,}+/, '_')
+          .downcase
       end
 
       def file_name!
-        self.replace file_name
+        replace file_name
       end
     end
   end
 end
 
-String.send(:include, Natra::Extensions::String)
+String.include(Natra::Extensions::String)

data/lib/natra/cli.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'thor'
 module Natra
+  # Entry point for the natra executable: maps commands onto generators.
   class CLI < Thor
     desc '-v', 'Show Natra version number'
     map %w[-v --version] => :version
@@ -11,9 +14,11 @@ module Natra
     register Natra::Generators::AppGenerator, 'new', 'new APP_PATH', 'Creates a new Sinatra application'
     register Natra::Generators::ModelGenerator, 'model', 'model NAME', 'Generate a model'
     register Natra::Generators::ControllerGenerator, 'controller', 'controller NAME', 'Generate a controller'
-    register Natra::Generators::ScaffoldGenerator, 'scaffold', 'scaffold NAME', 'Generate a model with its associated views and controllers'
+    register Natra::Generators::ScaffoldGenerator, 'scaffold', 'scaffold NAME',
+             'Generate a model with its associated views and controllers'
+    register Natra::Generators::ServiceGenerator, 'service_object', 'service_object NAME', 'Generate a service object'
 
-    def self.exit_on_failure
+    def self.exit_on_failure?
       true
     end
   end

data/lib/natra/generators/app/app_generator.rb

@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
+require 'shellwords'
 require 'thor/group'
 module Natra
   module Generators
+    # Generates a new Sinatra application skeleton (natra new).
     class AppGenerator < Thor::Group
       include Thor::Actions
+
       desc 'Creates a new Sinatra application'
       argument :name, type: :string, desc: 'The name of the new application'
       class_option :capistrano, type: :boolean, desc: 'Include Capistrano configuration'
       class_option :redis, type: :boolean, desc: 'Include Redis configuration'
-      class_option :rvm, type: :boolean, desc: 'Create .ruby-version (ruby-2.1.0) and .ruby-gemset'
+      class_option :rvm, type: :boolean, desc: 'Create .ruby-version (the Ruby running natra, 3.3+) and .ruby-gemset'
       class_option :bundle, type: :boolean, desc: 'Run bundle after generating the app'
       class_option :git, type: :boolean, desc: 'Initialize a Git repository'
 
       def setup
         @app_path = name.directory_name
         @name     = name.file_name
-        options.each { |key, value| instance_variable_set "@#{key}".to_sym, value }
+        options.each { |key, value| instance_variable_set :"@#{key}", value }
       end
 
       def self.source_root
@@ -22,22 +27,24 @@ module Natra
       end
 
       def create_empty_directories
-        %w[config/initializers lib spec].each {|dir| empty_directory File.join(@app_path, dir)}
+        %w[config/initializers lib spec app/services].each { |dir| empty_directory File.join(@app_path, dir) }
         empty_directory File.join(@app_path, 'db/migrate')
         create_file File.join(@app_path, 'lib', '.keep')
         template 'config/environment.rb', File.join(@app_path, 'config/environment.rb')
       end
 
       def create_seeds_file
-        create_file File.join(@app_path, 'db', 'seeds.rb')
+        create_file File.join(@app_path, 'db', 'seeds.rb'), "# Seed data, loaded by rake db:seed.\n"
       end
 
       def initialize_db
         copy_file('bin/setup', File.join(@app_path, 'bin/setup'))
+        chmod(File.join(@app_path, 'bin/setup'), 0o755)
       end
 
       def uuid_setup
-        template 'db/migrate/add_extensions.rb', File.join(@app_path, "db/migrate/#{Time.now.strftime('%Y%m%d')}0000_add_extensions.rb")
+        template 'db/migrate/add_extensions.rb',
+                 File.join(@app_path, "db/migrate/#{Time.now.strftime('%Y%m%d')}0000_add_extensions.rb")
       end
 
       def create_public_directory
@@ -45,7 +52,7 @@ module Natra
       end
 
       def create_app_directory
-        %w[app/controllers app/views app/models].each {|dir| directory dir, File.join(@app_path, dir)}
+        %w[app/controllers app/views app/models].each { |dir| directory dir, File.join(@app_path, dir) }
       end
 
       def create_app_spec
@@ -60,6 +67,14 @@ module Natra
         template 'config.ru', File.join(@app_path, 'config.ru')
       end
 
+      def create_puma_config
+        copy_file 'config/puma.rb', File.join(@app_path, 'config/puma.rb')
+      end
+
+      def create_oj_initializer
+        copy_file 'config/initializers/oj.rb', File.join(@app_path, 'config/initializers/oj.rb')
+      end
+
       def create_gemfile
         template 'Gemfile', File.join(@app_path, 'Gemfile')
       end
@@ -121,13 +136,13 @@ module Natra
       end
 
       def create_rvm_gemset
-        if @rvm
-          create_file(File.join(@app_path, '.ruby-version'), 'ruby-2.1.0')
-          create_file(File.join(@app_path, '.ruby-gemset'), @app_path)
+        return unless @rvm
+
+        create_file(File.join(@app_path, '.ruby-version'), "ruby-#{RUBY_VERSION}")
+        create_file(File.join(@app_path, '.ruby-gemset'), @app_path)
 
-          @bundle = false
-          puts "You need to run 'bundle install' manually."
-        end
+        @bundle = false
+        puts "You need to run 'bundle install' manually."
       end
 
       def initialize_git_repo
@@ -138,14 +153,12 @@ module Natra
         inside(@app_path) { run('bundle') if @bundle }
       end
 
+      # The Git repository, if any, was created by initialize_git_repo.
       def initialize_app
-        system <<~SCRIPT
-          cd #{@app_path}
-          #{'chmod +x bin/setup'}
-          git init
-          git add .
-          docker-compose build --pull
-        SCRIPT
+        commands = ["cd #{Shellwords.escape(@app_path)}"]
+        commands << 'git add .' if @git
+        commands << 'docker compose build --pull'
+        system commands.join("\n")
       end
     end
   end

data/lib/natra/generators/app/templates/Dockerfile

@@ -1,13 +1,31 @@
-FROM ruby AS base
+FROM ruby:3.3-slim AS base
+
+# build-essential compiles native gems (bcrypt, oj, puma); libpq-dev is needed by pg.
+RUN apt-get update -qq \
+  && apt-get install -y --no-install-recommends build-essential git libpq-dev libyaml-dev \
+  && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /usr/src/app
-RUN gem install bundler
-COPY Gemfile /usr/src/app/
+
+COPY Gemfile Gemfile.lock* ./
+
 FROM base AS development
-RUN bundle install -j5 --without staging production
-COPY . /usr/src/app
+
+RUN bundle install -j5
+
+COPY . .
+
 FROM base AS release
-RUN bundle install -j5 --without development test
-RUN chmod 755 ./usr/src/app
-RUN chmod 755 ./usr/src/app/bin/setup
-COPY . /usr/src/app
-CMD puma
+
+ENV RACK_ENV=production \
+    BUNDLE_WITHOUT=development:test
+
+RUN bundle install -j5
+
+COPY . .
+
+RUN chmod 755 bin/setup
+
+EXPOSE 9292
+
+CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]

data/lib/natra/generators/app/templates/Gemfile

@@ -1,32 +1,38 @@
-source 'http://rubygems.org'
-ruby '2.5.3'
-gem 'bcrypt'
-gem 'coveralls'
-gem 'natra'
-gem 'oj'
-gem 'pg', '~> 0.21.0'
-gem 'puma'
-gem 'rake'
-gem 'rack-timeout'
-gem 'require_all'
-gem 'seed-fu'
-gem 'scout_apm'
-gem 'sinatra'
-gem 'sinatra-activerecord', :require => 'sinatra/activerecord'
-gem 'tux'
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+ruby '~> 3.3'
+
+gem 'activerecord', '~> 8.1'
+gem 'bcrypt', '~> 3.1'
+gem 'oj', '~> 3.16'
+gem 'pg', '~> 1.5'
+gem 'puma', '>= 6.4'
+gem 'rack-timeout', '~> 0.7'
+gem 'rake', '~> 13.0'
+<% if @redis -%>
+gem 'redis', '~> 5.0'
+<% end -%>
+gem 'require_all', '~> 3.0'
+gem 'scout_apm', '~> 6.0'
+gem 'seed-fu', '~> 2.3'
+gem 'sinatra', '~> 4.1'
+gem 'sinatra-activerecord', '~> 2.0', require: 'sinatra/activerecord'
+
 group :development, :test do
-  gem 'pry-byebug'
   gem 'pry'
+  gem 'pry-byebug'
 end
+
 group :test do
-  gem 'awesome_print'
+  gem 'amazing_print'
   gem 'capybara'
-  gem 'database_cleaner'
+  gem 'database_cleaner-active_record'
   gem 'factory_bot'
   gem 'faker'
   gem 'guard-rspec'
   gem 'guard-rubocop'
-  gem 'simplecov'
   gem 'rack-test'
   gem 'rspec'
+  gem 'simplecov', require: false
 end

data/lib/natra/generators/app/templates/Guardfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 guard :rspec, cmd: 'rspec', all_after_pass: true, all_on_start: true do
   require 'guard/rspec/dsl'
   dsl = Guard::RSpec::Dsl.new(self)

data/lib/natra/generators/app/templates/README.md

@@ -1,52 +1,51 @@
 # <%= @name %> service
 
-## Commands
-```
-natra -v              # Show Natra version number
-natra help [COMMAND]  # Describe available commands or one specific command
-natra new APP-NAME    # Creates a new Sinatra application
-natra model NAME      # Generate a model
-natra controller NAME # Generate a controller
-natra scaffold NAME   # Generate a model with its associated views and controllers
-```
-The controller generator also have an optional views flag `--no-views` to create controllers without views.
-
-## Using Natra
+A Sinatra JSON API with ActiveRecord and PostgreSQL, generated by [natra](https://github.com/jamesnjuguna0419/natra).
 
-To generate your app:
+## Running with Docker
 
-    natra new APP-NAME
+The database settings come from `secrets.env`.
 
-After natra is done generating your app, run `bundle install` from your app's directory:
+```sh
+docker compose build
+docker compose run --rm web bin/setup
+docker compose up
+```
 
-    cd APP-NAME
-    bundle install
+The app listens on http://localhost:9292.
 
-## Development
+## Running locally
 
-This project is configured to run in Docker containers facilitated by `docker-compose`. [nib](https://github.com/technekes/nib) is our tool of choice for interacting with `docker-compose` in development.
+You need Ruby 3.3 and a running PostgreSQL server.
 
+```sh
+bundle install
+bundle exec rake db:create db:migrate
+bundle exec puma -C config/puma.rb
+```
 
-### Running the app
+`config/database.yml` reads the database names from `DEV_DATABASE`, `TEST_DATABASE` and `PROD_DATABASE`, and falls back to `development_<%= @name.directory_name %>`, `test_<%= @name.directory_name %>` and `production_<%= @name.directory_name %>`. If `DATABASE_URL` is set, it is used instead.
 
-Use [nib](https://github.com/technekes/nib) to build and start up the web app.
+## Tests
 
 ```sh
-nib build --pull
-nib up
+RACK_ENV=test bundle exec rake db:create db:migrate
+bundle exec rspec
 ```
 
-### Running Tests
-
-The app is configured to use [guard](https://github.com/guard/guard) facilitate running the tests as files change. To start up guard run:
+To run the specs and RuboCop as files change:
 
 ```sh
-nib guard web
+bundle exec guard
 ```
 
-Alternatively the specs can be run as a one-off with:
+## Generators
+
+Run these from the app directory:
 
 ```sh
-nib rspec web
+natra model NAME [field:type ...]   # Generate a model and its migration
+natra controller NAME               # Generate a controller and its views
+natra scaffold NAME [field:type ...] # Generate a model, controller and views
+natra service_object NAME           # Generate a service object in app/services
 ```
-

data/lib/natra/generators/app/templates/Rakefile

@@ -1,3 +1,4 @@
-require_relative './config/environment'
+# frozen_string_literal: true
+
+require_relative 'config/environment'
 require 'sinatra/activerecord/rake'
-require 'sinatra/activerecord'

data/lib/natra/generators/app/templates/app/controllers/application_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require './config/environment'
 
 class ApplicationController < Sinatra::Base

data/lib/natra/generators/app/templates/app/views/welcome.erb

@@ -1,3 +1,4 @@
+    <h1>Welcome to the Sinatra Template!</h1>
     <div class="sidebar">
       <h3>Environment</h3>
       <ul>
@@ -5,6 +6,6 @@
         <li><b>Environment:</b> <%= ENV["RACK_ENV"] %></li>
         <li><b>Server:</b> <%= @env["SERVER_SOFTWARE"] %></li>
         <li><b>Port:</b> <%= @env["SERVER_PORT"] %></li>
-        <li><b>Help:</b>see the <a href="https://github.com/thirunjuguna/natra">README</a> </li>
+        <li><b>Help:</b> see the <a href="https://github.com/jamesnjuguna0419/natra">README</a></li>
       </ul>
     </div>