telegem 0.1.0

data/lib/markup/keyboard.rb

@@ -0,0 +1,294 @@
+module Telegem
+  module Markup
+    class Keyboard
+      attr_reader :buttons, :options
+
+      def initialize(buttons = [], **options)
+        @buttons = buttons
+        @options = {
+          resize_keyboard: true,
+          one_time_keyboard: false,
+          selective: false
+        }.merge(options)
+      end
+
+      # Create from array
+      def self.[](*rows)
+        new(rows)
+      end
+
+      # Builder pattern
+      def self.build(&block)
+        builder = Builder.new
+        builder.instance_eval(&block) if block_given?
+        builder.keyboard
+      end
+
+      # Add a row
+      def row(*buttons)
+        @buttons << buttons.flatten
+        self
+      end
+
+      # Add a button
+      def button(text, **options)
+        last_row = @buttons.last || []
+
+        if last_row.is_a?(Array)
+          last_row << { text: text }.merge(options)
+        else
+          @buttons << [{ text: text }.merge(options)]
+        end
+        self
+      end
+
+      # Chainable options
+      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
+
+      # Convert to Telegram format
+      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
+
+      # Remove keyboard
+      def self.remove(selective: false)
+        {
+          remove_keyboard: true,
+          selective: selective
+        }
+      end
+
+      # Force reply
+      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
+
+      # Create from array
+      def self.[](*rows)
+        new(rows)
+      end
+
+      # Builder pattern
+      def self.build(&block)
+        builder = InlineBuilder.new
+        builder.instance_eval(&block) if block_given?
+        builder.keyboard
+      end
+
+      # Add a row
+      def row(*buttons)
+        @buttons << buttons.flatten
+        self
+      end
+
+      # Add a button
+      def button(text, **options)
+        last_row = @buttons.last || []
+
+        if last_row.is_a?(Array)
+          last_row << { text: text }.merge(options)
+        else
+          @buttons << [{ text: text }.merge(options)]
+        end
+        self
+      end
+
+      # URL button
+      def url(text, url)
+        button(text, url: url)
+      end
+
+      # Callback button
+      def callback(text, data)
+        button(text, callback_data: data)
+      end
+
+      # Web app button
+      def web_app(text, url)
+        button(text, web_app: { url: url })
+      end
+
+      # Login button
+      def login(text, url, **options)
+        button(text, login_url: { url: url, **options })
+      end
+
+      # Switch inline query button
+      def switch_inline(text, query = "")
+        button(text, switch_inline_query: query)
+      end
+
+      # Switch inline query current chat button
+      def switch_inline_current(text, query = "")
+        button(text, switch_inline_query_current_chat: query)
+      end
+
+      # Convert to Telegram format
+      def to_h
+        {
+          inline_keyboard: @buttons.map { |row| row.is_a?(Array) ? row : [row] }
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # Builder DSL for keyboards
+    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))
+        else
+          @keyboard.row(*buttons)
+        end
+        self
+      end
+
+      def button(text, **options)
+        @keyboard.button(text, **options)
+        self
+      end
+
+      def method_missing(name, *args, &block)
+        if @keyboard.respond_to?(name)
+          @keyboard.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @keyboard.respond_to?(name) || super
+      end
+    end
+
+    # Builder DSL for inline keyboards
+    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))
+        else
+          @keyboard.row(*buttons)
+        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 method_missing(name, *args, &block)
+        if @keyboard.respond_to?(name)
+          @keyboard.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @keyboard.respond_to?(name) || super
+      end
+    end
+
+    # Shortcuts for common use
+    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

data/lib/session/memory_store.rb

@@ -0,0 +1,49 @@
+      module Telegem
+        module Session
+          class MemoryStore
+            def initialize
+              @store = {}
+              @mutex = Mutex.new
+            end
+
+            def get(key)
+              @mutex.synchronize do
+                @store[key.to_s]
+              end
+            end
+
+            def set(key, value)
+              @mutex.synchronize do
+                @store[key.to_s] = value
+              end
+            end
+
+            def delete(key)
+              @mutex.synchronize do
+                @store.delete(key.to_s)
+              end
+            end
+
+            def clear
+              @mutex.synchronize do
+                @store.clear
+              end
+            end
+
+            def keys
+              @mutex.synchronize do
+                @store.keys
+              end
+            end
+
+            def size
+              @mutex.synchronize do
+                @store.size
+              end
+            end
+
+            def empty?
+              @mutex.synchronize do
+                @store.empty?
+              end
+            end 

data/lib/session/middleware.rb

@@ -0,0 +1,53 @@
+module Telegem
+  module Session
+    class Middleware
+      def initialize(store = nil)
+        @store = store || MemoryStore.new
+      end
+
+      def call(ctx, next_middleware)
+        user_id = get_user_id(ctx)
+        return next_middleware.call(ctx) unless user_id
+
+        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
+      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
+      end
+    end
+  end
+end

data/telegem.rb

@@ -0,0 +1,55 @@
+module Telegem
+  VERSION = '0.1.0'.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)
+    require_relative 'lib/core/bot'
+    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
+end
+
+# Load all components
+require_relative 'lib/api/client'
+require_relative 'lib/api/types'
+require_relative 'lib/core/bot'
+require_relative 'lib/core/context'
+require_relative 'lib/core/composer'
+require_relative 'lib/core/scene'
+require_relative 'lib/session/middleware'
+require_relative 'lib/session/memory_store'
+require_relative 'lib/markup/keyboard'
+require_relative 'webhook/server'

data/version.rb

@@ -0,0 +1,4 @@
+# version.rb
+module Telegem
+  VERSION = '0.1.0'.freeze
+end

data/webhook/server.rb

@@ -0,0 +1,86 @@
+    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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: telegem
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Phantom
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.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
+email:
+- ynghosted@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/api/client.rb
+- lib/api/types.rb
+- lib/core/bot.rb
+- lib/core/composer.rb
+- lib/core/context.rb
+- lib/core/scene.rb
+- lib/markup/keyboard.rb
+- lib/session/memory_store.rb
+- lib/session/middleware.rb
+- telegem.rb
+- version.rb
+- webhook/server.rb
+homepage: https://gitlab.com/ruby-telegem/telegem
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+- webhook
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Modern, async Telegram Bot API for Ruby
+test_files: []