twitter-bootstrap-rails 5.3.0 → 5.4.0

data/lib/twitter/bootstrap/rails/config.rb

@@ -0,0 +1,54 @@
+require "twitter/bootstrap/rails/version"
+
+module Twitter
+  module Bootstrap
+    module Rails
+      # How the host app loads Bootstrap's assets. `rails g bootstrap:install cdn`
+      # writes an initializer setting this to :cdn; `bootstrap:layout` reads it to
+      # pick its default. Defaults to :static so the layout generator works whether
+      # or not that initializer exists.
+      VALID_ASSET_MODES = [:static, :cdn].freeze
+
+      @asset_mode = :static
+
+      class << self
+        attr_reader :asset_mode
+
+        def asset_mode=(mode)
+          mode = mode.to_sym
+          unless VALID_ASSET_MODES.include?(mode)
+            raise ArgumentError,
+              "asset_mode must be one of #{VALID_ASSET_MODES.inspect}, got #{mode.inspect}"
+          end
+          @asset_mode = mode
+        end
+
+        def cdn?
+          asset_mode == :cdn
+        end
+
+        # Which asset pipeline the host app runs. Propshaft (the Rails 8 default)
+        # has no Sprockets directives: a `//= require` line in a manifest is an
+        # inert comment there, so assets have to be linked explicitly instead.
+        def asset_pipeline
+          return @asset_pipeline if defined?(@asset_pipeline) && @asset_pipeline
+
+          if defined?(::Propshaft)
+            :propshaft
+          elsif defined?(::Sprockets)
+            :sprockets
+          else
+            :unknown
+          end
+        end
+
+        # Set explicitly to override detection (used by the specs).
+        attr_writer :asset_pipeline
+
+        def propshaft?
+          asset_pipeline == :propshaft
+        end
+      end
+    end
+  end
+end

data/lib/twitter/bootstrap/rails/engine.rb

@@ -12,14 +12,6 @@ module Twitter
   module Bootstrap
     module Rails
       class Engine < ::Rails::Engine
-        initializer 'twitter-bootstrap-rails.setup',
-          :after => 'less-rails.after.load_config_initializers',
-          :group => :all do |app|
-            if defined?(Less)
-              app.config.less.paths << File.join(config.root, 'vendor', 'toolkit')
-            end
-          end
-
         initializer 'twitter-bootstrap-rails.setup_helpers' do |app|
           app.config.to_prepare do
             ActionController::Base.send :include, Breadcrumbs

data/lib/twitter/bootstrap/rails/version.rb

@@ -1,7 +1,34 @@
 module Twitter
   module Bootstrap
     module Rails
-      VERSION = "5.3.0"
+      VERSION = "5.4.0"
+
+      # The Bootstrap release this gem vendors and links to. The gem version no
+      # longer tracks it; this constant is the authoritative statement.
+      BOOTSTRAP_VERSION = "5.3.8"
+      POPPER_VERSION = "2.11.8"
+
+      # URLs and Subresource Integrity hashes exactly as published on
+      # https://getbootstrap.com/docs/5.3/getting-started/introduction/
+      # Bumping Bootstrap means editing this hash and re-vendoring the dist files.
+      BOOTSTRAP_CDN = {
+        :css => {
+          :url => "https://cdn.jsdelivr.net/npm/bootstrap@#{BOOTSTRAP_VERSION}/dist/css/bootstrap.min.css",
+          :integrity => "sha384-sRIl4kxILFvY47J16cr9ZwB07vP4J8+LH7qKQnuqkuIAvNWLzeN8tE5YBujZqJLB"
+        },
+        :bundle => {
+          :url => "https://cdn.jsdelivr.net/npm/bootstrap@#{BOOTSTRAP_VERSION}/dist/js/bootstrap.bundle.min.js",
+          :integrity => "sha384-FKyoEForCGlyvwx9Hj09JcYn3nv7wiPVlz7YYwJrWVcXK/BmnVDxM+D2scQbITxI"
+        },
+        :js => {
+          :url => "https://cdn.jsdelivr.net/npm/bootstrap@#{BOOTSTRAP_VERSION}/dist/js/bootstrap.min.js",
+          :integrity => "sha384-G/EV+4j2dNv+tEPo3++6LCgdCROaejBqfUeNjuKAiuXbjrxilcCdDz6ZAVfHWe1Y"
+        },
+        :popper => {
+          :url => "https://cdn.jsdelivr.net/npm/@popperjs/core@#{POPPER_VERSION}/dist/umd/popper.min.js",
+          :integrity => "sha384-I7E8VVD/ismYTF4hNIPjVp/Zjvgyol6VFvRkX/vR+Vc4jQkC+hVqc2pM8ODewa9r"
+        }
+      }.freeze
     end
   end
 end

data/lib/twitter-bootstrap-rails.rb

@@ -6,5 +6,4 @@ module Twitter
   end
 end
 
-#require 'less-rails'
 require 'twitter/bootstrap/rails/bootstrap' if defined?(Rails)

data/spec/lib/generators/cdn_generator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Bootstrap::Generators::CdnGenerator do
+  let(:cdn) { Twitter::Bootstrap::Rails::BOOTSTRAP_CDN }
+
+  it "prints the stylesheet link and the JS bundle by default" do
+    output = run_generator(described_class)
+
+    expect(output).to include(cdn[:css][:url])
+    expect(output).to include(cdn[:css][:integrity])
+    expect(output).to include(cdn[:bundle][:url])
+    expect(output).to include(cdn[:bundle][:integrity])
+  end
+
+  it "prints only the stylesheet link with --css" do
+    output = run_generator(described_class, %w[--css])
+
+    expect(output).to include(cdn[:css][:url])
+    expect(output).not_to include(cdn[:bundle][:url])
+  end
+
+  it "prints only the bundle script with --js" do
+    output = run_generator(described_class, %w[--js])
+
+    expect(output).to include(cdn[:bundle][:url])
+    expect(output).not_to include(cdn[:css][:url])
+  end
+
+  it "prints the Popper pair with --separate-popper" do
+    output = run_generator(described_class, %w[--separate-popper])
+
+    expect(output).to include(cdn[:popper][:url])
+    expect(output).to include(cdn[:js][:url])
+    expect(output).not_to include(cdn[:bundle][:url])
+  end
+
+  it "writes nothing to disk" do
+    run_generator(described_class)
+
+    expect(Dir.children(destination_root)).to be_empty
+  end
+end

data/spec/lib/generators/install_generator_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Bootstrap::Generators::InstallGenerator do
+  let(:vendored_css) { 'app/assets/stylesheets/twitter/bootstrap/bootstrap.min.css' }
+  let(:vendored_js) { 'app/assets/javascripts/twitter/bootstrap/bootstrap.bundle.min.js' }
+
+  describe "static (the default)" do
+    it "vendors both Bootstrap dist files into the app" do
+      run_generator(described_class, %w[static])
+
+      expect(destination_exist?(vendored_css)).to be true
+      expect(destination_exist?(vendored_js)).to be true
+    end
+
+    it "vendors the Bootstrap version this gem declares" do
+      run_generator(described_class, %w[static])
+
+      expect(read_destination(vendored_css)).to include("Bootstrap  v#{Twitter::Bootstrap::Rails::BOOTSTRAP_VERSION}")
+      expect(read_destination(vendored_js)).to include("Bootstrap v#{Twitter::Bootstrap::Rails::BOOTSTRAP_VERSION}")
+    end
+
+    it "defaults to static when no mode is given" do
+      run_generator(described_class)
+
+      expect(destination_exist?(vendored_css)).to be true
+    end
+
+    it "writes manifests that require the vendored files" do
+      run_generator(described_class, %w[static])
+
+      expect(read_destination('app/assets/javascripts/application.js'))
+        .to include("//= require twitter/bootstrap/bootstrap.bundle.min")
+      expect(read_destination('app/assets/stylesheets/bootstrap_and_overrides.css'))
+        .to include("*= require twitter/bootstrap/bootstrap.min")
+    end
+
+    it "adds the require lines to manifests the app already has" do
+      write_destination('app/assets/javascripts/application.js', "// application\n//= require_tree .\n")
+      write_destination('app/assets/stylesheets/application.css', "/*\n *= require_self\n *= require_tree .\n*/\n")
+
+      run_generator(described_class, %w[static])
+
+      expect(read_destination('app/assets/javascripts/application.js'))
+        .to include("//= require twitter/bootstrap/bootstrap.bundle.min")
+      expect(read_destination('app/assets/stylesheets/application.css'))
+        .to include("*= require bootstrap_and_overrides")
+    end
+
+    it "says what to add by hand when a manifest has no Sprockets anchor" do
+      # A Propshaft app's application.css is plain CSS with nothing to anchor to.
+      write_destination('app/assets/stylesheets/application.css', "/*\n * Propshaft manifest.\n */\n")
+
+      output = run_generator(described_class, %w[static])
+
+      expect(output).to match(/has no `require_self` directive to anchor to/)
+      expect(output).to include("*= require bootstrap_and_overrides")
+      expect(read_destination('app/assets/stylesheets/application.css')).not_to include("require bootstrap_and_overrides")
+    end
+
+    it "does not duplicate require lines when run twice" do
+      run_generator(described_class, %w[static])
+      run_generator(described_class, %w[static])
+
+      js = read_destination('app/assets/javascripts/application.js')
+      expect(js.scan("require twitter/bootstrap/bootstrap.bundle.min").length).to eq(1)
+    end
+
+    it "writes no CDN initializer" do
+      run_generator(described_class, %w[static])
+
+      expect(destination_exist?('config/initializers/bootstrap.rb')).to be false
+    end
+
+    it "raises rather than silently installing nothing when a dist file is missing" do
+      allow(File).to receive(:file?).and_call_original
+      allow(File).to receive(:file?).with(/bootstrap\.min\.css\z/).and_return(false)
+
+      expect {
+        run_generator(described_class, %w[static])
+      }.to raise_error(described_class::MissingAssetError, /bootstrap\.min\.css/)
+    end
+  end
+
+  # Propshaft is the Rails 8 default and has no Sprockets directives: a
+  # `//= require` line there is an inert comment, so writing manifests that rely
+  # on one would ship an app with no Bootstrap at all.
+  describe "static on a Propshaft app" do
+    before { Twitter::Bootstrap::Rails.asset_pipeline = :propshaft }
+
+    it "still vendors both dist files" do
+      run_generator(described_class, %w[static])
+
+      expect(destination_exist?(vendored_css)).to be true
+      expect(destination_exist?(vendored_js)).to be true
+    end
+
+    it "writes no Sprockets manifests" do
+      run_generator(described_class, %w[static])
+
+      expect(destination_exist?('app/assets/javascripts/application.js')).to be false
+      expect(destination_exist?('app/assets/stylesheets/bootstrap_and_overrides.css')).to be false
+    end
+
+    it "does not touch an existing application.css" do
+      original = "/*\n * Propshaft manifest.\n */\n"
+      write_destination('app/assets/stylesheets/application.css', original)
+
+      run_generator(described_class, %w[static])
+
+      expect(read_destination('app/assets/stylesheets/application.css')).to eq(original)
+    end
+
+    it "points the user at bootstrap:layout" do
+      output = run_generator(described_class, %w[static])
+
+      expect(output).to match(/vendored for Propshaft/)
+    end
+  end
+
+  describe "cdn" do
+    it "vendors nothing" do
+      run_generator(described_class, %w[cdn])
+
+      expect(destination_exist?(vendored_css)).to be false
+      expect(destination_exist?(vendored_js)).to be false
+    end
+
+    it "writes an initializer selecting cdn mode" do
+      run_generator(described_class, %w[cdn])
+
+      expect(read_destination('config/initializers/bootstrap.rb'))
+        .to include("Twitter::Bootstrap::Rails.asset_mode = :cdn")
+    end
+
+    it "creates no asset manifests" do
+      run_generator(described_class, %w[cdn])
+
+      expect(destination_exist?('app/assets/javascripts/application.js')).to be false
+      expect(destination_exist?('app/assets/stylesheets/bootstrap_and_overrides.css')).to be false
+    end
+  end
+
+  it "rejects an unknown mode" do
+    expect {
+      run_generator(described_class, %w[less])
+    }.to raise_error(Rails::Generators::Error, /Expected 'static' or 'cdn'/)
+  end
+end

data/spec/lib/generators/layout_generator_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Bootstrap::Generators::LayoutGenerator do
+  let(:cdn) { Twitter::Bootstrap::Rails::BOOTSTRAP_CDN }
+
+  # The generated layout for the given engine.
+  def generate_layout(args = [], engine: :erb)
+    stub_rails_application(engine)
+    run_generator(described_class, args)
+    read_destination("app/views/layouts/application.html.#{engine}")
+  end
+
+  [:erb, :haml, :slim].each do |engine|
+    context "with the #{engine} template engine" do
+      it "uses the asset pipeline by default" do
+        layout = generate_layout([], :engine => engine)
+
+        expect(layout).to include('stylesheet_link_tag "application"')
+        expect(layout).to include('javascript_include_tag "application"')
+        expect(layout).not_to include("cdn.jsdelivr.net")
+      end
+
+      it "emits the CDN link and bundle with --cdn" do
+        layout = generate_layout(%w[--cdn], :engine => engine)
+
+        expect(layout).to include(cdn[:css][:url])
+        expect(layout).to include(cdn[:css][:integrity])
+        expect(layout).to include(cdn[:bundle][:url])
+        expect(layout).to include(cdn[:bundle][:integrity])
+        expect(layout).to include('crossorigin="anonymous"')
+      end
+
+      it "does not also link the pipeline when using --cdn" do
+        layout = generate_layout(%w[--cdn], :engine => engine)
+
+        expect(layout).not_to include('stylesheet_link_tag')
+        expect(layout).not_to include('javascript_include_tag')
+      end
+
+      it "emits Popper and bootstrap.js instead of the bundle with --cdn --separate-popper" do
+        layout = generate_layout(%w[--cdn --separate-popper], :engine => engine)
+
+        expect(layout).to include(cdn[:popper][:url])
+        expect(layout).to include(cdn[:popper][:integrity])
+        expect(layout).to include(cdn[:js][:url])
+        expect(layout).to include(cdn[:js][:integrity])
+        expect(layout).not_to include(cdn[:bundle][:url])
+      end
+
+      it "includes the important globals: doctype, html lang, and viewport" do
+        layout = generate_layout([], :engine => engine)
+
+        expect(layout).to match(/\A(<!doctype html>|!!!|doctype html)/)
+        expect(layout).to match(/lang[^\n]*en/)
+        expect(layout).to include("width=device-width, initial-scale=1")
+      end
+
+      it "carries no Bootstrap 3 markup" do
+        layout = generate_layout([], :engine => engine)
+
+        expect(layout).not_to include("navbar-default")
+        expect(layout).not_to include("icon-bar")
+        expect(layout).not_to include("html5shiv")
+        expect(layout).not_to match(/\bwell\b/)
+      end
+    end
+  end
+
+  describe "on a Propshaft app" do
+    before { Twitter::Bootstrap::Rails.asset_pipeline = :propshaft }
+
+    [:erb, :haml, :slim].each do |engine|
+      it "links the vendored Bootstrap explicitly in #{engine}, since require directives are inert" do
+        layout = generate_layout([], :engine => engine)
+
+        expect(layout).to include('stylesheet_link_tag "twitter/bootstrap/bootstrap.min", "application"')
+        expect(layout).to include('javascript_include_tag "twitter/bootstrap/bootstrap.bundle.min"')
+      end
+    end
+
+    it "does not link an application.js that Propshaft apps do not have" do
+      layout = generate_layout
+
+      expect(layout).not_to include('javascript_include_tag "twitter/bootstrap/bootstrap.bundle.min", "application"')
+    end
+
+    it "still uses the CDN when asked" do
+      layout = generate_layout(%w[--cdn])
+
+      expect(layout).to include(cdn[:css][:url])
+      expect(layout).not_to include('stylesheet_link_tag')
+    end
+  end
+
+  it "names the layout after the given argument" do
+    stub_rails_application(:erb)
+    run_generator(described_class, %w[admin])
+
+    expect(destination_exist?("app/views/layouts/admin.html.erb")).to be true
+  end
+
+  it "warns and falls back to the bundle when --separate-popper is used without --cdn" do
+    stub_rails_application(:erb)
+    output = run_generator(described_class, %w[--separate-popper])
+
+    expect(output).to match(/separate-popper only applies with --cdn/)
+    expect(read_destination("app/views/layouts/application.html.erb")).not_to include(cdn[:popper][:url])
+  end
+
+  it "defaults to CDN tags when bootstrap:install recorded cdn mode" do
+    Twitter::Bootstrap::Rails.asset_mode = :cdn
+    layout = generate_layout
+
+    expect(layout).to include(cdn[:css][:url])
+  end
+
+  it "lets --no-cdn override a recorded cdn mode" do
+    Twitter::Bootstrap::Rails.asset_mode = :cdn
+    layout = generate_layout(%w[--no-cdn])
+
+    expect(layout).to include('stylesheet_link_tag "application"')
+    expect(layout).not_to include("cdn.jsdelivr.net")
+  end
+end

data/spec/lib/generators/no_hardcoded_versions_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+# Bumping Bootstrap should be a one-file change. If a template hardcodes a CDN
+# URL or an integrity hash, that promise quietly breaks.
+describe "generator templates" do
+  gem_root = File.expand_path("../../../..", __FILE__)
+
+  let(:template_files) do
+    Dir[File.join(gem_root, "lib/generators/**/templates/**/*")].select { |f| File.file?(f) }
+  end
+
+  it "has templates to check" do
+    expect(template_files).not_to be_empty
+  end
+
+  it "hardcodes no Bootstrap CDN version" do
+    offenders = template_files.select { |f| File.read(f).include?("bootstrap@") }
+
+    expect(offenders).to be_empty,
+      "these templates hardcode a CDN version instead of using the constants: #{offenders.inspect}"
+  end
+
+  it "hardcodes no Subresource Integrity hash" do
+    offenders = template_files.select { |f| File.read(f).match?(/sha384-/) }
+
+    expect(offenders).to be_empty,
+      "these templates hardcode an integrity hash instead of using the constants: #{offenders.inspect}"
+  end
+
+  it "keeps the vendored assets on the version the gem declares" do
+    version = Twitter::Bootstrap::Rails::BOOTSTRAP_VERSION
+
+    {
+      "vendor/assets/stylesheets/twitter/bootstrap/bootstrap.min.css" => "Bootstrap  v#{version}",
+      "vendor/assets/javascripts/twitter/bootstrap/bootstrap.bundle.min.js" => "Bootstrap v#{version}",
+      "app/assets/stylesheets/twitter-bootstrap-static/bootstrap.css" => "Bootstrap  v#{version}",
+      "app/assets/javascripts/twitter/bootstrap/bootstrap.min.js" => "Bootstrap v#{version}"
+    }.each do |path, banner|
+      full = File.join(gem_root, path)
+      expect(File.exist?(full)).to be(true), "missing vendored asset #{path}"
+      expect(File.read(full, 400)).to include(banner),
+        "#{path} is not Bootstrap #{version}"
+    end
+  end
+end

data/spec/lib/generators/snippet_generators_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe "Bootstrap snippet generators" do
+  Catalog = Bootstrap::Generators::SnippetCatalog
+  TEMPLATE_ROOT = File.expand_path("../../../../lib/generators/bootstrap/snippets/templates", __FILE__)
+
+  def generator_for(name)
+    Bootstrap::Generators.const_get("#{name.split('_').map(&:capitalize).join}Generator")
+  end
+
+  describe "the catalog" do
+    it "covers all twelve snippet categories from the docs" do
+      expect(Catalog::GENERATORS.values.sort).to eq(%w[
+        badges breadcrumbs buttons dropdowns features footers headers heroes
+        jumbotrons list-groups modals sidebars
+      ].sort)
+    end
+
+    it "has a template file for every catalogued variant" do
+      missing = Catalog::VARIANTS.flat_map do |category, variants|
+        variants.map { |v| "#{category}/#{v[:name]}" }
+               .reject { |rel| File.exist?(File.join(TEMPLATE_ROOT, "#{rel}.html.erb")) }
+      end
+
+      expect(missing).to be_empty, "catalogued variants with no template: #{missing.inspect}"
+    end
+
+    it "has a catalog entry for every template file" do
+      on_disk = Dir[File.join(TEMPLATE_ROOT, "*", "*.html.erb")]
+                .reject { |f| File.basename(File.dirname(f)) == "icons" }
+                .map { |f| "#{File.basename(File.dirname(f))}/#{File.basename(f, '.html.erb')}" }
+      catalogued = Catalog::VARIANTS.flat_map { |c, vs| vs.map { |v| "#{c}/#{v[:name]}" } }
+
+      expect((on_disk - catalogued)).to be_empty,
+        "templates with no catalog entry: #{(on_disk - catalogued).inspect}"
+    end
+
+    it "flags exactly the variants whose markup references the icon sprite" do
+      Catalog::VARIANTS.each do |category, variants|
+        variants.each do |v|
+          markup = File.read(File.join(TEMPLATE_ROOT, category, "#{v[:name]}.html.erb"))
+          expect(markup.include?('xlink:href="#')).to eq(v[:icons]),
+            "#{category}/#{v[:name]} :icons flag is #{v[:icons]} but markup says otherwise"
+        end
+      end
+    end
+
+    it "flags exactly the variants that reference docs-site placeholder images" do
+      placeholders = ["bootstrap-docs.png", "bootstrap-themes.png",
+                      "/docs/5.3/assets/", "unsplash-photo-"]
+
+      Catalog::VARIANTS.each do |category, variants|
+        variants.each do |v|
+          markup = File.read(File.join(TEMPLATE_ROOT, category, "#{v[:name]}.html.erb"))
+          expect(placeholders.any? { |p| markup.include?(p) }).to eq(!!v[:images]),
+            "#{category}/#{v[:name]} :images flag is #{v[:images]} but markup says otherwise"
+        end
+      end
+    end
+
+    it "gives every variant a unique name within its category" do
+      Catalog::VARIANTS.each do |category, variants|
+        names = variants.map { |v| v[:name] }
+        expect(names.uniq).to eq(names), "duplicate variant names in #{category}"
+      end
+    end
+  end
+
+  describe "the shipped snippet markup" do
+    let(:templates) { Dir[File.join(TEMPLATE_ROOT, "*", "*.html.erb")] }
+
+    it "carries no leftover docs page chrome" do
+      offenders = templates.select do |f|
+        body = File.read(f)
+        body.include?("b-example-divider") || body.include?("bd-mode-toggle") ||
+          body.match?(/<h1 class="visually-hidden">[^<]*examples/)
+      end
+
+      expect(offenders).to be_empty, "page chrome leaked into: #{offenders.inspect}"
+    end
+
+    it "keeps viewBox correctly cased so icons render" do
+      offenders = templates.select { |f| File.read(f).include?("viewbox=") }
+
+      expect(offenders).to be_empty, "lowercased viewBox (icons will not render) in: #{offenders.inspect}"
+    end
+
+    it "references only icons that the sprite defines" do
+      sprite = File.read(File.join(TEMPLATE_ROOT, "icons", "_bootstrap_icons.html.erb"))
+      defined_ids = sprite.scan(/<symbol id="([^"]+)"/).flatten
+
+      referenced = templates.flat_map { |f| File.read(f).scan(/<use xlink:href="#([^"]+)"/).flatten }.uniq
+
+      expect(referenced - defined_ids).to be_empty,
+        "snippets reference icons missing from the sprite: #{(referenced - defined_ids).inspect}"
+    end
+  end
+
+  describe "generating a snippet" do
+    it "writes the default variant as a partial" do
+      run_generator(generator_for("header"))
+
+      expect(destination_exist?('app/views/shared/_header.html.erb')).to be true
+    end
+
+    it "writes the requested variant" do
+      run_generator(generator_for("hero"), %w[dark])
+
+      partial = read_destination('app/views/shared/_hero.html.erb')
+      expected = File.read(File.join(TEMPLATE_ROOT, "heroes", "dark.html.erb"))
+      expect(partial).to eq(expected)
+    end
+
+    it "accepts dashes in place of underscores" do
+      run_generator(generator_for("footer"), %w[with-newsletter])
+
+      expect(read_destination('app/views/shared/_footer.html.erb'))
+        .to eq(File.read(File.join(TEMPLATE_ROOT, "footers", "with_newsletter.html.erb")))
+    end
+
+    it "honours --as" do
+      run_generator(generator_for("footer"), %w[columns --as=site_footer])
+
+      expect(destination_exist?('app/views/shared/_site_footer.html.erb')).to be true
+      expect(destination_exist?('app/views/shared/_footer.html.erb')).to be false
+    end
+
+    it "honours --path" do
+      run_generator(generator_for("badge"), %w[pills --path=app/views/components])
+
+      expect(destination_exist?('app/views/components/_badge.html.erb')).to be true
+    end
+
+    it "tells the user how to render it" do
+      output = run_generator(generator_for("modal"), %w[confirm])
+
+      expect(output).to include('render "shared/modal"')
+    end
+
+    it "raises on an unknown variant, listing the valid ones" do
+      expect {
+        run_generator(generator_for("badge"), %w[neon])
+      }.to raise_error(Rails::Generators::Error, /Unknown badges variant "neon".*pills, subtle/m)
+    end
+  end
+
+  describe "the icons sprite" do
+    it "is installed alongside a snippet that needs it" do
+      run_generator(generator_for("header"), %w[dark_search])
+
+      expect(destination_exist?('app/views/shared/_bootstrap_icons.html.erb')).to be true
+    end
+
+    it "is not installed for a snippet that does not use icons" do
+      run_generator(generator_for("header"), %w[nav_pills])
+
+      expect(destination_exist?('app/views/shared/_bootstrap_icons.html.erb')).to be false
+    end
+
+    it "can be skipped with --no-icons" do
+      run_generator(generator_for("header"), %w[dark_search --no-icons])
+
+      expect(destination_exist?('app/views/shared/_header.html.erb')).to be true
+      expect(destination_exist?('app/views/shared/_bootstrap_icons.html.erb')).to be false
+    end
+
+    it "follows --path" do
+      run_generator(generator_for("header"), %w[dark_search --path=app/views/components])
+
+      expect(destination_exist?('app/views/components/_bootstrap_icons.html.erb')).to be true
+    end
+  end
+
+  describe "--list" do
+    it "prints each variant with its description and writes nothing" do
+      output = run_generator(generator_for("sidebar"), %w[--list])
+
+      expect(output).to include("icon_only")
+      expect(output).to include("Narrow icon-only sidebar")
+      expect(output).to include("Default: dark")
+      expect(Dir.children(destination_root)).to be_empty
+    end
+  end
+
+  describe "every generator" do
+    Bootstrap::Generators::SnippetCatalog::GENERATORS.each do |generator_name, category|
+      it "bootstrap:#{generator_name} generates each of its #{category} variants" do
+        klass = generator_for(generator_name)
+
+        Catalog.variant_names(category).each do |variant|
+          remove_destination_root
+          run_generator(klass, [variant])
+
+          partial = destination_path("app/views/shared/_#{generator_name}.html.erb")
+          expect(File.exist?(partial)).to be(true), "#{generator_name} #{variant} wrote nothing"
+          expect(File.size(partial)).to be > 50
+        end
+      end
+    end
+  end
+end