opinionated_rails 0.1.4

data/lib/opinionated_rails/steps/addons/tailwind_step.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class TailwindStep < Step
+        def self.id = :tailwind
+        def self.tier = :addon
+        def self.needs = [ :frontend ]
+        def self.summary = "Configure Tailwind CSS"
+        def self.description = "Installs Tailwind v3 with a path appropriate for the chosen frontend."
+        def self.prompts = "None"
+
+        TAILWIND_VERSION = "3.4.1".freeze
+
+        # The standalone CLI only auto-detects ./tailwind.config.js, but the config lives in config/.
+        REACT_CLI = "npx tailwindcss -c ./config/tailwind.config.js " \
+                    "-i ./app/assets/stylesheets/application.tailwind.css -o ./app/assets/builds/tailwind.css".freeze
+        TAILWIND_RAILS_VERSION = "3.3.0".freeze
+
+        DIRECTIVES = <<~CSS
+          @tailwind base;
+          @tailwind components;
+          @tailwind utilities;
+        CSS
+
+        def if_condition(context)
+          context.output(:frontend, :frontend) != :none
+        end
+
+        def prompt(_context); end
+
+        def generate(context)
+          unless if_condition(context)
+            context.set_output(:tailwind, nil)
+            return
+          end
+
+          if context.output(:frontend, :frontend) == :react
+            configure_for_react(context)
+          else
+            configure_for_stimulus(context)
+          end
+
+          write_stylesheet(context)
+          update_layout(context)
+
+          context.set_output(:tailwind, { tailwind: true })
+        end
+
+        def outputs(context)
+          context.output(:tailwind)
+        end
+
+        private
+
+        def configure_for_stimulus(context)
+          gemfile = File.join(context.app_path, "Gemfile")
+          if File.exist?(gemfile) && !File.read(gemfile).include?("tailwindcss-rails")
+            File.open(gemfile, "a") { |f| f.puts("gem \"tailwindcss-rails\", \"#{TAILWIND_RAILS_VERSION}\"") }
+          end
+
+          write_tailwind_config(context, stimulus_content)
+          append_procfile(context, "css: bin/rails tailwindcss:watch")
+        end
+
+        def configure_for_react(context)
+          package_json_path = File.join(context.app_path, "package.json")
+          package = File.exist?(package_json_path) ? JSON.parse(File.read(package_json_path)) : {}
+
+          package["devDependencies"] ||= {}
+          package["devDependencies"]["tailwindcss"] = TAILWIND_VERSION
+
+          package["scripts"] ||= {}
+          package["scripts"]["build:css"] = "#{REACT_CLI} --minify"
+
+          File.write(package_json_path, JSON.pretty_generate(package))
+
+          write_tailwind_config(context, react_content)
+          append_procfile(context, "css: #{REACT_CLI} --watch")
+        end
+
+        def write_stylesheet(context)
+          css_path = File.join(context.app_path, "app/assets/stylesheets/application.tailwind.css")
+          FileUtils.mkdir_p(File.dirname(css_path))
+          File.write(css_path, DIRECTIVES)
+        end
+
+        def write_tailwind_config(context, content)
+          config_path = File.join(context.app_path, "config/tailwind.config.js")
+          FileUtils.mkdir_p(File.dirname(config_path))
+          File.write(config_path, content)
+        end
+
+        def stimulus_content
+          <<~JS
+            module.exports = {
+              content: [
+                "./app/views/**/*.html.erb",
+                "./app/helpers/**/*.rb",
+                "./app/javascript/**/*.js",
+                "./app/assets/stylesheets/**/*.css"
+              ],
+              theme: {},
+              plugins: []
+            }
+          JS
+        end
+
+        def react_content
+          <<~JS
+            module.exports = {
+              content: ["./app/views/**/*.html.erb", "./app/javascript/**/*.{js,jsx}"],
+              theme: {},
+              plugins: []
+            }
+          JS
+        end
+
+        def append_procfile(context, line)
+          procfile = File.join(context.app_path, "Procfile.dev")
+
+          if File.exist?(procfile)
+            content = File.read(procfile)
+            return if content.include?(line)
+
+            File.open(procfile, "a") { |f| f.puts(line) }
+          else
+            File.write(procfile, "web: bin/rails server\n#{line}\n")
+          end
+        end
+
+        def update_layout(context)
+          layout = File.join(context.app_path, "app/views/layouts/application.html.erb")
+          return unless File.exist?(layout)
+
+          content = File.read(layout)
+          return if content.include?('stylesheet_link_tag "tailwind"')
+
+          tag = '    <%= stylesheet_link_tag "tailwind", "data-turbo-track": "reload" %>'
+          content = content.sub(/\s*<\/head>/, "\n#{tag}\n  </head>")
+
+          File.write(layout, content)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/addons/vcr_step.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class VcrStep < Step
+        def self.id = :vcr
+        def self.tier = :addon
+        def self.needs = [ :testing ]
+        def self.summary = "Configure VCR"
+        def self.description = "Installs VCR for recording and replaying HTTP interactions in tests."
+        def self.prompts = "Enable VCR for HTTP interaction recording? (default: no)"
+
+        VCR_VERSION = "6.2.0".freeze
+        WEBMOCK_VERSION = "3.23.1".freeze
+
+        MINIMAL_RAILS_HELPER = <<~RUBY
+          require 'spec_helper'
+          ENV['RAILS_ENV'] ||= 'test'
+          require_relative '../config/environment'
+          require 'rspec/rails'
+
+          RSpec.configure do |config|
+            config.fixture_paths = [
+              Rails.root.join('spec/fixtures')
+            ]
+            config.use_transactional_fixtures = true
+          end
+        RUBY
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          choice = shell.ask("Enable VCR for HTTP interaction recording? (default: no):").to_s.strip
+          choice = "no" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "yes", "y"
+              context.answer(:vcr, true)
+              break
+            when "no", "n"
+              context.answer(:vcr, false)
+              break
+            else
+              shell.say("Invalid. Enter 'yes' or 'no'.", :red)
+              choice = shell.ask("Enable VCR for HTTP interaction recording? (default: no):").to_s.strip
+              choice = "no" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          enabled = context.get(:vcr) == true
+
+          unless enabled
+            context.set_output(:vcr, { vcr: false })
+            return
+          end
+
+          add_test_group_gems(context)
+
+          if context.output(:testing, :test_framework) == :minitest
+            install_for_minitest(context)
+          else
+            install_for_rspec(context)
+          end
+
+          context.set_output(:vcr, { vcr: true })
+        end
+
+        def outputs(context)
+          context.output(:vcr)
+        end
+
+        private
+
+        def add_test_group_gems(context)
+          add_test_group_gem(context, "gem \"vcr\", \"#{VCR_VERSION}\"")
+          add_test_group_gem(context, "gem \"webmock\", \"#{WEBMOCK_VERSION}\"")
+        end
+
+        def add_test_group_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          content = File.read(gemfile_path)
+          return if content.include?(gem_line)
+
+          lines = content.lines
+          group_start = lines.index { |line| line.strip == "group :test do" }
+
+          if group_start
+            end_index = (group_start + 1...lines.size).find { |i| lines[i].strip == "end" }
+            lines.insert(end_index, "  #{gem_line}\n")
+          else
+            lines << "\n" unless lines.last.nil? || lines.last.end_with?("\n")
+            lines << "\ngroup :test do\n  #{gem_line}\nend\n"
+          end
+
+          File.write(gemfile_path, lines.join)
+        end
+
+        def vcr_config(cassette_dir)
+          <<~RUBY
+            require "vcr"
+            require "webmock"
+
+            VCR.configure do |config|
+              config.cassette_library_dir = "#{cassette_dir}"
+              config.hook_into :webmock
+
+              # Redact secrets from recorded cassettes before they're written to disk.
+              # Example: strip a bearer token from the Authorization header.
+              config.filter_sensitive_data("<API_KEY>") { ENV["API_KEY"] }
+            end
+          RUBY
+        end
+
+        def install_for_rspec(context)
+          support_path = File.join(context.app_path, "spec/support/vcr.rb")
+          FileUtils.mkdir_p(File.dirname(support_path))
+          File.write(support_path, vcr_config("spec/cassettes"))
+
+          ensure_rails_helper(context)
+          require_support_files(context)
+        end
+
+        def install_for_minitest(context)
+          support_path = File.join(context.app_path, "test/support/vcr.rb")
+          FileUtils.mkdir_p(File.dirname(support_path))
+          File.write(support_path, vcr_config("test/cassettes"))
+
+          require_line = "require_relative \"support/vcr\"\n"
+          test_helper_path = File.join(context.app_path, "test/test_helper.rb")
+          return unless File.exist?(test_helper_path)
+
+          content = File.read(test_helper_path)
+          return if content.include?(require_line)
+
+          File.write(test_helper_path, "#{require_line}#{content}")
+        end
+
+        def ensure_rails_helper(context)
+          rails_helper_path = File.join(context.app_path, "spec/rails_helper.rb")
+          return if File.exist?(rails_helper_path)
+
+          FileUtils.mkdir_p(File.dirname(rails_helper_path))
+          File.write(rails_helper_path, MINIMAL_RAILS_HELPER)
+        end
+
+        def require_support_files(context)
+          rails_helper_path = File.join(context.app_path, "spec/rails_helper.rb")
+          require_line = "require \"support/vcr\"\n"
+
+          content = File.read(rails_helper_path)
+          return if content.include?(require_line) || content.include?("support/**/*.rb")
+
+          lines = content.lines
+          require_index = lines.rindex { |line| line.start_with?("require") }
+          insert_at = require_index ? require_index + 1 : lines.size
+
+          lines.insert(insert_at, require_line)
+          File.write(rails_helper_path, lines.join)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/core/app_name_step.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Core
+      class AppNameStep < Step
+        def self.id = :app_name
+        def self.summary = "Set the application name"
+        def self.description = "Records the Rails application name used for the generated app."
+        def self.tier = :core
+        def self.prompts = "App name (free text, valid Ruby constant once camelized, no leading digit)"
+
+        RESERVED_NAMES = %w[ test application ].freeze
+
+        def prompt(context)
+          return if preset_name?(context)
+
+          loop do
+            raw = context.shell.ask("App name:")
+            raise OpinionatedRails::Error, "No app name given (input ended)" if raw.nil?
+
+            normalized = normalize(raw)
+            errors = validate(normalized)
+
+            if errors.empty?
+              context.answer(:app_name, normalized)
+              break
+            end
+
+            context.shell.say("Invalid: #{errors.join(', ')}", :red)
+          end
+        end
+
+        # `opinionated_rails new my_app` supplies the name up front; fall back to asking if it's invalid.
+        def preset_name?(context)
+          preset = context.get(:app_name_input)
+          return false if preset.to_s.strip.empty?
+
+          normalized = normalize(preset)
+          errors = validate(normalized)
+          if errors.empty?
+            context.answer(:app_name, normalized)
+            return true
+          end
+
+          context.shell.say("Invalid app name #{preset.inspect}: #{errors.join(', ')}", :red)
+          false
+        end
+
+        def generate(context)
+          name = context.get(:app_name)
+          errors = validate(name)
+
+          raise ArgumentError, "Invalid app name: #{errors.join(', ')}" unless errors.empty?
+
+          context.set_output(:app_name, { app_name: name })
+        end
+
+        def outputs(context)
+          context.output(:app_name)
+        end
+
+        private
+
+        def normalize(raw)
+          raw.to_s.strip.downcase.gsub(/[-\s]+/, "_").gsub(/[^a-z0-9_]/, "")
+        end
+
+        def validate(name)
+          errors = []
+          errors << "cannot be blank" if name.empty?
+          errors << "must start with a letter" if name.match?(/\A\d/)
+          errors << "must contain only letters, digits, underscores and hyphens" unless name.match?(/\A[a-z0-9_-]*\z/)
+          errors << "is a reserved name" if RESERVED_NAMES.include?(name)
+          errors << "collides with an existing constant" if name.match?(/\A[a-z]/) && Object.const_defined?(camelize(name))
+          errors
+        end
+
+        def camelize(name)
+          name.split("_").map(&:capitalize).join
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/core/app_type_step.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Core
+      class AppTypeStep < Step
+        def self.id = :app_type
+        def self.summary = "Choose API-only or full-stack"
+        def self.description = "Decides whether the app is API-only or a full-stack Rails app."
+        def self.tier = :core
+        def self.prompts = "App type: API-only or Full-stack (default: Full-stack)"
+
+        def prompt(context)
+          shell = context.shell
+          shell.say("Choose an app type:")
+          shell.say("  1. Full-stack")
+          shell.say("  2. API-only")
+
+          choice = shell.ask("App type (default: Full-stack):").to_s.strip
+          choice = "full-stack" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "full-stack", "1"
+              context.answer(:app_type, :full_stack)
+              break
+            when "api-only", "2"
+              context.answer(:app_type, :api_only)
+              break
+            else
+              shell.say("Invalid. Enter 'Full-stack', 'API-only', 1, or 2.", :red)
+              choice = shell.ask("App type (default: Full-stack):").to_s.strip
+              choice = "full-stack" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          type = context.get(:app_type)
+          raise ArgumentError, "No app type answer" unless type
+
+          context.set_output(:app_type, { app_type: type })
+        end
+
+        def outputs(context)
+          context.output(:app_type)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/core/database_step.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Core
+      class DatabaseStep < Step
+        def self.id = :database
+        def self.summary = "Choose the database"
+        def self.description = "Prompts for the database adapter (SQLite, PostgreSQL, MySQL)."
+        def self.tier = :core
+        def self.prompts = "Database adapter: SQLite, PostgreSQL, or MySQL (default: SQLite)"
+
+        ADAPTERS = {
+          "sqlite" => :sqlite3,
+          "postgresql" => :postgresql,
+          "mysql" => :mysql2
+        }.freeze
+
+        DISPLAY_NAMES = %w[ SQLite PostgreSQL MySQL ].freeze
+
+        def prompt(context)
+          shell = context.shell
+          shell.say("Choose a database:")
+          DISPLAY_NAMES.each_with_index { |name, index| shell.say("  #{index + 1}. #{name}") }
+
+          loop do
+            choice = shell.ask("Database (default: SQLite):").to_s.strip.downcase
+            choice = "sqlite" if choice.empty?
+            choice = ADAPTERS.keys[choice.to_i - 1] if %w[1 2 3].include?(choice)
+
+            if ADAPTERS.key?(choice)
+              context.answer(:database, ADAPTERS[choice])
+              break
+            end
+
+            shell.say("Invalid choice. Enter #{DISPLAY_NAMES.join(', ')}.", :red)
+          end
+        end
+
+        def generate(context)
+          adapter = context.get(:database)
+          raise ArgumentError, "No database answer" unless adapter
+
+          context.set_output(:database, { database: adapter })
+        end
+
+        def outputs(context)
+          context.output(:database)
+        end
+      end
+    end
+  end
+end