telegem 2.1.0 → 3.0.1

data/lib/core/bot.rb

@@ -1,16 +1,16 @@
 require 'concurrent'
 require 'logger'
+require 'async'
 
 module Telegem
   module Core
     class Bot
       attr_reader :token, :api, :handlers, :middleware, :logger, :scenes, 
-                  :running, :polling_thread, :session_store
+                  :running, :session_store
       
       def initialize(token, **options)
         @token = token
         @api = API::Client.new(token, **options.slice(:logger, :timeout))
-        @api_mutex = Mutex.new  # ← LINE 1 ADDED HERE
         
         @handlers = {
           message: [],
@@ -27,57 +27,27 @@ module Telegem
         @logger = options[:logger] || Logger.new($stdout)
         @error_handler = nil
         @session_store = options[:session_store] || Session::MemoryStore.new
-        
-        @thread_pool = Concurrent::FixedThreadPool.new(options[:max_threads] || 10)
-        @update_queue = Queue.new
-        @worker_threads = []
-        
-        @polling_thread = nil
-        @running = false
-        @offset = nil
-        
-        start_workers(options[:worker_count] || 5)
+
+        @running = false 
+        @offset = 0
+        @polling_options = options.slice(:timeout, :limit, :allowed_updates) || {}
       end
       
-      def start_polling(**options)
-        return if @running
-        
-        @running = true
-        @polling_options = {
-          timeout: 30,
-          limit: 100,
-          allowed_updates: nil
-        }.merge(options)
-        
-        @offset = nil
-        
-        @logger.info "🤖 Starting Telegem bot (polling mode)..."
-        
-        @polling_thread = Thread.new do
-          Thread.current.abort_on_exception = false
-          poll_loop
-        end
-        
-        self
+    def start_polling(**options)
+      @running = true
+      @polling_options = options
+      Async do
+        poll_loop  # Now runs in Async context
       end
+    end
       
       def shutdown
         return unless @running
         
         @logger.info "🛑 Shutting down bot..."
         @running = false
-        
-        if @polling_thread&.alive?
-          @polling_thread.join(3)
-        end
-        
-        stop_workers
-        
-        @api.close if @api.respond_to?(:close)
-        
-        @logger.info "✅ Bot shutdown complete"
-      end
-      
+        sleep 0.1
+      end 
       def running?
         @running
       end
@@ -128,16 +98,16 @@ module Telegem
         end
       end
       
-      def set_webhook(url, **options)
-        @api.call!('setWebhook', { url: url }.merge(options))
+      def set_webhook(url, **options, &callback)
+        @api.call!('setWebhook', { url: url }.merge(options), &callback)
       end
-      
-      def delete_webhook
-        @api.call!('deleteWebhook', {})
+
+      def delete_webhook(&callback)
+        @api.call!('deleteWebhook', {}, &callback)
       end
-      
-      def get_webhook_info
-        @api.call!('getWebhookInfo', {})
+
+      def get_webhook_info(&callback)
+        @api.call!('getWebhookInfo', {}, &callback)
       end
       
       def process(update_data)
@@ -147,112 +117,74 @@ module Telegem
       
       private
       
-      def poll_loop
-        @logger.debug "Entering polling loop"
-        
-        while @running
-          begin
-            result = fetch_updates
-            
-            if result && result.is_a?(Hash) && result['ok']
-              handle_updates_response(result)
-            elsif result
-              @logger.warn "Unexpected API response format: #{result.class}"
-            end
-            
-            sleep 0.1 unless @offset.nil?
-            
-          rescue => e
-            handle_error(e)
-            sleep 5
-          end
+    def poll_loop
+      fetch_updates do |result|
+        if result && result['ok']
+          handle_updates_response(result)
+        end
+
+        if @running
+          # Schedule next poll in NEW async context
+          Async { |task| 
+            task.sleep(1)
+            poll_loop 
+          }
         end
-        
-        @logger.debug "Exiting polling loop"
       end
-      
-      def fetch_updates
+    end
+     
+      def fetch_updates(&completion_callback)
         params = {
-          timeout: @polling_options[:timeout],
-          limit: @polling_options[:limit]
+          timeout: @polling_options[:timeout] || 30,
+          limit: @polling_options[:limit] || 100
         }
         params[:offset] = @offset if @offset
         params[:allowed_updates] = @polling_options[:allowed_updates] if @polling_options[:allowed_updates]
-        
-        @logger.debug("Fetching updates with offset: #{@offset}")
-        
-        # Simple direct call - no .wait
-        updates = @api.call!('getUpdates', params)
-        
-        if updates && updates.is_a?(Array)
-          @logger.debug("Got #{updates.length} updates")
-          return { 'ok' => true, 'result' => updates }
-        end
-        
-        nil
-      end
-      
-      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|
-            @update_queue << [update_data, nil]
-          end
-          
-          @offset = updates.last['update_id'] + 1
-          @logger.debug "Updated offset to #{@offset}"
-        end
-      end
-      
-      def start_workers(count)
-        count.times do |i|
-          @worker_threads << Thread.new do
-            Thread.current.abort_on_exception = false
-            worker_loop(i)
+
+        @logger.debug "Fetching updates with offset: #{@offset}"
+
+        @api.call!('getUpdates', params) do |updates_array, error|
+         if error 
+           @logger.error "Polling error: #{error.message}"
+           completion_callback.call(nil, error) if completion_callback
+           else 
+
+          # Success
+          if updates_array && updates_array.is_a?(Array)
+            result = { 'ok' => true, 'result' => updates_array }
+            completion_callback.call(result, nil) if completion_callback
+          else
+            completion_callback.call(nil, nil) if completion_callback
           end
-        end
-        @logger.debug "Started #{count} worker threads"
-      end
-      
-      def stop_workers
-        @logger.debug "Stopping worker threads"
-        
-        @worker_threads.size.times { @update_queue << :shutdown }
-        
-        @worker_threads.each do |thread|
-          thread.join(2) if thread.alive?
-        end
-        
-        @worker_threads.clear
+         end 
+       end
       end
-      
-      def worker_loop(id)
-        @logger.debug "Worker #{id} started"
-        
-        while @running
-          begin
-            task = @update_queue.pop
-            
-            break if task == :shutdown
-            
-            update_data, callback = task
-            process_update(Types::Update.new(update_data))
+         
             
-            callback&.call if callback.respond_to?(:call)
-            
-          rescue => e
-            @logger.error "Worker #{id} error: #{e.message}"
-          end
-        end
-        
-        @logger.debug "Worker #{id} stopped"
-      end
       
+      def handle_updates_response(api_response)
+        if api_response['ok'] 
+          updates = api_response['result'] || [] 
+             updates.each do |data|
+               Async do |task|
+                update_object = Types::Update.new(data) 
+                process_update(update_object)
+               end 
+             end 
+           if updates.any? 
+             @offset = updates.last['update_id'] + 1
+             @logger.debug "Updated offset to; #{@offset}"
+           end 
+        end 
+      end 
+     
       def process_update(update)
-        @api_mutex.synchronize do  # ← LINE 2 ADDED HERE
+        if update.message&.text && @logger
+         user = update.message.from
+         cmd = update.message.text.split.first
+         @logger.info("#{cmd} - #{user.username || user.first_name}")
+        end
+  
           ctx = Context.new(update, self)
           
           begin
@@ -262,7 +194,7 @@ module Telegem
           rescue => e
             handle_error(e, ctx)
           end
-        end  # ← This 'end' matches the 'do' above
+
       end
       
       def run_middleware_chain(ctx, &final)
@@ -361,4 +293,4 @@ module Telegem
       end
     end
   end
-end
+end 

data/lib/telegem.rb

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