rsg 0.0.1

data/exe/rsg

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+source_path = Pathname.new(__FILE__).dirname.join("../lib").expand_path
+$LOAD_PATH << source_path
+
+require "rsg"
+
+if ARGV.empty?
+  puts "Please provide a path for the new application"
+  puts
+  puts "See --help for more info"
+  exit 0
+elsif ["-v", "--version"].include? ARGV[0]
+  puts "RSG:   #{RSG::VERSION}"
+  puts "Rails: #{Rails::VERSION}"
+  exit 0
+end
+
+Rsg::AppGenerator.start

data/lib/rsg/generators/actions.rb

@@ -0,0 +1,108 @@
+require "json"
+require "shellwords"
+
+module Rsg
+  module Generators
+    module Actions
+      def rsg_install
+        append_gem "rsg",
+                   within_group: %i(development test),
+                   install: false,
+                   path: options[:path]
+      end
+
+      def rsg_generate(name, quiet: false)
+        cmd = "generate #{name}"
+        cmd << " -q" if quiet
+
+        rails_command cmd
+        git_add_commit "RSG Generator executed: #{name}"
+      end
+
+      def rsg_apply_default!
+        rsg_apply "rsg-default"
+      end
+
+      def rsg_apply(template)
+        apply Rsg.lookup_app_template(template)
+      end
+
+      def api_mode?
+        return @api_mode if defined?(@api_mode)
+        @api_mode = !!(File.read("config/application.rb") =~ /^[^#]*config\.api_only = true[^\n]*$/)
+      end
+
+      def confirm?(prompt)
+        opts = { limited_to: %w(y n) }
+        ask(prompt, opts).downcase == 'y'
+      end
+
+      def git_add_commit(commit_msg)
+        truncated_msg = commit_msg.strip.gsub("\n", ' ')[0..59].strip
+        truncated_msg.gsub!(/.{3}$/, '...') if commit_msg.length > 60
+        say_status :run, "git add . && git commit -m \"#{truncated_msg}\""
+
+        run "git add .", verbose: false, capture: true
+        run "git commit -m #{Shellwords.escape(commit_msg)}", verbose: false, capture: true
+      end
+
+      def enable_railtie(name)
+        uncomment_lines "config/application.rb", /require ['"]#{name}\/railtie['"]/
+      end
+
+      def append_gem(gem_name, install: true, within_group: [], after: ["bootsnap", "rails"], **gem_line_params)
+        within_group = Array(within_group)
+        if within_group.any?
+          group_part = within_group.map { |g| "[:'\"]#{g}['\"]?" }.join(", ")
+          regex = /^ *group #{group_part} do\n(\s*(gem|#)[^\n]+\n)+ *end\n/
+        else
+          regex = /.+/m
+        end
+
+        gsub_file "Gemfile", regex do |match|
+          gem_line = build_gem_line(gem_name, gem_line_params)
+          append_gem_line(match, gem_line, after)
+        end
+
+        run("bundle install", capture: true) if install
+      end
+
+      private
+
+      def append_gem_line(code, gem_line, after)
+        code_lines = code.split("\n")
+        index = code_lines.length
+        indentation = ""
+
+        # Goes to the line above the `end` line by default
+        if code_lines[0] =~ /^([^#]*)group/
+          index -= 1
+          indentation = "#{$1}  "
+        end
+
+        Array(after).each do |candidate|
+          idx = code_lines.index { |l| l =~ /^([^#]*)gem ['"]#{candidate}['"].*$/ }
+          next unless idx
+
+          indentation = $1
+          index = idx + 1
+          break
+        end
+
+        code_lines.insert(index, "#{indentation}#{gem_line}").join("\n") << "\n"
+      end
+
+      def build_gem_line(gem_name, params = {})
+        line = "gem '#{gem_name}'"
+        if params.key?(:version)
+          version_args = Array(params[:version]).map { |v| "'#{v}'" }.join(", ")
+          line << ", #{version_args}"
+        end
+        line << ", require: '#{params[:require]}'" if params.key?(:require)
+        line << ", group: #{params[:group]}" if params.key?(:group)
+        line << ", path: '#{params[:path]}'" if params[:path].present?
+        line
+      end
+    end
+  end
+end

data/lib/rsg/generators/app/USAGE

@@ -0,0 +1,14 @@
+Description:
+    RSG is a Rails app generator with Doximity's basic defaults configured.
+
+    For full details on the changes we've made compared to a vanilla Rails app, check
+    our GitHub project:
+        https://github.com/doximity/rsg
+
+Example:
+    rsg ~/Code/weblog [options]
+
+    Is the equivalent of running `rails new ~/Code/weblog [options]` with most Rails
+    components disabled by default. This will generate a minimal Rails app in
+    ~/Code/weblog configured with our preferred defaults. Some questions might be
+    asked along the way to fine tune the generated app.

data/lib/rsg/generators/app/app_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rsg
+  # The application builder allows you to override elements of the application
+  # generator without being forced to reverse the operations of the default
+  # generator.
+  #
+  # This allows you to override entire operations, like the creation of the
+  # Gemfile, README, or JavaScript files, without needing to know exactly
+  # what those operations do so you can create another template action.
+  #
+  # For Rails 6.1, you can check out https://github.com/rails/rails/blob/6-1-stable/railties/lib/rails/generators/rails/app/app_generator.rb#L44
+  class AppBuilder < ::Rails::AppBuilder
+    def master_key
+      gsub_file "config/application.rb",
+        /^(\s*)(config\.load_defaults[^\n]+)\n$/,
+        "\\1\\2\n\n\\1# We don't use Rails encrypted secrets\n"\
+        "\\1config.require_master_key = false\n" \
+        "\\1config.active_support.use_authenticated_message_encryption = false\n"
+    end
+
+    ###########################################################################
+    # Simple template overwrites
+    ###########################################################################
+
+    def readme
+      template "README.md.erb", "README.md"
+    end
+
+    ###########################################################################
+    # Things to skip since we don't care about them
+    ###########################################################################
+
+    def ruby_version
+      # NOOP since we have the ruby version in Gemfile
+    end
+
+    def credentials
+      # NOOP since we store env vars / secrets elsewhere
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+require_relative "app_builder"
+
+module Rsg
+  # AppGenerator is the entrypoint for generation of new apps which builds on
+  # top of the core `rails new` command
+  class AppGenerator < Rails::Generators::AppGenerator
+    include Generators::Actions
+
+    hide!
+
+    class_option :version, type: :boolean, aliases: "-v", group: :rsg, desc: "Show RSG version number and quit"
+    class_option :help, type: :boolean, aliases: "-h", group: :rsg, desc: "Show this help message and quit"
+    class_option :path, type: :string, default: nil, desc: "Path to the RSG gem"
+    class_option :template, aliases: "-m", type: :string, default: "rsg-default", desc: "Path to some application template (can be a filesystem path or URL)"
+
+    # --minimal might take care of some of these, but not all, we change all defaults here regardless since
+    # --minimal is subject to change with new releases. We also hide them all, and re-add things as necessary
+    # based on user input as generators kick in
+    class_option :skip_action_cable, type: :boolean, default: true, desc: "Skip Action Cable files", hide: true
+    class_option :skip_action_mailbox, type: :boolean, default: true, desc: "Skip Action Mailbox files", hide: true
+    class_option :skip_action_mailer, type: :boolean, default: true, desc: "Skip Action Mailer files", hide: true
+    class_option :skip_action_text, type: :boolean, default: true, desc: "Skip Action Text files", hide: true
+    class_option :skip_active_job, type: :boolean, default: true, desc: "Skip Active Job files", hide: true
+    class_option :skip_active_record, type: :boolean, default: true, desc: "Skip Active Record files", hide: true
+    class_option :skip_active_storage, type: :boolean, default: true, desc: "Skip Active Storage files", hide: true
+    class_option :skip_bundle, type: :boolean, default: true, desc: "Don't run bundle install", hide: true
+    class_option :skip_javascript, type: :boolean, default: true, desc: "Skip JavaScript files", hide: true
+    class_option :skip_jbuilder, type: :boolean, default: true, desc: "Skip jbuilder gem", hide: true
+    class_option :skip_keeps, type: :boolean, default: true, desc: "Skip Puma", hide: true
+    class_option :skip_spring, type: :boolean, default: true, desc: "Don't install Spring application preloader", hide: true
+    class_option :skip_sprockets, type: :boolean, default: true, desc: "Skip Sprockets files", hide: true
+    class_option :skip_system_test, type: :boolean, default: true, desc: "Skip system test files", hide: true
+    class_option :skip_test, type: :boolean, default: true, desc: "Skip Test Unit", hide: true
+    class_option :skip_turbolinks, type: :boolean, default: true, desc: "Skip turbolinks gem", hide: true
+    class_option :skip_webpack_install, type: :boolean, default: true, desc: "Don't run webpack install", hide: true
+
+    # Hide other flags, but leave their defaults untouched
+    class_option :database, type: :string, default: "sqlite3", desc: "Configure for selected database (options: #{DATABASES.join("/")})", hide: true
+    class_option :dev, type: :boolean, default: false, desc: "Set up the application with Gemfile pointing to your Rails checkout", hide: true
+    class_option :edge, type: :boolean, default: false, desc: "Set up the application with Gemfile pointing to Rails repository", hide: true
+    class_option :master, type: :boolean, default: false, desc: "Preconfigure a minimal rails app", hide: true
+    class_option :minimal, type: :boolean, default: false, desc: "Preconfigure a minimal rails app", hide: true
+    class_option :skip_bootsnap, type: :boolean, default: false, desc: "Skip bootsnap gem", hide: true
+    class_option :skip_collision_check, type: :boolean, default: false, desc: "Skip collision check", hide: true
+    class_option :skip_gemfile, type: :boolean, default: false, desc: "Don't create a Gemfile", hide: true
+    class_option :skip_git, type: :boolean, default: false, desc: "Skip .gitignore file", hide: true
+    class_option :skip_listen, type: :boolean, default: false, desc: "Don't generate configuration that depends on the listen gem", hide: true
+    class_option :skip_namespace, type: :boolean, default: false, desc: "Skip namespace (affects only isolated engines)", hide: true
+    class_option :skip_puma, type: :boolean, default: false, desc: "Skip Puma related files", hide: true
+    class_option :webpack, type: :string, desc: "Preconfigure Webpack with a particular framework (options: react, vue, angular, elm, stimulus)", hide: true
+
+    def self.banner
+      "rsg #{arguments.map(&:usage).join(" ")} [options]"
+    end
+
+    def self.source_paths
+      @__source_paths ||= [
+        Rails::Generators::AppGenerator.source_root,
+        Pathname.new(__FILE__).dirname.join("templates").expand_path
+      ]
+    end
+
+    def set_default_accessors!
+      bundled_template = Rsg.lookup_app_template(options[:template])
+      super
+      self.rails_template = bundled_template if bundled_template
+    end
+
+    protected
+
+    # rubocop:disable Naming/AccessorMethodName
+    def get_builder_class
+      Rsg::AppBuilder
+    end
+    # rubocop:enable Naming/AccessorMethodName
+  end
+end

data/lib/rsg/generators/app/templates/README.md.erb

@@ -0,0 +1,22 @@
+# <%= app_name.humanize %>
+
+```
+TODO: Write a few words about what the app does
+```
+
+## Generated with RSG v<%= Rsg::VERSION %>
+
+This is an application generated with [rsg](https://github.com/doximity/rsg). If you've skipped any of its
+generators (like ActiveRecord's) or if you'd like to know what else is available for you to configure you
+can run `rails generate --help | grep rsg`.
+
+## Getting Started
+
+After you have cloned this repo, run this setup script to set up your machine
+with the necessary dependencies to run and test this app:
+
+    % ./bin/setup
+
+Then start the web server with:
+
+    % ./bin/rails server

data/lib/rsg/generators/base.rb

@@ -0,0 +1,27 @@
+require "pathname"
+require "rails/generators"
+
+module Rsg
+  module Generators
+    class Base < Rails::Generators::Base
+      include Actions
+      include Options
+
+      def self.inherited(base)
+        super
+
+        parts = base.namespace.split(":")
+        return unless parts[0] == "rsg"
+
+        parts = parts[1..-2] + ["templates"]
+        templates_path = Pathname.new(__FILE__).dirname.join(*parts).expand_path
+
+        base.source_paths << templates_path if templates_path.exist?
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/rsg/generators/dotenv/install_generator.rb

@@ -0,0 +1,24 @@
+require_relative "../base"
+
+module Rsg
+  module Dotenv
+    class InstallGenerator < Rsg::Generators::Base
+      def banner
+        say "Configuring dotent-rails in development and test environments"
+      end
+
+      def add_dotenv
+        append_gem "dotenv-rails",
+          version: "< 3",
+          after: "rails",
+          group: [:development, :test],
+          require: "dotenv/rails-now"
+      end
+
+      def configure_dotenv
+        copy_file "env.development", ".env.development"
+        copy_file "env.test", ".env.test"
+      end
+    end
+  end
+end

data/lib/rsg/generators/dotenv/templates/env.development

@@ -0,0 +1,2 @@
+PORT="3000"
+APP_URL="http://localhost:${PORT}"

data/lib/rsg/generators/dotenv/templates/env.test

@@ -0,0 +1,2 @@
+PORT="3000"
+APP_URL="http://test:${PORT}"

data/lib/rsg/generators/gemfile/cleanup_generator.rb

@@ -0,0 +1,28 @@
+require_relative "../base"
+
+module Rsg
+  module Gemfile
+    class CleanupGenerator < Rsg::Generators::Base
+      def banner
+        say "Cleaning up Gemfile"
+      end
+
+      def remove_comments
+        gsub_file "Gemfile", /^ *#\s*[^#\n]+\n/, ""
+      end
+
+      def remove_tzinfo
+        # Remove tzinfo-data since we don't have a need for it in dev / prod env
+        gsub_file "Gemfile", /\ngem 'tzinfo-data'[^\n]+\n/, ""
+      end
+
+      def remove_extra_whitespace
+        gsub_file "Gemfile", /^( *gem[^\n]+)\n\n\n/, "\\1\n\n"
+      end
+
+      def isolate_rails_gem
+        gsub_file "Gemfile", /^( *)(gem ["']rails["'][^\n]+)\n(?: *)(gem ['"]puma['"][^\n]+)\n$/, "\\1\\2\n\n\\3"
+      end
+    end
+  end
+end

data/lib/rsg/generators/install/install_generator.rb

@@ -0,0 +1,13 @@
+require_relative "../base"
+
+module Rsg
+  module Install
+    class InstallGenerator < Rsg::Generators::Base
+      class_option :path, type: :string, default: nil, desc: "Path to the RSG gem"
+
+      def add_rsg
+        install_rsg
+      end
+    end
+  end
+end

data/lib/rsg/generators/logging/common_generator.rb

@@ -0,0 +1,40 @@
+require_relative "../base"
+
+module Rsg
+  module Logging
+    class CommonGenerator < Rsg::Generators::Base
+      def banner
+        say "Improving basic logging configs"
+      end
+
+      def log_level_env_var
+       inject_into_file "config/application.rb", <<-CODE, before: /^  end$/
+\n    # Sane default log levels per env, but able to tweak with env var
+    # NOTE: Settings on config/environments/*.rb take precedence over this
+    config.log_level = ENV.fetch('LOG_LEVEL') { Rails.env.development? ? 'debug' : 'info' }.to_sym
+
+    # Log to stdout most of the time and allow use of JSON logs in dev by using an env var
+    config.x.log_to_stdout = %w[1 true yes].include?(ENV.fetch('RAILS_LOG_TO_STDOUT', '1'))
+       CODE
+      end
+
+      def stdout_logging_in_dev
+       inject_into_file "config/environments/development.rb", <<-CODE, before: /^end$/
+\n  # Configure stdout logging in dev as well
+  if config.x.log_to_stdout
+    logger = ActiveSupport::Logger.new(STDOUT)
+    logger.formatter = config.log_formatter
+    config.logger = ActiveSupport::TaggedLogging.new(logger)
+  end
+     CODE
+      end
+
+      def adjust_prod
+        comment_lines "config/environments/production.rb", /^(\s*)(config\.log_level .+)$/
+        gsub_file "config/environments/production.rb",
+                  'ENV["RAILS_LOG_TO_STDOUT"].present?',
+                  "config.x.log_to_stdout"
+      end
+    end
+  end
+end

data/lib/rsg/generators/logging/lograge_generator.rb

@@ -0,0 +1,31 @@
+require_relative "../base"
+
+module Rsg
+  module Logging
+    class LogrageGenerator < Rsg::Generators::Base
+      def self.source_root
+        Pathname.new(__FILE__).dirname.join("templates").expand_path
+      end
+
+      def banner
+        say "Configuring lograge with JSON logging"
+      end
+
+      def add_lograge
+        append_gem "lograge", install: false
+        append_gem "logstash-event", after: "lograge"
+      end
+
+      def initializer
+        copy_file "initializer_lograge.rb", "config/initializers/logging.rb"
+      end
+
+      def json_logs_env_var
+        inject_into_file "config/application.rb", <<-CODE, before: /^  end$/
+\n    # Enable JSON logs with lograge
+    config.x.json_logs = Rails.env.production? || %w[1 true yes].include?(ENV.fetch('JSON_LOGS', '0'))
+        CODE
+      end
+    end
+  end
+end

data/lib/rsg/generators/logging/templates/initializer_lograge.rb

@@ -0,0 +1,9 @@
+Rails.application.configure do
+  return unless config.x.json_logs
+
+  # See https://github.com/roidrage/lograge for more information on how to configure the gem
+  # This only configures logs to be formatted as JSON when lograge is enabled but you can do much more with it,
+  # like annotating logs with user IDs
+  config.lograge.enabled = true
+  config.lograge.formatter = Lograge::Formatters::Logstash.new
+end

data/lib/rsg/generators/misc/misc_generator.rb

@@ -0,0 +1,61 @@
+require_relative "../base"
+
+module Rsg
+  module Misc
+    class MiscGenerator < Generators::Base
+      def self.source_root
+        Pathname.new(__FILE__).dirname.join("templates").expand_path
+      end
+
+      def banner
+        say "Making some extra tweaks"
+      end
+
+      def disable_assets_generators
+        return if api_mode?
+
+        inject_into_file "config/application.rb", <<-CODE, before: /^\s*# Don't generate system test files./
+
+    # Don't generate CSS files when using scaffolding commands, since we compile assets through webpacker
+    config.generators.assets = false
+    config.generators.scaffold_stylesheet = false
+    config.generators.stylesheets = false
+
+    # Most of time we can get away with a handful of methods in the default application_helper. Other ones
+    # can be introduced as needed
+    config.generators.helper = false
+       CODE
+      end
+
+      def configure_pry
+        append_gem "pry-rails", within_group: :development
+      end
+
+      def remove_assets
+        run "rm -rf app/assets"
+      end
+
+      # TODO: Skip puma on app generator, introduce a new Puma::InstallGenerator
+      def puma_configs
+        copy_file "puma.rb", "config/puma.rb", force: true
+      end
+
+      # TODO: Move to an i18n generator that does this and more
+      def configure_environments
+        # If by any chance we make use of translations, let them fail and get
+        # caught early on the dev process
+        uncomment_lines "config/environments/development.rb", /raise_on_missing_translations/
+        uncomment_lines "config/environments/test.rb", /raise_on_missing_translations/
+      end
+
+      def healthcheck
+        inject_into_file "config/routes.rb", <<-CODE, before: "end"
+
+  # Defines a static healthcheck for probes. Please note that this won't
+  # output any logs in production
+  get :healthcheck, to: proc { [200, {}, ['OK']] }
+        CODE
+      end
+    end
+  end
+end

data/lib/rsg/generators/misc/templates/puma.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+max_threads_count = ENV.fetch('RAILS_MAX_THREADS', 5)
+min_threads_count = ENV.fetch('RAILS_MIN_THREADS') { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+# worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch('PORT', 3000)
+
+# Specifies the `environment` that Puma will run in.
+# environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+# pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
+
+# Specifies the number of `workers` to boot in clustered mode. Workers are
+# forked web server processes. If using threads and workers together the
+# concurrency of the application would be max `threads` * `workers`. Workers do
+# not work on JRuby or Windows (both of which do not support processes).
+#
+# Here we disable workers by default since we tipically run our apps in
+# containers, so we can scale the amount of processes by spinning up new
+# containers to handle the load instead of having multiple processes running in
+# the same container.
+workers ENV.fetch('WEB_CONCURRENCY', 0)
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory.
+#
+# preload_app!
+
+# Allow puma to be restarted by `rails restart` command.
+plugin :tmp_restart

data/lib/rsg/generators/options.rb

@@ -0,0 +1,15 @@
+module Rsg
+  module Generators
+    module Options
+      def self.included(base)
+        configure_basic_options(base)
+      end
+
+      def self.configure_basic_options(base)
+        base.instance_eval do
+          class_option :quiet, type: :boolean, aliases: "-q", default: false, desc: "Suppress status output"
+        end
+      end
+    end
+  end
+end

data/lib/rsg/generators/orm/active_record_generator.rb

@@ -0,0 +1,44 @@
+require_relative "../base"
+
+module Rsg
+  module Orm
+    class ActiveRecordGenerator < Generators::Base
+      include Rails::Generators::Database
+
+      SUPPORTED_DBS = %w(sqlite3 mysql postgres)
+      class_option :database, type: :string, default: nil, desc: "Configure for selected database (options: #{SUPPORTED_DBS.join("/")})"
+
+      def self.source_root
+        Pathname.new(__FILE__).dirname.join("templates").expand_path
+      end
+
+      def banner
+        say "Configuring active record"
+      end
+
+      def enable_active_record
+        enable_railtie "active_record"
+      end
+
+      def configure_driver
+        database = options.fetch(:database) { ask("Which database you'd like to use?", limited_to: SUPPORTED_DBS, default: "sqlite3") }
+        template "active_record/#{database}.yml", "config/database.yml"
+
+        name, version = gem_for_database(database)
+        append_gem name, version: version
+      end
+
+      def write_db_sample
+        copy_file "db.rake", "lib/tasks/db.rake"
+        copy_file "seeds.rb", "db/seeds.rb"
+        copy_file "samples.rb", "db/samples.rb"
+      end
+
+      def migrate
+        return if no?("Would you like to create the database schema?")
+
+        rake "db:create db:migrate"
+      end
+    end
+  end
+end