telegem 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c55866ecfc21045fd47141b991f00a209cecd5c866fe52b73c2ffb302f0245ea
-  data.tar.gz: 0a0e93a2c61487e759ecbc1e3ed2f86b1e77fbd993076acbebc6287f36584a52
+  metadata.gz: 5b3073c1e51978c6c7a09bc9ef4e28a0d262b15b23be16d6a81c9c69d11ef9dd
+  data.tar.gz: a4850c9a75a3009bf55c9aa587ab61e2a9fbf75f1d210762e103c64d5c044a7e
 SHA512:
-  metadata.gz: 791184d5d43c592bbd66b844386112bd336ee4a7ab7bcfe30ce08eaca3a30f53eb819642c9ba5640084c4d17f91b81cee11cf006c4537175e2b86db2420c6db8
-  data.tar.gz: 668eb8f1b6b3e5d3d2280fb2000e545836fa53af096ab6af89b87560b7484bee51a3be8360dbfe989966423c69ea0a916cb5f40f99862c19a47205d8880d8570
+  metadata.gz: e259c050dd7d42564dc53e82266e7becc2089d7bf72ab14b1c85c7189215f36a543bc1c0ee6b677277cafc9661ac35057e4c2110260ad198397d49623a8c4cf7
+  data.tar.gz: c30b8f65dacb91c98d78a01ff359896f85d79295ca466667c8c60c5ea995fa82d8d28127c44b5490f64573524f3a9820dfe8b96ccc7a54a571d9a7e77377ce9d

data/lib/api/client.rb

@@ -1,4 +1,4 @@
-# lib/api/client.rb - V2.0.0 (ASYNC-FIRST, NON-BLOCKING)
+# lib/api/client.rb - WORKING VERSION
 require 'httpx'
 require 'json'
 
@@ -7,89 +7,62 @@ module Telegem
     class Client
       BASE_URL = 'https://api.telegram.org'
       
-      attr_reader :token, :logger, :http, :connection_pool
+      attr_reader :token, :logger, :http
 
-      def initialize(token, logger: nil, timeout: 30, pool_size: 10)
+      def initialize(token, **options)
         @token = token
-        @logger = logger || Logger.new($stdout)
+        @logger = options[:logger] || Logger.new($stdout)
+        timeout = options[:timeout] || 30
         
-        # HTTPX with proper async configuration
-        @http = HTTPX.plugin(:persistent)
-                     .with(
-                       timeout: { 
-                         connect_timeout: 10,
-                         write_timeout: 10,
-                         read_timeout: timeout,
-                         keep_alive_timeout: 15
-                       },
-                       headers: {
-                         'Content-Type' => 'application/json',
-                         'User-Agent' => "Telegem/#{Telegem::VERSION} (Ruby #{RUBY_VERSION}; #{RUBY_PLATFORM})"
-                       },
-                       max_requests: pool_size  # Connection pool
-                     )
+        @http = HTTPX.with(
+          timeout: { 
+            connect_timeout: 10,
+            write_timeout: 10,
+            read_timeout: timeout
+          },
+          headers: {
+            'Content-Type' => 'application/json',
+            'User-Agent' => "Telegem/#{Telegem::VERSION}"
+          }
+        )
         
-        # Add retry plugin if available
-        if HTTPX.plugins.key?(:retries)
-          @http = @http.plugin(:retries, max_retries: 3, retry_on: [500, 502, 503, 504])
-        end
-        
-        # Ensure proper cleanup
         ObjectSpace.define_finalizer(self, proc { close })
       end
 
-      # PRIMARY API: Async call - returns HTTPX request (promise-like)
       def call(method, params = {})
         url = "#{BASE_URL}/bot#{@token}/#{method}"
         
-        @logger.debug("🚀 Async API: #{method}") if @logger
+        @logger.debug("API: #{method}") if @logger
         
-        # Pure async - returns immediately
         @http.post(url, json: params.compact)
-             .then(&method(:handle_response_async))
-             .on_error(&method(:handle_error_async))
       end
 
-      # SYNC WRAPPER: For when you absolutely need blocking
-      def call!(method, params = {}, timeout: nil)
-        timeout ||= @http.options.timeout[:read_timeout]
-        
-        # Start async request
+      def call!(method, params = {})
         request = call(method, params)
+        request.wait
         
-        # Wait with timeout
-        begin
-          wait_result = request.wait(timeout)
-          
-          if request.error
-            # Error already logged by handle_error_async
-            raise APIError, request.error.message
-          elsif !wait_result
-            raise NetworkError, "Request timeout after #{timeout}s"
-          end
-          
-          # Return the actual result (not the request object)
-          request.instance_variable_get(:@result) || request.response
-        rescue Timeout::Error
-          raise NetworkError, "Request timeout after #{timeout}s"
+        if request.error
+          handle_error(request.error)
+          return nil
         end
+        
+        handle_response(request.response)
       end
 
-      # File upload - also async
       def upload(method, params)
         url = "#{BASE_URL}/bot#{@token}/#{method}"
         
-        # Build multipart form
-        form = build_multipart_form(params)
-        
-        @logger.debug("📤 Async Upload: #{method}") if @logger
+        form = params.map do |key, value|
+          if file_object?(value)
+            [key.to_s, HTTPX::FormData::File.new(value)]
+          else
+            [key.to_s, value.to_s]
+          end
+        end
         
         @http.post(url, form: form)
-             .then(&method(:handle_response_async))
-             .on_error(&method(:handle_error_async))
       end
 
-      # Convenience method for getUpdates with proper async handling
       def get_updates(offset: nil, timeout: 30, limit: 100, allowed_updates: nil)
         params = { timeout: timeout, limit: limit }
         params[:offset] = offset if offset
@@ -98,95 +71,56 @@ module Telegem
         call('getUpdates', params)
       end
 
-      # Close connections gracefully
       def close
         @http.close
       end
 
       private
 
-      # Async response handler - stores result on request object
-      def handle_response_async(response)
-        response.raise_for_status unless response.status == 200
+      def handle_response(response)
+        return nil unless response
         
-        case response.status
-        when 429  # Rate limit
-          retry_after = response.headers['retry-after']&.to_i || 1
-          raise RateLimitError.new("Rate limited", retry_after)
-        when 200
-          begin
-            json = response.json
-          rescue JSON::ParserError => e
-            raise APIError, "Invalid JSON: #{e.message}"
-          end
-          
-          unless json
-            raise APIError, "Empty response"
-          end
-          
-          if json['ok']
-            # Store result on request for sync access
-            response.request.instance_variable_set(:@result, json['result'])
-            json['result']
-          else
-            raise APIError.new(json['description'], json['error_code'])
-          end
+        if response.status != 200
+          raise APIError, "HTTP #{response.status}"
+        end
+        
+        begin
+          json = response.json
+        rescue JSON::ParserError
+          raise APIError, "Invalid JSON response"
+        end
+        
+        unless json
+          raise APIError, "Empty response"
+        end
+        
+        if json['ok']
+          json['result']
         else
-          response.raise_for_status
+          raise APIError.new(json['description'], json['error_code'])
         end
       end
 
-      # Async error handler
-      def handle_error_async(error)
+      def handle_error(error)
         case error
         when HTTPX::TimeoutError
-          @logger.error("⏰ Timeout: #{error.message}") if @logger
-          raise NetworkError, "Timeout: #{error.message}"
+          @logger.error("Timeout: #{error.message}") if @logger
+          raise NetworkError, "Request timeout"
         when HTTPX::ConnectionError
-          @logger.error("🔌 Connection: #{error.message}") if @logger
-          raise NetworkError, "Connection failed: #{error.message}"
-        when HTTPX::HTTPError
-          @logger.error("🌐 HTTP #{error.response.status}: #{error.message}") if @logger
-          raise APIError, "HTTP #{error.response.status}: #{error.message}"
-        when RateLimitError
-          @logger.error("🚦 Rate limit: retry after #{error.retry_after}s") if @logger
-          raise error  # Re-raise for user handling
+          @logger.error("Connection error: #{error.message}") if @logger
+          raise NetworkError, "Connection failed"
         else
-          @logger.error("💥 Unexpected: #{error.class}: #{error.message}") if @logger
+          @logger.error("Error: #{error.class}: #{error.message}") if @logger
           raise APIError, error.message
         end
       end
 
-      def build_multipart_form(params)
-        params.map do |key, value|
-          if file_object?(value)
-            [key.to_s, HTTPX::FormData::File.new(value)]
-          else
-            [key.to_s, value.to_s]
-          end
-        end
-      end
-
       def file_object?(obj)
-        case obj
-        when File, StringIO, Tempfile
-          true
-        when Pathname
-          obj.exist? && obj.readable?
-        when String
-          # Check if it's a local file (not URL)
-          if obj.start_with?('http://', 'https://', 'ftp://')
-            false  # Telegram handles URLs directly
-          else
-            File.exist?(obj) && File.readable?(obj)
-          end
-        else
-          false
-        end
+        obj.is_a?(File) || obj.is_a?(StringIO) || obj.is_a?(Tempfile) ||
+          (obj.is_a?(String) && File.exist?(obj))
       end
     end
 
-    # Custom Errors
     class APIError < StandardError
       attr_reader :code
       
@@ -197,14 +131,5 @@ module Telegem
     end
 
     class NetworkError < APIError; end
-    
-    class RateLimitError < APIError
-      attr_reader :retry_after
-      
-      def initialize(message, retry_after = 1)
-        super(message)
-        @retry_after = retry_after
-      end
-    end
   end
 end

data/lib/telegem.rb

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

metadata

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