smart_message 0.0.10 → 0.0.13

data/lib/smart_message/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

data/lib/smart_message/.idea/markdown.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MarkdownSettings">
+    <option name="fileGroupingEnabled" value="true" />
+  </component>
+</project>

data/lib/smart_message/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="ruby-2.6.10-p210" project-jdk-type="RUBY_SDK" />
+</project>

data/lib/smart_message/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/smart_message.iml" filepath="$PROJECT_DIR$/.idea/smart_message.iml" />
+    </modules>
+  </component>
+</project>

data/lib/smart_message/.idea/smart_message.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="ModuleRunConfigurationManager">
+    <shared />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/features" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/spec" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v1.17.2, ruby-2.6.10-p210) [gem]" level="application" />
+  </component>
+</module>

data/lib/smart_message/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

data/lib/smart_message/addressing.rb

@@ -202,6 +202,11 @@ module SmartMessage
         end
       end
       
+      # Setter method for from - allows ClassName.from = 'value' syntax
+      def from=(entity_id)
+        from(entity_id)
+      end
+      
       def from_configured?; !from.nil?; end
       def from_missing?;     from.nil?; end
       def reset_from; 
@@ -224,6 +229,11 @@ module SmartMessage
         end
       end
       
+      # Setter method for to - allows ClassName.to = 'value' syntax
+      def to=(entity_id)
+        to(entity_id)
+      end
+      
       def to_configured?;   !to.nil?; end
       def to_missing?;       to.nil?; end
       def reset_to; 
@@ -246,6 +256,11 @@ module SmartMessage
         end
       end
       
+      # Setter method for reply_to - allows ClassName.reply_to = 'value' syntax
+      def reply_to=(entity_id)
+        reply_to(entity_id)
+      end
+      
       def reply_to_configured?; !reply_to.nil?; end
       def reply_to_missing?;     reply_to.nil?; end
       def reset_reply_to; 

data/lib/smart_message/base.rb

@@ -50,7 +50,6 @@ module SmartMessage
       # instance-level override of class plugins  
       # Don't use fallback defaults here - let the methods handle fallbacks when actually used
       @transport   = (self.class.class_variable_get(:@@transport) rescue nil)
-      @serializer  = (self.class.class_variable_get(:@@serializer) rescue nil)
 
       # Check if we're reconstructing from serialized data (complete header provided)
       if props[:_sm_header]
@@ -71,8 +70,8 @@ module SmartMessage
         @to = header.to
         @reply_to = header.reply_to
         
-        # Extract payload properties
-        payload_props = props[:_sm_payload] || {}
+        # Extract payload properties directly from props (flat structure)
+        payload_props = props.except(:_sm_header)
         
         attributes = {
           _sm_header: header
@@ -132,7 +131,7 @@ module SmartMessage
       # Extract payload properties (non-header properties)
       payload_props = self.class.properties.each_with_object({}) do |prop, hash|
         next if prop == :_sm_header
-        hash[prop.to_s] = self[prop]  # Use string keys to match old format
+        hash[prop.to_s] = self[prop]  # Access property value
       end
       
       JSON.generate(payload_props)
@@ -154,31 +153,39 @@ module SmartMessage
 
 
 
+    # Convert message to hash for serialization
+    def to_hash
+      # Get all properties and their values
+      hash = {}
+      self.class.properties.each do |prop|
+        hash[prop] = self[prop]
+      end
+      hash
+    end
+
     ###########################################################
     ## class methods
 
     class << self
       # Decode a complete serialized message back to a message instance
+      # Note: This method is no longer used with transport-based serialization
+      # Transports handle decoding and create message instances directly
       # @param serialized_message [String] The serialized message content
       # @return [SmartMessage::Base] The decoded message instance
       def decode(serialized_message)
-        logger = SmartMessage::Logger.default
-
         begin
           (self.logger || SmartMessage::Logger.default).info { "[SmartMessage] Received: #{self.name} (#{serialized_message.bytesize} bytes)" }
 
-          # Use the class's configured serializer to decode the message
-          serializer = self.serializer || SmartMessage::Serializer.default
-          
-          # Deserialize the complete message
-          deserialized_data = serializer.decode(serialized_message)
+          # This method is deprecated - transports now handle serialization
+          # For backward compatibility, try to decode as JSON
+          require 'json'
+          deserialized_data = JSON.parse(serialized_message)
 
           # Create new message instance with the complete deserialized data
           if deserialized_data.is_a?(Hash)
             # Convert string keys to symbols for compatibility with keyword arguments
             symbol_props = deserialized_data.transform_keys(&:to_sym)
             
-            # With single-tier serialization, use the complete deserialized message structure
             message = self.new(**symbol_props)
 
             (self.logger || SmartMessage::Logger.default).debug { "[SmartMessage] Deserialized message: #{self.name}" }

data/lib/smart_message/configuration.rb

@@ -53,7 +53,6 @@ module SmartMessage
   #   SmartMessage.configure do |config|
   #     config.logger = MyApp::Logger.new             # Custom logger object
   #     config.transport = MyApp::Transport.new
-  #     config.serializer = MyApp::Serializer.new
   #   end
   #
   #   # Explicitly disable logging:
@@ -71,17 +70,16 @@ module SmartMessage
   #   class SpecialMessage < SmartMessage::Base
   #     config do
   #       logger MyApp::SpecialLogger.new  # Override just the logger
-  #       # transport and serializer still use global defaults
+  #       # transport still uses global defaults
   #     end
   #   end
   class Configuration
-    attr_accessor :transport, :serializer, :log_level, :log_format, :log_include_source, :log_structured_data, :log_colorize, :log_options
+    attr_accessor :transport, :log_level, :log_format, :log_include_source, :log_structured_data, :log_colorize, :log_options
     attr_reader :logger
     
     def initialize
       @logger = nil
       @transport = nil
-      @serializer = nil
       @logger_explicitly_set_to_nil = false
       @log_level = nil
       @log_format = nil
@@ -101,7 +99,6 @@ module SmartMessage
     def reset!
       @logger = nil
       @transport = nil
-      @serializer = nil
       @logger_explicitly_set_to_nil = false
       @log_level = nil
       @log_format = nil
@@ -121,11 +118,6 @@ module SmartMessage
       !@transport.nil?
     end
     
-    # Check if serializer is configured
-    def serializer_configured?
-      !@serializer.nil?
-    end
-    
     # Get the configured logger or no logging
     def default_logger
       case @logger
@@ -156,11 +148,6 @@ module SmartMessage
       @transport || framework_default_transport
     end
     
-    # Get the configured serializer or framework default
-    def default_serializer
-      @serializer || framework_default_serializer
-    end
-    
     private
     
     # Framework's built-in default logger (Lumberjack)
@@ -187,13 +174,5 @@ module SmartMessage
     def framework_default_transport
       SmartMessage::Transport::RedisTransport.new
     end
-    
-    # Framework's built-in default serializer (JSON)
-    def framework_default_serializer
-      SmartMessage::Serializer::Json.new
-    rescue => e
-      # Fallback if JSON serializer is not available
-      nil
-    end
   end
 end

data/lib/smart_message/dead_letter_queue.rb

@@ -48,7 +48,7 @@ module SmartMessage
     # @param error_info [Hash] Error details including :error, :retry_count, :transport, etc.
     def enqueue(message, error_info = {})
       message_header = message._sm_header
-      message_payload = message.encode
+      message_payload = JSON.generate(message.to_hash)
 
       entry = {
         timestamp: Time.now.iso8601,

data/lib/smart_message/logger.rb

@@ -9,15 +9,26 @@ require_relative 'logger/lumberjack'
 module SmartMessage
   module Logger
     class << self
-      # Global default logger instance
-      def default
-        @default ||= Lumberjack.new
+      # Global default logger instance - uses configuration if available
+      def default(options = {})
+        # Always check current configuration first (don't cache when config is available)
+        if defined?(SmartMessage.configuration) && SmartMessage.configuration.logger_configured?
+          SmartMessage.configuration.default_logger
+        else
+          # Cache the framework default logger only when no configuration
+          @default ||= Lumberjack.new(**options)
+        end
       end
 
       # Set the default logger
       def default=(logger)
         @default = logger
       end
+      
+      # Reset the cached default logger
+      def reset!
+        @default = nil
+      end
     end
   end
-end
+end

data/lib/smart_message/messaging.rb

@@ -4,34 +4,8 @@
 
 module SmartMessage
   # Messaging module for SmartMessage::Base
-  # Handles message encoding and publishing operations
+  # Handles message publishing operations
   module Messaging
-    # SMELL: How does the transport know how to decode a message before
-    #        it knows the message class?  We need a wrapper around
-    #        the entire message in a known serialization.  That
-    #        wrapper would contain two properties: _sm_header and
-    #        _sm_payload
-
-    # NOTE: to publish a message it must first be encoded using a
-    #       serializer.  The receive a subscribed to message it must
-    #       be decoded via a serializer from the transport to be processed.
-    def encode
-      raise Errors::SerializerNotConfigured if serializer_missing?
-
-      serializer.encode(self)
-    end
-
-    # Convert message to hash with _sm_header and _sm_payload structure
-    # This is the foundation for wrapper architecture
-    def to_h
-      # Update header with serializer info before converting
-      _sm_header.serializer = serializer.class.to_s if serializer_configured?
-      
-      {
-        :_sm_header => header_hash_with_symbols,
-        :_sm_payload => payload_hash_with_symbols
-      }
-    end
 
 
     # NOTE: you publish instances; but, you subscribe/unsubscribe at
@@ -44,16 +18,12 @@ module SmartMessage
         # Update header with current publication info
         _sm_header.published_at   = Time.now
         _sm_header.publisher_pid  = Process.pid
-        _sm_header.serializer     = serializer.class.to_s if serializer_configured?
-
-        # Single-tier serialization: serialize entire message with designated serializer
-        serialized_message = encode
         
         raise Errors::TransportNotConfigured if transport_missing?
         
-        # Transport receives the message class name (for channel routing) and serialized message
+        # Transport now handles serialization - just pass the message instance
         (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] About to call transport.publish" }
-        transport.publish(_sm_header.message_class, serialized_message)
+        transport.publish(self)
         (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] transport.publish completed" }
         
         # Log the message publish
@@ -67,34 +37,5 @@ module SmartMessage
       end
     end # def publish
 
-    private
-
-    # Convert header to hash with symbol keys
-    def header_hash_with_symbols
-      _sm_header.to_hash.transform_keys(&:to_sym)
-    end
-    
-    # Extract all non-header properties into a hash with symbol keys
-    # Performs deep symbolization on nested structures
-    def payload_hash_with_symbols
-      self.class.properties.each_with_object({}) do |prop, hash|
-        next if prop == :_sm_header
-        hash[prop.to_sym] = deep_symbolize_keys(self[prop])
-      end
-    end
-
-    # Recursively convert all string keys to symbols in nested hashes and arrays
-    def deep_symbolize_keys(obj)
-      case obj
-      when Hash
-        obj.each_with_object({}) do |(key, value), result|
-          result[key.to_sym] = deep_symbolize_keys(value)
-        end
-      when Array
-        obj.map { |item| deep_symbolize_keys(item) }
-      else
-        obj
-      end
-    end
   end
 end

data/lib/smart_message/plugins.rb

@@ -4,7 +4,7 @@
 
 module SmartMessage
   # Plugin configuration module for SmartMessage::Base
-  # Handles transport, serializer, and logger configuration at both
+  # Handles transport and logger configuration at both
   # class and instance levels
   module Plugins
     def self.included(base)
@@ -12,7 +12,6 @@ module SmartMessage
       base.class_eval do
         # Class-level plugin storage
         class_variable_set(:@@transport, nil) unless class_variable_defined?(:@@transport)
-        class_variable_set(:@@serializer, nil) unless class_variable_defined?(:@@serializer)
         class_variable_set(:@@logger, nil) unless class_variable_defined?(:@@logger)
       end
     end
@@ -45,27 +44,6 @@ module SmartMessage
     end
     def reset_transport;        @transport = nil;  end
 
-
-    #########################################################
-    ## instance-level serializer configuration
-
-    def serializer(klass_or_instance = nil)
-      if klass_or_instance.nil?
-        # Return instance serializer, class serializer, or global configuration
-        @serializer || self.class.class_variable_get(:@@serializer) || SmartMessage::Serializer.default
-      else
-        @serializer = klass_or_instance
-      end
-    end
-
-    def serializer_configured?; !serializer_missing?;   end
-    def serializer_missing?
-      # Check if serializer is explicitly configured (without fallback to defaults)
-      @serializer.nil? && 
-        (self.class.class_variable_get(:@@serializer) rescue nil).nil?
-    end
-    def reset_serializer;       @serializer = nil;  end
-
     module ClassMethods
       #########################################################
       ## class-level configuration
@@ -105,28 +83,12 @@ module SmartMessage
         end
       end
 
-      def logger_configured?;     !logger.nil?;   end
-      def logger_missing?;         logger.nil?;   end
-      def reset_logger;          class_variable_set(:@@logger, nil);  end
-
-      #########################################################
-      ## class-level serializer configuration
-
-      def serializer(klass_or_instance = nil)
-        if klass_or_instance.nil?
-          # Return class-level serializer or fall back to global configuration
-          class_variable_get(:@@serializer) || SmartMessage::Serializer.default
-        else
-          class_variable_set(:@@serializer, klass_or_instance)
-        end
+      def logger_configured?;     !logger_missing?;   end
+      def logger_missing?
+        # Check if class-level logger is explicitly configured (without fallback to defaults)
+        (class_variable_get(:@@logger) rescue nil).nil?
       end
-
-      def serializer_configured?; !serializer_missing?;   end
-      def serializer_missing?
-        # Check if class-level serializer is explicitly configured (without fallback to defaults)
-        (class_variable_get(:@@serializer) rescue nil).nil?
-      end
-      def reset_serializer;      class_variable_set(:@@serializer, nil);  end
+      def reset_logger;          class_variable_set(:@@logger, nil);  end
     end
   end
 end

data/lib/smart_message/serializer.rb

@@ -0,0 +1,14 @@
+# lib/smart_message/serializer.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module Serializer
+    class << self
+      def default
+        # Check global configuration first, then fall back to framework default
+        SmartMessage.configuration.default_serializer
+      end
+    end
+  end
+end

data/lib/smart_message/transport/base.rb

@@ -11,15 +11,17 @@ module SmartMessage
     class Base
       include BreakerMachines::DSL
 
-      attr_reader :options, :dispatcher
+      attr_reader :options, :dispatcher, :serializer
 
       def initialize(**options)
         @options = default_options.merge(options)
         @dispatcher = options[:dispatcher] || SmartMessage::Dispatcher.new
+        @serializer = options[:serializer] || default_serializer
         configure
         configure_transport_circuit_breakers
         
         logger.debug { "[SmartMessage::Transport::#{self.class.name.split('::').last}] Initialized with options: #{@options}" }
+        logger.debug { "[SmartMessage::Transport::#{self.class.name.split('::').last}] Using serializer: #{@serializer.class.name}" }
       rescue => e
         logger&.error { "[SmartMessage] Error in transport initialization: #{e.class.name} - #{e.message}" }
         raise
@@ -43,10 +45,20 @@ module SmartMessage
         {}
       end
 
+      # Default serializer for this transport (override in subclasses)
+      def default_serializer
+        SmartMessage::Serializer::Json.new
+      end
+
       # Publish a message with circuit breaker protection
-      # @param message_class [String] The message class name (used for channel routing)
-      # @param serialized_message [String] Complete serialized message content
-      def publish(message_class, serialized_message)
+      # @param message [SmartMessage::Base] The message instance to publish
+      def publish(message)
+        # Extract routing info from message header
+        message_class = message._sm_header.message_class
+        
+        # Serialize the entire message (flat structure with _sm_header)
+        serialized_message = encode_message(message)
+        
         circuit(:transport_publish).wrap do
           do_publish(message_class, serialized_message)
         end
@@ -58,7 +70,7 @@ module SmartMessage
         raise unless e.is_a?(Hash) && e[:circuit_breaker]
 
         # Handle circuit breaker fallback
-        handle_publish_fallback(e, message_class, serialized_message)
+        handle_publish_fallback(e, message._sm_header.message_class, serialized_message)
       end
 
       # Template method for actual publishing (implement in subclasses)
@@ -150,13 +162,32 @@ module SmartMessage
         end
       end
 
+      # Encode a message using the transport's serializer
+      # @param message [SmartMessage::Base] The message to encode
+      # @return [String] The serialized message
+      def encode_message(message)
+        # Update header with serializer info
+        message._sm_header.serializer = @serializer.class.to_s
+        
+        # Serialize the entire message as a flat structure
+        @serializer.encode(message.to_hash)
+      end
+
+      # Decode a message using the transport's serializer
+      # @param serialized_message [String] The serialized message
+      # @return [Hash] The decoded message data
+      def decode_message(serialized_message)
+        @serializer.decode(serialized_message)
+      end
+
       # Receive and route a message (called by transport implementations)
       # @param message_class [String] The message class name
       # @param serialized_message [String] The serialized message content
       protected
 
       def receive(message_class, serialized_message)
-        # Decode the message using the class's configured serializer
+        # Decode the message using transport's serializer
+        decoded_data = decode_message(serialized_message)
         
         # Add defensive check for message_class type
         unless message_class.respond_to?(:constantize)
@@ -165,10 +196,13 @@ module SmartMessage
           raise ArgumentError, "message_class must be a String, got #{message_class.class.name}"
         end
         
+        # Reconstruct the message instance from flat structure
         message_class_obj = message_class.constantize
-        decoded_message = message_class_obj.decode(serialized_message)
+        # Convert string keys to symbols for keyword arguments
+        symbol_data = decoded_data.transform_keys(&:to_sym)
+        message = message_class_obj.new(**symbol_data)
         
-        @dispatcher.route(decoded_message)
+        @dispatcher.route(message)
       rescue => e
         logger.error { "[SmartMessage] Error in transport receive: #{e.class.name} - #{e.message}" }
         logger.error { "[SmartMessage] message_class: #{message_class.inspect} (#{message_class.class.name})" }

data/lib/smart_message/transport/memory_transport.rb

@@ -16,30 +16,49 @@ module SmartMessage
         }
       end
 
+      # Memory transport doesn't need serialization
+      def default_serializer
+        nil
+      end
+
       def configure
         @messages = []
         @message_mutex = Mutex.new
       end
 
-      # Publish message to memory queue
+      # Implement do_publish for memory transport (no serialization needed)
       def do_publish(message_class, serialized_message)
+        # For memory transport, serialized_message is actually the message object
+        message = serialized_message
+        
         @message_mutex.synchronize do
           # Prevent memory overflow
           @messages.shift if @messages.size >= @options[:max_messages]
           
+          # Store the actual message object, no serialization needed
           @messages << {
             message_class: message_class,
-            serialized_message: serialized_message,
+            message: message.dup,  # Store a copy to prevent mutation
             published_at: Time.now
           }
         end
 
         # Auto-process if enabled
         if @options[:auto_process]
-          receive(message_class, serialized_message)
+          # Route directly without serialization
+          @dispatcher.route(message)
         end
       end
 
+      # Override encode_message to return the message object directly
+      def encode_message(message)
+        # Update header with serializer info (even though we don't serialize)
+        message._sm_header.serializer = 'none'
+        
+        # Return the message object itself (no encoding needed)
+        message
+      end
+
       # Get all stored messages
       def all_messages
         @message_mutex.synchronize { @messages.dup }
@@ -59,7 +78,7 @@ module SmartMessage
       def process_all
         messages_to_process = @message_mutex.synchronize { @messages.dup }
         messages_to_process.each do |msg|
-          receive(msg[:message_class], msg[:serialized_message])
+          @dispatcher.route(msg[:message])
         end
       end
 

data/lib/smart_message/transport/redis_transport.rb

@@ -24,6 +24,17 @@ module SmartMessage
         }
       end
 
+      # Default to MessagePack for Redis (efficient binary format)
+      def default_serializer
+        # Try MessagePack first, fall back to JSON
+        begin
+          require 'smart_message/serializer/message_pack'
+          SmartMessage::Serializer::MessagePack.new
+        rescue LoadError
+          SmartMessage::Serializer::Json.new
+        end
+      end
+
       def configure
         @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
         @redis_sub = Redis.new(url: @options[:url], db: @options[:db])