smart_message 0.0.4 → 0.0.5

data/lib/smart_message/base.rb

@@ -6,6 +6,7 @@ require 'securerandom'   # STDLIB
 
 require_relative './wrapper.rb'
 require_relative './property_descriptions.rb'
+require_relative './property_validations.rb'
 
 module SmartMessage
   # The foundation class for the smart message
@@ -19,16 +20,38 @@ module SmartMessage
     
     # Registry for proc-based message handlers
     @@proc_handlers = {}
+    
+    # Class-level version setting
+    class << self
+      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
 
     include Hashie::Extensions::Dash::PropertyTranslation
 
     include SmartMessage::PropertyDescriptions
+    include SmartMessage::PropertyValidations
 
     include Hashie::Extensions::Coercion
     include Hashie::Extensions::DeepMerge
     include Hashie::Extensions::IgnoreUndeclared
     include Hashie::Extensions::IndifferentAccess
-    include Hashie::Extensions::MergeInitializer
+    # MergeInitializer interferes with required property validation - removed
     include Hashie::Extensions::MethodAccess
 
     # Common attrubutes for all messages
@@ -47,13 +70,28 @@ module SmartMessage
       @serializer  = nil
       @logger      = nil
 
+      # Create header with version validation specific to this message class
+      header = SmartMessage::Header.new(
+        uuid:           SecureRandom.uuid,
+        message_class:  self.class.to_s,
+        published_at:   Time.now,
+        publisher_pid:  Process.pid,
+        version:        self.class.version
+      )
+      
+      # Set up version validation to match the expected class version
+      expected_version = self.class.expected_header_version
+      header.singleton_class.class_eval do
+        define_method(:validate_version!) do
+          unless self.version == expected_version
+            raise SmartMessage::Errors::ValidationError, 
+              "Header version must be #{expected_version}, got: #{self.version}"
+          end
+        end
+      end
+      
       attributes = {
-        _sm_header: SmartMessage::Header.new(
-          uuid:           SecureRandom.uuid,
-          message_class:  self.class.to_s,
-          published_at:   2,
-          publisher_pid:  3
-        )
+        _sm_header: header
       }.merge(props)
 
       super(attributes, &block)
@@ -62,6 +100,57 @@ module SmartMessage
 
     ###################################################
     ## Common instance methods
+    
+    # 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
 
     # SMELL: How does the transport know how to decode a message before
     #        it knows the message class?  We need a wrapper around
@@ -82,6 +171,9 @@ module SmartMessage
     # NOTE: you publish instances; but, you subscribe/unsubscribe at
     #       the class-level
     def publish
+      # Validate the complete message before publishing (now uses overridden validate!)
+      validate!
+      
       # TODO: move all of the _sm_ property processes into the wrapper
       _sm_header.published_at   = Time.now
       _sm_header.publisher_pid  = Process.pid
@@ -150,6 +242,11 @@ module SmartMessage
       self.class.to_s
     end
 
+    # return this class' description
+    def description
+      self.class.description
+    end
+
 
     # returns a collection of class Set that consists of
     # the symbolized values of the property names of the message
@@ -173,7 +270,7 @@ module SmartMessage
       
       def description(desc = nil)
         if desc.nil?
-          @description
+          @description || "#{self.name} is a SmartMessage"
         else
           @description = desc.to_s
         end

data/lib/smart_message/errors.rb

@@ -25,5 +25,8 @@ module SmartMessage
     # A received message is of an unknown class
     class UnknownMessageClass < RuntimeError; end
 
+    # A property validation failed
+    class ValidationError < RuntimeError; end
+
   end
 end

data/lib/smart_message/header.rb

@@ -2,19 +2,46 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require_relative './property_descriptions'
+require_relative './property_validations'
+
 module SmartMessage
   # Every smart message has a common header format that contains
   # information used to support the dispatching of subscribed
   # messages upon receipt from a transport.
   class Header < Hashie::Dash
     include Hashie::Extensions::IndifferentAccess
-    include Hashie::Extensions::MergeInitializer
     include Hashie::Extensions::MethodAccess
+    include SmartMessage::PropertyDescriptions
+    include SmartMessage::PropertyValidations
 
     # Common attributes of the smart message standard header
-    property :uuid
-    property :message_class
-    property :published_at
-    property :publisher_pid
+    property :uuid, 
+      required: true,
+      message: "UUID is required for message tracking and deduplication",
+      description: "Unique identifier for this specific message instance, used for tracking and deduplication"
+    
+    property :message_class, 
+      required: true,
+      message: "Message class is required to identify the message type",
+      description: "Fully qualified class name of the message type (e.g. 'OrderMessage', 'PaymentNotification')"
+    
+    property :published_at, 
+      required: true,
+      message: "Published timestamp is required for message ordering",
+      description: "Timestamp when the message was published by the sender, used for ordering and debugging"
+    
+    property :publisher_pid, 
+      required: true,
+      message: "Publisher process ID is required for debugging and traceability",
+      description: "Process ID of the publishing application, useful for debugging and tracing message origins"
+    
+    property :version, 
+      required: true, 
+      default: 1,
+      message: "Message version is required for schema compatibility",
+      description: "Schema version of the message format, used for schema evolution and compatibility checking",
+      validate: ->(v) { v.is_a?(Integer) && v > 0 },
+      validation_message: "Header version must be a positive integer"
   end
 end

data/lib/smart_message/property_descriptions.rb

@@ -13,16 +13,17 @@ module SmartMessage
 
     module ClassMethods
       def property(property_name, options = {})
+        # Extract our custom option before passing to parent
         description = options.delete(:description)
         
-        # Store description if provided
+        # Call original property method first
+        super(property_name, options)
+        
+        # Then store description if provided
         if description
           @property_descriptions ||= {}
           @property_descriptions[property_name.to_sym] = description
         end
-        
-        # Call original property method
-        super(property_name, options)
       end
 
       def property_description(property_name)

data/lib/smart_message/property_validations.rb

@@ -0,0 +1,141 @@
+# lib/smart_message/property_validations.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module PropertyValidations
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        @property_validators = {}
+      end
+    end
+
+    module ClassMethods
+      def property(property_name, options = {})
+        # Extract our custom options before passing to Hashie::Dash
+        # Note: Hashie's 'message' option only works with 'required', so we use 'validation_message'
+        validator = options.delete(:validate)
+        validation_message = options.delete(:validation_message)
+
+        # Call original property method first
+        super(property_name, options)
+
+        # Then store validator if provided
+        if validator
+          @property_validators ||= {}
+          @property_validators[property_name.to_sym] = {
+            validator: validator,
+            message: validation_message || "Validation failed for property '#{property_name}'"
+          }
+
+          # Note: We don't override setter methods since they may conflict with Hashie::Dash
+          # Instead, validation happens during validate! calls
+        end
+      end
+
+      def property_validator(property_name)
+        @property_validators&.[](property_name.to_sym)
+      end
+
+      def property_validators
+        @property_validators&.dup || {}
+      end
+
+      def validated_properties
+        @property_validators&.keys || []
+      end
+
+      # Validate all properties with validators
+      def validate_all(instance)
+        validated_properties.each do |property_name|
+          validator_info = property_validator(property_name)
+          next unless validator_info
+
+          value = instance.send(property_name)
+          validator = validator_info[:validator]
+          error_message = validator_info[:message]
+
+          # Skip validation if value is nil and property is not required
+          next if value.nil? && !instance.class.required_properties.include?(property_name)
+
+          # Perform validation
+          is_valid = case validator
+                     when Proc
+                       instance.instance_exec(value, &validator)
+                     when Symbol
+                       instance.send(validator, value)
+                     when Regexp
+                       !!(value.to_s =~ validator)
+                     when Class
+                       value.is_a?(validator)
+                     when Array
+                       validator.include?(value)
+                     when Range
+                       validator.include?(value)
+                     else
+                       value == validator
+                     end
+
+          unless is_valid
+            raise SmartMessage::Errors::ValidationError, "#{instance.class.name}##{property_name}: #{error_message}"
+          end
+        end
+        true
+      end
+    end
+
+    # Instance methods
+    def validate!
+      self.class.validate_all(self)
+    end
+
+    def valid?
+      validate!
+      true
+    rescue SmartMessage::Errors::ValidationError
+      false
+    end
+
+    def validation_errors
+      errors = []
+      self.class.validated_properties.each do |property_name|
+        validator_info = self.class.property_validator(property_name)
+        next unless validator_info
+
+        value = send(property_name)
+        validator = validator_info[:validator]
+
+        # Skip validation if value is nil and property is not required
+        next if value.nil? && !self.class.required_properties.include?(property_name)
+
+        # Perform validation
+        is_valid = case validator
+                   when Proc
+                     instance_exec(value, &validator)
+                   when Symbol
+                     send(validator, value)
+                   when Regexp
+                     !!(value.to_s =~ validator)
+                   when Class
+                     value.is_a?(validator)
+                   when Array
+                     validator.include?(value)
+                   when Range
+                     validator.include?(value)
+                   else
+                     value == validator
+                   end
+
+        unless is_valid
+          errors << {
+            property: property_name,
+            value: value,
+            message: validator_info[:message]
+          }
+        end
+      end
+      errors
+    end
+  end
+end

data/lib/smart_message/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -218,6 +218,7 @@ files:
 - examples/04_redis_smart_home_iot.rb
 - examples/05_proc_handlers.rb
 - examples/06_custom_logger_example.rb
+- examples/07_error_handling_scenarios.rb
 - examples/README.md
 - examples/smart_home_iot_dataflow.md
 - examples/tmux_chat/README.md
@@ -238,6 +239,7 @@ files:
 - lib/smart_message/logger/base.rb
 - lib/smart_message/logger/default.rb
 - lib/smart_message/property_descriptions.rb
+- lib/smart_message/property_validations.rb
 - lib/smart_message/serializer.rb
 - lib/smart_message/serializer/base.rb
 - lib/smart_message/serializer/json.rb