telegem 0.2.5 → 1.0.0

data/lib/session/middleware.rb

@@ -1,3 +1,4 @@
+# lib/session/middleware.rb - UPDATED
 module Telegem
   module Session
     class Middleware
@@ -9,45 +10,28 @@ module Telegem
         user_id = get_user_id(ctx)
         return next_middleware.call(ctx) unless user_id
 
+        # Load session
         ctx.session = @store.get(user_id) || {}
-
-        begin
-          result = next_middleware.call(ctx)
-          # Handle async result
-          result.is_a?(Async::Task) ? result : Async::Task.new(result)
-        ensure
-          @store.set(user_id, ctx.session)
-        end
-      end
+        
+        # Run the chain
+        result = next_middleware.call(ctx)
+        
+        # Save session (regardless of result)
+        @store.set(user_id, ctx.session)
+        
+        # Return whatever the chain returned
+        result
+      rescue => e
+        # Save session even on error
+        @store.set(user_id, ctx.session) if user_id && ctx.session
+        raise e
+      end
+      
       private
-
+      
       def get_user_id(ctx)
-        return nil unless ctx.from
-
-        ctx.from.id
-      end
-    end
-
-    class MemoryStore
-      def initialize
-        @store = {}
-      end
-
-      def get(key)
-        @store[key]
-      end
-
-      def set(key, value)
-        @store[key] = value
-      end
-
-      def delete(key)
-        @store.delete(key)
-      end
-
-      def clear
-        @store.clear
+        ctx.from&.id
       end
     end
   end
-end
+end

data/lib/telegem.rb

@@ -1,54 +1,9 @@
-# lib/telegem.rb
-require "async"
-require "async/http"
-require "mime/types"
-require 'logger'
-require 'json'
-
+# lib/telegem.rb - MAIN ENTRY POINT
 module Telegem
-  VERSION = '0.2.5'.freeze
-
-  # Define module structure
-  module API; end
-  module Core; end
-  module Session; end
-  module Markup; end
-  module Webhook; end
-  module Types; end
-
-  # Shortcut for creating a new bot
-  def self.new(token, **options)
-    Core::Bot.new(token, **options)
-  end
-
-  # Configure global settings
-  def self.configure(&block)
-    yield(config) if block_given?
-    config
-  end
-
-  def self.config
-    @config ||= Configuration.new
-  end
-
-  class Configuration
-    attr_accessor :logger, :default_adapter, :default_concurrency,
-                  :default_session_store, :default_webhook_port
-
-    def initialize
-      @logger = Logger.new($stdout)
-      @default_adapter = :async_http
-      @default_concurrency = 10
-      @default_session_store = :memory
-      @default_webhook_port = 3000
-    end
-  end
-
-  # Error base class
-  class Error < StandardError; end
+  VERSION = "1.0.0".freeze
 end
 
-# Load all components
+# Load core components
 require_relative 'api/client'
 require_relative 'api/types'
 require_relative 'core/bot'
@@ -58,11 +13,59 @@ require_relative 'core/scene'
 require_relative 'session/middleware'
 require_relative 'session/memory_store'
 require_relative 'markup/keyboard'
+require_relative 'webhook/server'
+
+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
+  
+  def self.inline(&block)
+    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
+  
+  # Framework information
+  def self.info
+    <<~INFO
+      🤖 Telegem #{VERSION}
+      Modern Telegram Bot Framework for Ruby
+      
+      Features:
+      • Async HTTPX-based API client
+      • Scene system for multi-step conversations  
+      • Express.js-style middleware
+      • Clean Telegraf.js-inspired DSL
+      • Webhook and polling support
+      • Built-in session management
+      • Fluent keyboard DSL
+      
+      Website: https://gitlab.com/ruby-telegem/telegem
+    INFO
+  end
+end
 
-# Webhook might be in different location
-begin
-  require_relative 'webhook/server'
-rescue LoadError
-  # Try root webhook directory
-  require_relative '../webhook/server'
+# Also define a top-level shortcut for convenience
+def Telegem(token, **options)
+  Telegem.new(token, **options)
 end

data/lib/webhook/server.rb

@@ -0,0 +1,193 @@
+# lib/webhook/server.rb - HTTPX VERSION
+require 'json'
+require 'webrick'
+
+module Telegem
+  module Webhook
+    class Server
+      attr_reader :bot, :port, :host, :logger, :server, :running
+
+      def initialize(bot, port: 3000, host: '0.0.0.0', logger: nil)
+        @bot = bot
+        @port = port
+        @host = host
+        @logger = logger || Logger.new($stdout)
+        @server = nil
+        @running = false
+      end
+
+      def run
+        return if @running
+        
+        @logger.info "🚀 Starting Telegem webhook server on #{@host}:#{@port}"
+        @logger.info "📝 Set your Telegram webhook to: #{webhook_url}"
+        
+        @running = true
+        
+        @server_thread = Thread.new do
+          begin
+            # Create WEBrick server
+            @server = WEBrick::HTTPServer.new(
+              Port: @port,
+              BindAddress: @host,
+              Logger: @logger,
+              AccessLog: []
+            )
+            
+            # Mount the webhook endpoint
+            @server.mount_proc("/webhook/#{@bot.token}") do |req, res|
+              handle_webhook_request(req, res)
+            end
+            
+            # Mount health check
+            @server.mount_proc('/health') do |req, res|
+              res.status = 200
+              res.content_type = 'text/plain'
+              res.body = 'OK'
+            end
+            
+            # Mount root
+            @server.mount_proc('/') do |req, res|
+              res.status = 200
+              res.content_type = 'text/html'
+              res.body = <<~HTML
+                <html>
+                  <head><title>Telegem Webhook Server</title></head>
+                  <body>
+                    <h1>Telegem Webhook Server</h1>
+                    <p>Webhook URL: <code>#{webhook_url}</code></p>
+                    <p>Status: <span style="color: green;">Running</span></p>
+                    <p><a href="/health">Health Check</a></p>
+                  </body>
+                </html>
+              HTML
+            end
+            
+            # Handle shutdown signals
+            ['INT', 'TERM'].each do |signal|
+              Signal.trap(signal) { shutdown }
+            end
+            
+            # Start the server
+            @server.start
+            
+          rescue => e
+            @logger.error "❌ Webhook server error: #{e.class}: #{e.message}"
+            @logger.error e.backtrace.join("\n") if e.backtrace
+            raise
+          ensure
+            @running = false
+          end
+        end
+        
+        self
+      end
+
+      def stop
+        return unless @running
+        
+        @logger.info "🛑 Stopping webhook server..."
+        @running = false
+        
+        # Stop WEBrick server
+        @server&.shutdown
+        
+        # Wait for server thread
+        @server_thread&.join(5)
+        
+        @logger.info "✅ Webhook server stopped"
+      end
+
+      alias_method :shutdown, :stop
+
+      def running?
+        @running
+      end
+
+      def webhook_url
+        base_url = ENV['WEBHOOK_URL'] || "http://#{@host}:#{@port}"
+        "#{base_url}/webhook/#{@bot.token}"
+      end
+
+      private
+
+      def handle_webhook_request(req, res)
+        # Only accept POST requests
+        unless req.request_method == 'POST'
+          res.status = 405
+          res.content_type = 'text/plain'
+          res.body = 'Method Not Allowed'
+          return
+        end
+
+        begin
+          # Parse the update
+          body = req.body.read
+          update_data = JSON.parse(body)
+          
+          # Process the update in a separate thread to keep response fast
+          Thread.new do
+            begin
+              @bot.process(update_data)
+            rescue => e
+              @logger.error "Error processing update: #{e.message}"
+            end
+          end
+          
+          # Immediate response to Telegram
+          res.status = 200
+          res.content_type = 'text/plain'
+          res.body = 'OK'
+          
+        rescue JSON::ParserError => e
+          @logger.error "Invalid JSON in webhook request: #{e.message}"
+          res.status = 400
+          res.content_type = 'text/plain'
+          res.body = 'Bad Request'
+        rescue => e
+          @logger.error "Error handling webhook: #{e.class}: #{e.message}"
+          res.status = 500
+          res.content_type = 'text/plain'
+          res.body = 'Internal Server Error'
+        end
+      end
+    end
+
+    # Middleware for Rack apps (Rails, Sinatra, etc.)
+    class Middleware
+      def initialize(app, bot)
+        @app = app
+        @bot = bot
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        
+        # Check if this is a webhook request
+        if req.post? && req.path == "/webhook/#{@bot.token}"
+          handle_webhook(req)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def handle_webhook(req)
+        begin
+          update_data = JSON.parse(req.body.read)
+          
+          # Process async in background
+          Thread.new { @bot.process(update_data) }
+          
+          [200, { 'Content-Type' => 'text/plain' }, ['OK']]
+        rescue JSON::ParserError
+          [400, { 'Content-Type' => 'text/plain' }, ['Bad Request']]
+        rescue => e
+          @bot.logger.error("Webhook error: #{e.message}") if @bot.logger
+          [500, { 'Content-Type' => 'text/plain' }, ['Internal Server Error']]
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,91 +1,93 @@
 --- !ruby/object:Gem::Specification
 name: telegem
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 1.0.0
 platform: ruby
 authors:
-- Phantom
-bindir: bin
+- Your Name
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: async
+  name: httpx
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.24.0
 - !ruby/object:Gem::Dependency
-  name: async-http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.60'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.60'
-- !ruby/object:Gem::Dependency
-  name: mime-types
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
-  type: :runtime
+        version: '13.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 0.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-description: A Telegraf-inspired Telegram Bot framework with async I/O
+        version: 0.14.0
+description: Blazing-fast Telegram Bot framework with true async/await patterns, inspired
+  by Telegraf.js
 email:
-- ynghosted@icloud.com
+- your-email@example.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".replit"
+- Contributing.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Readme.md
+- Test-Projects/.gitkeep
+- Test-Projects/bot_test1.rb
+- Test-Projects/pizza_test_bot_guide.md
+- docs/.gitkeep
+- docs/Api.md
+- docs/Cookbook.md
+- docs/How_to_use.md
+- docs/QuickStart.md
+- docs/Usage.md
 - lib/api/client.rb
 - lib/api/types.rb
 - lib/core/bot.rb
@@ -96,8 +98,8 @@ files:
 - lib/session/memory_store.rb
 - lib/session/middleware.rb
 - lib/telegem.rb
-- telegem.gemspec
-- webhook/server.rb
+- lib/webhook/.gitkeep
+- lib/webhook/server.rb
 homepage: https://gitlab.com/ruby-telegem/telegem
 licenses:
 - MIT
@@ -105,6 +107,7 @@ metadata:
   homepage_uri: https://gitlab.com/ruby-telegem/telegem
   source_code_uri: https://gitlab.com/ruby-telegem/telegem
   changelog_uri: https://gitlab.com/ruby-telegem/telegem/-/blob/main/CHANGELOG.md
+  documentation_uri: https://gitlab.com/ruby-telegem/telegem/-/tree/main/docs
 rdoc_options: []
 require_paths:
 - lib
@@ -112,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/telegem.gemspec

@@ -1,43 +0,0 @@
-# telegem.gemspec
-Gem::Specification.new do |spec|
-  spec.name          = "telegem"
-  
-  # 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.2.5"
-  
-  spec.authors       = ["Phantom"]
-  spec.email         = ["ynghosted@icloud.com"]
-
-  spec.summary       = "Modern, async Telegram Bot API for Ruby"
-  spec.description   = "A Telegraf-inspired Telegram Bot framework with async I/O"
-  spec.homepage      = "https://gitlab.com/ruby-telegem/telegem"
-  spec.license       = "MIT"
-  spec.required_ruby_version = ">= 3.0"
-
-  # Include all necessary files
-  spec.files         = Dir[
-    "lib/**/*.rb",           # All Ruby files in lib/
-    "webhook/**/*.rb",       # Webhook files (if in root)
-    "README.md",
-    "LICENSE.txt",
-    "CHANGELOG.md",
-    "*.gemspec"
-  ].select { |f| File.exist?(f) }
-  
-  # This tells RubyGems to look in lib/ when requiring
-  spec.require_paths = ["lib"]
-
-  spec.metadata = {
-    "homepage_uri" => "https://gitlab.com/ruby-telegem/telegem",
-    "source_code_uri" => "https://gitlab.com/ruby-telegem/telegem",
-    "changelog_uri" => "https://gitlab.com/ruby-telegem/telegem/-/blob/main/CHANGELOG.md"
-  }
-
-  spec.add_dependency "async", "~> 2.0"
-  spec.add_dependency "async-http", "~> 0.60"
-  spec.add_dependency "mime-types", "~> 3.4"
-
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end

data/webhook/server.rb

@@ -1,86 +0,0 @@
-    module Telegem
-      module Webhook
-        class Server
-          attr_reader :bot, :endpoint, :server, :logger
-
-          def initialize(bot, endpoint: nil, logger: nil)
-            @bot = bot
-            @endpoint = endpoint || Async::HTTP::Endpoint.parse("http://0.0.0.0:3000")
-            @logger = logger || Logger.new($stdout)
-            @server = nil
-            @running = false
-          end
-
-          def run
-            Async do |task|
-              @server = Async::HTTP::Server.new(app, @endpoint)
-              @running = true
-
-              @logger.info "Starting webhook server on #{@endpoint}"
-              @logger.info "Set your Telegram webhook to: #{webhook_url}"
-
-              @server.run
-            rescue => e
-              @logger.error "Webhook server error: #{e.message}"
-              raise
-            ensure
-              @running = false
-            end
-          end
-
-          def stop
-            Async do
-              @server&.close
-              @running = false
-              @logger.info "Webhook server stopped"
-            end
-          end
-
-          def running?
-            @running
-          end
-
-          def webhook_url
-            "#{@endpoint.url}/webhook/#{@bot.token}"
-          end
-
-          def app
-            proc do |req|
-              handle_request(req)
-            end
-          end
-
-          def process_webhook_request(req)
-            Async do 
-              body = req.body.read
-              data = JSON.parse(body)
-              await @bot.process(data)
-              [200, {}, ["OK"]]
-            rescue JSON::ParserError => e
-              @logger.error "Invalid JSON in webhook request: #{e.message}"
-              [400, {}, ["Bad Request"]]
-            rescue => e
-              @logger.error "Error processing webhook request: #{e.message}"
-              [500, {}, ["Internal Server Error"]] 
-            end
-          end
-
-          def handle_request(req)
-            Async do 
-              case req.path
-              when "/webhook/#{@bot.token}"
-                process_webhook_request(req)
-              when "/health"
-                [200, {}, ["OK"]]
-              else 
-                [404, {}, ["Not Found"]]
-              end
-            end
-          end
-
-          def call(req)
-            handle_request(req)
-          end
-        end
-      end
-    end