telegem 3.1.3 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef63701f663694078c74cc777b733f9d7fd8c20f9d8309e12fdcbea6e979911
-  data.tar.gz: 29a744115f81510dfd0f2f082f7990cb67e63fafb976e69efda80caca9215de7
+  metadata.gz: d61b868c4601e8372d69f3a30af35e5efb2cfe7024c518c2c239804dd2914e7a
+  data.tar.gz: 38069437b5d718560e1480cc3846160bbdcd33a1b03380aadf6785692ebdecf3
 SHA512:
-  metadata.gz: b2e45b5fad65c6637eee3f982832eb4d227904e85e0efa7bf40315e69e69267d867aa8b6e2ea9e5eef00f5274c07697dee42b213bd75286887e2e21845ac9c25
-  data.tar.gz: 6e34ea4d896573e99ce30ecccb3fad123e43e3f60517c8aa3a5a779515428105dfc64dcf762cdb640878725ecbda8beba82d46f5aebaa104acbc8c5211c5622d
+  metadata.gz: '095647f0f51efff1afafc5233341506b76780288aafba0dd87aae6a9ffe42f5115aaf0aaf2a0f5db4034d2a053a7ff0d75d966b1fea34aa7e20e082e06b7bf1d'
+  data.tar.gz: fbe3e2f72ac63184f8378ca98108b9a16f87cfcf91219260de04a65bf1945dbdcec4c0d5b49bd82295714e478ad2798a7ffec38e86f411f4a13b6b5524a40dbc

data/Readme.md

@@ -1,4 +1,4 @@
-Telegem 🤖⚡
+![Telegem Logo](https://gitlab.com/ruby-telegem/telegem/-/raw/main/assets/logo.png)
 
 Modern, blazing-fast async Telegram Bot API for Ruby - Inspired by Telegraf, built for performance.
 
@@ -17,7 +17,7 @@ Blazing-fast, modern Telegram Bot framework for Ruby. Inspired by Telegraf.js, b
 
 ✨ Features
 
-- ⚡ True httpx(Async) I/O - Built on async gem, not blocking threads
+- ⚡ True Async I/O - Built on async gem, not blocking threads
 - 🎯 Telegraf-style DSL - Familiar API for JavaScript developers
 - 🔌 Middleware System - Compose behavior like Express.js
 - 🧙 Scene System - Multi-step conversations (wizards/forms)
@@ -108,7 +108,7 @@ Perfect For:
 
 ---
 
-📚 Documentation
+[📚 Documentation](https://www.rubydoc.info/gems/telegem/3.2.0/index)
 
 
 

data/lib/api/client.rb

@@ -1,4 +1,4 @@
-require 'httpx'
+require 'async/http'
 require 'json'
 
 module Telegem
@@ -6,112 +6,121 @@ module Telegem
     class Client
       BASE_URL = 'https://api.telegram.org'
       
-      attr_reader :token, :logger, :http
+      attr_reader :token, :logger
 
       def initialize(token, **options)
         @token = token
-        @mutex = Mutex.new
         @logger = options[:logger] || Logger.new($stdout)
-        timeout = options[:timeout] || 30
+        @timeout = options[:timeout] || 30
         
-        @http = HTTPX.plugin(:callbacks).with(
-          timeout: { 
-            request_timeout: timeout,
-            connect_timeout: 10,
-            write_timeout: 10,
-            read_timeout: timeout
-          },
-          headers: {
-            'Content-Type' => 'application/json',
-            'User-Agent' => "Telegem/#{Telegem::VERSION}"
-          }
-        )
+        @endpoint = Async::HTTP::Endpoint.parse(BASE_URL)
+        @client = Async::HTTP::Client.new(@endpoint)
       end
       
-      def call(method, params = {}) 
-        url = "#{BASE_URL}/bot#{@token}/#{method}"
-        @logger.debug("Api call #{method}") if @logger 
-        response = @http.post(url, json: params.compact)
-        json = response.json 
-        if json && json['ok'] 
-          json['result'] 
-        else 
-          raise APIError.new(json ? json['description'] : "Api Error")
-        end  
-      end  
+      def call(method, params = {})
+        Async do
+          make_request(method, params)
+        end.wait
+      end
       
       def call!(method, params = {}, &callback)
-        url = "#{BASE_URL}/bot#{@token}/#{method}"
         return unless callback
         
-        @http.post(url, json: params.compact) do |response| 
-          begin 
-            if response.status == 200
-              json = response.json 
-              if json && json['ok'] 
-                @logger.debug("#{json}") if @logger 
-                callback.call(json['result'], nil) 
-              else 
-                error_msg = json ? json['description'] : "NO JSON Response" 
-                error_code = json['error_code'] if json 
-                callback.call(nil, APIError.new("API ERROR #{error_msg}", error_code))
-              end 
-            else
-              callback.call(nil, NetworkError.new("HTTP #{response.status}")) 
-            end 
-          rescue JSON::ParserError
-            callback.call(nil, NetworkError.new("Invalid Json response"))
-          rescue => e
-            callback.call(nil, e)
-          end 
-        end 
-      end 
+        Async do
+          begin
+            result = make_request(method, params)
+            callback.call(result, nil)
+          rescue => error
+            callback.call(nil, error)
+          end
+        end
+      end
       
       def upload(method, params)
-        url = "#{BASE_URL}/bot#{@token}/#{method}"
-        response = @http.post(url, form: params)
-        response.json 
+        Async do
+          url = "/bot#{@token}/#{method}"
+          
+          body = Async::HTTP::Body::Multipart.new
+          
+          params.each do |key, value|
+            if file_object?(value)
+              body.add(key.to_s, value, filename: File.basename(value))
+            else
+              body.add(key.to_s, value.to_s)
+            end
+          end
+          
+          response = @client.post(url, {}, body)
+          handle_response(response)
+        end.wait
+      end
+      
+      def download(file_id, destination_path = nil)
+        Async do
+          file_info = call('getFile', file_id: file_id)
+          return nil unless file_info && file_info['file_path']
+          
+          file_path = file_info['file_path']
+          download_url = "/file/bot#{@token}/#{file_path}"
+          
+          response = @client.get(download_url)
+          
+          if response.status == 200
+            content = response.read
+            if destination_path
+              File.binwrite(destination_path, content)
+              destination_path
+            else
+              content
+            end
+          else
+            raise NetworkError.new("Download failed: HTTP #{response.status}")
+          end
+        end.wait
       end
       
-      def download(file_id, destination_path = nil) 
-        file_info = call('getFile', file_id: file_id)
-        return nil unless file_info && file_info['file_path'] 
-        file_path = file_info['file_path'] 
-        download_url = "#{BASE_URL}/file/bot#{@token}/#{file_path}"
-        @logger.debug("downloading.. #{download_url}") if @logger 
-        response = @http.get(download_url)
-        if response.status == 200
-          if destination_path
-            File.binwrite(destination_path, response.body.to_s)
-            @logger.debug("saved to #{destination_path}") if @logger 
-            destination_path
-          else 
-            response.body.to_s 
-          end 
-        else 
-          raise NetworkError.new("Download failed : #{response.status}") 
-        end 
-      end 
-
       def get_updates(offset: nil, timeout: 30, limit: 100, allowed_updates: nil)
         params = { timeout: timeout, limit: limit }
         params[:offset] = offset if offset
         params[:allowed_updates] = allowed_updates if allowed_updates
         call('getUpdates', params)
       end
-
+      
       def close
-        @http.close
+        @client.close
       end
-
+      
       private
-
+      
+      def make_request(method, params)
+        url = "/bot#{@token}/#{method}"
+        @logger.debug("Api call #{method}") if @logger
+        
+        response = @client.post(
+          url,
+          { 'content-type' => 'application/json' },
+          JSON.dump(params.compact)
+        )
+        
+        handle_response(response)
+      end
+      
+      def handle_response(response)
+        json = JSON.parse(response.read)
+        
+        if json && json['ok']
+          json['result']
+        else
+          raise APIError.new(json ? json['description'] : "Api Error")
+        end
+      end
+      
       def file_object?(obj)
         obj.is_a?(File) || obj.is_a?(StringIO) || obj.is_a?(Tempfile) ||
           (obj.is_a?(String) && File.exist?(obj))
       end
     end
-
+    
     class APIError < StandardError
       attr_reader :code
       
@@ -120,7 +129,7 @@ module Telegem
         @code = code
       end
     end
-
+    
     class NetworkError < APIError; end
   end
-end
+end

data/lib/core/bot.rb

@@ -1,6 +1,4 @@
-require 'concurrent'
-require 'logger'
-require 'async'
+require 'json'
 
 module Telegem
   module Core
@@ -39,13 +37,13 @@ module Telegem
         @polling_options = options.slice(:timeout, :limit, :allowed_updates) || {}
       end
       
-    def start_polling(**options)
-      @running = true
-      @polling_options = options
-      Async do
-        poll_loop  # Now runs in Async context
+      def start_polling(**options)
+        @running = true
+        @polling_options = options
+        Async do
+          poll_loop
+        end
       end
-    end
       
       def shutdown
         return unless @running
@@ -54,6 +52,7 @@ module Telegem
         @running = false
         sleep 0.1
       end 
+      
       def running?
         @running
       end
@@ -78,7 +77,7 @@ module Telegem
       def contact(**options, &block) 
         on(:message, contact: true) do |ctx| 
           block.call(ctx)
-       end 
+        end 
       end 
       
       def poll_answer(&block) 
@@ -87,10 +86,10 @@ module Telegem
         end
       end 
       
-     def pre_checkout_query(&block) 
-       on(:pre_checkout_query) do |ctx| 
-         block.call(ctx) 
-       end 
+      def pre_checkout_query(&block) 
+        on(:pre_checkout_query) do |ctx| 
+          block.call(ctx) 
+        end 
       end 
       
       def shipping_query(&block) 
@@ -100,34 +99,35 @@ module Telegem
       end 
       
       def chat_join_request(&block)
-  on(:chat_join_request) do |ctx|
-    block.call(ctx)
-  end
-end
+        on(:chat_join_request) do |ctx|
+          block.call(ctx)
+        end
+      end
 
-  def chat_boost(&block)
-   on(:chat_boost) do |ctx|
-    block.call(ctx)
-   end
- end
+      def chat_boost(&block)
+        on(:chat_boost) do |ctx|
+          block.call(ctx)
+        end
+      end
 
- def removed_chat_boost(&block)
-   on(:removed_chat_boost) do |ctx|
-    block.call(ctx)
-   end
- end
+      def removed_chat_boost(&block)
+        on(:removed_chat_boost) do |ctx|
+          block.call(ctx)
+        end
+      end
 
-  def message_reaction(&block)
-  on(:message_reaction) do |ctx|
-    block.call(ctx)
-  end
- end
+      def message_reaction(&block)
+        on(:message_reaction) do |ctx|
+          block.call(ctx)
+        end
+      end
 
-def message_reaction_count(&block)
-  on(:message_reaction_count) do |ctx|
-    block.call(ctx)
-  end
-end
+      def message_reaction_count(&block)
+        on(:message_reaction_count) do |ctx|
+          block.call(ctx)
+        end
+      end
+      
       def web_app_data(&block) 
         on(:message, web_app_data: true) do |ctx|
           block.call(ctx) 
@@ -170,106 +170,82 @@ end
       end
       
       def set_webhook(url, **options, &callback)
-        @api.call!('setWebhook', { url: url }.merge(options), &callback)
+        if callback
+          @api.call!('setWebhook', { url: url }.merge(options), &callback)
+        else
+          @api.call('setWebhook', { url: url }.merge(options))
+        end
       end
 
       def delete_webhook(&callback)
-        @api.call!('deleteWebhook', {}, &callback)
+        if callback
+          @api.call!('deleteWebhook', {}, &callback)
+        else
+          @api.call('deleteWebhook', {})
+        end
       end
 
       def get_webhook_info(&callback)
-        @api.call!('getWebhookInfo', {}, &callback)
+        if callback
+          @api.call!('getWebhookInfo', {}, &callback)
+        else
+          @api.call('getWebhookInfo', {})
+        end
       end
       
       def process(update_data)
         update = Types::Update.new(update_data)
         process_update(update)
       end
+
+      
       
       private
       
-    def poll_loop
-      while @running 
-       begin 
-        Async do |task| 
-          fetch_updates do |result, error|
-            if error 
-             @logger.error "Polling error #{error.message}"
-              task.sleep(0.2)
-               elsif result && result['ok'] 
-                handle_updates_response(result) 
-                end 
-              end 
-            end.wait
-            rescue => e 
-             @logger.error "poll loop error #{e.message}"
-             end
-             sleep 0.5 
-             end 
-            end 
-     
-      def fetch_updates(&completion_callback)
-        params = {
-          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}"
-
-        @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
+      def poll_loop
+        while @running
+          begin
+            updates = @api.get_updates(
+              offset: @offset,
+              timeout: @polling_options[:timeout] || 30,
+              limit: @polling_options[:limit] || 100,
+              allowed_updates: @polling_options[:allowed_updates]
+            )
+            
+            if updates && updates.any?
+              updates.each do |update_data|
+                Async do
+                  update = Types::Update.new(update_data)
+                  process_update(update)
+                end
+              end
+              
+              @offset = updates.last['update_id'] + 1
+              @logger.debug("Updated offset to: #{@offset}")
+            end
+          rescue => e
+            @logger.error("Poll loop error: #{e.message}")
+            sleep 1
           end
-         end 
-       end
+        end
       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)
         if update.message&.text && @logger
-         user = update.message.from
-         cmd = update.message.text.split.first
-         @logger.info("#{cmd} - #{user.username}")
+          user = update.message.from
+          cmd = update.message.text.split.first
+          @logger.info("#{cmd} - #{user.username}")
         end
-  
-          ctx = Context.new(update, self)
-          
-          begin
-            run_middleware_chain(ctx) do |context|
-              dispatch_to_handlers(context)
-            end
-          rescue => e
-            handle_error(e, ctx)
-          end
 
+        ctx = Context.new(update, self)
+        
+        begin
+          run_middleware_chain(ctx) do |context|
+            dispatch_to_handlers(context)
+          end
+        rescue => e
+          handle_error(e, ctx)
+        end
       end
       
       def run_middleware_chain(ctx, &final)
@@ -290,19 +266,20 @@ end
         end
         
         unless @middleware.any? { |m, _, _| m.to_s =~ /Scene/ }
-    begin
-      require_relative '../session/scene_middleware'
-      chain.use(Telegem::Scene::Middleware.new)
-    rescue LoadError => e
-      @logger.debug("Scene middleware not available: #{e.message}") if @logger
-    end
-  end
-  unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
-    chain.use(Session::Middleware.new(@session_store))
-  end
-  
-  chain
-end
+          begin
+            require_relative '../session/scene_middleware'
+            chain.use(Telegem::Scene::Middleware.new)
+          rescue LoadError => e
+            @logger.debug("Scene middleware not available: #{e.message}") if @logger
+          end
+        end
+        
+        unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
+          chain.use(Session::Middleware.new(@session_store))
+        end
+        
+        chain
+      end
       
       def dispatch_to_handlers(ctx)
         update_type = detect_update_type(ctx.update)
@@ -347,16 +324,16 @@ end
           when :location 
             ctx.message&.location != nil 
           when :contact 
-             ctx.message&.contact != nil 
+            ctx.message&.contact != nil 
           when :web_app_data 
             ctx.message&.web_app_data != nil
           else 
-            if  ctx.update.respond_to?(key) 
-            ctx.update.send(key) == value
-          else 
-            false 
-          end 
-         end
+            if ctx.update.respond_to?(key)
+              ctx.update.send(key) == value
+            else 
+              false 
+            end 
+          end
         end 
       end
       
@@ -392,4 +369,4 @@ end
       end
     end
   end
-end 
+end

data/lib/core/context.rb

@@ -42,6 +42,82 @@ module Telegem
         inline_query&.query
       end
       
+      def message_id 
+        message&.message_id
+      end 
+
+      def message_date
+        message&.date
+      end 
+
+      def edit_date 
+        message&.edit_date
+      end 
+
+      def command_name 
+        message&.command_name
+      end 
+
+      def has_media?
+        message&.has_media? || false
+      end 
+
+      def media_type
+        message&.media_type
+      end 
+
+      def entities
+        message&.entities || []
+      end 
+
+      def caption_entities
+        message&caption_entities || []
+      end 
+      
+      def caption 
+        message&.caption 
+      end 
+
+      def reply?
+        message&.reply?
+      end 
+
+      def replied_message
+        message&.reply_to_message 
+      end 
+
+      def replied_text
+        replied_message&.text
+      end 
+
+      def replied_from 
+        replied_message&.from 
+      end 
+
+      def replied_chat
+        replied_message&.chat 
+      end 
+      
+      def update_type
+        @update.type 
+      end 
+
+      def is_edited?
+        !!@update.edited_message
+      end 
+
+      def channel_post?
+        update_type == :channel_post
+      end 
+
+      def callback_query?
+        update_type == :callback_query
+      end 
+
+      def inline_query?
+        update_type == :inline_query
+      end 
+        
       def reply(text, **options)
         return nil unless chat
         

data/lib/core/rate_limit.rb

@@ -88,7 +88,8 @@ module Telegem
     end
     
     def cleanup_counter(type, key, now)
-      
+      expires = @counters[type].get_ttl(key) || now
+      @counters[type].delete(key) if now > expires 
     end
     
     def rate_limit_response(ctx)
@@ -96,5 +97,5 @@ module Telegem
       ctx.reply("⏳ Please wait a moment before sending another request.") rescue nil
       nil
     end
-  end
+  end 
 end

data/lib/markup/keyboard.rb

@@ -152,16 +152,13 @@ module Telegem
       end
 
       def to_h
-  # Keep only hash buttons
-    clean_rows = @buttons.map do |row|
-    row = row.is_a?(Array) ? row : [row]
-    row.select { |btn| btn.is_a?(Hash) }
-  end.reject(&:empty?)
-  
-  {
-    inline_keyboard: clean_rows
-  }
-   end 
+        clean_rows = @buttons.compact.map do |row| 
+          row = Array(row).compact.select { |btn| is_a?(Hash) }
+          row.empty? ? nil : row 
+        end.compact 
+         { inline_keyboard: clean_rows} 
+      end 
+   
       def to_json(*args)
         to_h.to_json(*args)
       end

data/lib/telegem.rb

@@ -3,7 +3,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = "3.1.3".freeze 
+  VERSION = "3.2.1".freeze 
 end
 
 # Load core components
@@ -82,4 +82,4 @@ if ENV['TELEGEM_GLOBAL'] == 'true'
   def Telegem(token, **options)
     ::Telegem.new(token, **options)
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: telegem
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.2.1
 platform: ruby
 authors:
 - sick_phantom
@@ -118,7 +118,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".replit"
 - CHANGELOG
 - CODE_OF_CONDUCT.md
 - Contributing.md
@@ -127,6 +126,8 @@ files:
 - LICENSE
 - Readme.md
 - Starts_HallofFame.md
+- assets/.gitkeep
+- assets/logo.png
 - bin/.gitkeep
 - bin/telegem-ssl
 - examples/.gitkeep
@@ -158,7 +159,7 @@ metadata:
   bug_tracker_uri: https://gitlab.com/ruby-telegem/telegem/-/issues
   documentation_uri: https://gitlab.com/ruby-telegem/telegem/-/tree/main/docs-src?ref_type=heads
   rubygems_mfa_required: 'false'
-post_install_message: "Thanks for installing Telegem 3.1.3!\n\n\U0001F4DA Documentation:
+post_install_message: "Thanks for installing Telegem 3.2.1!\n\n\U0001F4DA Documentation:
   https://gitlab.com/ruby-telegem/telegem\n\n\U0001F510 For SSL Webhooks:\nRun: telegem-ssl
   your-domain.com\nThis sets up Let's Encrypt certificates automatically.\n\n\U0001F916
   Happy bot building!\n"

data/.replit

@@ -1,13 +0,0 @@
-run = "bundle exec ruby main.rb"
-hidden = [".bundle"]
-entrypoint = "main.rb"
-modules = ["ruby-3.2"]
-
-[nix]
-channel = "stable-24_05"
-
-[gitHubImport]
-requiredFiles = [".replit", "replit.nix"]
-
-[agent]
-expertMode = true