tdlib-ruby 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4843f71309fcaf5799ce384c56d1df0a7d7d36131a5e162e3f3fd6d14dda68f7
-  data.tar.gz: eca6f03dd7e531f6a80595c562954427b71528c84d321a77e8babac791af9692
+  metadata.gz: 1c9e152ea091aaa6715f0ce9188a89f59c34e0c60600344ddb37454409956c99
+  data.tar.gz: 83c128d9e58d4e0fdac3c04a071e5646090d77ca06be93829af437f33174a77c
 SHA512:
-  metadata.gz: 3618eb07efe5081c116efb1ee9cc0cf39ccff51bd1fd1933e3c0e1690b27e1be12087faf91096e1636fc00a55f3edb9797b8c616e38418187fd2a3b2b3bdb157
-  data.tar.gz: a87798327ce6f1995fbce7f2c5a216ed7c4baa01b65bb81cc109fbca7c757f8e20dce56b2e373a703e83e7ddaaf4af6e69cbc697e8fd845ef2d8b7c4c86c7ad3
+  metadata.gz: 6a1bc253a33dac9e246fb897611de97436eecbdafb15cee2c4c4b7dc8630b2bd4fd5e40e8ec7085c0f6e752173dde0b56bddca4a6fbd64dd9b5e02eff47eb71d
+  data.tar.gz: 6f9e04ecea637478035631306ea0ea8e25e78f8d5fc9e89e51d0a538ff1425b2102db6c17432558964a4d0edf6df5c10df77939b71042202667d65d8e1142cb5

data/.gitignore

@@ -6,3 +6,4 @@
 /vendor/cache/*.gem
 /.vscode/
 /.yardoc/
+/.idea/

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "td"]
+	path = td
+	url = https://github.com/tdlib/td.git

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-- 2.3.6
-- 2.5.0
+- 2.3.8
+- 2.6.0
 addons:
   apt:
     sources:
@@ -20,7 +20,6 @@ env:
     secure: DmAoRsr+dTPVNs486nBXzChjzCCVdoxfmSbvqMBBl0v8uuUIZD1rSfYKcEaL5pmE7vgYq3X+3Dk0gf4ef/p2xPVKqFKrkBiF/7t06WgQTH7003gHMLq3aC7R9+1xvqJDzpoc6UB59Y1fOJBe5YfqDuw1dT9a46tzY2uzoVpEpbN8M/hssaKf6Wuzvpz5yekFeXq2raPwi3aOqvkSG+ODoacVdYQgJ4Vn0//CI2HzWijkQCvdsefWQUKkbgtuLWRp3UNy8AEhVWzQnTcSM7oc+MwMsOI/90DZkTP5n2WJl/CFTM5b70VyrIciG92SvTAhhBo/p7t3QBJa6kJMPXAHh5q+3wqVQA411+CoVF48bO5rKjKY3Ply49uqAzVJRh+Tkhf5uC1pHiZ6QKGxu1Czde+mKItBpaDmJFmQi0CSdv2WYXLnJWOQIO6vc2P3liwpMDRDyaGWOQtUYS+gHAlRbD4NPycIkGjkcjmLMqSEEO1TdCpM+CYwTvNTkRS+9HrWXZNdEfWORDYHgYohoIP6kY6XWSgunUb6F6pVxLoPWJNEBEVuIMZeOa/s9oklxBzD5XXIzBx4QsPYanvfxoN1uOcXlBXbOGqwiqb+urokNDw+BzWhbA+xY03U2+yO0Ujh3HQDyMDtrXEQfaPC0SxpEvIINVYwznG4sMKvbOaCVSo=
 before_install:
 - set -e
-- git clone https://github.com/tdlib/td
 - cd td
 - mkdir -p build
 - cd build

data/ChangeLog.md

@@ -1,3 +1,12 @@
+### 2.0.0 / 2019-02-08
+
+* Generated types and client functions
+* Async handlers
+* Use ffi instead of fiddle
+* Use Concurrent::Promises
+* TD errors handling in promises
+* Add use_file_database setting to config
+
 ### 1.0.0 / 2018-05-27
 
 * Return promises from TD::Client#broadcast

data/README.md

@@ -23,6 +23,13 @@ http://rpms.southbridge.ru/rhel7/stable/SRPMS/
 
 http://rpms.southbridge.ru/rhel6/stable/SRPMS/
 
+## Compatibility table
+
+| Gem Version   |   | tdlib version |
+|:-------------:|:-:| :-----------: |
+| 1.x           | → | 1.0 - 1.2     |
+| 2.0           | → | 1.3           |
+
 ## Install
 
 Add to your gemfile:
@@ -35,7 +42,7 @@ and run *bundle install*.
 
 Or just run *gem install tdlib-ruby*
 
-## Basic example
+## Basic authentication example
 
 ```ruby
 require 'tdlib-ruby'
@@ -54,59 +61,52 @@ client = TD::Client.new
 begin
   state = nil
 
-  client.on('updateAuthorizationState') do |update|
-    next unless update.dig('authorization_state', '@type') == 'authorizationStateWaitPhoneNumber'
-    state = :wait_phone
-  end
-
-  client.on('updateAuthorizationState') do |update|
-    next unless update.dig('authorization_state', '@type') == 'authorizationStateWaitCode'
-    state = :wait_code
-  end
-
-  client.on('updateAuthorizationState') do |update|
-    next unless update.dig('authorization_state', '@type') == 'authorizationStateReady'
-    state = :ready
+  client.on(TD::Types::Update::AuthorizationState) do |update|
+    state = case update.authorization_state
+            when TD::Types::AuthorizationState::WaitPhoneNumber
+              :wait_phone_number
+            when TD::Types::AuthorizationState::WaitCode
+              :wait_code
+            when TD::Types::AuthorizationState::WaitPassword
+              :wait_password
+            when TD::Types::AuthorizationState::Ready
+              :ready
+            else
+              nil
+            end
   end
+  
+  client.connect
 
   loop do
     case state
-    when :wait_phone
-      p 'Please, enter your phone number:'
+    when :wait_phone_number
+      puts 'Please, enter your phone number:'
       phone = STDIN.gets.strip
-      params = {
-        '@type' => 'setAuthenticationPhoneNumber',
-        'phone_number' => phone
-      }
-      client.broadcast_and_receive(params)
+      client.set_authentication_phone_number(phone).wait
     when :wait_code
-      p 'Please, enter code from SMS:'
+      puts 'Please, enter code from SMS:'
       code = STDIN.gets.strip
-      params = {
-        '@type' => 'checkAuthenticationCode',
-        'code' => code
-      }
-      client.broadcast_and_receive(params)
+      client.check_authentication_code(code).wait
+    when :wait_password
+      puts 'Please, enter 2FA password:'
+      password = STDIN.gets.strip
+      client.check_authentication_password(password).wait
     when :ready
-      @me = client.broadcast_and_receive('@type' => 'getMe')
+      client.get_me.then { |user| @me = user }.rescue { |err| puts "error: #{err}" }.wait
       break
     end
+    sleep 0.1
   end
 
 ensure
-  client.close
+  client.dispose
 end
 
 p @me
 ```
 
-## TD::Client#broadcast
-
-From version 1.0 TD::Client##broadcast returns [Concurrent::Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html) object.
-
-```ruby
-  me = client.broadcast('@type' => 'getMe').then { |result| puts result }.rescue { |error| puts error }.value
-```
+Client methods are being executed asynchronously and return Concurrent::Promises::Future (see: https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/promises.in.md).
 
 ## Configuration
 
@@ -118,17 +118,18 @@ TD.configure do |config|
   config.client.api_id = 12345
   config.client.api_hash = 'your_api_hash'
   config.client.use_test_dc = true # default: false
-  config.database_directory = 'path/to/db/dir' # default: "#{Dir.home}/.tdlib-ruby/db"
-  config.files_directory = 'path/to/files/dir' # default: "#{Dir.home}/.tdlib-ruby/files"
+  config.client.database_directory = 'path/to/db/dir' # default: "#{Dir.home}/.tdlib-ruby/db"
+  config.client.files_directory = 'path/to/files/dir' # default: "#{Dir.home}/.tdlib-ruby/files"
+  config.client.use_file_database = true # default: true
   config.client.use_chat_info_database = true # default: true
-  config.use_secret_chats = true # default: true
-  config.use_message_database = true # default: true
-  config.system_language_code = 'ru' # default: 'en'
-  config.device_model = 'Some device model' # default: 'Ruby TD client'
-  config.system_version = '42' # default: 'Unknown'
-  config.application_version = '1.0' # default: '1.0'
-  config.enable_storage_optimizer = true # default: true
-  config.ignore_file_names = true # default: false
+  config.client.use_secret_chats = true # default: true
+  config.client.use_message_database = true # default: true
+  config.client.system_language_code = 'ru' # default: 'en'
+  config.client.device_model = 'Some device model' # default: 'Ruby TD client'
+  config.client.system_version = '42' # default: 'Unknown'
+  config.client.application_version = '1.0' # default: '1.0'
+  config.client.enable_storage_optimizer = true # default: true
+  config.client.ignore_file_names = true # default: false
 end
 ```
 
@@ -160,3 +161,5 @@ TD::Client.new(database_directory: 'will override value from config',
 ## Authors
 
 The gem is designed by [Southbridge](https://southbridge.io)
+
+Typeization made by [Yuri Mikhaylov](https://github.com/yurijmi) 

data/bin/build

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'etc'
+
+`
+set -e
+cd td
+mkdir -p build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release #{'-DOPENSSL_ROOT_DIR=/usr/local/opt/openssl@1.1/' if RbConfig::CONFIG['host_os'] =~ /darwin|mac os/} ..
+cmake --build . -j #{Etc.nprocessors}
+`

data/bin/parser

@@ -0,0 +1,447 @@
+#!/usr/bin/env ruby
+
+require 'active_support/all'
+
+AUTOLOAD_BASE_DIR  = 'tdlib/types'
+TD_API_TL_LOCATION = File.join(File.expand_path("../../", __FILE__), %w(td td generate scheme td_api.tl))
+
+def parse_tl_type(type)
+  if (vector = type.scan(/[vV]ector<(.*)>/)).length > 0
+    "TD::Types::Array.of(#{parse_tl_type(vector[0][0])})"
+  elsif type.match?(/[iI]nt\d\d/)
+    'TD::Types::Integer'
+  elsif type.match?(/[dD]ouble/)
+    'TD::Types::Float'
+  elsif type.match?(/[bB]ytes/)
+    'TD::Types::String'
+  else
+    "TD::Types::#{type.camelcase}"
+  end
+end
+
+def parse_argument_description(argument, description)
+  statements = description.split('; ')[1..-1]
+
+  if statements.length == 0
+    statements = description.split(', ')[1..-1]
+  end
+
+  optional = nil
+
+  if statements.length > 0
+    statements.each do |statement|
+      statement.downcase!
+
+      if statement.match?(/(can be null|may be null|can be empty|may be empty|optional|if empty|empty until|empty for|if available)/)
+        optional = true
+      elsif statement.match?(/(must be non-empty)/)
+        optional = false
+      end
+    end
+  end
+
+  {
+      argument => {
+          description: description,
+          optional:    optional
+      }
+  }
+end
+
+def parse_tl_entry(tl_entry)
+  info = {}
+  arguments = {}
+
+  # A fix for multiline comments
+  tl_entry.gsub!("\n//-", " ")
+
+  tl_entry.strip!
+
+  tl_entry.split("\n").each do |line|
+    if line.start_with?('//')
+      line.sub('//@', '').split(' @').each do |at_statement|
+        if at_statement.start_with?('class')
+          info[:class] = at_statement[6..-1]
+        elsif at_statement.start_with?('description')
+          info[:description] = at_statement[12..-1]
+        elsif at_statement.start_with?('param_description')
+          arguments.deep_merge!(parse_argument_description('description', at_statement[18..-1]))
+        else
+          argument    = at_statement.split(' ')[0]
+          description = at_statement[(argument.length + 1)..-1]
+
+          arguments.deep_merge!(parse_argument_description(argument, description))
+        end
+      end
+    else
+      args, super_class = line.sub(';', '').split(" = ")
+      args = args.split(' ')
+
+      info[:class]       = args[0]
+      info[:super_class] = super_class
+
+      args = (args[1..-1] || []).map do |a|
+        arg, type = a.split(':')
+
+        { arg => { type: parse_tl_type(type) } }
+      end.reduce(&:merge) || {}
+
+      arguments.deep_merge!(args)
+    end
+  end
+
+  if !info[:super_class] or info[:class].downcase == info[:super_class].downcase
+    info[:super_class] = 'Base'
+  end
+
+  # Setting all arguments to optional, if at least one argument stated to be required
+  # noinspection RubySimplifyBooleanInspection
+  if arguments.any? { |_,v| v[:optional] == false }
+    arguments.select { |_,v| v[:optional] == nil }.each { |k,_| arguments[k][:optional] = true }
+  end
+
+  info[:arguments] = arguments
+
+  info
+end
+
+def normalize_class_name(class_name, super_class_name)
+  class_name = class_name.camelcase
+
+  case super_class_name
+  when 'ChatEventAction'
+    class_name.sub('ChatEvent', '')
+  when 'InputMessageContent'
+    class_name.sub('InputMessage', '')
+  when 'MessageContent'
+    class_name.sub('Message', '')
+  else
+    class_name
+  end
+end
+
+def build_hierarchy(classes)
+  hierarchy = {}
+
+  classes.each do |c|
+    (hierarchy[c[:super_class].camelcase] ||= []).push(normalize_class_name(c[:class], c[:super_class]))
+  end
+
+  hierarchy
+end
+
+def build_lookup_table(classes)
+  lookup_table = {}
+
+  classes.each do |c|
+    class_name       = normalize_class_name(c[:class], c[:super_class])
+    super_class_name = c[:super_class].camelcase
+
+    unless super_class_name == 'Base'
+      class_name = "#{super_class_name}::#{class_name.sub(super_class_name, '')}"
+    end
+
+    lookup_table[c[:class]] = class_name
+  end
+
+  lookup_table
+end
+
+# Splits tl file into usable chunks. Usually starts with a SuperClass followed by subclasses.
+def split_tl_file(tl_file, range = 0..-1)
+  # A fix for some entries (mainly chatAction ones) having a different structure from the rest
+  tl_file.gsub!(";\n//", ";\n\n//")
+
+  tl_file.split("\n\n\n")[range].map { |e| e.split("\n\n") }.flatten
+end
+
+# Partially taken from ActionView's word_wrap. Sowwy ;w;
+def wrap_comment(comment, indent = "  ", line_width: 117,
+                 start_sequence: "#{indent}# ",
+                 first_start_sequence: start_sequence,
+                 break_sequence: "\n#{indent}#   ")
+  comment.split('. ').map.with_index do |sentence, i|
+    this_start_sequence = i == 0 ? first_start_sequence : start_sequence
+
+    line = "#{this_start_sequence}#{sentence}.".split("\n").collect!.with_index do |line, j|
+      this_line_width = j == 0 ? line_width + 2 : line_width
+
+      line.length > this_line_width ? line.gsub(/(.{1,#{this_line_width}})(\s+|$)/, "\\1#{break_sequence}") : line
+    end.join(break_sequence)
+
+    if line.end_with?(break_sequence)
+      line = line[0..-(break_sequence.length + 1)]
+    end
+
+    line
+  end.join("\n")
+end
+
+def wrap_params(param_string, max_length, indent_num)
+  if param_string.length > max_length
+    param_string.gsub(/(.{1,#{max_length}})(\s+|$)/, "\\1\n#{' ' * indent_num}").strip
+  else
+    param_string
+  end
+end
+
+def type_to_comment_type(type)
+  type.gsub('TD::Types::Array.of(', 'Array<').gsub(')', '>').
+      gsub('TD::Types::Integer', 'Integer').
+      gsub('TD::Types::Float',   'Float').
+      gsub('TD::Types::String',  'String').
+      gsub('TD::Types::Bool',    'Boolean')
+end
+
+# Generates YARD documentation comment for each param
+def attrs_to_yard_comment(attrs, key = 'attr')
+  attrs.map do |attr, info|
+    type = type_to_comment_type(info[:type])
+    description = info[:description].gsub(@lookup_regex) do |m|
+      @lookup_table[m.strip] ? "#{m[0]}{TD::Types::#{@lookup_table[m.strip]}}#{m[-1]}" : m
+    end
+
+    wrap_comment(description, "  ",
+                 first_start_sequence: "  # @#{key} #{attr} [#{type}#{", nil" if info[:optional]}] ",
+                 start_sequence: "  #   ", break_sequence: "\n  #   ")
+  end.join("\n")
+end
+
+puts "Creating types directory"
+
+FileUtils.mkdir_p "types"
+
+puts "Writing Base class"
+
+klass = <<-RUBY
+module TD::Types
+  class Base < Dry::Struct
+    # throw an error when unknown keys provided
+    input input.strict
+    
+    # convert string keys to symbols
+    transform_keys(&:to_sym)
+    
+    # resolve default types on nil
+    transform_types do |type|
+      if type.default?
+        type.constructor do |value|
+          value.nil? ? Dry::Types::Undefined : value
+        end
+      else
+        type
+      end
+    end
+    
+    def to_hash
+      { '@type' => LOOKUP_TABLE.key(self.class.name.sub('TD::Types::', '')) }.merge(super)
+    end
+    alias_method :to_h, :to_hash
+    
+    def to_json(*args)
+      to_hash.to_json(*args)
+    end
+  end
+end
+RUBY
+
+File.write 'lib/tdlib/types/base.rb', klass
+
+puts "Parsing td_api.tl"
+
+# Reading the TL file and splitting it into classes and functions
+@classes, @functions = File.read(TD_API_TL_LOCATION).split("\n\n---functions---\n\n")
+
+# First entry in td_api.tl is typecasting, it's worthless for us.
+# Last entry before functions is a testing class, once again worthless
+@classes = split_tl_file(@classes, 1..-2)
+
+# Last function in td_api.tl is for testing, another worthless thing for us
+@functions = split_tl_file(@functions, 0..-2)
+
+puts "Converting classes into Ruby types"
+
+@classes = @classes.map { |c| parse_tl_entry(c) }
+@class_names = @classes.map { |c| normalize_class_name(c[:class], c[:super_class]) }
+@class_hierarchy = build_hierarchy(@classes)
+@lookup_table = build_lookup_table(@classes)
+@lookup_regex = Regexp.union(@lookup_table.keys.select { |k| k.match?(/[a-z]+[A-Z][a-z]+/) }.map { |k| /\W#{k}\W/ })
+
+@classes.each do |class_info|
+  class_name       = normalize_class_name(class_info[:class], class_info[:super_class])
+  attributes       = class_info[:arguments]
+  description      = class_info[:description]
+  super_class_name = class_info[:super_class].camelcase
+
+  if (subclasses = @class_hierarchy[class_info[:class]])
+    autoload_statements = <<-RUBY
+    %w[
+      #{subclasses.map { |c| c.sub(class_name, '').underscore }.join("\n      ")}
+    ].each do |type|
+      autoload TD::Types.camelize(type), "#{AUTOLOAD_BASE_DIR}/#{class_name.underscore}/\#{type}"
+    end
+    RUBY
+  else
+    autoload_statements = ""
+  end
+
+  if super_class_name == 'Base'
+    file_name  = class_name.underscore
+    class_name = "#{class_name} < Base"
+  else
+    file_name  = "#{super_class_name.underscore}/#{class_name.sub(super_class_name, '').underscore}"
+    class_name = "#{super_class_name}::#{class_name.sub(super_class_name, '')} < #{super_class_name}"
+
+    FileUtils.mkdir_p "types/#{super_class_name.underscore}"
+  end
+
+  if attributes.blank?
+    attributes_doc = ""
+    attributes     = ""
+  else
+    attributes_doc = "\n  #\n" + attrs_to_yard_comment(attributes, 'attr')
+
+    attributes = "\n    " + attributes.map do |attr, info|
+      "attribute :#{attr}, #{info[:type]}#{ ".optional.default(nil)" if info[:optional] }"
+    end.join("\n    ")
+  end
+
+  unless description.blank?
+    description = "\n#{wrap_comment(description, "  ")}"
+  end
+
+  klass = <<-RUBY
+module TD::Types#{description}#{attributes_doc}
+  class #{class_name}#{attributes}
+#{autoload_statements}  end
+end
+  RUBY
+
+  File.write "lib/tdlib/types/#{file_name}.rb", klass
+end
+
+puts "Generating Types class"
+
+lt_max_length = @lookup_table.max_by { |k,_| k.length }[0].length
+
+lookup_table = @lookup_table.map do |k,v|
+  indent = " " * (lt_max_length - k.length + 1)
+
+  "'#{k}'#{indent}=> '#{v}'"
+end
+
+klass = <<-RUBY
+require 'dry-struct'
+require 'dry-types'
+
+module TD::Types
+  include Dry::Types.module
+  
+  LOOKUP_TABLE = {
+      #{lookup_table.join(",\n      ")}
+  }.freeze
+  
+  module_function
+  
+  # Recursively wraps a hash into typed classes
+  def wrap(object)
+    # Wrapping each entry in array
+    if object.kind_of?(::Array)
+      object.map { |o| wrap(o) }
+    elsif object.kind_of?(::Hash)
+      type = object.delete('@type')
+      
+      object.each do |key, val|
+        if val.respond_to?(:each)
+          object[key] = wrap(val)
+        end
+      end
+      
+      unless type
+        return object
+      end
+      
+      if (klass = LOOKUP_TABLE[type])
+        const_get(klass).new(object)
+      else
+        raise ArgumentError.new("Can't find class for \#{type}")
+      end
+    else 
+      object
+    end
+  end
+  
+  # Simple implementation for internal use only.
+  def camelize(str)
+    str.gsub(/(?:_|(\\/)|^)([a-z\\d]*)/i) { "\#{$1}\#{$2.capitalize}" }
+  end
+  
+  %w[
+    #{(@class_hierarchy["Base"].map { |c| c.underscore } + ['base']).sort_by { |c| c }.join("\n    ")}
+  ].each do |type|
+    autoload camelize(type), "#{AUTOLOAD_BASE_DIR}/\#{type}"
+  end
+end
+RUBY
+
+File.write 'lib/tdlib/types.rb', klass
+
+puts "Converting functions"
+
+@functions = @functions.map { |c| parse_tl_entry(c) }.sort_by { |c| c[:class] }
+
+# Converts TDApi functions into methods. Still need human touch haha
+@functions = @functions.map do |func|
+  method_name  = func[:class].underscore
+  params       = func[:arguments]
+  description  = func[:description]
+  # TODO: Replace InputMessageContent and others (see #normalize_class_name)
+  return_class = type_to_comment_type("TD::Types::#{func[:super_class].camelcase}")
+
+  param_max_length = params.merge({'@type' => nil}).max_by { |k,_| k.length }[0].length
+
+  if params.blank?
+    params_doc      = ""
+    method_params   = ""
+    func_params = ""
+  else
+    params_doc = "\n" + attrs_to_yard_comment(params, 'param')
+
+    # TODO: Fix mixup of =nil params (only in set_password)
+    method_params = params.map do |attr, info|
+      "#{attr}#{ " = nil" if info[:optional] }"
+    end.join(", ")
+
+    method_params = "(#{wrap_params(method_params, 118 - (method_name.length + 5), method_name.length + 7)})"
+
+    func_params = ",\n              " + params.map do |attr, info|
+      indent = " " * (param_max_length - attr.length + 1)
+
+      "'#{attr}'#{indent}=> #{attr}"
+    end.join(",\n              ")
+  end
+
+  unless description.blank?
+    description = wrap_comment(description, "  ")
+  end
+
+  <<-RUBY
+#{description}
+  ##{params_doc}
+  # @return [#{return_class}]
+  def #{method_name}#{method_params}
+    broadcast('@type'#{" " * (param_max_length - 4)}=> '#{func[:class]}'#{func_params})
+  end
+  RUBY
+end
+
+klass = <<-RUBY
+# This is a generated module from current TDLib scheme
+# It contains all available TDLib methods
+module TD::ClientMethods
+#{@functions.join("  \n")}end
+RUBY
+
+File.write 'lib/tdlib/client_methods.rb', klass
+
+puts "Done. Please look through client_methods.rb carefully, especially the set_password method!"