pgbus 0.9.10 → 0.10.0

data/lib/pgbus/generators/config_converter.rb

@@ -1,345 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module Pgbus
-  module Generators
-    # Converts a +config/pgbus.yml+ file into a Ruby initializer
-    # (+config/initializers/pgbus.rb+) using the Ruby DSL added in
-    # Pgbus 0.5+ — capsule string DSL, ActiveSupport::Duration coercion,
-    # auto-tuned pool size, named capsules, etc.
-    #
-    # Drops settings that:
-    #   - match the gem default (no point restating it)
-    #   - are deprecated (settings that no longer exist in the public API —
-    #     see DEPRECATED_SETTINGS; pool_size is NOT one of these, it's a
-    #     live accessor that overrides auto-tuning and is preserved)
-    #
-    # Converts seconds to durations when they evenly divide into a clean
-    # unit (7 days, 30 days, 10 minutes). Falls back to the raw integer
-    # otherwise.
-    #
-    # When the YAML has multiple environments with different values for
-    # the same setting, emits Rails.env-aware code:
-    #
-    #   - 2 envs with same value → unconditional line
-    #   - 2 envs, one differs → `unless Rails.env.X?` modifier
-    #   - 3+ envs with differences → `case Rails.env when ... end`
-    #
-    # Backwards compatible: the original YAML file is NOT touched. The
-    # generator's CLI wrapper writes the new initializer and tells the
-    # user to delete the YAML when ready.
-    class ConfigConverter
-      class Error < Pgbus::Error; end
-
-      # Setters that accept ActiveSupport::Duration (PR 5).
-      DURATION_SETTINGS = %w[
-        visibility_timeout archive_retention idempotency_ttl
-        outbox_retention stats_retention recurring_execution_retention
-      ].freeze
-
-      # Settings that no longer exist in the public API. The converter
-      # silently drops these from the generated initializer so users on
-      # legacy YAML get a clean migration. NOTE: pool_size is intentionally
-      # NOT here — it's a live Configuration#pool_size accessor users set to
-      # override auto-tuning, so it must survive the conversion unchanged.
-      #
-      #   - notify_throttle_ms     -> Pgbus::Client::NOTIFY_THROTTLE_MS
-      #   - circuit_breaker_*      -> Pgbus::CircuitBreaker constants
-      #   - archive_compaction_*   -> Pgbus::Process::Dispatcher constants
-      #   - dead_letter_queue_suffix -> Pgbus::DEAD_LETTER_SUFFIX (frozen)
-      DEPRECATED_SETTINGS = %w[
-        notify_throttle_ms
-        circuit_breaker_threshold circuit_breaker_base_backoff circuit_breaker_max_backoff
-        archive_compaction_interval archive_compaction_batch_size
-        dead_letter_queue_suffix
-      ].freeze
-
-      # Settings whose default we know how to compute by inspecting
-      # Pgbus::Configuration.new. Any setting not listed here is emitted
-      # as-is (we can't tell if it matches the default).
-      KNOWN_SETTINGS = %w[
-        queue_prefix default_queue pool_timeout listen_notify
-        visibility_timeout max_retries idempotency_ttl
-        max_jobs_per_worker max_memory_mb max_worker_lifetime
-        dispatch_interval prefetch_limit
-        circuit_breaker_enabled
-        archive_retention
-        outbox_enabled outbox_poll_interval outbox_batch_size outbox_retention
-        stats_enabled stats_retention
-        recurring_schedule_interval recurring_execution_retention skip_recurring
-        polling_interval default_priority priority_levels
-        return_to_app_url workers
-      ].freeze
-
-      def self.from_yaml(path)
-        raise Error, "config file not found: #{path}" unless File.exist?(path)
-
-        parsed = YAML.safe_load_file(path, aliases: true, permitted_classes: [Symbol])
-        from_hash(parsed)
-      end
-
-      def self.from_hash(envs_hash)
-        new(envs_hash).render
-      end
-
-      def initialize(envs_hash)
-        @envs = (envs_hash || {}).reject { |env, _| env.start_with?("default") }
-        @envs = { "production" => envs_hash } if @envs.empty? && envs_hash
-        @defaults = build_defaults
-      end
-
-      def render
-        lines = []
-        lines << "# frozen_string_literal: true"
-        lines << "#"
-        lines << "# Generated by `rails generate pgbus:update` from config/pgbus.yml."
-        lines << "# Review and adjust as needed, then delete config/pgbus.yml."
-        lines << ""
-        lines << "Pgbus.configure do |c|"
-
-        body = render_body
-        body.each { |line| lines << "  #{line}" }
-
-        lines << "end"
-        "#{lines.join("\n")}\n"
-      end
-
-      private
-
-      def build_defaults
-        config = Pgbus::Configuration.new
-        KNOWN_SETTINGS.each_with_object({}) do |key, h|
-          h[key] = config.public_send(key) if config.respond_to?(key)
-        end
-      end
-
-      def render_body
-        all_settings = collect_all_settings
-        return [] if all_settings.empty?
-
-        constant_settings, varying_settings = partition_by_variance(all_settings)
-        special_keys = %w[workers]
-
-        lines = []
-        # Special: workers comes first (most user-visible)
-        special_keys.each do |key|
-          rendered = render_workers(constant_settings[key], varying_settings[key])
-          lines.concat(rendered) if rendered
-        end
-
-        constant_settings.each do |key, value|
-          next if special_keys.include?(key)
-          next if drop?(key, value)
-
-          lines << render_setting(key, value)
-        end
-
-        varying_settings.each do |key, env_values|
-          next if special_keys.include?(key)
-          next if env_values.values.all? { |v| drop?(key, v) }
-
-          lines.concat(render_varying_setting(key, env_values))
-        end
-
-        lines
-      end
-
-      def collect_all_settings
-        all_keys = @envs.values.flat_map { |env_settings| env_settings&.keys || [] }.uniq
-        all_keys.to_h do |key|
-          [key, @envs.transform_values { |env_settings| env_settings&.fetch(key, :__missing__) }]
-        end
-      end
-
-      # Returns [constant_settings, varying_settings].
-      # constant_settings: { "key" => value }   (same value in EVERY env)
-      # varying_settings:  { "key" => { env => value, ... } }
-      #
-      # A setting is only "constant" when it is present in every env
-      # and all envs agree on the value. If any env is missing the
-      # setting entirely (e.g. `polling_interval: 0.01` set only under
-      # `test:`), emitting it as an unconditional line would silently
-      # apply the value to envs that never asked for it — see #93.
-      def partition_by_variance(all_settings)
-        constant = {}
-        varying = {}
-        all_settings.each do |key, env_values|
-          present_values = env_values.reject { |_, v| v == :__missing__ }
-          unique_values = present_values.values.uniq
-          all_envs_present = present_values.size == env_values.size
-
-          if all_envs_present && unique_values.size <= 1
-            constant[key] = unique_values.first
-          else
-            varying[key] = present_values
-          end
-        end
-        [constant, varying]
-      end
-
-      def drop?(key, value)
-        return true if DEPRECATED_SETTINGS.include?(key)
-        return true if value == :__missing__
-        return true if @defaults.key?(key) && @defaults[key] == value
-
-        false
-      end
-
-      def render_setting(key, value)
-        "c.#{key} = #{render_value(key, value)}"
-      end
-
-      def render_varying_setting(key, env_values)
-        envs = env_values.keys
-
-        # Single-env coverage: the setting exists in exactly one env.
-        # Emit an `if Rails.env.X?` modifier rather than a case block
-        # so other envs fall back to the gem default. This is the
-        # fix for #93 — without it, a `test:`-only `polling_interval`
-        # would leak into dev and prod as an unconditional assignment.
-        if envs.size == 1
-          env = envs.first
-          value = env_values[env]
-          return ["c.#{key} = #{render_value(key, value)} if Rails.env.#{env}?"]
-        end
-
-        if envs.size == 2 && envs.include?("development")
-          # Special case: "everything except dev" — common pattern
-          non_dev_value = env_values.except("development").values.first
-          dev_value = env_values["development"]
-          return ["c.#{key} = #{render_value(key, non_dev_value)} unless Rails.env.development?"] if dev_value.nil? && non_dev_value
-        end
-
-        # Fallback: case Rails.env block — `when` clauses indented one
-        # level inside the case, `end` flush with `c.X` (standard Ruby
-        # formatting for assigned case expressions).
-        lines = ["c.#{key} = case Rails.env"]
-        env_values.each do |env, value|
-          lines << "  when \"#{env}\" then #{render_value(key, value)}"
-        end
-        lines << "end"
-        lines
-      end
-
-      def render_workers(constant_workers, varying_workers)
-        if constant_workers && !varying_workers
-          rendered = render_workers_value(constant_workers)
-          return rendered unless rendered.nil? || rendered.empty?
-        end
-
-        if varying_workers
-          # Different worker config per env. when clauses indented one
-          # level inside the case, end flush with c.workers (standard
-          # Ruby formatting for assigned case expressions).
-          lines = ["c.workers = case Rails.env"]
-          varying_workers.each do |env, workers|
-            string_form = workers_as_string(workers)
-            value = string_form ? string_form.inspect : workers.inspect
-            lines << "  when \"#{env}\" then #{value}"
-          end
-          lines << "end"
-          return lines
-        end
-
-        nil
-      end
-
-      def render_workers_value(workers)
-        return nil if workers.nil? || workers == :__missing__
-
-        # Drop if matches the gem default ([{queues: %w[default], threads: 5}]).
-        # Compare via normalized form (string keys both sides) so YAML's
-        # string-keyed hashes match the symbol-keyed default.
-        return nil if normalize_workers(workers) == normalize_workers(@defaults["workers"])
-
-        if workers_simple?(workers)
-          string_form = workers_as_string(workers)
-          ["c.workers = #{string_form.inspect}"]
-        else
-          workers.map.with_index do |capsule, idx|
-            render_capsule_call(capsule, idx)
-          end
-        end
-      end
-
-      # Normalize a workers array to symbol-keyed hashes with array-of-string
-      # queues for stable comparison. Doesn't mutate input.
-      def normalize_workers(workers)
-        return nil if workers.nil?
-
-        workers.map do |capsule|
-          {
-            queues: Array(capsule[:queues] || capsule["queues"]).map(&:to_s),
-            threads: (capsule[:threads] || capsule["threads"] || 5).to_i
-          }
-        end
-      end
-
-      def workers_simple?(workers)
-        workers.all? do |capsule|
-          extras = capsule.keys.map(&:to_s) - %w[queues threads]
-          extras.empty?
-        end
-      end
-
-      def workers_as_string(workers)
-        workers.map do |capsule|
-          queues = (capsule["queues"] || capsule[:queues]).join(", ")
-          threads = capsule["threads"] || capsule[:threads] || 5
-          "#{queues}: #{threads}"
-        end.join("; ")
-      end
-
-      def render_capsule_call(capsule, _idx)
-        queues = capsule["queues"] || capsule[:queues]
-        threads = capsule["threads"] || capsule[:threads] || 5
-        name = capsule["name"] || capsule[:name] || queues.first
-        opts = capsule.reject { |k, _| %w[queues threads name].include?(k.to_s) }
-
-        parts = ["queues: #{queues.inspect}", "threads: #{threads}"]
-        opts.each { |k, v| parts << "#{k}: #{v.inspect}" }
-
-        "c.capsule :#{name}, #{parts.join(", ")}"
-      end
-
-      def render_value(key, value)
-        return "nil" if value.nil?
-
-        if DURATION_SETTINGS.include?(key) && value.is_a?(Integer) && value.positive?
-          duration_form = format_duration(value)
-          return duration_form if duration_form
-        end
-
-        if value.is_a?(Integer) && value >= 1000
-          format_integer_with_underscores(value)
-        else
-          value.inspect
-        end
-      end
-
-      def format_duration(seconds)
-        units = [
-          [86_400, "day", "days"],
-          [3600, "hour", "hours"],
-          [60, "minute", "minutes"],
-          [1, "second", "seconds"]
-        ]
-
-        units.each do |unit_seconds, singular, plural|
-          next unless (seconds % unit_seconds).zero?
-
-          count = seconds / unit_seconds
-          unit_name = count == 1 ? singular : plural
-          return "#{count}.#{unit_name}"
-        end
-
-        nil
-      end
-
-      def format_integer_with_underscores(int)
-        int.to_s.reverse.scan(/\d{1,3}/).join("_").reverse
-      end
-    end
-  end
-end