rails-dev 0.1.0

data/lib/rails_dev/cli.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module RailsDev
+  module CLI
+    class << self
+      def run(argv, output: $stdout, error: $stderr)
+        output = Output.new(output)
+        shell = Shell.new(output, Output.new(error))
+        validate_arguments(argv)
+        Main.start(argv, debug: true, shell: shell)
+        0
+      rescue Interrupted => error
+        output.puts("[rails-dev] #{error.message}")
+        128 + Signal.list.fetch(error.signal)
+      rescue Error, Thor::Error, Errno::ENOENT => error
+        shell.error("rails-dev: #{error.message}")
+        error.is_a?(Error) ? error.status : 1
+      end
+
+      private
+
+      def validate_arguments(argv)
+        raise Thor::InvocationError, "Specify a command. See rails-dev --help." if argv.empty?
+
+        options = argv.take_while { |argument| argument != "--" }
+        options.each_with_index do |argument, index|
+          next unless argument == "--root"
+
+          value = options[index + 1]
+          if value.nil? || value.start_with?("-")
+            raise Thor::MalformattedArgumentError, "No value provided for option '--root'"
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "cli/shell"
+require_relative "cli/base"
+require_relative "cli/services"
+require_relative "cli/main"

data/lib/rails_dev/commands.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module RailsDev
+  class Commands
+    attr_reader :env
+    attr_writer :instance
+
+    def initialize(root, output: $stdout, shutdown_timeout: 3)
+      @root = root
+      @output = Output.new(output)
+      @env = Bundler.unbundled_env
+      @children = []
+      @shutdown_timeout = shutdown_timeout
+    end
+
+    def with_signals
+      previous = %w[INT TERM HUP].to_h { |signal| [signal, Signal.trap(signal) { @signal = signal }] }
+      yield
+    ensure
+      stop
+      previous&.each { |signal, handler| Signal.trap(signal, handler) }
+    end
+
+    def run(*argv)
+      execute(argv, stream: true)
+    end
+
+    def capture(*argv)
+      execute(argv, stream: false)
+    end
+
+    def start(name, argv, stream: true, ready_message: nil, keep_stdin_open: false)
+      check_for_interrupt
+      child = Child.new(name, argv, env: env, root: @root, output: stream ? @output : nil,
+                                    ready_message: ready_message, keep_stdin_open: keep_stdin_open)
+      @children << child
+      record_processes
+      child
+    end
+
+    def replace(argv)
+      Kernel.exec(env, [argv.first, argv.first], *argv.drop(1), chdir: @root, unsetenv_others: true)
+    rescue Errno::ENOENT
+      raise Error, "Command not found: #{argv.first}."
+    end
+
+    def stop(selected = @children.dup)
+      return if selected.empty?
+
+      selected.each { |child| child.signal("TERM") }
+      wait_for_shutdown(selected)
+      selected.each do |child|
+        child.signal("KILL")
+        child.reap
+        child.close
+        @children.delete(child)
+      end
+      record_processes
+    end
+
+    def record_processes
+      @instance&.record_processes(@children.map(&:pid))
+    end
+
+    def check_for_interrupt
+      return unless @signal
+
+      signal = @signal
+      @signal = nil
+      raise Interrupted, signal
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def say(message)
+      @output.puts("[rails-dev] #{message}")
+    end
+
+    private
+
+    def execute(argv, stream:)
+      child = start(argv.first, argv, stream: stream)
+      wait(child)
+      raise Error, child.failure_message unless child.status.success?
+
+      child.stdout
+    ensure
+      stop([child]) if child
+    end
+
+    def wait(child)
+      while child.running?
+        check_for_interrupt
+        failed = @children.find { |other| other != child && !other.running? }
+        raise Error, "#{failed.name} exited while running #{child.name} (#{failed.exit_reason})." if failed
+
+        sleep 0.03
+      end
+      child.poll
+      check_for_interrupt
+    end
+
+    def wait_for_shutdown(selected)
+      deadline = monotonic_time + @shutdown_timeout
+      until selected.none?(&:group_alive?) || monotonic_time >= deadline
+        selected.each(&:poll)
+        sleep 0.03
+      end
+    end
+  end
+end

data/lib/rails_dev/compose.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+require "rubygems/version"
+
+module RailsDev
+  class Compose
+    attr_reader :lock_key
+
+    def initialize(config, commands, state, runtime)
+      @config = config
+      @commands = commands
+      @state = state
+      @runtime = runtime
+      @base = ["docker", "compose", "-f", config.compose_file]
+      @base += config.profiles.flat_map { |profile| ["--profile", profile] }
+    end
+
+    def start
+      check_version!
+      load_project
+      @plan = ServicePorts.new(@services, @config)
+      return {} if @services.empty?
+
+      prepare_ports
+      @state.synchronize(lock_key) do
+        @commands.run(*@command, "up", "-d", "--wait", "--wait-timeout", @config.startup_timeout.to_s,
+                      "--no-recreate", *@services.keys)
+        @plan.environment(endpoints)
+      end
+    end
+
+    def stop
+      load_project
+      return if @services.empty?
+
+      @state.synchronize(lock_key) do
+        @commands.say("Stopping shared services: #{@services.keys.join(", ")}. Containers and volumes are kept.")
+        @commands.run(*@base, "stop", *@services.keys)
+      end
+    end
+
+    private
+
+    def check_version!
+      version = @commands.capture("docker", "compose", "version", "--short").strip.delete_prefix("v")
+      return if Gem::Version.correct?(version) && Gem::Version.new(version) >= Gem::Version.new("2.24.4")
+
+      raise Error, "Docker Compose 2.24.4 or newer is required for port overrides."
+    end
+
+    def load_project
+      model = JSON.parse(@commands.capture(*@base, "config", "--format", "json"))
+      @lock_key = "compose:#{model.fetch("name")}"
+      @services = model.fetch("services", {}).except(*@config.exclude_services)
+    end
+
+    def prepare_ports
+      path = File.join(@runtime, "compose.ports.yml")
+      File.write(path, @plan.override, perm: 0o600)
+      @command = [*@base, "-f", path]
+      @commands.capture(*@command, "config", "--quiet")
+    end
+
+    def endpoints
+      publications = published_ports
+      @plan.ports.each_with_object({}) do |(service, ports), result|
+        ports.each do |port|
+          target, protocol = port.values_at("target", "protocol")
+          result[[service, target, protocol]] = endpoint(service, target, protocol, publications.fetch(service, []))
+        end
+      end
+    end
+
+    def published_ports
+      containers = @commands.capture(*@command, "ps", "--all", "--format", "json", *@services.keys)
+                            .lines.map { |line| JSON.parse(line) }
+      containers.group_by { |container| container.fetch("Service") }.transform_values do |group|
+        group.flat_map { |container| container["Publishers"] || [] }
+      end
+    end
+
+    def endpoint(service, target, protocol, publishers)
+      bindings = publishers.select do |port|
+        port["TargetPort"] == target && port["Protocol"] == protocol && port["PublishedPort"].positive?
+      end
+      unless bindings.one? && bindings.first["URL"] == "127.0.0.1"
+        raise Error, "#{service}:#{target}/#{protocol} must publish one port on 127.0.0.1; " \
+                     "Docker returned #{bindings.inspect}. Existing containers are not recreated automatically."
+      end
+
+      published = bindings.first.fetch("PublishedPort").to_s
+      @commands.say("#{service}:#{target}/#{protocol} -> 127.0.0.1:#{published} (shared; kept running on exit)")
+      { host: "127.0.0.1", port: published }
+    end
+  end
+end

data/lib/rails_dev/configuration.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class Configuration
+    HOOKS = %i[before_start after_ready after_stop around_run].freeze
+
+    attr_accessor :compose_file, :procfile, :web, :startup_timeout, :shutdown_timeout, :readiness, :https, :name,
+                  :env, :exclude_services, :profiles, :publish_ports, :integrations
+
+    attr_reader :connections, :hooks, :optional_processes
+
+    def self.load(root, global_path: default_global_path)
+      config = new
+      paths = [global_path, File.join(root, "config/rails_dev.rb"), File.join(root, "config/rails_dev.local.rb")]
+      RailsDev.load_configuration(config, paths)
+      config.validate!(root)
+      config
+    end
+
+    def self.default_global_path
+      File.join(ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config")), "rails-dev/config.rb")
+    end
+
+    def initialize
+      @https = true
+      @procfile = "Procfile.dev"
+      @web = "web"
+      @startup_timeout = 90
+      @shutdown_timeout = 5
+      @readiness = {}
+      @http = {}
+      @optional_processes = {}
+      @env = {}
+      @exclude_services = []
+      @profiles = []
+      @publish_ports = {}
+      @integrations = []
+      @connections = {}
+      @hooks = HOOKS.to_h { |name| [name, []] }
+    end
+
+    HOOKS.each do |name|
+      define_method(name) do |&callback|
+        hooks.fetch(name) << callback if callback
+        hooks.fetch(name)
+      end
+    end
+
+    def http(name, **options)
+      @http[name.to_s] = merge_options(@http.fetch(name.to_s, {}), options)
+    end
+
+    def endpoints
+      defaults = { web.to_s => { port: 3000, env: "PORT", url_env: "RAILS_DEV_URL", readiness: { path: "/up" } } }
+      defaults.merge(@http) { |_name, inherited, override| merge_options(inherited, override) }.map do |name, options|
+        Endpoint.new(name, defaults: readiness, **options)
+      end
+    end
+
+    def optional(process, with: process)
+      @optional_processes[process.to_s] = with.to_s
+      @integrations |= [with.to_s]
+    end
+
+    def enable_integrations(names)
+      selected = Array(names).map(&:to_s)
+      available = integrations.map(&:to_s)
+      unknown = selected - available
+      unless unknown.empty?
+        raise Error, "Unknown integrations: #{unknown.join(", ")}. " \
+                     "Available integrations: #{available.empty? ? "none" : available.join(", ")}."
+      end
+
+      @enabled_integrations = selected
+    end
+
+    def enabled?(name)
+      Array(@enabled_integrations).include?(name.to_s)
+    end
+
+    def connect(service, port:, env:, protocol: "tcp")
+      env.each do |variable, template|
+        unless variable.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+          raise Error, "Invalid environment variable name: #{variable.inspect}."
+        end
+
+        tokens = template.scan(/%\{([^}]+)\}/).flatten
+        raise Error, "#{variable}: use only %{host} and %{port} placeholders." unless (tokens - %w[host port]).empty?
+
+        @connections[variable] = { service: service.to_s, port: port, protocol: protocol, value: template }
+      end
+    end
+
+    def validate_connection_environment(env)
+      return unless env["DATABASE_URL"] && connections.key?("PGPORT") && !connections.key?("DATABASE_URL")
+
+      raise Error, "Unset DATABASE_URL or explicitly map it; it overrides the mapped PGPORT."
+    end
+
+    def validate!(root)
+      validate_app!(root)
+      validate_name!(root)
+      if compose_file
+        @compose_file = File.expand_path(compose_file, root)
+        raise Error, "Compose file does not exist: #{compose_file}" unless File.file?(compose_file)
+      end
+      unless startup_timeout.positive? && shutdown_timeout.positive?
+        raise Error, "Startup and shutdown timeouts must be positive."
+      end
+
+      endpoints
+    end
+
+    private
+
+    def merge_options(inherited, overrides)
+      inherited.merge(overrides) do |key, previous, value|
+        key == :readiness && previous.is_a?(Hash) && value.is_a?(Hash) ? previous.merge(value) : value
+      end
+    end
+
+    def validate_app!(root)
+      %w[Gemfile bin/rails].each do |path|
+        next if File.file?(File.join(root, path))
+
+        raise Error, "Expected a Rails app; missing #{path} in #{root}."
+      end
+    end
+
+    def validate_name!(root)
+      @name ||= File.basename(root).downcase.gsub(/[^a-z0-9]+/, "-")[0, 45].gsub(/\A-|-\z/, "")
+      return if name.match?(/\A[a-z0-9](?:[a-z0-9-]{0,43}[a-z0-9])?\z/)
+
+      raise Error, "Set config.name to a hostname label of 1–45 lowercase letters, digits, or internal hyphens."
+    end
+  end
+end

data/lib/rails_dev/cookies.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class Cookies
+    def initialize(app, prefix:)
+      @app = app
+      @prefix = prefix
+    end
+
+    def call(env)
+      env["HTTP_COOKIE"] = env.fetch("HTTP_COOKIE", "").split(/;\s*/).filter_map do |cookie|
+        cookie.delete_prefix(@prefix) if cookie.start_with?(@prefix)
+      end.join("; ")
+
+      status, headers, body = @app.call(env)
+      if headers["set-cookie"]
+        headers["set-cookie"] = Array(headers["set-cookie"]).map { |cookie| "#{@prefix}#{cookie}" }
+      end
+      [status, headers, body]
+    end
+  end
+end

data/lib/rails_dev/endpoint.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module RailsDev
+  class Endpoint
+    attr_reader :name, :port
+    attr_accessor :url
+
+    def initialize(name, port:, env:, url_env: "RAILS_DEV_#{name.upcase.tr("-", "_")}_URL", readiness: false,
+                   defaults: {})
+      @name = name
+      @port = port
+      @preferred_port = port
+      @variable = env
+      @url_variable = url_env
+      @check = readiness
+      @options = { path: "/" }.merge(defaults).merge(readiness.is_a?(Hash) ? readiness : { path: readiness })
+      return if port.is_a?(Integer) && (1024..65_535).cover?(port)
+
+      raise Error, "#{name}: port must be an integer between 1024 and 65535."
+    end
+
+    def allocate(excluding: [])
+      @port = Ports.available(@preferred_port, excluding: excluding)
+      @url = "http://127.0.0.1:#{port}"
+      @ready = @started = @next_check = @last_failure = nil
+    end
+
+    def environment
+      { @variable => port.to_s, @url_variable => url }
+    end
+
+    def ready?(deadline)
+      return true if @ready || !@check
+
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @started ||= now
+      remaining = remaining_time(now, deadline)
+      return false if @next_check && now < @next_check
+
+      @next_check = now + @options.fetch(:interval, 0.1)
+      @ready = check(remaining)
+    end
+
+    def readiness_failure
+      return if @ready || !@check
+
+      target = if @check.respond_to?(:call)
+                 "custom readiness check"
+               else
+                 path = @options.fetch(:path).to_s.split(/[?#]/, 2).first
+                 "#{@options.fetch(:method, "GET").upcase} http://127.0.0.1:#{port}#{path}"
+               end
+      "#{name} (#{target}): #{@last_failure || "not checked yet"}"
+    end
+
+    private
+
+    def remaining_time(now, deadline)
+      remaining = [deadline, @started + @options.fetch(:timeout, Float::INFINITY)].min - now
+      unless remaining.positive?
+        raise Error, "Startup timed out: #{readiness_failure}. Check the process output and readiness settings."
+      end
+
+      remaining
+    end
+
+    def check(remaining)
+      @last_failure = "check did not pass" if @check.respond_to?(:call)
+      @check.respond_to?(:call) ? @check.call(self) : healthy_response?(remaining)
+    rescue Error
+      raise
+    rescue StandardError => error
+      raise Error, "#{name} readiness check failed: #{error.message}"
+    end
+
+    def healthy_response?(remaining)
+      response = connection(remaining).request(request, @options[:body])
+      successful_response?(response)
+    rescue SystemCallError, IOError, Timeout::Error, Net::ProtocolError => error
+      @last_failure = "request failed (#{error.class})"
+      false
+    end
+
+    def successful_response?(response)
+      success = @options.fetch(:success, 200)
+      expected = success.respond_to?(:call) ? "a passing custom success check" : Array(success).join(" or ")
+      @last_failure = "HTTP #{response.code}; expected #{expected}"
+      success.respond_to?(:call) ? success.call(response) : Array(success).include?(response.code.to_i)
+    end
+
+    def connection(remaining)
+      http = Net::HTTP.new("127.0.0.1", port, nil)
+      http.open_timeout = http.read_timeout = http.write_timeout = [@options.fetch(:request_timeout, 1), remaining].min
+      http
+    end
+
+    def request
+      method = @options.fetch(:method, "GET").upcase
+      headers = { "Host" => URI(url).host }.merge(@options.fetch(:headers, {}))
+      Net::HTTPGenericRequest.new(method, !@options[:body].nil?, method != "HEAD", @options.fetch(:path), headers)
+    end
+  end
+end

data/lib/rails_dev/foreman.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class Foreman
+    attr_reader :endpoints
+
+    def initialize(root, config)
+      @root = root
+      @config = config
+      @path = File.expand_path(config.procfile, root)
+      @names = File.readlines(@path).filter_map { |line| line[/\A([A-Za-z0-9_-]+):\s*.+/, 1] }.uniq
+      @endpoints = config.endpoints
+      validate!
+      @endpoints.select! { |endpoint| selected?(endpoint.name) }
+    end
+
+    def command
+      [RbConfig.ruby, Gem.bin_path("foreman", "foreman"), "start", "--procfile", @path, "--root", @root,
+       "--port", base_port.to_s, "--formation", formation,
+       "--timeout", @config.shutdown_timeout.to_s]
+    end
+
+    private
+
+    def validate!
+      missing = (endpoints.map(&:name) + @config.optional_processes.keys).uniq - @names
+      raise Error, "#{@config.procfile} is missing processes: #{missing.join(", ")}." unless missing.empty?
+      raise Error, "The primary web process must be enabled." unless selected?(@config.web.to_s)
+    end
+
+    def selected?(name)
+      selection = @config.optional_processes[name]
+      !selection || @config.enabled?(selection)
+    end
+
+    def base_port
+      port = endpoints.find { |endpoint| endpoint.name == @config.web.to_s }.port
+      port - (@names.index(@config.web.to_s) * 100)
+    end
+
+    def formation
+      @names.map { |name| "#{name}=#{selected?(name) ? 1 : 0}" }.join(",")
+    end
+  end
+end

data/lib/rails_dev/hooks.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsDev
+  class Hooks
+    def initialize(config, context)
+      @callbacks = config.hooks
+      @context = context
+    end
+
+    def call(name)
+      @callbacks.fetch(name).each { |callback| invoke(name, callback) }
+    end
+
+    def around(index = 0, &)
+      callback = @callbacks.fetch(:around_run)[index]
+      return yield unless callback
+
+      invoke(:around_run, callback, -> { around(index + 1, &) })
+    end
+
+    def after_stop(failure = nil)
+      @callbacks.fetch(:after_stop).reverse_each do |callback|
+        invoke(:after_stop, callback)
+      rescue StandardError => error
+        @context.say(error.message) if failure
+        failure ||= error
+      end
+      raise failure if failure
+    end
+
+    private
+
+    def invoke(name, callback, *)
+      @context.check_for_interrupt
+      callback.call(@context, *)
+      @context.check_for_interrupt
+    rescue Error
+      raise
+    rescue StandardError => error
+      raise Error, "#{name} hook failed: #{error.message}"
+    end
+  end
+end