telegem 3.0.6 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b1fc2ee7549822e2fbf1a1808f49e274de5a1d1f40be2acd3829087f10e2ace
-  data.tar.gz: cf376724f4cd390e690cdaea90eace022eb555ea325416c017ad8a83523b2de9
+  metadata.gz: 5551464d15fac54752c3b598184502f34b986ff5450c9afc11dda12e582bc90a
+  data.tar.gz: 80e223030e618a3e2f997cb15e8692ea7f74b620035a3fdeebe795c42c8422f6
 SHA512:
-  metadata.gz: c1fcf41f167133dfe32d92e7a903b1644b070f9d9544e9cf3de5475a06c6e7c4583770d9df0bea92d0729858700bfc0b955b82b7ec633afef967397e57e25362
-  data.tar.gz: ef730bff829458909631028f04cc794cbad161be022ac0218521f11083d36fafb40ea6b18e10fab3e13c4f6501e7696942ea4ba2e697d470d9508186b73812d9
+  metadata.gz: 0604f9c803fdddd15e90f2b187404173bd512a827c262cb82a31a9f642a3595033a8415fadba3197c8bd9b12347686b1bf3d8fdc53ba973b43cce03db56bcc05
+  data.tar.gz: 81bd29e6218605f201b98d51d30cfe9650fbafb1b7c1645a257ccb946b6d2bec8e9b7fad2668c6c1daa057bae7f4dbc8711dbd3698ada5dfc402c2fc0f82205c

data/lib/core/bot.rb

@@ -255,7 +255,7 @@ end
         if update.message&.text && @logger
          user = update.message.from
          cmd = update.message.text.split.first
-         @logger.info("#{cmd} - #{user.username || user.first_name}")
+         @logger.info("#{cmd} - #{user.username}")
         end
   
           ctx = Context.new(update, self)
@@ -287,12 +287,20 @@ end
           end
         end
         
-        unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
-          chain.use(Session::Middleware.new(@session_store))
-        end
-        
-        chain
-      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
       
       def dispatch_to_handlers(ctx)
         update_type = detect_update_type(ctx.update)

data/lib/core/context.rb

@@ -321,7 +321,43 @@ module Telegem
       def uploading_document(**options)
         send_chat_action('upload_document', **options)
       end
-      
+      def scene 
+        session[:telegem_scene]&.[](:id)
+      end 
+      def ask(question, **options)
+        scene_data = session[:telegem_scene]
+        if scene_data
+          scene_data[:waiting_for_response] = true 
+          scene_data[:last_question] = question
+        end 
+        reply(question, **options) 
+      end 
+      def scene_data 
+        @session[:telegem_scene]&.[](:data) || {} 
+      end 
+      def current_scene
+        @session[:telegem_scene]&.[](:id)
+      end 
+      def in_scene?
+        !current_scene.nil?
+      end 
+      def leave_scene(**options)
+        scene_data = @session[:telegem_scene] 
+        return unless scene_data 
+        scene_id = scene_data[:id].to_sym 
+        scene = @bot.scenes[scene_id] 
+        result = scene&.leave(self, options[:reason] || :manual) 
+        @session.delete(:telegem_scene)
+        @scene = nil 
+        result
+      end 
+      def next_step(step_name = nil)
+        scene_data = @session[:telegem_scene]
+        return unless scene_data
+        scene_id = scene_data[:id].to_sym 
+        scene = @bot.scenes[scene_id] 
+        scene&.next_step(self, step_name) 
+       end 
       def with_typing(&block)
         typing_request = typing
         
@@ -339,23 +375,12 @@ module Telegem
       end
       
       def enter_scene(scene_name, **options)
-        return nil unless @bot.scenes[scene_name]
-        
-        @scene = scene_name
-        @bot.scenes[scene_name].enter(self, **options)
-      end
-      
-      def leave_scene(**options)
-        return nil unless @scene && @bot.scenes[@scene]
-        
-        scene_name = @scene
-        @scene = nil
-        @bot.scenes[scene_name].leave(self, **options)
-      end
-      
-      def current_scene
-        @bot.scenes[@scene] if @scene
-      end
+        scene = @bot.scenes[scene_name]
+        return nil unless scene
+        leave_scene if in_scene?
+        scene.enter(self, options[:step], options.except(:step))
+         scene_name
+      end 
       
       def logger
         @bot.logger

data/lib/core/rate_limit.rb

@@ -0,0 +1,100 @@
+
+module Telegem
+  class RateLimit
+    def initialize(**options)
+      @options = {
+        global: { max: 30, per: 1 },    # 30 reqs/second globally
+        user: { max: 5, per: 10 },      # 5 reqs/10 seconds per user
+        chat: { max: 20, per: 60 }      # 20 reqs/minute per chat
+      }.merge(options)
+      
+      @counters = {
+        global: Telegem::Session::MemoryStore.new,
+        user: Telegem::Session::MemoryStore.new,
+        chat: Telegem::Session::MemoryStore.new
+      }
+    end
+    
+    def call(ctx, next_middleware)
+      return next_middleware.call(ctx) unless should_rate_limit?(ctx)
+      
+      if limit_exceeded?(ctx)
+        ctx.logger&.warn("Rate limit exceeded for #{ctx.from&.id}")
+        return rate_limit_response(ctx)
+      end
+      
+      increment_counters(ctx)
+      next_middleware.call(ctx)
+    end
+    
+    private
+    
+    def should_rate_limit?(ctx)
+      
+      return false if ctx.update.poll?
+      return false if ctx.update.chat_member?
+      return true
+    end
+    
+    def limit_exceeded?(ctx)
+      global_limit?(ctx) || user_limit?(ctx) || chat_limit?(ctx)
+    end
+    
+    def global_limit?(ctx)
+      check_limit(:global, "global", ctx)
+    end
+    
+    def user_limit?(ctx)
+      return false unless ctx.from&.id
+      check_limit(:user, "user:#{ctx.from.id}", ctx)
+    end
+    
+    def chat_limit?(ctx)
+      return false unless ctx.chat&.id
+      check_limit(:chat, "chat:#{ctx.chat.id}", ctx)
+    end
+    
+    def check_limit(type, key, ctx)
+      limit = @options[type]
+      return false unless limit
+      
+      counter = @counters[type].get(key) || 0
+      counter >= limit[:max]
+    end
+    
+    def increment_counters(ctx)
+      now = Time.now.to_i
+      
+      
+      if @options[:global]
+        key = "global"
+        cleanup_counter(:global, key, now)
+        @counters[:global].increment(key, 1, ttl: @options[:global][:per])
+      end
+      
+      
+      if @options[:user] && ctx.from&.id
+        key = "user:#{ctx.from.id}"
+        cleanup_counter(:user, key, now)
+        @counters[:user].increment(key, 1, ttl: @options[:user][:per])
+      end
+      
+      
+      if @options[:chat] && ctx.chat&.id
+        key = "chat:#{ctx.chat.id}"
+        cleanup_counter(:chat, key, now)
+        @counters[:chat].increment(key, 1, ttl: @options[:chat][:per])
+      end
+    end
+    
+    def cleanup_counter(type, key, now)
+      
+    end
+    
+    def rate_limit_response(ctx)
+      
+      ctx.reply("⏳ Please wait a moment before sending another request.") rescue nil
+      nil
+    end
+  end
+end

data/lib/core/scene.rb

@@ -1,90 +1,157 @@
-# 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
+        @timeout = 300  # 5 minutes default timeout
+        
         instance_eval(&block) if block_given?
       end
-
+      
       def step(name, &action)
         @steps[name.to_sym] = action
         self
       end
-
+      
       def on_enter(&callback)
         @enter_callbacks << callback
         self
       end
-
+      
       def on_leave(&callback)
         @leave_callbacks << callback
         self
       end
-
-      def enter(ctx, step_name = nil)
+      
+      def timeout(seconds)
+        @timeout = seconds
+        self
+      end
+      
+  
+      def enter(ctx, step_name = nil, **initial_data)
         step_name ||= @default_step
         
-        # Store scene state in context
-        ctx.scene = { id: @id, step: step_name.to_sym }
+      
+        ctx.session[:telegem_scene] = {
+          id: @id.to_s,
+          step: step_name.to_s,
+          data: initial_data,
+          entered_at: Time.now.to_i,
+          timeout: @timeout,
+          waiting_for_response: false,
+          last_question: nil
+        }
         
-        # Run enter callbacks
+        ctx.instance_variable_set(:@current_scene, self)
+
         @enter_callbacks.each { |cb| cb.call(ctx) }
         
-        # Enter the first step
-        process_step(ctx, step_name)
-      end
 
-      def leave(ctx)
-        # Run leave callbacks
-        @leave_callbacks.each { |cb| cb.call(ctx) }
-        
-        # Clear scene from context
-        ctx.scene = nil
-        nil
+        execute_step(ctx, step_name)
       end
+      
 
-      def process_step(ctx, step_name)
-        step = @steps[step_name.to_sym]
+      def process(ctx)
+        scene_data = ctx.session[:telegem_scene]
+        return unless scene_data
         
-        unless step
-          ctx.logger.error("Unknown step #{step_name} in scene #{@id}")
-          return nil
+
+        if Time.now.to_i - scene_data[:entered_at] > scene_data[:timeout]
+          leave(ctx, :timeout)
+          return
         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
+        if scene_data[:waiting_for_response] && ctx.message&.text
+          process_response(ctx, scene_data)
+        else
+
+          execute_step(ctx, scene_data[:step])
         end
+      end
+
+      def leave(ctx, reason = :manual)
+        scene_data = ctx.session.delete(:telegem_scene)
+        ctx.instance_variable_set(:@current_scene, nil)
         
-        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
+
+        @leave_callbacks.each { |cb| cb.call(ctx, reason, scene_data[:data]) }
+        
+        scene_data[:data]
       end
+      
 
       def current_step(ctx)
-        return nil unless ctx.scene && ctx.scene[:id] == @id
-        ctx.scene[:step]
+        scene_data = ctx.session[:telegem_scene]
+        scene_data[:step] if scene_data
+      end
+      
+      
+      def scene_data(ctx)
+        ctx.session[:telegem_scene]&.[](:data) || {}
       end
+      
+      private
 
-      def reset(ctx)
-        ctx.scene = { id: @id, step: @default_step }
-        self
+      def execute_step(ctx, step_name)
+        action = @steps[step_name.to_sym]
+        return leave(ctx, :invalid_step) unless action
+
+        scene_data = ctx.session[:telegem_scene]
+        scene_data[:step] = step_name.to_s
+        scene_data[:waiting_for_response] = false
+        scene_data[:last_question] = nil
+        
+       
+        result = action.call(ctx, scene_data[:data])
+        
+
+        if result.is_a?(Symbol) || result.is_a?(String)
+          next_step(ctx, result)
+        end
+        
+        result
       end
+      
+      
+      def process_response(ctx, scene_data)
 
-      def to_s
-        "#<Scene #{@id}>"
+        current_step_name = scene_data[:step]
+        scene_data[:data][current_step_name] = ctx.message.text
+        
+  
+        scene_data[:waiting_for_response] = false
+        
+        next_step(ctx)
+      end
+      
+
+      def next_step(ctx, specific_step = nil)
+        scene_data = ctx.session[:telegem_scene]
+        return unless scene_data
+        
+        current_step = scene_data[:step].to_sym
+        step_names = @steps.keys
+        
+        if specific_step
+          next_step_name = specific_step.to_sym
+        else
+          current_index = step_names.index(current_step)
+          next_step_name = step_names[current_index + 1] if current_index
+        end
+        
+        if next_step_name
+          execute_step(ctx, next_step_name)
+        else
+          leave(ctx, :completed)
+        end
       end
     end
   end

data/lib/plugins/file_extract.rb

@@ -0,0 +1,127 @@
+require 'open-uri'
+require 'tempfile'
+require 'pdf-reader'
+require 'docx'
+
+module Telegem
+  module Plugins
+    class FileExtractor
+      SUPPORTED_TYPES = {
+        pdf: 'application/pdf',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        txt: 'text/plain',
+        csv: 'text/csv',
+        html: 'text/html',
+        rtf: 'application/rtf',
+        odt: 'application/vnd.oasis.opendocument.text'
+      }
+      
+      def initialize(**options)
+        @options = {
+          max_size: 10 * 1024 * 1024,
+          timeout: 30,
+          cache: true
+        }.merge(options)
+        
+        @cache = Telegem::Session::MemoryStore.new
+      end
+      
+      def call(ctx, next_middleware)
+        ctx.define_singleton_method(:extract_file_text) do |file_id = nil, **opts|
+          extract_from_context(self, file_id, opts)
+        end
+        
+        ctx.define_singleton_method(:file_content) do
+          @_file_content
+        end
+        
+        ctx.define_singleton_method(:file_metadata) do
+          @_file_metadata
+        end
+        
+        next_middleware.call(ctx)
+      end
+      
+      class << self
+        def extract_from_context(ctx, file_id = nil, **options)
+          message = ctx.update.message
+          return nil unless message
+          
+          file_info = find_file_info(message, file_id)
+          return nil unless file_info
+          
+          return file_info[:content] if file_info[:type] == :text
+          
+          file_path = download_file(ctx.bot.api, file_info[:file_id], options)
+          return nil unless file_path
+          
+          text = extract_text(file_path, file_info[:type])
+          
+          if options.fetch(:cache, true)
+            ctx.instance_variable_set(:@_file_content, text)
+            ctx.instance_variable_set(:@_file_metadata, file_info)
+          end
+          
+          text
+        end
+        
+        private
+        
+        def find_file_info(message, file_id)
+          return { file_id: file_id, type: :unknown } if file_id
+          
+          if message.document
+            mime = message.document.mime_type || 'application/octet-stream'
+            type = SUPPORTED_TYPES.key(mime) || :unknown
+            { file_id: message.document.file_id, type: type, mime: mime, name: message.document.file_name }
+          elsif message.photo&.any?
+            { file_id: message.photo.last.file_id, type: :image, mime: 'image/jpeg' }
+          elsif message.video
+            { file_id: message.video.file_id, type: :video, mime: message.video.mime_type }
+          elsif message.audio
+            { file_id: message.audio.file_id, type: :audio, mime: message.audio.mime_type }
+          elsif message.voice
+            { file_id: message.voice.file_id, type: :audio, mime: 'audio/ogg' }
+          elsif message.text
+            { type: :text, content: message.text }
+          end
+        end
+        
+        def download_file(api, file_id, options)
+          file = api.call('getFile', file_id: file_id)
+          return nil unless file && file['ok']
+          
+          file_path = file['result']['file_path']
+          url = "https://api.telegram.org/file/bot#{api.token}/#{file_path}"
+          
+          temp_file = Tempfile.new(['telegem', File.extname(file_path)])
+          
+          URI.open(url, read_timeout: options[:timeout] || 30) do |remote|
+            temp_file.binmode
+            temp_file.write(remote.read)
+          end
+          
+          temp_file.close
+          temp_file.path
+        rescue => e
+          nil
+        end
+        
+        def extract_text(file_path, type)
+          case type
+          when :pdf
+            PDF::Reader.new(file_path).pages.map(&:text).join("\n")
+          when :docx
+            Docx::Document.open(file_path).text
+          when :txt, :html, :csv, :rtf, :odt
+            File.read(file_path, encoding: 'utf-8')
+          else
+            ""
+          end
+        rescue => e
+          "Error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/session/scene_middleware.rb

@@ -0,0 +1,23 @@
+
+module Telegem
+  module Scene
+    class Middleware
+      def call(ctx, next_middleware)
+        # Check if user is in a scene
+        if ctx.session[:telegem_scene]
+          scene_data = ctx.session[:telegem_scene]
+          scene = ctx.bot.scenes[scene_data[:id].to_sym]
+          
+          if scene
+            # Let scene handle it
+            scene.process(ctx)
+            return  # Don't call regular handlers
+          end
+        end
+        
+        # Not in scene, proceed normally
+        next_middleware.call(ctx)
+      end
+    end
+  end
+end

data/lib/telegem.rb

@@ -3,7 +3,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = "3.0.6".freeze 
+  VERSION = "3.1.0".freeze 
 end
 
 # Load core components
@@ -17,6 +17,8 @@ require_relative 'session/middleware'
 require_relative 'session/memory_store'
 require_relative 'markup/keyboard'
 # Webhook is loaded lazily when needed
+require_relative 'plugins/file_extract'
+require_relative 'session/scene_middleware'
 
 module Telegem
   # Main entry point: Telegem.new(token)
@@ -80,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.0.6
+  version: 3.1.0
 platform: ruby
 authors:
 - sick_phantom
@@ -13,98 +13,72 @@ dependencies:
   name: httpx
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: pdf-reader
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: async
+  name: docx
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -119,34 +93,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.18'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.18'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -197,11 +143,15 @@ files:
 - lib/core/bot.rb
 - lib/core/composer.rb
 - lib/core/context.rb
+- lib/core/rate_limit.rb
 - lib/core/scene.rb
 - lib/markup/.gitkeep
 - lib/markup/keyboard.rb
+- lib/plugins/.gitkeep
+- lib/plugins/file_extract.rb
 - lib/session/memory_store.rb
 - lib/session/middleware.rb
+- lib/session/scene_middleware.rb
 - lib/telegem.rb
 - lib/webhook/.gitkeep
 - lib/webhook/server.rb
@@ -216,7 +166,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.0.6!\n\n\U0001F4DA Documentation:
+post_install_message: "Thanks for installing Telegem 3.1.0!\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"