v0.13.1

Fix #chat for non-message updates with TypedUpdates enabled
Fixes #82
2026-08-28 15:26:18 +03:00 · 2018-05-28 13:27:35 +03:00 · 2018-05-19 12:53:15 +03:00 · 2018-05-14 13:20:35 +03:00 · 2018-05-14 12:18:14 +03:00 · 2018-04-25 11:15:23 +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/.gitignore
+++ b/.gitignore
@@ -1,9 +1,12 @@
 /.bundle/
 /.yardoc
 /Gemfile.lock
+/gemfiles/*.lock
+/gemfiles/.bundle
 /_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
+/log/
 /tmp/
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,29 +1,55 @@
+# Rubocop does not support 2.0
+Gemspec/RequiredRubyVersion: {Enabled: false}
+
 Rails: {Enabled: true}

-Style/Alias: {Enabled: false}
-Style/AlignParameters:
+Layout/AlignParameters:
  # Disable, till rubocop supports combination of styles.
  # Use one of this styles where appropriate, keep it clean, compact and readable.
  Enabled: false
  # EnforcedStyle:
  # - with_first_parameter
  # - with_fixed_indentation
+
+# Breaks
+#
+#   I18n.t(key,
+#     param: val,
+#     # ...
+#   )
+Layout/ClosingParenthesisIndentation: {Enabled: false}
+Layout/DotPosition: {EnforcedStyle: trailing}
+Layout/FirstParameterIndentation: {EnforcedStyle: consistent}
+# Same as Layout/ClosingParenthesisIndentation
+Layout/MultilineMethodCallBraceLayout: {Enabled: false}
+Layout/MultilineMethodCallIndentation: {EnforcedStyle: indented}
+Layout/MultilineOperationIndentation: {EnforcedStyle: indented}
+Layout/SpaceInsideHashLiteralBraces: {EnforcedStyle: no_space}
+
+# Offences named scopes and `expect {}.to change {}`.
+Lint/AmbiguousBlockAssociation: {Enabled: false}
+
+Naming/PredicateName: {Enabled: false}
+Naming/VariableNumber: {EnforcedStyle: snake_case}
+
+Style/Alias: {Enabled: false}
 Style/AndOr: {EnforcedStyle: conditionals}
-Style/ClosingParenthesisIndentation: {Enabled: false}
 Style/Documentation: {Enabled: false}
-Style/DotPosition: {EnforcedStyle: trailing}
-Style/FirstParameterIndentation: {EnforcedStyle: consistent}
 Style/IfUnlessModifier: {Enabled: false}
+
+# Consistent to other definitions.
+Style/EmptyMethod: {EnforcedStyle: expanded}
+
 Style/ModuleFunction: {Enabled: false}
-Style/MultilineOperationIndentation: {EnforcedStyle: indented}
 Style/NestedParenthesizedCalls: {Enabled: false}
-Style/PredicateName: {Enabled: false}
 Style/SignalException: {EnforcedStyle: only_raise}
-Style/SpaceInsideHashLiteralBraces: {EnforcedStyle: no_space}
 Style/TrailingCommaInArguments: {Enabled: false}
 Style/TrailingCommaInLiteral: {EnforcedStyleForMultiline: comma}

 Metrics/AbcSize: {Max: 21}
+# Other metrics are just enough.
+# This one offences all specs, routes and some initializers.
+Metrics/BlockLength: {Enabled: false}
 Metrics/LineLength: {Max: 100}
 Metrics/MethodLength: {Max: 30}
 Metrics/CyclomaticComplexity: {Max: 8}
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +1,34 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.2.3
-env:
-  - RAILS=4
-  - RAILS=5
+- 2.5
+- 2.4
+gemfile:
+- gemfiles/rails_52.gemfile
+- gemfiles/rails_51.gemfile
+matrix:
+  include:
+  # old rails
+  - rvm: 2.5
+    gemfile: gemfiles/rails_50.gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rails_42.gemfile
+  # old rubies
+  - rvm: 2.3
+    gemfile: gemfiles/rails_52.gemfile
+  # future rails
+  - rvm: 2.5
+    gemfile: gemfiles/rails_60.gemfile
+  # Allow rails 6 to fail while master branch is used
+  allow_failures:
+  - rvm: 2.5
+    gemfile: gemfiles/rails_60.gemfile
 notifications:
  email: false
+
+# for 2.5.0 until 2.5.1 is released:
+#   https://github.com/travis-ci/travis-ci/issues/8978
+#   https://github.com/travis-ci/travis-ci/issues/8969#issuecomment-354135622
+before_install:
+  - gem update --system
+  - gem install bundler
--- a/26
+++ b/26
@@ -0,0 +1,26 @@
+appraise 'rails-60' do
+  git 'https://github.com/rails/rails.git' do
+    gem 'actionpack', '~> 6.0.0.alpha'
+    gem 'railties', '~> 6.0.0.alpha'
+  end
+end
+
+appraise 'rails-52' do
+  gem 'actionpack', '~> 5.2.0.beta2'
+  gem 'railties', '~> 5.2.0.beta2'
+end
+
+appraise 'rails-51' do
+  gem 'actionpack', '~> 5.1'
+  gem 'railties', '~> 5.1'
+end
+
+appraise 'rails-50' do
+  gem 'actionpack', '~> 5.0'
+  gem 'railties', '~> 5.0'
+end
+
+appraise 'rails-42' do
+  gem 'actionpack', '~> 4.2'
+  gem 'railties', '~> 4.2'
+end
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,60 @@
+# 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.
+
+# 0.12.3
+
+- New methods from Bot API v3.5
+- Collect all api helper-methods in Client::ApiHelper module.
+- Add `bin/fetch-telegram-methods` to update API methods list from website.
+
+# 0.12.1
+
+- Fix `set_webhook` rake task for async bots with self-issued certificates.
+- Make `#session` raise error when store is not configured,
+  don't use Rails.cache as fallback for session_store.
+- Allow use different sessions for MessageContext.
+
+# 0.12.0
+
+- New API methods and payload types (up to Bot API 3.2).
+- Fix rails 5.1.x support.
+- RSpec context for callback_query updates.
+- `edit_message` helper.
+- ClientStub saves and returns token. Fixes testing multiple bots.
+- Raise descriptive error when accessing not-configured bot.
+
+# 0.11.3
+
+- Release dependencies for Rails 5.1.
+
+# 0.11.2
+
+- Rails 5.1 deep symbolized secrets support.
+
+# 0.11.1
+
+- Fixed poller for typed response.
+
+# 0.11.0
+
+- Remove Bot::StaleChat in favor of Bot::Forbidden, as Telegram adds more
+  and more new descriptions.
+  Please open an issue if you face a problem.
+
 # 0.10.2

 - Support `(edited_)channel_post` updates.
--- a/16
+++ b/16
@@ -1,24 +1,20 @@
 source 'https://rubygems.org'
 gemspec

-case ENV['RAILS']
-when '5'
-  gem 'actionpack', '5.0.0.rc1'
-when '4'
-  gem 'actionpack', '~> 4.2'
-end
-
 group :development do
-  gem 'sdoc', '~> 0.4.1'
+  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.0'

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

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

  gem 'coveralls', '~> 0.8.2', require: false
 end
--- a/README.md
+++ b/README.md
@@ -4,16 +4,16 @@
 [![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)

-Tools for developing bot for Telegram. Best used with Rails, but can be be used in
-[standalone app](https://github.com/telegram-bot-rb/telegram-bot/wiki/Non-rails-application).
+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
 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. Allows to write separate methods for each command.
+- 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.
@@ -24,9 +24,11 @@ Here is sample [telegram_bot_app](https://github.com/telegram-bot-rb/telegram_bo
 with session, keyboards and inline queries.
 Run it on your local machine in 1 minute!

-And here is [app teamplate](https://github.com/telegram-bot-rb/rails_template)
+And here is [app template](https://github.com/telegram-bot-rb/rails_template)
 to generate clean app in seconds.

+Examples and cookbook in [wiki](https://github.com/telegram-bot-rb/telegram-bot/wiki).
+
 ## Installation

 Add this line to your application's Gemfile:
@@ -43,51 +45,70 @@ Or install it yourself as:

    $ gem install telegram-bot

+Require if necessary:
+
+```ruby
+require 'telegram/bot'
+```
+
 ## Usage

-### Configuration
+### Configuration in Rails app

 Add `telegram` section into `secrets.yml`:

 ```yml
-telegram:
-  bots:
-    # just set the token
-    chat: TOKEN_1
-    # or add username to support commands with mentions (/help@ChatBot)
-    auction:
-      token: TOKEN_2
-      username: ChatBot
+development:
+  telegram:
+    # Single bot can be specified like this
+    bot: TOKEN
+    # or
+    bot:
+      token: TOKEN
+      username: SomeBot

-  # Single bot can be specified like this
-  bot: TOKEN
-  # or
-  bot:
-    token: TOKEN
-    username: SomeBot
+    # For multiple bots in single app use hash of `internal_bot_id => settings`
+    bots:
+      # just set the bot token
+      chat: TOKEN_1
+      # or add username to support commands with mentions (/help@ChatBot)
+      auction:
+        token: TOKEN_2
+        username: ChatBot
 ```

-### Client
-
 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]`.

-You can create clients manually with `Telegram::Bot::Client.new(token, username)`.
+### Client
+
+Client is instantiated with `Telegram::Bot::Client.new(token, username)`.
 Username is optional and used only to parse commands with mentions.

 There is `request(path_suffix, body)` method to perform any query.
-And there are also shortcuts for available queries in underscored style
-(`answer_inline_query` instead of `answerInlineQuery`).
-All this methods just post given params to specific URL.
+And there are shortcuts for all available requests in underscored style
+(`answer_inline_query(params)` instead of `answerInlineQuery`).

 ```ruby
 bot.request(:getMe) or bot.get_me
 bot.request(:getupdates, offset: 1) or bot.get_updates(offset: 1)
-bot.send_message chat_id: chat_id, text: 'Test'
+bot.send_message(chat_id: chat_id, text: 'Test')
 ```

+There is no magic, they just pass params as is and set `path_suffix`.
+See [`Client`](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/client.rb)
+class for list of available methods. Please open PR or issue if it misses methods from
+new API versions.
+
+Any API request error will raise `Telegram::Bot::Error` with description in its message.
+Special `Telegram::Bot::Forbidden` is raised when bot can't post messages to the chat anymore.
+
+#### Typed responses
+
 By default client will return parsed json responses. You can enable
-response typecasting to virtus models using `telegram-bot-types` gem:
+response typecasting to virtus models using
+[`telegram-bot-types`](https://github.com/telegram-bot-rb/telegram-bot-types) gem:
+
 ```ruby
 # Add to your gemfile:
 gem 'telegram-bot-types', '~> x.x.x'
@@ -99,18 +120,26 @@ bot.extend Telegram::Bot::Client::TypedResponse
 bot.get_me.class # => Telegram::Bot::Types::User
 ```

-Any API request error will raise `Telegram::Bot::Error` with description in its message.
-Special `Telegram::Bot::StaleChat` is raised when bot can't post messages to the chat anymore.
-
 ### Controller

+Controller makes it easy to keep bot's code readable.
+It does nothing more than finding out action name for update and invoking it.
+So there is almost no overhead comparing to large `switch`, while you
+can represent actions as separate methods keeping source much more readable and supportable.
+
+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
  around_action :with_locale

  # Every update can have one of: message, inline_query, chosen_inline_result,
-  # callback_query.
+  # callback_query, etc.
  # Define method with same name to respond to this updates.
  def message(message)
    # message can be also accessed via instance method
@@ -160,6 +189,20 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 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:
+
+```ruby
+def respond_with(type, params); end
+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
+```
+
 #### Optional typecasting

 You can enable typecasting of `update` with `telegram-bot-types` by including
@@ -177,35 +220,56 @@ end

 #### Session

-There is support for sessions using `ActiveSupport::Cache` stores.
+This API is very close to ActiveController's session API, but works different
+under the hood. Cookies can not be used to store session id or
+whole session (like CookieStore does). So it uses key-value store and `session_key`
+method to build identifier from update.
+
+Store can be one of numerous `ActiveSupport::Cache` stores.
+While `:file_store` is suitable for development and single-server deployments
+without heavy load, it doesn't scale well. Key-value databases with persistance
+like Redis are more appropriate for production use.

 ```ruby
-# configure store in env files:
+# In rails app store can be configured in env files:
 config.telegram_updates_controller.session_store = :redis_store, {expires_in: 1.month}

+# In other app it can be done for all controllers with:
+Telegram::Bot::UpdatesController.session_store = :redis_store, {expires_in: 1.month}
+# or for specific one:
+OneOfUpdatesController.session_store = :redis_store, {expires_in: 1.month}
+```
+
+Default session id is made from bot's username and `(from || chat)['id']`.
+It means that session will be the same for updates from user in every chat,
+and different for every user in the same group chat.
+To change this behavior you can override `session_key` method, or even
+define [multiple sessions](https://github.com/telegram-bot-rb/telegram-bot/wiki/Multiple-session-objects)
+in single controller. For details see `Session` module.
+
+```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
  include Telegram::Bot::UpdatesController::Session
  # or just shortcut:
  use_session!

-  # You can override global config
+  # You can override global config for this controller.
  self.session_store = :file_store

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

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

  private
-  # By default it uses bot's username and user's id as a session key.
-  # Chat's id is used only when `from` field is empty.
-  # Override `session_key` method to change this behavior.
+
+  # In this case session will persist for user only in specific chat.
+  # Same user in other chat will have different session.
  def session_key
-    # In this case session will persist for user only in specific chat:
-    "#{bot.username}:#{chat['id']}:#{from['id']}"
+    "#{bot.username}:#{chat['id']}:#{from['id']}" if chat && from
  end
 end
 ```
@@ -245,77 +309,88 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
  # 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 use
+  # 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!
-  # It'll use context value as action name for all contexts which miss handlers.
 end
 ```

-You can use `CallbackQueryContext` in the similar way to split `#callback_query` into
-several specific methods. It doesn't require session support, and takes context from
-data. If data has a prefix with colon like this `my_ctx:smth...` it'll call
-`my_ctx_callback_query('smth...')` when there is such action method. Otherwise
-it'll call `callback_query('my_ctx:smth...')` as usual.
+#### Callback queries
+
+You can include `CallbackQueryContext` module to split `#callback_query` into
+several methods. It doesn't require session support, and takes context from
+data: if data has a prefix with colon like this `my_ctx:smth...` it invokes
+`my_ctx_callback_query('smth...')` when such action method is defined. Otherwise
+it invokes `callback_query('my_ctx:smth...')` as usual.
+Callback queries without prefix stay untouched.
+
+```ruby
+# This one handles `set_value:%{something}`.
+def set_value_callback_query(new_value = nil, *)
+  save_this(value)
+  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.")
+end
+```
+
+### Routes in Rails app
+
+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.
+
+```ruby
+# Most off apps would require
+telegram_webhook TelegramController
+# which is same as
+telegram_webhook TelegramController, :default
+
+# Use different controllers for each bot:
+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

-To process update run:
+To process update with controller call `.dispatch(bot, update)` on it.
+There are several options to run it automatically:
+
+- Use webhooks with routes helper (described above).
+- Use `Telegram::Bot::Middleware` with rack ([example in wiki](https://github.com/telegram-bot-rb/telegram-bot/wiki/Not-rails-application)).
+- 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
+with `:from` and/or `:chat` options instead of `update` object:

 ```ruby
-ControllerClass.dispatch(bot, update)
-```
-
-There is also ability to run action without update:
-
-```ruby
-# Most likely you'll want to pass :from and :chat
 controller = ControllerClass.new(bot, from: telegram_user, chat: telegram_chat)
-controller.process(:help, *args)
+controller.process(:welcome, *args)
 ```

-### Routes
-
-Use `telegram_webhooks` helper to add routes. It will create routes for bots
-at "telegram/#{bot.token}" path.
-
-```ruby
-# Create routes for all Telegram.bots to use same controller:
-telegram_webhooks TelegramController
-
-# Or pass custom bots usin any of supported config options:
-telegram_webhooks TelegramController,
-                 bot,
-                 {token: token, username: username},
-                 other_bot_token
-
-# Use different controllers for each bot:
-telegram_webhooks bot => TelegramChatController,
-                  other_bot => TelegramAuctionController
-
-# telegram_webhooks creates named routes.
-# Route name depends on `Telegram.bots`.
-# When there is single bot it will use 'telegram_webhook'.
-# When there are it will use bot's key in the `Telegram.bots` as prefix
-# (eg. `chat_telegram_webhook`).
-# 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
-```
-
-For Rack applications you can also use `Telegram::Bot::Middleware` or just
-call `.dispatch(bot, update)` on controller.
-
 ### Development & Debugging

-Use `rake telegram:bot:poller` to run poller. It'll automatically load
-changes without restart in development env. Optionally specify bot to run poller for
-with `BOT` envvar (`BOT=chat`).
+Use `rake telegram:bot:poller` to run poller in rails app. It automatically loads
+changes without restart in development env.
+Optionally pass bot id in `BOT` envvar (`BOT=chat`) to specify bot to run poller for.

-This task will not work if you don't use `telegram_webhooks`.
-You can run poller manually with
-`Telegram::Bot::UpdatesPoller.start(bot, controller_class)`.
+This task requires `telegram_webhook` helper to be used as it connects bots with controller.
+To run poller in other cases use:
+
+```ruby
+Telegram::Bot::UpdatesPoller.start(bot, controller_class)
+```

 ### Testing

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

 To stub all possible clients use `Telegram::Bot::ClientStub.stub_all!` before
-initializing clients. Most likely you'll want something like this:
+initializing clients. Here is template for RSpec:

 ```ruby
 # environments/test.rb
-# Make sure to run it before defining routes or storing bot to some place in app!
+# Make sure to run it before defining routes or accessing any bot in the app!
 Telegram.reset_bots
 Telegram::Bot::ClientStub.stub_all!

@@ -335,6 +410,8 @@ Telegram::Bot::ClientStub.stub_all!
 RSpec.configure do |config|
  # ...
  config.after { Telegram.bot.reset }
+  # or for multiple bots:
+  config.after { Telegram.bots.each_value(&:reset) }
  # ...
 end
 ```
@@ -353,6 +430,13 @@ RSpec.describe TelegramWebhooksController, :telegram_bot do
    subject { -> { dispatch_command :start } }
    it { should respond_with_message 'Hi there!' }
  end
+
+  # There is context for callback queries with related matchers.
+  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

 # For controller specs use
@@ -370,12 +454,17 @@ 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`.
+
 See sample app for more examples.

-### Deploying
+### Deployment

-Use `rake telegram:bot:set_webhook` to update webhook url for all configured bots.
-Certificate can be specified with `CERT=path/to/cert`.
+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

@@ -435,19 +524,18 @@ If you want async mode, but don't want to setup queue, know that Rails 5 are shi
 with Async adapter by default, and there is
 [Sucker Punch](https://github.com/brandonhilkert/sucker_punch) for Rails 4.

-Be aware of some limitations:
-
- Client will not return API response.
- Sending files is not available in async mode [now],
-  because them can not be serialized.
-
 To disable async mode for the block of code use `bot.async(false) { bot.send_photo }`.
 Yes, it's threadsafe too.

+#### Limitations
+
+- Client will not return API response.
+- Sending files is not available in async mode, because they can not be serialized.
+
 ## Development

-After checking out the repo, run `bin/setup` to install dependencies.
-Then, run `rake spec` to run the tests.
+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.

 To install this gem onto your local machine, run `bundle exec rake install`.
@@ -455,15 +543,7 @@ To release a new version, update the version number in `version.rb`,
 and then run `bundle exec rake release`, which will create a git tag for the version,
 push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

-### Different Rails versions
-
-To setup development for specific major Rails version use:
-
-```
-RAILS=5 bundle install
-# or
-RAILS=5 bundle update
-```
+Use `bin/fetch-telegram-methods` to update API methods list from Telegram website.

 ## Contributing

--- a/bin/fetch-telegram-methods
+++ b/bin/fetch-telegram-methods
@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+#
+# Fetch list of methods from Telegram docs.
+# Use it to update client.rb.
+
+require 'net/http'
+require 'nokogiri'
+
+DOCS_URL = 'https://core.telegram.org/bots/api'.freeze
+
+page_html = Net::HTTP.get(URI(DOCS_URL))
+doc = Nokogiri::HTML(page_html)
+
+# Select `h4`s, but use `h3`s to group them.
+headers = doc.css('h3, h4').
+  chunk_while { |_, x| x.name == 'h4' }.
+  map { |g| g.select { |x| x.name == 'h4' } }.
+  map { |g| g.map(&:text) }
+
+# Method starts with lowercase and does not have spaces.
+NOT_METHOD_REGEXP = /(\A[^a-z])|\s/
+
+# Filter method names.
+method_list = headers.
+  map { |g| g.reject { |x| x.match?(NOT_METHOD_REGEXP) } }.
+  reject(&:empty?)
+
+api_version = doc.text.match(/^(Bot API ([\d\.]+))\.?$/)
+
+result = ['# Generated with bin/fetch-telegram-methods']
+result << "# #{api_version[1]}" if api_version
+result << ''
+result << method_list.map { |g| g.join("\n") }.join("\n\n")
+result << ''
+result_txt = result.join("\n")
+
+puts result_txt
+
+API_METHODS_FILE = File.expand_path('../lib/telegram/bot/client/api_methods.txt', __dir__).freeze
+File.write(API_METHODS_FILE, result_txt)
+puts '', "Updated #{API_METHODS_FILE}"
--- a/bin/setup
+++ b/bin/setup
@@ -3,6 +3,7 @@ set -euo pipefail
 IFS=$'\n\t'

 bundle install
+appraisal install
 bin/install_git_hooks

 # Do any other automated setup that you need to do here
--- a/gemfiles/rails_42.gemfile
+++ b/gemfiles/rails_42.gemfile
@@ -0,0 +1,21 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "actionpack", "~> 4.2"
+gem "railties", "~> 4.2"
+
+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.0"
+  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_50.gemfile
+++ b/gemfiles/rails_50.gemfile
@@ -0,0 +1,21 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "actionpack", "~> 5.0"
+gem "railties", "~> 5.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.0"
+  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_51.gemfile
+++ b/gemfiles/rails_51.gemfile
@@ -0,0 +1,21 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "actionpack", "~> 5.1"
+gem "railties", "~> 5.1"
+
+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.0"
+  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_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.beta2"
+gem "railties", "~> 5.2.0.beta2"
+
+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.0"
+  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,23 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+git "https://github.com/rails/rails.git" do
+  gem "actionpack", "~> 6.0.0.alpha"
+  gem "railties", "~> 6.0.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.0"
+  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/tasks/telegram-bot.rake
+++ b/lib/tasks/telegram-bot.rake
@@ -21,7 +21,7 @@ namespace :telegram do
        route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
        url = routes.send("#{route_name}_url")
        puts "Setting webhook for #{key}..."
-        bot.set_webhook(url: url, certificate: cert)
+        bot.async(false) { bot.set_webhook(url: url, certificate: cert) }
      end
    end
  end
--- a/lib/telegram/bot.rb
+++ b/lib/telegram/bot.rb
@@ -5,25 +5,19 @@ module Telegram

  module Bot
    class Error < StandardError; 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

-    # Error class for events when chat is not available anymore for bot.
-    # While Telegram has same error codes for different messages and there is no
-    # official docs for this error codes it uses `description` to
-    # check response.
-    class StaleChat < Error
-      DESCRIPTIONS = [
-        'Bot was blocked',
-        'bot was kicked',
-        "can't write to",
-        'group chat is deactivated',
-      ].freeze
+    module_function

-      class << self
-        def match_response?(response)
-          description = response['description'].to_s
-          DESCRIPTIONS.any? { |x| description[x] }
-        end
+    def deprecation_0_14
+      @deprecation ||= begin
+        require 'active_support/deprecation'
+        ActiveSupport::Deprecation.new('0.14', 'Telegram::Bot')
      end
    end

--- a/lib/telegram/bot/botan.rb
+++ b/lib/telegram/bot/botan.rb
@@ -35,7 +35,7 @@ module Telegram
      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 300 > 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
--- a/lib/telegram/bot/client.rb
+++ b/lib/telegram/bot/client.rb
@@ -1,12 +1,10 @@
 require 'json'
 require 'httpclient'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/hash/keys'

 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
@@ -14,6 +12,9 @@ module Telegram
      prepend Botan::ClientHelpers
      include DebugClient

+      require 'telegram/bot/client/api_helper'
+      include ApiHelper
+
      class << self
        def by_id(id)
          Telegram.bots[id]
@@ -35,6 +36,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
@@ -43,65 +56,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 = {}) # rubocop:disable PerceivedComplexity
-        res = http_request("#{base_uri}#{action}", self.class.prepare_body(body))
-        status = res.status
-        return JSON.parse(res.body) if 300 > status
-        result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
-        err_msg = "#{res.reason}: #{result && result['description'] || '-'}"
-        if result
-          # NotFound is raised only for valid responses from Telegram
-          raise NotFound, err_msg if 404 == status
-          raise StaleChat, err_msg if StaleChat.match_response?(result)
-        end
-        raise Error, err_msg
-      end
-
-      # Splited to the sections similar to API docs.
-      %w(
-        deleteWebhook
-        getUpdates
-        getWebhookInfo
-        setWebhook
-
-        answerCallbackQuery
-        forwardMessage
-        getChat
-        getChatAdministrators
-        getChatMember
-        getChatMembersCount
-        getFile
-        getMe
-        getUserProfilePhotos
-        kickChatMember
-        leaveChat
-        sendAudio
-        sendChatAction
-        sendContact
-        sendDocument
-        sendLocation
-        sendMessage
-        sendPhoto
-        sendSticker
-        sendVenue
-        sendVideo
-        sendVoice
-        unbanChatMember
-
-        editMessageCaption
-        editMessageReplyMarkup
-        editMessageText
-
-        answerInlineQuery
-
-        getGameHighScores
-        sendGame
-        setGameScore
-      ).each do |method|
-        define_method(method.underscore) { |*args| request(method, *args) }
+      def request(action, body = {})
+        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_helper.rb
+++ b/lib/telegram/bot/client/api_helper.rb
@@ -0,0 +1,31 @@
+require 'active_support/core_ext/string/inflections'
+
+module Telegram
+  module Bot
+    class Client
+      module ApiHelper
+        METHODS_LIST_FILE = File.expand_path('../api_methods.txt', __FILE__)
+
+        class << self
+          def methods_list(file = METHODS_LIST_FILE)
+            File.read(file).lines.
+              map(&:strip).
+              reject { |x| x.empty? || x.start_with?('#') }
+          end
+
+          # Defines method with underscored name to post to specific endpoint:
+          #
+          #   define_method :getMe
+          #   # defines #get_me
+          def define_helpers(*list)
+            list.map(&:to_s).each do |method|
+              define_method(method.underscore) { |*args| request(method, *args) }
+            end
+          end
+        end
+
+        define_helpers(*methods_list)
+      end
+    end
+  end
+end
--- a/lib/telegram/bot/client/api_methods.txt
+++ b/lib/telegram/bot/client/api_methods.txt
@@ -0,0 +1,68 @@
+# Generated with bin/fetch-telegram-methods
+# Bot API 3.5.
+
+getUpdates
+setWebhook
+deleteWebhook
+getWebhookInfo
+
+getMe
+sendMessage
+forwardMessage
+sendPhoto
+sendAudio
+sendDocument
+sendVideo
+sendVoice
+sendVideoNote
+sendMediaGroup
+sendLocation
+editMessageLiveLocation
+stopMessageLiveLocation
+sendVenue
+sendContact
+sendChatAction
+getUserProfilePhotos
+getFile
+kickChatMember
+unbanChatMember
+restrictChatMember
+promoteChatMember
+exportChatInviteLink
+setChatPhoto
+deleteChatPhoto
+setChatTitle
+setChatDescription
+pinChatMessage
+unpinChatMessage
+leaveChat
+getChat
+getChatAdministrators
+getChatMembersCount
+getChatMember
+setChatStickerSet
+deleteChatStickerSet
+answerCallbackQuery
+
+editMessageText
+editMessageCaption
+editMessageReplyMarkup
+deleteMessage
+
+sendSticker
+getStickerSet
+uploadStickerFile
+createNewStickerSet
+addStickerToSet
+setStickerPositionInSet
+deleteStickerFromSet
+
+answerInlineQuery
+
+sendInvoice
+answerShippingQuery
+answerPreCheckoutQuery
+
+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/client_stub.rb
+++ b/lib/telegram/bot/client_stub.rb
@@ -35,6 +35,7 @@ module Telegram
      end

      def initialize(token = nil, username = nil, **options)
+        @token = token || options[:token]
        @username = username || options[:username] || token
        reset
      end
--- a/lib/telegram/bot/config_methods.rb
+++ b/lib/telegram/bot/config_methods.rb
@@ -1,5 +1,5 @@
 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
  module Bot
@@ -33,12 +33,16 @@ module Telegram

      # Default bot.
      def bot
-        @bot ||= bots[:default]
+        @bot ||= bots.fetch(:default) do
+          raise 'Default bot is not configured.' \
+            ' Add :default to bots_config' \
+            ' or use telegram.bot/telegram.bots.default section in secrets.yml.'
+        end
      end

      # Hash of botan clients made from #bots.
      def botans
-        @botans ||= bots.transform_values(&:botan)
+        @botans ||= bots.map { |k, v| [k, v.botan] }.to_h
      end

      # Returns config for .bots method. By default uses `telegram['bots']` section
@@ -48,9 +52,11 @@ module Telegram
      def bots_config
        @bots_config ||=
          if defined?(Rails.application)
-            telegram_config = Rails.application.secrets[:telegram] || {}
-            (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
-              default = telegram_config['bot']
+            app = Rails.application
+            store = app.respond_to?(:credentials) ? app.credentials : app.secrets
+            secrets = store.fetch(:telegram, {}).with_indifferent_access
+            secrets.fetch(:bots, {}).symbolize_keys.tap do |config|
+              default = secrets[:bot]
              config[:default] = default if default
            end
          else
--- a/lib/telegram/bot/initializers.rb
+++ b/lib/telegram/bot/initializers.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/keys'
+
 module Telegram
  module Bot
    module Initializers
--- a/lib/telegram/bot/railtie.rb
+++ b/lib/telegram/bot/railtie.rb
@@ -18,7 +18,7 @@ module Telegram

        ActiveSupport.on_load('telegram.bot.updates_controller') do
          self.logger = options.logger || Rails.logger
-          self.session_store = options.session_store || Rails.cache
+          self.session_store = options.session_store if options.session_store
        end
      end

--- a/lib/telegram/bot/routes_helper.rb
+++ b/lib/telegram/bot/routes_helper.rb
@@ -28,40 +28,49 @@ module Telegram
      #   telegram_webhooks TelegramController
      #
      #   # Or pass custom bots usin any of supported config options:
-      #   telegram_webhooks TelegramController,
-      #                     bot,
-      #                     {token: token, username: username},
-      #                     other_bot_token
-      #
-      #   # Use different controllers for each bot:
-      #   telegram_webhooks bot => TelegramChatController,
-      #                     other_bot => TelegramAuctionController
-      #
-      #   # 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
-      #
+      #   telegram_webhooks TelegramController, [
+      #     bot,
+      #     {token: token, username: username},
+      #     other_bot_token,
+      #   ]
      def telegram_webhooks(controllers, bots = nil, **options)
+        Bot.deprecation_0_14.deprecation_warning(:telegram_webhooks, <<-TXT.strip_heredoc)
+          It brings unnecessary complexity and encourages writeng less readable code.
+          Please use telegram_webhook method instead.
+          It's signature `telegram_webhook(controller, bot = :default, **options)`.
+          Multiple-bot environments now requires calling this method in a loop
+          or using statement for each bot.
+        TXT
        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?
+          telegram_webhook(controller, bot, options.merge(bot_options || {}))
        end
      end
+
+      # Define route which processes requests using given controller and bot.
+      #
+      #   telegram_webhook TelegramController, bot
+      #
+      #   telegram_webhook TelegramController
+      #   # same as:
+      #   telegram_webhook TelegramController, :default
+      #
+      #   # 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
 end
--- a/lib/telegram/bot/rspec/integration.rb
+++ b/lib/telegram/bot/rspec/integration.rb
@@ -1,8 +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(:default_message_options) { {from: {id: from_id}, chat: {id: chat_id}} }
  let(:controller_path) do
    route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
    Rails.application.routes.url_helpers.public_send("#{route_name}_path")
@@ -14,7 +16,7 @@ RSpec.shared_context 'telegram/bot/integration' do
    }
  end
  let(:clear_session?) { described_class.respond_to?(:session_store) }
-  before { described_class.session_store.clear if clear_session? }
+  before { described_class.session_store.try!(:clear) if clear_session? }

  include Telegram::Bot::RSpec::ClientMatchers

@@ -36,14 +38,48 @@ RSpec.shared_context 'telegram/bot/integration' do
  end

  # Matcher to check response. Make sure to define `let(:chat_id)`.
-  def respond_with_message(expected)
+  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
 end
--- a/lib/telegram/bot/updates_controller.rb
+++ b/lib/telegram/bot/updates_controller.rb
@@ -53,12 +53,19 @@ 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[
+        instrumentation
+        log_subscriber
+        reply_helpers
+        rescue
+        session
+      ].each { |file| require "telegram/bot/updates_controller/#{file}" }
+
+      %w[
+        CallbackQueryContext
+        MessageContext
+        TypedUpdate
+      ].each { |mod| autoload mod, "telegram/bot/updates_controller/#{mod.underscore}" }

      include AbstractController::Callbacks
      # Redefine callbacks with default terminator.
@@ -72,13 +79,13 @@ module Telegram
      end

      include AbstractController::Translation
+      include Rescue
      include ReplyHelpers
-      prepend Instrumentation
+      include Instrumentation
+
      extend Session::ConfigMethods

-      autoload :TypedUpdate, 'telegram/bot/updates_controller/typed_update'
-
-      PAYLOAD_TYPES = %w(
+      PAYLOAD_TYPES = %w[
        message
        edited_message
        channel_post
@@ -86,7 +93,9 @@ module Telegram
        inline_query
        chosen_inline_result
        callback_query
-      ).freeze
+        shipping_query
+        pre_checkout_query
+      ].freeze
      CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
      CONFLICT_CMD_REGEX = Regexp.new("^(#{PAYLOAD_TYPES.join('|')}|\\d)")

@@ -111,10 +120,17 @@ module Telegram
        # any commands.
        def command_from_text(text, username = nil)
          return unless text
-          match = text.match CMD_REGEX
+          match = text.match(CMD_REGEX)
          return unless match
-          return if match[3] && username != true && match[3] != username
-          [match[1], text.split.drop(1)]
+          mention = match[3]
+          [match[1], text.split.drop(1)] if username == true || !mention || mention == username
+        end
+
+        def payload_from_update(update)
+          update && PAYLOAD_TYPES.find do |type|
+            item = update[type]
+            return [item, type] if item
+          end
        end
      end

@@ -133,13 +149,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'`
@@ -147,7 +157,14 @@ 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
@@ -169,15 +186,21 @@ module Telegram
      # Returns array `[is_command?, action, args]`.
      def action_for_payload
        if payload_type
-          send("action_for_#{payload_type}") || [false, payload_type, [payload]]
+          send("action_for_#{payload_type}") || action_for_default_payload
        else
          [false, :unsupported_payload_type, []]
        end
      end

+      def action_for_default_payload
+        [false, 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)
@@ -185,12 +208,6 @@ module Telegram
      end
      alias_method :action_for_channel_post, :action_for_message

-      # It doesn't extract commands from edited messages. Just process
-      # them as usual ones.
-      def action_for_edited_message
-      end
-      alias_method :action_for_edited_channel_post, :action_for_edited_message
-
      def action_for_inline_query
        [false, payload_type, [payload['query'], payload['offset']]]
      end
@@ -208,6 +225,11 @@ module Telegram
      def action_missing(*)
      end

+      PAYLOAD_TYPES.each do |type|
+        method = :"action_for_#{type}"
+        alias_method method, :action_for_default_payload unless instance_methods.include?(method)
+      end
+
      ActiveSupport.run_load_hooks('telegram.bot.updates_controller', self)
    end
  end
--- a/lib/telegram/bot/updates_controller/callback_query_context.rb
+++ b/lib/telegram/bot/updates_controller/callback_query_context.rb
@@ -15,7 +15,6 @@ module Telegram
        # because `data` param is controlled by client.
        def action_for_callback_query
          context, new_data = context_from_callback_query
-          # binding.pry
          if context
            action_name = "#{context}_callback_query"
            [false, action_name, [new_data]] if action_method?(action_name)
--- 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",
@@ -39,7 +40,7 @@ module Telegram
          Instrumentation.instrument(:respond_with, type: type) { super }
        end

-        %i(answer_callback_query answer_inline_query).each do |type|
+        %i[answer_callback_query answer_inline_query].each do |type|
          define_method(type) do |*args|
            Instrumentation.instrument(:respond_with, type: type) { super(*args) }
          end
--- a/lib/telegram/bot/updates_controller/log_subscriber.rb
+++ b/lib/telegram/bot/updates_controller/log_subscriber.rb
@@ -17,7 +17,7 @@ module Telegram
            payload   = event.payload
            additions = UpdatesController.log_process_action(payload)
            message = "Completed in #{event.duration.round}ms"
-            message << " (#{additions.join(' | ')})" unless additions.blank?
+            message << " (#{additions.join(' | ')})" if additions.present?
            message
          end
        end
--- a/lib/telegram/bot/updates_controller/message_context.rb
+++ b/lib/telegram/bot/updates_controller/message_context.rb
@@ -7,14 +7,11 @@ module Telegram

        include Session

-        included do
-          # As we use before_action context is cleared anyway,
-          # no matter we used it or not.
-          singleton_class.send :attr_reader, :context_handlers, :context_to_action
-          @context_handlers = {}
-        end
-
        module ClassMethods
+          def context_handlers
+            @_context_handlers ||= {}
+          end
+
          # Registers handler for context.
          #
          #     context_handler :rename do |*|
@@ -39,6 +36,8 @@ module Telegram
            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
@@ -59,10 +58,16 @@ module Telegram
        # 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
+          session
+        end
+
        # Fetches context and finds handler for it. If message has new command,
        # it has higher priority than contextual action.
        def action_for_message
-          val = session.delete(:context)
+          val = message_context_session.delete(:context)
          @context = val && val.to_sym
          super || context && begin
            handler = handler_for_context
@@ -72,7 +77,7 @@ module Telegram

        # Save context for the next request.
        def save_context(context)
-          session[:context] = context
+          message_context_session[:context] = context
        end

        def handler_for_context
--- a/lib/telegram/bot/updates_controller/reply_helpers.rb
+++ b/lib/telegram/bot/updates_controller/reply_helpers.rb
@@ -38,6 +38,19 @@ module Telegram
          )
          bot.answer_callback_query(params)
        end
+
+        # Edit message from callback query.
+        def edit_message(type, params = {})
+          params =
+            if message_id = payload['inline_message_id'] # rubocop:disable AssignmentInCondition
+              params.merge(inline_message_id: message_id)
+            elsif message = payload['message'] # rubocop:disable AssignmentInCondition
+              params.merge(chat_id: message['chat']['id'], message_id: message['message_id'])
+            else
+              raise 'Can not edit message without `inline_message_id` or `message`'
+            end
+          bot.public_send("edit_message_#{type}", params)
+        end
      end
    end
  end
--- 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
@@ -35,7 +35,7 @@ RSpec.shared_context 'telegram/bot/updates_controller' do
  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
--- a/lib/telegram/bot/updates_controller/session.rb
+++ b/lib/telegram/bot/updates_controller/session.rb
@@ -8,19 +8,26 @@ module Telegram
      module Session
        extend ActiveSupport::Concern

+        module ClassMethods
+          # Builds session with given key and optional store (default to session_store).
+          # This way it's easier to define multiple custom sessions,
+          # ex. one for group chat and one for user.
+          def build_session(key, store = session_store)
+            raise 'session_store is not configured' unless store
+            key ? SessionHash.new(store, key) : NullSessionHash.new
+          end
+        end
+
        def process_action(*)
          super
        ensure
-          session.commit
+          session.commit if @_session
        end

        protected

        def session
-          @_session ||= begin
-            key = session_key
-            key ? SessionHash.new(self.class.session_store, key) : NullSessionHash.new
-          end
+          @_session ||= self.class.build_session(session_key)
        end

        def session_key
--- a/lib/telegram/bot/updates_controller/testing.rb
+++ b/lib/telegram/bot/updates_controller/testing.rb
@@ -2,7 +2,7 @@ module Telegram
  module Bot
    class UpdatesController
      module Testing
-        IVARS_TO_KEEP = %i(@_session).freeze
+        IVARS_TO_KEEP = %i[@_session].freeze

        # Perform multiple dispatches on same instance.
        def dispatch_again(bot = nil, update = nil)
--- a/lib/telegram/bot/updates_poller.rb
+++ b/lib/telegram/bot/updates_poller.rb
@@ -41,38 +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 => 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) }
-        return unless response['ok'] && response['result'].any?
+        response.is_a?(Array) ? response : response['result']
+      rescue Timeout::Error
+        log { 'Fetch timeout' }
+        nil
+      end
+
+      def process_updates(updates)
        reload! do
-          response['result'].each do |update|
+          updates.each do |update|
            @offset = update['update_id'] + 1
-            yield update
+            process_update(update)
          end
        end
-      rescue Timeout::Error # rubocop:disable HandleExceptions
+      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.10.2'.freeze
+    VERSION = '0.13.1'.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
@@ -0,0 +1,13 @@
+require 'integration_helper'
+
+RSpec.describe DefaultBotController, :telegram_bot, type: :request do
+  describe '#start' do
+    subject { -> { dispatch_command :start } }
+    it { should respond_with_message 'from default' }
+  end
+
+  describe '#load_session' do
+    subject { -> { dispatch_command :load_session } }
+    it { should_not raise_error }
+  end
+end
--- a/spec/integration/requests/named_bot_spec.rb
+++ b/spec/integration/requests/named_bot_spec.rb
@@ -0,0 +1,9 @@
+require 'integration_helper'
+
+RSpec.describe NamedBotController, :telegram_bot, type: :request do
+  let(:bot) { Telegram.bots[:named] }
+  describe '#start' do
+    subject { -> { dispatch_command :start } }
+    it { should respond_with_message 'from named' }
+  end
+end
--- a/spec/integration/requests/other_bot_spec.rb
+++ b/spec/integration/requests/other_bot_spec.rb
@@ -0,0 +1,14 @@
+require 'integration_helper'
+
+RSpec.describe OtherBotController, :telegram_bot, type: :request do
+  let(:bot) { Telegram.bots[:other] }
+  describe '#start' do
+    subject { -> { dispatch_command :start } }
+    it { should respond_with_message 'from other' }
+  end
+
+  describe '#load_session' do
+    subject { -> { dispatch_command :load_session } }
+    it { should raise_error(/session_store is not configured/) }
+  end
+end
--- a/spec/integration_helper.rb
+++ b/spec/integration_helper.rb
@@ -0,0 +1,83 @@
+require 'telegram/bot/rspec/integration'
+require 'action_controller'
+require 'action_dispatch'
+require 'action_dispatch/testing/integration'
+
+require 'rails'
+require 'telegram/bot/railtie'
+require 'rspec/rails/adapters'
+require 'rspec/rails/fixture_support'
+require 'rspec/rails/example/rails_example_group'
+require 'rspec/rails/example/request_example_group'
+
+ENV['RAILS_ENV'] = 'test'
+class TestApplication < Rails::Application
+  config.eager_load = false
+  config.log_level = :debug
+  config.action_dispatch.show_exceptions = false
+
+  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 |*|
+      respond_with :message, text: "from #{bot_name}"
+    end
+  end
+  Object.const_set("#{bot_name}_bot_controller".camelize, controller)
+end
+
+[DefaultBotController, OtherBotController].each do |klass|
+  klass.class_eval do
+    use_session!
+
+    define_method :load_session do |*|
+      session[:test]
+    end
+  end
+end
+
+DefaultBotController.session_store = :memory_store
+
+RSpec.configure do |config|
+  config.include RSpec::Rails::RequestExampleGroup, type: :request
+
+  config.around type: :request do |ex|
+    begin
+      Telegram.reset_bots
+      Telegram::Bot::ClientStub.stub_all!
+      ex.run
+    ensure
+      Telegram.reset_bots
+      Telegram::Bot::ClientStub.stub_all!(false)
+    end
+  end
+
+  config.before type: :request do
+    # Redefine routes before every example, so it does not depent on order.
+    Rails.application.routes.draw do
+      require 'telegram/bot/routes_helper'
+      extend Telegram::Bot::RoutesHelper
+
+      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,6 +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/json'

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

--- a/spec/telegram/bot/botan_spec.rb
+++ b/spec/telegram/bot/botan_spec.rb
@@ -3,7 +3,7 @@ RSpec.describe Telegram::Bot::Botan do
  let(:token) { 'token' }

  include_examples 'initializers', :botans
-  include_examples 'async', request_args: -> { [double(:method), double(:url)] }
+  it_behaves_like 'async', request_args: -> { [double(:method), double(:url)] }

  describe '.new' do
    subject { described_class.new(*args) }
--- 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
@@ -4,7 +4,7 @@ RSpec.describe Telegram::Bot::Client do
  let(:botan_token) { double(:botan_token) }

  include_examples 'initializers'
-  include_examples 'async', request_args: -> { [double(:action), {body: :content}] }
+  it_behaves_like 'async', request_args: -> { [double(:action), {body: :content}] }

  describe '.prepare_body' do
    subject { described_class.prepare_body(input) }
@@ -19,7 +19,7 @@ RSpec.describe Telegram::Bot::Client do

      it 'encodes nested hashes to json' do
        expected = input.dup
-        %i(c d e).each { |x| expected[x] = expected[x].to_json }
+        %i[c d e].each { |x| expected[x] = expected[x].to_json }
        should eq expected
      end
    end
@@ -35,7 +35,7 @@ RSpec.describe Telegram::Bot::Client do
    subject { described_class.new(*args) }

    context 'when multiple args are given' do
-      let(:args) { %w(secret superbot) }
+      let(:args) { %w[secret superbot] }
      its(:token) { should eq args[0] }
      its(:username) { should eq args[1] }
      its(:base_uri) { should include args[0] }
@@ -48,4 +48,49 @@ RSpec.describe Telegram::Bot::Client do
      its(:base_uri) { should include args[0][:token] }
    end
  end
+
+  describe '#request' do
+    subject { -> { instance.request(action, request_body) } }
+    let(:action) { :some_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 } }
+
+    let(:status) { 200 }
+    let(:body) { body_json.to_json }
+    let(:body_json) { {'param' => 'val', 'description' => 'some description'} }
+    before do
+      expect(described_class).to receive(:prepare_body).with(request_body) { prepared_body }
+      expect(instance).to receive(:http_request).with(url, prepared_body) { response }
+    end
+    around { |ex| Telegram::Bot::ClientStub.stub_all!(false) { ex.run } }
+
+    shared_examples 'invalid body' do |error = Telegram::Bot::Error|
+      context 'when body is not json' do
+        let(:body) { '{' }
+        it { should raise_error error }
+      end
+    end
+
+    its(:call) { should eq body_json }
+    include_examples 'invalid body', JSON::ParserError
+
+    context 'when status is 403' do
+      let(:status) { 403 }
+      it { should raise_error Telegram::Bot::Forbidden, body_json['description'] }
+      include_examples 'invalid body'
+    end
+
+    context 'when status is 404' do
+      let(:status) { 404 }
+      it { should raise_error Telegram::Bot::NotFound, body_json['description'] }
+      include_examples 'invalid body'
+    end
+
+    context 'when status is other' do
+      let(:status) { 500 }
+      it { should raise_error Telegram::Bot::Error, /#{body_json['description']}/ }
+    end
+  end
 end
--- a/spec/telegram/bot/client_stub_spec.rb
+++ b/spec/telegram/bot/client_stub_spec.rb
@@ -45,9 +45,15 @@ RSpec.describe Telegram::Bot::ClientStub do
    end

    context 'when username and token are given' do
-      let(:args) { %w(token superbot) }
-      its(:token) { should eq nil }
+      let(:args) { %w[token superbot] }
+      its(:token) { should eq args[0] }
      its(:username) { should eq args[1] }
    end
+
+    context 'when hash config is given' do
+      let(:args) { [token: 'token', username: 'superbot'] }
+      its(:token) { should eq args[0][:token] }
+      its(:username) { should eq args[0][:username] }
+    end
  end
 end
--- a/spec/telegram/bot/config_methods_spec.rb
+++ b/spec/telegram/bot/config_methods_spec.rb
@@ -22,8 +22,13 @@ RSpec.describe Telegram::Bot::ConfigMethods do
  end

  describe '#bot' do
-    subject { registry.bot }
-    it { should eq registry.bots[:default] }
+    subject { -> { registry.bot } }
+    its(:call) { should eq registry.bots[:default] }
+
+    context 'when bot is not configured' do
+      let(:config) { super().except(:default) }
+      it { should raise_error(/bot is not configured/) }
+    end
  end

  describe '#bots' do
@@ -67,6 +72,7 @@ RSpec.describe Telegram::Bot::ConfigMethods do

    context 'when not configured' do
      let(:registry) { Object.new.tap { |x| x.extend described_class } }
+      before { hide_const('Rails') }
      it { should eq({}) }

      context 'in rails environment' do
@@ -87,6 +93,12 @@ RSpec.describe Telegram::Bot::ConfigMethods do
          end
          it { should include default: config[:bot] }
          it { should include 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] }
+          end
        end
      end
    end
--- a/spec/telegram/bot/routes_helper_spec.rb
+++ b/spec/telegram/bot/routes_helper_spec.rb
@@ -40,6 +40,62 @@ RSpec.describe Telegram::Bot::RoutesHelper do
    end
  end

+  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(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
+
+    context 'when called with controller' do
+      let(:input) { [controller, 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 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',
+            option: :val,
+            path: 'telegram/some_token'
+        end
+      end
+    end
+
+    context 'when called with controller and smth castable to bot' do
+      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
+      end
+    end
+  end
+
  describe '#telegram_webhooks' do
    subject { mapper.telegram_webhooks(*input) }
    let(:mapper) { double(:mapper).tap { |x| x.extend described_class } }
@@ -47,6 +103,7 @@ RSpec.describe Telegram::Bot::RoutesHelper do
    let(:controller) { double(:controller, name: :controller) }
    let(:other_controller) { double(:other_controller, name: :other_controller) }
    before { allow(Telegram).to receive(:bots) { bots } }
+    around { |ex| Telegram::Bot.deprecation_0_14.silence { ex.run } }

    def assert_routes(*expected) # rubocop:disable AbcSize
      expected.each do |(bot, controller, route_name, options)|
--- a/spec/telegram/bot/rspec/integration_spec.rb
+++ b/spec/telegram/bot/rspec/integration_spec.rb
@@ -5,7 +5,8 @@ require 'action_dispatch/testing/integration'

 RSpec.describe 'Integrations helper', :telegram_bot do
  include ActionDispatch::Integration::Runner
-  def reset_template_assertion; end
+  def reset_template_assertion
+  end

  let(:app) do
    app = Telegram::Bot::Middleware.new(bot, controller)
@@ -38,7 +39,7 @@ RSpec.describe 'Integrations helper', :telegram_bot do

  describe '#dispatch_message' do
    subject { -> { dispatch_message "/start #{args.join ' '}", options } }
-    let(:args) { %w(asd qwe) }
+    let(:args) { %w[asd qwe] }
    let(:options) { {} }
    it { should respond_with_message "Start: #{args.inspect}, option: " }

@@ -59,7 +60,7 @@ RSpec.describe 'Integrations helper', :telegram_bot do
    it { should respond_with_message "Start: #{args.inspect}, option: " }

    context 'with args' do
-      let(:args) { %w(asd qwe) }
+      let(:args) { %w[asd qwe] }
      it { should respond_with_message "Start: #{args.inspect}, option: " }
    end

@@ -68,4 +69,44 @@ RSpec.describe 'Integrations helper', :telegram_bot do
      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/updates_controller/instrumentation_spec.rb
+++ b/spec/telegram/bot/updates_controller/instrumentation_spec.rb
@@ -0,0 +1,91 @@
+RSpec.describe Telegram::Bot::UpdatesController::Instrumentation do
+  include_context 'telegram/bot/updates_controller'
+
+  subject { -> { dispatch } }
+  let(:update) do
+    build_update :message, default_message_options.merge(text: '/start')
+  end
+
+  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: update)
+
+      action = action_name(:process_action)
+      expect(events[action].size).to eq(1)
+      expect(events[action][0].last).to include(update: 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
@@ -65,7 +65,7 @@ RSpec.describe Telegram::Bot::UpdatesController::MessageContext do

      context 'when message has new command' do
        let(:text) { '/action a s d' }
-        its(:call) { should eq [:action_result, *%w(a s d)] }
+        its(:call) { should eq [:action_result, 'a', 's', 'd'] }
        it { should change { session[:context] }.to nil }
      end
    end
--- a/spec/telegram/bot/updates_controller/reply_helpers_spec.rb
+++ b/spec/telegram/bot/updates_controller/reply_helpers_spec.rb
@@ -48,4 +48,32 @@ RSpec.describe Telegram::Bot::UpdatesController do
      end
    end
  end
+
+  describe '#edit_message' do
+    subject { controller.edit_message(type, params) }
+    let(:type) { :reply_markup }
+
+    it { expect { subject }.to raise_error(/Can not edit message without/) }
+
+    context 'when inline_message_id is present' do
+      let(:payload) { {inline_message_id: double(:message_id)} }
+      it 'sets inline_message_id' do
+        expect(bot).to receive("edit_message_#{type}").with(params.merge(
+          inline_message_id: payload[:inline_message_id],
+        )) { result }
+        should eq result
+      end
+    end
+
+    context 'when message is present' do
+      let(:payload) { {message: super().merge(chat: chat)} }
+      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'],
+        )) { result }
+        should eq result
+      end
+    end
+  end
 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
@@ -54,4 +54,45 @@ RSpec.describe Telegram::Bot::UpdatesController::Session do
      end
    end
  end
+
+  describe '.build_session' do
+    subject { controller_class.build_session(key, *args) }
+    let(:key) {}
+    let(:args) { [] }
+    it { expect { subject }.to raise_error(/session_store is not configured/) }
+
+    shared_examples 'NullSessionHash when key is not present' do |store_proc|
+      it { should be_instance_of(described_class::NullSessionHash) }
+
+      context 'and key is present' do
+        let(:key) { :test_key }
+        it 'is valid SessionHash' do
+          expect(subject).to be_instance_of(described_class::SessionHash)
+          expect(subject.id).to eq key
+          expect(subject.instance_variable_get(:@store)).to be(instance_exec(&store_proc))
+        end
+      end
+    end
+
+    context 'when store configured' do
+      before { controller_class.session_store = nil }
+      include_examples 'NullSessionHash when key is not present',
+        -> { controller_class.session_store }
+    end
+
+    context 'when store is given' do
+      let(:args) { [double(:store)] }
+      include_examples 'NullSessionHash when key is not present', -> { args[0] }
+    end
+  end
+
+  describe '.session_store=' do
+    subject { ->(val) { controller_class.session_store = val } }
+    it 'casts to AS::Cache' do
+      expect { subject[:null_store] }.to change(controller_class, :session_store).
+        to(instance_of(ActiveSupport::Cache::NullStore))
+      expect { subject[nil] }.to change(controller_class, :session_store).
+        to(instance_of(ActiveSupport::Cache::MemoryStore))
+    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
@@ -107,8 +107,8 @@ RSpec.describe Telegram::Bot::UpdatesController do
      it { should eq [false, :unsupported_payload_type, []] }
    end

-    %w(message channel_post).each do |type|
-      context 'when payload is edited_message' do
+    %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
@@ -123,11 +123,11 @@ RSpec.describe Telegram::Bot::UpdatesController do
        context 'with command' do
          let(:text) { "/test#{"@#{mention}" if mention} arg 1 2" }
          let(:mention) {}
-          it { should eq [true, 'test', %w(arg 1 2)] }
+          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)] }
+            it { should eq [true, 'test', %w[arg 1 2]] }
          end

          context 'with mention for other bot' do
@@ -142,16 +142,32 @@ RSpec.describe Telegram::Bot::UpdatesController do
        end
      end
    end
+
+    custom_payload_types = %w[
+      message
+      edited_message
+      channel_post
+      edited_channel_post
+      inline_query
+      chosen_inline_result
+      callback_query
+    ]
+    (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]] }
+      end
+    end
  end

  context 'when `update` is a virtus model' do
    subject { controller }
    let(:update) { Telegram::Bot::Types::Update.new(super()) }
-    %w(
+    %w[
      message
      inline_query
      chosen_inline_result
-    ).each do |type|
+    ].each do |type|
      context "with #{type}" do
        type_class = Telegram::Bot::Types.const_get(type.camelize)
        let(:payload_type) { type }
@@ -178,7 +194,7 @@ RSpec.describe Telegram::Bot::UpdatesController do

  describe '#process' do
    subject { -> { controller.process(:action, *args) } }
-    let(:args) { [:arg1, :arg2] }
+    let(:args) { %i[arg1 arg2] }
    let(:controller_class) do
      Class.new(described_class) do
        attr_reader :acted, :hooked
--- a/spec/telegram/bot/updates_poller_spec.rb
+++ b/spec/telegram/bot/updates_poller_spec.rb
@@ -1,9 +1,57 @@
 RSpec.describe Telegram::Bot::UpdatesPoller do
-  describe '#initialize' do
-    subject { described_class.new bot, controller }
-    let(:bot) { double }
-    let(:controller) { double }
+  let(:instance) { described_class.new(bot, controller) }
+  let(:bot) { Telegram::Bot::Client.new('token') }
+  let(:controller) { double(:controller) }

+  describe '#initialize' do
+    subject { instance }
    it { should be }
  end
+
+  describe '#process_updates' do
+    subject { -> { instance.process_updates(updates) } }
+    let(:block) { ->(x) { expect(x).to eq expected_results.shift } }
+    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
+        request_result
+      end
+    end
+
+    it { should eq updates.as_json }
+
+    context 'with typed response' do
+      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 eq updates.as_json }
+    end
+  end
 end
--- a/spec/telegram/bot_spec.rb
+++ b/spec/telegram/bot_spec.rb
@@ -2,25 +2,4 @@ RSpec.describe Telegram::Bot do
  it 'has a version number' do
    expect(described_class::VERSION).not_to be nil
  end
-
-  describe described_class::StaleChat do
-    describe '.match_response?' do
-      subject { ->(val) { described_class.match_response?(val) } }
-
-      it 'returns true for specific errors' do
-        expect(subject.call({})).to eq false
-        expect(subject.call('description' => 'test')).to eq false
-        expect(subject.call('description' => 'Error: bot was kicked from')).to eq true
-        expect(subject.call(
-          'description' => "Forbidden: can't write to private chat with deleted user"
-        )).to eq true
-        expect(subject.call(
-          'description' => 'Bad request: group chat is deactivated'
-        )).to eq true
-        expect(subject.call(
-          'description' => 'Forbidden: Bot was blocked by the user'
-        )).to eq true
-      end
-    end
-  end
 end
--- a/telegram-bot.gemspec
+++ b/telegram-bot.gemspec
@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'telegram/bot/version'
@@ -20,9 +19,10 @@ Gem::Specification.new do |spec|

  spec.required_ruby_version = '~> 2.0'

-  spec.add_dependency 'activesupport', '>= 4.0', '< 5.1'
-  spec.add_dependency 'actionpack', '>= 4.0', '< 5.1'
+  spec.add_dependency 'actionpack', '>= 4.0', '< 6.0'
+  spec.add_dependency 'activesupport', '>= 4.0', '< 6.0'
  spec.add_dependency 'httpclient', '~> 2.7'
-  spec.add_development_dependency 'bundler', '~> 1.11'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
  spec.add_development_dependency 'rake', '~> 10.0'
 end
Автор	SHA1	Сообщение	Дата
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
Max Melentiev	384d203b59	Fix spec helpers for callback queries	2017-12-04 09:47:17 +03:00
Max Melentiev	9e396cabc4	New methods from bot api v3.5 Collect all api helper-methods in Client::ApiHelper module. Add bin/fetch-telegram-methods to update methods list from website.	2017-11-24 11:08:12 +03:00
Max Melentiev	81c18034a5	Add some new files after `appraisal install`	2017-11-24 11:04:38 +03:00
printercu	f332d27ec8	Update README.md	2017-11-18 11:27:24 +03:00
printercu	fa9b01d9d2	Merge pull request #49 from telegram-bot-rb/update_rubocop Update rubocop	2017-11-17 09:59:43 +03:00
Max Melentiev	e06882f7af	Release rails dependencies	2017-11-17 09:53:10 +03:00
Max Melentiev	1a30b430df	Update rubocop, add appraisal gem	2017-11-17 09:46:49 +03:00
Max Melentiev	da93abaaf7	v0.12.1	2017-10-06 11:23:56 +03:00
printercu	0ae17fb34e	Merge pull request #45 from telegram-bot-rb/update_sessions Update sessions	2017-10-06 11:19:01 +03:00
Max Melentiev	7e41bd4f9b	Allow use different sessions for MessageContext	2017-10-06 11:10:05 +03:00
Max Melentiev	e529a79339	Don't use Rails.cache as fallback for session_store It's NullStore in development by default so session does not work, and indeed should not be dependent.	2017-10-06 11:07:11 +03:00
Max Melentiev	ef4f3caa5f	Make #session raise error when store is not configured Add more explanation on sessions in readme	2017-10-06 11:05:25 +03:00
Max Melentiev	df7039326d	Run set_webhook task always in sync way Fixes telegram-bot-rb/telegram_bot_app#7	2017-10-05 22:11:22 +03:00
Max Melentiev	4f47506e22	Fix typo in readme	2017-08-11 15:10:05 +03:00
Max Melentiev	6abbe5489d	v0.12.0	2017-08-11 15:04:41 +03:00
Max Melentiev	ff7de976d0	Add specs for #edit_message	2017-08-11 15:04:19 +03:00
Max Melentiev	aaba27eb70	New API methods and payload types (up to Bot API 3.2)	2017-08-11 15:04:02 +03:00
printercu	88a4a9aab3	Merge pull request #37 from zuf/master update rails dependency (<5.2 instead <=5.1)	2017-08-11 13:43:13 +03:00
Egor	9387043ec1	fix rails dependency (<5.2 instead <=5.1)	2017-08-10 18:07:21 +03:00
Max Melentiev	3dca35ba9a	callback_query context for RSpec	2017-07-25 10:58:18 +03:00
Max Melentiev	6879618c00	edit_message helper	2017-07-25 10:49:39 +03:00
Max Melentiev	6e4a69b6b1	Fix storing token in ClientStub when config hash is given	2017-05-17 17:45:21 +06:00
printercu	b8db576452	Merge pull request #31 from telegram-bot-rb/integration_test Integration test with rails app and two bots	2017-05-15 22:20:26 +06:00
Max Melentiev	2fffdeb475	Integration test with rails app and two bots	2017-05-15 22:11:52 +06:00
Max Melentiev	9defa42f40	Add notes on testing multiple bots to readme Fixes #29	2017-05-11 14:01:42 +06:00
Max Melentiev	0320507abe	Telegram.bot raises error when there is no default config	2017-05-11 13:57:29 +06:00
Max Melentiev	cd3d3739a4	v0.11.3	2017-05-05 17:30:49 +06:00
Max Melentiev	a054ac704c	Build with rails 5.1 on travis	2017-05-05 17:28:59 +06:00
printercu	23aa92e614	Merge pull request #28 from ironbrains/master Increase dependencies version	2017-05-05 17:19:05 +06:00
Bulat F	a49dca66fa	Increase dependencies version - Add support `activesupport 5.1` - Add support `actionpack 5.1`	2017-05-05 10:16:30 +03:00
Max Melentiev	2d5ca981ce	Rails 5.1 deep symbolized secrets support Fixes #26	2017-04-22 12:02:59 +03:00
Max Melentiev	cf9bd87cf2	Add notice about how to require gem to Readme Fixes #24	2017-03-11 21:33:20 +03:00
Max Melentiev	48ff7a4f43	Fix poller for typed responses Fixes: #22	2017-03-05 17:56:32 +03:00
Max Melentiev	17260cb5a9	v0.11.0	2017-02-10 09:34:15 +03:00
Max Melentiev	817af95369	Remove Bot::StaleChat in favor of Bot::Forbidden	2017-02-10 09:33:41 +03:00