v0.14.4

Bump rake version to resolve vulnerability notification
Merge pull request #131 from telegram-bot-rb/update_api
2026-08-28 15:26:18 +03:00 · 2020-04-15 20:40:55 +03:00 · 2020-04-04 22:36:41 +03:00 · 2020-04-04 22:35:33 +03:00 · 2020-04-04 22:26:26 +03:00 · 2020-01-25 15:49:28 +03:00
--- a/.codeclimate.yml
+++ b/.codeclimate.yml
@@ -0,0 +1,8 @@
+checks:
+  method-complexity:
+    config:
+      threshold: 6 # should be just fine
+
+plugins:
+  rubocop:
+    enabled: true
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,3 +1,6 @@
+# Rubocop does not support 2.0
+Gemspec/RequiredRubyVersion: {Enabled: false}
+
 Rails: {Enabled: true}

 Layout/AlignParameters:
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,10 +1,31 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.2.3
+- 2.6
+- 2.5
 gemfile:
-  - gemfiles/rails_42.gemfile
-  - gemfiles/rails_50.gemfile
-  - gemfiles/rails_51.gemfile
+- gemfiles/rails_60.gemfile
+- gemfiles/rails_52.gemfile
+matrix:
+  include:
+  # old rails
+  - rvm: 2.5
+    gemfile: gemfiles/rails_51.gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rails_50.gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rails_42.gemfile
+  # old rubies
+  - rvm: 2.4
+    gemfile: gemfiles/rails_52.gemfile
+  - rvm: 2.3
+    gemfile: gemfiles/rails_52.gemfile
+  # future rails
+  - rvm: 2.5
+    gemfile: gemfiles/rails_61.gemfile
+  # Allow rails 6.1 to fail while master branch is used
+  allow_failures:
+  - rvm: 2.5
+    gemfile: gemfiles/rails_61.gemfile
 notifications:
  email: false
--- a/29
+++ b/29
@@ -1,14 +1,31 @@
+appraise 'rails-61' do
+  git 'https://github.com/rails/rails.git' do
+    gem 'actionpack', '~> 6.1.0.alpha'
+    gem 'railties', '~> 6.1.0.alpha'
+  end
+end
+
+appraise 'rails-60' do
+  gem 'actionpack', '~> 6.0.0'
+  gem 'railties', '~> 6.0.0'
+end
+
+appraise 'rails-52' do
+  gem 'actionpack', '~> 5.2.0'
+  gem 'railties', '~> 5.2.0'
+end
+
 appraise 'rails-51' do
-  gem 'actionpack', '~> 5.1'
-  gem 'railties', '~> 5.1'
+  gem 'actionpack', '~> 5.1.0'
+  gem 'railties', '~> 5.1.0'
 end

 appraise 'rails-50' do
-  gem 'actionpack', '~> 5.0'
-  gem 'railties', '~> 5.0'
+  gem 'actionpack', '~> 5.0.0'
+  gem 'railties', '~> 5.0.0'
 end

 appraise 'rails-42' do
-  gem 'actionpack', '~> 4.2'
-  gem 'railties', '~> 4.2'
+  gem 'actionpack', '~> 4.2.0'
+  gem 'railties', '~> 4.2.0'
 end
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,59 @@
 # Unreleased

+# 0.14.4
+
+- Update to Bot API 4.7
+
+# 0.14.3
+
+- Rails 6.0 support.
+- Update to Bot API 4.4.
+
+# 0.14.2
+
+- Add reply helpers: `answer_pre_checkout_query`, `answer_shipping_query`.
+- Update to Bot API 4.3.
+
+# 0.14.1
+
+- Read config from secrets when credentials don't provide it in rails >= 5.2.
+- Remove botan.io support. It's already shut down, so it should not be a braking change.
+  https://github.com/botanio/sdk#this-service-will-be-shut-down-on-25th-may-2018
+- Update to Bot API 4.1.
+
+# 0.14.0
+
+- Make integration & controller specs consistent.
+  __Breaking changes__ for controller specs:
+    - Changed signature `dispatch(bot, update) => dispatch(update, bot)`.
+    - `update` helper is symbolized by default.
+    - `build_update(type, data)` is dropped in favor of `deep_stringify(type => data)`.
+- Provide support for integration testing of bots in poller mode and non-Rails apps.
+  __Breaking changes__:
+    - Requiring `telegram/bot/rspec/integration` is deprecated in favor of
+      `telegram/bot/rspec/integration/rails`.
+    - `:telegram_bot` rspec tag is replaced with `telegram_bot: :rails`.
+- __Breaking change__. Use bang-methods as actions for commands.
+  This prevents calling context contextual actions and payload specific actions with commands.
+  Translation helper strips `!` from action name for lazy translations.
+- __Breaking change__. Drop `.context_handler`, `.context_to_action!` methods.
+  Use pass action name directly to `#save_context`.
+  It's the same as `.context_to_action!` is enabled by default.
+- Class-level helper for lazy translations.
+
+# 0.13.1
+
+- Extracted typed response mappings to telegram-bot-types gem.
+  It now provides definitions for all API v3.5 methods.
+- Fix #chat for non-message updates with TypedUpdates enabled
+
+# 0.13.0
+
+- `rescue_from`.
+- Support for `credentials` store in Rails 5.2.
+- Deprecate `telegram_webhooks` in favor of `telegram_webhook`.
+  It was too complicated and such routes looked ugly.
+
 # 0.12.4

 - Fix spec helpers for callback queries.
--- a/4
+++ b/4
@@ -8,13 +8,13 @@ group :development do
  gem 'pry-byebug', '~> 3.2.0'
  gem 'sdoc', '~> 0.4.1'

-  gem 'telegram-bot-types', '~> 0.3.0'
+  gem 'telegram-bot-types', '~> 0.6.2'

  gem 'rspec', '~> 3.5.0'
  gem 'rspec-its', '~> 1.1.0'
  gem 'rspec-rails', '~> 3.5.0'

-  gem 'rubocop', '~> 0.51.0'
+  gem 'rubocop', '~> 0.52.1'

  gem 'coveralls', '~> 0.8.2', require: false
 end
--- a/README.md
+++ b/README.md
@@ -4,6 +4,8 @@
 [![Code Climate](https://codeclimate.com/github/telegram-bot-rb/telegram-bot/badges/gpa.svg)](https://codeclimate.com/github/telegram-bot-rb/telegram-bot)
 [![Build Status](https://travis-ci.org/telegram-bot-rb/telegram-bot.svg)](https://travis-ci.org/telegram-bot-rb/telegram-bot)

+__Breaking changes in v0.14!__ See [upgrade guide](https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14).
+
 Tools for developing Telegram bots. Best used with Rails, but can be used in
 [standalone app](https://github.com/telegram-bot-rb/telegram-bot/wiki/Not-rails-application).
 Supposed to be used in webhook-mode in production, and poller-mode
@@ -11,13 +13,13 @@ in development, but you can use poller in production if you want.

 Package contains:

- Ligthweight client for bot API (with fast and thread-safe
+- Lightweight client for bot API (with fast and thread-safe
  [httpclient](https://github.com/nahi/httpclient) under the hood).
 - Controller with message parser: define methods for commands, not `case` branches.
 - Middleware and routes helpers for production env.
 - Poller with automatic source-reloader for development env.
 - Rake tasks to update webhook urls.
- __[Async mode](#async-mode)__ for Telegram and/or Botan API.
+- __[Async mode](#async-mode)__.
  Let the queue adapter handle network errors!

 Here is sample [telegram_bot_app](https://github.com/telegram-bot-rb/telegram_bot_app)
@@ -53,9 +55,28 @@ require 'telegram/bot'

 ## Usage

+### Configuration
+
+While clients can be instantiated explicitly, there is `Telegram.bots_config=` method
+to configure app-wide clients, which are accessible via `Telegram.bots`.
+It accepts hash of `{bot_id: bot_config}`, and there is special id `:default`
+which is used for `Telegram.bot`.
+
+```ruby
+Telegram.bots_config = {
+  default: DEFAULT_BOT_TOKEN,
+  chat: {token: CHAT_BOT_TOKEN, username: 'chatbot'},
+}
+
+Telegram.bot.get_updates
+Telegram.bot == Telegram.bots[:default] # true
+Telegram.bots[:chat].send_message(...)
+```
+
 ### Configuration in Rails app

-Add `telegram` section into `secrets.yml`:
+In Rails app `Telegram.bots_config` is read from `secrets.yml` automatically
+from `telegram` section:

 ```yml
 development:
@@ -77,6 +98,17 @@ development:
        username: ChatBot
 ```

+For Rails >= 5.2 `Telegram::Bot` searches for config first in credentials and then in secrets.
+To use credentials as config store, add telegram section to credentials instead of secrets using
+`rails credentials:edit`. In this case be aware of that [Rails < 6.0 may not load
+credentials in dev environment by default](https://github.com/telegram-bot-rb/telegram-bot/issues/74#issuecomment-384205609).
+In Rails >= 6.0 run `rails credentials:edit --environment development` to configure bot
+in each environment.
+
+I suggest not using Rails 5.2 credentials because it can lead to leakage of sensitive data
+and it's more difficult to use in multiple environments. See
+[secure_credentials](https://github.com/printercu/secure_credentials) gem for better option.
+
 From now clients will be accessible with `Telegram.bots[:chat]` or `Telegram.bots[:auction]`.
 Single bot can be accessed with `Telegram.bot` or `Telegram.bots[:default]`.

@@ -130,6 +162,9 @@ can represent actions as separate methods keeping source much more readable and
 New instance of controller is instantiated for each update.
 This way every update is processed in isolation from others.

+Bot controllers like usual rails controllers provides features like callbacks,
+`rescue_from` and instrumentation.
+
 ```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
  # use callbacks like in any other controllers
@@ -151,14 +186,11 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
  #   chosen_inline_result(result_id, query)
  #   callback_query(data)

-  # Define public methods to respond to commands.
+  # Define public methods ending with `!` to handle commands.
  # Command arguments will be parsed and passed to the method.
  # Be sure to use splat args and default values to not get errors when
  # someone passed more or less arguments in the message.
-  #
-  # For some commands like /message or /123 method names should start with
-  # `on_` to avoid conflicts.
-  def start(data = nil, *)
+  def start!(data = nil, *)
    # do_smth_with(data)

    # There are `chat` & `from` shortcut methods.
@@ -189,8 +221,9 @@ end
 #### Reply helpers

 There are helpers to respond for basic actions. They just set chat/message/query
-identifiers from update. See [`ReplyHelpers`](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/updates_controller/reply_helpers.rb) module for more information.
-Here are this methods signatures:
+identifiers from update. See
+[`ReplyHelpers`](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/updates_controller/reply_helpers.rb)
+module for more information. Here are this methods signatures:

 ```ruby
 def respond_with(type, params); end
@@ -198,12 +231,14 @@ def reply_with(type, params); end
 def answer_inline_query(results, params = {}); end
 def answer_callback_query(text, params = {}); end
 def edit_message(type, params = {}); end
+def answer_pre_checkout_query(ok, params = {}); end
+def answer_shipping_query(ok, params = {}); end
 ```

 #### Optional typecasting

 You can enable typecasting of `update` with `telegram-bot-types` by including
-`Telegram::Bot::UpdatesPoller::TypedUpdate`:
+`Telegram::Bot::UpdatesController::TypedUpdate`:

 ```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
@@ -253,11 +288,11 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
  # You can override global config for this controller.
  self.session_store = :file_store

-  def write(text = nil, *)
+  def write!(text = nil, *)
    session[:text] = text
  end

-  def read(*)
+  def read!(*)
    respond_with :message, text: session[:text]
  end

@@ -280,35 +315,28 @@ it asks you for additional argument. There is `MessageContext` for this:
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
  include Telegram::Bot::UpdatesController::MessageContext

-  def rename(*)
+  def rename!(*)
    # set context for the next message
-    save_context :rename
+    save_context :rename_from_message
    respond_with :message, text: 'What name do you like?'
  end

  # register context handlers to handle this context
-  context_handler :rename do |*words|
+  def rename_from_message(*words)
    update_name words[0]
    respond_with :message, text: 'Renamed!'
  end

-  # You can do it in other way:
-  def rename(name = nil, *)
+  # You can use same action name as context name:
+  def rename!(name = nil, *)
    if name
      update_name name
      respond_with :message, text: 'Renamed!'
    else
-      save_context :rename
+      save_context :rename!
      respond_with :message, text: 'What name do you like?'
    end
  end
-
-  # This will call #rename like if it is called with message '/rename %text%'
-  context_handler :rename
-
-  # If you have a lot of such methods you can call this method
-  # to use context value as action name for all contexts which miss handlers:
-  context_to_action!
 end
 ```

@@ -325,29 +353,37 @@ Callback queries without prefix stay untouched.
 # This one handles `set_value:%{something}`.
 def set_value_callback_query(new_value = nil, *)
  save_this(value)
-  answer_callback_query('Saved!)
+  answer_callback_query('Saved!')
 end

 # And this one is for `make_cool:%{something}`
 def make_cool_callback_query(thing = nil, *)
  do_it(thing)
-  answer_callback_query("#{thing} is cool now! Like a callback query context.") 
+  answer_callback_query("#{thing} is cool now! Like a callback query context.")
 end
 ```

 ### Routes in Rails app

-There is `telegram_webhooks` helper for rails app to define routes for webhooks.
+There is `telegram_webhook` helper for rails app to define routes for webhooks.
 It defines routes at `telegram/#{bot.token}` and connects bots with controller.
-For more options see [examples in wiki](https://github.com/telegram-bot-rb/telegram-bot/wiki/Routes-helpers-in-details).

 ```ruby
-# Create routes for all Telegram.bots using single controller:
-telegram_webhooks TelegramController
+# Most off apps would require
+telegram_webhook TelegramController
+# which is same as
+telegram_webhook TelegramController, :default

 # Use different controllers for each bot:
-telegram_webhooks chat: TelegramChatController,
-                  auction: TelegramAuctionController
+telegram_webhook TelegramChatController, :chat
+telegram_webhook TelegramAuctionController, :auction
+
+# Defined route is named and its name depends on `Telegram.bots`.
+# For single bot it will use 'telegram_webhook',
+# for multiple bots it uses bot's key in the `Telegram.bots` as prefix
+# (eg. `chat_telegram_webhook`).
+# You can override this with `as` option:
+telegram_webhook TelegramController, as: :custom_telegram_webhook
 ```

 #### Processesing updates
@@ -360,7 +396,7 @@ There are several options to run it automatically:
 - Use poller (described in the next section).

 To run action without update (ex., send notifications from jobs),
-you can call `#process` directly. In this case controller can be initialized 
+you can call `#process` directly. In this case controller can be initialized
 with `:from` and/or `:chat` options instead of `update` object:

 ```ruby
@@ -374,7 +410,7 @@ Use `rake telegram:bot:poller` to run poller in rails app. It automatically load
 changes without restart in development env.
 Optionally pass bot id in `BOT` envvar (`BOT=chat`) to specify bot to run poller for.

-This task requires `telegram_webhooks` helper to be used as it connects bots with controller.
+This task requires `telegram_webhook` helper to be used as it connects bots with controller.
 To run poller in other cases use:

 ```ruby
@@ -383,11 +419,11 @@ Telegram::Bot::UpdatesPoller.start(bot, controller_class)

 ### Testing

-There is `Telegram::Bot::ClientStub` class to stub client for tests.
-Instead of performing API requests it stores them in `requests` hash.
+There is a `Telegram::Bot::ClientStub` class to stub client for tests.
+Instead of performing API requests it stores them in a `requests` hash.

 To stub all possible clients use `Telegram::Bot::ClientStub.stub_all!` before
-initializing clients. Here is template for RSpec:
+initializing clients. Here is a template for RSpec:

 ```ruby
 # environments/test.rb
@@ -405,47 +441,83 @@ RSpec.configure do |config|
 end
 ```

-There are integration and controller contexts for RSpec and some built-in matchers:
+RSpec contexts and helpers are included automatically for groups and examples with matching
+tags. In RSpec < 3.4 it's required to use `include_context` explicitly.
+See [list of available helpers](https://github.com/telegram-bot-rb/telegram-bot/tree/master/lib/telegram/bot/rspec)
+for details.
+
+There are 3 types of integration tests:
+
+- `:rails` - for testing bot in webhooks-mode in Rails application.
+  It simulates webhook requests POSTing data to controller's endpoint.
+  It works on the top of requests specs, so `rspec-rails` gem is required.
+- `:rack` - For testing bot in webhooks-mode in non-Rails application.
+  It uses `rack-test` gem to POST requests to bot's endpoint.
+- `:poller` - Calls `.dispatch` directly on controller class.
+
+Pick the appropriate one, then require `telegram/bot/rspec/integration/#{type}`
+and mark spec group with tag `telegram_bot: type`. See configuration options
+for each type in
+[telegram/bot/rspec/integration/](https://github.com/telegram-bot-rb/telegram-bot/tree/master/lib/telegram/bot/rspec/integration).
+
+Here is an example test for a Rails app:

 ```ruby
 # spec/requests/telegram_webhooks_spec.rb
-require 'telegram/bot/rspec/integration'
+require 'telegram/bot/rspec/integration/rails'

-RSpec.describe TelegramWebhooksController, :telegram_bot do
-  # for old rspec add:
-  # include_context 'telegram/bot/integration'
+RSpec.describe TelegramWebhooksController, telegram_bot: :rails do
+  # for old RSpec:
+  # include_context 'telegram/bot/integration/rails'

-  describe '#start' do
+  # Main method is #dispatch(update). Some helpers are:
+  #   dispatch_message(text, options = {})
+  #   dispatch_command(cmd, *args)
+
+  # Available matchers can be found in Telegram::Bot::RSpec::ClientMatchers.
+  it 'shows usage of basic matchers' do
+    # The most basic one is #make_telegram_request(bot, action).
+    # It works similar to `receive` matcher and supports chaining `.with(args).exactly(n).times`.
+    expect { dispatch_command(:start) }.to make_telegram_request(bot, :sendMessage).
+      with(hash_including(text: 'msg text'))
+
+    # There are some shortcuts for dispatching basic updates and testing responses.
+    expect { dispatch_message('Hi') }.to send_telegram_message(bot, /msg regexp/, some: :option)
+  end
+
+  describe '#start!' do
    subject { -> { dispatch_command :start } }
+    # Using built in matcher for `respond_to`:
    it { should respond_with_message 'Hi there!' }
  end

-  # There is context for callback queries with related matchers.
+  # There is context for callback queries with related matchers,
+  # use :callback_query tag to include it.
  describe '#hey_callback_query', :callback_query do
    let(:data) { "hey:#{name}" }
    let(:name) { 'Joe' }
    it { should answer_callback_query('Hey Joe') }
    it { should edit_current_message :text, text: 'Done' }
+  end
 end
-
-# For controller specs use
-require 'telegram/bot/updates_controller/rspec_helpers'
-RSpec.describe TelegramWebhooksController, type: :telegram_bot_controller do
-  # for old rspec add:
-  # include_context 'telegram/bot/updates_controller'
-end
-
-# Matchers are available for custom specs:
-include Telegram::Bot::RSpec::ClientMatchers
-
-expect(&process_update).to send_telegram_message(bot, /msg regexp/, some: :option)
-expect(&process_update).
-  to make_telegram_request(bot, :sendMessage, hash_including(text: 'msg text'))
 ```

-Place integration tests inside `spec/requests`
-when using RSpec's `infer_spec_type_from_file_location!`,
-or just add `type: :request` to `describe`.
+There is a context for testing bot controller in the way similar to Rails controller tests.
+It's supposed to be a low-level alternative for integration tests. Among the differences is
+that controller tests use a single controller instance for all dispatches in specific exaple,
+session is stubbed (does not use configured store engine), and update is not serialized
+so it also supports mocks. This can be useful for unit testing, but should not be used as
+the default way to test the bot.
+
+```ruby
+require 'telegram/bot/updates_controller/rspec_helpers'
+RSpec.describe TelegramWebhooksController, type: :telegram_bot_controller do
+  # for old RSpec:
+  # include_context 'telegram/bot/updates_controller'
+
+  # Same helpers and matchers like dispatch_command, answer_callback_query are available here.
+end
+```

 See sample app for more examples.

@@ -455,48 +527,12 @@ While webhooks-mode is prefered, poller still can be used in production.
 See [comparison and examples](https://github.com/telegram-bot-rb/telegram-bot/wiki/Deployment)
 for details.

-### Botan.io metrics
-
-Initialize with `bot = Telegram::Bot::Client.new(token, botan: 'botan token')`
-or just add `botan` key in `secrets.yml`:
-
-```yml
-  telegram:
-    bot:
-      token: bot_token
-      botan: botan_token
-```
-
-Access to Botan client with `bot.botan`.
-Use `bot.botan.track(event, uid, payload)` to track events.
-
-There are some helpers for controllers in `Telegram::Bot::Botan::ControllerHelpers`:
-
-```ruby
-class Telegram::WebhookController < Telegram::Bot::UpdatesController
-  include Telegram::Bot::Botan::ControllerHelpers
-
-  # This will track with event: action_name & data: payload
-  before_action :botan_track_action
-
-  def smth(*)
-    # This will track event for current user only when botan is configured.
-    botan_track :my_event, custom_data
-
-    # or get access directly to botan client:
-    botan.track(...)
-  end
-end
-```
-
-There is no stubbing for botan clients, so don't set botan token in tests.
-
 ### Async mode

 There is built in support for async requests using ActiveJob. Without Rails
 you can implement your own worker class to handle such requests. This allows:

- Process updates very fast, without waiting for telegram and botan responses.
+- Process updates very fast, without waiting for telegram responses.
 - Handle and retry network and other errors with queue adapter.
 - ???

@@ -504,7 +540,7 @@ Instead of performing request instantly client serializes it, pushes to queue,
 and immediately return control back. The job is then fetched with a worker
 and real API request is performed. And this all is absolutely transparent for the app.

-To enable this mode add `async: true` to bot's and botan's config.
+To enable this mode add `async: true` to bot's config.
 For more information and custom configuration check out
 [docs](http://www.rubydoc.info/github/telegram-bot-rb/telegram-bot/master/Telegram/Bot/Async) or
 [source](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/async.rb).
@@ -523,7 +559,7 @@ Yes, it's threadsafe too.

 ## Development

-After checking out the repo, run `bin/setup` to install dependencies.
+After checking out the repo, run `bin/setup` to install dependencies and git hooks.
 Then, run `appraisal rake spec` to run the tests.
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.

--- a/gemfiles/rails_42.gemfile
+++ b/gemfiles/rails_42.gemfile
@@ -2,19 +2,19 @@

 source "https://rubygems.org"

-gem "actionpack", "~> 4.2"
-gem "railties", "~> 4.2"
+gem "actionpack", "~> 4.2.0"
+gem "railties", "~> 4.2.0"

 group :development do
  gem "appraisal", "~> 2.2"
  gem "pry", "~> 0.10.1"
  gem "pry-byebug", "~> 3.2.0"
  gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.3.0"
+  gem "telegram-bot-types", "~> 0.6.2"
  gem "rspec", "~> 3.5.0"
  gem "rspec-its", "~> 1.1.0"
  gem "rspec-rails", "~> 3.5.0"
-  gem "rubocop", "~> 0.51.0"
+  gem "rubocop", "~> 0.52.1"
  gem "coveralls", "~> 0.8.2", require: false
 end

--- a/gemfiles/rails_50.gemfile
+++ b/gemfiles/rails_50.gemfile
@@ -2,19 +2,19 @@

 source "https://rubygems.org"

-gem "actionpack", "~> 5.0"
-gem "railties", "~> 5.0"
+gem "actionpack", "~> 5.0.0"
+gem "railties", "~> 5.0.0"

 group :development do
  gem "appraisal", "~> 2.2"
  gem "pry", "~> 0.10.1"
  gem "pry-byebug", "~> 3.2.0"
  gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.3.0"
+  gem "telegram-bot-types", "~> 0.6.2"
  gem "rspec", "~> 3.5.0"
  gem "rspec-its", "~> 1.1.0"
  gem "rspec-rails", "~> 3.5.0"
-  gem "rubocop", "~> 0.51.0"
+  gem "rubocop", "~> 0.52.1"
  gem "coveralls", "~> 0.8.2", require: false
 end

--- a/gemfiles/rails_51.gemfile
+++ b/gemfiles/rails_51.gemfile
@@ -2,19 +2,19 @@

 source "https://rubygems.org"

-gem "actionpack", "~> 5.1"
-gem "railties", "~> 5.1"
+gem "actionpack", "~> 5.1.0"
+gem "railties", "~> 5.1.0"

 group :development do
  gem "appraisal", "~> 2.2"
  gem "pry", "~> 0.10.1"
  gem "pry-byebug", "~> 3.2.0"
  gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.3.0"
+  gem "telegram-bot-types", "~> 0.6.2"
  gem "rspec", "~> 3.5.0"
  gem "rspec-its", "~> 1.1.0"
  gem "rspec-rails", "~> 3.5.0"
-  gem "rubocop", "~> 0.51.0"
+  gem "rubocop", "~> 0.52.1"
  gem "coveralls", "~> 0.8.2", require: false
 end

--- a/gemfiles/rails_52.gemfile
+++ b/gemfiles/rails_52.gemfile
@@ -0,0 +1,21 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "actionpack", "~> 5.2.0"
+gem "railties", "~> 5.2.0"
+
+group :development do
+  gem "appraisal", "~> 2.2"
+  gem "pry", "~> 0.10.1"
+  gem "pry-byebug", "~> 3.2.0"
+  gem "sdoc", "~> 0.4.1"
+  gem "telegram-bot-types", "~> 0.6.2"
+  gem "rspec", "~> 3.5.0"
+  gem "rspec-its", "~> 1.1.0"
+  gem "rspec-rails", "~> 3.5.0"
+  gem "rubocop", "~> 0.52.1"
+  gem "coveralls", "~> 0.8.2", require: false
+end
+
+gemspec path: "../"
--- a/gemfiles/rails_60.gemfile
+++ b/gemfiles/rails_60.gemfile
@@ -0,0 +1,21 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "actionpack", "~> 6.0.0"
+gem "railties", "~> 6.0.0"
+
+group :development do
+  gem "appraisal", "~> 2.2"
+  gem "pry", "~> 0.10.1"
+  gem "pry-byebug", "~> 3.2.0"
+  gem "sdoc", "~> 0.4.1"
+  gem "telegram-bot-types", "~> 0.6.2"
+  gem "rspec", "~> 3.5.0"
+  gem "rspec-its", "~> 1.1.0"
+  gem "rspec-rails", "~> 3.5.0"
+  gem "rubocop", "~> 0.52.1"
+  gem "coveralls", "~> 0.8.2", require: false
+end
+
+gemspec path: "../"
--- a/gemfiles/rails_61.gemfile
+++ b/gemfiles/rails_61.gemfile
@@ -0,0 +1,23 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+git "https://github.com/rails/rails.git" do
+  gem "actionpack", "~> 6.1.0.alpha"
+  gem "railties", "~> 6.1.0.alpha"
+end
+
+group :development do
+  gem "appraisal", "~> 2.2"
+  gem "pry", "~> 0.10.1"
+  gem "pry-byebug", "~> 3.2.0"
+  gem "sdoc", "~> 0.4.1"
+  gem "telegram-bot-types", "~> 0.6.2"
+  gem "rspec", "~> 3.5.0"
+  gem "rspec-its", "~> 1.1.0"
+  gem "rspec-rails", "~> 3.5.0"
+  gem "rubocop", "~> 0.52.1"
+  gem "coveralls", "~> 0.8.2", require: false
+end
+
+gemspec path: "../"
--- a/lib/telegram/bot.rb
+++ b/lib/telegram/bot.rb
@@ -5,11 +5,23 @@ module Telegram

  module Bot
    class Error < StandardError; end
-    class NotFound < Error; end
+
+    # Raised for valid telegram response with 403 status code.
    class Forbidden < Error; end

+    # Raised for valid telegram response with 404 status code.
+    class NotFound < Error; end
+
+    module_function
+
+    def deprecation_0_15
+      @deprecation ||= begin
+        require 'active_support/deprecation'
+        ActiveSupport::Deprecation.new('0.15', 'Telegram::Bot')
+      end
+    end
+
    autoload :Async,              'telegram/bot/async'
-    autoload :Botan,              'telegram/bot/botan'
    autoload :Client,             'telegram/bot/client'
    autoload :ClientStub,         'telegram/bot/client_stub'
    autoload :DebugClient,        'telegram/bot/debug_client'
--- a/lib/telegram/bot/async.rb
+++ b/lib/telegram/bot/async.rb
@@ -1,28 +1,23 @@
 module Telegram
  module Bot
-    # Telegram & Botan clients can perform requests in async way with
+    # Telegram clients can perform requests in async way with
    # any job adapter (ActiveJob by default). Using Rails you don't need any
    # additional configuration. However you may want to enable async requests
-    # by default with `async: true` in `secrets.yml`. Botan client doesn't inherit
-    # async setting from client and must be configured separately.
+    # by default with `async: true` in `secrets.yml`.
    #
    #   telegram:
    #     bots:
    #       chat_async:
    #         token: secret
    #         async: true # enable async mode for client
-    #         botan: botan_token # in this way botan will not be async
-    #         botan: # in this way - it's in async mode
-    #           token: botan_token
-    #           async: true
    #
    # Without Rails To start using async requests
    # initialize client with `id` kwarg and make sure the client is
    # accessible via `Teletgram.bots[id]` in job worker. Or just use
    # `Telegram.bots_config=` for configuration.
    #
-    # Being in async mode `#request` enqueues job instead to perform
-    # http request instead of performing it directly.
+    # Being in async mode `#request` enqueues job to perform
+    # http request instead of performing it immediately.
    # Async behavior is controlled with `#async=` writer
    # and can be enabled/disabled for the block with `#async`:
    #
@@ -34,7 +29,7 @@ module Telegram
    # while `#async(val, &block)` is thread-safe.
    #
    # It can be set with custom job class or classname. By default it defines
-    # job classes for every client class, inherited from ApplicationRecord, which
+    # job classes inherited from ApplicationJob, which
    # can be accessed via `.default_async_job`. You can integrate it with any
    # other job provider by defining a class with `.perform_later(bot_id, *args)`
    # method. See Async::Job for implemetation.
--- a/lib/telegram/bot/botan.rb
+++ b/lib/telegram/bot/botan.rb
@@ -1,53 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      TRACK_URI = 'https://api.botan.io/track'.freeze
-
-      autoload :ClientHelpers, 'telegram/bot/botan/client_helpers'
-      autoload :ControllerHelpers, 'telegram/bot/botan/controller_helpers'
-      class Error < Bot::Error; end
-
-      extend Initializers
-      prepend Async
-      include DebugClient
-
-      class << self
-        def by_id(id)
-          Telegram.botans[id]
-        end
-
-        def prepare_async_args(method, uri, query = {}, body = nil)
-          [method.to_s, uri.to_s, Async.prepare_hash(query), body]
-        end
-      end
-
-      attr_reader :client, :token
-
-      def initialize(token = nil, **options)
-        @client = HTTPClient.new
-        @token = token || options[:token]
-      end
-
-      def track(event, uid, payload = {})
-        request(:post, TRACK_URI, {name: event, uid: uid}, payload.to_json)
-      end
-
-      def request(method, uri, query = {}, body = nil)
-        res = http_request(method, uri, query.merge(token: token), body)
-        status = res.status
-        return JSON.parse(res.body) if status < 300
-        result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
-        err_msg = "#{res.reason}: #{result && result['info'] || '-'}"
-        raise Error, err_msg
-      end
-
-      def http_request(method, uri, query, body)
-        client.request(method, uri, query, body)
-      end
-
-      def inspect
-        "#<#{self.class.name}##{object_id}(#{@id})>"
-      end
-    end
-  end
-end
--- a/lib/telegram/bot/botan/client_helpers.rb
+++ b/lib/telegram/bot/botan/client_helpers.rb
@@ -1,15 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      # Helpers for botan.io metrics.
-      module ClientHelpers
-        attr_reader :botan
-
-        def initialize(*, botan: nil, **options)
-          super
-          @botan = Botan.wrap(botan, id: id) if botan
-        end
-      end
-    end
-  end
-end
--- a/lib/telegram/bot/botan/controller_helpers.rb
+++ b/lib/telegram/bot/botan/controller_helpers.rb
@@ -1,33 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      # Helpers for botan.io metrics.
-      module ControllerHelpers
-        class MissingFrom < Error; end
-
-        protected
-
-        def botan
-          @botan ||= bot.try!(:botan)
-        end
-
-        # Track custom event for user taken from `from` field:
-        #
-        #   botan_track :my_event, {data: :val}
-        #
-        def botan_track(event, data = {})
-          raise MissingFrom, 'Can not track without user' unless from
-          botan.try! { |x| x.track(event, from['id'], data) }
-        end
-
-        # Track current action and payload for current user. Best used with `before_action`:
-        #
-        #   before_action :botan_track_action
-        #
-        def botan_track_action
-          botan_track(action_name, payload)
-        end
-      end
-    end
-  end
-end
--- a/lib/telegram/bot/client.rb
+++ b/lib/telegram/bot/client.rb
@@ -4,12 +4,11 @@ require 'httpclient'
 module Telegram
  module Bot
    class Client
-      URL_TEMPLATE = 'https://api.telegram.org/bot%s/'.freeze
+      URL_TEMPLATE = 'https://api.telegram.org/bot%<token>s/'.freeze

      autoload :TypedResponse, 'telegram/bot/client/typed_response'
      extend Initializers
      prepend Async
-      prepend Botan::ClientHelpers
      include DebugClient

      require 'telegram/bot/client/api_helper'
@@ -36,6 +35,18 @@ module Telegram
        def prepare_async_args(action, body = {})
          [action.to_s, Async.prepare_hash(prepare_body(body))]
        end
+
+        def error_for_response(response)
+          result = JSON.parse(response.body) rescue nil # rubocop:disable RescueModifier
+          return Error.new(response.reason) unless result
+          message = result['description'] || '-'
+          # This errors are raised only for valid responses from Telegram
+          case response.status
+          when 403 then Forbidden.new(message)
+          when 404 then NotFound.new(message)
+          else Error.new("#{response.reason}: #{message}")
+          end
+        end
      end

      attr_reader :client, :token, :username, :base_uri
@@ -44,23 +55,13 @@ module Telegram
        @client = HTTPClient.new
        @token = token || options[:token]
        @username = username || options[:username]
-        @base_uri = format URL_TEMPLATE, self.token
+        @base_uri = format(URL_TEMPLATE, token: self.token)
      end

      def request(action, body = {})
-        res = http_request("#{base_uri}#{action}", self.class.prepare_body(body))
-        status = res.status
-        return JSON.parse(res.body) if status < 300
-        result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
-        err_msg = result && result['description'] || '-'
-        if result
-          # This errors are raised only for valid responses from Telegram
-          case status
-          when 403 then raise Forbidden, err_msg
-          when 404 then raise NotFound, err_msg
-          end
-        end
-        raise Error, "#{res.reason}: #{err_msg}"
+        response = http_request("#{base_uri}#{action}", self.class.prepare_body(body))
+        raise self.class.error_for_response(response) if response.status >= 300
+        JSON.parse(response.body)
      end

      # Endpoint for low-level request. For easy host highjacking & instrumentation.
--- a/lib/telegram/bot/client/api_methods.txt
+++ b/lib/telegram/bot/client/api_methods.txt
@@ -1,5 +1,5 @@
 # Generated with bin/fetch-telegram-methods
-# Bot API 3.5.
+# Bot API 4.7

 getUpdates
 setWebhook
@@ -13,6 +13,7 @@ sendPhoto
 sendAudio
 sendDocument
 sendVideo
+sendAnimation
 sendVoice
 sendVideoNote
 sendMediaGroup
@@ -21,6 +22,8 @@ editMessageLiveLocation
 stopMessageLiveLocation
 sendVenue
 sendContact
+sendPoll
+sendDice
 sendChatAction
 getUserProfilePhotos
 getFile
@@ -28,6 +31,8 @@ kickChatMember
 unbanChatMember
 restrictChatMember
 promoteChatMember
+setChatAdministratorCustomTitle
+setChatPermissions
 exportChatInviteLink
 setChatPhoto
 deleteChatPhoto
@@ -43,10 +48,14 @@ getChatMember
 setChatStickerSet
 deleteChatStickerSet
 answerCallbackQuery
+setMyCommands
+getMyCommands

 editMessageText
 editMessageCaption
+editMessageMedia
 editMessageReplyMarkup
+stopPoll
 deleteMessage

 sendSticker
@@ -56,6 +65,7 @@ createNewStickerSet
 addStickerToSet
 setStickerPositionInSet
 deleteStickerFromSet
+setStickerSetThumb

 answerInlineQuery

@@ -63,6 +73,8 @@ sendInvoice
 answerShippingQuery
 answerPreCheckoutQuery

+setPassportDataErrors
+
 sendGame
 setGameScore
 getGameHighScores
--- a/lib/telegram/bot/client/typed_response.rb
+++ b/lib/telegram/bot/client/typed_response.rb
@@ -1,35 +1,23 @@
+require 'telegram/bot/client/api_helper'
+require 'active_support/core_ext/string/inflections'
+
 module Telegram
  module Bot
    class Client
      # Actions with type-casted results. Install `telegram-bot-types` gem first.
      module TypedResponse
-        {
-          getFile:              :File,
-          getMe:                :User,
-          getUpdates:           [:Update],
-          getUserProfilePhotos: :UserProfilePhotos,
+        # First we define methods for every available api method to return `result`
+        # field instead of object.
+        ApiHelper.methods_list.each do |method|
+          define_method(method.to_s.underscore) do |*args|
+            super(*args)['result']
+          end
+        end

-          forwardMessage:       :Message,
-          sendAudio:            :Message,
-          sendDocument:         :Message,
-          sendLocation:         :Message,
-          sendMessage:          :Message,
-          sendPhoto:            :Message,
-          sendSticker:          :Message,
-          sendVideo:            :Message,
-          sendVoice:            :Message,
-        }.each do |method, type|
-          next unless type
-          if type.is_a?(Array)
-            type_class = Types.const_get(type.first)
-            define_method(method.to_s.underscore) do |*args|
-              request(method, *args)['result'].map { |x| type_class.new(x) }
-            end
-          else
-            type_class = Types.const_get(type)
-            define_method(method.to_s.underscore) do |*args|
-              type_class.new request(method, *args)['result']
-            end
+        # And then override some of them which has castable results.
+        Types::Response::WRAPPED_METHODS.each do |method, type|
+          define_method(method.to_s.underscore) do |*args|
+            Types::Response.wrap(super(*args)['result'], type)
          end
        end
      end
--- a/lib/telegram/bot/config_methods.rb
+++ b/lib/telegram/bot/config_methods.rb
@@ -1,5 +1,4 @@
 require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/transform_values'
 require 'active_support/core_ext/hash/indifferent_access'

 module Telegram
@@ -41,11 +40,6 @@ module Telegram
        end
      end

-      # Hash of botan clients made from #bots.
-      def botans
-        @botans ||= bots.transform_values(&:botan)
-      end
-
      # Returns config for .bots method. By default uses `telegram['bots']` section
      # from `secrets.yml` merging `telegram['bot']` at `:default` key.
      #
@@ -53,10 +47,13 @@ module Telegram
      def bots_config
        @bots_config ||=
          if defined?(Rails.application)
-            secrets = Rails.application.secrets.
-              fetch(:telegram, {}).with_indifferent_access
-            secrets.fetch(:bots, {}).symbolize_keys.tap do |config|
-              default = secrets[:bot]
+            app = Rails.application
+            store = app.credentials[:telegram] if app.respond_to?(:credentials)
+            store ||= app.secrets[:telegram] if app.respond_to?(:secrets)
+            store ||= {}
+            store = store.with_indifferent_access
+            store.fetch(:bots, {}).symbolize_keys.tap do |config|
+              default = store[:bot]
              config[:default] = default if default
            end
          else
@@ -69,7 +66,6 @@ module Telegram
        @bots = nil
        @bot = nil
        @bots_config = nil
-        @botans = nil
      end
    end
  end
--- a/lib/telegram/bot/middleware.rb
+++ b/lib/telegram/bot/middleware.rb
@@ -1,8 +1,7 @@
 require 'active_support/concern'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/json'
-require 'action_dispatch/http/mime_type'
-require 'action_dispatch/http/request'
+require 'action_dispatch'

 module Telegram
  module Bot
--- a/lib/telegram/bot/routes_helper.rb
+++ b/lib/telegram/bot/routes_helper.rb
@@ -24,43 +24,25 @@ module Telegram
        end
      end

-      #   # Create routes for all Telegram.bots to use same controller:
-      #   telegram_webhooks TelegramController
+      # Define route which processes requests using given controller and bot.
      #
-      #   # Or pass custom bots usin any of supported config options:
-      #   telegram_webhooks TelegramController,
-      #                     bot,
-      #                     {token: token, username: username},
-      #                     other_bot_token
+      #   telegram_webhook TelegramController, bot
      #
-      #   # Use different controllers for each bot:
-      #   telegram_webhooks bot => TelegramChatController,
-      #                     other_bot => TelegramAuctionController
+      #   telegram_webhook TelegramController
+      #   # same as:
+      #   telegram_webhook TelegramController, :default
      #
-      #   # telegram_webhooks creates named routes. See
-      #   # RoutesHelper.route_name_for_bot for more info.
-      #   # You can override this options or specify others:
-      #   telegram_webhooks TelegramController, as: :my_webhook
-      #   telegram_webhooks bot => [TelegramChatController, as: :chat_webhook],
-      #                     other_bot => TelegramAuctionController,
-      #                     admin_chat: TelegramAdminChatController
-      #
-      def telegram_webhooks(controllers, bots = nil, **options)
-        unless controllers.is_a?(Hash)
-          bots = bots ? Array.wrap(bots) : Telegram.bots.values
-          controllers = Hash[bots.map { |x| [x, controllers] }]
-        end
-        controllers.each do |bot, controller|
-          bot = Client.wrap(bot)
-          controller, bot_options = controller if controller.is_a?(Array)
-          params = {
-            to: Middleware.new(bot, controller),
-            as: RoutesHelper.route_name_for_bot(bot),
-            format: false,
-          }.merge!(options).merge!(bot_options || {})
-          post("telegram/#{RoutesHelper.escape_token bot.token}", params)
-          UpdatesPoller.add(bot, controller) if Telegram.bot_poller_mode?
-        end
+      #   # pass additional options
+      #   telegram_webhook TelegramController, :default, as: :custom_route_name
+      def telegram_webhook(controller, bot = :default, **options)
+        bot = Client.wrap(bot)
+        params = {
+          to: Middleware.new(bot, controller),
+          as: RoutesHelper.route_name_for_bot(bot),
+          format: false,
+        }.merge!(options)
+        post("telegram/#{RoutesHelper.escape_token bot.token}", params)
+        UpdatesPoller.add(bot, controller) if Telegram.bot_poller_mode?
      end
    end
  end
--- a/lib/telegram/bot/rspec.rb
+++ b/lib/telegram/bot/rspec.rb
@@ -2,6 +2,15 @@ module Telegram
  module Bot
    module RSpec
      autoload :ClientMatchers, 'telegram/bot/rspec/client_matchers'
+
+      module_function
+
+      # Yelds a block if `include_context` is supported.
+      def with_include_context
+        ::RSpec.configure do |config|
+          yield(config) if config.respond_to?(:include_context)
+        end
+      end
    end
  end
 end
--- a/lib/telegram/bot/rspec/callback_query_helpers.rb
+++ b/lib/telegram/bot/rspec/callback_query_helpers.rb
@@ -0,0 +1,39 @@
+require 'telegram/bot/rspec'
+require 'telegram/bot/rspec/message_helpers'
+
+# Shared helpers for testing callback query updates.
+RSpec.shared_context 'telegram/bot/callback_query' do
+  include_context 'telegram/bot/message_helpers'
+
+  subject { -> { dispatch callback_query: payload } }
+  let(:payload) { {id: callback_query_id, from: from, message: message, data: data} }
+  let(:callback_query_id) { 11 }
+  let(:message_id) { 22 }
+  let(:message) { {message_id: message_id, chat: chat, text: 'message text'} }
+  let(:data) { raise '`let(:data) { "callback query data here" }` is required' }
+
+  # Matcher to check that origin message got edited.
+  def edit_current_message(type, options = {})
+    description = 'edit current message'
+    options = options.merge(
+      message_id: message[:message_id],
+      chat_id: chat_id,
+    )
+    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
+      bot, :"editMessage#{type.to_s.camelize}", description: description
+    ).with(hash_including(options))
+  end
+
+  # Matcher to check that callback query is answered.
+  def answer_callback_query(text = Regexp.new(''), options = {})
+    description = "answer callback query with #{text.inspect}"
+    text = a_string_matching(text) if text.is_a?(Regexp)
+    options = options.merge(
+      callback_query_id: payload[:id],
+      text: text,
+    )
+    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
+      bot, :answerCallbackQuery, description: description
+    ).with(hash_including(options))
+  end
+end
--- a/lib/telegram/bot/rspec/integration.rb
+++ b/lib/telegram/bot/rspec/integration.rb
@@ -1,85 +1,10 @@
-RSpec.shared_context 'telegram/bot/integration' do
-  let(:bot) { Telegram.bot }
-  let(:default_message_options) { {from: from, chat: chat} }
-  let(:from) { {id: from_id} }
-  let(:from_id) { 123 }
-  let(:chat) { {id: chat_id} }
-  let(:chat_id) { 456 }
-  let(:controller_path) do
-    route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
-    Rails.application.routes.url_helpers.public_send("#{route_name}_path")
-  end
-  let(:request_headers) do
-    {
-      'ACCEPT' => 'application/json',
-      'Content-Type' => 'application/json',
-    }
-  end
-  let(:clear_session?) { described_class.respond_to?(:session_store) }
-  before { described_class.session_store.try!(:clear) if clear_session? }
+require 'telegram/bot'
+Telegram::Bot.deprecation_0_15.warn(
+  "`require 'telegram/bot/rspec/integration'` is deprecated in favor of " \
+  "`require 'telegram/bot/rspec/integration/rails'`"
+)
+require 'telegram/bot/rspec/integration/rails'

-  include Telegram::Bot::RSpec::ClientMatchers
-
-  def dispatch(update)
-    if ActionPack::VERSION::MAJOR >= 5
-      post(controller_path, params: update.to_json, headers: request_headers)
-    else
-      post(controller_path, update.to_json, request_headers)
-    end
-  end
-
-  def dispatch_message(text, options = {})
-    dispatch message: default_message_options.merge(options).merge(text: text)
-  end
-
-  def dispatch_command(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    dispatch_message("/#{args.join ' '}", options)
-  end
-
-  # Matcher to check response. Make sure to define `let(:chat_id)`.
-  def respond_with_message(expected = Regexp.new(''))
-    raise 'Define chat_id to use respond_with_message' unless defined?(chat_id)
-    send_telegram_message(bot, expected, chat_id: chat_id)
-  end
-end
-
-RSpec.shared_context 'telegram/bot/callback_query', callback_query: true do
-  include_context 'telegram/bot/integration'
-
-  subject { -> { dispatch callback_query: payload } }
-  let(:payload) { {id: 11, from: from, message: message, data: data} }
-  let(:message) { {message_id: 22, chat: chat, text: 'message text'} }
-
-  # Matcher to check that origin message got edited.
-  def edit_current_message(type, options = {})
-    description = 'edit current message'
-    options = options.merge(
-      message_id: message[:message_id],
-      chat_id: chat_id,
-    )
-    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
-      bot, :"editMessage#{type.to_s.camelize}", description: description
-    ).with(hash_including(options))
-  end
-
-  # Matcher to check that callback query is answered.
-  def answer_callback_query(text = Regexp.new(''), options = {})
-    description = "answer callback query with #{text.inspect}"
-    text = a_string_matching(text) if text.is_a?(Regexp)
-    options = options.merge(
-      callback_query_id: payload[:id],
-      text: text,
-    )
-    Telegram::Bot::RSpec::ClientMatchers::MakeTelegramRequest.new(
-      bot, :answerCallbackQuery, description: description
-    ).with(hash_including(options))
-  end
-end
-
-RSpec.configure do |config|
-  if config.respond_to?(:include_context)
-    config.include_context 'telegram/bot/integration', :telegram_bot
-    config.include_context 'telegram/bot/callback_query', :telegram_bot, :callback_query
-  end
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rails', telegram_bot: true
 end
--- a/lib/telegram/bot/rspec/integration/poller.rb
+++ b/lib/telegram/bot/rspec/integration/poller.rb
@@ -0,0 +1,14 @@
+require 'telegram/bot/rspec/integration/shared'
+
+RSpec.shared_context 'telegram/bot/integration/poller' do
+  include_context 'telegram/bot/integration/shared'
+  let(:controller_class) { described_class }
+
+  def dispatch(update)
+    controller_class.dispatch(bot, update.as_json)
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/poller', telegram_bot: :poller
+end
--- a/lib/telegram/bot/rspec/integration/rack.rb
+++ b/lib/telegram/bot/rspec/integration/rack.rb
@@ -0,0 +1,24 @@
+require 'telegram/bot/rspec/integration/shared'
+require 'rack/test'
+
+RSpec.shared_context 'telegram/bot/integration/rack' do
+  include_context 'telegram/bot/integration/shared'
+  include Rack::Test::Methods
+
+  let(:request_path) { raise '`let(:request_path) { path to bot }` is required' }
+  let(:app) { raise '`let(:app) { your rack app here }` is required' }
+  let(:request_headers) do
+    {
+      'ACCEPT' => 'application/json',
+      'CONTENT_TYPE' => 'application/json',
+    }
+  end
+
+  def dispatch(update)
+    post request_path, update.to_json, request_headers
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rack', telegram_bot: :rack
+end
--- a/lib/telegram/bot/rspec/integration/rails.rb
+++ b/lib/telegram/bot/rspec/integration/rails.rb
@@ -0,0 +1,28 @@
+require 'telegram/bot/rspec/integration/shared'
+
+RSpec.shared_context 'telegram/bot/integration/rails', type: :request do
+  include_context 'telegram/bot/integration/shared'
+
+  let(:controller_path) do
+    route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
+    Rails.application.routes.url_helpers.public_send("#{route_name}_path")
+  end
+  let(:request_headers) do
+    {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json',
+    }
+  end
+
+  def dispatch(update)
+    if ActionPack::VERSION::MAJOR >= 5
+      post(controller_path, params: update.to_json, headers: request_headers)
+    else
+      post(controller_path, update.to_json, request_headers)
+    end
+  end
+end
+
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/integration/rails', telegram_bot: :rails
+end
--- a/lib/telegram/bot/rspec/integration/shared.rb
+++ b/lib/telegram/bot/rspec/integration/shared.rb
@@ -0,0 +1,14 @@
+require 'active_support/json'
+require 'telegram/bot'
+require 'telegram/bot/rspec/message_helpers'
+require 'telegram/bot/rspec/callback_query_helpers'
+
+RSpec.shared_context 'telegram/bot/integration/shared' do
+  include Telegram::Bot::RSpec::ClientMatchers
+  include_context 'telegram/bot/message_helpers'
+  include_context 'telegram/bot/callback_query', :callback_query
+
+  let(:bot) { Telegram.bot }
+  let(:clear_session?) { described_class.respond_to?(:session_store) }
+  before { described_class.session_store.try!(:clear) if clear_session? }
+end
--- a/lib/telegram/bot/rspec/message_helpers.rb
+++ b/lib/telegram/bot/rspec/message_helpers.rb
@@ -0,0 +1,26 @@
+# Shared helpers for testing message updates.
+RSpec.shared_context 'telegram/bot/message_helpers' do
+  let(:default_message_options) { {from: from, chat: chat} }
+  let(:from) { {id: from_id} }
+  let(:from_id) { 123 }
+  let(:chat) { {id: chat_id} }
+  let(:chat_id) { 456 }
+
+  # Shortcut for dispatching messages with default params.
+  def dispatch_message(text, options = {})
+    dispatch message: default_message_options.merge(options).merge(text: text)
+  end
+
+  # Dispatch command message.
+  def dispatch_command(cmd, *args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    args.unshift("/#{cmd}")
+    dispatch_message(args.join(' '), options)
+  end
+
+  # Matcher to check response. Make sure to define `let(:chat_id)`.
+  def respond_with_message(expected = Regexp.new(''))
+    raise 'Define chat_id to use respond_with_message' unless defined?(chat_id)
+    send_telegram_message(bot, expected, chat_id: chat_id)
+  end
+end
--- a/lib/telegram/bot/updates_controller.rb
+++ b/lib/telegram/bot/updates_controller.rb
@@ -1,4 +1,5 @@
 require 'abstract_controller'
+require 'active_support/core_ext/string/inflections'
 require 'active_support/callbacks'
 require 'active_support/version'

@@ -6,13 +7,13 @@ module Telegram
  module Bot
    # Base class to create update processors. With callbacks, session and helpers.
    #
-    # Define public methods for each command and they will be called when
-    # update has this command. Message is automatically parsed and
-    # words are passed as method arguments. Be sure to use default values and
+    # Public methods ending with `!` handle messages with commands.
+    # Message text is automatically parsed  into method arguments.
+    # Be sure to use default values and
    # splat arguments in every action method to not get errors, when user
    # sends command without necessary args / with extra args.
    #
-    #     def start(token = nil, *)
+    #     def start!(token = nil, *)
    #       if token
    #         # ...
    #       else
@@ -20,25 +21,21 @@ module Telegram
    #       end
    #     end
    #
-    #     def help(*)
+    #     def help!(*)
    #       respond_with :message, text:
    #     end
    #
    # To process plain text messages (without commands) or other updates just
-    # define public method with name of payload type. They will receive payload
-    # as an argument.
+    # define public method with name of payload type.
+    # By default they receive payload as an argument, but some of them are called
+    # with more usefuk args:
    #
    #     def message(message)
    #       respond_with :message, text: "Echo: #{message['text']}"
    #     end
    #
-    #     def inline_query(query)
-    #       answer_inline_query results_for_query(query), is_personal: true
-    #     end
-    #
-    #     # To process conflicting commands (`/message args`) just use `on_` prefix:
-    #     def on_message(*args)
-    #       # ...
+    #     def inline_query(query, offset)
+    #       answer_inline_query results_for_query(query, offset), is_personal: true
    #     end
    #
    # To process update run:
@@ -53,12 +50,21 @@ module Telegram
    class UpdatesController < AbstractController::Base # rubocop:disable ClassLength
      abstract!

-      require 'telegram/bot/updates_controller/session'
-      require 'telegram/bot/updates_controller/log_subscriber'
-      require 'telegram/bot/updates_controller/instrumentation'
-      require 'telegram/bot/updates_controller/reply_helpers'
-      autoload :CallbackQueryContext, 'telegram/bot/updates_controller/callback_query_context'
-      autoload :MessageContext, 'telegram/bot/updates_controller/message_context'
+      %w[
+        Commands
+        Instrumentation
+        LogSubscriber
+        ReplyHelpers
+        Rescue
+        Session
+        Translation
+      ].each { |name| require "telegram/bot/updates_controller/#{name.underscore}" }
+
+      %w[
+        CallbackQueryContext
+        MessageContext
+        TypedUpdate
+      ].each { |mod| autoload mod, "telegram/bot/updates_controller/#{mod.underscore}" }

      include AbstractController::Callbacks
      # Redefine callbacks with default terminator.
@@ -71,12 +77,15 @@ module Telegram
                          skip_after_callbacks_if_terminated: true
      end

-      include AbstractController::Translation
+      include Commands
+      include Rescue
      include ReplyHelpers
-      prepend Instrumentation
-      extend Session::ConfigMethods
+      include Translation
+      # Add instrumentations hooks at the bottom, to ensure they instrument
+      # all the methods properly.
+      include Instrumentation

-      autoload :TypedUpdate, 'telegram/bot/updates_controller/typed_update'
+      extend Session::ConfigMethods

      PAYLOAD_TYPES = %w[
        message
@@ -88,9 +97,9 @@ module Telegram
        callback_query
        shipping_query
        pre_checkout_query
+        poll
+        poll_answer
      ].freeze
-      CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
-      CONFLICT_CMD_REGEX = Regexp.new("^(#{PAYLOAD_TYPES.join('|')}|\\d)")

      class << self
        # Initialize controller and process update.
@@ -98,30 +107,15 @@ module Telegram
          new(*args).dispatch
        end

-        # Overrid it to filter or transform commands.
-        # Default implementation is to convert to downcase and add `on_` prefix
-        # for conflicting commands.
-        def action_for_command(cmd)
-          cmd.downcase!
-          cmd.match(CONFLICT_CMD_REGEX) ? "on_#{cmd}" : cmd
-        end
-
-        # Fetches command from text message. All subsequent words are returned
-        # as arguments.
-        # If command has mention (eg. `/test@SomeBot`), it returns commands only
-        # for specified username. Set `username` to `true` to accept
-        # any commands.
-        def command_from_text(text, username = nil)
-          return unless text
-          match = text.match CMD_REGEX
-          return unless match
-          return if match[3] && username != true && match[3] != username
-          [match[1], text.split.drop(1)]
+        def payload_from_update(update)
+          update && PAYLOAD_TYPES.find do |type|
+            item = update[type]
+            return [item, type] if item
+          end
        end
      end

-      attr_internal_reader :update, :bot, :payload, :payload_type, :is_command
-      alias_method :command?, :is_command
+      attr_internal_reader :update, :bot, :payload, :payload_type
      delegate :username, to: :bot, prefix: true, allow_nil: true

      # Second argument can be either update object with hash access & string
@@ -135,13 +129,7 @@ module Telegram
        @_update = update
        @_bot = bot
        @_chat, @_from = options && options.values_at(:chat, :from)
-
-        payload_data = nil
-        update && PAYLOAD_TYPES.find do |type|
-          item = update[type]
-          payload_data = [item, type] if item
-        end
-        @_payload, @_payload_type = payload_data
+        @_payload, @_payload_type = self.class.payload_from_update(update)
      end

      # Accessor to `'chat'` field of payload. Also tries `'chat'` in `'message'`
@@ -149,65 +137,86 @@ module Telegram
      #
      # Can be overriden with `chat` option for #initialize.
      def chat
-        @_chat ||= payload.try! { |x| x['chat'] || x['message'] && x['message']['chat'] }
+        @_chat ||=
+          if payload
+            if payload.is_a?(Hash)
+              payload['chat'] || payload['message'] && payload['message']['chat']
+            else
+              payload.try(:chat) || payload.try(:message).try!(:chat)
+            end
+          end
      end

      # Accessor to `'from'` field of payload. Can be overriden with `from` option
      # for #initialize.
      def from
-        @_from ||= payload && payload['from']
+        @_from ||= payload.is_a?(Hash) ? payload['from'] : payload.try(:from)
      end

      # Processes current update.
      def dispatch
-        @_is_command, action, args = action_for_payload
+        action, args = action_for_payload
        process(action, *args)
      end

+      attr_internal_reader :action_options
+
+      # It provides support for passing array as action, where first vaule
+      # is action name and second is action metadata.
+      # This metadata is stored inside action_options
+      def process(action, *args)
+        action, options = action if action.is_a?(Array)
+        @_action_options = options || {}
+        super
+      end
+
+      # There are multiple ways how action name is calculated for update
+      # (see Commands, MessageContext, etc.). This method represents the
+      # way how action was calculated for current udpate.
+      #
+      # Some of possible values are `:payload, :command, :message_context`.
+      def action_type
+        action_options[:type] || :payload
+      end
+
      # Calculates action name and args for payload.
      # Uses `action_for_#{payload_type}` methods.
      # If this method doesn't return anything
      # it uses fallback with action same as payload type.
-      # Returns array `[is_command?, action, args]`.
+      # Returns array `[action, args]`.
      def action_for_payload
        if payload_type
          send("action_for_#{payload_type}") || action_for_default_payload
        else
-          [false, :unsupported_payload_type, []]
+          [:unsupported_payload_type, []]
        end
      end

      def action_for_default_payload
-        [false, payload_type, [payload]]
+        [payload_type, [payload]]
      end

-      # If payload is a message with command, then returned action is an
-      # action for this command.
-      # Separate method, so it can be easily overriden (ex. MessageContext).
-      #
-      # This is not used for edited messages/posts. It process them as basic updates.
-      def action_for_message
-        cmd, args = self.class.command_from_text(payload['text'], bot_username)
-        cmd &&= self.class.action_for_command(cmd)
-        [true, cmd, args] if cmd
-      end
-      alias_method :action_for_channel_post, :action_for_message
-
      def action_for_inline_query
-        [false, payload_type, [payload['query'], payload['offset']]]
+        [payload_type, [payload['query'], payload['offset']]]
      end

      def action_for_chosen_inline_result
-        [false, payload_type, [payload['result_id'], payload['query']]]
+        [payload_type, [payload['result_id'], payload['query']]]
      end

      def action_for_callback_query
-        [false, payload_type, [payload['data']]]
+        [payload_type, [payload['data']]]
      end

-      # Silently ignore unsupported messages.
-      # Params are `action, *args`.
-      def action_missing(*)
+      def action_for_poll_answer
+        [payload_type, [payload['poll_id'], payload['option_ids']]]
+      end
+
+      # Silently ignore unsupported messages to not fail when user crafts
+      # an update with usupported command, callback query context, etc.
+      def action_missing(action, *_args)
+        logger.debug { "The action '#{action}' is not defined in #{self.class.name}" } if logger
+        nil
      end

      PAYLOAD_TYPES.each do |type|
--- a/lib/telegram/bot/updates_controller/callback_query_context.rb
+++ b/lib/telegram/bot/updates_controller/callback_query_context.rb
@@ -17,8 +17,12 @@ module Telegram
          context, new_data = context_from_callback_query
          if context
            action_name = "#{context}_callback_query"
-            [false, action_name, [new_data]] if action_method?(action_name)
-          end || super
+            if action_method?(action_name)
+              action_options = {type: :callback_query_context, context: context}
+              return [[action_name, action_options], [new_data]]
+            end
+          end
+          super
        end

        def context_from_callback_query
--- a/lib/telegram/bot/updates_controller/commands.rb
+++ b/lib/telegram/bot/updates_controller/commands.rb
@@ -0,0 +1,44 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      #  Support for parsing commands
+      module Commands
+        CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
+
+        class << self
+          # Fetches command from text message. All subsequent words are returned
+          # as arguments.
+          # If command has mention (eg. `/test@SomeBot`), it returns commands only
+          # for specified username. Set `username` to `true` to accept
+          # any commands.
+          def command_from_text(text, username = nil)
+            return unless text
+            match = text.match(CMD_REGEX)
+            return unless match
+            mention = match[3]
+            [match[1], text.split.drop(1)] if username == true || !mention || mention == username
+          end
+        end
+
+        # Override it to filter or transform commands.
+        # Default implementation is to downcase and add `!` suffix.
+        def action_for_command(cmd)
+          "#{cmd.downcase}!"
+        end
+
+        # If payload is a message with command, then returned action is an
+        # action for this command.
+        # Separate method, so it can be easily overriden (ex. MessageContext).
+        #
+        # This is not used for edited messages/posts. It process them as basic updates.
+        def action_for_message
+          cmd, args = Commands.command_from_text(payload['text'], bot_username)
+          return unless cmd
+          [[action_for_command(cmd), type: :command, command: cmd], args]
+        end
+
+        alias_method :action_for_channel_post, :action_for_message
+      end
+    end
+  end
+end
--- a/lib/telegram/bot/updates_controller/instrumentation.rb
+++ b/lib/telegram/bot/updates_controller/instrumentation.rb
@@ -4,12 +4,13 @@ module Telegram
      # Most methods are taken from ActionController::Instrumentation,
      # some are slightly modified.
      module Instrumentation
-        class << self
-          def prepended(base)
-            base.send :config_accessor, :logger
-            base.extend ClassMethods
-          end
+        extend ActiveSupport::Concern

+        included do
+          config_accessor :logger
+        end
+
+        class << self
          def instrument(action, *args, &block)
            ActiveSupport::Notifications.instrument(
              "#{action}.updates_controller.bot.telegram",
--- a/lib/telegram/bot/updates_controller/message_context.rb
+++ b/lib/telegram/bot/updates_controller/message_context.rb
@@ -2,62 +2,42 @@ module Telegram
  module Bot
    class UpdatesController
      # Allows to store context in session and treat next message according to this context.
+      #
+      # It provides `save_context` method to store method name
+      # to be used as action for next update:
+      #
+      #     def set_location!(*)
+      #       save_context(:set_location_from_message)
+      #       respond_with :message, text: 'Where are you?'
+      #     end
+      #
+      #     def set_location_from_messge(city = nil, *)
+      #       # update
+      #     end
+      #
+      #     # OR
+      #     # This will support both `/set_location city_name`, and `/set_location`
+      #     # with subsequent refinement.
+      #     def set_location!(city = nil, *)
+      #       if city
+      #         # update
+      #       else
+      #         save_context(:set_location!)
+      #         respond_with :message, text: 'Where are you?'
+      #       end
+      #     end
      module MessageContext
        extend ActiveSupport::Concern

        include Session

-        module ClassMethods
-          def context_handlers
-            @_context_handlers ||= {}
-          end
-
-          # Registers handler for context.
-          #
-          #     context_handler :rename do |*|
-          #       resource.update!(name: payload['text'])
-          #     end
-          #
-          #     # To run other action with all the callbacks:
-          #     context_handler :rename do |*words|
-          #       process(:rename, *words)
-          #     end
-          #
-          #     # Or just
-          #     context_handler :rename, :your_action_to_call
-          #     context_handler :rename # to call :rename
-          #
-          def context_handler(context = nil, action = nil, &block)
-            context &&= context.to_sym
-            if block
-              action = "_context_handler_#{context}"
-              define_method(action, &block)
-            end
-            context_handlers[context] = action || context
-          end
-
-          attr_reader :context_to_action
-
-          # Use it to use context value as action name for all contexts
-          # which miss handlers.
-          # For security reasons it supports only action methods and will
-          # raise AbstractController::ActionNotFound if context is invalid.
-          def context_to_action!
-            @context_to_action = true
-          end
-        end
-
        # Action to clear context.
-        def cancel
+        def cancel!
          # Context is already cleared in action_for_message
        end

        private

-        # Context is read from the session to treat messages
-        # according to previous request.
-        attr_reader :context
-
        # Controller may have multiple sessions, let it be possible
        # to select session for message context.
        def message_context_session
@@ -68,10 +48,11 @@ module Telegram
        # it has higher priority than contextual action.
        def action_for_message
          val = message_context_session.delete(:context)
-          @context = val && val.to_sym
+          context = val && val.to_s
          super || context && begin
-            handler = handler_for_context
-            [true, handler, payload['text'].try!(:split) || []] if handler
+            args = payload['text'].try!(:split) || []
+            action = action_for_message_context(context)
+            [[action, type: :message_context, context: context], args]
          end
        end

@@ -80,18 +61,16 @@ module Telegram
          message_context_session[:context] = context
        end

-        def handler_for_context
-          self.class.context_handlers[context] || self.class.context_to_action && begin
-            action_name = context.to_s
-            unless action_method?(action_name)
-              raise AbstractController::ActionNotFound,
-                "The action '#{action_name}' could not be set from context " \
-                "for #{self.class.name}. " \
-                'context_to_action! supports only action methods for security reasons. ' \
-                'If you need to call this action use context_handler for it.'
-            end
-            action_name
-          end
+        # Returns action name for message context. By default it's the same as context name.
+        # Raises AbstractController::ActionNotFound if action is not available.
+        # This differs from other cases where invalid actions are silently ignored,
+        # because message context is controlled by developer, and users are not able
+        # to construct update to run any specific context.
+        def action_for_message_context(context)
+          action = context.to_s
+          return action if action_method?(action)
+          raise AbstractController::ActionNotFound,
+            "The context action '#{action}' is not found in #{self.class.name}"
        end
      end
    end
--- a/lib/telegram/bot/updates_controller/reply_helpers.rb
+++ b/lib/telegram/bot/updates_controller/reply_helpers.rb
@@ -21,7 +21,7 @@ module Telegram
          respond_with(type, params)
        end

-        # Same as reply_with, but for inline queries.
+        # Same as respond_with, but for inline queries.
        def answer_inline_query(results, params = {})
          params = params.merge(
            inline_query_id: payload['id'],
@@ -30,7 +30,7 @@ module Telegram
          bot.answer_inline_query(params)
        end

-        # Same as reply_with, but for callback queries.
+        # Same as respond_with, but for callback queries.
        def answer_callback_query(text, params = {})
          params = params.merge(
            callback_query_id: payload['id'],
@@ -39,6 +39,23 @@ module Telegram
          bot.answer_callback_query(params)
        end

+        # Same as respond_with, but for pre checkout queries.
+        def answer_pre_checkout_query(ok, params = {})
+          params = params.merge(
+            pre_checkout_query_id: payload['id'],
+            ok: ok,
+          )
+          bot.answer_pre_checkout_query(params)
+        end
+
+        def answer_shipping_query(ok, params = {})
+          params = params.merge(
+            shipping_query_id: payload['id'],
+            ok: ok,
+          )
+          bot.answer_shipping_query(params)
+        end
+
        # Edit message from callback query.
        def edit_message(type, params = {})
          params =
--- a/lib/telegram/bot/updates_controller/rescue.rb
+++ b/lib/telegram/bot/updates_controller/rescue.rb
@@ -0,0 +1,20 @@
+require 'active_support/rescuable'
+
+module Telegram
+  module Bot
+    class UpdatesController
+      module Rescue
+        extend ActiveSupport::Concern
+        include ActiveSupport::Rescuable
+
+        private
+
+        def process_action(*)
+          super
+        rescue Exception => exception # rubocop:disable RescueException
+          rescue_with_handler(exception) || raise
+        end
+      end
+    end
+  end
+end
--- a/lib/telegram/bot/updates_controller/rspec_helpers.rb
+++ b/lib/telegram/bot/updates_controller/rspec_helpers.rb
@@ -1,53 +1,41 @@
 require 'telegram/bot/updates_controller/testing'
+require 'telegram/bot/rspec/message_helpers'
+require 'telegram/bot/rspec/callback_query_helpers'

 RSpec.shared_context 'telegram/bot/updates_controller' do
+  include Telegram::Bot::RSpec::ClientMatchers
+  include_context 'telegram/bot/message_helpers'
+  include_context 'telegram/bot/callback_query', :callback_query
+
  let(:controller_class) { described_class }
  let(:controller) do
-    controller_class.new(bot, update).tap do |x|
+    controller_class.new(*controller_args).tap do |x|
      x.extend Telegram::Bot::UpdatesController::Testing
    end
  end
-  let(:update) { build_update(payload_type, payload) }
+  let(:controller_args) { [bot, deep_stringify(update)] }
+  let(:update) { {payload_type => payload} }
  let(:payload_type) { :some_type }
  let(:payload) { double(:payload) }
  let(:bot) { Telegram::Bot::ClientStub.new(bot_name) }
  let(:bot_name) { 'bot' }
  let(:session) { controller.send(:session) }
-  let(:from_id) { 123 }
-  let(:chat_id) { 456 }
-  let(:default_message_options) { {from: {id: from_id}, chat: {id: chat_id}} }

-  include Telegram::Bot::RSpec::ClientMatchers
-
-  def dispatch(bot = self.bot, update = self.update)
-    controller.dispatch_again(bot, update)
-  end
-
-  def dispatch_message(text, options = {})
-    update = build_update :message, default_message_options.merge(options).merge(text: text)
-    dispatch bot, update
-  end
-
-  def build_update(type, content)
-    deep_stringify type => content
+  # Process update.
+  def dispatch(update = self.update, bot = self.bot)
+    controller.dispatch_again(bot, deep_stringify(update))
  end

+  # Same as `.as_json` but mocks-friendly.
  def deep_stringify(input)
    case input
    when Array then input.map(&method(__callee__))
-    when Hash then input.transform_keys(&:to_s).transform_values(&method(__callee__))
+    when Hash then input.map { |k, v| [k.to_s, deep_stringify(v)] }.to_h
    else input
    end
  end
-
-  # Matcher to check response. Make sure to define `let(:chat_id)`.
-  def respond_with_message(expected)
-    send_telegram_message(bot, expected, chat_id: chat_id)
-  end
 end

-RSpec.configure do |config|
-  if config.respond_to?(:include_context)
-    config.include_context 'telegram/bot/updates_controller', type: :telegram_bot_controller
-  end
+Telegram::Bot::RSpec.with_include_context do |config|
+  config.include_context 'telegram/bot/updates_controller', type: :telegram_bot_controller
 end
--- a/lib/telegram/bot/updates_controller/translation.rb
+++ b/lib/telegram/bot/updates_controller/translation.rb
@@ -0,0 +1,47 @@
+module Telegram
+  module Bot
+    class UpdatesController
+      # Provides helpers similar to AbstractController::Translation
+      # but by default uses `action_name_i18n_key` in lazy translation keys
+      # which strips `!` from action names by default. This makes translating
+      # strings for commands more convenient.
+      #
+      # To disable this behaviour use `alias_method :action_name_i18n_key, :action_name`.
+      module Translation
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Class-level helper for lazy translations.
+          def translate(key, options = {})
+            key = "#{controller_path.tr('/', '.')}#{key}" if key.to_s.start_with?('.')
+            I18n.translate(key, options)
+          end
+          alias :t :translate
+        end
+
+        # See toplevel description.
+        def translate(key, options = {})
+          if key.to_s.start_with?('.')
+            path = controller_path.tr('/', '.')
+            defaults = [:"#{path}#{key}"]
+            defaults << options[:default] if options[:default]
+            options[:default] = defaults.flatten
+            key = "#{path}.#{action_name_i18n_key}#{key}"
+          end
+          I18n.translate(key, options)
+        end
+        alias :t :translate
+
+        # Strips trailing `!` from action_name.
+        def action_name_i18n_key
+          action_name.chomp('!')
+        end
+
+        def localize(*args)
+          I18n.localize(*args)
+        end
+        alias :l :localize
+      end
+    end
+  end
+end
--- a/lib/telegram/bot/updates_poller.rb
+++ b/lib/telegram/bot/updates_poller.rb
@@ -41,40 +41,54 @@ module Telegram

      def start
        return if running
-        @running = true
-        log { 'Started bot poller.' }
-        while running
-          begin
-            fetch_updates do |update|
-              controller.dispatch(bot, update)
-            end
-          rescue Interrupt
-            @running = false
-          rescue StandardError => e
-            logger.error { ([e.message] + e.backtrace).join("\n") } if logger
-          end
+        begin
+          @running = true
+          log { 'Started bot poller.' }
+          run
+        rescue Interrupt
+          nil # noop
+        ensure
+          @running = false
        end
-        log { 'Stop polling bot updates.' }
+        log { 'Stoped polling bot updates.' }
      end

+      def run
+        while running
+          updates = fetch_updates
+          process_updates(updates) if updates && updates.any?
+        end
+      end
+
+      # Method to stop poller from other thread.
      def stop
        return unless running
-        log { 'Killing polling thread.' }
+        log { 'Stopping polling bot updates.' }
        @running = false
      end

-      def fetch_updates
+      def fetch_updates(offset = self.offset)
        response = bot.async(false) { bot.get_updates(offset: offset, timeout: timeout) }
-        updates = response.is_a?(Array) ? response : response['result']
-        return unless updates && updates.any?
+        response.is_a?(Array) ? response : response['result']
+      rescue Timeout::Error
+        log { 'Fetch timeout' }
+        nil
+      end
+
+      def process_updates(updates)
        reload! do
          updates.each do |update|
            @offset = update['update_id'] + 1
-            yield update
+            process_update(update)
          end
        end
-      rescue Timeout::Error
-        log { 'Fetch timeout' }
+      rescue StandardError => e
+        logger.error { ([e.message] + e.backtrace).join("\n") } if logger
+      end
+
+      # Override this method to setup custom error collector.
+      def process_update(update)
+        controller.dispatch(bot, update)
      end

      def reload!
--- a/lib/telegram/bot/version.rb
+++ b/lib/telegram/bot/version.rb
@@ -1,6 +1,6 @@
 module Telegram
  module Bot
-    VERSION = '0.12.4'.freeze
+    VERSION = '0.14.4'.freeze

    def self.gem_version
      Gem::Version.new VERSION
--- a/spec/integration/requests/default_bot_spec.rb
+++ b/spec/integration/requests/default_bot_spec.rb
@@ -1,6 +1,6 @@
 require 'integration_helper'

-RSpec.describe DefaultBotController, :telegram_bot, type: :request do
+RSpec.describe DefaultBotController, telegram_bot: :rails do
  describe '#start' do
    subject { -> { dispatch_command :start } }
    it { should respond_with_message 'from default' }
--- a/spec/integration/requests/named_bot_spec.rb
+++ b/spec/integration/requests/named_bot_spec.rb
@@ -1,6 +1,6 @@
 require 'integration_helper'

-RSpec.describe NamedBotController, :telegram_bot, type: :request do
+RSpec.describe NamedBotController, telegram_bot: :rails do
  let(:bot) { Telegram.bots[:named] }
  describe '#start' do
    subject { -> { dispatch_command :start } }
--- a/spec/integration/requests/other_bot_spec.rb
+++ b/spec/integration/requests/other_bot_spec.rb
@@ -1,6 +1,6 @@
 require 'integration_helper'

-RSpec.describe OtherBotController, :telegram_bot, type: :request do
+RSpec.describe OtherBotController, telegram_bot: :rails do
  let(:bot) { Telegram.bots[:other] }
  describe '#start' do
    subject { -> { dispatch_command :start } }
--- a/spec/integration_helper.rb
+++ b/spec/integration_helper.rb
@@ -1,7 +1,6 @@
-require 'telegram/bot/rspec/integration'
+require 'telegram/bot/rspec/integration/rails'
 require 'action_controller'
 require 'action_dispatch'
-require 'action_dispatch/testing/integration'

 require 'rails'
 require 'telegram/bot/railtie'
@@ -15,21 +14,28 @@ class TestApplication < Rails::Application
  config.eager_load = false
  config.log_level = :debug
  config.action_dispatch.show_exceptions = false
-  secrets[:secret_key_base] = 'test'
-  secrets[:telegram] = {
+
+  telegram_config = {
    bot: 'default_token',
    bots: {
      other: {token: 'other_token'},
      named: {token: 'named_token', username: 'TestBot'},
    },
  }
+
+  if respond_to?(:credentials)
+    credentials.config[:telegram] = telegram_config
+  else
+    secrets[:secret_key_base] = 'test'
+    secrets[:telegram] = telegram_config
+  end
 end
 Rails.application.initialize!

 # # Controllers
 %w[default other named].each do |bot_name|
  controller = Class.new(Telegram::Bot::UpdatesController) do
-    define_method :start do |*|
+    define_method :start! do |*|
      respond_with :message, text: "from #{bot_name}"
    end
  end
@@ -40,7 +46,7 @@ end
  klass.class_eval do
    use_session!

-    define_method :load_session do |*|
+    define_method :load_session! do |*|
      session[:test]
    end
  end
@@ -68,9 +74,9 @@ RSpec.configure do |config|
      require 'telegram/bot/routes_helper'
      extend Telegram::Bot::RoutesHelper

-      telegram_webhooks default: DefaultBotController,
-                        other: OtherBotController,
-                        named: NamedBotController
+      telegram_webhook DefaultBotController, :default
+      telegram_webhook OtherBotController, :other
+      telegram_webhook NamedBotController, :named
    end
  end
 end
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -16,7 +16,7 @@ $LOAD_PATH.unshift GEM_ROOT.join('lib')
 require 'telegram/bot'
 require 'telegram/bot/updates_controller/rspec_helpers'
 require 'telegram/bot/types'
-require 'active_support/core_ext/object/json'
+require 'active_support/json'

 Dir[GEM_ROOT.join('spec/support/**/*.rb')].each { |f| require f }

@@ -32,6 +32,14 @@ RSpec.configure do |config|
    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
  end

+  # This config option will be enabled by default on RSpec 4,
+  # but for reasons of backwards compatibility, you have to
+  # set it on RSpec 3.
+  #
+  # It causes the host group and examples to inherit metadata
+  # from the shared context.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
  config.mock_with :rspec do |mocks|
    # Prevents you from mocking or stubbing a method that does not exist on
    # a real object. This is generally recommended, and will default to
--- a/spec/support/examples/integration.rb
+++ b/spec/support/examples/integration.rb
@@ -0,0 +1,24 @@
+RSpec.shared_examples 'shared integration examples' do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      def start!(data = nil, *)
+        respond_with :message, text: "Hi #{data}"
+      end
+
+      def callback_query(data, *)
+        answer_callback_query "pong: #{data}"
+      end
+    end
+  end
+
+  describe '#start' do
+    subject { -> { dispatch_command(:start, :test_data) } }
+    it { should respond_with_message('Hi test_data') }
+  end
+
+  describe '#callback_query', :callback_query do
+    let(:data) { :test_data }
+    it { should answer_callback_query "pong: #{data}" }
+  end
+end
--- a/spec/telegram/bot/botan/client_helpers_spec.rb
+++ b/spec/telegram/bot/botan/client_helpers_spec.rb
@@ -1,33 +0,0 @@
-RSpec.describe Telegram::Bot::Client do
-  let(:instance) { described_class.new(*client_args) }
-  let(:token) { 'token' }
-  let(:botan_token) { double(:botan_token) }
-  let(:client_id) { 'client_id' }
-  let(:client_args) { [token] }
-
-  describe '#botan' do
-    subject { instance.botan }
-    it { should eq nil }
-
-    context 'when botan token is set' do
-      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_token] }
-      it { should be_instance_of Telegram::Bot::Botan }
-      its(:token) { should eq botan_token }
-      its(:id) { should eq client_id }
-
-      it 'doesnt inherit async from client' do
-        expect(instance.async).to be
-        expect(subject.async).to_not be
-      end
-    end
-
-    context 'when botan is configured with hash' do
-      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_config] }
-      let(:botan_config) { {token: botan_token, async: Class.new} }
-      it { should be_instance_of Telegram::Bot::Botan }
-      its(:token) { should eq botan_token }
-      its(:id) { should eq client_id }
-      its(:async) { should eq botan_config[:async] }
-    end
-  end
-end
--- a/spec/telegram/bot/botan/controller_helpers_spec.rb
+++ b/spec/telegram/bot/botan/controller_helpers_spec.rb
@@ -1,54 +0,0 @@
-RSpec.describe Telegram::Bot::Botan::ControllerHelpers do
-  include_context 'telegram/bot/updates_controller'
-  let(:controller_class) do
-    described_class = self.described_class
-    Class.new(Telegram::Bot::UpdatesController) do
-      include described_class
-    end
-  end
-  let(:botan) { double(:botan) }
-  let(:result) { double(:result) }
-  let(:payload) { {from: {id: user_id}} }
-  let(:payload_type) { :message }
-  let(:user_id) { double(:user_id) }
-  before { allow(bot).to receive(:botan) { botan } }
-
-  shared_examples 'basic tracking' do
-    context 'when botan is not configured' do
-      let(:botan) {}
-      it { should eq nil }
-    end
-
-    context 'when `from` is empty' do
-      let(:payload) { {text: 'test'} }
-      it { expect { subject }.to raise_error described_class::MissingFrom }
-    end
-  end
-
-  describe '#botan_track' do
-    subject { controller.send(:botan_track, event, data) }
-    let(:event) { double(:event) }
-    let(:data) { double(:data) }
-
-    it 'calls botan#track' do
-      expect(botan).to receive(:track).with(event, user_id, data) { result }
-      should eq result
-    end
-
-    include_examples 'basic tracking'
-  end
-
-  describe '#botan_track_action' do
-    subject { controller.send(:botan_track_action) }
-    let(:action_name) { double(:action_name) }
-
-    it 'calls botan#track with current action and payload' do
-      expect(controller).to receive(:action_name) { action_name }
-      expect(botan).to receive(:track).
-        with(action_name, user_id, deep_stringify(payload)) { result }
-      should eq result
-    end
-
-    include_examples 'basic tracking'
-  end
-end
--- a/spec/telegram/bot/botan_spec.rb
+++ b/spec/telegram/bot/botan_spec.rb
@@ -1,27 +0,0 @@
-RSpec.describe Telegram::Bot::Botan do
-  let(:instance) { described_class.new 'token' }
-  let(:token) { 'token' }
-
-  include_examples 'initializers', :botans
-  it_behaves_like 'async', request_args: -> { [double(:method), double(:url)] }
-
-  describe '.new' do
-    subject { described_class.new(*args) }
-
-    context 'when usual args are given' do
-      let(:args) { ['secret'] }
-      its(:token) { should eq args[0] }
-    end
-
-    context 'when options are given' do
-      let(:args) { [token: 'secret'] }
-      its(:token) { should eq args[0][:token] }
-    end
-  end
-
-  describe '.prepare_async_args' do
-    subject { described_class.prepare_async_args(*input) }
-    let(:input) { [:post, :uri, {a: 1, b: :sym, 'd' => 'str'}, 'body'] }
-    it { should eq ['post', 'uri', {a: 1, b: 'sym', 'd' => 'str'}, 'body'] }
-  end
-end
--- a/spec/telegram/bot/client/typed_response_spec.rb
+++ b/spec/telegram/bot/client/typed_response_spec.rb
@@ -3,7 +3,7 @@ RSpec.describe Telegram::Bot::Client::TypedResponse do

  describe '#get_me' do
    subject { bot.get_me }
-    before { expect(bot).to receive(:request).with(:getMe) { response } }
+    before { expect(bot).to receive(:request).with('getMe') { response } }
    let(:response) { {'ok' => true, 'result' => {'id' => user_id}} }
    let(:user_id) { 123 }
    it { should be_instance_of Telegram::Bot::Types::User }
@@ -17,7 +17,7 @@ RSpec.describe Telegram::Bot::Client::TypedResponse do

  describe '#get_updates' do
    subject { bot.get_updates }
-    before { expect(bot).to receive(:request).with(:getUpdates) { response } }
+    before { expect(bot).to receive(:request).with('getUpdates') { response } }
    let(:response) { {'ok' => true, 'result' => [{'update_id' => update_id}]} }
    let(:update_id) { 123 }
    it { should be_instance_of Array }
@@ -29,4 +29,16 @@ RSpec.describe Telegram::Bot::Client::TypedResponse do
      it { expect { subject }.to raise_error Telegram::Bot::Error }
    end
  end
+
+  describe '#delete_webhook' do
+    subject { bot.delete_webhook }
+    before { expect(bot).to receive(:request).with('deleteWebhook') { response } }
+    let(:response) { {'ok' => true, 'result' => true} }
+    it { should eq true }
+
+    context 'on error' do
+      let(:response) { raise Telegram::Bot::Error }
+      it { expect { subject }.to raise_error Telegram::Bot::Error }
+    end
+  end
 end
--- a/spec/telegram/bot/client_spec.rb
+++ b/spec/telegram/bot/client_spec.rb
@@ -1,7 +1,6 @@
 RSpec.describe Telegram::Bot::Client do
  let(:instance) { described_class.new 'token' }
  let(:token) { 'token' }
-  let(:botan_token) { double(:botan_token) }

  include_examples 'initializers'
  it_behaves_like 'async', request_args: -> { [double(:action), {body: :content}] }
@@ -52,7 +51,7 @@ RSpec.describe Telegram::Bot::Client do
  describe '#request' do
    subject { -> { instance.request(action, request_body) } }
    let(:action) { :some_action }
-    let(:url) { "#{format described_class::URL_TEMPLATE, token}#{action}" }
+    let(:url) { "#{format(described_class::URL_TEMPLATE, token: token)}#{action}" }
    let(:request_body) { double(:body) }
    let(:prepared_body) { double(:prepared_body) }
    let(:response) { HTTP::Message.new_response(body).tap { |x| x.status = status } }
--- a/spec/telegram/bot/config_methods_spec.rb
+++ b/spec/telegram/bot/config_methods_spec.rb
@@ -11,12 +11,10 @@ RSpec.describe Telegram::Bot::ConfigMethods do
      chat: {
        token: 'chat_token',
        username: 'Chat',
-        botan: 'chat_botan_token',
      },
      other_chat: {
        'token' => 'other_chat_token',
        'username' => 'OtherChat',
-        'botan' => 'other_chat_botan_token',
      },
    }
  end
@@ -43,7 +41,6 @@ RSpec.describe Telegram::Bot::ConfigMethods do
      its(:id) { should eq :chat }
      its(:token) { should eq config[:chat][:token] }
      its(:username) { should eq config[:chat][:username] }
-      its('botan.token') { should eq config[:chat][:botan] }
    end

    context 'configured by hash with stringified keys' do
@@ -51,18 +48,6 @@ RSpec.describe Telegram::Bot::ConfigMethods do
      its(:id) { should eq :other_chat }
      its(:token) { should eq config[:other_chat]['token'] }
      its(:username) { should eq config[:other_chat]['username'] }
-      its('botan.token') { should eq config[:other_chat]['botan'] }
-    end
-  end
-
-  describe '#botans' do
-    subject { registry.botans }
-    it do
-      should eq(
-        default: nil,
-        chat: registry.bots[:chat].botan,
-        other_chat: registry.bots[:other_chat].botan,
-      )
    end
  end

@@ -76,13 +61,14 @@ RSpec.describe Telegram::Bot::ConfigMethods do
      it { should eq({}) }

      context 'in rails environment' do
-        before { stub_const('Rails', double(application: double(secrets: secrets))) }
+        before { stub_const('Rails', double(application: double(app_stub))) }
+        let(:app_stub) { {secrets: secrets} }
        let(:secrets) { {} }
        it { should eq({}) }

        context 'when there is telegram section in secrets' do
-          let(:secrets) { {telegram: config.stringify_keys} }
-          let(:config) do
+          let(:secrets) { {telegram: secrets_config} }
+          let(:secrets_config) do
            {
              bot: double(:bot_config),
              bots: {
@@ -91,13 +77,21 @@ RSpec.describe Telegram::Bot::ConfigMethods do
              },
            }
          end
-          it { should include default: config[:bot] }
-          it { should include config[:bots] }
+          it { should include default: secrets_config[:bot] }
+          it { should include secrets_config[:bots] }

          context 'on rails >5.1 (deep symbolized keys)' do
-            let(:secrets) { {telegram: config.deep_symbolize_keys} }
-            it { should include default: config[:bot] }
-            it { should include config[:bots] }
+            let(:secrets) { super().deep_symbolize_keys }
+            it { should include default: secrets_config[:bot] }
+            it { should include secrets_config[:bots] }
+          end
+
+          context 'and credentials (>= 5.2)' do
+            let(:app_stub) { super().merge(credentials: credentials) }
+            let(:credentials) { {telegram: credentials_config} }
+            let(:credentials_config) { {bot: double(:credentials_bot_config)} }
+            it { should include default: credentials_config[:bot] }
+            it { should_not include secrets[:bots] }
          end
        end
      end
--- a/spec/telegram/bot/middleware_spec.rb
+++ b/spec/telegram/bot/middleware_spec.rb
@@ -7,7 +7,6 @@ RSpec.describe Telegram::Bot::Middleware do

  describe '#call' do
    subject { instance.call(env) }
-    let(:env) { {'action_dispatch.request.request_parameters' => json_body} }
    let(:update) { {'message' => {'id' => 1}} }
    let(:env) do
      Rack::MockRequest.env_for('/',
@@ -21,7 +20,6 @@ RSpec.describe Telegram::Bot::Middleware do
    if ActionPack::VERSION::MAJOR < 5
      # Before Rails 5, params are parsed in middleware.
      # In Rails 5, they are parsed in Request#request_parameters.
-      require 'action_dispatch/middleware/params_parser'
      let(:instance) { ActionDispatch::ParamsParser.new(super()) }
    end

--- a/spec/telegram/bot/routes_helper_spec.rb
+++ b/spec/telegram/bot/routes_helper_spec.rb
@@ -40,26 +40,24 @@ RSpec.describe Telegram::Bot::RoutesHelper do
    end
  end

-  describe '#telegram_webhooks' do
-    subject { mapper.telegram_webhooks(*input) }
+  describe '#telegram_webhook' do
+    subject { mapper.telegram_webhook(*input) }
    let(:mapper) { double(:mapper).tap { |x| x.extend described_class } }
    let(:bots) { {default: bot, other: other_bot} }
    let(:controller) { double(:controller, name: :controller) }
    let(:other_controller) { double(:other_controller, name: :other_controller) }
    before { allow(Telegram).to receive(:bots) { bots } }

-    def assert_routes(*expected) # rubocop:disable AbcSize
-      expected.each do |(bot, controller, route_name, options)|
-        expected_path = options.delete(:path) || "telegram/#{bot.token}"
-        expect(mapper).to receive(:post) do |path, params|
-          expect(path).to eq expected_path
-          middleware = params[:to]
-          expect(middleware.controller).to eq(controller)
-          expect(middleware.bot.token).to eq(bot.token)
-          expect(middleware.bot.username).to eq(bot.username)
-          expect(params[:as]).to eq route_name
-          expect(params).to include(options) if options
-        end
+    def assert_routes(bot, controller, route_name, options) # rubocop:disable AbcSize
+      expected_path = options.delete(:path) || "telegram/#{bot.token}"
+      expect(mapper).to receive(:post) do |path, params|
+        expect(path).to eq expected_path
+        middleware = params[:to]
+        expect(middleware.controller).to eq(controller)
+        expect(middleware.bot.token).to eq(bot.token)
+        expect(middleware.bot.username).to eq(bot.username)
+        expect(params[:as]).to eq route_name
+        expect(params).to include(options) if options
      end
      subject
    end
@@ -67,78 +65,33 @@ RSpec.describe Telegram::Bot::RoutesHelper do
    context 'when called with controller' do
      let(:input) { [controller, option: :val] }

-      it 'creates routes for every bot and this controller' do
-        assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
-                      [other_bot, controller, 'other_telegram_webhook', option: :val]
+      it 'creates routes for default bot and this controller' do
+        assert_routes bot, controller, 'default_telegram_webhook', option: :val
      end

      context 'and bot does not have configured token' do
        let(:bot) { create_bot(nil) }
-        it 'creates routes for every bot and this controller' do
-          assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
-                        [other_bot, controller, 'other_telegram_webhook', option: :val]
+        it 'creates routes for default bot and this controller' do
+          assert_routes bot, controller, 'default_telegram_webhook', option: :val
        end
      end

      context 'and bot has colon in token' do
        let(:bot) { create_bot('some:token') }
        it 'replaces colon with underscore' do
-          assert_routes [
-            bot,
-            controller,
-            'default_telegram_webhook',
+          assert_routes bot, controller, 'default_telegram_webhook',
            option: :val,
-            path: 'telegram/some_token',
-          ], [other_bot, controller, 'other_telegram_webhook', option: :val]
+            path: 'telegram/some_token'
        end
      end
    end

-    context 'when called with hash' do
-      let(:input) do
-        [
-          {
-            bot => controller,
-            'custom_token' => [other_controller, as: :custom_route, option: :other_val],
-            other: controller,
-          },
-          option: :val,
-        ]
-      end
-
-      it 'creates routes for every bot and its controller' do
-        assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
-                      [
-                        create_bot('custom_token'),
-                        other_controller,
-                        :custom_route,
-                        option: :other_val,
-                      ],
-                      [Telegram.bots[:other], controller, 'other_telegram_webhook', option: :val]
-      end
-    end
-
    context 'when called with controller and smth castable to bot' do
-      let(:input) do
-        [
-          controller,
-          ['custom_token', token: bot.token, username: 'new_name'],
-          option: :val,
-        ]
-      end
+      let(:input) { [controller, 'custom_token', option: :val] }

      it 'creates routes for every created bot and controller' do
-        assert_routes [
-          create_bot('custom_token'),
-          controller,
-          'telegram_webhook',
-          option: :val,
-        ], [
-          create_bot(bot.token, 'new_name'),
-          controller,
-          'telegram_webhook',
-          option: :val,
-        ]
+        assert_routes create_bot('custom_token'), controller, 'telegram_webhook',
+          option: :val
      end
    end
  end
--- a/spec/telegram/bot/rspec/callback_query_helpers_spec.rb
+++ b/spec/telegram/bot/rspec/callback_query_helpers_spec.rb
@@ -0,0 +1,42 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Integration spec helpers', telegram_bot: :poller do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      include Telegram::Bot::UpdatesController::CallbackQueryContext
+
+      def callback_query(data = nil, *)
+        answer_callback_query "data: #{data}"
+      end
+
+      def context_callback_query(data = nil, *)
+        answer_callback_query "data: #{data}", extra: :param
+      end
+
+      def answer_and_edit_callback_query(data = nil, *)
+        answer_callback_query "data: #{data}"
+        edit_message :text, text: 'edited-text', extra: :param
+      end
+    end
+  end
+
+  describe '#callback_query', :callback_query do
+    let(:data) { 'unknown:command' }
+    it { should answer_callback_query("data: #{data}") }
+  end
+
+  describe '#context_callback_query', :callback_query do
+    let(:data) { 'context:test:payload' }
+    it { should answer_callback_query('data: test:payload', extra: :param) }
+    it { should_not edit_current_message(:text) }
+  end
+
+  describe '#answer_and_edit_callback_query', :callback_query do
+    let(:data) { 'answer_and_edit:test:payload' }
+    it do
+      should answer_callback_query(/test:payload/).
+        and edit_current_message(:text, text: /edited/, extra: :param)
+    end
+  end
+end
--- a/spec/telegram/bot/rspec/integration/poller_spec.rb
+++ b/spec/telegram/bot/rspec/integration/poller_spec.rb
@@ -0,0 +1,5 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Poller integration spec', telegram_bot: :poller do
+  include_examples 'shared integration examples'
+end
--- a/spec/telegram/bot/rspec/integration/rack_spec.rb
+++ b/spec/telegram/bot/rspec/integration/rack_spec.rb
@@ -0,0 +1,20 @@
+require 'telegram/bot/rspec/integration/rack'
+
+RSpec.describe 'Rack integration spec', telegram_bot: :rack do
+  include_examples 'shared integration examples'
+  let(:request_path) { '/bot' }
+  let(:app) do
+    path = request_path
+    bot_app = Telegram::Bot::Middleware.new(bot, controller_class)
+    app = Rack::Builder.new do
+      map(path) { run bot_app }
+      run ->(env) { raise "Route is not mapped: #{env['PATH_INFO']}" }
+    end
+    if ActionPack::VERSION::MAJOR >= 5
+      app
+    else
+      require 'action_dispatch/middleware/params_parser'
+      ActionDispatch::ParamsParser.new(app)
+    end
+  end
+end
--- a/spec/telegram/bot/rspec/integration/rails_spec.rb
+++ b/spec/telegram/bot/rspec/integration/rails_spec.rb
@@ -0,0 +1 @@
+# Tested in spec/integration
--- a/spec/telegram/bot/rspec/integration_spec.rb
+++ b/spec/telegram/bot/rspec/integration_spec.rb
@@ -1,112 +0,0 @@
-require 'telegram/bot/rspec/integration'
-require 'action_controller'
-require 'action_dispatch'
-require 'action_dispatch/testing/integration'
-
-RSpec.describe 'Integrations helper', :telegram_bot do
-  include ActionDispatch::Integration::Runner
-  def reset_template_assertion
-  end
-
-  let(:app) do
-    app = Telegram::Bot::Middleware.new(bot, controller)
-    if ActionPack::VERSION::MAJOR >= 5
-      app
-    else
-      require 'action_dispatch/middleware/params_parser'
-      ActionDispatch::ParamsParser.new(app)
-    end
-  end
-  let(:bot) { Telegram::Bot::ClientStub.new('token') }
-  let(:controller_path) { '/' }
-  let(:controller) do
-    Class.new(Telegram::Bot::UpdatesController) do
-      def start(*args)
-        respond_with :message, text: "Start: #{args.inspect}, option: #{payload[:option]}"
-      end
-    end
-  end
-
-  describe '#default_message_options' do
-    subject { default_message_options }
-    it { should eq from: {id: from_id}, chat: {id: chat_id} }
-  end
-
-  describe '#dispatch' do
-    subject { -> { dispatch message: {text: '/start', **default_message_options} } }
-    it { should respond_with_message 'Start: [], option: ' }
-  end
-
-  describe '#dispatch_message' do
-    subject { -> { dispatch_message "/start #{args.join ' '}", options } }
-    let(:args) { %w[asd qwe] }
-    let(:options) { {} }
-    it { should respond_with_message "Start: #{args.inspect}, option: " }
-
-    context 'with options' do
-      let(:options) { {option: 1} }
-      it { should respond_with_message "Start: #{args.inspect}, option: 1" }
-
-      context 'and chat_id is not set' do
-        let(:options) { super().merge(chat: nil) }
-        it { should raise_error(/chat is not present/) }
-      end
-    end
-  end
-
-  describe '#dispatch_command' do
-    subject { -> { dispatch_command :start, *args } }
-    let(:args) { [] }
-    it { should respond_with_message "Start: #{args.inspect}, option: " }
-
-    context 'with args' do
-      let(:args) { %w[asd qwe] }
-      it { should respond_with_message "Start: #{args.inspect}, option: " }
-    end
-
-    context 'with options' do
-      let(:args) { ['asd', 'qwe', option: 1] }
-      it { should respond_with_message "Start: #{args[0...-1].inspect}, option: 1" }
-    end
-  end
-
-  describe 'callback queries', :callback_query do
-    let(:controller) do
-      Class.new(Telegram::Bot::UpdatesController) do
-        include Telegram::Bot::UpdatesController::CallbackQueryContext
-
-        def callback_query(data = nil, *)
-          answer_callback_query "data: #{data}"
-        end
-
-        def context_callback_query(data = nil, *)
-          answer_callback_query "data: #{data}", extra: :param
-        end
-
-        def answer_and_edit_callback_query(data = nil, *)
-          answer_callback_query "data: #{data}"
-          edit_message :text, text: 'edited-text', extra: :param
-        end
-      end
-    end
-
-    describe '#callback_query' do
-      let(:data) { 'unknown:command' }
-      it { should answer_callback_query("data: #{data}") }
-    end
-
-    describe '#context_callback_query' do
-      let(:data) { 'context:test:payload' }
-      it { should answer_callback_query('data: test:payload', extra: :param) }
-      it { should_not edit_current_message(:text) }
-    end
-
-    describe '#answer_and_edit_callback_query' do
-      let(:data) { 'answer_and_edit:test:payload' }
-      it do
-        should answer_callback_query(/test:payload/).
-          and edit_current_message(:text, text: /edited/, extra: :param)
-      end
-    end
-  end
-end
--- a/spec/telegram/bot/rspec/message_helpers_spec.rb
+++ b/spec/telegram/bot/rspec/message_helpers_spec.rb
@@ -0,0 +1,115 @@
+require 'telegram/bot/rspec/integration/poller'
+
+RSpec.describe 'Integration: message helpers', telegram_bot: :poller do
+  describe '#default_message_options' do
+    subject { default_message_options }
+    it { should eq from: {id: from_id}, chat: {id: chat_id} }
+  end
+
+  describe '#dispatch_message' do
+    subject { -> { dispatch_message text, options } }
+    let(:text) { '/start asd qwe' }
+    let(:options) { {} }
+    let(:result) { double(:result) }
+
+    it 'invokes dispatch' do
+      expect(self).to receive(:dispatch).with(
+        message: hash_including(default_message_options.merge(
+          text: text,
+        )),
+      ) { result }
+      expect(subject.call).to eq result
+    end
+
+    context 'with options' do
+      let(:options) { {option: 1} }
+      it 'invokes dispatch' do
+        expect(self).to receive(:dispatch).with(
+          message: hash_including(default_message_options.merge(
+            text: text,
+          ).merge(options)),
+        ) { result }
+        expect(subject.call).to eq result
+      end
+    end
+  end
+
+  describe '#dispatch_command' do
+    subject { -> { dispatch_command :start, *args } }
+    let(:args) { [] }
+    let(:result) { double(:result) }
+
+    it 'invokes dispatch' do
+      expect(self).to receive(:dispatch).with(
+        message: hash_including(default_message_options.merge(
+          text: '/start',
+        )),
+      ) { result }
+      expect(subject.call).to eq result
+    end
+
+    context 'with args & options' do
+      let(:args) { [*params, options] }
+      let(:params) { %w[qwe asd] }
+      let(:options) { {option: 1} }
+      it 'invokes dispatch' do
+        expect(self).to receive(:dispatch).with(
+          message: hash_including(default_message_options.merge(
+            text: "/start #{params.join(' ')}",
+          ).merge(options)),
+        ) { result }
+        expect(subject.call).to eq result
+      end
+    end
+  end
+end
+
+# Old specs
+RSpec.describe 'Integration: message helpers', telegram_bot: :poller do
+  let(:bot) { Telegram::Bot::ClientStub.new('token') }
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      def start!(*args)
+        respond_with :message, text: "Start: #{args.inspect}, option: #{payload['option']}"
+      end
+    end
+  end
+
+  describe '#default_message_options' do
+    subject { default_message_options }
+    it { should eq from: {id: from_id}, chat: {id: chat_id} }
+  end
+
+  describe '#dispatch_message' do
+    subject { -> { dispatch_message "/start #{args.join ' '}", options } }
+    let(:args) { %w[asd qwe] }
+    let(:options) { {} }
+    it { should respond_with_message "Start: #{args.inspect}, option: " }
+
+    context 'with options' do
+      let(:options) { {option: 1} }
+      it { should respond_with_message "Start: #{args.inspect}, option: 1" }
+
+      context 'and chat_id is not set' do
+        let(:options) { super().merge(chat: nil) }
+        it { should raise_error(/chat is not present/) }
+      end
+    end
+  end
+
+  describe '#dispatch_command' do
+    subject { -> { dispatch_command :start, *args } }
+    let(:args) { [] }
+    it { should respond_with_message "Start: #{args.inspect}, option: " }
+
+    context 'with args' do
+      let(:args) { %w[asd qwe] }
+      it { should respond_with_message "Start: #{args.inspect}, option: " }
+    end
+
+    context 'with options' do
+      let(:args) { ['asd', 'qwe', option: 1] }
+      it { should respond_with_message "Start: #{args[0...-1].inspect}, option: 1" }
+    end
+  end
+end
--- a/spec/telegram/bot/updates_controller/callback_query_context_spec.rb
+++ b/spec/telegram/bot/updates_controller/callback_query_context_spec.rb
@@ -27,7 +27,7 @@ RSpec.describe Telegram::Bot::UpdatesController::CallbackQueryContext do
  describe '#dispatch' do
    subject { -> { dispatch } }
    let(:payload_type) { :callback_query }
-    let(:payload) { {'data' => data} }
+    let(:payload) { {data: data} }
    let(:data) { text }
    let(:text) { 'asd qwe zxc' }

--- a/spec/telegram/bot/updates_controller/commands_spec.rb
+++ b/spec/telegram/bot/updates_controller/commands_spec.rb
@@ -0,0 +1,111 @@
+RSpec.describe Telegram::Bot::UpdatesController::Commands do
+  describe '#action_for_command' do
+    subject { ->(*args) { object.action_for_command(*args) } }
+    let(:object) { Object.new.tap { |x| x.extend described_class } }
+
+    def assert_subject(input, expected)
+      expect(subject.call input).to eq expected
+    end
+
+    it 'bypasses and downcases not conflictint commands' do
+      assert_subject 'test', 'test!'
+      assert_subject 'TeSt', 'test!'
+      assert_subject '_Te1St', '_te1st!'
+    end
+  end
+
+  describe '.command_from_text' do
+    subject { ->(*args) { described_class.command_from_text(*args) } }
+
+    def assert_subject(input, cmd, *args)
+      expected = cmd ? [cmd, args] : cmd
+      expect(subject.call(*input)).to eq expected
+    end
+
+    let(:max_cmd_size) { 32 }
+    let(:long_cmd) { 'a' * (max_cmd_size - 1) }
+    let(:too_long_cmd) { 'a' * max_cmd_size }
+
+    it 'works for simple commands' do
+      assert_subject '/test', 'test'
+      assert_subject '/tE_2_St', 'tE_2_St'
+      assert_subject '/123', '123'
+      assert_subject "/#{long_cmd}", long_cmd
+    end
+
+    it 'works for simple messages' do
+      assert_subject 'text', nil
+      assert_subject ' ', nil
+      assert_subject ' text', nil
+      assert_subject ' 1', nil
+      assert_subject ' /text', nil
+      assert_subject '/te-xt', nil
+      assert_subject 'text /cmd ', nil
+      assert_subject "/#{too_long_cmd}", nil
+    end
+
+    it 'works for mentioned commands' do
+      assert_subject ['/test@bot', 'bot'], 'test'
+      assert_subject ['/test@otherbot', 'bot'], nil
+      assert_subject ['/test@Bot', 'bot'], nil
+      assert_subject '/test@bot', nil
+      assert_subject ['/test@bot', true], 'test'
+      assert_subject ['/test@otherbot', true], 'test'
+    end
+
+    it 'works for commands with args' do
+      assert_subject '/test arg', 'test', 'arg'
+      assert_subject '/test  arg  1  2', 'test', 'arg', '1', '2'
+      assert_subject ['/test@bot arg', 'bot'], 'test', 'arg'
+      assert_subject ['/test@otherbot arg', 'bot'], nil
+      assert_subject '/test@bot arg', nil
+    end
+
+    it 'works for commands with multiline args' do
+      assert_subject "/test arg\nother", 'test', 'arg', 'other'
+      assert_subject "/test one\ntwo\n\nthree", 'test', 'one', 'two', 'three'
+    end
+  end
+
+  describe '#action_for_payload' do
+    include_context 'telegram/bot/updates_controller'
+    let(:controller_class) { Telegram::Bot::UpdatesController }
+    subject { controller.action_for_payload }
+
+    %w[message channel_post].each do |type|
+      context "when payload is edited_#{type}" do
+        let(:payload_type) { "edited_#{type}" }
+        it { should eq [payload_type, [payload]] }
+      end
+
+      context 'when payload is message' do
+        let(:payload_type) { type }
+        let(:payload) { {'text' => text} }
+        let(:text) { 'test' }
+
+        it { should eq [payload_type, [payload]] }
+
+        context 'with command' do
+          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
+          let(:mention) {}
+          it { should eq [['test!', type: :command, command: 'test'], %w[arg 1 2]] }
+
+          context 'with mention' do
+            let(:mention) { bot.username }
+            it { should eq [['test!', type: :command, command: 'test'], %w[arg 1 2]] }
+          end
+
+          context 'with mention for other bot' do
+            let(:mention) { 'other_bot_name' }
+            it { should eq [payload_type, [payload]] }
+          end
+        end
+
+        context 'without text' do
+          let(:payload) { {'audio' => {'file_id' => 123}} }
+          it { should eq [payload_type, [payload]] }
+        end
+      end
+    end
+  end
+end
--- a/spec/telegram/bot/updates_controller/instrumentation_spec.rb
+++ b/spec/telegram/bot/updates_controller/instrumentation_spec.rb
@@ -0,0 +1,89 @@
+RSpec.describe Telegram::Bot::UpdatesController::Instrumentation do
+  include_context 'telegram/bot/updates_controller'
+
+  subject { -> { dispatch } }
+  let(:update) { {message: default_message_options.merge(text: '/start')} }
+
+  let(:controller_class) do
+    Class.new(Telegram::Bot::UpdatesController) do
+      def start!(*)
+      end
+    end
+  end
+
+  let(:action_scope) { 'updates_controller.bot.telegram' }
+  let(:events) { Hash.new { |h, k| h[k] = [] } }
+  let!(:subscriber) do
+    ActiveSupport::Notifications.subscribe(/#{action_scope}/) do |action, *args|
+      events[action] << args
+    end
+  end
+  after { ActiveSupport::Notifications.unsubscribe(subscriber) }
+
+  def actions_list(*prefixes)
+    prefixes.map { |x| action_name(x) }
+  end
+
+  def action_name(prefix)
+    "#{prefix}.#{action_scope}"
+  end
+
+  describe '#process_action' do
+    it 'fires start_processing and process_action events' do
+      should change(events, :keys).by(actions_list(:start_processing, :process_action))
+
+      action = action_name(:start_processing)
+      expect(events[action].size).to eq(1)
+      expect(events[action][0].last).to include(update: deep_stringify(update))
+
+      action = action_name(:process_action)
+      expect(events[action].size).to eq(1)
+      expect(events[action][0].last).to include(update: deep_stringify(update))
+    end
+  end
+
+  describe '#halted_callback_hook' do
+    let(:controller_class) do
+      super().try(:class_eval) do |x|
+        x.before_action :halter_method
+
+        def halter_method
+          require 'active_support/version'
+          if ActiveSupport::VERSION::MAJOR >= 5
+            throw :abort
+          else
+            false
+          end
+        end
+
+        self
+      end
+    end
+
+    it 'fires halted_callback event' do
+      should change(events, :keys).
+        by(actions_list(:start_processing, :halted_callback, :process_action))
+
+      action = action_name(:halted_callback)
+      expect(events[action].size).to eq(1)
+      expect(events[action][0].last).to include(filter: :halter_method)
+    end
+  end
+
+  describe '#respond_with' do
+    before do
+      def controller.start!(*)
+        respond_with :message, text: 'sample response'
+      end
+    end
+
+    it 'fires respond_with event' do
+      should change(events, :keys).
+        by(actions_list(:start_processing, :respond_with, :process_action))
+
+      action = action_name(:respond_with)
+      expect(events[action].size).to eq(1)
+      expect(events[action][0].last).to include(type: :message)
+    end
+  end
+end
--- a/spec/telegram/bot/updates_controller/message_context_spec.rb
+++ b/spec/telegram/bot/updates_controller/message_context_spec.rb
@@ -6,7 +6,7 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
      include described_class

      attr_accessor :filter_done
-      before_action only: :redirect do
+      before_action only: :context_with_filter do
        self.filter_done = true
      end

@@ -17,19 +17,16 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
        [:no_context, *args]
      end

-      context_handler :block do |*args|
-        [:block_result, *args]
+      def handler_method(*args)
+        [:method_result_1, *args]
      end

-      context_handler :redirect
-      context_handler :other_redirect, :redirect
-
-      def redirect(*args)
-        [:method_result, *args]
+      def context_with_filter(*args)
+        [:method_result_2, *args]
      end

-      def action(*args)
-        [:action_result, *args]
+      def action!(*args)
+        [:command_result, *args]
      end

      private
@@ -52,85 +49,59 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do
      it { should_not change { session[:context] } }
    end

-    context 'when context is handled by block' do
-      before { session[:context] = :block }
-      its(:call) { should eq [:block_result, *text.split] }
+    context 'when context is handled by handler_method' do
+      before { session[:context] = :handler_method }
+      its(:call) { should eq [:method_result_1, *text.split] }
      it { should_not change(controller, :filter_done) }
      it { should change { session[:context] }.to nil }

      context 'when message has no text' do
        let(:payload) { {'audio' => {'file_id' => 123}} }
-        its(:call) { should eq [:block_result] }
+        its(:call) { should eq [:method_result_1] }
      end

      context 'when message has new command' do
        let(:text) { '/action a s d' }
-        its(:call) { should eq [:action_result, 'a', 's', 'd'] }
+        its(:call) { should eq [:command_result, 'a', 's', 'd'] }
        it { should change { session[:context] }.to nil }
      end
    end

-    context 'when context is handled by short redirect' do
-      before { session[:context] = :redirect }
-      its(:call) { should eq [:method_result, *text.split] }
+    context 'when context is handled by short context_with_filter' do
+      before { session[:context] = :context_with_filter }
+      its(:call) { should eq [:method_result_2, *text.split] }
      it { should change(controller, :filter_done).to true }
      it { should change { session[:context] }.to nil }
      it { should change(controller, :callbacks_runs).to 1 }

      context 'when message has no text' do
        let(:payload) { {'audio' => {'file_id' => 123}} }
-        its(:call) { should eq [:method_result] }
+        its(:call) { should eq [:method_result_2] }
        it { should change(controller, :filter_done).to true }
        it { should change { session[:context] }.to nil }
      end
    end

-    context 'when context is handled by custom redirect' do
-      before { session[:context] = :other_redirect }
-      its(:call) { should eq [:method_result, *text.split] }
-      it { should change(controller, :filter_done).to true }
-      it { should change { session[:context] }.to nil }
-    end
-
-    context 'when context is action`s name but not mapped' do
-      before { session[:context] = :action }
-      its(:call) { should eq [:no_context, payload] }
+    context 'when context is command-action`s name' do
+      before { session[:context] = :action! }
+      its(:call) { should eq [:command_result, *text.split] }
      it { should_not change(controller, :filter_done) }
      it { should change { session[:context] }.to nil }
    end

-    context 'when context_to_action is true' do
-      before { controller_class.context_to_action! }
-
-      context 'when context is not set' do
-        its(:call) { should eq [:no_context, payload] }
-        it { should_not change(controller, :filter_done) }
-        it { should_not change { session[:context] } }
+    context 'when context is not an action`s name' do
+      before { session[:context] = :not_action }
+      it do
+        should raise_error(AbstractController::ActionNotFound).
+          and change { session[:context] }.to nil
      end
+    end

-      context 'when context is action`s name but not mapped' do
-        before { session[:context] = :action }
-        its(:call) { should eq [:action_result, *text.split] }
-        it { should_not change(controller, :filter_done) }
-        it { should change { session[:context] }.to nil }
-      end
-
-      context 'when context is invalid' do
-        before { session[:context] = :invalid }
-        it 'raises error and clears context' do
-          expect do
-            should raise_error AbstractController::ActionNotFound
-          end.to change { session[:context] }.to nil
-        end
-      end
-
-      context 'when context is private method`s name' do
-        before { session[:context] = :not_action }
-        it 'raises error and clears context' do
-          expect do
-            should raise_error AbstractController::ActionNotFound
-          end.to change { session[:context] }.to nil
-        end
+    context 'when context is invalid name' do
+      before { session[:context] = :invalid }
+      it do
+        should raise_error(AbstractController::ActionNotFound).
+          and change { session[:context] }.to nil
      end
    end
  end
--- a/spec/telegram/bot/updates_controller/reply_helpers_spec.rb
+++ b/spec/telegram/bot/updates_controller/reply_helpers_spec.rb
@@ -4,8 +4,8 @@ RSpec.describe Telegram::Bot::UpdatesController do
  let(:respond_type) { :photo }
  let(:result) { double(:result) }
  let(:payload_type) { :message }
-  let(:payload) { {message_id: double(:message_id)} }
-  let(:chat) { {'id' => double(:chat_id)} }
+  let(:payload) { {message_id: double(:message_id), chat: chat} }
+  let(:chat) { {id: double(:chat_id)} }

  shared_examples 'missing chat' do
    context 'when chat is missing' do
@@ -19,9 +19,8 @@ RSpec.describe Telegram::Bot::UpdatesController do
    include_examples 'missing chat'

    it 'sets chat_id & reply_to_message_id' do
-      expect(controller).to receive(:chat) { chat }
      expect(bot).to receive("send_#{respond_type}").
-        with(params.merge(chat_id: chat['id'])) { result }
+        with(params.merge(chat_id: chat[:id])) { result }
      should eq result
    end
  end
@@ -31,19 +30,18 @@ RSpec.describe Telegram::Bot::UpdatesController do
    include_examples 'missing chat'

    it 'sets chat_id & reply_to_message_id' do
-      expect(controller).to receive(:chat) { chat }
      expect(bot).to receive("send_#{respond_type}").with(params.merge(
-        chat_id: chat['id'],
+        chat_id: chat[:id],
        reply_to_message_id: payload[:message_id],
      )) { result }
      should eq result
    end

    context 'when update is not set' do
-      let(:update) { {chat: chat} }
+      let(:controller_args) { [bot, chat: deep_stringify(chat)] }
      it 'sets chat_id' do
        expect(bot).to receive("send_#{respond_type}").
-          with(params.merge(chat_id: chat['id'])) { result }
+          with(params.merge(chat_id: chat[:id])) { result }
        should eq result
      end
    end
@@ -70,7 +68,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
      it 'sets chat_id & message_id' do
        expect(bot).to receive("edit_message_#{type}").with(params.merge(
          message_id: payload[:message][:message_id],
-          chat_id: payload[:message][:chat]['id'],
+          chat_id: payload[:message][:chat][:id],
        )) { result }
        should eq result
      end
--- a/spec/telegram/bot/updates_controller/rescue_spec.rb
+++ b/spec/telegram/bot/updates_controller/rescue_spec.rb
@@ -0,0 +1,31 @@
+RSpec.describe Telegram::Bot::UpdatesController::Rescue do
+  include_context 'telegram/bot/updates_controller'
+
+  describe '#process_action' do
+    subject { -> { dispatch_message("/#{command} x y z") } }
+
+    let(:controller_class) do
+      Class.new(Telegram::Bot::UpdatesController) do
+        rescue_from ArgumentError, with: -> { respond_with :message, text: 'Rescued' }
+
+        def rescuable!(*)
+          raise ArgumentError, 'rescuable'
+        end
+
+        def not_rescuable!(*)
+          raise 'not_rescuable'
+        end
+      end
+    end
+
+    context 'when exception is rescued' do
+      let(:command) { :rescuable }
+      it { should respond_with_message 'Rescued' }
+    end
+
+    context 'when exception is not rescued' do
+      let(:command) { :not_rescuable }
+      it { should raise_error('not_rescuable') }
+    end
+  end
+end
--- a/spec/telegram/bot/updates_controller/session_spec.rb
+++ b/spec/telegram/bot/updates_controller/session_spec.rb
@@ -19,11 +19,11 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
      controller_class.class_eval do
        self.session_store = :memory_store

-        def write(text)
+        def write!(text)
          session[:text] = text
        end

-        def read
+        def read!
          session[:text]
        end

@@ -36,7 +36,7 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
    end

    def build_message(text, from)
-      {'message' => {'text' => text, 'from' => from.stringify_keys}}
+      deep_stringify(message: {text: text, from: from})
    end

    it 'stores session between requests' do
--- a/spec/telegram/bot/updates_controller/translation_spec.rb
+++ b/spec/telegram/bot/updates_controller/translation_spec.rb
@@ -0,0 +1,31 @@
+RSpec.describe Telegram::Bot::UpdatesController::Translation do
+  describe '#translate' do
+    let(:controller) do
+      double(
+        controller_path: 'telegram/webhooks',
+        action_name: 'start!',
+      ).tap { |x| x.extend(described_class) }
+    end
+
+    it 'uses action_name without ! for lazy translations' do
+      expect(I18n).to receive(:translate).with('telegram.webhooks.start.hello',
+        default: [:'telegram.webhooks.hello'],
+      )
+      controller.t('.hello')
+    end
+  end
+
+  describe described_class::ClassMethods do
+    describe '#translate' do
+      let(:controller_class) do
+        double(controller_path: 'telegram/webhooks').
+          tap { |x| x.extend(described_class) }
+      end
+
+      it 'uses controller_path for lazy translations' do
+        expect(I18n).to receive(:translate).with('telegram.webhooks.hello', {})
+        controller_class.t('.hello')
+      end
+    end
+  end
+end
--- a/spec/telegram/bot/updates_controller/typed_update_spec.rb
+++ b/spec/telegram/bot/updates_controller/typed_update_spec.rb
@@ -9,17 +9,40 @@ RSpec.describe Telegram::Bot::UpdatesController::TypedUpdate do

  context 'when `update` is a virtus model' do
    subject { controller }
-    %w[
-      message
-      inline_query
-      chosen_inline_result
-    ].each do |type|
+    unique_types = Telegram::Bot::UpdatesController::PAYLOAD_TYPES - %w[
+      edited_message
+      channel_post
+      edited_channel_post
+    ]
+    unique_types.each do |type|
      context "with #{type}" do
        type_class = Telegram::Bot::Types.const_get(type.camelize)
        let(:payload_type) { type }
-        let(:payload) { {} }
+        let(:payload) do
+          {}.tap do |result|
+            result[:chat] = chat if type_class.instance_methods.include?(:chat)
+            result[:from] = from if type_class.instance_methods.include?(:from)
+          end
+        end
+        let(:chat) { {id: 'chat_id'} }
+        let(:from) { {id: 'from_id'} }
        its(:payload_type) { should eq payload_type }
        its(:payload) { should be_instance_of type_class }
+
+        if type_class.instance_methods.include?(:chat)
+          # Virtus does not support ==. :(
+          its(:chat) { should be_instance_of Telegram::Bot::Types::Chat }
+          its('chat.to_hash') { should include chat }
+        else
+          its(:chat) { should eq nil }
+        end
+
+        if type_class.instance_methods.include?(:from)
+          its(:from) { should be_instance_of Telegram::Bot::Types::User }
+          its('from.to_hash') { should include from }
+        else
+          its(:from) { should eq nil }
+        end
      end
    end
  end
--- a/spec/telegram/bot/updates_controller_spec.rb
+++ b/spec/telegram/bot/updates_controller_spec.rb
@@ -1,81 +1,5 @@
 RSpec.describe Telegram::Bot::UpdatesController do
  include_context 'telegram/bot/updates_controller'
-  let(:other_bot_name) { 'other_bot' }
-
-  describe '.action_for_command' do
-    subject { ->(*args) { described_class.action_for_command(*args) } }
-
-    def assert_subject(input, expected)
-      expect(subject.call input).to eq expected
-    end
-
-    it 'bypasses and downcases not conflictint commands' do
-      assert_subject 'test', 'test'
-      assert_subject 'TeSt', 'test'
-      assert_subject '_Te1St', '_te1st'
-    end
-
-    it 'adds _on to conflicting commands' do
-      described_class::PAYLOAD_TYPES.each do |x|
-        assert_subject x, "on_#{x}"
-        assert_subject x.upcase, "on_#{x}"
-      end
-      assert_subject '1TeSt', 'on_1test'
-    end
-  end
-
-  describe '.command_from_text' do
-    subject { ->(*args) { described_class.command_from_text(*args) } }
-
-    def assert_subject(input, cmd, *args)
-      expected = cmd ? [cmd, args] : cmd
-      expect(subject.call(*input)).to eq expected
-    end
-
-    let(:max_cmd_size) { 32 }
-    let(:long_cmd) { 'a' * (max_cmd_size - 1) }
-    let(:too_long_cmd) { 'a' * max_cmd_size }
-
-    it 'works for simple commands' do
-      assert_subject '/test', 'test'
-      assert_subject '/tE_2_St', 'tE_2_St'
-      assert_subject '/123', '123'
-      assert_subject "/#{long_cmd}", long_cmd
-    end
-
-    it 'works for simple messages' do
-      assert_subject 'text', nil
-      assert_subject ' ', nil
-      assert_subject ' text', nil
-      assert_subject ' 1', nil
-      assert_subject ' /text', nil
-      assert_subject '/te-xt', nil
-      assert_subject 'text /cmd ', nil
-      assert_subject "/#{too_long_cmd}", nil
-    end
-
-    it 'works for mentioned commands' do
-      assert_subject ['/test@bot', 'bot'], 'test'
-      assert_subject ['/test@otherbot', 'bot'], nil
-      assert_subject ['/test@Bot', 'bot'], nil
-      assert_subject '/test@bot', nil
-      assert_subject ['/test@bot', true], 'test'
-      assert_subject ['/test@otherbot', true], 'test'
-    end
-
-    it 'works for commands with args' do
-      assert_subject '/test arg', 'test', 'arg'
-      assert_subject '/test  arg  1  2', 'test', 'arg', '1', '2'
-      assert_subject ['/test@bot arg', 'bot'], 'test', 'arg'
-      assert_subject ['/test@otherbot arg', 'bot'], nil
-      assert_subject '/test@bot arg', nil
-    end
-
-    it 'works for commands with multiline args' do
-      assert_subject "/test arg\nother", 'test', 'arg', 'other'
-      assert_subject "/test one\ntwo\n\nthree", 'test', 'one', 'two', 'three'
-    end
-  end

  describe '#action_for_payload' do
    subject { controller.action_for_payload }
@@ -87,60 +11,30 @@ RSpec.describe Telegram::Bot::UpdatesController do
    context 'when payload is inline_query' do
      let(:payload_type) { 'inline_query' }
      let(:payload) { stub_payload(:id, :from, :location, :query, :offset) }
-      it { should eq [false, payload_type, payload.values_at(:query, :offset)] }
+      it { should eq [payload_type, payload.values_at(:query, :offset)] }
    end

    context 'when payload is chosen_inline_result' do
      let(:payload_type) { 'chosen_inline_result' }
      let(:payload) { stub_payload(:result_id, :from, :location, :inline_message_id, :query) }
-      it { should eq [false, payload_type, payload.values_at(:result_id, :query)] }
+      it { should eq [payload_type, payload.values_at(:result_id, :query)] }
    end

    context 'when payload is callback_query' do
      let(:payload_type) { 'callback_query' }
      let(:payload) { stub_payload(:id, :from, :message, :inline_message_id, :data) }
-      it { should eq [false, payload_type, payload.values_at(:data)] }
+      it { should eq [payload_type, payload.values_at(:data)] }
+    end
+
+    context 'when payload is poll_answer' do
+      let(:payload_type) { 'poll_answer' }
+      let(:payload) { stub_payload(:poll_id, :user, :option_ids) }
+      it { should eq [payload_type, payload.values_at(:poll_id, :option_ids)] }
    end

    context 'when payload is not supported' do
      let(:payload_type) { '_unsupported_' }
-      it { should eq [false, :unsupported_payload_type, []] }
-    end
-
-    %w[message channel_post].each do |type|
-      context "when payload is edited_#{type}" do
-        let(:payload_type) { "edited_#{type}" }
-        it { should eq [false, payload_type, [payload]] }
-      end
-
-      context 'when payload is message' do
-        let(:payload_type) { type }
-        let(:payload) { {'text' => text} }
-        let(:text) { 'test' }
-
-        it { should eq [false, payload_type, [payload]] }
-
-        context 'with command' do
-          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
-          let(:mention) {}
-          it { should eq [true, 'test', %w[arg 1 2]] }
-
-          context 'with mention' do
-            let(:mention) { bot.username }
-            it { should eq [true, 'test', %w[arg 1 2]] }
-          end
-
-          context 'with mention for other bot' do
-            let(:mention) { other_bot_name }
-            it { should eq [false, payload_type, [payload]] }
-          end
-        end
-
-        context 'without text' do
-          let(:payload) { {'audio' => {'file_id' => 123}} }
-          it { should eq [false, payload_type, [payload]] }
-        end
-      end
+      it { should eq [:unsupported_payload_type, []] }
    end

    custom_payload_types = %w[
@@ -151,11 +45,12 @@ RSpec.describe Telegram::Bot::UpdatesController do
      inline_query
      chosen_inline_result
      callback_query
+      poll_answer
    ]
    (described_class::PAYLOAD_TYPES - custom_payload_types).each do |type|
      context "when payload is #{type}" do
        let(:payload_type) { type }
-        it { should eq [false, payload_type, [payload]] }
+        it { should eq [payload_type, [payload]] }
      end
    end
  end
@@ -278,11 +173,13 @@ RSpec.describe Telegram::Bot::UpdatesController do
      instance_eval(&block)
      context 'when re-initialized' do
        let(:controller) do
-          described_class.new(double(:other_bot), build_update(:message,
+          initial_update = deep_stringify message: {
            text: 'original message',
            from: double(:original_from),
            chat: double(:original_chat),
-          )).tap { |x| x.send(:initialize, bot, update) }
+          }
+          described_class.new(double(:other_bot), initial_update).
+            tap { |x| x.send(:initialize, *controller_args) }
        end
        instance_eval(&block)
      end
@@ -300,7 +197,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
    end

    context 'when options hash is given' do
-      let(:update) { {from: from, chat: chat} }
+      let(:controller_args) { [bot, from: from, chat: chat] }
      with_reinitialize do
        its(:bot) { should eq bot }
        its(:update) { should eq nil }
--- a/spec/telegram/bot/updates_poller_spec.rb
+++ b/spec/telegram/bot/updates_poller_spec.rb
@@ -8,12 +8,32 @@ RSpec.describe Telegram::Bot::UpdatesPoller do
    it { should be }
  end

-  describe '#fetch_updates' do
-    subject { -> { instance.fetch_updates(&block) } }
+  describe '#process_updates' do
+    subject { -> { instance.process_updates(updates) } }
    let(:block) { ->(x) { expect(x).to eq expected_results.shift } }
-    let(:results) { [{update_id: 12}, {update_id: 34}] }
-    let(:expected_results) { results.as_json }
-    let(:request_result) { {ok: true, result: results}.as_json }
+    let(:updates) { [{update_id: 12}, {update_id: 34}].as_json }
+    let(:processed_updates) { [] }
+    before do
+      allow(controller).to receive(:dispatch) do |bot, update|
+        expect(bot).to eq self.bot
+        processed_updates << update
+      end
+    end
+
+    it { should change(instance, :offset).to(updates.last['update_id'] + 1) }
+    it { should change(self, :processed_updates).to(updates) }
+
+    context 'with typed response' do
+      let(:updates) { super().map { |x| Telegram::Bot::Types::Update.new(x) } }
+      it { should change(instance, :offset).to(updates.last['update_id'] + 1) }
+      it { should change(self, :processed_updates).to(updates) }
+    end
+  end
+
+  describe '#fetch_updates' do
+    subject { instance.fetch_updates }
+    let(:updates) { [{update_id: 12}, {update_id: 34}] }
+    let(:request_result) { {ok: true, result: updates}.as_json }
    before do
      allow(bot).to receive(:get_updates) do
        expect(bot.async).to be_falsy
@@ -21,19 +41,17 @@ RSpec.describe Telegram::Bot::UpdatesPoller do
      end
    end

-    it { should change(instance, :offset).to(results.last[:update_id] + 1) }
-    it { should change { expected_results }.to([]) }
+    it { should eq updates.as_json }

    context 'with typed response' do
-      let(:request_result) { results.as_json.map { |x| Telegram::Bot::Types::Update.new(x) } }
-      let(:expected_results) { request_result.dup }
-      it { should change(instance, :offset).to(results.last[:update_id] + 1) }
-      it { should change { expected_results }.to([]) }
+      let(:updates) { super().map { |x| Telegram::Bot::Types::Update.new(x.as_json) } }
+      let(:request_result) { updates }
+      it { should eq updates }
    end

    context 'when bot is in async mode' do
      let(:bot) { Telegram::Bot::Client.new('token', async: Class.new) }
-      it { should change { expected_results }.to([]) }
+      it { should eq updates.as_json }
    end
  end
 end
--- a/telegram-bot.gemspec
+++ b/telegram-bot.gemspec
@@ -17,12 +17,15 @@ Gem::Specification.new do |spec|
  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
  spec.require_paths = ['lib']

+  spec.post_install_message = 'Breaking changes in v0.14! ' \
+    'See upgrade guide at https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14'
+
  spec.required_ruby_version = '~> 2.0'

-  spec.add_dependency 'actionpack', '>= 4.0', '< 6.0'
-  spec.add_dependency 'activesupport', '>= 4.0', '< 6.0'
+  spec.add_dependency 'actionpack', '>= 4.0', '< 6.1'
+  spec.add_dependency 'activesupport', '>= 4.0', '< 6.1'
  spec.add_dependency 'httpclient', '~> 2.7'

-  spec.add_development_dependency 'bundler', '~> 1.11'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'bundler', '> 1.16'
+  spec.add_development_dependency 'rake', '~> 13.0'
 end
Автор	SHA1	Сообщение	Дата
Max Melentiev	8494c7df0c	v0.14.4	2020-04-15 20:40:55 +03:00
Max Melentiev	a2659e00c2	Bump rake version to resolve vulnerability notification	2020-04-04 22:36:41 +03:00
Max Melentiev	e43c611d9d	Merge pull request #131 from telegram-bot-rb/update_api Update to Bot API 4.7	2020-04-04 22:35:33 +03:00
Max Melentiev	b84c48bc1d	Update to Bot API 4.7	2020-04-04 22:26:26 +03:00
Max Melentiev	43cd096a21	Fix spelling in Async docs	2020-01-25 15:49:28 +03:00
Maximilian Haack	903e14a3e5	Fix make_telegram_request examples in README (#129 )	2020-01-25 13:34:48 +03:00
Max Melentiev	da31cd148a	v0.14.3	2019-08-24 19:34:34 +03:00
Max Melentiev	552f3b3353	Update to Bot API 4.4	2019-08-24 19:33:46 +03:00
Max Melentiev	e5f93f608b	Merge pull request #121 from telegram-bot-rb/rails_60 Require tests against rails 6.0, run tests against rails 6.1.alpha	2019-08-19 22:10:50 +03:00
Max Melentiev	7e823b4354	Require tests against rails 6.0, run tests against rails 6.1.alpha Rails 6.0 requires ruby >= 2.5, so ruby 2.4 is not tested by default and replaced with 2.6	2019-08-19 11:06:48 +03:00
Max Melentiev	ca4ea9e6cb	v0.14.2	2019-06-30 21:15:53 +03:00
Max Melentiev	68ec0257bd	Add note on editing rails 6.0 credential	2019-06-30 21:10:22 +03:00
Max Melentiev	b50bd30137	Add methods from api v4.3	2019-06-30 20:57:50 +03:00
Max Melentiev	80362da270	Add answer_shipping_query helper	2019-06-30 20:56:41 +03:00
Muhammad Nuzaihan Bin Kamal Luddin	294d762785	Add answer_pre_checkout_query helper (#118 )	2019-06-30 20:39:43 +03:00
printercu	1cb3265371	Merge pull request #113 from telegram-bot-rb/fix_travis Remove workaround for ruby 2.5.0 to fix travis builds	2019-02-15 20:03:31 +05:30
Max Melentiev	c44529725f	Relax bundler dependency	2019-02-15 19:46:01 +05:30
Max Melentiev	fa43561765	Remove workaround for ruby 2.5.0 to fix travis builds	2019-02-15 19:27:18 +05:30
printercu	cea856c928	Merge pull request #110 from biow0lf/master Fix typo	2019-02-15 19:25:32 +05:30
Igor Zubkov	5a93c1efc6	Fix typo	2019-01-24 03:47:05 +02:00
Max Melentiev	38ee303912	Fix doc-comment for latest changes	2018-09-23 10:39:56 +03:00
Max Melentiev	380d13f65a	Update to Bot API 4.1	2018-09-03 08:57:10 +03:00
Max Melentiev	20427499c3	Read config from secrets when credentials don't provide it in rails >= 5.2	2018-06-27 09:47:26 +03:00
Max Melentiev	8936a7a96c	Remove botan.io support https://github.com/botanio/sdk#this-service-will-be-shut-down-on-25th-may-2018	2018-06-22 07:45:08 +03:00
printercu	e2e32e041a	Merge pull request #94 from KonstantinReido/master Changed README a bit	2018-06-22 07:34:40 +03:00
Konstantin Reido	543258fa11	Remove section about Botan.io because this service isn’t available anymore	2018-06-22 00:52:27 +03:00
Konstantin Reido	4bf5956b41	Add a note to README about credentials API appeared in rails 5.2	2018-06-22 00:30:11 +03:00
Konstantin Reido	8b6dc60aaa	Fix typo in README	2018-06-22 00:25:20 +03:00
Max Melentiev	b6bef94081	Fix spelling in readme	2018-06-07 16:57:14 +06:00
Max Melentiev	1f62636a91	v0.14.0	2018-06-07 16:49:50 +06:00
printercu	64d00681a3	Merge pull request #85 from telegram-bot-rb/commands Refactor actions system	2018-06-07 14:42:12 +06:00
Max Melentiev	409d6e4aa8	Use not confusing naming in readme	2018-06-07 14:38:51 +06:00
Max Melentiev	b5f4c97f44	Class-level helper for lazy translations	2018-06-07 14:26:13 +06:00
Max Melentiev	7ff89d012c	Translation helper strips `!` from action name for lazy translations	2018-06-07 14:10:22 +06:00
Max Melentiev	6dd705fe89	Drop `.context_handler`, `.context_to_action!` methods	2018-06-07 12:32:09 +06:00
Max Melentiev	9310fa613b	Use bang-methods as actions for commands	2018-06-07 12:32:08 +06:00
printercu	8db3204609	Merge pull request #84 from telegram-bot-rb/unify_specs Unify specs	2018-06-07 12:29:31 +06:00
Max Melentiev	fb02c34be9	Add deprecated fallback at telegram/bot/rspec/integration	2018-06-07 12:20:34 +06:00
Max Melentiev	a9b45c70cf	Update readme	2018-06-06 01:47:17 +06:00
Daniel Pietersen	ad798cd48d	Testing Cleanup Thought I'd suggest some edits based on grammar and some spelling mistakes considering how useful this Bot has been for the project I'm working on. Feel free to ignore if it's not needed.	2018-06-06 01:37:34 +06:00
Max Melentiev	4d76941d03	Support for testing bots in poller mode and non-Rails apps	2018-05-30 11:43:05 +03:00
Max Melentiev	050df20533	Require action_dispatch fully It uses autoload, so it's lazy-loaded. However there are missing some internal requires so it will asks for more not-related `requires` when requiring some files directly.	2018-05-30 11:43:05 +03:00
Max Melentiev	673986ca7e	Make integration & controller specs consistent	2018-05-30 11:43:05 +03:00
Max Melentiev	eeb2569bd7	Remve deprecated telegram_webhooks	2018-05-28 19:49:11 +03:00
Max Melentiev	2eb2670ed2	v0.13.1	2018-05-28 13:27:35 +03:00
Max Melentiev	6a5e642470	Fix #chat for non-message updates with TypedUpdates enabled Fixes #82	2018-05-19 12:53:15 +03:00
printercu	4ff5a58b98	Merge pull request #79 from telegram-bot-rb/fix-travis Fix travis build	2018-05-14 13:20:35 +03:00
printercu	ffb13321b4	Fix travis build	2018-05-14 12:18:14 +03:00
printercu	3bdc4f5ae0	Merge pull request #72 from WA9ACE/patch-1 Spelling correction	2018-04-25 11:15:23 +03:00
Max Melentiev	5603016e4a	Extracted typed response mappings to telegram-bot-types gem Fixes #75	2018-04-25 11:07:34 +03:00
Caleb Albritton	fa6b9a825e	Spelling correction	2018-04-13 11:50:05 -04:00
printercu	bdff6b2e1c	Merge pull request #65 from telegram-bot-rb/rails-6 Prepare for rails 6	2018-02-21 21:34:49 +03:00
Max Melentiev	f39a451192	Add rails-6 to build matrix	2018-02-21 20:35:03 +03:00
Max Melentiev	9af6de8d36	Avoid Hash#transform_values. Fixes #63	2018-02-21 19:49:09 +03:00
Max Melentiev	c86b2ef09b	v0.13.0	2018-02-02 11:03:14 +03:00
Max Melentiev	bfcb1c5f41	Deleted page from wiki with old routes examples, remove this link from readme	2018-02-02 11:01:22 +03:00
Max Melentiev	88c8d4fd4e	Deprecate telegram_webhooks in favor of telegram_webhook	2018-02-02 10:52:48 +03:00
Max Melentiev	06253c940e	Extract methods in UpdatesPoller	2018-02-02 10:37:45 +03:00
printercu	eb24816e1e	Merge pull request #61 from telegram-bot-rb/test-cc Setup codeclimate integration	2018-01-18 14:12:11 +03:00
Max Melentiev	a67a643c7b	Build new rubies on travis	2018-01-18 14:04:39 +03:00
Max Melentiev	28db729320	Update changelog	2018-01-18 12:43:10 +03:00
Max Melentiev	7f1f2bb884	Fix readme	2018-01-18 12:42:11 +03:00
Max Melentiev	88ae24b7e8	Fix codeclimate issues	2018-01-18 12:42:04 +03:00
Max Melentiev	3a876a42df	Setup codeclimate	2018-01-18 12:31:32 +03:00
Yuri S	66991d3653	Support for :credentials on Rails v5.2.x. (#60 )	2018-01-17 10:40:24 +03:00
Max Melentiev	5407c5028f	Fix specs for rails 4	2018-01-09 12:00:49 +03:00
Max Melentiev	b41032eee9	Update rubocop	2018-01-05 14:21:08 +03:00
Max Melentiev	707e532963	Specs for instrumentation	2018-01-05 14:20:19 +03:00
Max Melentiev	45e8a7283f	`rescue_from` feature	2018-01-05 13:19:44 +03:00
Max Melentiev	70a1ed8a8f	Compact `require`s	2018-01-05 12:52:46 +03:00