telegem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62c9d35475ba9320251a3a59954a34a0d0a0cf88e73787c03e493376704c76d5
+  data.tar.gz: 3a0bc3965894c05cc915d687fd546a18dcd958e034e2a674bf28677b8601b1d3
+SHA512:
+  metadata.gz: 46885ed06aba5022c292c213413784d620743400da0ef9220126234a3bb12e83867bf069e7279bdae161ae8fec5eca9cba7936a3826f666505dde516a34b8de8
+  data.tar.gz: 3a1cd8545eb8b7c5b5c8ff4b92e7423e7c1a9e542e5d2200941d7cae9aecb890055a1d9d1371850bd6b0ba816d50c1c929acdebf52aff05fa466f238dec5e002

data/lib/api/client.rb

@@ -0,0 +1,156 @@
+      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
+          end
+
+          class APIError < StandardError
+            attr_reader :code
+
+            def initialize(message, code = nil)
+              super(message)
+              @code = code
+            end
+          end
+        end
+      end

data/lib/api/types.rb

@@ -0,0 +1,190 @@
+module Telegem
+  module Types
+    class BaseType
+      def initialize(data)
+        @_raw_data = data || {}
+      end
+      
+      def method_missing(name, *args)
+        key = name.to_s
+        return @_raw_data[key] if @_raw_data.key?(key)
+        
+        camel_key = snake_to_camel(key)
+        return @_raw_data[camel_key] if @_raw_data.key?(camel_key)
+        
+        super
+      end
+      
+      def respond_to_missing?(name, include_private = false)
+        key = name.to_s
+        camel_key = snake_to_camel(key)
+        @_raw_data.key?(key) || @_raw_data.key?(camel_key) || super
+      end
+      
+      attr_reader :_raw_data
+      
+      private
+      
+      def snake_to_camel(str)
+        str.gsub(/_([a-z])/) { $1.upcase }
+      end
+    end
+    
+    class User < BaseType
+      attr_reader :id, :is_bot, :first_name, :last_name, :username,
+                  :can_join_groups, :can_read_all_group_messages, :supports_inline_queries
+      
+      def initialize(data)
+        super(data)
+        
+        @id = data['id']
+        @is_bot = data['is_bot']
+        @first_name = data['first_name']
+        @last_name = data['last_name']
+        @username = data['username']
+        @can_join_groups = data['can_join_groups']
+        @can_read_all_group_messages = data['can_read_all_group_messages']
+        @supports_inline_queries = data['supports_inline_queries']
+      end
+      
+      def full_name
+        [first_name, last_name].compact.join(' ')
+      end
+      
+      def mention
+        username ? "@#{username}" : first_name
+      end
+    end
+    
+    class Chat < BaseType
+      attr_reader :id, :type, :username, :title
+      
+      def initialize(data)
+        super(data)
+        
+        @id = data['id']
+        @type = data['type']
+        @username = data['username']
+        @title = data['title']
+      end
+      
+      def private?
+        type == 'private'
+      end
+      
+      def group?
+        type == 'group'
+      end
+      
+      def supergroup?
+        type == 'supergroup'
+      end
+      
+      def channel?
+        type == 'channel'
+      end
+    end
+    
+    class MessageEntity < BaseType
+      attr_reader :type, :offset, :length, :url, :user, :language
+      
+      def initialize(data)
+        super(data)
+        
+        @type = data['type']
+        @offset = data['offset']
+        @length = data['length']
+        @url = data['url']
+        @user = User.new(data['user']) if data['user']
+        @language = data['language']
+      end
+    end
+    
+    class Message < BaseType
+      attr_reader :message_id, :from, :chat, :date, :text, :entities,
+                  :reply_markup, :via_bot, :forward_from, :forward_from_chat
+      
+      def initialize(data)
+        super(data)
+        
+        @message_id = data['message_id']
+        @from = User.new(data['from']) if data['from']
+        @chat = Chat.new(data['chat']) if data['chat']
+        @date = Time.at(data['date']) if data['date']
+        @text = data['text']
+        
+        if data['entities']
+          @entities = data['entities'].map { |e| MessageEntity.new(e) }
+        end
+        
+        @reply_markup = data['reply_markup']
+        @via_bot = User.new(data['via_bot']) if data['via_bot']
+        @forward_from = User.new(data['forward_from']) if data['forward_from']
+        @forward_from_chat = Chat.new(data['forward_from_chat']) if data['forward_from_chat']
+      end
+      
+      # FIXED: Proper command detection
+      def command?
+        return false unless text
+        return false unless entities
+        
+        # Find a "bot_command" entity
+        command_entity = entities.find { |e| e.type == 'bot_command' }
+        return false unless command_entity
+        
+        # Extract the command text
+        command_text = text[command_entity.offset, command_entity.length]
+        command_text&.start_with?('/')
+      end
+      
+      def command_name
+        return nil unless command?
+        
+        command_entity = entities.find { |e| e.type == 'bot_command' }
+        return nil unless command_entity
+        
+        cmd = text[command_entity.offset, command_entity.length]
+        cmd = cmd[1..-1]  # Remove "/"
+        cmd = cmd.split('@').first  # Remove bot username
+        cmd
+      end
+      
+      def command_args
+        return nil unless command?
+        
+        command_entity = entities.find { |e| e.type == 'bot_command' }
+        return nil unless command_entity
+        
+        # Text after the command entity
+        args_start = command_entity.offset + command_entity.length
+        text[args_start..-1]&.strip
+      end
+    end
+    
+    class CallbackQuery < BaseType
+      attr_reader :id, :from, :message, :data, :chat_instance
+      
+      def initialize(data)
+        super(data)
+        
+        @id = data['id']
+        @from = User.new(data['from']) if data['from']
+        @message = Message.new(data['message']) if data['message']
+        @data = data['data']
+        @chat_instance = data['chat_instance']
+      end
+    end
+    
+    class Update < BaseType
+      attr_reader :update_id, :message, :callback_query
+      
+      def initialize(data)
+        super(data)
+        
+        @update_id = data['update_id']
+        @message = Message.new(data['message']) if data['message']
+        @callback_query = CallbackQuery.new(data['callback_query']) if data['callback_query']
+      end
+    end
+  end
+end

data/lib/core/bot.rb

@@ -0,0 +1,275 @@
+module Telegem
+  module Core
+    class Bot
+      attr_reader :token, :api, :handlers, :middleware, :logger, :scenes
+
+      def initialize(token, **options)
+        @token = token
+        @api = API::Client.new(token, **options.slice(:endpoint, :logger))
+        @handlers = {
+          message: [],
+          callback_query: [],
+          inline_query: [],
+          chat_member: [],
+          poll: [],
+          pre_checkout_query: [],
+          shipping_query: []
+        }
+        @middleware = []
+        @scenes = {}
+        @logger = options[:logger] || Logger.new($stdout)
+        @error_handler = nil
+        @session_store = options[:session_store] || Session::MemoryStore.new
+        @concurrency = options[:concurrency] || 10
+        @semaphore = Async::Semaphore.new(@concurrency)
+      end
+
+      # DSL Methods
+      def command(name, **options, &block)
+        pattern = /^\/#{Regexp.escape(name)}(?:@\w+)?(?:\s+(.+))?$/i
+
+        on(:message, text: pattern) do |ctx|
+          ctx.match = ctx.message.text.match(pattern)
+          ctx.state[:command_args] = ctx.match[1] if ctx.match
+          block.call(ctx)
+        end
+      end
+
+      def hears(pattern, **options, &block)
+        on(:message, text: pattern) do |ctx|
+          ctx.match = ctx.message.text.match(pattern)
+          block.call(ctx)
+        end
+      end
+
+      def on(type, filters = {}, &block)
+        @handlers[type] << { filters: filters, handler: block }
+      end
+
+      def use(middleware, *args, &block)
+        @middleware << [middleware, args, block]
+        self
+      end
+
+      def error(&block)
+        @error_handler = block
+      end
+
+      def scene(id, &block)
+        @scenes[id] = Scene.new(id, &block)
+      end
+
+      # Async Polling
+      def start_polling(**options)
+        Async do |parent|
+          @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)
+                end
+              end
+            end
+
+            offset = updates.last&.update_id.to_i + 1 if updates.any?
+          end
+        rescue => e
+          handle_error(e)
+          raise
+        end
+      end
+
+      # Webhook Support
+      def webhook(app = nil, &block)
+        require 'telegem/webhook'
+
+        if block_given?
+          Webhook::Server.new(self, &block)
+        elsif app
+          Webhook::Middleware.new(self, app)
+        else
+          Webhook::Server.new(self)
+        end
+      end
+
+      def set_webhook(url, **options)
+        Async do
+          params = { url: url }.merge(options)
+          await @api.call('setWebhook', params)
+        end
+      end
+
+      def delete_webhook
+        Async do
+          await @api.call('deleteWebhook', {})
+        end
+      end
+
+      def get_webhook_info
+        Async do
+          await @api.call('getWebhookInfo', {})
+        end
+      end
+
+      # Core Processing
+      def process(update_data)
+        Async do
+          update = Types::Update.new(update_data)
+          await process_update(update)
+        end
+      end
+
+      def shutdown
+        @logger.info "Shutting down..."
+        @api.close
+        @logger.info "Bot stopped"
+      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
+      end
+
+      def process_update(update)
+        Async do
+          ctx = Context.new(update, self)
+
+          begin
+            await run_middleware_chain(ctx) do |context|
+              await dispatch_to_handlers(context)
+            end
+          rescue => e
+            await handle_error(e, ctx)
+          end
+        end
+      end
+
+      def run_middleware_chain(ctx, &final)
+        chain = build_middleware_chain
+        chain.call(ctx, &final)
+      end
+
+      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)
+            chain.use(middleware)
+          else
+            chain.use(middleware_class)
+          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
+
+        chain
+      end
+
+      def dispatch_to_handlers(ctx)
+        Async do
+          update_type = detect_update_type(ctx.update)
+          handlers = @handlers[update_type] || []
+
+          handlers.each do |handler|
+            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
+            end
+          end
+        end
+      end
+
+      def detect_update_type(update)
+        return :message if update.message
+        return :callback_query if update.callback_query
+        return :inline_query if update.inline_query
+        return :chat_member if update.chat_member
+        return :poll if update.poll
+        return :pre_checkout_query if update.pre_checkout_query
+        return :shipping_query if update.shipping_query
+        :unknown
+      end
+
+      def matches_filters?(ctx, filters)
+        return true if filters.empty?
+
+        filters.all? do |key, value|
+          case key
+          when :text
+            matches_text_filter(ctx, value)
+          when :chat_type
+            matches_chat_type_filter(ctx, value)
+          when :command
+            matches_command_filter(ctx, value)
+          else
+            if value.respond_to?(:call)
+              result = value.call(ctx)
+              result = await(result) if result.is_a?(Async::Task)
+              result
+            else
+              ctx.update.send(key) == value
+            end
+          end
+        end
+      end
+
+      def matches_text_filter(ctx, pattern)
+        return false unless ctx.message&.text
+
+        if pattern.is_a?(Regexp)
+          ctx.message.text.match?(pattern)
+        else
+          ctx.message.text.include?(pattern.to_s)
+        end
+      end
+
+      def matches_chat_type_filter(ctx, type)
+        return false unless ctx.chat
+        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
+      end
+
+      def handle_error(error, ctx = nil)
+        if @error_handler
+          result = @error_handler.call(error, ctx)
+          await(result) if result.is_a?(Async::Task)
+        else
+          @logger.error("Unhandled error: #{error.class}: #{error.message}")
+          @logger.error(error.backtrace.join("\n")) if error.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/core/composer.rb

@@ -0,0 +1,40 @@
+module Telegem
+  module Core
+    class Composer
+      def initialize
+        @middleware = []
+      end
+
+      def use(middleware)
+        @middleware << middleware
+        self
+      end
+
+      def call(ctx, &final)
+        return final.call(ctx) if @middleware.empty?
+
+        # Build async-aware chain
+        chain = final
+
+        @middleware.reverse_each do |middleware|
+          chain = ->(context) do
+            if middleware.respond_to?(:call)
+              result = middleware.call(context, chain)
+              result.is_a?(Async::Task) ? result : Async::Task.new(result)
+            elsif middleware.is_a?(Class)
+              instance = middleware.new
+              result = instance.call(context, chain)
+              result.is_a?(Async::Task) ? result : Async::Task.new(result)
+            else
+              raise "Invalid middleware: #{middleware.class}"
+            end
+          end
+        end
+
+        # Execute the chain
+        chain.call(ctx)
+      end
+
+      def empty?
+        @middleware.empty?
+      end