outset 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 863fabe79965bc0d21477932bf97e165ad54fbcd385ba972d198f40dec78e3df
+  data.tar.gz: 3ea461e5243abbff2cf8ed693b919edc7d23467c7c039255f3bbf914009fb7df
+SHA512:
+  metadata.gz: 3faf1b252d4b2b15126422ba2c83771be0a39fcb865194526d654a421a408062e3542e560bf4f5a6aec4926b1583eed8d5931915d22bb112fab8f69b1ac172b2
+  data.tar.gz: 3d06676a5c1a7b330b90ad703b530bd963c2d2384f902a42d492b9200e28342ce6d5bd22e2f18b00433a69e08241d2fe1665b53a101d4cc2362217a73ac96af4

data/exe/outset

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/outset"
+
+Outset::CLI.start(ARGV)

data/lib/outset/cli.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "commands/new"
+require_relative "commands/config_cmd"
+require_relative "commands/doctor"
+require_relative "recipes"
+
+module Outset
+  class CLI < Thor
+    def self.exit_on_failure? = true
+
+    desc "new APP_NAME", "Bootstrap a new Rails application"
+    option :database, aliases: "-d", type: :string,  default: nil,   desc: "Database (postgresql, mysql, sqlite3)"
+    option :css,      aliases: "-c", type: :string,  default: nil,   desc: "CSS framework (tailwind, bootstrap, sass, postcss, none)"
+    option :js,       aliases: "-j", type: :string,  default: nil,   desc: "JavaScript bundler (importmap, esbuild, bun, webpack, rollup)"
+    option :recipe,   aliases: "-r", type: :string,  default: nil,   desc: "Use a predefined recipe"
+    option :yes,      aliases: "-y", type: :boolean, default: false, desc: "Accept all defaults, skip prompts"
+    def new(app_name)
+      UI.banner
+      Commands::New.new(app_name, options).run
+    end
+
+    desc "config [ACTION]", "View or edit your outset config (~/.outset/config.toml)"
+    def config(action = "show")
+      Commands::ConfigCmd.new(action).run
+    end
+
+    desc "doctor", "Check that your environment is ready to use outset"
+    def doctor
+      UI.banner
+      Commands::Doctor.new.run
+    end
+
+    desc "recipes", "List available recipes"
+    def recipes
+      UI.info("Available recipes:")
+      puts
+      Recipes.all.each do |name, recipe|
+        puts "  #{UI::PASTEL.bold(name.ljust(10))} #{recipe[:description]}"
+        UI.muted("    db=#{recipe[:database]}  css=#{recipe[:css]}  js=#{recipe[:js]}  gems=#{recipe[:gems].empty? ? "none" : recipe[:gems].join(", ")}")
+        puts
+      end
+    end
+
+    desc "version", "Print outset version"
+    def version
+      puts "outset v#{Outset::VERSION}"
+    end
+
+    map %w[--version -v] => :version
+  end
+end

data/lib/outset/commands/config_cmd.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Outset
+  module Commands
+    class ConfigCmd
+      def initialize(action)
+        @action = action
+      end
+
+      def run
+        case @action
+        when "show"   then show
+        when "init"   then Config.init!
+        when "edit"   then edit
+        when "path"   then puts Config::CONFIG_FILE
+        else
+          UI.error("Unknown config action: '#{@action}'")
+          UI.muted("  Available: show, init, edit, path")
+          exit(1)
+        end
+      end
+
+      private
+
+      def show
+        if File.exist?(Config::CONFIG_FILE)
+          UI.info("Config file: #{Config::CONFIG_FILE}")
+          puts
+          puts File.read(Config::CONFIG_FILE)
+        else
+          UI.warn("No config file found. Run `outset config init` to create one.")
+          puts
+          UI.muted("Default values:")
+          puts Config.default_toml
+        end
+      end
+
+      def edit
+        unless File.exist?(Config::CONFIG_FILE)
+          Config.init!
+        end
+        editor = ENV["VISUAL"] || ENV["EDITOR"] || "nano"
+        system("#{editor} #{Config::CONFIG_FILE}")
+      end
+    end
+  end
+end

data/lib/outset/commands/doctor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Outset
+  module Commands
+    class Doctor
+      CHECKS = [
+        {
+          name: "Ruby >= 3.1",
+          check: -> { RUBY_VERSION >= "3.1.0" },
+          fix:   "Install Ruby 3.1+ via rbenv or asdf"
+        },
+        {
+          name: "Rails installed",
+          check: -> { system("which rails > /dev/null 2>&1") },
+          fix:   "Run: gem install rails"
+        },
+        {
+          name: "Git installed",
+          check: -> { system("which git > /dev/null 2>&1") },
+          fix:   "Install git from https://git-scm.com"
+        },
+        {
+          name: "Git user.name configured",
+          check: -> { !`git config user.name`.strip.empty? rescue false },
+          fix:   "Run: git config --global user.name 'Your Name'"
+        },
+        {
+          name: "Git user.email configured",
+          check: -> { !`git config user.email`.strip.empty? rescue false },
+          fix:   "Run: git config --global user.email 'you@example.com'"
+        },
+        {
+          name: "Outset config file",
+          check: -> { File.exist?(Config::CONFIG_FILE) },
+          fix:   "Run: outset config init"
+        }
+      ].freeze
+
+      def run
+        UI.info("Checking your environment...\n")
+        all_passed = true
+
+        CHECKS.each do |check|
+          if check[:check].call
+            UI.success(check[:name])
+          else
+            UI.warn("#{check[:name]}  →  #{check[:fix]}")
+            all_passed = false
+          end
+        end
+
+        puts
+        if all_passed
+          UI.success("All checks passed. You're ready to use outset!")
+        else
+          UI.warn("Some checks failed. Fix the issues above and run `outset doctor` again.")
+        end
+      end
+    end
+  end
+end

data/lib/outset/commands/new.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tmpdir"
+
+module Outset
+  module Commands
+    class New
+      DATABASES   = %w[postgresql mysql sqlite3].freeze
+      CSS_OPTIONS = %w[tailwind bootstrap sass postcss none].freeze
+      JS_OPTIONS  = %w[importmap esbuild bun webpack rollup].freeze
+
+      OPTIONAL_GEMS = [
+        { name: "Devise (Authentication)",      value: "devise"        },
+        { name: "Pundit (Authorization)",       value: "pundit"        },
+        { name: "Sidekiq (Background Jobs)",    value: "sidekiq"       },
+        { name: "RSpec + FactoryBot (Tests)",   value: "rspec"         },
+        { name: "Annotate (Model Annotations)", value: "annotate"      },
+        { name: "Letter Opener (Email preview)",value: "letter_opener" },
+        { name: "Pagy (Pagination)",            value: "pagy"          },
+      ].freeze
+
+      def initialize(app_name, options = {})
+        @app_name = app_name
+        @options  = options
+        @resolved = Config.resolve(options)
+        @prompt   = TTY::Prompt.new(interrupt: :exit)
+      end
+
+      def run
+        validate_app_name!
+        validate_rails_installed!
+
+        selections = if effective_recipe
+                       recipe_selections
+                     elsif @options[:yes]
+                       default_selections
+                     else
+                       prompt_user
+                     end
+
+        confirm_and_run(selections)
+      end
+
+      private
+
+      def effective_recipe
+        @options[:recipe] || @resolved["default_recipe"]
+      end
+
+      def validate_app_name!
+        unless @app_name.match?(/\A[a-z][a-z0-9_]*\z/)
+          UI.error("Invalid app name: '#{@app_name}'")
+          UI.muted("  App names must start with a letter and contain only lowercase letters, numbers, and underscores.")
+          exit(1)
+        end
+
+        if Dir.exist?(@app_name)
+          UI.error("Directory '#{@app_name}' already exists.")
+          exit(1)
+        end
+      end
+
+      def validate_rails_installed!
+        unless system("which rails > /dev/null 2>&1")
+          UI.error("Rails is not installed. Run: gem install rails")
+          exit(1)
+        end
+      end
+
+      def recipe_selections
+        name   = effective_recipe
+        recipe = Recipes.find(name)
+        UI.info("Using recipe: #{name} — #{recipe[:description]}")
+        puts
+        {
+          database: @options[:database] || recipe[:database],
+          css:      @options[:css]      || recipe[:css],
+          js:       @options[:js]       || recipe[:js],
+          gems:     (recipe[:gems] + @resolved["gems"]).uniq
+        }
+      end
+
+      def default_selections
+        {
+          database: @resolved["database"],
+          css:      @resolved["css"],
+          js:       @resolved["javascript"],
+          gems:     @resolved["gems"]
+        }
+      end
+
+      def prompt_user
+        UI.info("Configuring: #{@app_name}")
+        puts
+
+        database = if @options[:database]
+                     UI.muted("  Database: #{@options[:database]} (from flag)")
+                     @options[:database]
+                   else
+                     @prompt.select("Database:", DATABASES, default: @resolved["database"])
+                   end
+
+        css = if @options[:css]
+                UI.muted("  CSS: #{@options[:css]} (from flag)")
+                @options[:css]
+              else
+                @prompt.select("CSS framework:", CSS_OPTIONS, default: @resolved["css"])
+              end
+
+        js = if @options[:js]
+               UI.muted("  JS: #{@options[:js]} (from flag)")
+               @options[:js]
+             else
+               @prompt.select("JavaScript bundler:", JS_OPTIONS, default: @resolved["javascript"])
+             end
+
+        always_gems = @resolved["gems"]
+        gems = @prompt.multi_select("Optional gems: (space to select, enter to confirm)") do |menu|
+          OPTIONAL_GEMS.each do |gem_opt|
+            preselected = always_gems.include?(gem_opt[:value])
+            menu.choice gem_opt[:name], gem_opt[:value], disabled: (preselected ? "(always)" : false)
+          end
+        end
+        gems += always_gems
+
+        { database: database, css: css, js: js, gems: gems.uniq }
+      end
+
+      def confirm_and_run(selections)
+        puts
+        UI.info("Ready to create '#{@app_name}' with:")
+        UI.muted("  Recipe   : #{effective_recipe}") if effective_recipe
+        UI.muted("  Database : #{selections[:database]}")
+        UI.muted("  CSS      : #{selections[:css]}")
+        UI.muted("  JS       : #{selections[:js]}")
+        UI.muted("  Gems     : #{selections[:gems].empty? ? "none" : selections[:gems].join(", ")}")
+        puts
+
+        return unless @options[:yes] || @prompt.yes?("Proceed?")
+
+        generate(selections)
+      end
+
+      def generate(selections)
+        rails_flags = build_rails_flags(selections)
+
+        if selections[:gems].any?
+          template_path = write_template(selections[:gems])
+          rails_flags << "--template=#{template_path}"
+        end
+
+        cmd = "rails new #{@app_name} #{rails_flags.join(" ")}"
+        UI.info("Running: #{cmd}")
+        puts
+
+        success = Bundler.with_unbundled_env { system(cmd) }
+
+        File.delete(template_path) if template_path && File.exist?(template_path)
+
+        if success
+          puts
+          UI.success("App created! Next steps:")
+          UI.muted("  cd #{@app_name}")
+          UI.muted("  bin/setup")
+          UI.muted("  bin/dev")
+        else
+          UI.error("rails new failed. See output above for details.")
+          exit(1)
+        end
+      end
+
+      def build_rails_flags(selections)
+        flags = []
+        flags << "--database=#{selections[:database]}"
+        flags << "--css=#{selections[:css]}"        unless selections[:css] == "none"
+        flags << "--javascript=#{selections[:js]}"
+        flags << "--skip-test" if selections[:gems].include?("rspec")
+        flags
+      end
+
+      # Writes a temporary Rails template.rb file and returns its path
+      def write_template(gems)
+        template = build_template(gems)
+        path = File.join(Dir.tmpdir, "outset_template_#{@app_name}_#{Process.pid}.rb")
+        File.write(path, template)
+        path
+      end
+
+      def build_template(gems)
+        lines = ["# Generated by outset v#{Outset::VERSION}", ""]
+
+        # Gem declarations
+        lines << "# ── Gems ─────────────────────────────────────────────"
+        gems.each { |g| lines << gem_declaration(g) }
+        lines << ""
+
+        # after_bundle block
+        lines << "after_bundle do"
+        gems.each do |g|
+          after = after_bundle_steps(g)
+          lines += after.map { |l| "  #{l}" } if after.any?
+        end
+        lines << "  git add: '.', commit: %(-m 'Initial scaffold via outset')"
+        lines << "end"
+        lines << ""
+
+        lines.join("\n")
+      end
+
+      def gem_declaration(gem_name)
+        case gem_name
+        when "rspec"
+          "gem_group :development, :test do\n  gem 'rspec-rails'\n  gem 'factory_bot_rails'\n  gem 'faker'\nend"
+        when "letter_opener"
+          "gem_group :development do\n  gem 'letter_opener'\nend"
+        when "sidekiq"
+          "gem 'sidekiq'"
+        else
+          "gem '#{gem_name}'"
+        end
+      end
+
+      def after_bundle_steps(gem_name)
+        case gem_name
+        when "devise"  then ["generate 'devise:install'", "generate 'devise', 'User'"]
+        when "pundit"  then ["generate 'pundit:install'"]
+        when "rspec"   then ["generate 'rspec:install'", "rails_command 'db:create'"]
+        when "sidekiq" then ["# Add Sidekiq as ActiveJob backend in config/application.rb manually"]
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/outset/config.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Outset
+  class Config
+    CONFIG_DIR  = File.expand_path("~/.outset")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.toml")
+
+    DEFAULTS = {
+      "defaults" => {
+        "database"   => "postgresql",
+        "css"        => "tailwind",
+        "javascript" => "importmap"
+      },
+      "skip" => {
+        "rubocop"  => false,
+        "brakeman" => false,
+        "docker"   => false
+      },
+      "gems" => {
+        "always" => []
+      },
+      "recipes" => {
+        "default" => nil
+      }
+    }.freeze
+
+    def self.load
+      new.load
+    end
+
+    def load
+      return DEFAULTS.dup unless File.exist?(CONFIG_FILE)
+
+      require "toml-rb"
+      user_config = TomlRB.load_file(CONFIG_FILE)
+      deep_merge(DEFAULTS.dup, user_config)
+    rescue => e
+      UI.warn("Could not read config file: #{e.message}. Using defaults.")
+      DEFAULTS.dup
+    end
+
+    def self.resolve(options = {})
+      config = load
+      default_recipe = config.dig("recipes", "default")
+      default_recipe = nil if default_recipe.nil? || default_recipe.to_s.strip.empty?
+      {
+        "database"       => options[:database]           || ENV["OUTSET_DATABASE"] || config.dig("defaults", "database"),
+        "css"            => options[:css]                || ENV["OUTSET_CSS"]      || config.dig("defaults", "css"),
+        "javascript"     => options[:js]                 || ENV["OUTSET_JS"]       || config.dig("defaults", "javascript"),
+        "gems"           => config.dig("gems", "always") || [],
+        "default_recipe" => default_recipe
+      }
+    end
+
+    def self.init!
+      return if File.exist?(CONFIG_FILE)
+
+      FileUtils.mkdir_p(CONFIG_DIR)
+      File.write(CONFIG_FILE, default_toml)
+      UI.success("Created config file at #{CONFIG_FILE}")
+    end
+
+    def self.default_toml
+      <<~TOML
+        # ~/.outset/config.toml
+        # Edit this file to set your personal defaults.
+
+        [defaults]
+        database   = "postgresql"
+        css        = "tailwind"
+        javascript = "importmap"
+
+        [skip]
+        rubocop  = false
+        brakeman = false
+        docker   = false
+
+        [gems]
+        always = []  # Gems added to every new app, e.g. ["annotate", "letter_opener"]
+
+        [recipes]
+        default = ""  # Name of your default recipe, e.g. "saas"
+
+        # Define custom recipes (uncomment and edit to add your own):
+        # [recipes.mystartup]
+        # description = "My startup stack"
+        # database    = "postgresql"
+        # css         = "tailwind"
+        # js          = "esbuild"
+        # gems        = ["devise", "sidekiq", "pagy"]
+      TOML
+    end
+
+    private
+
+    def deep_merge(base, override)
+      base.merge(override) do |_key, base_val, override_val|
+        if base_val.is_a?(Hash) && override_val.is_a?(Hash)
+          deep_merge(base_val, override_val)
+        else
+          override_val
+        end
+      end
+    end
+  end
+end

data/lib/outset/recipes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Outset
+  module Recipes
+    REGISTRY = {
+      "saas" => {
+        description: "Full SaaS stack — auth, jobs, pagination",
+        database:    "postgresql",
+        css:         "tailwind",
+        js:          "importmap",
+        gems:        %w[devise pundit sidekiq pagy annotate letter_opener]
+      },
+      "api" => {
+        description: "API-only app — no frontend assets",
+        database:    "postgresql",
+        css:         "none",
+        js:          "importmap",
+        gems:        %w[devise rspec]
+      },
+      "minimal" => {
+        description: "Bare minimum — SQLite, no extras",
+        database:    "sqlite3",
+        css:         "none",
+        js:          "importmap",
+        gems:        []
+      }
+    }.freeze
+
+    def self.find(name)
+      REGISTRY[name] || user_recipes[name] || begin
+        UI.error("Unknown recipe: '#{name}'")
+        UI.muted("  Available recipes: #{all.keys.join(", ")}")
+        exit(1)
+      end
+    end
+
+    def self.all
+      REGISTRY.merge(user_recipes)
+    end
+
+    def self.user_recipes
+      config = Config.load
+      (config["recipes"] || {}).each_with_object({}) do |(name, value), hash|
+        next unless value.is_a?(Hash)
+        hash[name] = {
+          description: value["description"] || "Custom recipe",
+          database:    value["database"]    || "postgresql",
+          css:         value["css"]         || "tailwind",
+          js:          value["js"]          || "importmap",
+          gems:        value["gems"]        || []
+        }
+      end
+    end
+  end
+end

data/lib/outset/ui.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Outset
+  module UI
+    PASTEL = Pastel.new
+
+    def self.banner
+      puts PASTEL.bold.blue(<<~BANNER)
+          ___   _   _  _____  ____   _____  _____
+         / _ \\ | | | ||_   _|/ ___| | ____|_   _|
+        | | | || | | |  | |  \\___ \\ |  _|    | |
+        | |_| || |_| |  | |   ___) || |___   | |
+         \\___/  \\___/   |_|  |____/ |_____|  |_|
+      BANNER
+      puts PASTEL.dim("  Rails Application Bootstrapper v#{Outset::VERSION}")
+      puts
+    end
+
+    def self.success(msg)  = puts PASTEL.green("✓ #{msg}")
+    def self.error(msg)    = puts PASTEL.red("✗ #{msg}")
+    def self.info(msg)     = puts PASTEL.cyan("→ #{msg}")
+    def self.warn(msg)     = puts PASTEL.yellow("! #{msg}")
+    def self.muted(msg)    = puts PASTEL.dim(msg)
+  end
+end

data/lib/outset/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Outset
+  VERSION = "0.1.0"
+end

data/lib/outset.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "outset/version"
+require_relative "outset/ui"
+require_relative "outset/config"
+require_relative "outset/recipes"
+require_relative "outset/cli"

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: outset
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kingsley Chijioke
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A personal Rails application bootstrapper with interactive prompts, a
+  config file, and predefined recipes — callable as `outset new <app_name>`.
+email:
+- dev@kingsleychijioke.me
+executables:
+- outset
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/outset
+- lib/outset.rb
+- lib/outset/cli.rb
+- lib/outset/commands/config_cmd.rb
+- lib/outset/commands/doctor.rb
+- lib/outset/commands/new.rb
+- lib/outset/config.rb
+- lib/outset/recipes.rb
+- lib/outset/ui.rb
+- lib/outset/version.rb
+homepage: https://github.com/kinsomicrote/outset
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Bootstrap new Rails applications your way
+test_files: []