telegem 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a100bc051a797130ecebdf67164f6d2566fda1241a3240226396412b1cd6d7
-  data.tar.gz: 6f41d93f14122381a14138be904987032abc577c8d0fde33e53d0632505d6363
+  metadata.gz: a800a5e96af8c42cd15dd4448e6b157beb99c6a1e5e29de786b9af0464903093
+  data.tar.gz: 25829f45ed0434bd0a8bd6f09a98296292d96037b21dea52323596f42cdec7a4
 SHA512:
-  metadata.gz: 11ee3ef944c5ddafeb77c91e9e069bca3631061f073525abf3b7a60f009b8b2c30cc8f12e73a828001b2bec062039b73de55af23896d621b77f7c2dac6e544ca
-  data.tar.gz: 9a378f859712a891550e5fd1647053a7a2dae80065d08f9c1b73f9fbdaf6ff7b006115165a403848866d6ba8da439a351166661200128ed7bfb23af83141f4a6
+  metadata.gz: 5cb72e7a6d9dc453808e617033f6e5d52229dc72299779834e4ecacf67d4cc25510f2ca97dbbbca199c0adb7e2ee1c5f18a4c77d576198a891f8b98bbfd75c94
+  data.tar.gz: a490e086730633ccf1e8ba3cc4d018033fbbe0ddc3b300104f9aff1a91d542766e7053a2c81cefcedc8b4555c0415368a7df42ef47c59ff9d5b284a0e413defc

data/lib/core/bot.rb

@@ -1,14 +1,19 @@
+# lib/core/bot.rb - Telegem v2.0.0 (Stable)
 require 'concurrent'
 require 'logger'
 
 module Telegem
   module Core
     class Bot
-      attr_reader :token, :api, :handlers, :middleware, :logger, :scenes, :running, :polling_thread
+      # Public accessors for bot state and components
+      attr_reader :token, :api, :handlers, :middleware, :logger, :scenes, 
+                  :running, :polling_thread, :session_store
       
       def initialize(token, **options)
         @token = token
         @api = API::Client.new(token, **options.slice(:logger, :timeout))
+        
+        # Initialize handler registries for different update types
         @handlers = {
           message: [],
           callback_query: [],
@@ -18,23 +23,81 @@ module Telegem
           pre_checkout_query: [],
           shipping_query: []
         }
+        
         @middleware = []
         @scenes = {}
         @logger = options[:logger] || Logger.new($stdout)
         @error_handler = nil
         @session_store = options[:session_store] || Session::MemoryStore.new
         
+        # Thread pool and worker management
         @thread_pool = Concurrent::FixedThreadPool.new(options[:max_threads] || 10)
         @update_queue = Queue.new
         @worker_threads = []
         
+        # Polling state
         @polling_thread = nil
         @running = false
-        @offset = nil
+        @offset = nil  # Last processed update ID
         
+        # Start worker threads for processing updates
         start_workers(options[:worker_count] || 5)
       end
       
+      # ========================
+      # POLLING LIFECYCLE METHODS
+      # ========================
+      
+      def start_polling(**options)
+        return if @running
+        
+        @running = true
+        @polling_options = {
+          timeout: 30,
+          limit: 100,
+          allowed_updates: nil
+        }.merge(options)
+        
+        @offset = nil  # Reset offset when starting
+        
+        @logger.info "🤖 Starting Telegem bot (polling mode)..."
+        
+        @polling_thread = Thread.new do
+          Thread.current.abort_on_exception = false
+          poll_loop
+        end
+        
+        self
+      end
+      
+      def shutdown
+        return unless @running
+        
+        @logger.info "🛑 Shutting down bot..."
+        @running = false
+        
+        # Gracefully stop polling thread
+        if @polling_thread&.alive?
+          @polling_thread.join(3)
+        end
+        
+        # Stop worker threads
+        stop_workers
+        
+        # Close API connections
+        @api.close if @api.respond_to?(:close)
+        
+        @logger.info "✅ Bot shutdown complete"
+      end
+      
+      def running?
+        @running
+      end
+      
+      # ========================
+      # COMMAND & EVENT HANDLERS
+      # ========================
+      
       def command(name, **options, &block)
         pattern = /^\/#{Regexp.escape(name)}(?:@\w+)?(?:\s+(.+))?$/i
         
@@ -69,25 +132,9 @@ module Telegem
         @scenes[id] = Scene.new(id, &block)
       end
       
-      def start_polling(**options)
-        return if @running
-        
-        @running = true
-        @polling_options = {
-          timeout: 30,
-          limit: 100,
-          allowed_updates: nil
-        }.merge(options)
-        
-        @offset = nil
-        
-        @polling_thread = Thread.new do
-          @logger.info "🤖 Starting Telegem bot (HTTPX async)..."
-          poll_loop
-        end
-        
-        self
-      end
+      # ========================
+      # WEBHOOK METHODS
+      # ========================
       
       def webhook(app = nil, port: nil, host: '0.0.0.0', logger: nil, &block)
         require_relative '../webhook/server'
@@ -113,124 +160,136 @@ module Telegem
         @api.call!('getWebhookInfo', {})
       end
       
+      # ========================
+      # UPDATE PROCESSING
+      # ========================
+      
       def process(update_data)
         update = Types::Update.new(update_data)
         process_update(update)
       end
       
-      def shutdown
-        @logger.info "🛑 Shutting down..."
-        
-        @running = false
-        
-        @polling_thread&.join(5) if @polling_thread&.alive?
+      # ========================
+      # PRIVATE METHODS
+      # ========================
+      
+      private
+      
+      # ----- POLLING LOGIC -----
+      
+      def poll_loop
+        @logger.debug "Entering polling loop"
         
-        stop_workers
+        while @running
+          begin
+            # Use synchronous call to avoid HTTPX version conflicts
+            result = fetch_updates
+            
+            if result && result.is_a?(Hash) && result['ok']
+              handle_updates_response(result)
+            elsif result
+              @logger.warn "Unexpected API response format"
+            end
+            
+            # Small delay between polls unless we just processed updates
+            sleep 0.1 unless @offset.nil?
+            
+          rescue => e
+            handle_error(e)
+            sleep 5  # Wait before retrying after error
+          end
+        end
         
-        @api.close
+        @logger.debug "Exiting polling loop"
+      end
+      
+      def fetch_updates
+        params = {
+          timeout: @polling_options[:timeout],
+          limit: @polling_options[:limit]
+        }
+        params[:offset] = @offset if @offset
+        params[:allowed_updates] = @polling_options[:allowed_updates] if @polling_options[:allowed_updates]
         
-        @logger.info "✅ Bot stopped"
+        # Use call! for synchronous operation (more reliable)
+        @api.call!('getUpdates', params)
       end
       
-      def running?
-        @running
+      def handle_updates_response(api_response)
+        updates = api_response['result'] || []
+        
+        if updates.any?
+          @logger.debug "Processing #{updates.length} update(s)"
+          
+          updates.each do |update_data|
+            # Queue for processing by worker threads
+            @update_queue << [update_data, nil]
+          end
+          
+          # Update offset for next request
+          @offset = updates.last['update_id'] + 1
+          @logger.debug "Updated offset to #{@offset}"
+        end
       end
       
-      private
+      # ----- WORKER THREAD MANAGEMENT -----
       
       def start_workers(count)
         count.times do |i|
           @worker_threads << Thread.new do
+            Thread.current.abort_on_exception = false
             worker_loop(i)
           end
         end
+        @logger.debug "Started #{count} worker threads"
       end
       
       def stop_workers
+        @logger.debug "Stopping worker threads"
+        
+        # Send shutdown signals to all workers
         @worker_threads.size.times { @update_queue << :shutdown }
+        
+        # Wait for threads to finish
         @worker_threads.each do |thread|
           thread.join(2) if thread.alive?
         end
+        
         @worker_threads.clear
       end
       
       def worker_loop(id)
-        @logger.debug "Worker #{id} started" if @logger
+        @logger.debug "Worker #{id} started"
+        
         while @running
           begin
+            # Wait for a task from the queue
             task = @update_queue.pop
+            
+            # Check for shutdown signal
             break if task == :shutdown
             
             update_data, callback = task
-            update = Types::Update.new(update_data)
-            process_update(update)
-            callback&.call(update) if callback.respond_to?(:call)
-          rescue => e
-            @logger.error "Worker #{id} error: #{e.message}"
-          end
-        end
-        @logger.debug "Worker #{id} stopped" if @logger
-      end
-      
-      def poll_loop
-        while @running
-          begin
-            # Get updates - returns HTTPX request object
-            updates_request = fetch_updates
+            process_update(Types::Update.new(update_data))
             
-            # Wait for the request to complete
-            updates_request.wait(@polling_options[:timeout] + 5)
-            
-            # Get the response AFTER waiting
-            response = updates_request.response
-            
-            if response && response.status == 200
-              if json = response.json
-                handle_updates_response(json)
-              end
-            end
-            
-            # Small delay to prevent tight loop
-            sleep 0.1 unless @offset.nil?
+            # Execute callback if provided
+            callback&.call if callback.respond_to?(:call)
             
           rescue => e
-            handle_error(e)
-            sleep 5
+            @logger.error "Worker #{id} error: #{e.message}"
           end
         end
-      end
-      
-      def fetch_updates
-        params = {
-          timeout: @polling_options[:timeout],
-          limit: @polling_options[:limit]
-        }
-        params[:offset] = @offset if @offset
-        params[:allowed_updates] = @polling_options[:allowed_updates] if @polling_options[:allowed_updates]
         
-        @api.call('getUpdates', params)
+        @logger.debug "Worker #{id} stopped"
       end
       
-      def handle_updates_response(api_response)
-        return unless api_response['ok']
-        
-        updates_data = api_response['result'] || []
-        
-        # Queue updates for worker processing
-        updates_data.each do |update_data|
-          @update_queue << [update_data, nil]
-        end
-        
-        # Update offset for next poll
-        if updates_data.any?
-          @offset = updates_data.last['update_id'] + 1
-        end
-      end
+      # ----- UPDATE PROCESSING PIPELINE -----
       
       def process_update(update)
         ctx = Context.new(update, self)
         
         begin
+          # Run through middleware chain, then dispatch to handlers
           run_middleware_chain(ctx) do |context|
             dispatch_to_handlers(context)
           end
@@ -247,6 +306,7 @@ module Telegem
       def build_middleware_chain
         chain = Composer.new
         
+        # Add user-defined middleware
         @middleware.each do |middleware_class, args, block|
           if middleware_class.respond_to?(:new)
             middleware = middleware_class.new(*args, &block)
@@ -256,6 +316,7 @@ module Telegem
           end
         end
         
+        # Add session middleware if not already present
         unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
           chain.use(Session::Middleware.new(@session_store))
         end
@@ -267,14 +328,17 @@ module Telegem
         update_type = detect_update_type(ctx.update)
         handlers = @handlers[update_type] || []
         
+        # Find and execute the first matching handler
         handlers.each do |handler|
           if matches_filters?(ctx, handler[:filters])
             handler[:handler].call(ctx)
-            break
+            break  # First matching handler wins
           end
         end
       end
       
+      # ----- FILTER MATCHING LOGIC -----
+      
       def detect_update_type(update)
         return :message if update.message
         return :callback_query if update.callback_query
@@ -323,13 +387,16 @@ module Telegem
         ctx.message.command_name == command_name.to_s
       end
       
+      # ----- ERROR HANDLING -----
+      
       def handle_error(error, ctx = nil)
         if @error_handler
           @error_handler.call(error, ctx)
         else
           @logger.error("❌ Unhandled error: #{error.class}: #{error.message}")
-          @logger.error("Context: #{ctx.raw_update}") if ctx
-          @logger.error(error.backtrace&.join("\n")) if error.backtrace
+          if ctx
+            @logger.error("Context - User: #{ctx.from&.id}, Chat: #{ctx.chat&.id}")
+          end
         end
       end
     end

data/lib/telegem.rb

@@ -3,7 +3,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = "2.0.5".freeze
+  VERSION = "2.0.6".freeze
 end
 
 # Load core components

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: telegem
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
 platform: ruby
 authors:
 - sick_phantom
@@ -198,7 +198,7 @@ metadata:
   bug_tracker_uri: https://gitlab.com/ruby-telegem/telegem/-/issues
   documentation_uri: https://gitlab.com/ruby-telegem/telegem/-/blob/main/README.md
   rubygems_mfa_required: 'false'
-post_install_message: "Thanks for installing Telegem 2.0.5!\n\nQuick start:\n  bot
+post_install_message: "Thanks for installing Telegem 2.0.6!\n\nQuick start:\n  bot
   = Telegem.new(\"YOUR_TOKEN\")\n  bot.on(:message) { |ctx| ctx.reply(\"Hello!\")
   }\n  bot.start_polling\n\nDocumentation: https://gitlab.com/ruby-telegem/telegem\nHappy
   bot building! \U0001F916\n"