smart_message 0.0.1 → 0.0.3

data/lib/smart_message/base.rb

@@ -5,6 +5,7 @@
 require 'securerandom'   # STDLIB
 
 require_relative './wrapper.rb'
+require_relative './property_descriptions.rb'
 
 module SmartMessage
   # The foundation class for the smart message
@@ -15,9 +16,14 @@ module SmartMessage
     @@transport   = nil
     @@serializer  = nil
     @@logger      = nil
+    
+    # Registry for proc-based message handlers
+    @@proc_handlers = {}
 
     include Hashie::Extensions::Dash::PropertyTranslation
 
+    include SmartMessage::PropertyDescriptions
+
     include Hashie::Extensions::Coercion
     include Hashie::Extensions::DeepMerge
     include Hashie::Extensions::IgnoreUndeclared
@@ -162,6 +168,17 @@ module SmartMessage
 
     class << self
 
+      #########################################################
+      ## class-level description
+      
+      def description(desc = nil)
+        if desc.nil?
+          @description
+        else
+          @description = desc.to_s
+        end
+      end
+
       #########################################################
       ## class-level configuration
 
@@ -170,6 +187,44 @@ module SmartMessage
       end
 
 
+      #########################################################
+      ## proc handler management
+
+      # Register a proc handler and return a unique identifier for it
+      # @param message_class [String] The message class name
+      # @param handler_proc [Proc] The proc to register
+      # @return [String] Unique identifier for this handler
+      def register_proc_handler(message_class, handler_proc)
+        handler_id = "#{message_class}.proc_#{SecureRandom.hex(8)}"
+        @@proc_handlers[handler_id] = handler_proc
+        handler_id
+      end
+
+      # Call a registered proc handler
+      # @param handler_id [String] The handler identifier
+      # @param message_header [SmartMessage::Header] The message header
+      # @param message_payload [String] The message payload
+      def call_proc_handler(handler_id, message_header, message_payload)
+        handler_proc = @@proc_handlers[handler_id]
+        return unless handler_proc
+
+        handler_proc.call(message_header, message_payload)
+      end
+
+      # Remove a proc handler from the registry
+      # @param handler_id [String] The handler identifier to remove
+      def unregister_proc_handler(handler_id)
+        @@proc_handlers.delete(handler_id)
+      end
+
+      # Check if a handler ID refers to a proc handler
+      # @param handler_id [String] The handler identifier
+      # @return [Boolean] True if this is a proc handler
+      def proc_handler?(handler_id)
+        @@proc_handlers.key?(handler_id)
+      end
+
+
       #########################################################
       ## class-level transport configuration
 
@@ -212,25 +267,74 @@ module SmartMessage
       # Add this message class to the transport's catalog of
       # subscribed messages.  If the transport is missing, raise
       # an exception.
-      def subscribe(process_method = nil)
-        message_class   = whoami
-        process_method  = message_class + '.process' if process_method.nil?
+      #
+      # @param process_method [String, Proc, nil] The processing method:
+      #   - String: Method name like "MyService.handle_message" 
+      #   - Proc: A proc/lambda that accepts (message_header, message_payload)
+      #   - nil: Uses default "MessageClass.process" method
+      # @param block [Proc] Alternative way to pass a processing block
+      # @return [String] The identifier used for this subscription
+      #
+      # @example Using default handler
+      #   MyMessage.subscribe
+      #
+      # @example Using custom method name
+      #   MyMessage.subscribe("MyService.handle_message")
+      #
+      # @example Using a block
+      #   MyMessage.subscribe do |header, payload|
+      #     data = JSON.parse(payload)
+      #     puts "Received: #{data}"
+      #   end
+      #
+      # @example Using a proc
+      #   handler = proc { |header, payload| puts "Processing..." }
+      #   MyMessage.subscribe(handler)
+      def subscribe(process_method = nil, &block)
+        message_class = whoami
+        
+        # Handle different parameter types
+        if block_given?
+          # Block was passed - use it as the handler
+          handler_proc = block
+          process_method = register_proc_handler(message_class, handler_proc)
+        elsif process_method.respond_to?(:call)
+          # Proc/lambda was passed as first parameter
+          handler_proc = process_method
+          process_method = register_proc_handler(message_class, handler_proc)
+        elsif process_method.nil?
+          # Use default handler
+          process_method = message_class + '.process'
+        end
+        # If process_method is a String, use it as-is
 
         # TODO: Add proper logging here
 
         raise Errors::TransportNotConfigured if transport_missing?
         transport.subscribe(message_class, process_method)
+        
+        process_method
       end
 
 
       # Remove this process_method for this message class from the
       # subscribers list.
+      # @param process_method [String, nil] The processing method identifier to remove
+      #   - String: Method name like "MyService.handle_message" or proc handler ID
+      #   - nil: Uses default "MessageClass.process" method
       def unsubscribe(process_method = nil)
         message_class   = whoami
         process_method  = message_class + '.process' if process_method.nil?
         # TODO: Add proper logging here
 
-        transport.unsubscribe(message_class, process_method) if transport_configured?
+        if transport_configured?
+          transport.unsubscribe(message_class, process_method)
+          
+          # If this was a proc handler, clean it up from the registry
+          if proc_handler?(process_method)
+            unregister_proc_handler(process_method)
+          end
+        end
       end
 
 

data/lib/smart_message/dispatcher.rb

@@ -118,13 +118,20 @@ module SmartMessage
       @subscribers[message_klass].each do |message_processor|
         SS.add(message_klass, message_processor, 'routed' )
         @router_pool.post do
-          parts         = message_processor.split('.')
-          target_klass  = parts[0]
-          class_method  = parts[1]
           begin
-            target_klass.constantize
-                        .method(class_method)
-                        .call(message_header, message_payload)
+            # Check if this is a proc handler or a regular method call
+            if proc_handler?(message_processor)
+              # Call the proc handler via SmartMessage::Base
+              SmartMessage::Base.call_proc_handler(message_processor, message_header, message_payload)
+            else
+              # Original method call logic
+              parts         = message_processor.split('.')
+              target_klass  = parts[0]
+              class_method  = parts[1]
+              target_klass.constantize
+                          .method(class_method)
+                          .call(message_header, message_payload)
+            end
           rescue Exception => e
             # TODO: Add proper exception logging
             # Exception details: #{e.message}
@@ -135,6 +142,15 @@ module SmartMessage
       end
     end
 
+    private
+
+    # Check if a message processor is a proc handler
+    # @param message_processor [String] The message processor identifier
+    # @return [Boolean] True if this is a proc handler
+    def proc_handler?(message_processor)
+      SmartMessage::Base.proc_handler?(message_processor)
+    end
+
 
     #######################################################
     ## Class methods

data/lib/smart_message/property_descriptions.rb

@@ -0,0 +1,41 @@
+# lib/smart_message/property_descriptions.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module PropertyDescriptions
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        @property_descriptions = {}
+      end
+    end
+
+    module ClassMethods
+      def property(property_name, options = {})
+        description = options.delete(:description)
+        
+        # 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)
+        @property_descriptions&.[](property_name.to_sym)
+      end
+
+      def property_descriptions
+        @property_descriptions&.dup || {}
+      end
+
+      def described_properties
+        @property_descriptions&.keys || []
+      end
+    end
+  end
+end

data/lib/smart_message/transport/redis_transport.rb

@@ -0,0 +1,190 @@
+# lib/smart_message/transport/redis_transport.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'redis'
+require 'securerandom'
+require 'set'
+
+module SmartMessage
+  module Transport
+    # Redis pub/sub transport for SmartMessage
+    # Uses message class name as the Redis channel name
+    class RedisTransport < Base
+      attr_reader :redis_pub, :redis_sub, :subscriber_thread
+
+      def default_options
+        {
+          url: 'redis://localhost:6379',
+          db: 0,
+          auto_subscribe: true,
+          reconnect_attempts: 5,
+          reconnect_delay: 1
+        }
+      end
+
+      def configure
+        @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
+        @redis_sub = Redis.new(url: @options[:url], db: @options[:db])
+        @subscribed_channels = Set.new
+        @subscriber_thread = nil
+        @running = false
+        @mutex = Mutex.new
+        
+        start_subscriber if @options[:auto_subscribe]
+      end
+
+      # Publish message to Redis channel using message class name
+      def publish(message_header, message_payload)
+        channel = message_header.message_class
+        
+        begin
+          @redis_pub.publish(channel, message_payload)
+        rescue Redis::ConnectionError
+          retry_with_reconnect('publish') { @redis_pub.publish(channel, message_payload) }
+        end
+      end
+
+      # Subscribe to a message class (Redis channel)
+      def subscribe(message_class, process_method)
+        super(message_class, process_method)
+        
+        @mutex.synchronize do
+          @subscribed_channels.add(message_class)
+          restart_subscriber if @running
+        end
+      end
+
+      # Unsubscribe from a specific message class and process method
+      def unsubscribe(message_class, process_method)
+        super(message_class, process_method)
+        
+        @mutex.synchronize do
+          # If no more subscribers for this message class, unsubscribe from channel
+          if @dispatcher.subscribers[message_class].nil? || @dispatcher.subscribers[message_class].empty?
+            @subscribed_channels.delete(message_class)
+            restart_subscriber if @running
+          end
+        end
+      end
+
+      # Unsubscribe from all process methods for a message class
+      def unsubscribe!(message_class)
+        super(message_class)
+        
+        @mutex.synchronize do
+          @subscribed_channels.delete(message_class)
+          restart_subscriber if @running
+        end
+      end
+
+      def connected?
+        begin
+          @redis_pub.ping == 'PONG' && @redis_sub.ping == 'PONG'
+        rescue Redis::ConnectionError
+          false
+        end
+      end
+
+      def connect
+        @redis_pub.ping
+        @redis_sub.ping
+        start_subscriber unless @running
+      end
+
+      def disconnect
+        stop_subscriber
+        @redis_pub.quit if @redis_pub
+        @redis_sub.quit if @redis_sub
+      end
+
+      private
+
+      def start_subscriber
+        return if @running
+        
+        @running = true
+        @subscriber_thread = Thread.new do
+          begin
+            subscribe_to_channels
+          rescue => e
+            # Log error but don't crash the thread
+            puts "Redis subscriber error: #{e.message}" if @options[:debug]
+            retry_subscriber
+          end
+        end
+      end
+
+      def stop_subscriber
+        @running = false
+        
+        if @subscriber_thread
+          @subscriber_thread.kill
+          @subscriber_thread.join(5) # Wait up to 5 seconds
+          @subscriber_thread = nil
+        end
+      end
+
+      def restart_subscriber
+        stop_subscriber
+        start_subscriber if @subscribed_channels.any?
+      end
+
+      def subscribe_to_channels
+        return unless @subscribed_channels.any?
+        
+        begin
+          @redis_sub.subscribe(*@subscribed_channels) do |on|
+            on.message do |channel, message_payload|
+              # Create a header with the channel as message_class
+              message_header = SmartMessage::Header.new(
+                message_class: channel,
+                uuid: SecureRandom.uuid,
+                published_at: Time.now,
+                publisher_pid: 'redis_subscriber'
+              )
+              
+              receive(message_header, message_payload)
+            end
+            
+            on.subscribe do |channel, subscriptions|
+              puts "Subscribed to Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+            end
+            
+            on.unsubscribe do |channel, subscriptions|
+              puts "Unsubscribed from Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+            end
+          end
+        rescue => e
+          # Silently handle connection errors during subscription
+          puts "Redis subscription error: #{e.class.name}" if @options[:debug]
+          retry_subscriber if @running
+        end
+      end
+
+      def retry_subscriber
+        return unless @running
+        
+        sleep(@options[:reconnect_delay])
+        subscribe_to_channels if @running
+      end
+
+      def retry_with_reconnect(operation)
+        attempts = 0
+        begin
+          yield
+        rescue Redis::ConnectionError => e
+          attempts += 1
+          if attempts <= @options[:reconnect_attempts]
+            sleep(@options[:reconnect_delay])
+            # Reconnect
+            @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
+            retry
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/transport/registry.rb

@@ -53,6 +53,7 @@ module SmartMessage
         # Register built-in transports
         register(:stdout, SmartMessage::Transport::StdoutTransport)
         register(:memory, SmartMessage::Transport::MemoryTransport)
+        register(:redis, SmartMessage::Transport::RedisTransport)
       end
     end
   end

data/lib/smart_message/transport.rb

@@ -6,6 +6,7 @@ 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

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/smart_message.gemspec

@@ -39,6 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'hashie'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'redis'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -190,13 +204,19 @@ files:
 - docs/examples.md
 - docs/getting-started.md
 - docs/ideas_to_think_about.md
+- docs/message_processing.md
+- docs/proc_handlers_summary.md
+- docs/properties.md
 - docs/serializers.md
 - docs/transports.md
 - docs/troubleshooting.md
 - examples/01_point_to_point_orders.rb
 - examples/02_publish_subscribe_events.rb
 - examples/03_many_to_many_chat.rb
+- examples/04_redis_smart_home_iot.rb
+- examples/05_proc_handlers.rb
 - examples/README.md
+- examples/smart_home_iot_dataflow.md
 - examples/tmux_chat/README.md
 - examples/tmux_chat/bot_agent.rb
 - examples/tmux_chat/human_agent.rb
@@ -213,12 +233,14 @@ files:
 - lib/smart_message/header.rb
 - lib/smart_message/logger.rb
 - lib/smart_message/logger/base.rb
+- lib/smart_message/property_descriptions.rb
 - lib/smart_message/serializer.rb
 - lib/smart_message/serializer/base.rb
 - lib/smart_message/serializer/json.rb
 - lib/smart_message/transport.rb
 - lib/smart_message/transport/base.rb
 - lib/smart_message/transport/memory_transport.rb
+- lib/smart_message/transport/redis_transport.rb
 - lib/smart_message/transport/registry.rb
 - lib/smart_message/transport/stdout_transport.rb
 - lib/smart_message/version.rb