v0.15.0

Update to Bot API 5.0

.rubocop.yml

@@ -40,6 +40,7 @@ Style/IfUnlessModifier: {Enabled: false}
 # Consistent to other definitions.
 Style/EmptyMethod: {EnforcedStyle: expanded}
 
+Style/Lambda: {EnforcedStyle: literal}
 Style/ModuleFunction: {Enabled: false}
 Style/NestedParenthesizedCalls: {Enabled: false}
 Style/SignalException: {EnforcedStyle: only_raise}

.travis.yml

@@ -1,34 +1,31 @@
 language: ruby
 cache: bundler
 rvm:
+- 2.6
 - 2.5
-- 2.4
 gemfile:
+- gemfiles/rails_60.gemfile
 - gemfiles/rails_52.gemfile
-- gemfiles/rails_51.gemfile
 matrix:
   include:
   # old rails
+  - rvm: 2.5
+    gemfile: gemfiles/rails_51.gemfile
   - rvm: 2.5
     gemfile: gemfiles/rails_50.gemfile
   - rvm: 2.5
     gemfile: gemfiles/rails_42.gemfile
   # old rubies
+  - rvm: 2.4
+    gemfile: gemfiles/rails_52.gemfile
   - rvm: 2.3
     gemfile: gemfiles/rails_52.gemfile
   # future rails
   - rvm: 2.5
-    gemfile: gemfiles/rails_60.gemfile
+    gemfile: gemfiles/rails_61.gemfile
-  # Allow rails 6 to fail while master branch is used
+  # Allow rails 6.1 to fail while master branch is used
   allow_failures:
   - rvm: 2.5
-    gemfile: gemfiles/rails_60.gemfile
+    gemfile: gemfiles/rails_61.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

Appraisals

@@ -1,26 +1,31 @@
-appraise 'rails-60' do
+appraise 'rails-61' do
   git 'https://github.com/rails/rails.git' do
-    gem 'actionpack', '~> 6.0.0.alpha'
+    gem 'actionpack', '~> 6.1.0.alpha'
-    gem 'railties', '~> 6.0.0.alpha'
+    gem 'railties', '~> 6.1.0.alpha'
   end
 end
 
+appraise 'rails-60' do
+  gem 'actionpack', '~> 6.0.0'
+  gem 'railties', '~> 6.0.0'
+end
+
 appraise 'rails-52' do
-  gem 'actionpack', '~> 5.2.0.beta2'
+  gem 'actionpack', '~> 5.2.0'
-  gem 'railties', '~> 5.2.0.beta2'
+  gem 'railties', '~> 5.2.0'
 end
 
 appraise 'rails-51' do
-  gem 'actionpack', '~> 5.1'
+  gem 'actionpack', '~> 5.1.0'
-  gem 'railties', '~> 5.1'
+  gem 'railties', '~> 5.1.0'
 end
 
 appraise 'rails-50' do
-  gem 'actionpack', '~> 5.0'
+  gem 'actionpack', '~> 5.0.0'
-  gem 'railties', '~> 5.0'
+  gem 'railties', '~> 5.0.0'
 end
 
 appraise 'rails-42' do
-  gem 'actionpack', '~> 4.2'
+  gem 'actionpack', '~> 4.2.0'
-  gem 'railties', '~> 4.2'
+  gem 'railties', '~> 4.2.0'
 end

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Unreleased
 
+# 0.15.0
+
+- Add `:path` option to `telegram_webhook` route helper.
+- __Breaking change!__ Default route is generated using hashed bot token.
+  Please reconfigure webhook after update (`rake telegram:bot:set_webhook`).
+- Update to Bot API 5.0, add rake tasks for `deleteWebhook`, `close` & `logOut`.
+- Add `server` option for client to support local bot API servers.
+
+# 0.14.4
+
+- Update to Bot API 4.7
+
+# 0.14.3
+
+- Rails 6.0 support.
+- Update to Bot API 4.4.
+
+# 0.14.2
+
+- Add reply helpers: `answer_pre_checkout_query`, `answer_shipping_query`.
+- Update to Bot API 4.3.
+
+# 0.14.1
+
+- Read config from secrets when credentials don't provide it in rails >= 5.2.
+- Remove botan.io support. It's already shut down, so it should not be a braking change.
+  https://github.com/botanio/sdk#this-service-will-be-shut-down-on-25th-may-2018
+- Update to Bot API 4.1.
+
 # 0.14.0
 
 - Make integration & controller specs consistent.

Gemfile

@@ -8,7 +8,7 @@ group :development do
   gem 'pry-byebug', '~> 3.2.0'
   gem 'sdoc', '~> 0.4.1'
 
-  gem 'telegram-bot-types', '~> 0.6.0'
+  gem 'telegram-bot-types', '~> 0.6.2'
 
   gem 'rspec', '~> 3.5.0'
   gem 'rspec-its', '~> 1.1.0'

README.md

@@ -4,8 +4,6 @@
 [![Code Climate](https://codeclimate.com/github/telegram-bot-rb/telegram-bot/badges/gpa.svg)](https://codeclimate.com/github/telegram-bot-rb/telegram-bot)
 [![Build Status](https://travis-ci.org/telegram-bot-rb/telegram-bot.svg)](https://travis-ci.org/telegram-bot-rb/telegram-bot)
 
-__Breaking changes in v0.14!__ See [upgrading guide](https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14).
-
 Tools for developing Telegram bots. Best used with Rails, but can be used in
 [standalone app](https://github.com/telegram-bot-rb/telegram-bot/wiki/Not-rails-application).
 Supposed to be used in webhook-mode in production, and poller-mode
@@ -19,7 +17,7 @@ Package contains:
 - Middleware and routes helpers for production env.
 - Poller with automatic source-reloader for development env.
 - Rake tasks to update webhook urls.
-- __[Async mode](#async-mode)__ for Telegram and/or Botan API.
+- __[Async mode](#async-mode)__.
   Let the queue adapter handle network errors!
 
 Here is sample [telegram_bot_app](https://github.com/telegram-bot-rb/telegram_bot_app)
@@ -55,9 +53,32 @@ require 'telegram/bot'
 
 ## Usage
 
+### Configuration
+
+While clients can be instantiated explicitly, there is `Telegram.bots_config=` method
+to configure app-wide clients, which are accessible via `Telegram.bots`.
+It accepts hash of `{bot_id: bot_config}`, and there is special id `:default`
+which is used for `Telegram.bot`.
+
+```ruby
+Telegram.bots_config = {
+  default: DEFAULT_BOT_TOKEN,
+  chat: {
+    token: CHAT_BOT_TOKEN,
+    username: 'ChatBot', # to support commands with mentions (/help@ChatBot)
+    server: 'http://local.bot.api.server', # for Local Bot API Server
+  },
+}
+
+Telegram.bot.get_updates
+Telegram.bot == Telegram.bots[:default] # true
+Telegram.bots[:chat].send_message(...)
+```
+
 ### Configuration in Rails app
 
-Add `telegram` section into `secrets.yml`:
+In Rails app `Telegram.bots_config` is read from `secrets.yml` automatically
+from `telegram` section:
 
 ```yml
 development:
@@ -68,6 +89,7 @@ development:
     bot:
       token: TOKEN
       username: SomeBot
+      server: http://local.bot.api.server
 
     # For multiple bots in single app use hash of `internal_bot_id => settings`
     bots:
@@ -79,6 +101,17 @@ development:
         username: ChatBot
 ```
 
+For Rails >= 5.2 `Telegram::Bot` searches for config first in credentials and then in secrets.
+To use credentials as config store, add telegram section to credentials instead of secrets using
+`rails credentials:edit`. In this case be aware of that [Rails < 6.0 may not load
+credentials in dev environment by default](https://github.com/telegram-bot-rb/telegram-bot/issues/74#issuecomment-384205609).
+In Rails >= 6.0 run `rails credentials:edit --environment development` to configure bot
+in each environment.
+
+I suggest not using Rails 5.2 credentials because it can lead to leakage of sensitive data
+and it's more difficult to use in multiple environments. See
+[secure_credentials](https://github.com/printercu/secure_credentials) gem for better option.
+
 From now clients will be accessible with `Telegram.bots[:chat]` or `Telegram.bots[:auction]`.
 Single bot can be accessed with `Telegram.bot` or `Telegram.bots[:default]`.
 
@@ -201,12 +234,14 @@ def reply_with(type, params); end
 def answer_inline_query(results, params = {}); end
 def answer_callback_query(text, params = {}); end
 def edit_message(type, params = {}); end
+def answer_pre_checkout_query(ok, params = {}); end
+def answer_shipping_query(ok, params = {}); end
 ```
 
 #### Optional typecasting
 
 You can enable typecasting of `update` with `telegram-bot-types` by including
-`Telegram::Bot::UpdatesPoller::TypedUpdate`:
+`Telegram::Bot::UpdatesController::TypedUpdate`:
 
 ```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
@@ -334,7 +369,7 @@ 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.
+It defines routes at `telegram/#{hash_of(bot.token)}` and connects bots with controller.
 
 ```ruby
 # Most off apps would require
@@ -443,10 +478,11 @@ RSpec.describe TelegramWebhooksController, telegram_bot: :rails do
   #   dispatch_command(cmd, *args)
 
   # Available matchers can be found in Telegram::Bot::RSpec::ClientMatchers.
-  it 'shows usage of basic matchers'
+  it 'shows usage of basic matchers' do
-    # The most basic one is #make_telegram_request(bot, endpoint, params_matcher)
+    # The most basic one is #make_telegram_request(bot, action).
-    expect { dispatch_command(:start) }.
+    # It works similar to `receive` matcher and supports chaining `.with(args).exactly(n).times`.
-      to make_telegram_request(bot, :sendMessage, hash_including(text: 'msg text'))
+    expect { dispatch_command(:start) }.to make_telegram_request(bot, :sendMessage).
+      with(hash_including(text: 'msg text'))
 
     # There are some shortcuts for dispatching basic updates and testing responses.
     expect { dispatch_message('Hi') }.to send_telegram_message(bot, /msg regexp/, some: :option)
@@ -494,48 +530,12 @@ While webhooks-mode is prefered, poller still can be used in production.
 See [comparison and examples](https://github.com/telegram-bot-rb/telegram-bot/wiki/Deployment)
 for details.
 
-### Botan.io metrics
-
-Initialize with `bot = Telegram::Bot::Client.new(token, botan: 'botan token')`
-or just add `botan` key in `secrets.yml`:
-
-```yml
-  telegram:
-    bot:
-      token: bot_token
-      botan: botan_token
-```
-
-Access to Botan client with `bot.botan`.
-Use `bot.botan.track(event, uid, payload)` to track events.
-
-There are some helpers for controllers in `Telegram::Bot::Botan::ControllerHelpers`:
-
-```ruby
-class Telegram::WebhookController < Telegram::Bot::UpdatesController
-  include Telegram::Bot::Botan::ControllerHelpers
-
-  # This will track with event: action_name & data: payload
-  before_action :botan_track_action
-
-  def smth(*)
-    # This will track event for current user only when botan is configured.
-    botan_track :my_event, custom_data
-
-    # or get access directly to botan client:
-    botan.track(...)
-  end
-end
-```
-
-There is no stubbing for botan clients, so don't set botan token in tests.
-
 ### Async mode
 
 There is built in support for async requests using ActiveJob. Without Rails
 you can implement your own worker class to handle such requests. This allows:
 
-- Process updates very fast, without waiting for telegram and botan responses.
+- Process updates very fast, without waiting for telegram responses.
 - Handle and retry network and other errors with queue adapter.
 - ???
 
@@ -543,7 +543,7 @@ Instead of performing request instantly client serializes it, pushes to queue,
 and immediately return control back. The job is then fetched with a worker
 and real API request is performed. And this all is absolutely transparent for the app.
 
-To enable this mode add `async: true` to bot's and botan's config.
+To enable this mode add `async: true` to bot's config.
 For more information and custom configuration check out
 [docs](http://www.rubydoc.info/github/telegram-bot-rb/telegram-bot/master/Telegram/Bot/Async) or
 [source](https://github.com/telegram-bot-rb/telegram-bot/blob/master/lib/telegram/bot/async.rb).

bin/fetch-telegram-methods

@@ -25,7 +25,7 @@ method_list = headers.
   map { |g| g.reject { |x| x.match?(NOT_METHOD_REGEXP) } }.
   reject(&:empty?)
 
-api_version = doc.text.match(/^(Bot API ([\d\.]+))\.?$/)
+api_version = doc.text.match(/^(?:Introducing )?(Bot API ([\d\.]+))\.?$/)
 
 result = ['# Generated with bin/fetch-telegram-methods']
 result << "# #{api_version[1]}" if api_version

gemfiles/rails_42.gemfile

@@ -2,15 +2,15 @@
 
 source "https://rubygems.org"
 
-gem "actionpack", "~> 4.2"
+gem "actionpack", "~> 4.2.0"
-gem "railties", "~> 4.2"
+gem "railties", "~> 4.2.0"
 
 group :development do
   gem "appraisal", "~> 2.2"
   gem "pry", "~> 0.10.1"
   gem "pry-byebug", "~> 3.2.0"
   gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.6.0"
+  gem "telegram-bot-types", "~> 0.6.2"
   gem "rspec", "~> 3.5.0"
   gem "rspec-its", "~> 1.1.0"
   gem "rspec-rails", "~> 3.5.0"

gemfiles/rails_50.gemfile

@@ -2,15 +2,15 @@
 
 source "https://rubygems.org"
 
-gem "actionpack", "~> 5.0"
+gem "actionpack", "~> 5.0.0"
-gem "railties", "~> 5.0"
+gem "railties", "~> 5.0.0"
 
 group :development do
   gem "appraisal", "~> 2.2"
   gem "pry", "~> 0.10.1"
   gem "pry-byebug", "~> 3.2.0"
   gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.6.0"
+  gem "telegram-bot-types", "~> 0.6.2"
   gem "rspec", "~> 3.5.0"
   gem "rspec-its", "~> 1.1.0"
   gem "rspec-rails", "~> 3.5.0"

gemfiles/rails_51.gemfile

@@ -2,15 +2,15 @@
 
 source "https://rubygems.org"
 
-gem "actionpack", "~> 5.1"
+gem "actionpack", "~> 5.1.0"
-gem "railties", "~> 5.1"
+gem "railties", "~> 5.1.0"
 
 group :development do
   gem "appraisal", "~> 2.2"
   gem "pry", "~> 0.10.1"
   gem "pry-byebug", "~> 3.2.0"
   gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.6.0"
+  gem "telegram-bot-types", "~> 0.6.2"
   gem "rspec", "~> 3.5.0"
   gem "rspec-its", "~> 1.1.0"
   gem "rspec-rails", "~> 3.5.0"

gemfiles/rails_52.gemfile

@@ -2,15 +2,15 @@
 
 source "https://rubygems.org"
 
-gem "actionpack", "~> 5.2.0.beta2"
+gem "actionpack", "~> 5.2.0"
-gem "railties", "~> 5.2.0.beta2"
+gem "railties", "~> 5.2.0"
 
 group :development do
   gem "appraisal", "~> 2.2"
   gem "pry", "~> 0.10.1"
   gem "pry-byebug", "~> 3.2.0"
   gem "sdoc", "~> 0.4.1"
-  gem "telegram-bot-types", "~> 0.6.0"
+  gem "telegram-bot-types", "~> 0.6.2"
   gem "rspec", "~> 3.5.0"
   gem "rspec-its", "~> 1.1.0"
   gem "rspec-rails", "~> 3.5.0"

gemfiles/rails_60.gemfile

@@ -2,17 +2,15 @@
 
 source "https://rubygems.org"
 
-git "https://github.com/rails/rails.git" do
+gem "actionpack", "~> 6.0.0"
-  gem "actionpack", "~> 6.0.0.alpha"
+gem "railties", "~> 6.0.0"
-  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 "telegram-bot-types", "~> 0.6.2"
   gem "rspec", "~> 3.5.0"
   gem "rspec-its", "~> 1.1.0"
   gem "rspec-rails", "~> 3.5.0"

gemfiles/rails_61.gemfile

@@ -0,0 +1,23 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+git "https://github.com/rails/rails.git" do
+  gem "actionpack", "~> 6.1.0.alpha"
+  gem "railties", "~> 6.1.0.alpha"
+end
+
+group :development do
+  gem "appraisal", "~> 2.2"
+  gem "pry", "~> 0.10.1"
+  gem "pry-byebug", "~> 3.2.0"
+  gem "sdoc", "~> 0.4.1"
+  gem "telegram-bot-types", "~> 0.6.2"
+  gem "rspec", "~> 3.5.0"
+  gem "rspec-its", "~> 1.1.0"
+  gem "rspec-rails", "~> 3.5.0"
+  gem "rubocop", "~> 0.52.1"
+  gem "coveralls", "~> 0.8.2", require: false
+end
+
+gemspec path: "../"

lib/tasks/telegram-bot.rake

@@ -14,15 +14,22 @@ namespace :telegram do
 
     desc 'Set webhook urls for all bots'
     task set_webhook: :environment do
-      routes = Rails.application.routes.url_helpers
+      Telegram::Bot::Tasks.set_webhook
-      cert_file = ENV['CERT']
+    end
-      cert = File.open(cert_file) if cert_file
+
-      Telegram.bots.each do |key, bot|
+    desc 'Delete webhooks for all or specific BOT'
-        route_name = Telegram::Bot::RoutesHelper.route_name_for_bot(bot)
+    task :delete_webhook do
-        url = routes.send("#{route_name}_url")
+      Telegram::Bot::Tasks.delete_webhook
-        puts "Setting webhook for #{key}..."
+    end
-        bot.async(false) { bot.set_webhook(url: url, certificate: cert) }
+
-      end
+    desc 'Perform logOut command for all or specific BOT'
+    task :log_out do
+      Telegram::Bot::Tasks.log_out
+    end
+
+    desc 'Perform `close` command for all or specific BOT'
+    task :close do
+      Telegram::Bot::Tasks.close
     end
   end
 end

lib/telegram/bot.rb

@@ -14,21 +14,20 @@ module Telegram
 
     module_function
 
-    def deprecation_0_15
+    def deprecation_0_16
       @deprecation ||= begin
         require 'active_support/deprecation'
-        ActiveSupport::Deprecation.new('0.15', 'Telegram::Bot')
+        ActiveSupport::Deprecation.new('0.16', 'Telegram::Bot')
       end
     end
 
     autoload :Async,              'telegram/bot/async'
-    autoload :Botan,              'telegram/bot/botan'
     autoload :Client,             'telegram/bot/client'
     autoload :ClientStub,         'telegram/bot/client_stub'
     autoload :DebugClient,        'telegram/bot/debug_client'
-    autoload :Initializers,       'telegram/bot/initializers'
     autoload :Middleware,         'telegram/bot/middleware'
     autoload :RSpec,              'telegram/bot/rspec'
+    autoload :Tasks,              'telegram/bot/tasks'
     autoload :UpdatesController,  'telegram/bot/updates_controller'
     autoload :UpdatesPoller,      'telegram/bot/updates_poller'
   end

lib/telegram/bot/async.rb

@@ -1,28 +1,23 @@
 module Telegram
   module Bot
-    # Telegram & Botan clients can perform requests in async way with
+    # Telegram clients can perform requests in async way with
     # any job adapter (ActiveJob by default). Using Rails you don't need any
     # additional configuration. However you may want to enable async requests
-    # by default with `async: true` in `secrets.yml`. Botan client doesn't inherit
+    # by default with `async: true` in `secrets.yml`.
-    # async setting from client and must be configured separately.
     #
     #   telegram:
     #     bots:
     #       chat_async:
     #         token: secret
     #         async: true # enable async mode for client
-    #         botan: botan_token # in this way botan will not be async
-    #         botan: # in this way - it's in async mode
-    #           token: botan_token
-    #           async: true
     #
     # Without Rails To start using async requests
     # initialize client with `id` kwarg and make sure the client is
     # accessible via `Teletgram.bots[id]` in job worker. Or just use
     # `Telegram.bots_config=` for configuration.
     #
-    # Being in async mode `#request` enqueues job instead to perform
+    # Being in async mode `#request` enqueues job to perform
-    # http request instead of performing it directly.
+    # http request instead of performing it immediately.
     # Async behavior is controlled with `#async=` writer
     # and can be enabled/disabled for the block with `#async`:
     #
@@ -34,7 +29,7 @@ module Telegram
     # while `#async(val, &block)` is thread-safe.
     #
     # It can be set with custom job class or classname. By default it defines
-    # job classes for every client class, inherited from ApplicationRecord, which
+    # job classes inherited from ApplicationJob, which
     # can be accessed via `.default_async_job`. You can integrate it with any
     # other job provider by defining a class with `.perform_later(bot_id, *args)`
     # method. See Async::Job for implemetation.

lib/telegram/bot/botan.rb

@@ -1,53 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      TRACK_URI = 'https://api.botan.io/track'.freeze
-
-      autoload :ClientHelpers, 'telegram/bot/botan/client_helpers'
-      autoload :ControllerHelpers, 'telegram/bot/botan/controller_helpers'
-      class Error < Bot::Error; end
-
-      extend Initializers
-      prepend Async
-      include DebugClient
-
-      class << self
-        def by_id(id)
-          Telegram.botans[id]
-        end
-
-        def prepare_async_args(method, uri, query = {}, body = nil)
-          [method.to_s, uri.to_s, Async.prepare_hash(query), body]
-        end
-      end
-
-      attr_reader :client, :token
-
-      def initialize(token = nil, **options)
-        @client = HTTPClient.new
-        @token = token || options[:token]
-      end
-
-      def track(event, uid, payload = {})
-        request(:post, TRACK_URI, {name: event, uid: uid}, payload.to_json)
-      end
-
-      def request(method, uri, query = {}, body = nil)
-        res = http_request(method, uri, query.merge(token: token), body)
-        status = res.status
-        return JSON.parse(res.body) if status < 300
-        result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
-        err_msg = "#{res.reason}: #{result && result['info'] || '-'}"
-        raise Error, err_msg
-      end
-
-      def http_request(method, uri, query, body)
-        client.request(method, uri, query, body)
-      end
-
-      def inspect
-        "#<#{self.class.name}##{object_id}(#{@id})>"
-      end
-    end
-  end
-end

lib/telegram/bot/botan/client_helpers.rb

@@ -1,15 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      # Helpers for botan.io metrics.
-      module ClientHelpers
-        attr_reader :botan
-
-        def initialize(*, botan: nil, **options)
-          super
-          @botan = Botan.wrap(botan, id: id) if botan
-        end
-      end
-    end
-  end
-end

lib/telegram/bot/botan/controller_helpers.rb

@@ -1,33 +0,0 @@
-module Telegram
-  module Bot
-    class Botan
-      # Helpers for botan.io metrics.
-      module ControllerHelpers
-        class MissingFrom < Error; end
-
-        protected
-
-        def botan
-          @botan ||= bot.try!(:botan)
-        end
-
-        # Track custom event for user taken from `from` field:
-        #
-        #   botan_track :my_event, {data: :val}
-        #
-        def botan_track(event, data = {})
-          raise MissingFrom, 'Can not track without user' unless from
-          botan.try! { |x| x.track(event, from['id'], data) }
-        end
-
-        # Track current action and payload for current user. Best used with `before_action`:
-        #
-        #   before_action :botan_track_action
-        #
-        def botan_track_action
-          botan_track(action_name, payload)
-        end
-      end
-    end
-  end
-end

lib/telegram/bot/client.rb

@@ -1,21 +1,31 @@
+require 'active_support/core_ext/hash/keys'
 require 'json'
 require 'httpclient'
 
 module Telegram
   module Bot
     class Client
-      URL_TEMPLATE = 'https://api.telegram.org/bot%<token>s/'.freeze
+      SERVER = 'https://api.telegram.org'.freeze
+      URL_TEMPLATE = '%<server>s/bot%<token>s/'.freeze
 
       autoload :TypedResponse, 'telegram/bot/client/typed_response'
-      extend Initializers
       prepend Async
-      prepend Botan::ClientHelpers
       include DebugClient
 
       require 'telegram/bot/client/api_helper'
       include ApiHelper
 
       class << self
+        # Accepts different options to initialize bot.
+        def wrap(input, **options)
+          case input
+          when Symbol then by_id(input) or raise "#{name} #{input.inspect} not configured"
+          when self   then input
+          when Hash   then new(**input.symbolize_keys, **options)
+          else        new(input, **options)
+          end
+        end
+
         def by_id(id)
           Telegram.bots[id]
         end
@@ -52,11 +62,11 @@ module Telegram
 
       attr_reader :client, :token, :username, :base_uri
 
-      def initialize(token = nil, username = nil, **options)
+      def initialize(token = nil, username = nil, server: SERVER, **options)
         @client = HTTPClient.new
         @token = token || options[:token]
         @username = username || options[:username]
-        @base_uri = format(URL_TEMPLATE, token: self.token)
+        @base_uri = format(URL_TEMPLATE, server: server, token: self.token)
       end
 
       def request(action, body = {})

lib/telegram/bot/client/api_methods.txt

@@ -1,5 +1,5 @@
 # Generated with bin/fetch-telegram-methods
-# Bot API 3.5.
+# Bot API 5.0
 
 getUpdates
 setWebhook
@@ -7,12 +7,16 @@ deleteWebhook
 getWebhookInfo
 
 getMe
+logOut
+close
 sendMessage
 forwardMessage
+copyMessage
 sendPhoto
 sendAudio
 sendDocument
 sendVideo
+sendAnimation
 sendVoice
 sendVideoNote
 sendMediaGroup
@@ -21,6 +25,8 @@ editMessageLiveLocation
 stopMessageLiveLocation
 sendVenue
 sendContact
+sendPoll
+sendDice
 sendChatAction
 getUserProfilePhotos
 getFile
@@ -28,6 +34,8 @@ kickChatMember
 unbanChatMember
 restrictChatMember
 promoteChatMember
+setChatAdministratorCustomTitle
+setChatPermissions
 exportChatInviteLink
 setChatPhoto
 deleteChatPhoto
@@ -35,6 +43,7 @@ setChatTitle
 setChatDescription
 pinChatMessage
 unpinChatMessage
+unpinAllChatMessages
 leaveChat
 getChat
 getChatAdministrators
@@ -43,10 +52,14 @@ getChatMember
 setChatStickerSet
 deleteChatStickerSet
 answerCallbackQuery
+setMyCommands
+getMyCommands
 
 editMessageText
 editMessageCaption
+editMessageMedia
 editMessageReplyMarkup
+stopPoll
 deleteMessage
 
 sendSticker
@@ -56,6 +69,7 @@ createNewStickerSet
 addStickerToSet
 setStickerPositionInSet
 deleteStickerFromSet
+setStickerSetThumb
 
 answerInlineQuery
 
@@ -63,6 +77,8 @@ sendInvoice
 answerShippingQuery
 answerPreCheckoutQuery
 
+setPassportDataErrors
+
 sendGame
 setGameScore
 getGameHighScores

lib/telegram/bot/config_methods.rb

@@ -40,11 +40,6 @@ module Telegram
         end
       end
 
-      # Hash of botan clients made from #bots.
-      def botans
-        @botans ||= bots.map { |k, v| [k, v.botan] }.to_h
-      end
-
       # Returns config for .bots method. By default uses `telegram['bots']` section
       # from `secrets.yml` merging `telegram['bot']` at `:default` key.
       #
@@ -53,10 +48,12 @@ module Telegram
         @bots_config ||=
           if defined?(Rails.application)
             app = Rails.application
-            store = app.respond_to?(:credentials) ? app.credentials : app.secrets
+            store = app.credentials[:telegram] if app.respond_to?(:credentials)
-            secrets = store.fetch(:telegram, {}).with_indifferent_access
+            store ||= app.secrets[:telegram] if app.respond_to?(:secrets)
-            secrets.fetch(:bots, {}).symbolize_keys.tap do |config|
+            store ||= {}
-              default = secrets[:bot]
+            store = store.with_indifferent_access
+            store.fetch(:bots, {}).symbolize_keys.tap do |config|
+              default = store[:bot]
               config[:default] = default if default
             end
           else
@@ -69,7 +66,6 @@ module Telegram
         @bots = nil
         @bot = nil
         @bots_config = nil
-        @botans = nil
       end
     end
   end

lib/telegram/bot/initializers.rb

@@ -1,21 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-module Telegram
-  module Bot
-    module Initializers
-      # Accepts different options to initialize bot.
-      def wrap(input, **options)
-        case input
-        when Symbol then by_id(input) or raise "#{name} #{input.inspect} not configured"
-        when self   then input
-        when Hash   then new(**input.symbolize_keys, **options)
-        else        new(input, **options)
-        end
-      end
-
-      def by_id(_id)
-        raise 'Not implemented'
-      end
-    end
-  end
-end

lib/telegram/bot/routes_helper.rb

@@ -1,3 +1,6 @@
+require 'base64'
+require 'openssl'
+
 require 'telegram/bot'
 require 'active_support/core_ext/array/wrap'
 
@@ -17,10 +20,8 @@ module Telegram
           end || 'telegram_webhook'
         end
 
-        # Replaces colon with underscore so rails don't treat it as
+        def token_hash(token)
-        # route parameter.
+          Base64.urlsafe_encode64(OpenSSL::Digest::SHA1.digest(token), padding: false)
-        def escape_token(token)
-          token && token.tr(':', '_')
         end
       end
 
@@ -34,14 +35,17 @@ module Telegram
       #
       #   # pass additional options
       #   telegram_webhook TelegramController, :default, as: :custom_route_name
-      def telegram_webhook(controller, bot = :default, **options)
+      #
+      #   # Default path is generated using hashed bot token. Override it using:
+      #   telegram_webhook TelegramController, :default, path: 'top/secret'
+      def telegram_webhook(controller, bot = :default, path: nil, **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)
+        post(path || "telegram/#{bot.token && RoutesHelper.token_hash(bot.token)}", params)
         UpdatesPoller.add(bot, controller) if Telegram.bot_poller_mode?
       end
     end

lib/telegram/bot/rspec/integration.rb

@@ -1,10 +0,0 @@
-require 'telegram/bot'
-Telegram::Bot.deprecation_0_15.warn(
-  "`require 'telegram/bot/rspec/integration'` is deprecated in favor of " \
-  "`require 'telegram/bot/rspec/integration/rails'`"
-)
-require 'telegram/bot/rspec/integration/rails'
-
-Telegram::Bot::RSpec.with_include_context do |config|
-  config.include_context 'telegram/bot/integration/rails', telegram_bot: true
-end

lib/telegram/bot/tasks.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Telegram
+  module Bot
+    module Tasks
+      extend self
+
+      def set_webhook
+        routes = Rails.application.routes.url_helpers
+        cert_file = ENV['CERT']
+        cert = File.open(cert_file) if cert_file
+        each_bot do |key, bot|
+          route_name = RoutesHelper.route_name_for_bot(bot)
+          url = routes.send("#{route_name}_url")
+          say("Setting webhook for #{key}...")
+          bot.set_webhook(
+            url: url,
+            certificate: cert,
+            ip_address: ENV['IP_ADDRESS'],
+            drop_pending_updates: drop_pending_updates,
+          )
+        end
+      end
+
+      def delete_webhook
+        each_bot do |key, bot|
+          say("Deleting webhook for #{key}...")
+          bot.delete_webhook(drop_pending_updates: drop_pending_updates)
+        end
+      end
+
+      def log_out
+        each_bot do |key, bot|
+          say("Logging out #{key}...")
+          bot.log_out
+        end
+      end
+
+      def close
+        each_bot do |key, bot|
+          say("Closing #{key}...")
+          bot.close
+        end
+      end
+
+      private
+
+      def say(text)
+        puts(text) unless Rails.env.test? # rubocop:disable Rails/Output
+      end
+
+      def each_bot(&block)
+        id = ENV['BOT'].try!(:to_sym)
+        bots = id ? {id => Client.by_id(id)} : Telegram.bots
+        bots.each { |key, bot| bot.async(false) { block[key, bot] } }
+      end
+
+      def drop_pending_updates
+        ENV['DROP_PENDING_UPDATES'].try!(:downcase) == 'true'
+      end
+    end
+  end
+end

lib/telegram/bot/updates_controller.rb

@@ -7,13 +7,13 @@ module Telegram
   module Bot
     # Base class to create update processors. With callbacks, session and helpers.
     #
-    # Define public methods for each command and they will be called when
+    # Public methods ending with `!` handle messages with commands.
-    # update has this command. Message is automatically parsed and
+    # Message text is automatically parsed  into method arguments.
-    # words are passed as method arguments. Be sure to use default values and
+    # Be sure to use default values and
     # splat arguments in every action method to not get errors, when user
     # sends command without necessary args / with extra args.
     #
-    #     def start(token = nil, *)
+    #     def start!(token = nil, *)
     #       if token
     #         # ...
     #       else
@@ -21,25 +21,21 @@ module Telegram
     #       end
     #     end
     #
-    #     def help(*)
+    #     def help!(*)
     #       respond_with :message, text:
     #     end
     #
     # To process plain text messages (without commands) or other updates just
-    # define public method with name of payload type. They will receive payload
+    # define public method with name of payload type.
-    # as an argument.
+    # By default they receive payload as an argument, but some of them are called
+    # with more usefuk args:
     #
     #     def message(message)
     #       respond_with :message, text: "Echo: #{message['text']}"
     #     end
     #
-    #     def inline_query(query)
+    #     def inline_query(query, offset)
-    #       answer_inline_query results_for_query(query), is_personal: true
+    #       answer_inline_query results_for_query(query, offset), is_personal: true
-    #     end
-    #
-    #     # To process conflicting commands (`/message args`) just use `on_` prefix:
-    #     def on_message(*args)
-    #       # ...
     #     end
     #
     # To process update run:
@@ -101,6 +97,8 @@ module Telegram
         callback_query
         shipping_query
         pre_checkout_query
+        poll
+        poll_answer
       ].freeze
 
       class << self
@@ -152,7 +150,7 @@ module Telegram
       # Accessor to `'from'` field of payload. Can be overriden with `from` option
       # for #initialize.
       def from
-        @_from ||= payload && payload['from']
+        @_from ||= payload.is_a?(Hash) ? payload['from'] : payload.try(:from)
       end
 
       # Processes current update.
@@ -210,6 +208,10 @@ module Telegram
         [payload_type, [payload['data']]]
       end
 
+      def action_for_poll_answer
+        [payload_type, [payload['poll_id'], payload['option_ids']]]
+      end
+
       # Silently ignore unsupported messages to not fail when user crafts
       # an update with usupported command, callback query context, etc.
       def action_missing(action, *_args)

lib/telegram/bot/updates_controller/reply_helpers.rb

@@ -21,7 +21,7 @@ module Telegram
           respond_with(type, params)
         end
 
-        # Same as reply_with, but for inline queries.
+        # Same as respond_with, but for inline queries.
         def answer_inline_query(results, params = {})
           params = params.merge(
             inline_query_id: payload['id'],
@@ -30,7 +30,7 @@ module Telegram
           bot.answer_inline_query(params)
         end
 
-        # Same as reply_with, but for callback queries.
+        # Same as respond_with, but for callback queries.
         def answer_callback_query(text, params = {})
           params = params.merge(
             callback_query_id: payload['id'],
@@ -39,6 +39,23 @@ module Telegram
           bot.answer_callback_query(params)
         end
 
+        # Same as respond_with, but for pre checkout queries.
+        def answer_pre_checkout_query(ok, params = {})
+          params = params.merge(
+            pre_checkout_query_id: payload['id'],
+            ok: ok,
+          )
+          bot.answer_pre_checkout_query(params)
+        end
+
+        def answer_shipping_query(ok, params = {})
+          params = params.merge(
+            shipping_query_id: payload['id'],
+            ok: ok,
+          )
+          bot.answer_shipping_query(params)
+        end
+
         # Edit message from callback query.
         def edit_message(type, params = {})
           params =

lib/telegram/bot/updates_poller.rb

@@ -50,7 +50,7 @@ module Telegram
         ensure
           @running = false
         end
-        log { 'Stoped polling bot updates.' }
+        log { 'Stopped polling bot updates.' }
       end
 
       def run

lib/telegram/bot/version.rb

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

spec/integration/tasks_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'integration_helper'
+
+RSpec.describe Telegram::Bot::Tasks, type: :request do
+  include Telegram::Bot::RSpec::ClientMatchers
+
+  def stub_env(new_values)
+    new_values.stringify_keys!
+    old_values = ENV.to_h.slice(new_values.keys)
+    new_values.each { |k, v| ENV[k] = v.to_s }
+    yield
+  ensure
+    new_values.each_key { |k| ENV[k] = old_values[k] }
+  end
+
+  shared_examples 'uses BOT envar' do |bot_matcher|
+    it 'runs for all bots by default' do
+      matcher = Telegram.bots.values.map { |x| instance_exec(x, &bot_matcher) }.reduce(&:and)
+      expect(subject).to matcher
+    end
+
+    context 'when BOT specified' do
+      around { |ex| stub_env(BOT: :other) { ex.run } }
+
+      it 'runs for this bot only' do
+        expect(subject).to instance_exec(Telegram.bots[:other], &bot_matcher)
+      end
+    end
+  end
+
+  describe '#log_out' do
+    subject { -> { described_class.log_out } }
+    include_examples 'uses BOT envar', ->(bot) { make_telegram_request(bot, :logOut) }
+  end
+
+  describe '#close' do
+    subject { -> { described_class.close } }
+    include_examples 'uses BOT envar', ->(bot) { make_telegram_request(bot, :close) }
+  end
+
+  describe '#set_webhook' do
+    subject { -> { described_class.set_webhook } }
+    include_examples 'uses BOT envar', ->(bot) { make_telegram_request(bot, :setWebhook) }
+
+    context 'with options in env' do
+      around do |ex|
+        stub_env(IP_ADDRESS: '1.2.3.4', DROP_PENDING_UPDATES: 'TrUe') do
+          ex.run
+        end
+      end
+      include_examples 'uses BOT envar', ->(bot) {
+        make_telegram_request(bot, :setWebhook).with(hash_including(
+          ip_address: '1.2.3.4',
+          drop_pending_updates: true,
+        ))
+      }
+    end
+  end
+
+  describe '#delete_webhook' do
+    subject { -> { described_class.delete_webhook } }
+    include_examples 'uses BOT envar', ->(bot) { make_telegram_request(bot, :deleteWebhook) }
+
+    context 'with options in env' do
+      around { |ex| stub_env(DROP_PENDING_UPDATES: 'TrUe') { ex.run } }
+      include_examples 'uses BOT envar', ->(bot) {
+        make_telegram_request(bot, :deleteWebhook).with(hash_including(
+          drop_pending_updates: true,
+        ))
+      }
+    end
+  end
+end

spec/integration_helper.rb

@@ -14,6 +14,7 @@ class TestApplication < Rails::Application
   config.eager_load = false
   config.log_level = :debug
   config.action_dispatch.show_exceptions = false
+  routes.default_url_options = {host: 'test.rpsec'}
 
   telegram_config = {
     bot: 'default_token',

spec/support/examples/initializers.rb

@@ -1,65 +0,0 @@
-RSpec.shared_examples 'initializers' do |config_method = :bots|
-  describe '.wrap' do
-    subject { described_class.wrap(input, **options) }
-    let(:options) { {} }
-    let(:result) { double(:result) }
-    let(:username) { 'username' }
-
-    context 'when input is a string' do
-      let(:input) { token }
-
-      it 'treats string as token' do
-        expect(described_class).to receive(:new).with(token, {}) { result }
-        should eq result
-      end
-
-      context 'and additional options are given' do
-        let(:options) { {id: :test} }
-
-        it 'passes them to initializer' do
-          expect(described_class).to receive(:new).with(input, **options) { result }
-          should eq result
-        end
-      end
-    end
-
-    context 'when input is a hash' do
-      let(:input) { {token: token, 'username' => username, other: :options} }
-
-      it 'passes it with symbolized keys' do
-        expect(described_class).to receive(:new).with(**input.symbolize_keys) { result }
-        should eq result
-      end
-
-      context 'and additional options are given' do
-        let(:options) { {id: :test} }
-
-        it 'passes them to initializer' do
-          expect(described_class).to receive(:new).
-            with(**input.symbolize_keys, **options) { result }
-          should eq result
-        end
-      end
-    end
-
-    context 'when input is an instance of described_class' do
-      let!(:input) { instance }
-
-      it 'returns input' do
-        expect(described_class).to_not receive(:new)
-        should eq input
-      end
-    end
-
-    context 'when input is a Symbol' do
-      let(:input) { :client_1 }
-      before { allow(Telegram).to receive(config_method) { {client_1: instance} } }
-      it { should eq Telegram.send(config_method)[:client_1] }
-
-      context 'and there is no such bot' do
-        let(:input) { :invalid }
-        it { expect { subject }.to raise_error(/not configured/) }
-      end
-    end
-  end
-end

spec/telegram/bot/botan/client_helpers_spec.rb

@@ -1,33 +0,0 @@
-RSpec.describe Telegram::Bot::Client do
-  let(:instance) { described_class.new(*client_args) }
-  let(:token) { 'token' }
-  let(:botan_token) { double(:botan_token) }
-  let(:client_id) { 'client_id' }
-  let(:client_args) { [token] }
-
-  describe '#botan' do
-    subject { instance.botan }
-    it { should eq nil }
-
-    context 'when botan token is set' do
-      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_token] }
-      it { should be_instance_of Telegram::Bot::Botan }
-      its(:token) { should eq botan_token }
-      its(:id) { should eq client_id }
-
-      it 'doesnt inherit async from client' do
-        expect(instance.async).to be
-        expect(subject.async).to_not be
-      end
-    end
-
-    context 'when botan is configured with hash' do
-      let(:client_args) { [token, id: client_id, async: Class.new, botan: botan_config] }
-      let(:botan_config) { {token: botan_token, async: Class.new} }
-      it { should be_instance_of Telegram::Bot::Botan }
-      its(:token) { should eq botan_token }
-      its(:id) { should eq client_id }
-      its(:async) { should eq botan_config[:async] }
-    end
-  end
-end

spec/telegram/bot/botan/controller_helpers_spec.rb

@@ -1,54 +0,0 @@
-RSpec.describe Telegram::Bot::Botan::ControllerHelpers do
-  include_context 'telegram/bot/updates_controller'
-  let(:controller_class) do
-    described_class = self.described_class
-    Class.new(Telegram::Bot::UpdatesController) do
-      include described_class
-    end
-  end
-  let(:botan) { double(:botan) }
-  let(:result) { double(:result) }
-  let(:payload) { {from: {id: user_id}} }
-  let(:payload_type) { :message }
-  let(:user_id) { double(:user_id) }
-  before { allow(bot).to receive(:botan) { botan } }
-
-  shared_examples 'basic tracking' do
-    context 'when botan is not configured' do
-      let(:botan) {}
-      it { should eq nil }
-    end
-
-    context 'when `from` is empty' do
-      let(:payload) { {text: 'test'} }
-      it { expect { subject }.to raise_error described_class::MissingFrom }
-    end
-  end
-
-  describe '#botan_track' do
-    subject { controller.send(:botan_track, event, data) }
-    let(:event) { double(:event) }
-    let(:data) { double(:data) }
-
-    it 'calls botan#track' do
-      expect(botan).to receive(:track).with(event, user_id, data) { result }
-      should eq result
-    end
-
-    include_examples 'basic tracking'
-  end
-
-  describe '#botan_track_action' do
-    subject { controller.send(:botan_track_action) }
-    let(:action_name) { double(:action_name) }
-
-    it 'calls botan#track with current action and payload' do
-      expect(controller).to receive(:action_name) { action_name }
-      expect(botan).to receive(:track).
-        with(action_name, user_id, deep_stringify(payload)) { result }
-      should eq result
-    end
-
-    include_examples 'basic tracking'
-  end
-end

spec/telegram/bot/botan_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe Telegram::Bot::Botan do
-  let(:instance) { described_class.new 'token' }
-  let(:token) { 'token' }
-
-  include_examples 'initializers', :botans
-  it_behaves_like 'async', request_args: -> { [double(:method), double(:url)] }
-
-  describe '.new' do
-    subject { described_class.new(*args) }
-
-    context 'when usual args are given' do
-      let(:args) { ['secret'] }
-      its(:token) { should eq args[0] }
-    end
-
-    context 'when options are given' do
-      let(:args) { [token: 'secret'] }
-      its(:token) { should eq args[0][:token] }
-    end
-  end
-
-  describe '.prepare_async_args' do
-    subject { described_class.prepare_async_args(*input) }
-    let(:input) { [:post, :uri, {a: 1, b: :sym, 'd' => 'str'}, 'body'] }
-    it { should eq ['post', 'uri', {a: 1, b: 'sym', 'd' => 'str'}, 'body'] }
-  end
-end

spec/telegram/bot/client_spec.rb

@@ -1,11 +1,73 @@
 RSpec.describe Telegram::Bot::Client do
   let(:instance) { described_class.new 'token' }
   let(:token) { 'token' }
-  let(:botan_token) { double(:botan_token) }
 
-  include_examples 'initializers'
   it_behaves_like 'async', request_args: -> { [double(:action), {body: :content}] }
 
+  describe '.wrap' do
+    subject { described_class.wrap(input, **options) }
+    let(:options) { {} }
+    let(:result) { double(:result) }
+    let(:username) { 'username' }
+
+    context 'when input is a string' do
+      let(:input) { token }
+
+      it 'treats string as token' do
+        expect(described_class).to receive(:new).with(token, {}) { result }
+        should eq result
+      end
+
+      context 'and additional options are given' do
+        let(:options) { {id: :test} }
+
+        it 'passes them to initializer' do
+          expect(described_class).to receive(:new).with(input, **options) { result }
+          should eq result
+        end
+      end
+    end
+
+    context 'when input is a hash' do
+      let(:input) { {token: token, 'username' => username, other: :options} }
+
+      it 'passes it with symbolized keys' do
+        expect(described_class).to receive(:new).with(**input.symbolize_keys) { result }
+        should eq result
+      end
+
+      context 'and additional options are given' do
+        let(:options) { {id: :test} }
+
+        it 'passes them to initializer' do
+          expect(described_class).to receive(:new).
+            with(**input.symbolize_keys, **options) { result }
+          should eq result
+        end
+      end
+    end
+
+    context 'when input is an instance of described_class' do
+      let!(:input) { instance }
+
+      it 'returns input' do
+        expect(described_class).to_not receive(:new)
+        should eq input
+      end
+    end
+
+    context 'when input is a Symbol' do
+      let(:input) { :client_1 }
+      before { allow(Telegram).to receive(:bots) { {client_1: instance} } }
+      it { should eq Telegram.bots[:client_1] }
+
+      context 'and there is no such bot' do
+        let(:input) { :invalid }
+        it { expect { subject }.to raise_error(/not configured/) }
+      end
+    end
+  end
+
   describe '.prepare_body' do
     subject { described_class.prepare_body(input) }
 
@@ -33,26 +95,45 @@ RSpec.describe Telegram::Bot::Client do
 
   describe '.new' do
     subject { described_class.new(*args) }
+    let(:token) { 'secret' }
+    let(:username) { 'superbot' }
 
     context 'when multiple args are given' do
-      let(:args) { %w[secret superbot] }
+      let(:args) { [token, username] }
-      its(:token) { should eq args[0] }
+      its(:token) { should eq token }
-      its(:username) { should eq args[1] }
+      its(:username) { should eq username }
-      its(:base_uri) { should include args[0] }
+      its(:base_uri) { should eq "#{described_class::SERVER}/bot#{token}/" }
     end
 
     context 'when hash is given' do
       let(:args) { [token: 'secret', username: 'superbot'] }
-      its(:token) { should eq args[0][:token] }
+      its(:token) { should eq token }
-      its(:username) { should eq args[0][:username] }
+      its(:username) { should eq username }
-      its(:base_uri) { should include args[0][:token] }
+      its(:base_uri) { should eq "#{described_class::SERVER}/bot#{token}/" }
+    end
+
+    context 'with custom server' do
+      let(:server) { 'http://my.server' }
+      let(:args) { [token, username, server: server] }
+      its(:base_uri) { should eq "#{server}/bot#{token}/" }
+
+      context 'and hash options' do
+        let(:args) { [token: token, username: username, server: server] }
+        its(:base_uri) { should eq "#{server}/bot#{token}/" }
+      end
     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(:url) do
+      base_uri = format(described_class::URL_TEMPLATE,
+        server: described_class::SERVER,
+        token: token,
+      )
+      "#{base_uri}#{action}"
+    end
     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/config_methods_spec.rb

@@ -11,12 +11,10 @@ RSpec.describe Telegram::Bot::ConfigMethods do
       chat: {
         token: 'chat_token',
         username: 'Chat',
-        botan: 'chat_botan_token',
       },
       other_chat: {
         'token' => 'other_chat_token',
         'username' => 'OtherChat',
-        'botan' => 'other_chat_botan_token',
       },
     }
   end
@@ -43,7 +41,6 @@ RSpec.describe Telegram::Bot::ConfigMethods do
       its(:id) { should eq :chat }
       its(:token) { should eq config[:chat][:token] }
       its(:username) { should eq config[:chat][:username] }
-      its('botan.token') { should eq config[:chat][:botan] }
     end
 
     context 'configured by hash with stringified keys' do
@@ -51,18 +48,6 @@ RSpec.describe Telegram::Bot::ConfigMethods do
       its(:id) { should eq :other_chat }
       its(:token) { should eq config[:other_chat]['token'] }
       its(:username) { should eq config[:other_chat]['username'] }
-      its('botan.token') { should eq config[:other_chat]['botan'] }
-    end
-  end
-
-  describe '#botans' do
-    subject { registry.botans }
-    it do
-      should eq(
-        default: nil,
-        chat: registry.bots[:chat].botan,
-        other_chat: registry.bots[:other_chat].botan,
-      )
     end
   end
 
@@ -76,13 +61,14 @@ RSpec.describe Telegram::Bot::ConfigMethods do
       it { should eq({}) }
 
       context 'in rails environment' do
-        before { stub_const('Rails', double(application: double(secrets: secrets))) }
+        before { stub_const('Rails', double(application: double(app_stub))) }
+        let(:app_stub) { {secrets: secrets} }
         let(:secrets) { {} }
         it { should eq({}) }
 
         context 'when there is telegram section in secrets' do
-          let(:secrets) { {telegram: config.stringify_keys} }
+          let(:secrets) { {telegram: secrets_config} }
-          let(:config) do
+          let(:secrets_config) do
             {
               bot: double(:bot_config),
               bots: {
@@ -91,13 +77,21 @@ RSpec.describe Telegram::Bot::ConfigMethods do
               },
             }
           end
-          it { should include default: config[:bot] }
+          it { should include default: secrets_config[:bot] }
-          it { should include config[:bots] }
+          it { should include secrets_config[:bots] }
 
           context 'on rails >5.1 (deep symbolized keys)' do
-            let(:secrets) { {telegram: config.deep_symbolize_keys} }
+            let(:secrets) { super().deep_symbolize_keys }
-            it { should include default: config[:bot] }
+            it { should include default: secrets_config[:bot] }
-            it { should include config[:bots] }
+            it { should include secrets_config[:bots] }
+          end
+
+          context 'and credentials (>= 5.2)' do
+            let(:app_stub) { super().merge(credentials: credentials) }
+            let(:credentials) { {telegram: credentials_config} }
+            let(:credentials_config) { {bot: double(:credentials_bot_config)} }
+            it { should include default: credentials_config[:bot] }
+            it { should_not include secrets[:bots] }
           end
         end
       end

spec/telegram/bot/routes_helper_spec.rb

@@ -41,57 +41,61 @@ RSpec.describe Telegram::Bot::RoutesHelper do
   end
 
   describe '#telegram_webhook' do
-    subject { mapper.telegram_webhook(*input) }
+    subject { ->(*args) { mapper.telegram_webhook(*args) } }
     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
+    def assert_route(bot, controller, path: nil, **expected_options) # rubocop:disable AbcSize
-      expected_path = options.delete(:path) || "telegram/#{bot.token}"
+      path ||= "telegram/#{described_class.token_hash(bot.token)}"
-      expect(mapper).to receive(:post) do |path, params|
+      expect(mapper).to receive(:post) do |actual_path, actual_options|
-        expect(path).to eq expected_path
+        expect(actual_path).to eq(path)
-        middleware = params[:to]
+        middleware = actual_options[: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(actual_options).to include(expected_options)
-        expect(params).to include(options) if options
       end
-      subject
+      yield
     end
 
-    context 'when called with controller' do
+    it 'creates routes for default bot' do
-      let(:input) { [controller, option: :val] }
+      assert_route(bot, controller, as: 'default_telegram_webhook') do
-
+        subject[controller]
-      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
+      other_controller = double(:other_controller, name: :other_controller)
-        let(:bot) { create_bot(nil) }
+      assert_route(bot, other_controller, as: 'custom_route') do
-        it 'creates routes for default bot and this controller' do
+        subject[other_controller, as: 'custom_route']
-          assert_routes bot, controller, 'default_telegram_webhook', option: :val
-        end
       end
+    end
 
-      context 'and bot has colon in token' do
+    it 'passes extra options' do
-        let(:bot) { create_bot('some:token') }
+      assert_route(bot, controller, as: 'default_telegram_webhook', option: :val, other: 2) do
-        it 'replaces colon with underscore' do
+        subject[controller, option: :val, other: 2]
-          assert_routes bot, controller, 'default_telegram_webhook',
+      end
-            option: :val,
+    end
-            path: 'telegram/some_token'
+
+    it 'uses :path param to override default path' do
+      assert_route(bot, controller, as: 'default_telegram_webhook', path: 'custom/path') do
+        subject[controller, path: 'custom/path']
+      end
+    end
+
+    context 'when bot does not have configured token' do
+      let(:bot) { create_bot(nil) }
+      it 'creates route anyway' do
+        assert_route(bot, controller, as: 'default_telegram_webhook', path: 'telegram/') do
+          subject[controller]
         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',
+        assert_route(create_bot('custom_token'), controller, as: 'telegram_webhook') do
-          option: :val
+          subject[controller, 'custom_token']
+        end
       end
     end
   end

spec/telegram/bot/updates_controller_spec.rb

@@ -26,6 +26,12 @@ RSpec.describe Telegram::Bot::UpdatesController do
       it { should eq [payload_type, payload.values_at(:data)] }
     end
 
+    context 'when payload is poll_answer' do
+      let(:payload_type) { 'poll_answer' }
+      let(:payload) { stub_payload(:poll_id, :user, :option_ids) }
+      it { should eq [payload_type, payload.values_at(:poll_id, :option_ids)] }
+    end
+
     context 'when payload is not supported' do
       let(:payload_type) { '_unsupported_' }
       it { should eq [:unsupported_payload_type, []] }
@@ -39,6 +45,7 @@ RSpec.describe Telegram::Bot::UpdatesController do
       inline_query
       chosen_inline_result
       callback_query
+      poll_answer
     ]
     (described_class::PAYLOAD_TYPES - custom_payload_types).each do |type|
       context "when payload is #{type}" do

telegram-bot.gemspec

@@ -17,15 +17,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.post_install_message = 'Breaking changes in v0.14! ' \
-    'See upgrade guide at https://github.com/telegram-bot-rb/telegram-bot/wiki/Upgrading-to-0.14'
-
   spec.required_ruby_version = '~> 2.0'
 
-  spec.add_dependency 'actionpack', '>= 4.0', '< 6.0'
+  spec.add_dependency 'actionpack', '>= 4.0', '< 6.1'
-  spec.add_dependency 'activesupport', '>= 4.0', '< 6.0'
+  spec.add_dependency 'activesupport', '>= 4.0', '< 6.1'
   spec.add_dependency 'httpclient', '~> 2.7'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'bundler', '> 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
 end