telegram_workflow 1.3.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f33398c3b33397236392a5b645e39b58827df8e453727fd06496ce0b4479e11
-  data.tar.gz: 9155e202748c8242adc4f4789623b8c42156658616e545d1aafd2aa4f2f776f7
+  metadata.gz: b7d04e49cdc1dbb680c62e9293eba4e3e8bc42aeb19f071a18e7461bb12cc85f
+  data.tar.gz: cfa4a8f4c2bfe5b8cca0b3f6d3ba425b87ee3da3458fe851aba0fe94cc6d8273
 SHA512:
-  metadata.gz: 4f85e7ab9b297deab054185d03863c8183bf7fbd6a7f1325ec612fa0042ee0999a700e80d91cb5cbed3b945605595904ec1716192b341d39f2402df805ea69f1
-  data.tar.gz: 67bf8b6d8abc59f26c2e302f989aaa17777303bc3efdfb29844686d35f62994a2257557e7838188292e2fbbecc7eb7d1ad872c3f123eb9eb1b61b686b046a5ba
+  metadata.gz: '058d9f15e33a4dccfc331a44dbaef37f41d2b03a83ebf4d8949613f160e3c7e7458423b81ac3171dec0b520464c15f37619480b87ffc347ab3fd387fef1b3de0'
+  data.tar.gz: 04f6bfc69e83f2cfc47e1ed1f88708d74ff899c4e6d49184ec0c10815799b1dfa7e1b42a0dcb9bf6afde3fe566e518c34210f3d0190d488ef2d062297db7e2de

data/.github/workflows/ruby.yml

@@ -0,0 +1,41 @@
+name: Ruby
+
+on: [push]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0', '3.1']
+
+    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/Gemfile

@@ -3,9 +3,11 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in telegram_workflow.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake", "~> 13.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,289 +110,9 @@ 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:
-
-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`.
-
-## 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.
-
-Use `TelegramWorkflow::InputFile` to upload a file:
-
-```ruby
-client.send_photo photo: TelegramWorkflow::InputFile.new("/Users/telegram/images/image1.jpg")
-```
-
-`filename` and `content_type` fields can be customized:
-
-```ruby
-file = StringIO.new("hello!")
-client.send_document document: TelegramWorkflow::InputFile.new(file, filename: "hello.txt")
-```
-
-### 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`.
+Please see the [TelegramWorkflow wiki](https://github.com/rsamoilov/telegram_workflow/wiki) for more detailed documentation.
 
 ## Example
 

data/lib/telegram_workflow/client.rb

@@ -1,6 +1,6 @@
 class TelegramWorkflow::Client
-  API_VERSION = "4.9"
-  WebhookFilePath = Pathname.new("tmp/telegram_workflow/webhook_url.txt")
+  API_VERSION = "5.5"
+  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,36 @@ class TelegramWorkflow::Client
     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
@@ -78,57 +88,80 @@ 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
 

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

@@ -23,6 +23,12 @@ module TelegramWorkflow::Errors
     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/params.rb

@@ -16,7 +16,8 @@ class TelegramWorkflow::Params
       @params.dig("shipping_query", "from") ||
       @params.dig("inline_query", "from") ||
       @params.dig("chosen_inline_result", "from") ||
-      @params.dig("poll_answer", "user")
+      @params.dig("poll_answer", "user") ||
+      @params.dig("chat_join_request", "from")
   end
 
   def language_code
@@ -32,11 +33,15 @@ class TelegramWorkflow::Params
   end
 
   def chat_id
-    @params.dig("message", "chat", "id") ||
-      @params.dig("callback_query", "message", "chat", "id") ||
-      @params.dig("edited_message", "chat", "id") ||
-      @params.dig("channel_post", "chat", "id") ||
-      @params.dig("edited_channel_post", "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

data/lib/telegram_workflow/version.rb

@@ -1,3 +1,3 @@
 module TelegramWorkflow
-  VERSION = "1.3.0"
+  VERSION = "1.7.0"
 end

data/lib/telegram_workflow/workflow.rb

@@ -31,6 +31,8 @@ class TelegramWorkflow::Workflow
     end
 
     @session.dump
+
+    @client.inline_request
   end
 
   def redirect_to(action_or_step, session_params = nil)

data/lib/telegram_workflow.rb

@@ -39,6 +39,6 @@ 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/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.3.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Roman Samoilov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2022-01-05 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
@@ -82,17 +82,6 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- example/Gemfile
-- example/README.md
-- example/actions/create_appointment.rb
-- example/actions/list_actions.rb
-- example/actions/list_appointments.rb
-- example/actions/select_doctor.rb
-- example/actions/start.rb
-- example/client.rb
-- example/environment.rb
-- example/flow.jpg
-- example/main.rb
 - lib/telegram_workflow.rb
 - lib/telegram_workflow/action.rb
 - lib/telegram_workflow/client.rb
@@ -114,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
@@ -130,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

data/example/Gemfile

@@ -1,2 +0,0 @@
-source "https://rubygems.org"
-gem "telegram_workflow"

data/example/README.md

@@ -1,79 +0,0 @@
-## Description
-
-This is a fully working example of a bot which allows you to book an appointment with a doctor.
-
-The following diagram will help you understand the bot's flow:
-<p>
-  <img src="https://github.com/rsamoilov/telegram_workflow/blob/master/example/flow.jpg" width="400">
-</p>
-
-## Running the bot
-
-First, open [main.rb](main.rb) and configure the bot with your API token:
-
-```diff
-TelegramWorkflow.configure do |config|
-- config.api_token = <YOUR_TOKEN>
-+ config.api_token = "123456780:ABCDE_my-token"
-end
-```
-
-Next, run the bot:
-
-```
-bundle
-ruby main.rb
-```
-
-## Configuration
-
-Every Bot workflow begins with **`on_message`** callback in a `start_action`.
-There's no need to store current user data in session in this example, so we simply redirect to the `ListActions` action, which will be our "main" action.
-
-```ruby
-class Actions::Start < TelegramWorkflow::Action
-  def initial
-    on_message do
-      redirect_to Actions::ListActions
-    end
-  end
-end
-```
-
-Next, the Telegram client can be customized. We want to use Telegram's [InlineKeyboard](https://core.telegram.org/bots#inline-keyboards-and-on-the-fly-updating) to provide a user with a list of available actions.
-
-Let's encapsulate this inside our custom client class:
-
-```ruby
-class Client < TelegramWorkflow::Client
-  def send_actions(message, actions)
-    send_message text: message, reply_markup: { inline_keyboard: actions }
-  end
-end
-```
-
-Now, let's configure the gem:
-
-```ruby
-TelegramWorkflow.configure do |config|
-  config.start_action = Actions::Start
-  config.client = Client
-  config.session_store = TelegramWorkflow::Stores::File.new
-end
-```
-
-The last configuration parameter here is `session_store`. We are using `TelegramWorkflow::Stores::File` - a built-in implementation of persistent file store.
-
-[getUpdates](https://core.telegram.org/bots/api#getupdates) method is used in this example to receive the updates:
-
-```ruby
-TelegramWorkflow.updates.each do |params|
-  TelegramWorkflow.process(params)
-end
-```
-
-After a user has sent a message, `TelegramWorkflow.process` will initialize the last processed action and step and then call `on_message` callback on it.
-
-## Actions
-
-Check out the bot's code under [actions](actions) folder.

data/example/actions/create_appointment.rb

@@ -1,56 +0,0 @@
-#
-# this is an action to create an appointment;
-# each method represents one of the steps for appointment creation;
-# for the sake of simplicity, all created appointments are stored in the session
-#
-class Actions::CreateAppointment < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      client.send_message text: "Enter patient's name:"
-    end
-
-    on_message do
-      flash[:name] = params.message_text
-      redirect_to :reason
-    end
-  end
-
-  def reason
-    on_redirect do
-      client.send_message text: "What is the reason for visit?"
-    end
-
-    on_message do
-      flash[:reason] = params.message_text
-      redirect_to :date
-    end
-  end
-
-  def date
-    on_redirect do
-      client.send_message text: "What date works best for you?"
-    end
-
-    on_message do
-      date = Date.parse(params.message_text) rescue nil
-
-      # there's no redirect in case the date is invalid;
-      # this means that next time a user sends a message, the current action will be executed again
-      if date
-        flash[:date] = date
-        redirect_to :done
-      else
-        client.send_message text: "Invalid date format. Please try again."
-      end
-    end
-  end
-
-  # `specialty` parameter is added to flash in previous `Actions::SelectDoctor` action
-  def done
-    on_redirect do
-      (session[:appointments] ||= []) << flash.slice(:name, :reason, :date, :specialty)
-      client.send_message text: "Your appointment has been created!"
-      redirect_to Actions::ListActions
-    end
-  end
-end

data/example/actions/list_actions.rb

@@ -1,28 +0,0 @@
-class Actions::ListActions < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      available_actions = [
-        [{ text: "Make an appointment", callback_data: "create" }]
-      ]
-
-      if session[:appointments]&.any?
-        available_actions.unshift [{ text: "List my appointments", callback_data: "list" }]
-      end
-
-      # this is the customized client object
-      client.send_actions "Select an action:", available_actions
-    end
-
-    # `params.callback_data` here will be one of the identifiers defined as `callback_data` in `available_actions` array
-    # refer to https://core.telegram.org/bots/api#inlinekeyboardbutton
-    on_message do
-      next_action = if params.callback_data == "create"
-        Actions::SelectDoctor
-      elsif params.callback_data == "list"
-        Actions::ListAppointments
-      end
-
-      redirect_to next_action
-    end
-  end
-end

data/example/actions/list_appointments.rb

@@ -1,13 +0,0 @@
-class Actions::ListAppointments < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      appointments = session[:appointments].map do |app|
-        "<b>#{app[:name]}</b> on #{app[:date].to_s}"
-      end
-
-      # refer to https://core.telegram.org/bots/api#sendmessage for the list of available parameters
-      client.send_message text: appointments.join("\n"), parse_mode: "HTML"
-      redirect_to Actions::ListActions
-    end
-  end
-end

data/example/actions/select_doctor.rb

@@ -1,19 +0,0 @@
-class Actions::SelectDoctor < TelegramWorkflow::Action
-  def initial
-    on_redirect do
-      available_doctors = [
-        [{ text: "Family Medicine", callback_data: "family" }],
-        [{ text: "Emergency Medicine", callback_data: "emergency" }],
-        [{ text: "Pediatrics", callback_data: "pediatrics" }]
-      ]
-
-      client.send_actions "Select a doctor:", available_doctors
-    end
-
-    on_message do
-      # pass `specialty` parameter to the next action
-      # https://github.com/rsamoilov/telegram_workflow#redirect_toaction_or_class-flash_params--
-      redirect_to Actions::CreateAppointment, specialty: params.callback_data
-    end
-  end
-end

data/example/actions/start.rb

@@ -1,9 +0,0 @@
-class Actions::Start < TelegramWorkflow::Action
-  def initial
-    # we don't need to store current user id in session or make any other setup,
-    # so just redirect to the `ListActions` action
-    on_message do
-      redirect_to Actions::ListActions
-    end
-  end
-end

data/example/client.rb

@@ -1,5 +0,0 @@
-class Client < TelegramWorkflow::Client
-  def send_actions(message, actions)
-    send_message text: message, reply_markup: { inline_keyboard: actions }
-  end
-end

data/example/environment.rb

@@ -1,13 +0,0 @@
-require "telegram_workflow"
-require "date"
-
-module Actions
-end
-
-dependencies = %w(
-  ./actions/*.rb
-  ./client.rb
-)
-dependencies.each do |path|
-  Dir[path].each { |path| require_relative path }
-end

data/example/main.rb

@@ -1,17 +0,0 @@
-require_relative "environment"
-
-TelegramWorkflow.configure do |config|
-  config.start_action = Actions::Start
-  config.client = Client
-  config.session_store = TelegramWorkflow::Stores::File.new
-  config.api_token = <YOUR_TOKEN>
-end
-
-trap "SIGINT" do
-  puts "Exiting..."
-  TelegramWorkflow.stop_updates
-end
-
-TelegramWorkflow.updates(timeout: 5).each do |params|
-  TelegramWorkflow.process(params)
-end