telegem 3.2.2 → 3.3.0

data/lib/markup/keyboard.rb

@@ -1,311 +1,100 @@
 module Telegem
   module Markup
-    class Keyboard
-      attr_reader :buttons, :options
 
-      def initialize(buttons = [], **options)
-        @buttons = buttons
+    module ReplyButtons
+      def text(content, style: nil, icon_custom_emoji_id: nil)
+        {
+          text: content,
+          icon_custom_emoji_id: icon_custom_emoji_id,
+          style: style
+      }.compact
+    end
+    def request_contact(text, style: nil, icon_custom_emoji_id: nil)
+      {
+        text: text,
+        style: style,
+        icon_custom_emoji_id: icon_custom_emoji_id,
+        request_contact: true
+    }.compact
+    end
+    def request_location(text, style: nil, icon_custom_emoji_id:  nil)
+      {
+        text: text,
+        style: style,
+        icon_custom_emoji_id: icon_custom_emoji_id,
+        request_location: true
+    }.compact
+  end 
+  def request_poll(text, poll_type: nil, style: nil, icon_custom_emoji_id: nil)
+    {
+      text: text,
+      style: style,
+      icon_custom_emoji_id: icon_custom_emoji_id,
+      request_poll: poll_type ? { type: poll_type } : {}
+    }.compact
+  end
+  def web_app(text, url: nil, style: nil, icon_custom_emoji_id: nil)
+    {
+      text: text,
+      url: url,
+      style: style,
+      icon_custom_emoji_id: icon_custom_emoji_id
+    }.compact
+  end
+end
+    class ReplyBuilder
+      include ReplyButtons
+      def initialize
+        @rows = []
         @options = {
           resize_keyboard: true,
           one_time_keyboard: false,
           selective: false
-        }.merge(options)
-      end
-
-      def self.[](*rows)
-        new(rows)
-      end
-
-      def self.build(&block)
-        builder = Builder.new
-        builder.instance_eval(&block) if block_given?
-        builder.keyboard
-      end
-
-      def row(*buttons)
-        @buttons << buttons.flatten
-        self
-      end
-
-      def button(text, **options)
-        if @buttons.empty? || !@buttons.last.is_a?(Array)
-          @buttons << [{ text: text }.merge(options)]
-        else
-          @buttons.last << { text: text }.merge(options)
-        end
-        self
-      end
-
-      def request_contact(text)
-        button(text, request_contact: true)
-      end
-
-      def request_location(text)
-        button(text, request_location: true)
-      end
-
-      def request_poll(text, type = nil)
-        opts = type ? { request_poll: { type: type } } : { request_poll: {} }
-        button(text, opts)
-      end
-
-      def resize(resize = true)
-        @options[:resize_keyboard] = resize
-        self
-      end
-
-      def one_time(one_time = true)
-        @options[:one_time_keyboard] = one_time
-        self
-      end
-
-      def selective(selective = true)
-        @options[:selective] = selective
-        self
-      end
-
-      def to_h
-        {
-          keyboard: @buttons.map { |row| row.is_a?(Array) ? row : [row] },
-          **@options
-        }
-      end
-
-      def to_json(*args)
-        to_h.to_json(*args)
-      end
-
-      def self.remove(selective: false)
-        {
-          remove_keyboard: true,
-          selective: selective
-        }
-      end
-
-      def self.force_reply(selective: false, input_field_placeholder: nil)
-        markup = {
-          force_reply: true,
-          selective: selective
         }
-        markup[:input_field_placeholder] = input_field_placeholder if input_field_placeholder
-        markup
-      end
-    end
-
-    class InlineKeyboard
-      attr_reader :buttons
-
-      def initialize(buttons = [])
-        @buttons = buttons
-      end
-
-      def self.[](*rows)
-        new(rows)
-      end
-
-      def self.build(&block)
-        builder = InlineBuilder.new
-        builder.instance_eval(&block) if block_given?
-        builder.keyboard
       end
-
       def row(*buttons)
-        @buttons << buttons.flatten
-        self
-      end
-
-      def button(text, **options)
-        if @buttons.empty? || !@buttons.last.is_a?(Array)
-          @buttons << [{ text: text }.merge(options)]
-        else
-          @buttons.last << { text: text }.merge(options)
-        end
-        self
-      end
-
-      def url(text, url)
-        button(text, url: url)
-      end
-
-      def callback(text, data)
-        button(text, callback_data: data)
-      end
-
-      def web_app(text, url)
-        button(text, web_app: { url: url })
-      end
-
-      def login(text, url, **options)
-        button(text, login_url: { url: url, **options })
-      end
-
-      def switch_inline(text, query = "")
-        button(text, switch_inline_query: query)
-      end
-
-      def switch_inline_current(text, query = "")
-        button(text, switch_inline_query_current_chat: query)
-      end
-
-      def pay(text)
-        button(text, pay: true)
-      end
-
-      def to_h
-        clean_rows = @buttons.compact.map do |row| 
-          row = Array(row).compact.select { |btn| is_a?(Hash) }
-          row.empty? ? nil : row 
-        end.compact 
-         { inline_keyboard: clean_rows} 
-      end 
-   
-      def to_json(*args)
-        to_h.to_json(*args)
-      end
-    end
-
-    class Builder
-      attr_reader :keyboard
-
-      def initialize
-        @keyboard = Keyboard.new
-      end
-
-      def row(*buttons, &block)
-        if block_given?
-          sub_builder = Builder.new
-          sub_builder.instance_eval(&block)
-          @keyboard.row(*sub_builder.keyboard.buttons.flatten(1))
-        elsif buttons.any?
-          @keyboard.row(*buttons)
-        else
-          @keyboard.row
-        end
+        @rows << buttons
         self
       end
-
-      def button(text, **options)
-        @keyboard.button(text, **options)
+      def resize(value = true)
+        @options[:resize_keyboard] = value
         self
       end
-
-      def request_contact(text)
-        @keyboard.request_contact(text)
+      def one_time(value = true)
+        @options[:one_time_keyboard] = value
         self
       end
-
-      def request_location(text)
-        @keyboard.request_location(text)
+      def selective(value = true)
+        @options[:selective] = value
         self
       end
-
-      def request_poll(text, type = nil)
-        @keyboard.request_poll(text, type)
+      def placeholder(text)
+        @options[:input_field_placeholder] = text
         self
       end
-
-      def method_missing(name, *args, &block)
-        if @keyboard && @keyboard.respond_to?(name)
-          @keyboard.send(name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        @keyboard && @keyboard.respond_to?(name) || super
-      end
+      def build
+        ReplyKeyboard.new(@rows, @options)
     end
-
-    class InlineBuilder
-      attr_reader :keyboard
-
-      def initialize
-        @keyboard = InlineKeyboard.new
-      end
-
-      def row(*buttons, &block)
-        if block_given?
-          sub_builder = InlineBuilder.new
-          sub_builder.instance_eval(&block)
-          @keyboard.row(*sub_builder.keyboard.buttons.flatten(1))
-        elsif buttons.any?
-          @keyboard.row(*buttons)
-        else
-          @keyboard.row([]) 
+  end 
+      class ReplyKeyboard
+        def initialize(rows, options = {})
+          @rows = rows
+          @options = options
         end
-        self
-      end
-
-      def button(text, **options)
-        @keyboard.button(text, **options)
-        self
-      end
-
-      def url(text, url)
-        @keyboard.url(text, url)
-        self
-      end
-
-      def callback(text, data)
-        @keyboard.callback(text, data)
-        self
-      end
-
-      def web_app(text, url)
-        @keyboard.web_app(text, url)
-        self
-      end
-
-      def login(text, url, **options)
-        @keyboard.login(text, url, **options)
-        self
-      end
-
-      def switch_inline(text, query = "")
-        @keyboard.switch_inline(text, query)
-        self
-      end
-
-      def switch_inline_current(text, query = "")
-        @keyboard.switch_inline_current(text, query)
-        self
-      end
-
-      def pay(text)
-        @keyboard.pay(text)
-        self
-      end
-
-      def method_missing(name, *args, &block)
-        if @keyboard && @keyboard.respond_to?(name)
-          @keyboard.send(name, *args, &block)
-        else
-          super
+        def to_h
+          {
+            keyboard: @rows
+        }.merge(@options)
         end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        @keyboard && @keyboard.respond_to?(name) || super
-      end
-    end
-
-    class << self
-      def keyboard(&block)
-        Keyboard.build(&block)
-      end
-
-      def inline(&block)
-        InlineKeyboard.build(&block)
-      end
-
-      def remove(**options)
-        Keyboard.remove(**options)
-      end
-
-      def force_reply(**options)
-        Keyboard.force_reply(**options)
-      end
-    end
-  end
-end
+        def to_json(*args)
+          to_h.to_json(*args)
+        end 
+      end 
+      def self.keyboard(&block)
+        builder = ReplyBuilder.new
+        builder.instance_eval(&block) if block_given?
+        builder.build
+      end 
+    end 
+  end 
+    

data/lib/plugins/file_extract.rb

@@ -85,28 +85,8 @@ module Telegem
             success: false,
             error: "Failed to extract PDF: #{e.message}"
           }
-          rescue LoadError
-            {
-              success: false,
-              error: "PDF extraction requires the 'pdf-reader' gem. Please add it to your Gemfile."
-            } 
-            rescue PDF::Reader::MalformedPDFError => e
-              {
-                success: false,
-                error: "Malformed PDF: #{e.message}"
-              } 
-            rescue PDF::Reader::UnsupportedFeatureError => e
-              {
-                success: false,
-                error: "Unsupported PDF feature: #{e.message}"
-              } 
-            rescue PDF::Reader::EncryptedPDFError => e
-              {
-                success: false,
-                error: "Encrypted PDF: #{e.message}"
-              } 
             ensure 
-              cleanup if @options[:auto_delete]   
+              cleanup if @options[:auto_delete]
         end
       end 
       def extract_json
@@ -196,8 +176,8 @@ module Telegem
       def cleanup
         @temp_file.unlink if @temp_file
         @temp_file = nil
-      end
-    end
-  end
-end
-end 
+      end 
+    end 
+  end 
+end 
+end 

data/lib/session/memory_store.rb

@@ -5,7 +5,6 @@ module Telegem
       def initialize
         @store = {}
         @ttls = {}
-        @mutex = Mutex.new
         @default_ttl = 300  # 5 minutes
         @cleanup_interval = 60  # Clean expired every minute
         @last_cleanup = Time.now
@@ -13,18 +12,15 @@ module Telegem
 
       # Store with optional TTL
       def set(key, value, ttl: nil)
-        @mutex.synchronize do
           auto_cleanup
           key_s = key.to_s
           @store[key_s] = value
           @ttls[key_s] = Time.now + (ttl || @default_ttl)
           value
         end
-      end
 
       # Get value if not expired
       def get(key)
-        @mutex.synchronize do
           key_s = key.to_s
           return nil unless @store.key?(key_s)
           
@@ -36,37 +32,30 @@ module Telegem
           
           @store[key_s]
         end
-      end
 
       # Check if key exists and not expired
       def exist?(key)
-        @mutex.synchronize do
           key_s = key.to_s
           return false unless @store.key?(key_s)
           !expired?(key_s)
         end
-      end
 
       # Delete key
       def delete(key)
-        @mutex.synchronize do
           key_s = key.to_s
           @store.delete(key_s)
           @ttls.delete(key_s)
           true
         end
-      end
 
       # Increment counter (for rate limiting)
       def increment(key, amount = 1, ttl: nil)
-        @mutex.synchronize do
           key_s = key.to_s
           current = get(key_s) || 0
           new_value = current + amount
           set(key_s, new_value, ttl: ttl)
           new_value
         end
-      end
 
       # Decrement counter
       def decrement(key, amount = 1)
@@ -75,7 +64,6 @@ module Telegem
 
       # Clear expired entries (auto-called)
       def cleanup
-        @mutex.synchronize do
           now = Time.now
           @ttls.each do |key, expires|
             if now > expires
@@ -84,25 +72,20 @@ module Telegem
             end
           end
           @last_cleanup = now
-        end
-      end
+        end 
 
       # Clear everything
       def clear
-        @mutex.synchronize do
           @store.clear
           @ttls.clear
           @last_cleanup = Time.now
         end
-      end
 
       # Get all keys (non-expired)
       def keys
-        @mutex.synchronize do
           auto_cleanup
           @store.keys.select { |k| !expired?(k) }
         end
-      end
 
       # Get size (non-expired entries)
       def size
@@ -115,34 +98,28 @@ module Telegem
 
       # Get TTL remaining in seconds
       def ttl(key)
-        @mutex.synchronize do
           key_s = key.to_s
           return -1 unless @ttls[key_s]
           
           remaining = @ttls[key_s] - Time.now
           remaining > 0 ? remaining.ceil : -1
         end
-      end
 
       # Set TTL for existing key
       def expire(key, ttl)
-        @mutex.synchronize do
           key_s = key.to_s
           return false unless @store.key?(key_s)
           
           @ttls[key_s] = Time.now + ttl
           true
         end
-      end
 
       # Redis-like scan for pattern matching
       def scan(pattern = "*", count: 10)
-        @mutex.synchronize do
           auto_cleanup
           regex = pattern_to_regex(pattern)
           matching_keys = @store.keys.select { |k| k.match?(regex) && !expired?(k) }
           matching_keys.first(count)
-        end
       end
 
       private
@@ -158,7 +135,6 @@ module Telegem
       end
 
       def pattern_to_regex(pattern)
-        # Convert Redis-style pattern to Ruby regex
         regex_str = pattern.gsub('*', '.*').gsub('?', '.')
         Regexp.new("^#{regex_str}$")
       end

data/lib/telegem.rb

@@ -1,12 +1,12 @@
-# lib/telegem.rb - MAIN ENTRY POINT
+
 require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = "3.2.2".freeze 
+  VERSION = "3.3.0".freeze
 end
 
-# Load core components
+#
 require_relative 'api/client'
 require_relative 'api/types'
 require_relative 'core/bot'
@@ -16,17 +16,18 @@ require_relative 'core/scene'
 require_relative 'session/middleware'
 require_relative 'session/memory_store'
 require_relative 'markup/keyboard'
-# Webhook is loaded lazily when needed
+require_relative 'markup/inline'
+
 require_relative 'plugins/file_extract'
 require_relative 'session/scene_middleware'
 
 module Telegem
-  # Main entry point: Telegem.new(token)
+
   def self.new(token, **options)
     Core::Bot.new(token, **options)
   end
   
-  # Shortcut for creating keyboards
+
   def self.keyboard(&block)
     Markup.keyboard(&block)
   end
@@ -35,28 +36,23 @@ module Telegem
     Markup.inline(&block)
   end
   
-  # Remove keyboard markup
   def self.remove_keyboard(**options)
     Markup.remove(**options)
   end
   
-  # Force reply markup
   def self.force_reply(**options)
     Markup.force_reply(**options)
   end
   
-  # Current version
   def self.version
     VERSION
   end
-  
-  # Quick webhook setup
+
   def self.webhook(bot, **options)
     require_relative 'webhook/server'
     Webhook::Server.setup(bot, **options)
   end
   
-  # Framework information
   def self.info
     <<~INFO
       🤖 Telegem #{VERSION}
@@ -77,7 +73,7 @@ module Telegem
   end
 end
 
-# Optional global shortcut (enabled by env var)
+
 if ENV['TELEGEM_GLOBAL'] == 'true'
   def Telegem(token, **options)
     ::Telegem.new(token, **options)

data/lib/webhook/server.rb

@@ -120,7 +120,7 @@ module Telegem
         begin
           body = request.body.read
           update_data = JSON.parse(body)
-          Async { process_webhook_update(update_data) }
+           process_webhook_update(update_data) 
           [200, {}, ["OK"]]
         rescue
           [500, {}, ["Internal Server Error"]]