bug_bunny 4.6.1 → 4.8.0

data/lib/bug_bunny/resource.rb

@@ -25,8 +25,7 @@ module BugBunny
     define_model_callbacks :save, :create, :update, :destroy
 
     attr_reader :remote_attributes
-    attr_accessor :persisted
-    attr_accessor :routing_key, :exchange, :exchange_type
+    attr_accessor :persisted, :routing_key, :exchange, :exchange_type
 
     # @return [Hash] Opciones específicas de instancia para exchange y queue.
     attr_accessor :exchange_options, :queue_options
@@ -38,7 +37,9 @@ module BugBunny
       attr_writer :exchange_options, :queue_options
 
       # @api private
-      def thread_config(key); Thread.current["bb_#{object_id}_#{key}"]; end
+      def thread_config(key)
+        Thread.current["bb_#{object_id}_#{key}"]
+      end
 
       # Resuelve la configuración buscando en el hilo, luego en la jerarquía de clases.
       # @param key [Symbol] Clave en el Thread.current.
@@ -47,29 +48,41 @@ module BugBunny
       def resolve_config(key, instance_var)
         val = thread_config(key)
         return val if val
+
         target = self
         while target <= BugBunny::Resource
           value = target.instance_variable_get(instance_var)
           return value.respond_to?(:call) ? value.call : value unless value.nil?
+
           target = target.superclass
         end
         nil
       end
 
       # @return [ConnectionPool, nil]
-      def connection_pool; resolve_config(:pool, :@connection_pool); end
+      def connection_pool
+        resolve_config(:pool, :@connection_pool)
+      end
 
       # @return [String] Nombre del exchange actual.
-      def current_exchange; resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined for #{name}"); end
+      def current_exchange
+        resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined for #{name}")
+      end
 
       # @return [String] Tipo de exchange ('direct', 'topic', 'fanout').
-      def current_exchange_type; resolve_config(:exchange_type, :@exchange_type) || 'direct'; end
+      def current_exchange_type
+        resolve_config(:exchange_type, :@exchange_type) || 'direct'
+      end
 
       # @return [Hash] Opciones de exchange específicas (Nivel 3 de la cascada).
-      def current_exchange_options; resolve_config(:exchange_options, :@exchange_options) || {}; end
+      def current_exchange_options
+        resolve_config(:exchange_options, :@exchange_options) || {}
+      end
 
       # @return [Hash] Opciones de cola específicas.
-      def current_queue_options; resolve_config(:queue_options, :@queue_options) || {}; end
+      def current_queue_options
+        resolve_config(:queue_options, :@queue_options) || {}
+      end
 
       # @return [String] Nombre del recurso para la construcción de rutas.
       def resource_name
@@ -126,7 +139,8 @@ module BugBunny
       # @param pool [ConnectionPool] Pool de conexiones.
       # @param exchange_options [Hash] Opciones de infraestructura.
       # @param queue_options [Hash] Opciones de cola.
-      def with(exchange: nil, routing_key: nil, exchange_type: nil, pool: nil, exchange_options: nil, queue_options: nil)
+      def with(exchange: nil, routing_key: nil, exchange_type: nil, pool: nil, exchange_options: nil,
+               queue_options: nil)
         keys = {
           exchange: "bb_#{object_id}_exchange",
           exchange_type: "bb_#{object_id}_exchange_type",
@@ -163,9 +177,7 @@ module BugBunny
         end
 
         def method_missing(method, *args, &block)
-          if @used
-            ::Kernel.raise ::BugBunny::Error, "ScopeProxy is single-use. Call .with again for a new context."
-          end
+          ::Kernel.raise ::BugBunny::Error, 'ScopeProxy is single-use. Call .with again for a new context.' if @used
           @used = true
           @target.public_send(method, *args, &block)
         ensure
@@ -176,11 +188,13 @@ module BugBunny
       # Calcula la routing key final.
       # @param id [String, nil] ID del recurso.
       # @return [String]
-      def calculate_routing_key(id = nil)
+      def calculate_routing_key(_id = nil)
         manual_rk = thread_config(:routing_key)
         return manual_rk if manual_rk
+
         static_rk = resolve_config(:routing_key, :@routing_key)
         return static_rk if static_rk.present?
+
         resource_name
       end
 
@@ -206,6 +220,7 @@ module BugBunny
         )
 
         return [] unless response['body'].is_a?(Array)
+
         response['body'].map do |attrs|
           inst = new(attrs)
           inst.persisted = true
@@ -218,7 +233,9 @@ module BugBunny
 
       # Devuelve todos los registros.
       # @return [Array<BugBunny::Resource>]
-      def all; where({}); end
+      def all
+        where({})
+      end
 
       # Busca un registro por ID (GET).
       # Mapea un 404 (NotFound) devolviendo un objeto nulo.
@@ -264,8 +281,8 @@ module BugBunny
     # Inicializa el recurso.
     # @param attributes [Hash]
     def initialize(attributes = {})
-      @remote_attributes = {}.with_indifferent_access
-      @dynamic_changes = Set.new # Rastreo manual para atributos dinámicos
+      @extra_attributes = {}.with_indifferent_access
+      @dynamic_changes = Set.new
       @persisted = false
 
       # Contexto de infraestructura
@@ -275,41 +292,61 @@ module BugBunny
       @exchange_options = self.class.thread_config(:exchange_options) || self.class.current_exchange_options
       @queue_options = self.class.thread_config(:queue_options) || self.class.current_queue_options
 
-      super()
-      assign_attributes(attributes)
+      super
     end
 
-    # Limpia tanto el rastreo de ActiveModel como nuestro rastreo dinámico.
+    # Limpia el rastreo de ActiveModel y nuestro rastreo dinámico interno.
     def clear_changes_information
       super
       @dynamic_changes.clear
     end
 
+    # @return [Boolean] true si hay cambios nativos o dinámicos.
+    def changed?
+      super || @dynamic_changes.any?
+    end
+
+    # @return [Array<String>] Lista de atributos que han cambiado.
+    def changed
+      (super + @dynamic_changes.to_a).uniq
+    end
+
     # Serialización combinada.
     # @return [Hash]
     def attributes_for_serialization
-      @remote_attributes.merge(attributes)
+      @extra_attributes.merge(attributes)
     end
 
     # @return [String]
-    def calculate_routing_key(id=nil); @routing_key || self.class.calculate_routing_key(id); end
+    def calculate_routing_key(id = nil)
+      @routing_key || self.class.calculate_routing_key(id)
+    end
 
     # @return [String]
-    def current_exchange; @exchange || self.class.current_exchange; end
+    def current_exchange
+      @exchange || self.class.current_exchange
+    end
 
     # @return [String]
-    def current_exchange_type; @exchange_type || self.class.current_exchange_type; end
+    def current_exchange_type
+      @exchange_type || self.class.current_exchange_type
+    end
 
     # @return [BugBunny::Client]
-    def bug_bunny_client; self.class.bug_bunny_client; end
+    def bug_bunny_client
+      self.class.bug_bunny_client
+    end
 
     # @return [Boolean]
-    def persisted?; !!@persisted; end
+    def persisted?
+      !!@persisted
+    end
 
     # Asignación masiva de atributos.
     # @param new_attributes [Hash]
     def assign_attributes(new_attributes)
       return if new_attributes.nil?
+
       new_attributes.each { |k, v| public_send("#{k}=", v) }
     end
 
@@ -324,57 +361,58 @@ module BugBunny
     # Retorna el hash combinado de cambios (Tipados + Dinámicos).
     # @return [Hash]
     def changes_to_send
-      # 1. Cambios de ActiveModel (Tipados)
-      payload = changes.transform_values(&:last)
+      # 1. Obtener los nombres de todos los atributos que han cambiado (incluyendo dinámicos vía attribute_will_change!)
+      changed_keys = changed
 
-      # 2. Cambios Dinámicos (Manuales)
-      @dynamic_changes.each do |key|
-        payload[key] = @remote_attributes[key]
+      # 2. Construir el payload con los valores actuales de esas keys
+      payload = {}
+      changed_keys.each do |key|
+        payload[key] = public_send(key)
       end
 
       return payload unless payload.empty?
 
-      # Fallback: Si no hay cambios detectados, enviamos todo (útil para create)
+      # Fallback: Si no hay cambios detectados (ej: en un create), enviamos todo
       attributes_for_serialization.except('id', 'ID', 'Id', '_id')
     end
 
-    # Intercepta asignaciones dinámicas y las marca como sucias.
+    # Intercepta asignaciones dinámicas y las registra como cambios.
     def method_missing(method_name, *args, &block)
       attribute_name = method_name.to_s
       if attribute_name.end_with?('=')
         key = attribute_name.chop
         val = args.first
 
-        if @remote_attributes[key] != val
+        if @extra_attributes[key] != val
           @dynamic_changes << key
+          @extra_attributes[key] = val
         end
-
-        @remote_attributes[key] = val
       else
-        @remote_attributes.key?(attribute_name) ? @remote_attributes[attribute_name] : super
+        @extra_attributes.key?(attribute_name) ? @extra_attributes[attribute_name] : super
       end
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      @remote_attributes.key?(method_name.to_s.sub(/=$/, '')) || super
+      @extra_attributes.key?(method_name.to_s.sub(/=$/, '')) || super
     end
 
     # @return [Object] Valor del ID buscando en múltiples nomenclaturas.
     def id
-      attributes['id'] || @remote_attributes['id'] || @remote_attributes['ID'] || @remote_attributes['Id'] || @remote_attributes['_id']
+      attributes['id'] || @extra_attributes['id'] || @extra_attributes['ID'] || @extra_attributes['Id'] || @extra_attributes['_id']
     end
 
     def id=(value)
       if self.class.attribute_names.include?('id')
-        super(value)
+        super
       else
-        @remote_attributes['id'] = value
+        @dynamic_changes << 'id' if @extra_attributes['id'] != value
+        @extra_attributes['id'] = value
       end
     end
 
     def read_attribute_for_validation(attr)
       attr_s = attr.to_s
-      self.class.attribute_names.include?(attr_s) ? attribute(attr_s) : @remote_attributes[attr_s]
+      self.class.attribute_names.include?(attr_s) ? attribute(attr_s) : @extra_attributes[attr_s]
     end
 
     # @!group Persistencia
@@ -423,6 +461,7 @@ module BugBunny
     # @return [Boolean]
     def destroy
       return false unless persisted?
+
       run_callbacks(:destroy) do
         path = "#{self.class.resource_name}/#{id}"
         rk = calculate_routing_key(id)
@@ -449,6 +488,7 @@ module BugBunny
     # Carga errores remotos en el objeto local (utilizado al recibir 422).
     def load_remote_rabbit_errors(errors_hash)
       return if errors_hash.nil? || errors_hash.empty?
+
       if errors_hash.is_a?(String)
         errors.add(:base, errors_hash)
       else

data/lib/bug_bunny/routing/route.rb

@@ -17,6 +17,9 @@ module BugBunny
       # @return [String] El nombre del controlador en formato snake_case (ej. 'api/v1/metrics').
       attr_reader :controller
 
+      # @return [String, nil] El namespace del controlador si existe (ej. 'Api::V1').
+      attr_reader :namespace
+
       # @return [String] El nombre de la acción a ejecutar (ej. 'show').
       attr_reader :action
 
@@ -25,10 +28,12 @@ module BugBunny
       # @param http_method [String, Symbol] Verbo HTTP (ej. :get, 'POST').
       # @param path_pattern [String] Patrón de la URL. Los parámetros dinámicos deben iniciar con ':' (ej. 'users/:id').
       # @param to [String] Destino en formato 'controlador#accion' (ej. 'users#show').
+      # @param namespace [String, nil] El namespace del controlador (ej: 'Api::V1').
       # @raise [ArgumentError] Si el formato del destino `to` es inválido.
-      def initialize(http_method, path_pattern, to:)
+      def initialize(http_method, path_pattern, to:, namespace: nil)
         @http_method = http_method.to_s.upcase
         @path_pattern = normalize_path(path_pattern)
+        @namespace = namespace
 
         parse_destination!(to)
         compile_regex!

data/lib/bug_bunny/routing/route_set.rb

@@ -57,30 +57,57 @@ module BugBunny
       # Registra una ruta para el verbo GET.
       # @param path [String, Symbol] Patrón de la URL.
       # @param to [String, nil] Destino (controlador#accion). Si es nil, se infiere del scope.
-      def get(path, to: nil);    add_route('GET', path, to: to); end
+      def get(path, to: nil)
+        add_route('GET', path, to: to)
+      end
 
       # Registra una ruta para el verbo POST.
       # @param path [String, Symbol] Patrón de la URL.
       # @param to [String, nil] Destino (controlador#accion). Si es nil, se infiere del scope.
-      def post(path, to: nil);   add_route('POST', path, to: to); end
+      def post(path, to: nil)
+        add_route('POST', path, to: to)
+      end
 
       # Registra una ruta para el verbo PUT.
       # @param path [String, Symbol] Patrón de la URL.
       # @param to [String, nil] Destino (controlador#accion). Si es nil, se infiere del scope.
-      def put(path, to: nil);    add_route('PUT', path, to: to); end
+      def put(path, to: nil)
+        add_route('PUT', path, to: to)
+      end
 
       # Registra una ruta para el verbo PATCH.
       # @param path [String, Symbol] Patrón de la URL.
       # @param to [String, nil] Destino (controlador#accion). Si es nil, se infiere del scope.
-      def patch(path, to: nil);  add_route('PATCH', path, to: to); end
+      def patch(path, to: nil)
+        add_route('PATCH', path, to: to)
+      end
 
       # Registra una ruta para el verbo DELETE.
       # @param path [String, Symbol] Patrón de la URL.
       # @param to [String, nil] Destino (controlador#accion). Si es nil, se infiere del scope.
-      def delete(path, to: nil); add_route('DELETE', path, to: to); end
+      def delete(path, to: nil)
+        add_route('DELETE', path, to: to)
+      end
 
       # @!endgroup
 
+      # Define un bloque de namespace para organizar controladores en módulos.
+      # Los namespaces pueden anidarse y se acumulan (ej: `namespace :api { namespace :v1 }`
+      # resulta en el namespace "Api::V1").
+      #
+      # @param name [Symbol, String] Nombre del namespace (ej: :api, :v1).
+      # @yield Bloque conteniendo las definiciones de rutas dentro de este namespace.
+      # @return [void]
+      # @example
+      #   namespace :api do
+      #     resources :users # Busca Api::UsersController
+      #   end
+      def namespace(name, &block)
+        with_scope({ type: :namespace, name: name.to_s.camelize }) do
+          instance_eval(&block)
+        end
+      end
+
       # Macro que genera automáticamente las rutas CRUD para un recurso RESTful.
       # Soporta filtrado mediante `only` y `except`, y acepta un bloque para rutas anidadas.
       #
@@ -96,7 +123,7 @@ module BugBunny
         resource_path = name.to_s
 
         # Todas las acciones estándar disponibles
-        actions = [:index, :show, :create, :update, :destroy]
+        actions = %i[index show create update destroy]
 
         # Aplicamos los filtros si existen
         if only
@@ -114,10 +141,10 @@ module BugBunny
         delete "#{resource_path}/:id", to: "#{resource_path}#destroy" if actions.include?(:destroy)
 
         # Si se pasa un bloque, abrimos un Scope de Recurso para rutas anidadas
-        if block_given?
-          with_scope({ type: :resource, name: resource_path }) do
-            instance_eval(&block)
-          end
+        return unless block_given?
+
+        with_scope({ type: :resource, name: resource_path }) do
+          instance_eval(&block)
         end
       end
 
@@ -177,18 +204,19 @@ module BugBunny
       #
       # @param method [String] Verbo HTTP entrante (ej. 'GET').
       # @param path [String] URL entrante (ej. 'nodes/123/drain').
-      # @return [Hash, nil] Hash con `:controller`, `:action` y `:params`, o `nil` si no hay match.
+      # @return [Hash, nil] Hash con `:controller`, `:action`, `:params` y `:namespace`, o `nil` si no hay match.
       def recognize(method, path)
         @routes.each do |route|
-          if route.match?(method, path)
-            extracted_params = route.extract_params(path)
-
-            return {
-              controller: route.controller,
-              action: route.action,
-              params: extracted_params
-            }
-          end
+          next unless route.match?(method, path)
+
+          extracted_params = route.extract_params(path)
+
+          return {
+            controller: route.controller,
+            action: route.action,
+            params: extracted_params,
+            namespace: route.namespace
+          }
         end
 
         # Si llegamos aquí, es un 404 seguro.
@@ -220,10 +248,11 @@ module BugBunny
         end
 
         if final_to.nil?
-          raise ArgumentError, "Falta el destino 'to:' para la ruta #{method} '#{final_path}'. Usa la sintaxis 'controlador#accion'"
+          raise ArgumentError,
+                "Falta el destino 'to:' para la ruta #{method} '#{final_path}'. Usa la sintaxis 'controlador#accion'"
         end
 
-        @routes << Route.new(method, final_path, to: final_to)
+        @routes << Route.new(method, final_path, to: final_to, namespace: current_namespace)
       end
 
       # --- LÓGICA DE SCOPES INTERNOS ---
@@ -263,6 +292,15 @@ module BugBunny
         end
         nil
       end
+
+      # Calcula el namespace acumulado recorriendo la pila de scopes.
+      #
+      # @return [String, nil] El namespace (ej: "Api::V1") o nil si no hay.
+      # @api private
+      def current_namespace
+        parts = @scopes.select { |s| s[:type] == :namespace }.map { |s| s[:name] }
+        parts.empty? ? nil : parts.join('::')
+      end
     end
   end
 end

data/lib/bug_bunny/session.rb

@@ -9,6 +9,7 @@ module BugBunny
   # @api private
   class Session
     include BugBunny::Observability
+
     # @!group Opciones por Defecto (Nivel 1: Gema)
 
     # Opciones predeterminadas de la gema para Exchanges.
@@ -32,6 +33,7 @@ module BugBunny
       @connection = connection
       @publisher_confirms = publisher_confirms
       @channel = nil
+      @channel_mutex = Mutex.new
       @logger = BugBunny.configuration.logger
     end
 
@@ -43,12 +45,17 @@ module BugBunny
     # @return [Bunny::Channel] Un canal abierto y configurado.
     # @raise [BugBunny::CommunicationError] Si no se puede restablecer la conexión.
     def channel
-      # Si el canal existe y está abierto, lo devolvemos rápido.
+      # Fast path: canal abierto, sin adquirir el mutex.
       return @channel if @channel&.open?
 
-      # Si no, intentamos asegurar la conexión y crear el canal.
-      ensure_connection!
-      create_channel!
+      # Slow path: adquirimos el mutex y verificamos de nuevo (double-checked locking).
+      # Evita que múltiples threads creen canales simultáneamente cuando el canal cae.
+      @channel_mutex.synchronize do
+        return @channel if @channel&.open?
+
+        ensure_connection!
+        create_channel!
+      end
 
       @channel
     end
@@ -98,8 +105,10 @@ module BugBunny
     # Cierra el canal asociado a esta sesión de forma segura.
     # @return [void]
     def close
-      @channel&.close if @channel&.open?
-      @channel = nil
+      @channel_mutex.synchronize do
+        @channel&.close if @channel&.open?
+        @channel = nil
+      end
     end
 
     private
@@ -113,9 +122,7 @@ module BugBunny
 
       @channel.confirm_select if @publisher_confirms
 
-      if BugBunny.configuration.channel_prefetch
-        @channel.prefetch(BugBunny.configuration.channel_prefetch)
-      end
+      @channel.prefetch(BugBunny.configuration.channel_prefetch) if BugBunny.configuration.channel_prefetch
     rescue StandardError => e
       raise BugBunny::CommunicationError, "Failed to create channel: #{e.message}"
     end
@@ -127,10 +134,10 @@ module BugBunny
     def ensure_connection!
       return if @connection.open?
 
-      safe_log(:warn, "session.reconnect_attempt")
+      safe_log(:warn, 'session.reconnect_attempt')
       @connection.start
     rescue StandardError => e
-      safe_log(:error, "session.reconnect_failed", **exception_metadata(e))
+      safe_log(:error, 'session.reconnect_failed', **exception_metadata(e))
       raise BugBunny::CommunicationError, "Could not reconnect to RabbitMQ: #{e.message}"
     end
   end

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "4.6.1"
+  VERSION = '4.8.0'
 end

data/lib/bug_bunny.rb

@@ -25,6 +25,7 @@ require_relative 'bug_bunny/railtie' if defined?(Rails)
 # Actúa como espacio de nombres y punto de configuración global.
 module BugBunny
   extend BugBunny::Observability
+
   private_class_method :safe_log, :exception_metadata, :observability_name
 
   class << self
@@ -56,6 +57,7 @@ module BugBunny
   def self.configure
     self.configuration ||= Configuration.new
     yield(configuration)
+    configuration.validate!
   end
 
   # Crea e inicia una nueva conexión a RabbitMQ utilizando la gema Bunny.
@@ -94,9 +96,9 @@ module BugBunny
 
     @global_connection.close if @global_connection.open?
     @global_connection = nil
-    
+
     @logger = configuration.logger
-    safe_log(:info, "bug_bunny.disconnect")
+    safe_log(:info, 'bug_bunny.disconnect')
   end
 
   # @api private

data/lib/generators/bug_bunny/install/install_generator.rb

@@ -20,7 +20,7 @@ module BugBunny
       # @api private
       source_root File.expand_path('templates', __dir__)
 
-      desc "Instala la configuración inicial de BugBunny y crea la estructura de directorios."
+      desc 'Instala la configuración inicial de BugBunny y crea la estructura de directorios.'
 
       # Genera el archivo de configuración inicial.
       # Copia la plantilla `initializer.rb` a `config/initializers/bug_bunny.rb` en la app destino.
@@ -33,15 +33,55 @@ module BugBunny
       # Crea la estructura de carpetas necesaria para el patrón MVC de BugBunny.
       #
       # Genera:
-      # * `app/rabbit/controllers/`: Directorio donde vivirán los controladores de consumidores.
+      # * `app/bug_bunny/controllers/`: Directorio donde vivirán los controladores de consumidores.
       # * `.keep`: Archivo marcador para asegurar que Git rastree la carpeta aunque esté vacía.
       #
       # @return [void]
       def create_directories
-        empty_directory "app/rabbit/controllers"
-        create_file "app/rabbit/controllers/.keep", ""
+        empty_directory 'app/bug_bunny/controllers'
+        create_file 'app/bug_bunny/controllers/.keep', ''
+      end
+
+      # Escribe el bloque inicial de BugBunny en CLAUDE.md del proyecto consumidor.
+      #
+      # Si CLAUDE.md no existe, crea uno mínimo con la sección correspondiente.
+      # Si ya existe, agrega la sección `## Gemas internas` con el bloque de bug_bunny.
+      # En ambos casos, el rake task `bug_bunny:sync` se encarga de las actualizaciones futuras.
+      #
+      # @return [void]
+      def update_claude_md
+        spec = Gem::Specification.find_by_name('bug_bunny')
+        version = spec.version.to_s
+        docs_path = File.join(spec.gem_dir, 'docs', 'ai')
+
+        block = <<~BLOCK
+          ## Gemas internas
+
+          ### bug_bunny
+          - **Version:** #{version}
+          - **Docs:** #{docs_path}
+          - **Updated:** #{Time.now.strftime('%Y-%m-%d')}
+        BLOCK
+
+        claude_md = File.join(destination_root, 'CLAUDE.md')
+
+        if File.exist?(claude_md)
+          content = File.read(claude_md)
+          if content.include?('### bug_bunny')
+            say_status :skip, 'CLAUDE.md already has a bug_bunny block — run `rake bug_bunny:sync` to update'
+          elsif content.include?('## Gemas internas')
+            inject_into_file 'CLAUDE.md', "\n#{block.lines.drop(2).join}", after: "## Gemas internas\n"
+            say_status :update, 'Added bug_bunny block to existing ## Gemas internas section in CLAUDE.md'
+          else
+            append_to_file 'CLAUDE.md', "\n#{block}"
+            say_status :update, 'Added ## Gemas internas section to CLAUDE.md'
+          end
+        else
+          create_file 'CLAUDE.md', "# #{Rails.application.class.module_parent_name}\n\n#{block}"
+          say_status :create, 'CLAUDE.md created with bug_bunny block'
+        end
 
-        puts "🐰 BugBunny structure created successfully!"
+        say '  Add `bundle exec rake bug_bunny:sync` to bin/setup to keep this block up to date.'
       end
     end
   end