gruubY 0.2.0

data/lib/grubY/tdlib/client_manager.rb

@@ -0,0 +1,37 @@
+require "thread"
+require_relative "tdjson"
+
+module GrubY
+  module TDLib
+    class ClientManager
+      attr_reader :tdjson
+
+      def initialize(lib_path: nil, verbosity: 1)
+        @tdjson = TdJson.new(lib_path: lib_path, verbosity: verbosity)
+        @clients = {}
+        @mutex = Mutex.new
+      end
+
+      def add_client(client)
+        key = client.native_client_key
+        @mutex.synchronize { @clients[key] = client }
+        client
+      end
+
+      def remove_client(client)
+        key = client.native_client_key
+        @mutex.synchronize { @clients.delete(key) }
+      end
+
+      def each_client(&block)
+        snapshot = @mutex.synchronize { @clients.values.dup }
+        snapshot.each(&block)
+      end
+
+      def close
+        each_client(&:stop)
+        true
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/decorators.rb

@@ -0,0 +1,17 @@
+module GrubY
+  module TDLib
+    module Decorators
+      def initializer(filter: nil, position: nil, timeout: nil, &block)
+        add_handler("initializer", filter: filter, position: position, timeout: timeout, &block)
+      end
+
+      def finalizer(filter: nil, position: nil, timeout: nil, &block)
+        add_handler("finalizer", filter: filter, position: position, timeout: timeout, &block)
+      end
+
+      def on_message(filter: nil, position: nil, timeout: nil, &block)
+        add_handler("updateNewMessage", filter: filter, position: position, timeout: timeout, inner_object: true, &block)
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/errors.rb

@@ -0,0 +1,6 @@
+module GrubY
+  module TDLib
+    class StopHandlers < StandardError; end
+    class AuthorizationError < StandardError; end
+  end
+end

data/lib/grubY/tdlib/group_manager.rb

@@ -0,0 +1,58 @@
+module GrubY
+  module TDLib
+    class GroupManager
+      def initialize(client)
+        @client = client
+      end
+
+      def ban_chat_member(chat_id:, member_id:, banned_until_date: 0, revoke_messages: true)
+        @client.banChatMember(
+          chat_id: chat_id,
+          member_id: member_id,
+          banned_until_date: banned_until_date,
+          revoke_messages: revoke_messages
+        )
+      end
+
+      def unban_chat_member(chat_id:, member_id:)
+        @client.unbanChatMember(chat_id: chat_id, member_id: member_id)
+      end
+
+      def set_chat_title(chat_id:, title:)
+        @client.setChatTitle(chat_id: chat_id, title: title)
+      end
+
+      def set_chat_description(chat_id:, description:)
+        @client.setChatDescription(chat_id: chat_id, description: description)
+      end
+
+      def set_slow_mode(chat_id:, delay:)
+        @client.setChatSlowModeDelay(chat_id: chat_id, slow_mode_delay: delay)
+      end
+
+      def pin_chat_message(chat_id:, message_id:, disable_notification: false)
+        @client.pinChatMessage(
+          chat_id: chat_id,
+          message_id: message_id,
+          disable_notification: disable_notification
+        )
+      end
+
+      def unpin_chat_message(chat_id:, message_id: nil)
+        @client.unpinChatMessage(chat_id: chat_id, message_id: message_id)
+      end
+
+      def leave_chat(chat_id:)
+        @client.leaveChat(chat_id: chat_id)
+      end
+
+      def get_chat_member(chat_id:, member_id:)
+        @client.getChatMember(chat_id: chat_id, member_id: member_id)
+      end
+
+      def get_chat(chat_id:)
+        @client.getChat(chat_id: chat_id)
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/native.rb

@@ -0,0 +1,72 @@
+require "ffi"
+
+module GrubY
+  module TDLib
+    module Native
+      extend FFI::Library
+
+      class LibraryNotFoundError < StandardError; end
+
+      class << self
+        def load!(path = nil)
+          return if @loaded
+
+          ffi_lib(resolve_library_path(path))
+          attach_function :td_json_client_create, [], :pointer
+          attach_function :td_json_client_send, [:pointer, :string], :void
+          attach_function :td_json_client_receive, [:pointer, :double], :string
+          attach_function :td_json_client_execute, [:pointer, :string], :string
+          attach_function :td_json_client_destroy, [:pointer], :void
+          attach_function :td_set_log_verbosity_level, [:int], :void
+          @loaded = true
+        end
+
+        private
+
+        def resolve_library_path(custom_path)
+          return custom_path if custom_path && File.exist?(custom_path)
+
+          env_path = ENV["TDJSON_PATH"]
+          return env_path if env_path && File.exist?(env_path)
+
+          candidates = default_candidates
+          found = candidates.find { |path| File.exist?(path) }
+          return found if found
+
+          raise LibraryNotFoundError,
+            "TDLib (tdjson) not found. Set TDJSON_PATH or pass tdjson_path."
+        end
+
+        def default_candidates
+          if Gem.win_platform?
+            [
+              "tdjson.dll",
+              "vendor/tdlib/windows/tdjson.dll",
+              "vendor/tdlib/win/tdjson.dll",
+              "vendor/tdlib/tdjson.dll",
+              "C:/tdlib/bin/tdjson.dll",
+              "C:/Program Files/TDLib/bin/tdjson.dll"
+            ]
+          elsif RUBY_PLATFORM.include?("darwin")
+            [
+              "libtdjson.dylib",
+              "vendor/tdlib/macos/libtdjson.dylib",
+              "vendor/tdlib/darwin/libtdjson.dylib",
+              "vendor/tdlib/libtdjson.dylib",
+              "/usr/local/lib/libtdjson.dylib",
+              "/opt/homebrew/lib/libtdjson.dylib"
+            ]
+          else
+            [
+              "libtdjson.so",
+              "vendor/tdlib/linux/libtdjson.so",
+              "vendor/tdlib/libtdjson.so",
+              "/usr/lib/libtdjson.so",
+              "/usr/local/lib/libtdjson.so"
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/schema_builder.rb

@@ -0,0 +1,237 @@
+require "json"
+require "net/http"
+require "uri"
+require "cgi"
+require "stringio"
+
+module GrubY
+  module TDLib
+    class SchemaBuilder
+      TL_DEF_REGEX = /^(?<name>\w+)(?:#[0-9a-f]+)?\s+(?<params>.*)=\s+(?<type>\w+);$/
+      PARAM_DETAIL_REGEX = /(?<name>\w+):(?<type>[^\s]+)/
+      ROW_REGEX = /<tr>\s*<td>(.*?)<\/td>\s*<td>(.*?)<\/td>\s*<td>(.*?)<\/td>\s*<td>(.*?)<\/td>\s*<\/tr>/m
+      TAG_REGEX = /<[^>]*>/
+
+      def initialize(src:, version: "", commit: "", out: "tdlib.json")
+        @src = src
+        @version = version
+        @commit = commit
+        @out = out
+      end
+
+      def call
+        data = if @src.start_with?("http://", "https://")
+                 fetch_and_parse_tl(@src)
+               else
+                 parse_tl_from_file(@src)
+               end
+
+        data["version"] = @version
+        data["commit"] = @commit
+
+        begin
+          data["options"] = fetch_options
+        rescue StandardError => e
+          warn "Warning: failed to fetch options: #{e.message}"
+        end
+
+        save_json(data, @out)
+      end
+
+      private
+
+      def parse_tl_from_file(path)
+        File.open(path, "r:utf-8") do |file|
+          parse_tl_from_reader(file)
+        end
+      end
+
+      def fetch_and_parse_tl(url)
+        uri = URI.parse(url)
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "gruby-tdlib-schema-builder/1.0"
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", read_timeout: 30, open_timeout: 30) do |http|
+          http.request(request)
+        end
+        raise "failed to fetch #{url}: status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        parse_tl_from_reader(StringIO.new(response.body))
+      end
+
+      def parse_tl_from_reader(reader)
+        data = {
+          "name" => "Auto-generated JSON TDLib API",
+          "version" => "",
+          "commit" => "",
+          "classes" => {},
+          "types" => {},
+          "updates" => {},
+          "functions" => {},
+          "options" => {}
+        }
+
+        current_description = ""
+        current_params = {}
+        is_functions_section = false
+        start = false
+
+        reader.each_line do |raw_line|
+          line = raw_line.strip
+
+          if line.include?("---functions---")
+            is_functions_section = true
+            next
+          end
+
+          if line.start_with?("//")
+            start = true
+            if line.start_with?("//@")
+              parse_doc_tags(data, line.sub("//@", ""), current_params) do |description|
+                current_description = [current_description, description].reject(&:empty?).join(" ").strip
+              end
+            end
+            next
+          end
+
+          next if line.empty? || !start
+
+          match = TL_DEF_REGEX.match(line)
+          next unless match
+
+          name = match[:name]
+          params_str = match[:params]
+          result_type = match[:type]
+
+          type_def = {
+            "description" => current_description,
+            "args" => {},
+            "type" => result_type
+          }
+
+          params_str.scan(PARAM_DETAIL_REGEX) do |p_name, p_type|
+            p_desc = current_params[p_name] || ""
+            type_def["args"][p_name] = {
+              "description" => p_desc,
+              "is_optional" => optional_arg?(p_desc, p_type),
+              "type" => p_type
+            }
+          end
+
+          if is_functions_section
+            data["functions"][name] = type_def
+            (data["classes"][result_type] ||= default_class)["functions"] << name
+          elsif name.start_with?("update")
+            data["updates"][name] = type_def
+            (data["classes"][result_type] ||= default_class)["types"] << name
+          else
+            data["types"][name] = type_def
+            (data["classes"][result_type] ||= default_class)["types"] << name
+          end
+
+          current_description = ""
+          current_params = {}
+        end
+
+        data
+      end
+
+      def parse_doc_tags(data, tag_line, current_params)
+        parts = (" " + tag_line).split(" @")
+        current_class = nil
+
+        parts.each do |part|
+          part = part.strip
+          next if part.empty?
+
+          tag_name, tag_text = part.split(" ", 2)
+          tag_text = (tag_text || "").strip
+
+          case tag_name
+          when "class"
+            current_class = tag_text
+          when "description"
+            if current_class
+              data["classes"][current_class] = {
+                "description" => tag_text,
+                "types" => [],
+                "functions" => []
+              }
+              current_class = nil
+            else
+              yield(tag_text)
+            end
+          else
+            clean_name = tag_name.sub(/^param_/, "")
+            current_params[clean_name] = [current_params[clean_name], tag_text].compact.join(" ").strip
+          end
+        end
+      end
+
+      def default_class
+        { "description" => "", "types" => [], "functions" => [] }
+      end
+
+      def optional_arg?(description, type)
+        text = description.to_s.downcase
+        text.include?("may be null") ||
+          text.include?("pass null") ||
+          text.include?("may be empty") ||
+          description.to_s.include?("If non-empty,") ||
+          type.to_s.include?("?")
+      end
+
+      def fetch_options
+        url = URI.parse("https://core.telegram.org/tdlib/options")
+        request = Net::HTTP::Get.new(url)
+        request["User-Agent"] = "gruby-tdlib-schema-builder/1.0"
+
+        response = Net::HTTP.start(url.host, url.port, use_ssl: true, read_timeout: 30, open_timeout: 30) do |http|
+          http.request(request)
+        end
+        raise "failed to fetch options: status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        content = response.body
+        marker_index = content.index("list-of-options-supported-by-tdlib")
+        raise "could not find options list in HTML" unless marker_index
+
+        options = {}
+        content[marker_index..].scan(ROW_REGEX) do |name, type_name, writable, description|
+          clean_name = clean_html(name)
+          next if clean_name.empty? || clean_name.casecmp("name").zero?
+
+          options[clean_name] = {
+            "type" => map_type(clean_html(type_name)),
+            "writable" => clean_html(writable).casecmp("yes").zero?,
+            "description" => clean_html(description)
+          }
+        end
+
+        raise "no options were parsed from HTML" if options.empty?
+
+        options
+      end
+
+      def clean_html(text)
+        CGI.unescapeHTML(text.gsub(TAG_REGEX, "").strip)
+      end
+
+      def map_type(type_name)
+        case type_name
+        when "Integer"
+          "int64"
+        when "Boolean"
+          "Bool"
+        when "String"
+          "string"
+        else
+          type_name
+        end
+      end
+
+      def save_json(data, path)
+        File.write(path, JSON.pretty_generate(data) + "\n")
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/tdjson.rb

@@ -0,0 +1,49 @@
+require "json"
+require_relative "native"
+
+module GrubY
+  module TDLib
+    class TdJson
+      attr_reader :version
+
+      def initialize(lib_path: nil, verbosity: 1)
+        Native.load!(lib_path)
+        Native.td_set_log_verbosity_level(verbosity.to_i)
+        @version = fetch_version
+      end
+
+      def create_client_id
+        Native.td_json_client_create
+      end
+
+      def send(client_id, request)
+        Native.td_json_client_send(client_id, JSON.generate(request))
+      end
+
+      def receive(client_id, timeout:)
+        raw = Native.td_json_client_receive(client_id, timeout.to_f)
+        raw ? JSON.parse(raw) : nil
+      end
+
+      def execute(client_id, request)
+        raw = Native.td_json_client_execute(client_id, JSON.generate(request))
+        raw ? JSON.parse(raw) : nil
+      end
+
+      def destroy(client_id)
+        Native.td_json_client_destroy(client_id)
+      end
+
+      private
+
+      def fetch_version
+        temp = create_client_id
+        response = execute(temp, { "@type" => "getOption", "name" => "version" })
+        destroy(temp)
+        response&.dig("value", "value")
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/grubY/tdlib/user_session.rb

@@ -0,0 +1,69 @@
+require "base64"
+require "json"
+require "securerandom"
+
+module GrubY
+  module TDLib
+    module UserSession
+      module_function
+
+      VERSION = 1
+
+      def encode(
+        api_id:,
+        api_hash:,
+        database_directory:,
+        files_directory:,
+        database_encryption_key: "",
+        session_name: nil
+      )
+        payload = {
+          "v" => VERSION,
+          "api_id" => api_id.to_i,
+          "api_hash" => api_hash.to_s,
+          "database_directory" => database_directory.to_s,
+          "files_directory" => files_directory.to_s,
+          "database_encryption_key" => database_encryption_key.to_s,
+          "session_name" => session_name.to_s
+        }
+        Base64.urlsafe_encode64(payload.to_json)
+      end
+
+      def decode(session_string)
+        raise ArgumentError, "session_string is empty" if session_string.to_s.strip.empty?
+
+        payload = JSON.parse(Base64.urlsafe_decode64(session_string.to_s.strip))
+        unless payload.is_a?(Hash) && payload["v"].to_i == VERSION
+          raise ArgumentError, "invalid session string version"
+        end
+
+        payload
+      rescue ArgumentError, JSON::ParserError => e
+        raise ArgumentError, "invalid session string: #{e.message}"
+      end
+
+      def build(session_name: "default", root: "storage/tdlib-sessions")
+        normalized = session_name.to_s.strip
+        normalized = "default" if normalized.empty?
+
+        {
+          session_name: normalized,
+          database_directory: File.join(root, normalized, "db"),
+          files_directory: File.join(root, normalized, "files"),
+          database_encryption_key: SecureRandom.hex(24)
+        }
+      end
+
+      def client_kwargs(session_string)
+        payload = decode(session_string)
+        {
+          api_id: payload.fetch("api_id").to_i,
+          api_hash: payload.fetch("api_hash").to_s,
+          database_directory: payload.fetch("database_directory").to_s,
+          files_directory: payload.fetch("files_directory").to_s,
+          database_encryption_key: payload.fetch("database_encryption_key").to_s
+        }
+      end
+    end
+  end
+end

data/lib/grubY/types/base_object.rb

@@ -0,0 +1,72 @@
+module GrubY
+  class BaseObject
+    class << self
+      def fields(*names)
+        @field_names ||= []
+        @field_names.concat(names.map(&:to_sym))
+        attr_reader(*names)
+      end
+
+      def field_names
+        @field_names || []
+      end
+    end
+
+    def initialize(data = {}, api: nil, client: nil)
+      @data = normalize_hash(data)
+      @api = api
+      @client = client
+      self.class.field_names.each do |field|
+        instance_variable_set("@#{field}", @data[field.to_s])
+      end
+    end
+
+    attr_reader :api, :client
+
+    def [](key)
+      @data[key.to_s]
+    end
+
+    def dig(*keys)
+      normalized = keys.map(&:to_s)
+      @data.dig(*normalized)
+    end
+
+    def to_h
+      @data.dup
+    end
+
+    def method_missing(name, *args, &block)
+      return super unless args.empty? && block.nil?
+      return @data[name.to_s] if @data.key?(name.to_s)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @data.key?(name.to_s) || super
+    end
+
+    private
+
+    def call_api(method, params = {})
+      raise ArgumentError, "API is not bound to this object" unless @api
+
+      @api.request(method, params)
+    end
+
+    def call_raw_api(method, params = {})
+      raise ArgumentError, "API is not bound to this object" unless @api
+
+      @api.raw(method, params)
+    end
+
+    def normalize_hash(data)
+      return {} unless data.is_a?(Hash)
+
+      data.each_with_object({}) do |(k, v), out|
+        out[k.to_s] = v
+      end
+    end
+  end
+end