telegram-bot-ruby 2.4.0 → 2.5.0

data/rakelib/builders/type_builder.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Builders
+  class TypeBuilder
+    DRY_TYPES = %w[string integer float decimal array hash symbol boolean date date_time time range].freeze
+
+    attr_reader :name, :attributes, :templates_dir
+
+    def initialize(name, attributes, templates_dir:)
+      @name = name
+      @attributes = deep_dup(attributes)
+      @templates_dir = templates_dir
+    end
+
+    def build
+      if empty_type?
+        build_empty_type
+      else
+        build_full_type
+      end
+    end
+
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub('::', '/')
+                      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                      .tr('-', '_')
+                      .downcase
+    end
+
+    private
+
+    def empty_type?
+      attributes[:type].is_a?(Array)
+    end
+
+    def build_empty_type
+      attrs = attributes[:type].join(" |\n        ")
+      render_template('empty_type.erb', name: name, attributes: attrs)
+    end
+
+    def build_full_type
+      process_attributes!
+      render_template('type.erb', name: name, attributes: attributes)
+    end
+
+    def process_attributes!
+      attributes.each_pair do |attr_name, properties|
+        process_attribute!(attr_name, properties)
+      end
+    end
+
+    def process_attribute!(attr_name, properties)
+      process_type!(attr_name, properties)
+      process_items!(attr_name, properties)
+
+      original_type = properties[:type]
+      apply_required!(attr_name, properties, original_type)
+      apply_min_max!(attr_name, properties)
+      apply_default!(attr_name, properties, original_type)
+
+      normalize_boolean_type!(attr_name)
+    end
+
+    def normalize_boolean_type!(attr_name)
+      attributes[attr_name][:type] = 'Types::True' if attributes[attr_name][:type] == 'Types::Boolean.default(true)'
+      attributes[attr_name][:type] = attributes[attr_name][:type].gsub('Types::Boolean', 'Types::Bool')
+    end
+
+    def process_type!(attr_name, properties)
+      attributes[attr_name][:type] = if properties[:type].is_a?(Array)
+                                       properties[:type].map { |t| add_module_types(t) }.join(' | ')
+                                     else
+                                       add_module_types(properties[:type])
+                                     end
+    end
+
+    def process_items!(attr_name, properties)
+      if properties[:items].is_a?(String)
+        attributes[attr_name][:type] += ".of(#{add_module_types(properties[:items])})"
+      elsif properties[:items] && properties[:items][:type] == 'array'
+        attributes[attr_name][:type] += ".of(Types::Array.of(#{properties[:items][:items]}))"
+      end
+    end
+
+    def apply_required!(attr_name, properties, original_type)
+      return unless properties[:required_value]
+
+      attributes[attr_name][:type] += ".constrained(eql: #{typecast(original_type, properties[:required_value])})"
+    end
+
+    def apply_min_max!(attr_name, properties)
+      return unless properties[:min_size] || properties[:max_size]
+
+      constrain = '.constrained(minmax)'
+      constrain = properties[:min_size] ? constrain.gsub('min', "min_size: #{properties[:min_size]}, ") : ''
+      constrain = constrain.gsub('max', "max_size: #{properties[:max_size]}") if properties[:max_size]
+      attributes[attr_name][:type] += constrain
+    end
+
+    def apply_default!(attr_name, properties, original_type)
+      return if properties[:default].nil?
+
+      attributes[attr_name][:type] += ".default(#{typecast(original_type, properties[:default])})"
+    end
+
+    def add_module_types(type)
+      return 'Types::Float' if type == 'number'
+
+      DRY_TYPES.include?(type) ? "Types::#{type.capitalize}" : type
+    end
+
+    def typecast(type, obj)
+      type == 'Types::String' ? "'#{obj}'" : obj
+    end
+
+    def render_template(template_name, vars)
+      template_path = File.join(templates_dir, template_name)
+      template = ERB.new(File.read(template_path))
+
+      # Create binding with the variables
+      b = binding
+      vars.each { |k, v| b.local_variable_set(k, v) }
+
+      template.result(b).gsub("      \n", '')
+    end
+
+    def deep_dup(hash)
+      hash.transform_values do |v|
+        case v
+        when Hash then deep_dup(v)
+        when Array then v.dup
+        else v
+        end
+      end
+    end
+  end
+end

data/rakelib/parse.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'parsers/types_parser'
+require_relative 'parsers/methods_parser'
+
+namespace :parse do
+  desc 'Parse types from Telegram Bot API HTML documentation'
+  task :types do
+    puts 'Parsing types from Telegram Bot API...'
+
+    result = Parsers::TypesParser.new.parse
+
+    puts "Found #{result.keys.count} types"
+
+    File.write "#{__dir__}/../data/types.json", JSON.pretty_generate(result)
+    puts 'Written to data/types.json'
+  end
+
+  desc 'Parse methods from Telegram Bot API HTML documentation'
+  task :methods do
+    puts 'Parsing methods from Telegram Bot API...'
+
+    result = Parsers::MethodsParser.new.parse
+
+    puts "Found #{result.keys.count} methods"
+
+    File.write "#{__dir__}/../data/methods.json", JSON.pretty_generate(result)
+    puts 'Written to data/methods.json'
+  end
+end

data/rakelib/parsers/methods_parser.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'net/http'
+
+module Parsers
+  class MethodsParser
+    API_URL = 'https://core.telegram.org/bots/api'
+
+    def parse
+      doc = fetch_document
+      result = {}
+
+      method_headers(doc).each do |header|
+        method_name = extract_method_name(header)
+        next unless method_name
+
+        return_type = extract_return_type(header)
+        result[method_name] = return_type if return_type
+      end
+
+      result
+    end
+
+    private
+
+    def fetch_document
+      uri = URI.parse(API_URL)
+      response = Net::HTTP.get(uri)
+      Nokogiri::HTML(response)
+    end
+
+    def method_headers(doc)
+      doc.css('h4')
+    end
+
+    def extract_method_name(header)
+      name = header.text.strip
+      # Methods start with lowercase letter (camelCase)
+      # Types start with uppercase (PascalCase) - skip those
+      return nil unless name.match?(/\A[a-z][a-zA-Z0-9]*\z/)
+
+      name
+    end
+
+    def extract_return_type(header)
+      # Find description paragraphs after the header
+      sibling = header.next_element
+
+      while sibling
+        break if sibling.name == 'h4' # Next section
+
+        if sibling.name == 'p'
+          return_type = parse_return_statement(sibling)
+          return return_type if return_type
+        end
+
+        sibling = sibling.next_element
+      end
+
+      nil
+    end
+
+    def parse_return_statement(paragraph)
+      html = paragraph.inner_html
+
+      # Pattern: Returns an Array of <a>Type</a>
+      if (match = html.match(%r{Returns an Array of <a[^>]*>([^<]+)</a>}i))
+        return "Array<#{match[1]}>"
+      end
+
+      # Pattern: On success, an array of <a>Type</a> (lowercase)
+      if (match = html.match(%r{On success,? an array of <a[^>]*>([^<]+)</a>}i))
+        return "Array<#{match[1]}>"
+      end
+
+      # Pattern: Returns a <a>Type</a> or Returns the <a>Type</a>
+      if (match = html.match(%r{Returns (?:a |the )?.*?<a[^>]*>([^<]+)</a>}i))
+        return match[1]
+      end
+
+      # Pattern: Returns basic information ... in form of a <a>Type</a>
+      if (match = html.match(%r{in form of a <a[^>]*>([^<]+)</a>}i))
+        return match[1]
+      end
+
+      # Pattern: <a>Type</a> is returned, otherwise True is returned (union type)
+      # e.g., "the edited Message is returned, otherwise True is returned"
+      if (match = html.match(%r{<a[^>]*>([^<]+)</a> is returned,? otherwise <em>True</em> is returned}i))
+        return "#{match[1]} | Boolean"
+      end
+
+      # Pattern: Returns <em>True</em> or On success, <em>True</em> is returned
+      return 'Boolean' if html.match?(%r{<em>True</em>(?:\s+(?:is|on)|\s*\.)}i)
+
+      # Pattern: On success, a <a>Type</a> object is returned
+      if (match = html.match(%r{On success,? a <a[^>]*>([^<]+)</a> object is returned}i))
+        return match[1]
+      end
+
+      # Pattern: On success, the <a>Type</a> is returned / the edited/sent/stopped <a>X</a> is returned
+      if (match = html.match(%r{the (?:sent |edited |stopped )?<a[^>]*>([^<]+)</a> is returned}i))
+        return match[1]
+      end
+
+      # Pattern: Returns <em>Int</em> or Integer
+      return 'Integer' if html.match?(%r{Returns <em>Int</em>}i)
+
+      # Pattern: Returns ... as <em>String</em>
+      return 'String' if html.match?(%r{as <em>String</em>}i)
+
+      nil
+    end
+  end
+end

data/rakelib/parsers/types_parser.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'net/http'
+
+module Parsers
+  class TypesParser
+    API_URL = 'https://core.telegram.org/bots/api'
+
+    PRIMITIVE_TYPES = {
+      'String' => 'string',
+      'Integer' => 'integer',
+      'Boolean' => 'boolean',
+      'Float' => 'number',
+      'True' => 'boolean'
+    }.freeze
+
+    def parse
+      doc = fetch_document
+      result = {}
+
+      type_headers(doc).each do |header|
+        type_name = extract_type_name(header)
+        next unless type_name
+
+        type_data = parse_type(header, type_name)
+        result[type_name] = type_data if type_data
+      end
+
+      result
+    end
+
+    private
+
+    def fetch_document
+      uri = URI.parse(API_URL)
+      response = Net::HTTP.get(uri)
+      Nokogiri::HTML(response)
+    end
+
+    def type_headers(doc)
+      doc.css('h4')
+    end
+
+    def extract_type_name(header)
+      name = header.text.strip
+      # Types start with uppercase letter (CapitalCase)
+      # Methods start with lowercase (camelCase) - skip those
+      return nil unless name.match?(/\A[A-Z][a-zA-Z0-9]*\z/)
+
+      name
+    end
+
+    def parse_type(header, _type_name)
+      # Check if this is a union type (list of types without a table)
+      next_sibling = find_next_significant_sibling(header)
+
+      if union_type?(next_sibling)
+        parse_union_type(next_sibling)
+      else
+        parse_table_type(header)
+      end
+    end
+
+    def find_next_significant_sibling(header)
+      sibling = header.next_element
+      # Skip description paragraphs
+      sibling = sibling.next_element while sibling && sibling.name == 'p'
+      sibling
+    end
+
+    def union_type?(element)
+      element&.name == 'ul'
+    end
+
+    def parse_union_type(ul_element)
+      types = ul_element.css('li a').map { |a| a.text.strip }
+      { 'type' => types }
+    end
+
+    def parse_table_type(header)
+      table = find_attribute_table(header)
+      return {} unless table
+
+      attributes = {}
+      table.css('tbody tr').each do |row|
+        cells = row.css('td')
+        next unless cells.length >= 3
+
+        field_name = cells[0].text.strip
+        type_info = cells[1]
+        description_cell = cells[2]
+
+        attributes[field_name] = parse_attribute(type_info, description_cell)
+      end
+
+      attributes
+    end
+
+    def find_attribute_table(header)
+      sibling = header.next_element
+      while sibling
+        return sibling if sibling.name == 'table'
+        # Stop if we hit another h4 (next type/method)
+        break if sibling.name == 'h4'
+
+        sibling = sibling.next_element
+      end
+      nil
+    end
+
+    def parse_attribute(type_cell, description_cell)
+      attribute = {}
+      raw_type = type_cell.text.strip
+      description = description_cell.text.strip
+      description_html = description_cell.inner_html
+
+      # Parse type
+      type_value = parse_type_value(type_cell)
+      if type_value.is_a?(Hash)
+        attribute.merge!(type_value)
+      else
+        attribute['type'] = type_value
+      end
+
+      # Parse required (absence of "Optional" at start of description)
+      attribute['required'] = true unless description.start_with?('Optional')
+
+      # Parse required_value (always "X" or must be <em>X</em>)
+      required_value = extract_required_value(description, description_html)
+      if required_value
+        attribute['required_value'] = required_value
+        attribute['default'] = required_value
+      end
+
+      # Parse size constraints (N-M characters or must be between)
+      min_size, max_size = extract_size_constraints(description)
+      attribute['min_size'] = min_size if min_size
+      attribute['max_size'] = max_size if max_size
+
+      # Parse default value (Defaults to X)
+      # If HTML type is 'True' (not 'Boolean'), it means the field only exists when true
+      if raw_type == 'True' && !attribute.key?('default')
+        attribute['default'] = true
+      elsif !attribute.key?('default')
+        default = extract_default_value(description, description_html, attribute['type'])
+        attribute['default'] = default unless default.nil?
+      end
+
+      # Clean up: remove required if false
+      attribute.delete('required') unless attribute['required']
+
+      attribute
+    end
+
+    def parse_type_value(type_cell)
+      text = type_cell.text.strip
+      links = type_cell.css('a')
+
+      # Check for "Array of X"
+      if text.start_with?('Array of')
+        items_type = parse_array_items(type_cell, text)
+        return { 'type' => 'array', 'items' => items_type }
+      end
+
+      # Check for union type "X or Y"
+      if text.include?(' or ')
+        types = parse_union_types(type_cell, text)
+        return types.length == 1 ? normalize_type(types.first) : types.map { |t| normalize_type(t) }
+      end
+
+      # Single type
+      if links.any?
+        normalize_type(links.first.text.strip)
+      else
+        normalize_type(text)
+      end
+    end
+
+    def parse_array_items(type_cell, text)
+      # Handle "Array of Array of X"
+      if text.include?('Array of Array of')
+        inner_type = type_cell.css('a').last&.text&.strip || text.split('Array of Array of').last.strip
+        return { 'type' => 'array', 'items' => normalize_type(inner_type) }
+      end
+
+      # Regular "Array of X"
+      link = type_cell.css('a').first
+      if link
+        normalize_type(link.text.strip)
+      else
+        # Primitive array like "Array of String"
+        items_text = text.sub('Array of ', '').strip
+        normalize_type(items_text)
+      end
+    end
+
+    def parse_union_types(type_cell, text)
+      links = type_cell.css('a')
+      if links.any?
+        links.map { |l| l.text.strip }
+      else
+        text.split(' or ').map(&:strip)
+      end
+    end
+
+    def normalize_type(type)
+      PRIMITIVE_TYPES[type] || type
+    end
+
+    def extract_required_value(description, description_html)
+      # Pattern: always "X" or always "X" (smart quotes)
+      match = description.match(/always ["\u201c]([^"\u201d]+)["\u201d]/i)
+      return match[1].delete('\\') if match
+
+      # Pattern: must be <em>X</em> (check inner HTML)
+      match = description_html.match(%r{must be <em>([^<]+)</em>}i)
+      return match[1] if match
+
+      nil
+    end
+
+    def extract_size_constraints(description)
+      min_size = nil
+      max_size = nil
+
+      # Pattern: N-M characters (covers 0-N and 1-N cases)
+      if (match = description.match(/(\d+)-(\d+) characters/))
+        min_val = match[1].to_i
+        max_size = match[2].to_i
+        min_size = min_val if min_val.positive?
+      # Pattern: must be between N and M
+      elsif (match = description.match(/must be between (\d+) and (\d+)/))
+        min_size = match[1].to_i
+        max_size = match[2].to_i
+      end
+
+      [min_size, max_size]
+    end
+
+    def extract_default_value(description, description_html, type)
+      # Pattern: Defaults to "X" (with smart quotes U+201C/U+201D)
+      if (match = description.match(/Defaults to \u201c([^\u201d]+)\u201d/i))
+        return cast_default_value(match[1], type)
+      end
+
+      # Pattern: Defaults to <em>X</em> (check inner HTML for em-wrapped values)
+      if (match = description_html.match(%r{Defaults to <em>([^<]+)</em>}i))
+        return cast_default_value(match[1], type)
+      end
+
+      # Pattern: Defaults to <number> (plain numeric values)
+      if (match = description.match(/Defaults to (\d+)/i))
+        return cast_default_value(match[1], type)
+      end
+
+      nil
+    end
+
+    def cast_default_value(value, type)
+      case type
+      when 'integer'
+        value.to_i
+      when 'boolean'
+        value.downcase == 'true'
+      when 'number'
+        value.to_f
+      else
+        value
+      end
+    end
+  end
+end

data/rakelib/rebuild.rake

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'builders/type_builder'
+require_relative 'builders/endpoints_builder'
+
+namespace :rebuild do
+  desc 'Rebuild types from type_attributes.json'
+  task :types do
+    types = JSON.parse(File.read("#{__dir__}/../data/types.json"), symbolize_names: true)
+    templates_dir = "#{__dir__}/templates"
+
+    types.each_pair do |name, attributes|
+      builder = Builders::TypeBuilder.new(name.to_s, attributes, templates_dir: templates_dir)
+      output_path = "#{__dir__}/../lib/telegram/bot/types/#{Builders::TypeBuilder.underscore(name)}.rb"
+
+      File.write(output_path, builder.build)
+    end
+  end
+
+  desc 'Rebuild API endpoints from method_return_types.json'
+  task :methods do
+    methods = JSON.parse(File.read("#{__dir__}/../data/methods.json"))
+    templates_dir = "#{__dir__}/templates"
+
+    builder = Builders::EndpointsBuilder.new(methods, templates_dir: templates_dir)
+
+    File.write "#{__dir__}/../lib/telegram/bot/api/endpoints.rb", builder.build
+  end
+end

data/rakelib/templates/endpoints.erb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Telegram
+  module Bot
+    class Api
+      ENDPOINTS = {
+<%- methods.each_with_index do |(name, return_type), index| -%>
+        '<%= name %>' => <%= return_type %><%= index == methods.size - 1 ? '' : ',' %>
+<%- end -%>
+      }.freeze
+    end
+  end
+end