v0.13.0

Setup codeclimate integration

.codeclimate.yml

@@ -0,0 +1,8 @@
+checks:
+  method-complexity:
+    config:
+      threshold: 6 # should be just fine
+
+plugins:
+  rubocop:
+    enabled: true

.gitignore

@@ -1,6 +1,8 @@
 /.bundle/
 /.yardoc
 /Gemfile.lock
+/gemfiles/*.lock
+/gemfiles/.bundle
 /_yardoc/
 /coverage/
 /doc/

.rubocop.yml

@@ -1,30 +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/MultilineMethodCallIndentation: {EnforcedStyle: indented}
-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}

.travis.yml

@@ -1,10 +1,17 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.2.3
-env:
-  - RAILS=4
-  - RAILS=5
-  - RAILS=5_1
+  - 2.5
+  - 2.4
+  - 2.3
+gemfile:
+  - gemfiles/rails_52.gemfile
+  - gemfiles/rails_51.gemfile
+  - gemfiles/rails_50.gemfile
+  - gemfiles/rails_42.gemfile
 notifications:
   email: false
+
+# for 2.5.0 until 2.5.1 is released: https://github.com/travis-ci/travis-ci/issues/8978
+before_install:
+  - gem update --system

Appraisals

@@ -0,0 +1,19 @@
+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

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Unreleased
 
+# 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.

Gemfile

@@ -2,24 +2,11 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
-  case ENV['RAILS']
-  when '5_1'
-    gem 'railties', '5.1.0'
-    gem 'actionpack', '5.1.0'
-  when '5'
-    gem 'railties', '5.0.2'
-    gem 'actionpack', '5.0.2'
-  when '4'
-    gem 'railties', '~> 4.2'
-    gem 'actionpack', '~> 4.2'
-  else
-    gem 'railties'
-    gem 'actionpack'
-  end
+  gem 'appraisal', '~> 2.2'
 
-  gem 'sdoc', '~> 0.4.1'
   gem 'pry', '~> 0.10.1'
   gem 'pry-byebug', '~> 3.2.0'
+  gem 'sdoc', '~> 0.4.1'
 
   gem 'telegram-bot-types', '~> 0.3.0'
 
@@ -27,7 +14,7 @@ group :development do
   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

README.md

@@ -4,8 +4,8 @@
 [![Code Climate](https://codeclimate.com/github/telegram-bot-rb/telegram-bot/badges/gpa.svg)](https://codeclimate.com/github/telegram-bot-rb/telegram-bot)
 [![Build Status](https://travis-ci.org/telegram-bot-rb/telegram-bot.svg)](https://travis-ci.org/telegram-bot-rb/telegram-bot)
 
-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.
 
@@ -13,7 +13,7 @@ Package contains:
 
 - Ligthweight 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.
@@ -53,49 +53,62 @@ 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'
@@ -107,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::Forbidden` 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
@@ -171,7 +192,7 @@ end
 #### Reply helpers
 
 There are helpers to respond for basic actions. They just set chat/message/query
-identifiers from update. See `ReplyHelpers` method for more information.
+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
@@ -223,7 +244,8 @@ 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 in single controller. For details see `Session` module.
+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
@@ -231,14 +253,14 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   # 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
 
@@ -249,11 +271,6 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   def session_key
     "#{bot.username}:#{chat['id']}:#{from['id']}" if chat && from
   end
-
-  # This session will be the same for all updates in chat.
-  def chat_session
-    @_chat_session ||= self.class.build_session(chat && "#{bot.username}:#{chat['id']}")
-  end
 end
 ```
 
@@ -292,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
 
@@ -370,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!
 
@@ -432,10 +460,11 @@ 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
 
@@ -495,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`.
@@ -515,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
 

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}"

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

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.3.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: "../"

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.3.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: "../"

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.3.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: "../"

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.3.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: "../"

lib/telegram/bot.rb

@@ -5,9 +5,22 @@ module Telegram
 
   module Bot
     class Error < StandardError; end
-    class NotFound < Error; end
+
+    # Raised for valid telegram response with 403 status code.
     class Forbidden < Error; end
 
+    # Raised for valid telegram response with 404 status code.
+    class NotFound < Error; end
+
+    module_function
+
+    def deprecation_0_14
+      @deprecation ||= begin
+        require 'active_support/deprecation'
+        ActiveSupport::Deprecation.new('0.14', 'Telegram::Bot')
+      end
+    end
+
     autoload :Async,              'telegram/bot/async'
     autoload :Botan,              'telegram/bot/botan'
     autoload :Client,             'telegram/bot/client'

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

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 # rubocop:disable ClassLength
-      URL_TEMPLATE = 'https://api.telegram.org/bot%s/'.freeze
+    class Client
+      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,89 +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 = {})
-        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 = result && result['description'] || '-'
-        if result
-          # This errors are raised only for valid responses from Telegram
-          case status
-          when 403 then raise Forbidden, err_msg
-          when 404 then raise NotFound, err_msg
-          end
-        end
-        raise Error, "#{res.reason}: #{err_msg}"
-      end
-
-      # Splited to the sections similar to API docs.
-      %w(
-        deleteWebhook
-        getUpdates
-        getWebhookInfo
-        setWebhook
-
-        answerCallbackQuery
-        deleteChatPhoto
-        exportChatInviteLink
-        forwardMessage
-        getChat
-        getChatAdministrators
-        getChatMember
-        getChatMembersCount
-        getFile
-        getMe
-        getUserProfilePhotos
-        kickChatMember
-        leaveChat
-        pinChatMessage
-        promoteChatMember
-        restrictChatMember
-        sendAudio
-        sendChatAction
-        sendContact
-        sendDocument
-        sendLocation
-        sendMessage
-        sendPhoto
-        sendVenue
-        sendVideo
-        sendVideoNote
-        sendVoice
-        setChatDescription
-        setChatPhoto
-        setChatTitle
-        unbanChatMember
-        unpinChatMessage
-
-        deleteMessage
-        editMessageCaption
-        editMessageReplyMarkup
-        editMessageText
-
-        sendSticker
-        getStickerSet
-        uploadStickerFile
-        createNewStickerSet
-        addStickerToSet
-        setStickerPositionInSet
-        deleteStickerFromSet
-
-        answerInlineQuery
-
-        sendInvoice
-        answerShippingQuery
-        answerPreCheckoutQuery
-
-        getGameHighScores
-        sendGame
-        setGameScore
-      ).each do |method|
-        define_method(method.underscore) { |*args| request(method, *args) }
+        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.

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

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

lib/telegram/bot/config_methods.rb

@@ -53,8 +53,9 @@ module Telegram
       def bots_config
         @bots_config ||=
           if defined?(Rails.application)
-            secrets = Rails.application.secrets.
-              fetch(:telegram, {}).with_indifferent_access
+            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

lib/telegram/bot/initializers.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/keys'
+
 module Telegram
   module Bot
     module Initializers

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

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")

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
@@ -88,7 +95,7 @@ module Telegram
         callback_query
         shipping_query
         pre_checkout_query
-      ).freeze
+      ].freeze
       CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
       CONFLICT_CMD_REGEX = Regexp.new("^(#{PAYLOAD_TYPES.join('|')}|\\d)")
 
@@ -113,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
 
@@ -135,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'`

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

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

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

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)

lib/telegram/bot/updates_poller.rb

@@ -41,40 +41,54 @@ module Telegram
 
       def start
         return if running
-        @running = true
-        log { 'Started bot poller.' }
-        while running
-          begin
-            fetch_updates do |update|
-              controller.dispatch(bot, update)
-            end
-          rescue Interrupt
-            @running = false
-          rescue => e
-            logger.error { ([e.message] + e.backtrace).join("\n") } if logger
-          end
+        begin
+          @running = true
+          log { 'Started bot poller.' }
+          run
+        rescue Interrupt
+          nil # noop
+        ensure
+          @running = false
         end
-        log { 'Stop polling bot updates.' }
+        log { 'Stoped polling bot updates.' }
       end
 
+      def run
+        while running
+          updates = fetch_updates
+          process_updates(updates) if updates && updates.any?
+        end
+      end
+
+      # Method to stop poller from other thread.
       def stop
         return unless running
-        log { 'Killing polling thread.' }
+        log { 'Stopping polling bot updates.' }
         @running = false
       end
 
-      def fetch_updates
+      def fetch_updates(offset = self.offset)
         response = bot.async(false) { bot.get_updates(offset: offset, timeout: timeout) }
-        updates = response.is_a?(Array) ? response : response['result']
-        return unless updates && updates.any?
+        response.is_a?(Array) ? response : response['result']
+      rescue Timeout::Error
+        log { 'Fetch timeout' }
+        nil
+      end
+
+      def process_updates(updates)
         reload! do
           updates.each do |update|
             @offset = update['update_id'] + 1
-            yield update
+            process_update(update)
           end
         end
-      rescue Timeout::Error
-        log { 'Fetch timeout' }
+      rescue StandardError => e
+        logger.error { ([e.message] + e.backtrace).join("\n") } if logger
+      end
+
+      # Override this method to setup custom error collector.
+      def process_update(update)
+        controller.dispatch(bot, update)
       end
 
       def reload!

lib/telegram/bot/version.rb

@@ -1,6 +1,6 @@
 module Telegram
   module Bot
-    VERSION = '0.12.1'.freeze
+    VERSION = '0.13.0'.freeze
 
     def self.gem_version
       Gem::Version.new VERSION

spec/integration_helper.rb

@@ -15,19 +15,26 @@ class TestApplication < Rails::Application
   config.eager_load = false
   config.log_level = :debug
   config.action_dispatch.show_exceptions = false
-  secrets[:secret_key_base] = 'test'
-  secrets[:telegram] = {
+
+  telegram_config = {
     bot: 'default_token',
     bots: {
       other: {token: 'other_token'},
       named: {token: 'named_token', username: 'TestBot'},
     },
   }
+
+  if respond_to?(:credentials)
+    credentials.config[:telegram] = telegram_config
+  else
+    secrets[:secret_key_base] = 'test'
+    secrets[:telegram] = telegram_config
+  end
 end
 Rails.application.initialize!
 
 # # Controllers
-%w(default other named).each do |bot_name|
+%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}"
@@ -68,9 +75,9 @@ RSpec.configure do |config|
       require 'telegram/bot/routes_helper'
       extend Telegram::Bot::RoutesHelper
 
-      telegram_webhooks default: DefaultBotController,
-                        other: OtherBotController,
-                        named: NamedBotController
+      telegram_webhook DefaultBotController, :default
+      telegram_webhook OtherBotController, :other
+      telegram_webhook NamedBotController, :named
     end
   end
 end

spec/spec_helper.rb

@@ -16,7 +16,7 @@ $LOAD_PATH.unshift GEM_ROOT.join('lib')
 require 'telegram/bot'
 require 'telegram/bot/updates_controller/rspec_helpers'
 require 'telegram/bot/types'
-require 'active_support/core_ext/object/json'
+require 'active_support/json'
 
 Dir[GEM_ROOT.join('spec/support/**/*.rb')].each { |f| require f }
 

spec/telegram/bot/client_spec.rb

@@ -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] }
@@ -52,7 +52,7 @@ RSpec.describe Telegram::Bot::Client do
   describe '#request' do
     subject { -> { instance.request(action, request_body) } }
     let(:action) { :some_action }
-    let(:url) { "#{format described_class::URL_TEMPLATE, token}#{action}" }
+    let(:url) { "#{format(described_class::URL_TEMPLATE, token: token)}#{action}" }
     let(:request_body) { double(:body) }
     let(:prepared_body) { double(:prepared_body) }
     let(:response) { HTTP::Message.new_response(body).tap { |x| x.status = status } }

spec/telegram/bot/client_stub_spec.rb

@@ -45,7 +45,7 @@ RSpec.describe Telegram::Bot::ClientStub do
     end
 
     context 'when username and token are given' do
-      let(:args) { %w(token superbot) }
+      let(:args) { %w[token superbot] }
       its(:token) { should eq args[0] }
       its(:username) { should eq args[1] }
     end

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)|

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

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

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

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

spec/telegram/bot/updates_controller/typed_update_spec.rb

@@ -9,11 +9,11 @@ RSpec.describe Telegram::Bot::UpdatesController::TypedUpdate do
 
   context 'when `update` is a virtus model' do
     subject { controller }
-    %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 }

spec/telegram/bot/updates_controller_spec.rb

@@ -107,7 +107,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
       it { should eq [false, :unsupported_payload_type, []] }
     end
 
-    %w(message channel_post).each do |type|
+    %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]] }
@@ -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
@@ -143,7 +143,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
       end
     end
 
-    custom_payload_types = %w(
+    custom_payload_types = %w[
       message
       edited_message
       channel_post
@@ -151,7 +151,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
       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 }
@@ -163,11 +163,11 @@ RSpec.describe Telegram::Bot::UpdatesController do
   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 }
@@ -194,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

spec/telegram/bot/updates_poller_spec.rb

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

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.2'
-  spec.add_dependency 'actionpack', '>= 4.0', '< 5.2'
+  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