telegem 2.0.6 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a800a5e96af8c42cd15dd4448e6b157beb99c6a1e5e29de786b9af0464903093
-  data.tar.gz: 25829f45ed0434bd0a8bd6f09a98296292d96037b21dea52323596f42cdec7a4
+  metadata.gz: b5e8e2d8f412d455281a8ed45a4384161431715964447abf7d323c8e5a651eaf
+  data.tar.gz: e92cf5b7324c3e745a66dfcf935b9ed18bae231fa0051316070cf726dc259d4b
 SHA512:
-  metadata.gz: 5cb72e7a6d9dc453808e617033f6e5d52229dc72299779834e4ecacf67d4cc25510f2ca97dbbbca199c0adb7e2ee1c5f18a4c77d576198a891f8b98bbfd75c94
-  data.tar.gz: a490e086730633ccf1e8ba3cc4d018033fbbe0ddc3b300104f9aff1a91d542766e7053a2c81cefcedc8b4555c0415368a7df42ef47c59ff9d5b284a0e413defc
+  metadata.gz: 95f13660c4b21333d0a4d68a6fb1ba25767a1f3d5aa7f06f07d0f76b82796730f8803c3036c7297d9b8aaea99cd73e22cfe01999d5a52c6456b6b0b9a42921b3
+  data.tar.gz: f5cc5f64bb886ea1f38b8c51993db49c8850a0017a0722a70f670f783fbb997fcbdebc816fb28fb92e74bf543473addda1da8300430565df0fce260c84ea8cb4

data/lib/api/client.rb

@@ -1,4 +1,3 @@
-# lib/api/client.rb - MINIMAL WORKING VERSION
 require 'httpx'
 require 'json'
 
@@ -12,35 +11,52 @@ module Telegem
       def initialize(token, **options)
         @token = token
         @logger = options[:logger] || Logger.new($stdout)
-        @timeout = options[:timeout] || 30
+        timeout = options[:timeout] || 30
         
         @http = HTTPX.with(
-          timeout: { request_timeout: @timeout},
+          timeout: { 
+            request_timeout: timeout,
+            connect_timeout: 10,
+            write_timeout: 10,
+            read_timeout: timeout
+          },
           headers: {
-            'Content-Type' => 'application/json'
+            'Content-Type' => 'application/json',
+            'User-Agent' => "Telegem/#{Telegem::VERSION}"
           }
         )
       end
 
       def call(method, params = {})
         url = "#{BASE_URL}/bot#{@token}/#{method}"
+        @logger.debug("API Call: #{method}") if @logger
         @http.post(url, json: params.compact)
       end
 
       def call!(method, params = {})
-        request = call(method, params)
-        request.wait
+        url = "#{BASE_URL}/bot#{@token}/#{method}"
+        
+        @logger.debug("API Call (sync): #{method}") if @logger
         
-        if request.error
-          handle_error(request.error)
-          return nil
+        begin
+          response = @http.post(url, json: params.compact)
+          
+          if response.respond_to?(:status) && response.status == 200
+            json = response.json
+            return json['result'] if json && json['ok']
+          end
+          
+          @logger.error("API Error: HTTP #{response.status}") if response.respond_to?(:status) && @logger
+        rescue => e
+          @logger.error("Exception: #{e.message}") if @logger
         end
         
-        handle_response(request.response)
+        nil
       end
 
       def upload(method, params)
         url = "#{BASE_URL}/bot#{@token}/#{method}"
+        
         form = params.map do |key, value|
           if file_object?(value)
             [key.to_s, HTTPX::FormData::File.new(value)]
@@ -48,6 +64,7 @@ module Telegem
             [key.to_s, value.to_s]
           end
         end
+        
         @http.post(url, form: form)
       end
 
@@ -64,28 +81,6 @@ module Telegem
 
       private
 
-      def handle_response(response)
-        return nil unless response
-        
-        if response.status != 200
-          raise APIError, "HTTP #{response.status}"
-        end
-        
-        json = response.json
-        return nil unless json
-        
-        if json['ok']
-          json['result']
-        else
-          raise APIError.new(json['description'], json['error_code'])
-        end
-      end
-
-      def handle_error(error)
-        @logger.error("API Error: #{error.message}") if @logger
-        raise APIError, error.message
-      end
-
       def file_object?(obj)
         obj.is_a?(File) || obj.is_a?(StringIO) || obj.is_a?(Tempfile) ||
           (obj.is_a?(String) && File.exist?(obj))

data/lib/core/bot.rb

@@ -1,11 +1,9 @@
-# lib/core/bot.rb - Telegem v2.0.0 (Stable)
 require 'concurrent'
 require 'logger'
 
 module Telegem
   module Core
     class Bot
-      # Public accessors for bot state and components
       attr_reader :token, :api, :handlers, :middleware, :logger, :scenes, 
                   :running, :polling_thread, :session_store
       
@@ -13,7 +11,6 @@ module Telegem
         @token = token
         @api = API::Client.new(token, **options.slice(:logger, :timeout))
         
-        # Initialize handler registries for different update types
         @handlers = {
           message: [],
           callback_query: [],
@@ -30,24 +27,17 @@ module Telegem
         @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  # Last processed update ID
+        @offset = nil
         
-        # Start worker threads for processing updates
         start_workers(options[:worker_count] || 5)
       end
       
-      # ========================
-      # POLLING LIFECYCLE METHODS
-      # ========================
-      
       def start_polling(**options)
         return if @running
         
@@ -58,7 +48,7 @@ module Telegem
           allowed_updates: nil
         }.merge(options)
         
-        @offset = nil  # Reset offset when starting
+        @offset = nil
         
         @logger.info "🤖 Starting Telegem bot (polling mode)..."
         
@@ -76,15 +66,12 @@ module Telegem
         @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"
@@ -94,10 +81,6 @@ module Telegem
         @running
       end
       
-      # ========================
-      # COMMAND & EVENT HANDLERS
-      # ========================
-      
       def command(name, **options, &block)
         pattern = /^\/#{Regexp.escape(name)}(?:@\w+)?(?:\s+(.+))?$/i
         
@@ -132,10 +115,6 @@ module Telegem
         @scenes[id] = Scene.new(id, &block)
       end
       
-      # ========================
-      # WEBHOOK METHODS
-      # ========================
-      
       def webhook(app = nil, port: nil, host: '0.0.0.0', logger: nil, &block)
         require_relative '../webhook/server'
         
@@ -160,43 +139,31 @@ module Telegem
         @api.call!('getWebhookInfo', {})
       end
       
-      # ========================
-      # UPDATE PROCESSING
-      # ========================
-      
       def process(update_data)
         update = Types::Update.new(update_data)
         process_update(update)
       end
       
-      # ========================
-      # PRIVATE METHODS
-      # ========================
-      
       private
       
-      # ----- POLLING LOGIC -----
-      
       def poll_loop
         @logger.debug "Entering polling loop"
         
         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"
+              @logger.warn "Unexpected API response format: #{result.class}"
             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
+            sleep 5
           end
         end
         
@@ -204,17 +171,25 @@ module Telegem
       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]
-        
-        # Use call! for synchronous operation (more reliable)
-        @api.call!('getUpdates', params)
-      end
-      
+  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.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'] || []
         
@@ -222,18 +197,14 @@ module Telegem
           @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
       
-      # ----- WORKER THREAD MANAGEMENT -----
-      
       def start_workers(count)
         count.times do |i|
           @worker_threads << Thread.new do
@@ -247,10 +218,8 @@ module Telegem
       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
@@ -263,16 +232,13 @@ module Telegem
         
         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
             process_update(Types::Update.new(update_data))
             
-            # Execute callback if provided
             callback&.call if callback.respond_to?(:call)
             
           rescue => e
@@ -283,13 +249,10 @@ module Telegem
         @logger.debug "Worker #{id} stopped"
       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
@@ -306,7 +269,6 @@ 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)
@@ -316,7 +278,6 @@ 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
@@ -328,17 +289,14 @@ 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  # First matching handler wins
+            break
           end
         end
       end
       
-      # ----- FILTER MATCHING LOGIC -----
-      
       def detect_update_type(update)
         return :message if update.message
         return :callback_query if update.callback_query
@@ -387,8 +345,6 @@ 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)

data/lib/telegem.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: telegem
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.8
 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.6!\n\nQuick start:\n  bot
+post_install_message: "Thanks for installing Telegem 2.0.8!\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"