rails2static 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd83d25a90cc44c2e6154ccc5ac5c92743a08789bdf4570a1aed6ef6b8fd6545
+  data.tar.gz: 61ab9a728ee7ad23e0d2fcf2953dee3fa89d2905ce1f4096775804eea51beae8
+SHA512:
+  metadata.gz: 882585a94c5c0dfe240603d401a7fc51da998182c3f8300aca96212af698975b3edc9d5198b183a2f75936d60108d2fb92d58f874c9d4c143be79faadc773405
+  data.tar.gz: c20cf0177c17118ac081363f032de783b559cdd7f3dc2f7cfbd096317501e8329ea74f32cb137e28b0053e424597b711c524f665958517050900d46196b73c1d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ian Terrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# Rails2static
+
+Generate a deployable static site from a server-rendered Rails app. Add the gem, run a rake task, and get a `_site/` directory with HTML, CSS, JS, and images ready to deploy anywhere.
+
+Rails2static uses [Rack::Test](https://github.com/rack/rack-test) to call your Rails app directly — no running server needed. It crawls your app through the full middleware stack, rewrites links for static hosting, and collects all referenced assets.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rails2static"
+```
+
+Then `bundle install`.
+
+Generate the initializer:
+
+```sh
+rails generate rails2static:install
+```
+
+## Usage
+
+```sh
+rake rails2static
+# or
+rake static:generate
+```
+
+This will:
+
+1. BFS-crawl your app starting from `/`
+2. Rewrite internal links for static hosting
+3. Collect all referenced CSS, JS, images, and fonts
+4. Copy `public/` directory files (favicon, robots.txt, etc.)
+5. Write everything to `_site/`
+
+Preview the result locally:
+
+```sh
+rake static:preview
+```
+
+This starts a local server at http://localhost:8000 serving your generated site.
+
+## Configuration
+
+The install generator creates `config/initializers/rails2static.rb` with all options commented out. Uncomment and adjust as needed:
+
+```ruby
+Rails2static.configure do |config|
+  config.output_dir = "_site"              # Output directory (default: "_site")
+  config.entry_paths = ["/"]               # Starting paths for the crawl (default: ["/"])
+  config.host = "www.example.com"          # Host header sent with requests (default: "www.example.com")
+  config.trailing_slash = true             # /about -> /about/index.html (default: true)
+                                           # false  -> /about -> /about.html
+  config.exclude_patterns = [%r{/admin}]   # Regex patterns to skip (default: [])
+  config.include_assets = true             # Collect CSS/JS/images (default: true)
+  config.max_pages = 10_000                # Safety limit on pages crawled (default: 10,000)
+end
+```
+
+## How it works
+
+- **Crawler** — BFS from entry paths using `Rack::Test::Session`. Normalizes paths, follows redirects internally, detects cycles, skips external links, warns on 404s.
+- **Link Extractor** — Parses HTML with Nokogiri for `<a>`, `<link>`, `<script>`, `<img>`, `srcset`, `<video>`, and `<audio>` references.
+- **Link Rewriter** — Rewrites `<a href>` values so links work on static hosts. Skips external links, anchors, mailto/tel, and paths with file extensions.
+- **Asset Collector** — Fetches all asset URLs found in HTML via Rack::Test. Parses CSS for `url()` and `@import` references and fetches those recursively.
+- **Writer** — Writes HTML as `path/index.html` (trailing slash mode) or `path.html`. Non-HTML content keeps its original path. Binary content uses `binwrite`.
+
+## Demo
+
+The `demo/` directory contains a fully working Rails blog app that showcases rails2static. It uses SQLite with a pre-seeded database so you can try it immediately:
+
+```sh
+cd demo
+bundle install
+rake rails2static     # generates _site/
+rake static:preview   # serves it at http://localhost:8000
+```
+
+The demo app includes:
+
+- Posts with categories (HABTM), an about page, and a shared layout
+- Admin scaffolds at `/admin` (excluded from static output)
+- 4 seed posts, 3 categories, and an about page
+
+## License
+
+MIT

data/lib/generators/rails2static/install_generator.rb

@@ -0,0 +1,11 @@
+module Rails2static
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+
+    desc "Creates a Rails2static initializer"
+
+    def copy_initializer
+      template "rails2static.rb", "config/initializers/rails2static.rb"
+    end
+  end
+end

data/lib/generators/rails2static/templates/rails2static.rb

@@ -0,0 +1,23 @@
+Rails2static.configure do |config|
+  # Output directory for the generated static site
+  # config.output_dir = "_site"
+
+  # Starting paths for the crawl
+  # config.entry_paths = ["/"]
+
+  # Host header sent with requests
+  # config.host = "www.example.com"
+
+  # URL style: true  -> /about/index.html (works with most static hosts)
+  #            false -> /about.html
+  # config.trailing_slash = true
+
+  # Regex patterns for paths to skip
+  # config.exclude_patterns = [%r{/admin}]
+
+  # Collect and write CSS, JS, images, and fonts
+  # config.include_assets = true
+
+  # Safety limit on pages crawled
+  # config.max_pages = 10_000
+end

data/lib/rails2static/asset_collector.rb

@@ -0,0 +1,103 @@
+require "rack/test"
+require "set"
+
+module Rails2static
+  class AssetCollector
+    include Rack::Test::Methods
+
+    attr_reader :assets
+
+    def initialize(app:, config: Rails2static.configuration)
+      @app = app
+      @config = config
+      @assets = []
+      @fetched = Set.new
+    end
+
+    def app
+      @app
+    end
+
+    def collect(pages)
+      asset_urls = Set.new
+
+      pages.each do |page|
+        next unless page.html?
+
+        extractor = LinkExtractor.new(page.body, base_path: page.path)
+        extractor.asset_urls.each { |url| asset_urls.add(url) }
+      end
+
+      asset_urls.each { |url| fetch_asset(url) }
+
+      @assets
+    end
+
+    private
+
+    def fetch_asset(path)
+      return if @fetched.include?(path)
+
+      @fetched.add(path)
+
+      header("Host", @config.host)
+      get(path)
+
+      unless last_response.status == 200
+        log("  ASSET WARNING: #{last_response.status} #{path}")
+        return
+      end
+
+      content_type = last_response.content_type.to_s
+      body = last_response.body
+
+      page = Page.new(path: path, status: 200, content_type: content_type, body: body)
+      @assets << page
+
+      if page.css?
+        extract_css_refs(body, path).each { |ref| fetch_asset(ref) }
+      end
+
+      log("  ASSET #{path} (#{content_type})")
+    end
+
+    def extract_css_refs(css_body, base_path)
+      refs = []
+      dir = File.dirname(base_path)
+
+      css_body.scan(/url\(\s*['"]?([^'")]+?)['"]?\s*\)/) do |match|
+        url = match[0].strip
+        next if url.start_with?("data:")
+        next if url.match?(%r{\Ahttps?://})
+
+        resolved = if url.start_with?("/")
+                     url
+                   else
+                     File.join(dir, url)
+                   end
+
+        clean = resolved.split("?").first.split("#").first
+        refs << clean
+      end
+
+      css_body.scan(/@import\s+['"]([^'"]+)['"]/) do |match|
+        url = match[0].strip
+        next if url.match?(%r{\Ahttps?://})
+
+        resolved = if url.start_with?("/")
+                     url
+                   else
+                     File.join(dir, url)
+                   end
+
+        refs << resolved.split("?").first
+      end
+
+      refs.uniq
+    end
+
+    def log(message)
+      $stdout.puts message
+    end
+  end
+end

data/lib/rails2static/configuration.rb

@@ -0,0 +1,22 @@
+module Rails2static
+  class Configuration
+    attr_accessor :output_dir, :entry_paths, :host, :protocol,
+                  :trailing_slash, :exclude_patterns, :include_assets,
+                  :max_pages
+
+    def initialize
+      @output_dir = "_site"
+      @entry_paths = ["/"]
+      @host = "www.example.com"
+      @protocol = "https"
+      @trailing_slash = true
+      @exclude_patterns = []
+      @include_assets = true
+      @max_pages = 10_000
+    end
+
+    def excluded?(path)
+      exclude_patterns.any? { |pattern| path.match?(pattern) }
+    end
+  end
+end

data/lib/rails2static/crawler.rb

@@ -0,0 +1,107 @@
+require "rack/test"
+require "set"
+require "uri"
+
+module Rails2static
+  class Crawler
+    include Rack::Test::Methods
+
+    attr_reader :pages
+
+    def initialize(app:, config: Rails2static.configuration)
+      @app = app
+      @config = config
+      @pages = []
+      @visited = Set.new
+      @queue = []
+    end
+
+    def app
+      @app
+    end
+
+    def crawl
+      @config.entry_paths.each { |path| enqueue(path) }
+
+      while (path = @queue.shift)
+        break if @pages.size >= @config.max_pages
+
+        fetch(path)
+      end
+
+      @pages
+    end
+
+    private
+
+    def enqueue(path)
+      normalized = normalize(path)
+      return if normalized.nil?
+      return if @visited.include?(normalized)
+      return if @config.excluded?(normalized)
+
+      @visited.add(normalized)
+      @queue.push(normalized)
+    end
+
+    def fetch(path)
+      header("Host", @config.host)
+      get(path)
+
+      status = last_response.status
+      content_type = last_response.content_type.to_s
+      body = last_response.body
+
+      if (300..399).cover?(status)
+        location = last_response.headers["Location"].to_s
+        if !location.empty? && !external?(location)
+          redirect_path = URI.parse(location).path
+          enqueue(redirect_path)
+        end
+        log("  REDIRECT #{status} #{path} -> #{location}")
+        return
+      end
+
+      unless status == 200
+        log("  WARNING: #{status} #{path}")
+        return
+      end
+
+      page = Page.new(path: path, status: status, content_type: content_type, body: body)
+      @pages << page
+
+      if page.html?
+        extractor = LinkExtractor.new(body, base_path: path)
+        extractor.page_links.each { |link| enqueue(link) }
+      end
+
+      log("  #{status} #{path} (#{content_type})")
+    end
+
+    def normalize(path)
+      return nil if path.nil? || path.empty?
+
+      uri = URI.parse(path)
+      return nil if uri.scheme && !%w[http https].include?(uri.scheme)
+      return nil if uri.host && uri.host != @config.host
+
+      clean = uri.path.to_s
+      clean = "/" if clean.empty?
+      clean = clean.chomp("/") unless clean == "/"
+      clean
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def external?(url)
+      uri = URI.parse(url)
+      uri.host && uri.host != @config.host
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def log(message)
+      $stdout.puts message
+    end
+  end
+end

data/lib/rails2static/generator.rb

@@ -0,0 +1,88 @@
+require "fileutils"
+
+module Rails2static
+  class Generator
+    def initialize(app: nil, config: Rails2static.configuration)
+      @app = app || default_app
+      @config = config
+    end
+
+    def run
+      log("Rails2static: generating static site to #{@config.output_dir}/")
+
+      prepare_output_dir
+      pages = crawl
+      rewrite_links(pages)
+      write_pages(pages)
+      collect_and_write_assets(pages)
+      copy_public
+
+      log("Rails2static: done! #{pages.size} pages written to #{@config.output_dir}/")
+    end
+
+    private
+
+    def default_app
+      defined?(Rails) ? Rails.application : raise("No app provided and Rails is not defined")
+    end
+
+    def prepare_output_dir
+      FileUtils.rm_rf(@config.output_dir)
+      FileUtils.mkdir_p(@config.output_dir)
+      log("  Cleaned #{@config.output_dir}/")
+    end
+
+    def crawl
+      log("  Crawling...")
+      crawler = Crawler.new(app: @app, config: @config)
+      crawler.crawl
+    end
+
+    def rewrite_links(pages)
+      log("  Rewriting links...")
+      rewriter = LinkRewriter.new(@config)
+      pages.each do |page|
+        next unless page.html?
+
+        rewritten = rewriter.rewrite(page.body)
+        page.instance_variable_set(:@body, rewritten)
+      end
+    end
+
+    def write_pages(pages)
+      log("  Writing pages...")
+      writer = Writer.new(config: @config)
+      writer.write_pages(pages)
+    end
+
+    def collect_and_write_assets(pages)
+      return unless @config.include_assets
+
+      log("  Collecting assets...")
+      collector = AssetCollector.new(app: @app, config: @config)
+      assets = collector.collect(pages)
+
+      log("  Writing #{assets.size} assets...")
+      writer = Writer.new(config: @config)
+      writer.write_assets(assets)
+    end
+
+    def copy_public
+      public_dir = if defined?(Rails)
+                     Rails.public_path.to_s
+                   else
+                     "public"
+                   end
+
+      return unless File.directory?(public_dir)
+
+      log("  Copying public/ files...")
+      writer = Writer.new(config: @config)
+      writer.copy_public(public_dir)
+    end
+
+    def log(message)
+      $stdout.puts message
+    end
+  end
+end

data/lib/rails2static/link_extractor.rb

@@ -0,0 +1,103 @@
+require "nokogiri"
+
+module Rails2static
+  class LinkExtractor
+    attr_reader :page_links, :asset_urls
+
+    def initialize(html, base_path: "/")
+      @html = html
+      @base_path = base_path
+      @page_links = []
+      @asset_urls = []
+      extract
+    end
+
+    private
+
+    def extract
+      doc = Nokogiri::HTML(@html)
+
+      doc.css("a[href]").each do |a|
+        href = a["href"].to_s.strip
+        next if href.empty?
+
+        resolved = resolve(href)
+        @page_links << resolved if resolved
+      end
+
+      doc.css("link[href]").each do |link|
+        href = link["href"].to_s.strip
+        resolved = resolve(href)
+        @asset_urls << resolved if resolved
+      end
+
+      doc.css("script[src]").each do |script|
+        src = script["src"].to_s.strip
+        resolved = resolve(src)
+        @asset_urls << resolved if resolved
+      end
+
+      doc.css("img[src]").each do |img|
+        src = img["src"].to_s.strip
+        resolved = resolve(src)
+        @asset_urls << resolved if resolved
+      end
+
+      doc.css("img[srcset], source[srcset]").each do |el|
+        parse_srcset(el["srcset"].to_s).each do |url|
+          resolved = resolve(url)
+          @asset_urls << resolved if resolved
+        end
+      end
+
+      doc.css("video[src], audio[src], video source[src], audio source[src]").each do |el|
+        src = el["src"].to_s.strip
+        resolved = resolve(src)
+        @asset_urls << resolved if resolved
+      end
+
+      doc.css("video[poster]").each do |el|
+        poster = el["poster"].to_s.strip
+        resolved = resolve(poster)
+        @asset_urls << resolved if resolved
+      end
+
+      @page_links.uniq!
+      @asset_urls.uniq!
+    end
+
+    def resolve(href)
+      return nil if external?(href)
+      return nil if non_http?(href)
+
+      path = if href.start_with?("/")
+               href
+             else
+               File.join(File.dirname(@base_path), href)
+             end
+
+      normalize(path)
+    end
+
+    def external?(href)
+      href.match?(%r{\A(https?://|//|mailto:|tel:|javascript:)})
+    end
+
+    def non_http?(href)
+      href.start_with?("#") || href.start_with?("data:")
+    end
+
+    def normalize(path)
+      uri = URI.parse(path)
+      clean = uri.path
+      clean = clean.chomp("/") unless clean == "/"
+      clean.empty? ? "/" : clean
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def parse_srcset(srcset)
+      srcset.split(",").map { |entry| entry.strip.split(/\s+/).first }.compact
+    end
+  end
+end

data/lib/rails2static/link_rewriter.rb

@@ -0,0 +1,56 @@
+require "nokogiri"
+
+module Rails2static
+  class LinkRewriter
+    def initialize(config = Rails2static.configuration)
+      @config = config
+    end
+
+    def rewrite(html)
+      doc = Nokogiri::HTML(html)
+
+      doc.css("a[href]").each do |a|
+        href = a["href"].to_s.strip
+        next if skip?(href)
+
+        a["href"] = rewrite_href(href)
+      end
+
+      doc.to_html
+    end
+
+    private
+
+    def skip?(href)
+      return true if href.empty?
+      return true if href.match?(%r{\A(https?://|//|mailto:|tel:|javascript:|data:)})
+      return true if href.start_with?("#")
+      return true if has_extension?(href)
+
+      false
+    end
+
+    def has_extension?(href)
+      path = href.split("?").first.split("#").first
+      basename = File.basename(path)
+      basename.include?(".") && !basename.start_with?(".")
+    end
+
+    def rewrite_href(href)
+      path = href.split("?").first.split("#").first
+      fragment = href.include?("#") ? "#" + href.split("#").last : ""
+
+      if @config.trailing_slash
+        path = path.chomp("/")
+        path = "/" if path.empty?
+        rewritten = path == "/" ? "/" : "#{path}/"
+      else
+        path = path.chomp("/")
+        path = "/" if path.empty?
+        rewritten = path == "/" ? "/" : "#{path}.html"
+      end
+
+      "#{rewritten}#{fragment}"
+    end
+  end
+end

data/lib/rails2static/page.rb

@@ -0,0 +1,32 @@
+module Rails2static
+  class Page
+    attr_reader :path, :status, :content_type, :body
+
+    def initialize(path:, status:, content_type:, body:)
+      @path = path
+      @status = status
+      @content_type = content_type.to_s
+      @body = body
+    end
+
+    def html?
+      content_type.include?("text/html")
+    end
+
+    def css?
+      content_type.include?("text/css")
+    end
+
+    def ok?
+      status == 200
+    end
+
+    def redirect?
+      (300..399).cover?(status)
+    end
+
+    def binary?
+      !content_type.start_with?("text/") && !content_type.include?("json") && !content_type.include?("xml") && !content_type.include?("javascript")
+    end
+  end
+end

data/lib/rails2static/railtie.rb

@@ -0,0 +1,7 @@
+module Rails2static
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("../tasks/rails2static.rake", __dir__)
+    end
+  end
+end

data/lib/rails2static/version.rb

@@ -0,0 +1,3 @@
+module Rails2static
+  VERSION = "0.1.0"
+end

data/lib/rails2static/writer.rb

@@ -0,0 +1,75 @@
+require "fileutils"
+
+module Rails2static
+  class Writer
+    def initialize(config: Rails2static.configuration)
+      @config = config
+    end
+
+    def write_pages(pages)
+      pages.each { |page| write_page(page) }
+    end
+
+    def write_assets(assets)
+      assets.each { |asset| write_asset(asset) }
+    end
+
+    def copy_public(public_dir)
+      return unless File.directory?(public_dir)
+
+      Dir.glob(File.join(public_dir, "**", "*")).each do |file|
+        next if File.directory?(file)
+
+        relative = file.sub("#{public_dir}/", "")
+        dest = File.join(@config.output_dir, relative)
+
+        next if File.exist?(dest)
+
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(file, dest)
+      end
+    end
+
+    private
+
+    def write_page(page)
+      dest = destination_for(page)
+      FileUtils.mkdir_p(File.dirname(dest))
+
+      if page.binary?
+        File.binwrite(dest, page.body)
+      else
+        File.write(dest, page.body)
+      end
+    end
+
+    def write_asset(asset)
+      dest = File.join(@config.output_dir, asset.path)
+      FileUtils.mkdir_p(File.dirname(dest))
+
+      if asset.binary?
+        File.binwrite(dest, asset.body)
+      else
+        File.write(dest, asset.body)
+      end
+    end
+
+    def destination_for(page)
+      path = page.path
+
+      if path == "/"
+        return File.join(@config.output_dir, "index.html")
+      end
+
+      if page.html?
+        if @config.trailing_slash
+          File.join(@config.output_dir, path, "index.html")
+        else
+          File.join(@config.output_dir, "#{path}.html")
+        end
+      else
+        File.join(@config.output_dir, path)
+      end
+    end
+  end
+end

data/lib/rails2static.rb

@@ -0,0 +1,30 @@
+require "rails2static/version"
+require "rails2static/configuration"
+require "rails2static/page"
+require "rails2static/link_extractor"
+require "rails2static/link_rewriter"
+require "rails2static/crawler"
+require "rails2static/asset_collector"
+require "rails2static/writer"
+require "rails2static/generator"
+require "rails2static/railtie" if defined?(Rails::Railtie)
+
+module Rails2static
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def generate!(app: nil)
+      Generator.new(app: app).run
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/tasks/rails2static.rake

@@ -0,0 +1,23 @@
+desc "Generate a static site from this Rails app"
+task rails2static: :environment do
+  Rails2static.generate!
+end
+
+namespace :static do
+  desc "Generate a static site from this Rails app"
+  task generate: :environment do
+    Rails2static.generate!
+  end
+
+  desc "Preview the generated static site on http://localhost:8000"
+  task preview: :environment do
+    dir = Rails.root.join(Rails2static.configuration.output_dir)
+    abort "No #{Rails2static.configuration.output_dir}/ found. Run `rake rails2static` first." unless dir.exist?
+
+    require "webrick"
+    server = WEBrick::HTTPServer.new(Port: 8000, DocumentRoot: dir.to_s)
+    trap("INT") { server.shutdown }
+    puts "Serving #{dir}/ at http://localhost:8000 — Ctrl-C to stop"
+    server.start
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: rails2static
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian Terrell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Crawls a server-rendered Rails app via Rack::Test and outputs a deployable
+  static site.
+email:
+- ian.terrell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/generators/rails2static/install_generator.rb
+- lib/generators/rails2static/templates/rails2static.rb
+- lib/rails2static.rb
+- lib/rails2static/asset_collector.rb
+- lib/rails2static/configuration.rb
+- lib/rails2static/crawler.rb
+- lib/rails2static/generator.rb
+- lib/rails2static/link_extractor.rb
+- lib/rails2static/link_rewriter.rb
+- lib/rails2static/page.rb
+- lib/rails2static/railtie.rb
+- lib/rails2static/version.rb
+- lib/rails2static/writer.rb
+- lib/tasks/rails2static.rake
+homepage: https://github.com/ianterrell/rails2static
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: Generate a static site from a Rails app
+test_files: []