smart_message 0.0.7 → 0.0.9

data/lib/smart_message/transport/stdout_transport.rb

@@ -27,13 +27,22 @@ module SmartMessage
         @options[:loopback]
       end
 
-      # Publish message to STDOUT
-      def do_publish(message_header, message_payload)
-        @output.puts format_message(message_header, message_payload)
+      # Publish message to STDOUT (single-tier serialization)
+      def do_publish(message_class, serialized_message)
+        logger.debug { "[SmartMessage::StdoutTransport] do_publish called" }
+        logger.debug { "[SmartMessage::StdoutTransport] message_class: #{message_class}" }
+        
+        @output.puts format_message(message_class, serialized_message)
         @output.flush
 
         # If loopback is enabled, route the message back through the dispatcher
-        receive(message_header, message_payload) if loopback?
+        if loopback?
+          logger.debug { "[SmartMessage::StdoutTransport] Loopback enabled, calling receive" }
+          receive(message_class, serialized_message)
+        end
+      rescue => e
+        logger.error { "[SmartMessage] Error in stdout transport do_publish: #{e.class.name} - #{e.message}" }
+        raise
       end
 
       def connected?
@@ -46,17 +55,18 @@ module SmartMessage
 
       private
 
-      def format_message(message_header, message_payload)
+      def format_message(message_class, serialized_message)
         <<~MESSAGE
 
           ===================================================
           == SmartMessage Published via STDOUT Transport
-          == Header: #{message_header.inspect}
-          == Payload: #{message_payload}
+          == Single-Tier Serialization:
+          == Message Class: #{message_class}
+          == Serialized Message: #{serialized_message}
           ===================================================
 
         MESSAGE
       end
     end
   end
-end
+end

data/lib/smart_message/transport.rb

@@ -6,37 +6,4 @@ require_relative 'transport/base'
 require_relative 'transport/registry'
 require_relative 'transport/stdout_transport'
 require_relative 'transport/memory_transport'
-require_relative 'transport/redis_transport'
-
-module SmartMessage
-  # Transport layer abstraction for SmartMessage
-  module Transport
-    class << self
-      # Get the transport registry instance
-      def registry
-        @registry ||= Registry.new
-      end
-
-      # Register a transport adapter
-      def register(name, transport_class)
-        registry.register(name, transport_class)
-      end
-
-      # Get a transport by name
-      def get(name)
-        registry.get(name)
-      end
-
-      # Create a transport instance with options
-      def create(name, **options)
-        transport_class = get(name)
-        transport_class&.new(**options)
-      end
-
-      # List all registered transports
-      def available
-        registry.list
-      end
-    end
-  end
-end
+require_relative 'transport/redis_transport'

data/lib/smart_message/utilities.rb

@@ -0,0 +1,142 @@
+# lib/smart_message/utilities.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'set'   # STDLIB
+
+module SmartMessage
+  # Utilities module for SmartMessage::Base
+  # Provides utility methods for message introspection and debugging
+  module Utilities
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #########################################################
+    ## instance-level utility methods
+
+    # return this class' name as a string
+    def whoami
+      self.class.to_s
+    end
+
+    # return this class' description
+    def description
+      self.class.description
+    end
+
+    # Clean accessor to the SmartMessage header object
+    # Provides more intuitive API than _sm_header
+    # Note: Renamed to avoid conflict with class-level header DSL
+    def message_header
+      _sm_header
+    end
+
+    # returns a collection of class Set that consists of
+    # the symbolized values of the property names of the message
+    # without the injected '_sm_' properties that support
+    # the behind-the-sceens operations of SmartMessage.
+    def fields
+      to_h.keys
+          .reject{|key| key.start_with?('_sm_')}
+          .map{|key| key.to_sym}
+          .to_set
+    end
+
+    # Pretty print the message content to STDOUT using amazing_print
+    # @param pp_or_include_header [PP, Boolean] Either a PP printer object (from Ruby's pp library) 
+    #                                           or include_header boolean (for our custom usage)
+    # @param include_header [Boolean] Whether to include the SmartMessage header (default: false)
+    def pretty_print(pp_or_include_header = nil, include_header: false)
+      # Handle Ruby's PP library calling convention: pretty_print(pp_object)
+      if pp_or_include_header.is_a?(Object) && pp_or_include_header.respond_to?(:text)
+        # This is Ruby's PP library calling us - delegate to standard object pretty printing
+        pp_or_include_header.text(self.inspect)
+        return
+      end
+      
+      # Handle our custom calling convention: pretty_print(include_header: true)
+      if pp_or_include_header.is_a?(TrueClass) || pp_or_include_header.is_a?(FalseClass)
+        include_header = pp_or_include_header
+      end
+      
+      require 'amazing_print'
+      
+      if include_header
+        # Show both header and content
+        puts "Header:"
+        puts "-" * 20
+        
+        # Get header data, converting to symbols and filtering out nils
+        header_data = _sm_header.to_h
+          .reject { |key, value| value.nil? }
+        header_data = deep_symbolize_keys(header_data)
+        ap header_data
+        
+        puts "\nContent:"
+        puts "-" * 20
+        
+        # Get payload data (message properties excluding header)
+        content_data = get_payload_data.reject { |key, value| value.nil? }
+        content_data = deep_symbolize_keys(content_data)
+        ap content_data
+      else
+        # Show only message content (excluding _sm_ properties and nil values)
+        content_data = get_payload_data.reject { |key, value| value.nil? }
+        content_data = deep_symbolize_keys(content_data)
+        ap content_data
+      end
+    end
+
+    private
+
+    # Extract payload data (all properties except _sm_header)
+    def get_payload_data
+      self.class.properties.each_with_object({}) do |prop, hash|
+        next if prop == :_sm_header
+        hash[prop.to_sym] = 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
+
+    module ClassMethods
+      #########################################################
+      ## class-level description
+      
+      def description(desc = nil)
+        if desc.nil?
+          @description || "#{self.name} is a SmartMessage"
+        else
+          @description = desc.to_s
+        end
+      end
+
+      #########################################################
+      ## class-level utility methods
+
+      # return this class' name as a string
+      def whoami
+        ancestors.first.to_s
+      end
+
+      # Return a Set of symbols representing each defined property of
+      # this message class.
+      def fields
+        @properties.dup.delete_if{|item| item.to_s.start_with?('_sm_')}
+      end
+    end
+  end
+end

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = '0.0.7'
+  VERSION = '0.0.9'
 end

data/lib/smart_message/versioning.rb

@@ -0,0 +1,85 @@
+# lib/smart_message/versioning.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  # Versioning module for SmartMessage::Base
+  # Handles schema versioning and version validation
+  module Versioning
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Validate that the header version matches the expected version for this class
+    def validate_header_version!
+      expected = self.class.expected_header_version
+      actual = _sm_header.version
+      unless actual == expected
+        raise SmartMessage::Errors::ValidationError,
+          "#{self.class.name} expects version #{expected}, but header has version #{actual}"
+      end
+    end
+
+    # Override PropertyValidations validate! to include header and version validation
+    def validate!
+      # Validate message properties using PropertyValidations
+      super
+      
+      # Validate header properties
+      _sm_header.validate!
+      
+      # Validate header version matches expected class version  
+      validate_header_version!
+    end
+
+    # Override PropertyValidations validation_errors to include header errors
+    def validation_errors
+      errors = []
+      
+      # Get message property validation errors using PropertyValidations
+      errors.concat(super.map { |err| 
+        err.merge(source: 'message') 
+      })
+      
+      # Get header validation errors
+      errors.concat(_sm_header.validation_errors.map { |err| 
+        err.merge(source: 'header') 
+      })
+      
+      # Check version mismatch
+      expected = self.class.expected_header_version
+      actual = _sm_header.version
+      unless actual == expected
+        errors << {
+          property: :version,
+          value: actual,
+          message: "Expected version #{expected}, got: #{actual}",
+          source: 'version_mismatch'
+        }
+      end
+      
+      errors
+    end
+
+    module ClassMethods
+      # Class-level version setting
+      attr_accessor :_version
+      
+      def version(v = nil)
+        if v.nil?
+          @_version || 1  # Default to version 1 if not set
+        else
+          @_version = v
+          
+          # Set up version validation for the header
+          # This ensures that the header version matches the expected class version
+          @expected_header_version = v
+        end
+      end
+      
+      def expected_header_version
+        @expected_header_version || 1
+      end
+    end
+  end
+end

data/lib/smart_message/wrapper.rb.bak

@@ -0,0 +1,132 @@
+# lib/smart_message/wrapper.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'securerandom'   # STDLIB
+require_relative './header.rb'
+
+module SmartMessage
+  module Wrapper
+    # Every smart message has a common wrapper format that contains
+    # information used to support the dispatching of subscribed
+    # messages upon receipt from a transport as well as the serialized
+    # payload.
+    #
+    # The wrapper consolidates header and payload into a single object
+    # for cleaner method signatures throughout the SmartMessage dataflow.
+    class Base < Hashie::Dash
+      include Hashie::Extensions::IndifferentAccess
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::DeepMerge
+
+      # Core wrapper properties
+      # Using '_sm_' prefix to avoid collision with user message definitions
+      property :_sm_header,
+        required: true,
+        description: "SmartMessage header containing routing and metadata information"
+      
+      property :_sm_payload,
+        required: true, 
+        description: "Serialized message payload containing the business data"
+
+      # Create wrapper from header and payload
+      def initialize(header: nil, payload: nil, **props, &block)
+        # Handle different initialization patterns
+        if header && payload
+          attributes = {
+            _sm_header: header,
+            _sm_payload: payload
+          }
+        else
+          # Create default header if not provided
+          default_header = SmartMessage::Header.new(
+            uuid:           SecureRandom.uuid,
+            message_class:  'SmartMessage::Wrapper::Base',
+            published_at:   Time.now,
+            publisher_pid:  Process.pid,
+            version:        1
+          )
+          
+          attributes = {
+            _sm_header: default_header,
+            _sm_payload: nil
+          }.merge(props)
+        end
+
+        super(attributes, &block)
+      end
+
+      # Convenience accessors for header and payload
+      def header
+        _sm_header
+      end
+
+      def payload
+        _sm_payload
+      end
+
+      # Check if this is a broadcast message (to field is nil)
+      def broadcast?
+        _sm_header.to.nil?
+      end
+
+      # Check if this is a directed message (to field is present) 
+      def directed?
+        !broadcast?
+      end
+
+      # Get message class from header
+      def message_class
+        _sm_header.message_class
+      end
+
+      # Get sender from header
+      def from
+        _sm_header.from
+      end
+
+      # Get recipient from header
+      def to
+        _sm_header.to
+      end
+
+      # Get reply destination from header
+      def reply_to
+        _sm_header.reply_to
+      end
+
+      # Get message version from header
+      def version
+        _sm_header.version
+      end
+
+      # Get UUID from header
+      def uuid
+        _sm_header.uuid
+      end
+
+      # Convert wrapper to hash for serialization/transport
+      def to_hash
+        {
+          '_sm_header' => _sm_header.to_hash,
+          '_sm_payload' => _sm_payload
+        }
+      end
+
+      alias_method :to_h, :to_hash
+
+      # Outer-level JSON serialization for the wrapper
+      # This is level 2 serialization - always JSON for routing/monitoring
+      def to_json(*args)
+        require 'json'
+        to_hash.to_json(*args)
+      end
+
+      # Split wrapper into header and payload components
+      # Enables destructuring assignment: header, payload = wrapper.split
+      def split
+        [_sm_header, _sm_payload]
+      end
+    end
+  end
+end

data/lib/smart_message.rb

@@ -2,6 +2,8 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require 'zeitwerk'
+
 # FIXME: handle this better
 class MilClass  # IMO nil is the same as an empty String
   def to_s
@@ -9,47 +11,92 @@ class MilClass  # IMO nil is the same as an empty String
   end
 end
 
-
 require 'active_support/core_ext/string/inflections'
 require 'date'  # STDLIB
-
-# Production logging should use the logger framework, not debug_me
-
 require 'hashie'         # Your friendly neighborhood hash library.
 
-require_relative './simple_stats'
-
-require_relative './smart_message/version'
-require_relative './smart_message/errors'
-require_relative './smart_message/circuit_breaker'
+# Set up Zeitwerk autoloader
+loader = Zeitwerk::Loader.for_gem
+loader.tag = "smart_message"
+loader.ignore("#{__dir__}/simple_stats.rb")
+loader.setup
 
-require_relative './smart_message/dispatcher.rb'
-require_relative './smart_message/transport.rb'
-require_relative './smart_message/base.rb'
+# Load simple_stats manually since it's not following the naming convention
+require_relative './simple_stats'
 
 # SmartMessage abstracts messages from the backend transport process
 module SmartMessage
-  # The super class of all smart messages
-  # class Base < Dash from the Hashie gem plus mixins
-  # end
-
-  # encapsulates the message transport plugin
-  # module Transport is defined in transport.rb
-
-  # encapsulates the message code/decode serializer
+  class << self
+    # Global configuration for SmartMessage
+    # 
+    # Usage:
+    #   SmartMessage.configure do |config|
+    #     config.logger = MyApp::Logger.new
+    #     config.transport = MyApp::Transport.new
+    #     config.serializer = MyApp::Serializer.new
+    #   end
+    def configure
+      yield(configuration)
+    end
+    
+    # Get the global configuration instance
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    
+    # Reset global configuration to defaults
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+  # Module definitions for Zeitwerk to populate
   module Serializer
-    # the super class of the message serializer
-    class Base
+    class << self
+      def default
+        # Check global configuration first, then fall back to framework default
+        SmartMessage.configuration.default_serializer
+      end
     end
   end
 
-  # encapsulates the message logging capability
   module Logger
-    # the super class of the message logger
-    class Base
+    class << self
+      def default
+        # Check global configuration first, then fall back to framework default
+        SmartMessage.configuration.default_logger
+      end
+    end
+  end
+  
+  module Transport
+    class << self
+      def default
+        # Check global configuration first, then fall back to framework default
+        SmartMessage.configuration.default_transport
+      end
+      
+      def registry
+        @registry ||= Registry.new
+      end
+
+      def register(name, transport_class)
+        registry.register(name, transport_class)
+      end
+
+      def get(name)
+        registry.get(name)
+      end
+
+      def create(name, **options)
+        transport_class = get(name)
+        transport_class&.new(**options)
+      end
+
+      def available
+        registry.list
+      end
     end
   end
 end # module SmartMessage
 
-require_relative './smart_message/serializer'
-require_relative './smart_message/logger'
+# Don't eager load initially - let Zeitwerk handle lazy loading

data/smart_message.gemspec

@@ -41,6 +41,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'concurrent-ruby'
   spec.add_dependency 'redis'
   spec.add_dependency 'breaker_machines'
+  spec.add_dependency 'zeitwerk'
+  spec.add_dependency 'lumberjack'
+  spec.add_dependency 'colorize'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'