telegem 0.1.6 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0f4841ae7f22222a39ad5a3664843a908f522ac988cf9da42367b8edaa31e2
-  data.tar.gz: dd000aa5a145b4912bedc5b4e5eaf071a9fb6198a30279b43edf81492dab160e
+  metadata.gz: dc3dc81c673fa1128b108e02c3401f4bac483d7173759b4c901c3db625fa8dd8
+  data.tar.gz: 4cb6de9fa5d9b8c5babbbd83ff86b5b7f6c0161628e74dbb7416ee5eeaa10e70
 SHA512:
-  metadata.gz: 5cff4090a99a1d98996b25303e80ca516e415d383cbe123657a9606aeddf6fa3b211891ad568c0bfff85d1fd6b3865a61416ab3e9f03862c86603fb8aac79437
-  data.tar.gz: 3fcb8b5de79185dc660833dd2ae20ecdac3034633f84e14a770c29df408631ff310ca3349e7383333eb8ec2cee5cd001df6b918451144e4e93a8051e75ad2486
+  metadata.gz: 32211bca88485aa5d19b41c8bc400b1af8b790de8ec4cf9761537a2f59de299e4ee6c5dca2de3e5561f58fe0280238c1452cff10429aa876d2fad2426556819d
+  data.tar.gz: fef73c4f8d976614ec815cee3c230409bf471564f38a46acb5fc7093c80d2154186a621f68068098cc1072cdb144184c92a683be83e42107f7ea409ea3175b5e

data/lib/api/client.rb

@@ -1,156 +1,163 @@
-      module Telegem
-        module API
-          class Client
-            BASE_URL = 'https://api.telegram.org'
-
-            attr_reader :token, :logger
-
-            def initialize(token, endpoint: nil, logger: nil)
-              @token = token
-              @logger = logger || Logger.new($stdout)
-              @endpoint = endpoint || Async::HTTP::Endpoint.parse("#{BASE_URL}/bot#{token}")
-              @client = nil
-              @semaphore = Async::Semaphore.new(30)
-            end
-
-            def call(method, params = {})
-              Async do |task|
-                @semaphore.async do
-                  make_request(method, clean_params(params))
-                end
-              end
-            end
-
-            def upload(method, params)
-              Async do |task|
-                @semaphore.async do
-                  make_multipart_request(method, params)
-                end
-              end
-            end
-
-            def get_updates(offset: nil, timeout: 30, limit: 100)
-              params = { timeout: timeout, limit: limit }
-              params[:offset] = offset if offset
-              call('getUpdates', params)
-            end
-
-            def close
-              @client&.close
-            end
-
-            private
-
-            def make_request(method, params)
-              with_client do |client|
-                headers = { 'content-type' => 'application/json' }
-                body = params.to_json
-
-                response = client.post("/bot#{@token}/#{method}", headers, body)
-                handle_response(response)
-              end
-            end
-
-            def make_multipart_request(method, params)
-              with_client do |client|
-                form = build_multipart(params)
-                headers = form.headers
-
-                response = client.post("/bot#{@token}/#{method}", headers, form.body)
-                handle_response(response)
-              end
-            end
-
-            def with_client(&block)
-              @client ||= Async::HTTP::Client.new(@endpoint)
-              yield @client
-            end
-
-            def clean_params(params)
-              params.reject { |_, v| v.nil? }
-            end
-
-            def build_multipart(params)
-              # Build multipart form data for file uploads
-              boundary = SecureRandom.hex(16)
-              parts = []
-
-              params.each do |key, value|
-                if file?(value)
-                  parts << part_from_file(key, value, boundary)
-                else
-                  parts << part_from_field(key, value, boundary)
-                end
-              end
-
-              parts << "--#{boundary}--\r\n"
-
-              body = parts.join
-              headers = {
-                'content-type' => "multipart/form-data; boundary=#{boundary}",
-                'content-length' => body.bytesize.to_s
-              }
-
-              OpenStruct.new(headers: headers, body: body)
-            end
-
-            def file?(value)
-              value.is_a?(File) || 
-              value.is_a?(StringIO) || 
-              (value.is_a?(String) && File.exist?(value))
-            end
-
-            def part_from_file(key, file, boundary)
-              filename = File.basename(file.path) if file.respond_to?(:path)
-              filename ||= "file"
-
-              mime_type = MIME::Types.type_for(filename).first || 'application/octet-stream'
-
-              content = if file.is_a?(String)
-                          File.read(file)
-                        else
-                          file.read
-                        end
-
-              <<~PART
-                --#{boundary}\r
-                Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r
-                Content-Type: #{mime_type}\r
-                \r
-                #{content}\r
-              PART
-            end
-
-            def part_from_field(key, value, boundary)
-              <<~PART
-                --#{boundary}\r
-                Content-Disposition: form-data; name="#{key}"\r
-                \r
-                #{value}\r
-              PART
-            end
-
-            def handle_response(response)
-              body = response.read
-              json = JSON.parse(body)
-
-              if json['ok']
-                json['result']
-              else
-                raise APIError.new(json['description'], json['error_code'])
-              end
-            rescue JSON::ParserError
-              raise APIError, "Invalid JSON response: #{body[0..100]}"
-            end
+require 'async'
+require 'async/http'
+require 'json'
+require 'logger'
+require 'mime/types'
+require 'securerandom'
+require 'ostruct'
+
+module Telegem
+  module API
+    class Client
+      BASE_URL = 'https://api.telegram.org'
+
+      attr_reader :token, :logger
+
+      def initialize(token, endpoint: nil, logger: nil)
+        @token = token
+        @logger = logger || Logger.new($stdout)
+        @endpoint = endpoint || Async::HTTP::Endpoint.parse("#{BASE_URL}/bot#{token}")
+        @client = nil
+        @semaphore = Async::Semaphore.new(30)
+      end
+
+      def call(method, params = {})
+        Async do |task|
+          @semaphore.async do
+            make_request(method, clean_params(params))
           end
+        end
+      end
+
+      def upload(method, params)
+        Async do |task|
+          @semaphore.async do
+            make_multipart_request(method, params)
+          end
+        end
+      end
+
+      def get_updates(offset: nil, timeout: 30, limit: 100)
+        params = { timeout: timeout, limit: limit }
+        params[:offset] = offset if offset
+        call('getUpdates', params)
+      end
+
+      def close
+        @client&.close
+      end
+
+      private
 
-          class APIError < StandardError
-            attr_reader :code
+      def make_request(method, params)
+        with_client do |client|
+          headers = { 'content-type' => 'application/json' }
+          body = params.to_json
 
-            def initialize(message, code = nil)
-              super(message)
-              @code = code
-            end
+          response = client.post("/bot#{@token}/#{method}", headers, body)
+          handle_response(response)
+        end
+      end
+
+      def make_multipart_request(method, params)
+        with_client do |client|
+          form = build_multipart(params)
+          headers = form.headers
+
+          response = client.post("/bot#{@token}/#{method}", headers, form.body)
+          handle_response(response)
+        end
+      end
+
+      def with_client(&block)
+        @client ||= Async::HTTP::Client.new(@endpoint)
+        yield @client
+      end
+
+      def clean_params(params)
+        params.reject { |_, v| v.nil? }
+      end
+
+      def build_multipart(params)
+        boundary = SecureRandom.hex(16)
+        parts = []
+
+        params.each do |key, value|
+          if file?(value)
+            parts << part_from_file(key, value, boundary)
+          else
+            parts << part_from_field(key, value, boundary)
           end
         end
-      end
+
+        parts << "--#{boundary}--\r\n"
+
+        body = parts.join
+        headers = {
+          'content-type' => "multipart/form-data; boundary=#{boundary}",
+          'content-length' => body.bytesize.to_s
+        }
+
+        OpenStruct.new(headers: headers, body: body)
+      end
+
+      def file?(value)
+        value.is_a?(File) || 
+        value.is_a?(StringIO) || 
+        (value.is_a?(String) && File.exist?(value))
+      end
+
+      def part_from_file(key, file, boundary)
+        filename = File.basename(file.path) if file.respond_to?(:path)
+        filename ||= "file"
+
+        mime_type = MIME::Types.type_for(filename).first || 'application/octet-stream'
+
+        content = if file.is_a?(String)
+                    File.read(file)
+                  else
+                    file.read
+                  end
+
+        <<~PART
+          --#{boundary}\r
+          Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r
+          Content-Type: #{mime_type}\r
+          \r
+          #{content}\r
+        PART
+      end
+
+      def part_from_field(key, value, boundary)
+        <<~PART
+          --#{boundary}\r
+          Content-Disposition: form-data; name="#{key}"\r
+          \r
+          #{value}\r
+        PART
+      end
+
+      def handle_response(response)
+        body = response.read
+        json = JSON.parse(body)
+
+        if json['ok']
+          json['result']
+        else
+          raise APIError.new(json['description'], json['error_code'])
+        end
+      rescue JSON::ParserError
+        raise APIError, "Invalid JSON response: #{body[0..100]}"
+      end
+    end
+
+    class APIError < StandardError
+      attr_reader :code
+
+      def initialize(message, code = nil)
+        super(message)
+        @code = code
+      end
+    end
+  end
+end

data/lib/core/bot.rb

@@ -22,9 +22,10 @@ module Telegem
         @session_store = options[:session_store] || Session::MemoryStore.new
         @concurrency = options[:concurrency] || 10
         @semaphore = Async::Semaphore.new(@concurrency)
+        @polling_task = nil
+        @running = false
       end
 
-      # DSL Methods
       def command(name, **options, &block)
         pattern = /^\/#{Regexp.escape(name)}(?:@\w+)?(?:\s+(.+))?$/i
 
@@ -59,35 +60,43 @@ module Telegem
         @scenes[id] = Scene.new(id, &block)
       end
 
-      # Async Polling
       def start_polling(**options)
-        Async do |parent|
+        return @polling_task if @running
+        
+        @polling_task = Async do |parent|
+          @running = true
           @logger.info "Starting async polling..."
           offset = nil
 
-          loop do
-            updates = await fetch_updates(offset, **options)
-
-            # Process updates concurrently with limits
-            updates.each do |update|
-              parent.async do |child|
-                @semaphore.async do
-                  await process_update(update)
+          begin
+            loop do
+              updates_task = fetch_updates(offset, **options)
+              updates_data = updates_task.wait
+              updates = updates_data.map { |data| Types::Update.new(data) }
+
+              updates.each do |update|
+                parent.async do |child|
+                  @semaphore.async do
+                    process_update(update)
+                  end
                 end
               end
-            end
 
-            offset = updates.last&.update_id.to_i + 1 if updates.any?
+              offset = updates.last&.update_id.to_i + 1 if updates.any?
+            end
+          rescue => e
+            handle_error(e)
+            raise
+          ensure
+            @running = false
           end
-        rescue => e
-          handle_error(e)
-          raise
         end
+        
+        @polling_task
       end
 
-      # Webhook Support
       def webhook(app = nil, &block)
-        require 'telegem/webhook'
+        require_relative '../../webhook/server'
 
         if block_given?
           Webhook::Server.new(self, &block)
@@ -117,7 +126,6 @@ module Telegem
         end
       end
 
-      # Core Processing
       def process(update_data)
         Async do
           update = Types::Update.new(update_data)
@@ -127,24 +135,29 @@ module Telegem
 
       def shutdown
         @logger.info "Shutting down..."
+        
+        if @polling_task && @polling_task.running?
+          @polling_task.stop
+          @polling_task = nil
+        end
+        
         @api.close
+        @running = false
         @logger.info "Bot stopped"
       end
 
+      def running?
+        @running
+      end
+
       private
 
       def fetch_updates(offset, timeout: 30, limit: 100, allowed_updates: nil)
-        Async do
-          params = { timeout: timeout, limit: limit }
-          params[:offset] = offset if offset
-          params[:allowed_updates] = allowed_updates if allowed_updates
-
-          updates = await @api.get_updates(**params)
-          updates.map { |data| Types::Update.new(data) }
-        rescue API::APIError => e
-          @logger.error "Failed to fetch updates: #{e.message}"
-          []
-        end
+        params = { timeout: timeout, limit: limit }
+        params[:offset] = offset if offset
+        params[:allowed_updates] = allowed_updates if allowed_updates
+
+        @api.get_updates(**params)
       end
 
       def process_update(update)
@@ -169,7 +182,6 @@ module Telegem
       def build_middleware_chain
         chain = Composer.new
 
-        # Add user middleware
         @middleware.each do |middleware_class, args, block|
           if middleware_class.respond_to?(:new)
             middleware = middleware_class.new(*args, &block)
@@ -179,7 +191,6 @@ module Telegem
           end
         end
 
-        # Add session middleware if not already added
         unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
           chain.use(Session::Middleware.new(@session_store))
         end
@@ -196,7 +207,7 @@ module Telegem
             if matches_filters?(ctx, handler[:filters])
               result = handler[:handler].call(ctx)
               result = await(result) if result.is_a?(Async::Task)
-              break  # First matching handler wins
+              break
             end
           end
         end
@@ -251,11 +262,6 @@ module Telegem
         ctx.chat.type == type.to_s
       end
 
-      def webhook_server(**options)
-        require_relative '../webhook/server'
-        Webhook::Server.new(self, **options)
-      end
-
       def matches_command_filter(ctx, command_name)
         return false unless ctx.message&.command?
         ctx.message.command_name == command_name.to_s

data/lib/telegem.rb

@@ -6,7 +6,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.2.5'.freeze
 
   # Define module structure
   module API; end

data/telegem.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
   
   # Read version from lib/telegem.rb
   version_file = File.read('lib/telegem.rb').match(/VERSION\s*=\s*['"]([^'"]+)['"]/)
-  spec.version = version_file ? version_file[1] : "0.1.6"
+  spec.version = version_file ? version_file[1] : "0.2.5"
   
   spec.authors       = ["Phantom"]
   spec.email         = ["ynghosted@icloud.com"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: telegem
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.5
 platform: ruby
 authors:
 - Phantom