rails-local-ci 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8840d3903d7f32a508350be3bfe4dad1d65ca3799bcc4ff08dc891f3d1158bde
+  data.tar.gz: 17f2e4fe861ec938aca6bbcccc9139e8149a5d2aadfda7624f4807dccfe3e1ed
+SHA512:
+  metadata.gz: 9b423912230035964b67068059469d28539ac9861efd47f34e9149a393a9e3efee5a5fcf4ce95bde08ad7d154cafac1933c754fa70fceab7d5762ab5f3226956
+  data.tar.gz: 75caddc8fbf112217648ed8765fa57d886fc29a05bbab54048cd27d8474886888e5fb2e7d5c2fd79df594bc7ce7f7e2991d7b5b341eec96bcd65cd4dc5379fbf

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 rails_local_ci contributors
+
+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,317 @@
+# rails-local-ci
+
+> Backport of Rails 8.1's `ActiveSupport::ContinuousIntegration` for Rails 5.2–7.x
+
+Rails 8.1 introduced a standardized `bin/ci` script and `ActiveSupport::ContinuousIntegration` class ([PR #54693](https://github.com/rails/rails/pull/54693)) that runs the same CI steps locally and in the cloud. This gem ships that class for apps on Rails 5.2–7.x so you don't have to wait for an upgrade.
+
+When you do upgrade to Rails 8.1, remove the gem — `bin/ci` and `config/ci.rb` stay unchanged because Rails 8.1 provides the class at the same load path.
+
+---
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Usage](#usage)
+- [DSL Reference](#dsl-reference)
+- [Parallel Groups](#parallel-groups)
+- [Fail-Fast Mode](#fail-fast-mode)
+- [Commit Signoff](#commit-signoff)
+- [CI Integration](#ci-integration)
+- [Running Tests](#running-tests)
+- [Upgrading to Rails 8.1](#upgrading-to-rails-81)
+- [Compatibility](#compatibility)
+- [How It Works](#how-it-works)
+- [License](#license)
+
+---
+
+## Prerequisites
+
+- Ruby >= 2.4
+- Rails >= 5.2 and < 8.1
+
+---
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "rails-local-ci"
+```
+
+Install:
+
+```bash
+bundle install
+```
+
+Run the generator:
+
+```bash
+rails generate rails_local_ci:install
+```
+
+The generator copies two files into your app:
+
+- `bin/ci` — the runner script (set to executable)
+- `config/ci.rb` — your CI step definitions
+
+---
+
+## Usage
+
+Run all CI steps locally:
+
+```bash
+./bin/ci
+```
+
+Expected output:
+
+```
+Continuous Integration
+Running tests, style checks, and security audits
+
+Setup
+bin/setup --skip-server
+
+✅ Setup passed in 2.31s
+
+Style: Ruby
+bin/rubocop
+
+✅ Style: Ruby passed in 1.04s
+
+Tests: Rails
+bin/rails test
+
+✅ Tests: Rails passed in 4.17s
+
+✅ Continuous Integration passed in 8.34s
+```
+
+Define your steps in `config/ci.rb`:
+
+```ruby
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+  step "Style: Ruby",                      "bin/rubocop"        if File.exist?("bin/rubocop")
+  step "Security: Gem audit",              "bin/bundler-audit"  if File.exist?("bin/bundler-audit")
+  step "Security: Brakeman code analysis", "bin/brakeman --quiet --no-pager --exit-on-warn --exit-on-error" if File.exist?("bin/brakeman")
+  step "Tests: Rails",                     "bin/rails test"
+
+  if success?
+    heading "All CI checks passed!", "Your changes are ready for review"
+  else
+    failure "CI checks failed", "Fix the issues above before submitting your PR"
+  end
+end
+```
+
+`CI.run` sets `ENV["CI"] = "true"` for the duration of the run, which Rails uses to enable eager loading and disable verbose logging.
+
+---
+
+## DSL Reference
+
+All methods are available inside the `CI.run do ... end` block in `config/ci.rb`.
+
+| Method | Description |
+|--------|-------------|
+| `step "Title", "command"` | Run a shell command; records pass/fail and elapsed time |
+| `step "Title", "cmd", "arg1", "arg2"` | Run with multiple args — passed directly to `system`, correctly shell-escaped |
+| `group "Title" do ... end` | Group steps visually; runs sequentially |
+| `group "Title", parallel: N do ... end` | Run up to N steps concurrently in threads |
+| `success?` | Returns `true` if every step so far has passed |
+| `heading "Title"` | Print a green banner |
+| `heading "Title", "Subtitle"` | Print a green banner with a gray subtitle; accepts `padding: false` to suppress blank lines |
+| `failure "Title", "Subtitle"` | Print a red error banner |
+| `echo "Text", type: :success` | Print colorized text to the terminal |
+
+**Color types for `echo` and `heading`:**
+
+| Type | Color |
+|------|-------|
+| `:banner` | Green (bold) |
+| `:title` | Purple (bold) |
+| `:subtitle` | Gray (bold) |
+| `:error` | Red (bold) |
+| `:success` | Green (bold) |
+| `:progress` | Cyan (bold) |
+
+`CI.run` accepts optional title and subtitle overrides:
+
+```ruby
+CI.run "My App CI", "Linting, security, and tests" do
+  # ...
+end
+```
+
+---
+
+## Parallel Groups
+
+Run multiple independent steps concurrently using `group`:
+
+```ruby
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+
+  group "Checks", parallel: 3 do
+    step "Style: Ruby",        "bin/rubocop"
+    step "Security: Brakeman", "bin/brakeman --quiet"
+    step "Security: Gems",     "bin/bundler-audit"
+  end
+
+  step "Tests: Rails", "bin/rails test"
+end
+```
+
+`parallel: N` runs up to N steps in concurrent threads. Output is captured per-step (via PTY when available, Open3 otherwise) and displayed in declaration order after all steps complete — no interleaving. A live progress indicator shows which steps are running.
+
+`group` without `parallel:` (or `parallel: 1`) runs steps sequentially, useful for visual grouping.
+
+**Nested groups**: a `group` inside a parallel group runs its steps sequentially within that thread slot. Sub-groups cannot themselves be parallelized — attempting to set `parallel:` on a nested group raises `ArgumentError`.
+
+---
+
+## Fail-Fast Mode
+
+Stop at the first failing step instead of running all steps:
+
+```bash
+./bin/ci --fail-fast
+./bin/ci -f
+```
+
+---
+
+## Commit Signoff
+
+After a successful local CI run, post a green commit status directly to your Git host to unblock PR merge — no cloud CI runner needed.
+
+### GitHub
+
+Requires the [`gh` CLI](https://cli.github.com) and the `gh-signoff` extension:
+
+```bash
+gh extension install basecamp/gh-signoff
+```
+
+Add to `config/ci.rb`:
+
+```ruby
+if success?
+  step "Signoff: All systems go. Ready for merge and deploy.", "gh signoff"
+end
+```
+
+### Bitbucket
+
+Install [`bb-signoff`](https://github.com/its-magdy/bb-signoff):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/its-magdy/bb-signoff/main/bb-signoff \
+  -o /usr/local/bin/bb-signoff && chmod +x /usr/local/bin/bb-signoff
+```
+
+Create a Bitbucket repository access token with these scopes:
+- Repositories: Read, Write, Admin
+- Pull Requests: Read, Write
+
+Store the token in `~/.bb-signoff` or export it as `BB_API_TOKEN`.
+
+Add to `config/ci.rb`:
+
+```ruby
+if success?
+  step "Signoff: All systems go. Ready for merge and deploy.", "bb-signoff"
+end
+```
+
+---
+
+## CI Integration
+
+### GitHub Actions
+
+```yaml
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - run: bin/ci
+```
+
+### Bitbucket Pipelines
+
+```yaml
+pipelines:
+  default:
+    - step:
+        name: CI
+        script:
+          - bundle install
+          - bin/ci
+```
+
+---
+
+## Running Tests
+
+```bash
+bundle exec ruby test/continuous_integration_test.rb
+```
+
+---
+
+## Upgrading to Rails 8.1
+
+1. Remove `gem "rails-local-ci"` from your `Gemfile`
+2. Run `bundle install`
+
+`bin/ci` and `config/ci.rb` require no changes. Rails 8.1 ships `ActiveSupport::ContinuousIntegration` at the same load path this gem uses.
+
+---
+
+## Compatibility
+
+| Rails | Ruby  | Status |
+|-------|-------|--------|
+| 7.2   | 3.1+  | Tested |
+| 7.1   | 3.0+  | Compatible |
+| 7.0   | 2.7+  | Compatible |
+| 6.1   | 2.7+  | Compatible |
+| 6.0   | 2.7+  | Compatible |
+| 5.2   | 2.4+  | Compatible |
+| 8.1+  | —     | Use built-in — remove this gem |
+
+---
+
+## How It Works
+
+The gem places `ActiveSupport::ContinuousIntegration` at `lib/active_support/continuous_integration.rb` — the identical load path Rails 8.1 uses. The generated `bin/ci` does:
+
+```ruby
+require_relative "../config/boot"
+require "active_support/continuous_integration"  # resolved by this gem, or Rails 8.1 built-in
+
+CI = ActiveSupport::ContinuousIntegration
+require_relative "../config/ci.rb"
+```
+
+The generator copies only `bin/ci` and `config/ci.rb` into your app. The class itself lives in the gem.
+
+---
+
+## License
+
+[MIT](LICENSE)

data/lib/active_support/continuous_integration/group.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module ActiveSupport
+  class ContinuousIntegration
+    class Group # :nodoc:
+      class TaskCollector
+        attr_reader :tasks
+
+        def initialize(&block)
+          @tasks = []
+          instance_eval(&block)
+        end
+
+        def step(title, *command)
+          @tasks << [:step, title, command]
+        end
+
+        def group(name, **options, &block)
+          raise ArgumentError, "Sub-groups cannot be parallelized. Remove the `parallel:` option from the #{name.inspect} group." if options.key?(:parallel)
+          @tasks << [:group, name, block]
+        end
+      end
+
+      def initialize(ci, name, parallel:, &block)
+        @ci = ci
+        @name = name
+        @parallel = parallel
+        @tasks = TaskCollector.new(&block).tasks
+        @start_time = Time.now.to_f
+        @mutex = Mutex.new
+        @running = {}
+        @progress_visible = false
+        @log_files = []
+      end
+
+      def run
+        previous_trap = Signal.trap("INT") { abort @ci.colorize("\n❌ #{@running.keys.join(', ')} interrupted", :error) }
+
+        queue = Queue.new
+        @tasks.each { |task| queue << task }
+
+        with_progress do
+          @parallel.times.map do
+            Thread.new do
+              while (task = dequeue(queue))
+                break if @ci.failing_fast?
+                execute_task(*task)
+              end
+            end
+          end.each(&:join)
+        end
+      ensure
+        Signal.trap("INT", previous_trap || "-")
+        @log_files.each { |path| File.delete(path) if File.exist?(path) }
+      end
+
+      private
+        def with_progress
+          stop = false
+          thread = Thread.new do
+            until stop
+              @mutex.synchronize { refresh_progress }
+              sleep 0.1
+            end
+          end
+
+          yield
+
+          stop = true
+          thread.join
+        end
+
+        def execute_task(type, title, payload)
+          case type
+          when :step  then execute_step(title, payload)
+          when :group then execute_group(title, payload)
+          end
+        end
+
+        def execute_step(title, command)
+          @mutex.synchronize { @running[title] = Time.now.to_f }
+          success, log_path = capture_output(command)
+          @mutex.synchronize do
+            started = @running.delete(title)
+            clear_progress
+
+            @ci.report_step(title, command) do
+              replay_and_cleanup(log_path)
+              [success, Time.now.to_f - started]
+            end
+
+            refresh_progress
+          end
+          success
+        end
+
+        def execute_group(name, block)
+          all_success = true
+          TaskCollector.new(&block).tasks.each do |type, title, payload|
+            unless execute_task(type, title, payload)
+              all_success = false
+              break if @ci.fail_fast?
+            end
+          end
+
+          all_success
+        end
+
+        def capture_output(command)
+          log_path = Dir::Tmpname.create(["ci-", ".log"]) { }
+          @mutex.synchronize { @log_files << log_path }
+
+          success = spawn_process(command) do |output|
+            File.open(log_path, "w") do |f|
+              loop { f.write(output.readpartial(8192)) }
+            rescue EOFError, Errno::EIO
+              # Expected when process exits
+            end
+          end
+
+          [success, log_path]
+        rescue SystemCallError => e
+          File.write(log_path, "#{e.message}: #{command.join(" ")}\n")
+          [false, log_path]
+        end
+
+        def spawn_process(command, &block)
+          # Prefer PTY if available to retain output colors
+          if pty_available?
+            spawn_via_pty(command, &block)
+          else
+            spawn_via_open3(command, &block)
+          end
+        end
+
+        def pty_available?
+          require "pty"
+          true
+        rescue LoadError
+          false
+        end
+
+        def spawn_via_pty(command)
+          output, input, pid = PTY.spawn(*command)
+          input.close
+          yield output
+          Process.waitpid2(pid).last.success?
+        rescue PTY::ChildExited => e
+          e.status.success?
+        end
+
+        def spawn_via_open3(command)
+          require "open3"
+          Open3.popen2e(*command) do |input, output, wait_thr|
+            input.close
+            yield output
+            wait_thr.value.success?
+          end
+        end
+
+        def replay_and_cleanup(log_path)
+          File.open(log_path, "r") do |f|
+            while (chunk = f.read(8192))
+              print chunk
+            end
+          end
+          File.delete(log_path)
+        end
+
+        def refresh_progress
+          if @running.any?
+            print "\n\n" unless @progress_visible
+            elapsed = format_elapsed_brief(Time.now.to_f - @start_time)
+            print "\r\e[K#{@ci.colorize("#{@name} (#{elapsed}) - #{@running.keys.join(' | ')}...", :progress)}"
+            @progress_visible = true
+            $stdout.flush
+          end
+        end
+
+        def clear_progress
+          return unless @progress_visible
+          print "\r\e[2A\e[J"
+          @progress_visible = false
+        end
+
+        def format_elapsed_brief(seconds)
+          min, sec = seconds.divmod(60)
+          "#{"#{min.to_i}m" if min > 0}#{sec.to_i}s"
+        end
+
+        def dequeue(queue)
+          queue.pop(true)
+        rescue ThreadError
+          nil
+        end
+    end
+  end
+end

data/lib/active_support/continuous_integration.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides a DSL for declaring a continuous integration workflow that can be run either locally or in the cloud.
+  # Each step is timed, reports success/error, and is aggregated into a collective report that reports total runtime,
+  # as well as whether the entire run was successful or not.
+  #
+  # Example:
+  #
+  #   ActiveSupport::ContinuousIntegration.run do
+  #     step "Setup", "bin/setup --skip-server"
+  #     step "Style: Ruby", "bin/rubocop"
+  #     step "Security: Gem audit", "bin/bundler-audit"
+  #     step "Tests: Rails", "bin/rails test test:system"
+  #
+  #     if success?
+  #       step "Signoff: Ready for merge and deploy", "gh signoff"
+  #     else
+  #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+  #     end
+  #   end
+  #
+  # Starting with Rails 8.1, a default `bin/ci` and `config/ci.rb` file are created to provide out-of-the-box CI.
+  class ContinuousIntegration
+    COLORS = {
+      banner: "\033[1;32m",   # Green
+      title: "\033[1;35m",    # Purple
+      subtitle: "\033[1;90m", # Medium Gray
+      error: "\033[1;31m",    # Red
+      success: "\033[1;32m",  # Green
+      progress: "\033[1;36m"  # Cyan
+    }
+
+    attr_reader :results
+
+    # Perform a CI run. Execute each step, show their results and runtime, and exit with a non-zero status if there are any failures.
+    #
+    # Pass an optional title, subtitle, and a block that declares the steps to be executed.
+    #
+    # Sets the CI environment variable to "true" to allow for conditional behavior in the app, like enabling eager loading and disabling logging.
+    #
+    # A 'fail fast' option can be passed as a CLI argument (-f or --fail-fast). This exits with a non-zero status directly after a step fails.
+    #
+    # Example:
+    #
+    #   ActiveSupport::ContinuousIntegration.run do
+    #     step "Setup", "bin/setup --skip-server"
+    #     step "Style: Ruby", "bin/rubocop"
+    #     step "Security: Gem audit", "bin/bundler-audit"
+    #     step "Tests: Rails", "bin/rails test test:system"
+    #
+    #     if success?
+    #       step "Signoff: Ready for merge and deploy", "gh signoff"
+    #     else
+    #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+    #     end
+    #   end
+    def self.run(title = "Continuous Integration", subtitle = "Running tests, style checks, and security audits", &block)
+      ENV["CI"] = "true"
+      new.tap { |ci| ci.run(title, subtitle, &block) }
+    end
+
+    def run(title, subtitle, &block)
+      heading title, subtitle, padding: false
+      success, seconds = execute(title, &block)
+      result_line(title, success, seconds)
+      abort unless success?
+    end
+
+    def initialize
+      @results = []
+    end
+
+    # Declare a step with a title and a command. The command can either be given as a single string or as multiple
+    # strings that will be passed to `system` as individual arguments (and therefore correctly escaped for paths etc).
+    #
+    # Examples:
+    #
+    #   step "Setup", "bin/setup"
+    #   step "Single test", "bin/rails", "test", "--name", "test_that_is_one"
+    def step(title, *command)
+      previous_trap = Signal.trap("INT") { abort colorize("\n❌ #{title} interrupted", :error) }
+      report_step(title, command) do
+        started = Time.now.to_f
+        [system(*command), Time.now.to_f - started]
+      end
+      abort if failing_fast?
+    ensure
+      Signal.trap("INT", previous_trap || "-")
+    end
+
+    # Declare a group of steps that can be run in parallel. Steps within the group are collected first,
+    # then executed either concurrently (when +parallel+ > 1) or sequentially (when +parallel+ is 1).
+    #
+    # When running in parallel, each step's output is captured to avoid interleaving, and a progress
+    # display shows which steps are currently running.
+    #
+    # Sub-groups within a parallel group occupy a single parallel slot and run their steps sequentially.
+    #
+    # Examples:
+    #
+    #   group "Checks", parallel: 3 do
+    #     step "Style: Ruby", "bin/rubocop"
+    #     step "Security: Brakeman", "bin/brakeman --quiet"
+    #     step "Security: Gem audit", "bin/bundler-audit"
+    #   end
+    #
+    #   group "Tests" do
+    #     step "Unit tests", "bin/rails test"
+    #     step "System tests", "bin/rails test:system"
+    #   end
+    def group(name, parallel: 1, &block)
+      if parallel <= 1
+        instance_eval(&block)
+      else
+        Group.new(self, name, parallel: parallel, &block).run
+      end
+      abort if failing_fast?
+    end
+
+    # Returns true if all steps were successful.
+    def success?
+      results.map(&:first).all?
+    end
+
+    # Display an error heading with the title and optional subtitle to reflect that the run failed.
+    def failure(title, subtitle = nil)
+      heading title, subtitle, type: :error
+    end
+
+    # Display a colorized heading followed by an optional subtitle.
+    #
+    # Examples:
+    #
+    #   heading "Smoke Testing", "End-to-end tests verifying key functionality", padding: false
+    #   heading "Skipping video encoding tests", "Install FFmpeg to run these tests", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def heading(heading, subtitle = nil, type: :banner, padding: true)
+      echo "#{padding ? "\n\n" : ""}#{heading}", type: type
+      echo "#{subtitle}#{padding ? "\n" : ""}", type: :subtitle if subtitle
+    end
+
+    # Echo text to the terminal in the color corresponding to the type of the text.
+    #
+    # Examples:
+    #
+    #   echo "This is going to be green!", type: :success
+    #   echo "This is going to be red!", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def echo(text, type:)
+      puts colorize(text, type)
+    end
+
+    # :nodoc:
+    def report_step(title, command)
+      heading title, command.join(" "), type: :title
+      success, seconds = yield
+      result_line(title, success, seconds)
+      results << [success, title]
+      success
+    end
+
+    # :nodoc:
+    def colorize(text, type)
+      "#{COLORS.fetch(type)}#{text}\033[0m"
+    end
+
+    # :nodoc:
+    def fail_fast?
+      ARGV.include?("-f") || ARGV.include?("--fail-fast")
+    end
+
+    # :nodoc:
+    def failing_fast?
+      fail_fast? && failures.any?
+    end
+
+    private
+      def failures
+        results.reject(&:first)
+      end
+
+      def multiple_results?
+        results.size > 1
+      end
+
+      def execute(title, &block)
+        previous_trap = Signal.trap("INT") { abort colorize("\n❌ #{title} interrupted", :error) }
+
+        seconds = timing { instance_eval(&block) }
+
+        unless success?
+          if multiple_results?
+            failures.each do |success, title|
+              unless success
+                echo "   ↳ #{title} failed", type: :error
+              end
+            end
+          end
+        end
+
+        [success?, seconds]
+      ensure
+        Signal.trap("INT", previous_trap || "-")
+      end
+
+      def result_line(title, success, seconds)
+        elapsed = format_elapsed(seconds)
+        if success
+          echo "\n✅ #{title} passed in #{elapsed}", type: :success
+        else
+          echo "\n❌ #{title} failed in #{elapsed}", type: :error
+        end
+      end
+
+      def format_elapsed(seconds)
+        min, sec = seconds.divmod(60)
+        "#{"#{min.to_i}m" if min > 0}%.2fs" % sec
+      end
+
+      def timing
+        started_at = Time.now.to_f
+        yield
+        Time.now.to_f - started_at
+      end
+  end
+end
+
+require_relative "continuous_integration/group"

data/lib/generators/rails_local_ci/install_generator.rb

@@ -0,0 +1,22 @@
+require "rails/generators"
+
+module RailsLocalCi
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+    desc "Install Local CI: copies bin/ci and config/ci.rb into your Rails app"
+
+    def copy_ci_binstub
+      copy_file "bin_ci", "bin/ci"
+      chmod "bin/ci", 0755
+    end
+
+    def copy_ci_config
+      copy_file "config_ci.rb", "config/ci.rb"
+    end
+
+    def show_readme
+      say "\n✅ Local CI installed!", :green
+      say "   Run: ./bin/ci", :cyan
+    end
+  end
+end

data/lib/generators/rails_local_ci/templates/bin_ci

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "active_support/continuous_integration"
+
+CI = ActiveSupport::ContinuousIntegration
+require_relative "../config/ci.rb"

data/lib/generators/rails_local_ci/templates/config_ci.rb

@@ -0,0 +1,28 @@
+# Run using bin/ci
+
+CI.run do
+  step "Setup", "bin/setup --skip-server"
+
+  # Run independent checks in parallel for faster feedback:
+  #
+  #   group "Checks", parallel: 3 do
+  #     step "Style: Ruby",        "bin/rubocop"          if File.exist?("bin/rubocop")
+  #     step "Security: Brakeman", "bin/brakeman --quiet"  if File.exist?("bin/brakeman")
+  #     step "Security: Gems",     "bin/bundler-audit"     if File.exist?("bin/bundler-audit")
+  #   end
+
+  step "Style: Ruby",                      "bin/rubocop"        if File.exist?("bin/rubocop")
+  step "Security: Gem audit",              "bin/bundler-audit"  if File.exist?("bin/bundler-audit")
+  step "Security: Brakeman code analysis", "bin/brakeman --quiet --no-pager --exit-on-warn --exit-on-error" if File.exist?("bin/brakeman")
+  step "Tests: Rails",                     "bin/rails test"
+
+  # Optional: set a green commit status to unblock PR merge.
+  # GitHub: Requires the `gh` CLI and `gh extension install basecamp/gh-signoff`.
+  # Bitbucket: Install bb-signoff (https://github.com/Mohamed-Omar96/bb-signoff).
+  # if success?
+  #   step "Signoff: All systems go. Ready for merge and deploy.", "gh signoff"     # GitHub
+  #   step "Signoff: All systems go. Ready for merge and deploy.", "bb-signoff"     # Bitbucket
+  # else
+  #   failure "Signoff: CI failed. Do not merge or deploy.", "Fix the issues and try again."
+  # end
+end

data/lib/rails_local_ci/railtie.rb

@@ -0,0 +1,9 @@
+require "rails/railtie"
+
+module RailsLocalCi
+  class Railtie < Rails::Railtie
+    generators do
+      require "generators/rails_local_ci/install_generator"
+    end
+  end
+end

data/lib/rails_local_ci.rb

@@ -0,0 +1,2 @@
+require "active_support/continuous_integration"
+require "rails_local_ci/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: rails-local-ci
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mohamed Magdy Omar
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+description: Ships ActiveSupport::ContinuousIntegration and a generator that installs
+  bin/ci + config/ci.rb. Any Rails 6/7 app can `gem 'rails-local-ci'` and get the
+  same Local CI DX as Rails 8.1 built-in. Upgrading to Rails 8.1 later = just remove
+  the gem, zero code changes.
+email:
+- mm.medany96@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/active_support/continuous_integration.rb
+- lib/active_support/continuous_integration/group.rb
+- lib/generators/rails_local_ci/install_generator.rb
+- lib/generators/rails_local_ci/templates/bin_ci
+- lib/generators/rails_local_ci/templates/config_ci.rb
+- lib/rails_local_ci.rb
+- lib/rails_local_ci/railtie.rb
+homepage: https://github.com/its-magdy/rails-local-ci
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Backport of Rails 8.1 Local CI (ActiveSupport::ContinuousIntegration) for
+  Rails 5.2–7.x
+test_files: []