telegram_on_steroids 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8b199b6308185d9af76185b1c0dd7ae5b796c636413d55699136083a5036dcf0
+  data.tar.gz: 6f6846c55fca2acad53138ac2ee2b1d4d666d74d207c5975433e94b47f4e6d44
+SHA512:
+  metadata.gz: 759c9ec914db75077d7bec322f0def4b4418b4f89e9ea62f0043b87920963ae290278496197c7006dce054092fe458fda02e3ed451fe4a49bcb5583648d1b53e
+  data.tar.gz: 49e7c96cb5eb47e16b8009faf453aea2e262cfa139c263d73f62a08f8afc9c89a0e1959bbdc64922db58f6c1fc7f1e455ab05216505a8cf7bc57667138e351df

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,20 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# juwelier generated
+pkg
+
+.idea
+
+*.gem

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "juwelier", "~> 2.1.0"
+  gem "simplecov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2024 Slaurmagan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= telegram_on_steroids
+
+Description goes here.
+
+== Contributing to telegram_on_steroids
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2024 Slaurmagan. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "telegram_on_steroids"
+  gem.homepage = "http://github.com/Slaurmagan/telegram_on_steroids"
+  gem.license = "MIT"
+  gem.summary = %Q{TODO: one-line summary of your gem}
+  gem.description = %Q{TODO: longer description of your gem}
+  gem.email = "hrakovich.dev@gmail.com"
+  gem.authors = ["Slaurmagan"]
+
+  # dependencies defined in Gemfile
+end
+Juwelier::RubygemsDotOrgTasks.new
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "telegram_on_steroids #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/examples/example_action.rb

@@ -0,0 +1,13 @@
+class ExampleAction < TelegramOnSteroids::Action
+  on_redirect do |action|
+    action.send_message text: 'Text'
+  end
+
+  on_message do |action|
+    action.send_message text: 'Text'
+  end
+
+  on_callback_query whitelist: [] do |action|
+    action.answer_callback_query
+  end
+end

data/lib/telegram_on_steroids/action.rb

@@ -0,0 +1,73 @@
+require 'forwardable'
+
+module TelegramOnSteroids
+  class Action
+    extend Forwardable
+
+    attr_reader :client, :session, :action, :request
+
+
+    class << self
+      def on(name, &block)
+        raise StandardError, "#{name} not allowed callback" unless TelegramOnSteroids::UPDATE_TYPES.include?(name.to_s)
+
+        define_method("on_#{name.to_s}") do
+          instance_variable_set('@on_callback', block)
+        end
+
+        define_method("__run_on_#{name.to_s}") do
+          return respond_with_keyboard if request.params.callback? && pagination_callback? && current_keyboard
+
+          instance_eval(&block)
+        end
+      end
+    end
+
+    def_delegators :@request, :params
+    def_delegators :@client, :send_message
+
+    def initialize(request:, client:, session:)
+      @request = request
+      @client = client
+      @session = session
+    end
+
+    attr_reader :request, :client, :session
+
+    def respond_with_keyboard(keyboard: current_keyboard)
+      keyboard_instance = keyboard.is_a?(Class) ? keyboard.new(request:, action: self) : keyboard
+      inline_keyboard = keyboard_instance.to_telegram_format
+      message_id = request.params.to_h.dig('callback_query', 'message', 'message_id')
+      text = keyboard_instance.text
+      session.write(:current_page, 1) unless keyboard == current_keyboard
+
+      if message_id
+        client.edit_message_text message_id:, text:, reply_markup: { inline_keyboard: }
+      else
+        client.send_message text:, reply_markup: { inline_keyboard: }
+      end
+      session.write(:keyboard, keyboard.is_a?(Class) ? keyboard.name : keyboard.class.name)
+    end
+
+    def answer_callback_query(**params)
+      client.answer_callback_query callback_query_id: request.params.to_h.dig('callback_query', 'id'), **params
+    end
+
+    def pagination_callback?
+      request.params.callback_data =~ /page/
+    end
+
+    def current_keyboard
+      return unless session.read(:keyboard)
+
+      Object.const_get(session.read(:keyboard))
+    end
+
+    def redirect_to=(klass)
+      @redirect_to = klass
+    end
+
+    attr_accessor :request, :client, :session
+    attr_reader :redirect_to
+  end
+end

data/lib/telegram_on_steroids/client.rb

@@ -0,0 +1,173 @@
+class TelegramOnSteroids::Client
+  API_VERSION = "5.5"
+  # WebhookConfigPath = Pathname.new("tmp/telegram_workflow/webhook_config.txt")
+
+  AVAILABLE_ACTIONS = %i(
+    getUpdates
+    getWebhookInfo
+
+    getMe
+    sendMessage
+    forwardMessage
+    copyMessage
+    sendPhoto
+    sendAudio
+    sendDocument
+    sendVideo
+    sendAnimation
+    sendVoice
+    sendVideoNote
+    sendMediaGroup
+    sendLocation
+    editMessageLiveLocation
+    stopMessageLiveLocation
+    sendVenue
+    sendContact
+    sendPoll
+    sendDice
+    sendChatAction
+    getUserProfilePhotos
+    getFile
+    kickChatMember
+    banChatMember
+    unbanChatMember
+    restrictChatMember
+    promoteChatMember
+    setChatAdministratorCustomTitle
+    banChatSenderChat
+    unbanChatSenderChat
+    setChatPermissions
+    exportChatInviteLink
+    createChatInviteLink
+    editChatInviteLink
+    revokeChatInviteLink
+    setChatPhoto
+    deleteChatPhoto
+    setChatTitle
+    setChatDescription
+    pinChatMessage
+    unpinChatMessage
+    unpinAllChatMessages
+    leaveChat
+    getChat
+    getChatAdministrators
+    getChatMembersCount
+    getChatMemberCount
+    getChatMember
+    setChatStickerSet
+    deleteChatStickerSet
+    answerCallbackQuery
+    setMyCommands
+    deleteMyCommands
+    getMyCommands
+
+    editMessageText
+    editMessageCaption
+    editMessageMedia
+    editMessageReplyMarkup
+    stopPoll
+    deleteMessage
+
+    sendSticker
+    getStickerSet
+    uploadStickerFile
+    createNewStickerSet
+    addStickerToSet
+    setStickerPositionInSet
+    deleteStickerFromSet
+    setStickerSetThumb
+
+    answerInlineQuery
+
+    sendInvoice
+    answerShippingQuery
+    answerPreCheckoutQuery
+
+    setPassportDataErrors
+
+    sendGame
+    setGameScore
+    getGameHighScores
+
+    logOut
+    close
+  )
+
+  DEPRECATED_ACTIONS = {
+    kickChatMember: :banChatMember,
+    getChatMembersCount: :getChatMemberCount
+  }
+
+  AVAILABLE_ACTIONS.each do |action|
+    method_name = action.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+
+    define_method(method_name) do |params = {}|
+      @inline ?
+        save_request(action, params) :
+        make_request(action, params)
+    end
+  end
+
+  attr_accessor :inline, :inline_request
+  attr_reader :api_url
+
+  def initialize(chat_id = nil)
+    @chat_id = chat_id
+    @api_url = "https://api.telegram.org/bot#{TelegramOnSteroids.config.api_token}"
+  end
+
+  def set_webhook(params = {})
+    make_request("setWebhook", params)
+    cached_webhook_config(params)
+  end
+
+  def delete_webhook(params = {})
+    make_request("deleteWebhook", params)
+    cached_webhook_config(params)
+  end
+
+  def __setup_webhook(webhook_url = TelegramOnSteroids.config.webhook_url, params = {})
+    TelegramOnSteroids.config.logger.info "[TelegramWorkflow] Checking webhook setup..."
+
+    webhook_params = { url: webhook_url, allowed_updates: [], **params }
+
+    if cached_webhook_config != webhook_params
+      TelegramOnSteroids.config.logger.info "[TelegramWorkflow] Setting up a new webhook..."
+      set_webhook(webhook_params)
+    end
+  end
+
+  private
+
+  def cached_webhook_config(new_config = nil)
+    return nil
+    unless WebhookConfigPath.exist?
+      WebhookConfigPath.dirname.mkpath
+      WebhookConfigPath.write(Marshal.dump({}))
+    end
+
+    if new_config.nil?
+      Marshal.load(WebhookConfigPath.read)
+    else
+      WebhookConfigPath.write(Marshal.dump(new_config))
+    end
+  end
+
+  def save_request(action, params = {})
+    @inline_request = { method: action, chat_id: @chat_id, **params }
+  end
+
+  def make_request(action, params = {})
+    request_type = :json
+
+    response = ::Retryable.retryable(tries: 3, on: HTTP::ConnectionError) do
+      ::HTTP.post("#{@api_url}/#{action}", request_type => { chat_id: @chat_id, **params })
+    end
+
+    if response.code != 200
+      raise StandardError, response.parse["description"]
+    end
+
+    response.parse
+  end
+end

data/lib/telegram_on_steroids/configurable.rb

@@ -0,0 +1,22 @@
+module TelegramOnSteroids
+  module Configurable
+    def configure(&block)
+      define_method(:configure!) do
+        instance_eval { block.call(self) }
+      end
+
+      define_method(:after_initialize) do
+        configure!
+      end
+    end
+
+    def callable(name)
+      attr_writer(name)
+
+      define_method(name) do
+        var = instance_variable_get("@#{name.to_s}")
+        var.is_a?(Proc) ? instance_eval(&var) : var
+      end
+    end
+  end
+end

data/lib/telegram_on_steroids/configuration.rb

@@ -0,0 +1,50 @@
+unless defined?(Rails)
+  require "logger"
+end
+
+module TelegramOnSteroids
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+      config.verify!
+
+      @__after_configuration.call(config) if @__after_configuration
+    end
+
+    def __after_configuration(&block)
+      @__after_configuration = block
+    end
+  end
+
+  class Configuration
+    attr_accessor :session_store, :logger, :client, :start_action, :webhook_url, :api_token,
+                  :webhook_params, :commands
+
+    REQUIRED_PARAMS = %i(start_action api_token)
+
+    def initialize
+      @client = TelegramOnSteroids::Client
+      @webhook_params = {}
+
+      if defined?(Rails)
+        @session_store = Rails.cache
+        @logger = Rails.logger
+      else
+        @session_store = InMemoryStore
+        @logger = Logger.new(STDOUT)
+      end
+    end
+
+    def verify!
+      blank_params = REQUIRED_PARAMS.select { |p| send(p).nil? }
+
+      if blank_params.any?
+        raise StandardError, blank_params
+      end
+    end
+  end
+end

data/lib/telegram_on_steroids/in_memory_store.rb

@@ -0,0 +1,13 @@
+class TelegramOnSteroids::InMemoryStore
+  def initialize
+    @store = {}
+  end
+
+  def read(key)
+    @store[key]
+  end
+
+  def write(key, value)
+    @store[key] = value
+  end
+end

data/lib/telegram_on_steroids/keyboard/button.rb

@@ -0,0 +1,16 @@
+class TelegramOnSteroids::Keyboard::Button
+  extend TelegramOnSteroids::Configurable
+
+  def initialize(text:, callback_data:, keyboard:)
+    @text = text
+    @callback_data = callback_data
+    @keyboard = keyboard
+  end
+
+  def to_telegram_format
+    text = @text.is_a?(Proc) ? keyboard.instance_eval(&@text) : @text
+    { text:, callback_data: }
+  end
+
+  attr_reader :text, :callback_data, :keyboard
+end

data/lib/telegram_on_steroids/keyboard/inline_keyboard.rb

@@ -0,0 +1 @@
+class TelegramOnSteroids::Keyboard::Inline < TelegramOnSteroids::Keyboard; end

data/lib/telegram_on_steroids/keyboard/paginatable.rb

@@ -0,0 +1,55 @@
+module TelegramOnSteroids::Keyboard::Paginatable
+  DEFAULT_PER_PAGE = 2
+
+  def paginatable
+    true
+  end
+
+  def to_telegram_format
+    action.session.write(:current_page, current_page)
+    return buttons if first_page? && last_page?
+
+    buttons[offset...offset + per_page].push(navigation_buttons)
+  end
+
+  def navigation_buttons
+    return [prev_button] if last_page?
+    return [next_button] if first_page?
+
+    [prev_button, next_button]
+  end
+
+  def per_page
+    @per_page || DEFAULT_PER_PAGE
+  end
+
+  def per_page=(val)
+    @per_page = val
+  end
+
+  def current_page
+    return action.session.read(:current_page) || 1 unless request.params.callback_data =~ /page/
+
+    request.params.callback_data.scan(/\d+/).first.to_i
+  end
+
+  def offset
+    (current_page - 1) * per_page
+  end
+
+  def last_page?
+    current_page * per_page >= buttons.size
+  end
+
+  def first_page?
+    current_page == 1
+  end
+
+  def prev_button
+    { text: '<< Prev', callback_data: "page_#{current_page - 1}" }
+  end
+
+  def next_button
+    { text: 'Next >>', callback_data: "page_#{current_page + 1}" }
+  end
+end

data/lib/telegram_on_steroids/keyboard/row.rb

@@ -0,0 +1,12 @@
+class TelegramOnSteroids::Keyboard::Row
+  def initialize(keyboard:)
+    @buttons = []
+    @keyboard = keyboard
+  end
+
+  def button(**button)
+    buttons.push(TelegramOnSteroids::Keyboard::Button.new(**button, keyboard:).to_telegram_format)
+  end
+
+  attr_reader :buttons, :keyboard
+end

data/lib/telegram_on_steroids/keyboard.rb

@@ -0,0 +1,32 @@
+module TelegramOnSteroids
+  class Keyboard
+    extend Configurable
+
+    callable :text
+
+    def initialize(request:, action:)
+      @request = request
+      @buttons = []
+      @action = action
+      after_initialize
+    end
+
+    def after_initialize; end
+
+    def button(**button)
+      @buttons.push([Button.new(**button, keyboard: self).to_telegram_format])
+    end
+
+    def row
+      row = Row.new(keyboard: self)
+      yield row
+      buttons.push(row.buttons)
+    end
+
+    def to_telegram_format
+      buttons
+    end
+
+    attr_reader :buttons, :request, :action
+  end
+end

data/lib/telegram_on_steroids/params.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class TelegramOnSteroids::Params
+  def initialize(params)
+    @params = params
+  end
+
+  def [](key)
+    @params[key]
+  end
+
+  def user
+    @user ||= message&.dig("from") ||
+      @params.dig("callback_query", "from") ||
+      @params.dig("pre_checkout_query", "from") ||
+      @params.dig("shipping_query", "from") ||
+      @params.dig("inline_query", "from") ||
+      @params.dig("chosen_inline_result", "from") ||
+      @params.dig("poll_answer", "user") ||
+      @params.dig("chat_join_request", "from")
+  end
+
+  def language_code
+    user&.dig("language_code") || "en"
+  end
+
+  def user_id
+    user&.dig("id")
+  end
+
+  def username
+    user&.dig("username")
+  end
+
+  def chat_id
+    chat&.dig("id")
+  end
+
+  def chat
+    @params.dig("message", "chat") ||
+      @params.dig("callback_query", "message", "chat") ||
+      @params.dig("edited_message", "chat") ||
+      @params.dig("channel_post", "chat") ||
+      @params.dig("edited_channel_post", "chat")
+  end
+
+  def message
+    @params["message"] ||
+      @params["edited_message"] ||
+      @params["channel_post"] ||
+      @params["edited_channel_post"]
+  end
+
+  def type
+    @type ||= (TelegramOnSteroids::UPDATE_TYPES & @params.keys).first
+  end
+
+  def message_text
+    message&.dig("text")
+  end
+
+  def callback_data
+    @params.dig("callback_query", "data")
+  end
+
+  def inline_data
+    @params.dig("inline_query", "query")
+  end
+
+  def callback?
+    !callback_data.nil?
+  end
+
+  def start?
+    !!message_text&.start_with?("/start")
+  end
+
+  def command?
+    !!message_text&.start_with?("/")
+  end
+
+  def deep_link_payload
+    match = /\A\/(startgroup|start) (?<payload>.+)\z/.match(message_text)
+    match["payload"] if match
+  end
+
+  def to_h
+    @params
+  end
+end

data/lib/telegram_on_steroids/process.rb

@@ -0,0 +1,78 @@
+class TelegramOnSteroids::Process
+  attr_reader :params, :client, :session
+
+  def initialize(raw_params)
+    @params  = TelegramOnSteroids::Params.new(raw_params)
+    @session = TelegramOnSteroids::Session.new(@params)
+    chat_id = @params.chat_id
+    @client = TelegramOnSteroids.config.client.new(chat_id)
+    @logger = TelegramOnSteroids.config.logger
+
+    if TelegramOnSteroids.config.commands.keys.include?(params.message_text)
+      set_current_action(TelegramOnSteroids.config.commands[params.message_text])
+    end
+  end
+
+  def log_request
+    @logger.info "[TelegramOnSteroids] Processing by #{current_action.class.name}##{current_step}"
+    @logger.info "[TelegramOnSteroids] Params: #{params.to_h}"
+  end
+
+  def process
+    log_request
+
+    if current_action.respond_to?("__run_on_#{params.type}".to_sym)
+      current_action.send("__run_on_#{params.type}".to_sym)
+    else
+      current_action.__run_on_message if current_action.respond_to?(:__run_on_message)
+    end
+
+    session.write(:current_page, 1) unless params.callback?
+
+    if current_action.redirect_to
+      do_redirect
+    end
+
+    @session.dump
+
+    @client.inline_request
+  end
+
+  private
+
+  def current_action
+    @current_action ||= begin
+                          action_class = if action = session.read(:current_action)
+                                           Object.const_get(action)
+                                         else
+                                           TelegramOnSteroids.config.start_action
+                                         end
+
+                          action_class.new(request: self, client: @client, session:)
+                        end
+  end
+
+  def set_current_action(action_class)
+    session.write(:current_action, action_class.to_s)
+    set_current_step(nil)
+    session.reset_flash
+
+    @current_action = action_class.new(request: self, client: @client, session:)
+  end
+
+  def current_step
+    @session.read(:current_step) || :initial
+  end
+
+  def set_current_step(step)
+    @session.write(:current_step, step)
+  end
+
+  def do_redirect
+    action_or_step = @redirect_to
+    session_params = @session_params
+
+    set_current_action(current_action.redirect_to)
+    current_action.__run_on_redirect
+  end
+end

data/lib/telegram_on_steroids/session.rb

@@ -0,0 +1,52 @@
+class TelegramOnSteroids::Session
+  def initialize(params)
+    @session_id = [params.user_id, params.chat_id].join('.')
+    @store = TelegramOnSteroids.config.session_store
+    @session = if serialized_session = @store.read(@session_id)
+                 Oj.load(serialized_session)
+               else
+                 {}
+               end
+  end
+
+  def read(key)
+    @session[key]
+  end
+
+  def write(key, value)
+    @session[key] = value
+  end
+
+  def delete(key)
+    @session.delete(key)
+  end
+
+  def clear
+    @session.clear
+  end
+
+  def dump
+    @session_id && @store.write(@session_id, Oj.dump(@session))
+  end
+
+  # this is a user space to store some session data separately from the gem session
+  def user_session
+    @session_id ?
+      @session[:user_session] ||= {} :
+      NullSession.new
+  end
+
+  # this is a temporary per-action store
+  def flash
+    @session_id ?
+      @session[:flash] ||= {} :
+      NullSession.new
+  end
+
+  def reset_flash
+    flash.clear
+  end
+
+  class NullSession < Hash
+  end
+end

data/lib/telegram_on_steroids/updates.rb

@@ -0,0 +1,24 @@
+class TelegramOnSteroids::Updates
+  attr_writer :stop
+
+  def initialize(params)
+    @params = params
+  end
+
+  def enum
+    Enumerator.new do |y|
+      loop do
+        break if @stop
+
+        updates = TelegramOnSteroids::Client.new.get_updates(@params)["result"]
+        updates.each do |update|
+          y << update
+        end
+
+        if updates.any?
+          @params.merge! offset: updates.last["update_id"] + 1
+        end
+      end
+    end
+  end
+end

data/lib/telegram_on_steroids/version.rb

@@ -0,0 +1,3 @@
+module TelegramOnSteroids
+  VERSION = '0.1.0'
+end

data/lib/telegram_on_steroids.rb

@@ -0,0 +1,37 @@
+require_relative './telegram_on_steroids/configurable'
+require_relative './telegram_on_steroids/keyboard'
+require_relative './telegram_on_steroids/keyboard/inline_keyboard'
+require_relative './telegram_on_steroids/keyboard/paginatable'
+require_relative './telegram_on_steroids/keyboard/button'
+require_relative './telegram_on_steroids/keyboard/row'
+require_relative './telegram_on_steroids/action'
+require_relative './telegram_on_steroids/client'
+require_relative './telegram_on_steroids/params'
+require_relative './telegram_on_steroids/updates'
+require_relative './telegram_on_steroids/configuration'
+require_relative './telegram_on_steroids/process'
+require_relative './telegram_on_steroids/session'
+require_relative './telegram_on_steroids/version'
+require_relative './telegram_on_steroids/in_memory_store'
+
+module TelegramOnSteroids
+  UPDATE_TYPES = %w[message edited_message channel_post edited_channel_post message_reaction message_reaction_count inline_query chosen_inline_request callback_query shipping_query poll poll_answer my_chat_member chat_member chat_join_request chat_boost removed_chat_boost]
+
+  def self.process(params)
+    Process.new(params).process
+  end
+
+  def self.updates(offset: nil, limit: nil, timeout: 60, allowed_updates: nil)
+    params = {}
+    params[:offset] = offset if offset
+    params[:limit] = limit if limit
+    params[:timeout] = timeout if timeout
+    params[:allowed_updates] = allowed_updates if allowed_updates
+
+    (@updates = Updates.new(params)).enum
+  end
+
+  def self.stop_updates
+    @updates && @updates.stop = true
+  end
+end

data/telegram_on_steroids.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/telegram_on_steroids/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "telegram_on_steroids"
+  spec.version       = TelegramOnSteroids::VERSION
+  spec.authors       = ["Aliaksandr Hrakovich"]
+
+  spec.summary       = %q{A simple library to create Telegram Bots in Ruby.}
+  spec.homepage      = "https://github.com/slaurmagan/telegram_on_steroids"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.add_development_dependency "activesupport", "~> 5.2.0"
+  spec.add_dependency "http"
+  spec.add_dependency "retryable"
+  spec.add_dependency "oj"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.require_paths = ["lib"]
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|example)/}) }
+  end
+
+  spec.license       = "MIT"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: telegram_on_steroids
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aliaksandr Hrakovich
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- examples/example_action.rb
+- lib/telegram_on_steroids.rb
+- lib/telegram_on_steroids/action.rb
+- lib/telegram_on_steroids/client.rb
+- lib/telegram_on_steroids/configurable.rb
+- lib/telegram_on_steroids/configuration.rb
+- lib/telegram_on_steroids/in_memory_store.rb
+- lib/telegram_on_steroids/keyboard.rb
+- lib/telegram_on_steroids/keyboard/button.rb
+- lib/telegram_on_steroids/keyboard/inline_keyboard.rb
+- lib/telegram_on_steroids/keyboard/paginatable.rb
+- lib/telegram_on_steroids/keyboard/row.rb
+- lib/telegram_on_steroids/params.rb
+- lib/telegram_on_steroids/process.rb
+- lib/telegram_on_steroids/session.rb
+- lib/telegram_on_steroids/updates.rb
+- lib/telegram_on_steroids/version.rb
+- telegram_on_steroids.gemspec
+homepage: https://github.com/slaurmagan/telegram_on_steroids
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/slaurmagan/telegram_on_steroids
+  source_code_uri: https://github.com/slaurmagan/telegram_on_steroids
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: A simple library to create Telegram Bots in Ruby.
+test_files: []