telegram_workflow 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c96cb2e0a64ca84710249746fba7e205101fa03d3708f154e7b9532133c550f6
-  data.tar.gz: edf5c725fb5100eea709c375657026cc80d3e16075de537422f55604dea150b7
+  metadata.gz: 2fd629dee17a8e0caa932b91ad3cdccda3eba9e2cbd33dd15c57f38fcbb9aca7
+  data.tar.gz: e6ae112b2d49d6e9539549254605cc1ee8a5c57ac1421335195b531dd5ebde12
 SHA512:
-  metadata.gz: fb13268c4f33b5add25b82ccc628199aaec2571e57e8731f88b417c5727bb9c9d7639d860a7f6ef9af09110ba12a39db5c4d2ebbd777ea40e2f54c39d0d893ae
-  data.tar.gz: 5cdeb13d1098f17784dfdca787e2f73a0c8d8ee6cd704d42c5894b3de4b714b2cf1118ffbcd2f3391aa0e977b8a1c7806b3b3f606cf51e85e3df6074b6a61204
+  metadata.gz: '058ad9c7866ccd36ae2f5adc9a8c52c51364ecb84e1d0c3f7d39fd514f3868ba50745ff384485ab541988bbb87a1a725691c06d28b28f121cb7dfd36bfb8f3bb'
+  data.tar.gz: a5f3dc285f8fa706be2f9fad08d3cc192e6e90c256204e01befdce1ed547d9400de1a5e132cc750adbf369f18b064e019368df0b352836cc7bb3ecc23fd57b82

data/.github/workflows/ruby.yml

@@ -0,0 +1,41 @@
+name: Ruby
+
+on: [push]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.4', '2.5', '2.6', '2.7']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install packages
+      run: |
+        sudo apt update -qy
+        sudo apt install libdb-dev
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake
+    - name: Coveralls Parallel
+      uses: coverallsapp/github-action@master
+      with:
+        github-token: ${{ secrets.github_token }}
+        flag-name: run-${{ matrix.ruby-version }}
+        parallel: true
+
+  finish:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: Coveralls Finished
+      uses: coverallsapp/github-action@master
+      with:
+        github-token: ${{ secrets.github_token }}
+        parallel-finished: true

data/.gitignore

@@ -7,6 +7,7 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
+*.db
 
 # rspec failure tracking
 .rspec_status

data/Gemfile

@@ -7,5 +7,7 @@ gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 
 group :test do
-  gem "coveralls", require: false
+  gem "simplecov"
+  gem "simplecov-lcov", "~> 0.8.0"
+  gem "dbm"
 end

data/README.md

@@ -1,6 +1,6 @@
 # TelegramWorkflow
 
-[![Build Status](https://travis-ci.org/rsamoilov/telegram_workflow.svg?branch=master)](https://travis-ci.org/rsamoilov/telegram_workflow)
+![Build Status](https://github.com/rsamoilov/telegram_workflow/actions/workflows/ruby.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/rsamoilov/telegram_workflow/badge.svg?branch=master)](https://coveralls.io/github/rsamoilov/telegram_workflow?branch=master)
 [![Maintainability](https://api.codeclimate.com/v1/badges/fd13239262e3550c2193/maintainability)](https://codeclimate.com/github/rsamoilov/telegram_workflow/maintainability)
 
@@ -110,276 +110,13 @@ end
 Here you can see an example of redirection to another action.
 Having a bot logic split over such small actions improves code maintanability and allows to follow SRP.
 
-## Global Objects
+## Documentation
 
-Each action has a set of globally accessible objects:
+Please see the [TelegramWorkflow wiki](https://github.com/rsamoilov/telegram_workflow/wiki) for more detailed documentation.
 
-Object | Description
--------|------------
-[params](README.md#params) | Instance of `TelegramWorkflow::Params`.
-[client](README.md#client) | Instance of `TelegramWorkflow::Client`. Can be [customized](README.md#client-customization).
-[session](README.md#session) | Persistent store to keep session data. Instance of `Hash`.
-[flash](README.md#flash) | Temporary store to keep some data between different steps. Instance of `Hash`.
+## Example
 
-## Public API
-
-### params
-
-The `params` object encapsulates the logic to parse Telegram params.
-It implements useful methods, like `message_text`, `callback_data` or `deep_link_payload` to fetch user submitted data from the params.
-
-### client
-
-This is an instance of `TelegramWorkflow::Client` class, which implements a complete Telegram Bot API.
-The methods to access the API are called after raw Telegram API methods.
-For example, if you needed to call a [sendLocation](https://core.telegram.org/bots/api#sendlocation) method, you would use the following code:
-
-```ruby
-client.send_location latitude: 40.748, longitude: -73.985, live_period: 120
-```
-
-`chat_id` parameter should be omitted.
-
-### session
-
-This is a persistent store to save the data associated with a user, e.g. current user's id, some settings or anything you would store in a session in a regular web application.
-
-### flash
-
-This is a temporary store to save the data between the steps. The data persists while redirecting between the steps, but **gets deleted automatically when redirecting to another action**.
-
-### redirect_to(action_or_class, flash_params = {})
-
-As you already know, this function allows to build complex workflows by redirecting between actions and steps.
-The function expects either a symbol or instance of `Class` as a first argument. Passing a symbol will redirect to another step inside the current action. Passing instance of `Class` will redirect to another action.
-
-```ruby
-# redirect to a step
-redirect_to :suggest
-
-# redirect to an action
-redirect_to RateMovie
-```
-
-Sometimes you will need to share some data between the actions. You could use `session` for this, but a more appropriate solution would be to have `redirect_to` function to preserve the flash between actions.
-Check out this example:
-
-```ruby
-class AskForBirthday < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      client.send_message text: "What year is your birthday?"
-    end
-
-    on_message do
-      birthday = params.message_text.to_i
-      redirect_to DisplayAge, birthday: birthday
-    end
-  end
-end
-
-class DisplayAge < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      age = Date.today.year - flash[:birthday]
-      client.send_message text: "You are #{age}!"
-    end
-  end
-end
-```
-
-You can see that despite the fact that flash is being cleared when redirecting to another action, passing `birthday` value to the `redirect_to` call made it accessible via flash in the action we redirected to.
-
-## Configuration
-
-Configure the gem using the `TelegramWorkflow.configure` call.
-The two required parameters are `start_action` and `api_token`.
-
-```ruby
-TelegramWorkflow.configure do |config|
-  config.start_action = <Start Action Class>
-  config.api_token = <Your Token>
-end
-```
-
-Method | Default | Description
--------|---------|------------
-api_token | | This is the token you get from `@botfather` to access the Telegram API.
-start_action | | This is an entry-point action, which is called every time `/start` or `/startgroup` command is sent to the chat.  You cannnot redirect to this action or call it manually. Use it to set the things up, e.g. create a user record or store current user's id in the session.
-session_store | `Rails.cache` or `InMemoryStore.new` | This is the session store. Default implementation stores session in memory, which means it will be reset after server shutdown. Can be [customized](README.md#customization). Use `TelegramWorkflow::Stores::File` for persistent file store.
-logger | `Rails.logger` or `STDOUT` | Logger object. Can be [customized](README.md#customization).
-client | `TelegramWorkflow::Client` | The object which implements Telegram API. Can be [customized](README.md#client-customization).
-webhook_url | nil | The webhook url. Set it only if you are using webhooks for getting updates. TelegramWorkflow will create a webhook subscription automatically.
-
-## Updates
-
-The gem implements both methods of getting updates from the Telegram API.
-
-### Webhooks
-
-* Configure the gem with `webhook_url` value.
-* Process the updates with the following code in your controller:
-
-```ruby
-class TelegramWebhooksController < ApplicationController
-  def create
-    TelegramWorkflow.process(params)
-  end
-end
-```
-
-### Long polling
-
-* Make sure you don't configure the gem with `webhook_url` value.
-* Run the following code:
-
-```ruby
-TelegramWorkflow.updates.each do |params|
-  TelegramWorkflow.process(params)
-end
-```
-
-Be aware that `TelegramWorkflow.updates.each` call is blocking.
-
-`TelegramWorkflow` accepts all the parameters [getUpdates](https://core.telegram.org/bots/api#getupdates) does.
-
-```ruby
-TelegramWorkflow.updates(timeout: 60, allowed_updates: %w(channel_post edited_channel_post)).each do |params|
-  ...
-end
-```
-
-Since most of the time will be spent on waiting for the Telegram API to respond, you might also want to process the updates in parallel:
-
-```ruby
-require "concurrent-ruby"
-
-pool = Concurrent::CachedThreadPool.new
-
-TelegramWorkflow.updates.each do |params|
-  pool.post { TelegramWorkflow.process(params) }
-end
-```
-
-Use `stop_updates` call to exit the updates loop:
-
-```ruby
-trap "SIGINT" do
-  TelegramWorkflow.stop_updates
-end
-
-# decrease the timeout to wait no more than 10 seconds when exiting
-TelegramWorkflow.updates(timeout: 10).each do |params|
-  TelegramWorkflow.process(params)
-end
-
-```
-
-## Customization
-
-Object | Customization
--------|--------------
-logger | An object that responds to `info` and `error` methods.
-session_store | An object that responds to `read` and `write` methods. Refer to [InMemoryStore](lib/telegram_workflow/stores/in_memory.rb) class definition.
-client | An object that responds to `new(chat_id)` method.
-
-### Client Customization
-
-Use this customization to abstract your action's code from the Telegram API implementation details.
-
-Create a customized client:
-
-```ruby
-class MyClient < TelegramWorkflow::Client
-  def send_prize_location(user)
-    # this is an example call
-    prize = user.find_last_prize
-
-    send_venue latitude: prize.latitude,
-      longitude: prize.longitude,
-      address: prize.address
-      title: "Collect the last prize here!",
-      reply_markup: { keyboard: [[{ text: "Give me a hint" }], [{ text: "Give me anohter hint" }]] }
-  end
-end
-```
-
-Now, configure the gem to use the customized client:
-
-```ruby
-TelegramWorkflow.configure do |config|
-  config.client = MyClient
-end
-```
-
-Then, in your action:
-
-```ruby
-class FindPrize < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      client.send_prize_location(current_user)
-    end
-  end
-end
-```
-
-## Testing
-
-Testing utility provides `send_message` helper to emulate messages sent into the chat.
-
-```ruby
-# send a message
-send_message message_text: "text"
-
-# send CallbackQuery data
-send_message callback_data: "data"
-
-# send InlineQuery data
-send_message inline_data: "data"
-
-# customize the params
-send_message { |params| params[:edited_channel_post] = { text: "message" } }
-```
-
-Also, `subject.client` and `subject.flow` spies are available to track redirects and calls to the API client inside your actions.
-Store your tests under `spec/telegram_actions` or tag them with `type: :telegram_action`.
-
-Suppose we have the following action:
-
-```ruby
-class AskForBirthday < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      client.send_message text: "What year is your birthday?"
-    end
-
-    on_message do
-      Birthday.create! date: params.message_text
-      redirect_to DisplayAge
-    end
-  end
-end
-```
-
-Now, let's add some tests for this action:
-
-```ruby
-require "telegram_workflow/rspec"
-
-RSpec.describe AskForBirthday, type: :telegram_action do
-  it "asks for user's birthday" do
-    expect(subject.client).to have_received(:send_message).with(text: "What year is your birthday?")
-    expect {
-      send_message message_text: "10/10/2000"
-    }.to change { Birthday.count }.by(1)
-
-    expect(subject.flow).to have_received(:redirect_to).with(DisplayAge)
-  end
-end
-```
-
-As you can see, testing utility starts the flow automatically, calling `initial` step on `described_class`.
+Check out an example of a bot under [example](example) folder.
 
 ## Development
 

data/lib/telegram_workflow.rb

@@ -33,11 +33,12 @@ require "telegram_workflow/session"
 require "telegram_workflow/version"
 require "telegram_workflow/updates"
 require "telegram_workflow/workflow"
+require "telegram_workflow/input_file"
 require "telegram_workflow/stores/in_memory"
 require "telegram_workflow/stores/file"
 
 TelegramWorkflow.__after_configuration do |config|
   if config.webhook_url
-    TelegramWorkflow::Client.new.__setup_webhook
+    TelegramWorkflow::Client.new.__setup_webhook(config.webhook_url, config.webhook_params)
   end
 end

data/lib/telegram_workflow/client.rb

@@ -1,6 +1,6 @@
 class TelegramWorkflow::Client
-  API_VERSION = "4.8"
-  WebhookFilePath = Pathname.new("tmp/telegram_workflow/webhook_url.txt")
+  API_VERSION = "5.3"
+  WebhookConfigPath = Pathname.new("tmp/telegram_workflow/webhook_config.txt")
 
   AVAILABLE_ACTIONS = %i(
     getUpdates
@@ -9,6 +9,7 @@ class TelegramWorkflow::Client
     getMe
     sendMessage
     forwardMessage
+    copyMessage
     sendPhoto
     sendAudio
     sendDocument
@@ -28,27 +29,34 @@ class TelegramWorkflow::Client
     getUserProfilePhotos
     getFile
     kickChatMember
+    banChatMember
     unbanChatMember
     restrictChatMember
     promoteChatMember
     setChatAdministratorCustomTitle
     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
@@ -78,59 +86,85 @@ class TelegramWorkflow::Client
     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 = {}|
-      make_request(action, params)
+      if deprecated_in_favor_of = DEPRECATED_ACTIONS[action]
+        TelegramWorkflow.config.logger.warn "[TelegramWorkflow] #{action} action is deprecated. Use #{deprecated_in_favor_of} action instead."
+      end
+
+      @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
-    @webhook_url = TelegramWorkflow.config.webhook_url
     @api_url = "https://api.telegram.org/bot#{TelegramWorkflow.config.api_token}"
   end
 
   def set_webhook(params = {})
     make_request("setWebhook", params)
-    cached_webhook_url(new_url: @webhook_url)
+    cached_webhook_config(params)
   end
 
-  def delete_webhook
-    make_request("deleteWebhook", {})
-    cached_webhook_url(new_url: "")
+  def delete_webhook(params = {})
+    make_request("deleteWebhook", params)
+    cached_webhook_config(params)
   end
 
-  def __setup_webhook
+  def __setup_webhook(webhook_url = TelegramWorkflow.config.webhook_url, params = {})
     TelegramWorkflow.config.logger.info "[TelegramWorkflow] Checking webhook setup..."
 
-    if cached_webhook_url != @webhook_url
+    webhook_params = { url: webhook_url, allowed_updates: [], **params }
+
+    if cached_webhook_config != webhook_params
       TelegramWorkflow.config.logger.info "[TelegramWorkflow] Setting up a new webhook..."
-      set_webhook(url: @webhook_url)
+      set_webhook(webhook_params)
     end
   end
 
   private
 
-  def cached_webhook_url(new_url: nil)
-    unless WebhookFilePath.exist?
-      WebhookFilePath.dirname.mkpath
-      WebhookFilePath.write("")
+  def cached_webhook_config(new_config = nil)
+    unless WebhookConfigPath.exist?
+      WebhookConfigPath.dirname.mkpath
+      WebhookConfigPath.write(Marshal.dump({}))
     end
 
-    if new_url.nil?
-      WebhookFilePath.read
+    if new_config.nil?
+      Marshal.load(WebhookConfigPath.read)
     else
-      WebhookFilePath.write(new_url)
+      WebhookConfigPath.write(Marshal.dump(new_config))
     end
   end
 
-  def make_request(action, params)
+  def save_request(action, params = {})
+    raise TelegramWorkflow::Errors::DoubleInlineRequest if @inline_request
+    @inline_request = { method: action, chat_id: @chat_id, **params }
+  end
+
+  def make_request(action, params = {})
+    has_file_params = params.any? { |_, param| param.is_a?(TelegramWorkflow::InputFile) }
+    request_type = has_file_params ? :form : :json
+
     response = ::Retryable.retryable(tries: 3, on: HTTP::ConnectionError) do
-      ::HTTP.post("#{@api_url}/#{action}", json: { chat_id: @chat_id, **params })
+      ::HTTP.post("#{@api_url}/#{action}", request_type => { chat_id: @chat_id, **params })
     end
 
     if response.code != 200

data/lib/telegram_workflow/config.rb

@@ -21,12 +21,14 @@ module TelegramWorkflow
   end
 
   class Configuration
-    attr_accessor :session_store, :logger, :client, :start_action, :webhook_url, :api_token
+    attr_accessor :session_store, :logger, :client, :start_action, :webhook_url, :api_token,
+                  :webhook_params
 
     REQUIRED_PARAMS = %i(session_store start_action api_token)
 
     def initialize
       @client = TelegramWorkflow::Client
+      @webhook_params = {}
 
       if defined?(Rails)
         @session_store = Rails.cache

data/lib/telegram_workflow/errors.rb

@@ -11,12 +11,24 @@ module TelegramWorkflow::Errors
     end
   end
 
+  class StartRedirect < StandardError
+    def initialize(msg = "You cannot redirect to a start action.")
+      super
+    end
+  end
+
   class NoSession < StandardError
     def initialize(msg = "Session could not be fetched for this update.")
       super
     end
   end
 
+  class DoubleInlineRequest < StandardError
+    def initialize(msg = "Cannot send more than one request in a row in inline mode.")
+      super
+    end
+  end
+
   class ApiError < StandardError
   end
 

data/lib/telegram_workflow/input_file.rb

@@ -0,0 +1,2 @@
+class TelegramWorkflow::InputFile < HTTP::FormData::File
+end

data/lib/telegram_workflow/version.rb

@@ -1,3 +1,3 @@
 module TelegramWorkflow
-  VERSION = "1.2.0"
+  VERSION = "1.6.0"
 end

data/lib/telegram_workflow/workflow.rb

@@ -31,11 +31,14 @@ class TelegramWorkflow::Workflow
     end
 
     @session.dump
+
+    @client.inline_request
   end
 
   def redirect_to(action_or_step, session_params = nil)
     raise TelegramWorkflow::Errors::DoubleRedirect if @redirect_to
     raise TelegramWorkflow::Errors::SharedRedirect if action_or_step == :shared
+    raise TelegramWorkflow::Errors::StartRedirect  if action_or_step == TelegramWorkflow.config.start_action
 
     @redirect_to = action_or_step
     @session_params = session_params

data/telegram_workflow.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|example)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telegram_workflow
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Roman Samoilov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-21 00:00:00.000000000 Z
+date: 2021-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -66,15 +66,15 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.2.0
-description: 
-email: 
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -87,6 +87,7 @@ files:
 - lib/telegram_workflow/client.rb
 - lib/telegram_workflow/config.rb
 - lib/telegram_workflow/errors.rb
+- lib/telegram_workflow/input_file.rb
 - lib/telegram_workflow/params.rb
 - lib/telegram_workflow/rspec.rb
 - lib/telegram_workflow/session.rb
@@ -102,7 +103,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/rsamoilov/telegram_workflow
   source_code_uri: https://github.com/rsamoilov/telegram_workflow
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -118,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A simple library to create Telegram Bots in Ruby.
 test_files: []

data/.travis.yml

@@ -1,9 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.4.9
-  - 2.5.7
-  - 2.6.5
-  - 2.7.0
-before_install: gem install bundler