telegem 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fb8c1bced00447821d2b879718c2ab162cea8ff348970307d620ca31b106df7
-  data.tar.gz: 48034a23e5079b3335bac812bb8a2643478a628e25eee322af6aa16927cbeb41
+  metadata.gz: dc3dc81c673fa1128b108e02c3401f4bac483d7173759b4c901c3db625fa8dd8
+  data.tar.gz: 4cb6de9fa5d9b8c5babbbd83ff86b5b7f6c0161628e74dbb7416ee5eeaa10e70
 SHA512:
-  metadata.gz: dab8827b4606a40ea10f882b774a400c9c32685461b4147a1879987009b4d77ed9efd83571c15923915cdd40e61848533db2c09e74cc3535c00df8bcb1f78ebc
-  data.tar.gz: a5e90efd58279b2cb47b04a7933e42b9281f4e8aba197f12783339984c9b238a85e0f3a34faf75b3fe71137efd9941da4ffa5405b8c76da632fcea62b395d7c5
+  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

@@ -71,7 +71,8 @@ module Telegem
           begin
             loop do
               updates_task = fetch_updates(offset, **options)
-              updates = updates_task.wait
+              updates_data = updates_task.wait
+              updates = updates_data.map { |data| Types::Update.new(data) }
 
               updates.each do |update|
                 parent.async do |child|
@@ -152,17 +153,11 @@ module Telegem
       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)

data/lib/telegem.rb

@@ -6,7 +6,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = '0.2.0'.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.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - Phantom