telegem 0.2.5 → 1.0.0

data/lib/core/context.rb

@@ -1,3 +1,4 @@
+# lib/core/context.rb - HTTPX VERSION (NO ASYNC GEM)
 module Telegem
   module Core
     class Context
@@ -42,222 +43,227 @@ module Telegem
         inline_query&.query
       end
 
-      # Action methods
+      # Action methods - ALL return HTTPX request objects
       def reply(text, **options)
-        Async do
-          params = { chat_id: chat.id, text: text }.merge(options)
-          await @bot.api.call('sendMessage', params)
-        end
+        return nil unless chat
+        
+        params = { chat_id: chat.id, text: text }.merge(options)
+        @bot.api.call('sendMessage', params)
       end
 
       def edit_message_text(text, **options)
-        return Async::Task.new(nil) unless message
+        return nil unless message && chat
 
-        Async do
-          params = {
-            chat_id: chat.id,
-            message_id: message.message_id,
-            text: text
-          }.merge(options)
+        params = {
+          chat_id: chat.id,
+          message_id: message.message_id,
+          text: text
+        }.merge(options)
 
-          await @bot.api.call('editMessageText', params)
-        end
+        @bot.api.call('editMessageText', params)
       end
 
       def delete_message(message_id = nil)
         mid = message_id || message&.message_id
-        return Async::Task.new(nil) unless mid && chat
+        return nil unless mid && chat
 
-        Async do
-          await @bot.api.call('deleteMessage', chat_id: chat.id, message_id: mid)
-        end
+        @bot.api.call('deleteMessage', chat_id: chat.id, message_id: mid)
       end
 
       def answer_callback_query(text: nil, show_alert: false, **options)
-        return Async::Task.new(nil) unless callback_query
+        return nil unless callback_query
 
-        Async do
-          params = {
-            callback_query_id: callback_query.id,
-            show_alert: show_alert
-          }.merge(options)
+        params = {
+          callback_query_id: callback_query.id,
+          show_alert: show_alert
+        }.merge(options)
 
-          params[:text] = text if text
-          await @bot.api.call('answerCallbackQuery', params)
-        end
+        params[:text] = text if text
+        @bot.api.call('answerCallbackQuery', params)
       end
 
       def answer_inline_query(results, **options)
-        return Async::Task.new(nil) unless inline_query
+        return nil unless inline_query
 
-        Async do
-          params = {
-            inline_query_id: inline_query.id,
-            results: results.to_json
-          }.merge(options)
+        params = {
+          inline_query_id: inline_query.id,
+          results: results.to_json
+        }.merge(options)
 
-          await @bot.api.call('answerInlineQuery', params)
-        end
+        @bot.api.call('answerInlineQuery', params)
       end
 
       # Media methods
       def photo(photo, caption: nil, **options)
-        Async do
-          params = { chat_id: chat.id, caption: caption }.merge(options)
-
-          if file_object?(photo)
-            await @bot.api.upload('sendPhoto', params.merge(photo: photo))
-          else
-            await @bot.api.call('sendPhoto', params.merge(photo: photo))
-          end
+        return nil unless chat
+
+        params = { chat_id: chat.id, caption: caption }.merge(options)
+
+        if file_object?(photo)
+          @bot.api.upload('sendPhoto', params.merge(photo: photo))
+        else
+          @bot.api.call('sendPhoto', params.merge(photo: photo))
         end
       end
 
       def document(document, caption: nil, **options)
-        Async do
-          params = { chat_id: chat.id, caption: caption }.merge(options)
-
-          if file_object?(document)
-            await @bot.api.upload('sendDocument', params.merge(document: document))
-          else
-            await @bot.api.call('sendDocument', params.merge(document: document))
-          end
+        return nil unless chat
+
+        params = { chat_id: chat.id, caption: caption }.merge(options)
+
+        if file_object?(document)
+          @bot.api.upload('sendDocument', params.merge(document: document))
+        else
+          @bot.api.call('sendDocument', params.merge(document: document))
         end
       end
 
       def audio(audio, caption: nil, **options)
-        Async do
-          params = { chat_id: chat.id, caption: caption }.merge(options)
-
-          if file_object?(audio)
-            await @bot.api.upload('sendAudio', params.merge(audio: audio))
-          else
-            await @bot.api.call('sendAudio', params.merge(audio: audio))
-          end
+        return nil unless chat
+
+        params = { chat_id: chat.id, caption: caption }.merge(options)
+
+        if file_object?(audio)
+          @bot.api.upload('sendAudio', params.merge(audio: audio))
+        else
+          @bot.api.call('sendAudio', params.merge(audio: audio))
         end
       end
 
       def video(video, caption: nil, **options)
-        Async do
-          params = { chat_id: chat.id, caption: caption }.merge(options)
-
-          if file_object?(video)
-            await @bot.api.upload('sendVideo', params.merge(video: video))
-          else
-            await @bot.api.call('sendVideo', params.merge(video: video))
-          end
+        return nil unless chat
+
+        params = { chat_id: chat.id, caption: caption }.merge(options)
+
+        if file_object?(video)
+          @bot.api.upload('sendVideo', params.merge(video: video))
+        else
+          @bot.api.call('sendVideo', params.merge(video: video))
         end
       end
 
       def voice(voice, caption: nil, **options)
-        Async do
-          params = { chat_id: chat.id, caption: caption }.merge(options)
-
-          if file_object?(voice)
-            await @bot.api.upload('sendVoice', params.merge(voice: voice))
-          else
-            await @bot.api.call('sendVoice', params.merge(voice: voice))
-          end
+        return nil unless chat
+
+        params = { chat_id: chat.id, caption: caption }.merge(options)
+
+        if file_object?(voice)
+          @bot.api.upload('sendVoice', params.merge(voice: voice))
+        else
+          @bot.api.call('sendVoice', params.merge(voice: voice))
         end
       end
 
       def sticker(sticker, **options)
-        Async do
-          params = { chat_id: chat.id, sticker: sticker }.merge(options)
-          await @bot.api.call('sendSticker', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, sticker: sticker }.merge(options)
+        @bot.api.call('sendSticker', params)
       end
 
       def location(latitude, longitude, **options)
-        Async do
-          params = { 
-            chat_id: chat.id, 
-            latitude: latitude, 
-            longitude: longitude 
-          }.merge(options)
-
-          await @bot.api.call('sendLocation', params)
-        end
+        return nil unless chat
+
+        params = { 
+          chat_id: chat.id, 
+          latitude: latitude, 
+          longitude: longitude 
+        }.merge(options)
+
+        @bot.api.call('sendLocation', params)
       end
 
       def send_chat_action(action, **options)
-        Async do
-          params = { chat_id: chat.id, action: action }.merge(options)
-          await @bot.api.call('sendChatAction', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, action: action }.merge(options)
+        @bot.api.call('sendChatAction', params)
       end
 
       def forward_message(from_chat_id, message_id, **options)
-        Async do
-          params = { 
-            chat_id: chat.id, 
-            from_chat_id: from_chat_id, 
-            message_id: message_id 
-          }.merge(options)
-
-          await @bot.api.call('forwardMessage', params)
-        end
+        return nil unless chat
+
+        params = { 
+          chat_id: chat.id, 
+          from_chat_id: from_chat_id, 
+          message_id: message_id 
+        }.merge(options)
+
+        @bot.api.call('forwardMessage', params)
+      end
+
+      def copy_message(from_chat_id, message_id, **options)
+        return nil unless chat
+
+        params = { 
+          chat_id: chat.id, 
+          from_chat_id: from_chat_id, 
+          message_id: message_id 
+        }.merge(options)
+
+        @bot.api.call('copyMessage', params)
       end
 
+      # Chat management
       def pin_message(message_id, **options)
-        Async do
-          params = { chat_id: chat.id, message_id: message_id }.merge(options)
-          await @bot.api.call('pinChatMessage', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, message_id: message_id }.merge(options)
+        @bot.api.call('pinChatMessage', params)
       end
 
       def unpin_message(**options)
-        Async do
-          params = { chat_id: chat.id }.merge(options)
-          await @bot.api.call('unpinChatMessage', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id }.merge(options)
+        @bot.api.call('unpinChatMessage', params)
       end
 
       def kick_chat_member(user_id, **options)
-        Async do
-          params = { chat_id: chat.id, user_id: user_id }.merge(options)
-          await @bot.api.call('kickChatMember', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, user_id: user_id }.merge(options)
+        @bot.api.call('kickChatMember', params)
       end
 
       def ban_chat_member(user_id, **options)
-        Async do
-          params = { chat_id: chat.id, user_id: user_id }.merge(options)
-          await @bot.api.call('banChatMember', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, user_id: user_id }.merge(options)
+        @bot.api.call('banChatMember', params)
       end
 
       def unban_chat_member(user_id, **options)
-        Async do
-          params = { chat_id: chat.id, user_id: user_id }.merge(options)
-          await @bot.api.call('unbanChatMember', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id, user_id: user_id }.merge(options)
+        @bot.api.call('unbanChatMember', params)
       end
 
       def get_chat_administrators(**options)
-        Async do
-          params = { chat_id: chat.id }.merge(options)
-          await @bot.api.call('getChatAdministrators', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id }.merge(options)
+        @bot.api.call('getChatAdministrators', params)
       end
 
       def get_chat_members_count(**options)
-        Async do
-          params = { chat_id: chat.id }.merge(options)
-          await @bot.api.call('getChatMembersCount', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id }.merge(options)
+        @bot.api.call('getChatMembersCount', params)
       end
 
       def get_chat(**options)
-        Async do
-          params = { chat_id: chat.id }.merge(options)
-          await @bot.api.call('getChat', params)
-        end
+        return nil unless chat
+
+        params = { chat_id: chat.id }.merge(options)
+        @bot.api.call('getChat', params)
       end
 
       # Keyboard helpers
       def keyboard(&block)
-        require 'lib/markup/keyboard'
+        require 'telegem/markup/keyboard'
         Telegem::Markup.keyboard(&block)
       end
 
@@ -267,42 +273,40 @@ module Telegem
       end
 
       def reply_with_keyboard(text, keyboard_markup, **options)
-        Async do
-          reply_markup = keyboard_markup.is_a?(Hash) ? keyboard_markup : keyboard_markup.to_h
-          await reply(text, reply_markup: reply_markup, **options)
-        end
+        return nil unless chat
+
+        reply_markup = keyboard_markup.is_a?(Hash) ? keyboard_markup : keyboard_markup.to_h
+        reply(text, reply_markup: reply_markup, **options)
       end
 
       def reply_with_inline_keyboard(text, inline_markup, **options)
-        Async do
-          reply_markup = inline_markup.is_a?(Hash) ? inline_markup : inline_markup.to_h
-          await reply(text, reply_markup: reply_markup, **options)
-        end
+        return nil unless chat
+
+        reply_markup = inline_markup.is_a?(Hash) ? inline_markup : inline_markup.to_h
+        reply(text, reply_markup: reply_markup, **options)
       end
 
       def remove_keyboard(text = nil, **options)
-        Async do
-          reply_markup = Telegem::Markup.remove(**options.slice(:selective))
-          if text
-            await reply(text, reply_markup: reply_markup, **options.except(:selective))
-          else
-            reply_markup
-          end
+        return nil unless chat
+
+        reply_markup = Telegem::Markup.remove(**options.slice(:selective))
+        if text
+          reply(text, reply_markup: reply_markup, **options.except(:selective))
+        else
+          reply_markup
         end
       end
 
       def edit_message_reply_markup(reply_markup, **options)
-        return Async::Task.new(nil) unless message
+        return nil unless message && chat
 
-        Async do
-          params = {
-            chat_id: chat.id,
-            message_id: message.message_id,
-            reply_markup: reply_markup
-          }.merge(options)
+        params = {
+          chat_id: chat.id,
+          message_id: message.message_id,
+          reply_markup: reply_markup
+        }.merge(options)
 
-          await @bot.api.call('editMessageReplyMarkup', params)
-        end
+        @bot.api.call('editMessageReplyMarkup', params)
       end
 
       # Chat action shortcuts
@@ -327,11 +331,14 @@ module Telegem
       end
 
       def with_typing(&block)
-        Async do
-          await typing
-          result = block.call
-          result.is_a?(Async::Task) ? await(result) : result
-        end
+        # Start typing action
+        typing_request = typing
+        
+        # Execute block
+        result = block.call
+        
+        # Return block's result (could be HTTPX request or nil)
+        result
       end
 
       # Command detection
@@ -345,22 +352,18 @@ module Telegem
 
       # Scene management
       def enter_scene(scene_name, **options)
-        Async do
-          @scene = scene_name
-          if @bot.scenes[scene_name]
-            await @bot.scenes[scene_name].enter(self, **options)
-          end
-        end
+        return nil unless @bot.scenes[scene_name]
+
+        @scene = scene_name
+        @bot.scenes[scene_name].enter(self, **options)
       end
 
       def leave_scene(**options)
-        Async do
-          return unless @scene
-          if @bot.scenes[@scene]
-            await @bot.scenes[@scene].leave(self, **options)
-          end
-          @scene = nil
-        end
+        return nil unless @scene && @bot.scenes[@scene]
+
+        scene_name = @scene
+        @scene = nil
+        @bot.scenes[scene_name].leave(self, **options)
       end
 
       def current_scene
@@ -388,7 +391,7 @@ module Telegem
 
       def file_object?(obj)
         obj.is_a?(File) || obj.is_a?(StringIO) || obj.is_a?(Tempfile) ||
-        (obj.is_a?(String) && File.exist?(obj))
+          (obj.is_a?(String) && File.exist?(obj))
       end
     end
   end

data/lib/core/scene.rb

@@ -1,81 +1,91 @@
-        module Telegem
-          module Core
-            class Scene
-              attr_reader :id, :steps, :enter_callbacks, :leave_callbacks
+# lib/core/scene.rb - HTTPX VERSION (NO ASYNC GEM)
+module Telegem
+  module Core
+    class Scene
+      attr_reader :id, :steps, :enter_callbacks, :leave_callbacks
 
-              def initialize(id, default_step: :start, &block)
-                @id = id
-                @steps = {}
-                @enter_callbacks = []
-                @leave_callbacks = []
-                @default_step = default_step
-                instance_eval(&block) if block_given?
-              end
+      def initialize(id, default_step: :start, &block)
+        @id = id
+        @steps = {}
+        @enter_callbacks = []
+        @leave_callbacks = []
+        @default_step = default_step
+        instance_eval(&block) if block_given?
+      end
 
-              def step(name, &action)
-                @steps[name.to_sym] = action
-                self
-              end
+      def step(name, &action)
+        @steps[name.to_sym] = action
+        self
+      end
 
-              def on_enter(&callback)
-                @enter_callbacks << callback
-                self
-              end
+      def on_enter(&callback)
+        @enter_callbacks << callback
+        self
+      end
 
-              def on_leave(&callback)
-                @leave_callbacks << callback
-                self
-              end
+      def on_leave(&callback)
+        @leave_callbacks << callback
+        self
+      end
 
-              def enter(ctx, step_name = nil)
-                Async do
-                  step_name ||= @default_step
-                  ctx.scene = { id: @id, step: step_name.to_sym }
-                  @enter_callbacks.each { |cb| await(cb.call(ctx)) }
-                  await process_step(ctx, step_name)
-                rescue => e
-                  ctx.logger.error("Error entering scene #{@id}: #{e.message}") 
-                  raise 
-                end
-              end
+      def enter(ctx, step_name = nil)
+        step_name ||= @default_step
+        
+        # Store scene state in context
+        ctx.scene = { id: @id, step: step_name.to_sym }
+        
+        # Run enter callbacks
+        @enter_callbacks.each { |cb| cb.call(ctx) }
+        
+        # Enter the first step
+        process_step(ctx, step_name)
+      end
 
-              def leave(ctx) 
-                Async do 
-                  @leave_callbacks.each { |cb| await(cb.call(ctx)) }
-                  ctx.scene = nil 
-                rescue => e
-                  ctx.logger.error("Error leaving scene #{@id}: #{e.message}")
-                  raise 
-                end
-              end
+      def leave(ctx)
+        # Run leave callbacks
+        @leave_callbacks.each { |cb| cb.call(ctx) }
+        
+        # Clear scene from context
+        ctx.scene = nil
+        nil
+      end
 
-              def process_step(ctx, step_name)
-                Async do 
-                  step = @steps[step_name.to_sym] 
-                  raise "Unknown step #{step_name} in scene #{@id}" unless step 
+      def process_step(ctx, step_name)
+        step = @steps[step_name.to_sym]
+        
+        unless step
+          ctx.logger.error("Unknown step #{step_name} in scene #{@id}")
+          return nil
+        end
+        
+        # Execute the step
+        result = step.call(ctx)
+        
+        # Update step in context (unless step changed it)
+        if ctx.scene && ctx.scene[:id] == @id
+          ctx.scene[:step] = step_name.to_sym
+        end
+        
+        result
+      rescue => e
+        ctx.logger.error("Error processing step #{step_name} in scene #{@id}: #{e.message}")
+        ctx.logger.error(e.backtrace.join("\n")) if e.backtrace
+        nil
+      end
 
-                  result = step.call(ctx)
-                  result = await(result) if result.is_a?(Async::Task)
-                  ctx.scene[:step] = step_name.to_sym
-                  result
-                rescue => e
-                  ctx.logger.error("Error processing step #{step_name} in scene #{@id}: #{e.message}")
-                  raise 
-                end
-              end
+      def current_step(ctx)
+        return nil unless ctx.scene && ctx.scene[:id] == @id
+        ctx.scene[:step]
+      end
 
-              def current_step(ctx)
-                ctx.scene[:step] if ctx.scene && ctx.scene[:id] == @id 
-              end
+      def reset(ctx)
+        ctx.scene = { id: @id, step: @default_step }
+        self
+      end
 
-              def reset(ctx)
-                ctx.scene = { id: @id, step: @default_step }
-                self
-              end
-
-              def to_s
-                "#<Scene #{@id}>"
-              end
-            end
-          end
-        end
+      def to_s
+        "#<Scene #{@id}>"
+      end
+    end
+  end
+end

data/lib/session/memory_store.rb

@@ -1,7 +1,7 @@
 # lib/core/memory_store.rb - Generic in-memory store for caching/rate limiting
 module Telegem
   module Core
-    class MemoryStore
+    class CacheStore
       def initialize(default_ttl: 300) # 5 minutes default
         @store = {}
         @ttls = {}