v0.7.1

.travis.yml

@@ -2,8 +2,5 @@ language: ruby
 cache: bundler
 rvm:
   - 2.2.3
-env:
-  - RAILS=4
-  - RAILS=5
 notifications:
   email: false

CHANGELOG.md

@@ -1,27 +1,4 @@
-# Unreleased
+# 0.7.1
-
-- One more description for StaleChat error.
-
-# 0.8.0
-
-- Fixed `#reply_with`, now it sets `reply_to_message_id` as it's supposed to.
-  Added `#respond_with` which works the same way, but doesn't set `reply_to_message_id`.
-  Please, replace all occurrences of `reply_with` to `respond_with` to
-  keep it working the old way.
-- Fixes for Rails 5:
-  - Controller callbacks
-  - Middleware
-  - Setup travis builds
-
-# 0.7.4
-
-- Rails 5 support by @dreyks (#4).
-
-# 0.7.3
-
--  Fixed issues with poller in production (#3)
-
-# 0.7.2
 
 - Bot API 2.1
 - Fixed possible crashes when payload type is not supported.

Gemfile

@@ -1,13 +1,6 @@
 source 'https://rubygems.org'
 gemspec
 
-case ENV['RAILS']
-when '5'
-  gem 'actionpack', '5.0.0.rc1'
-when '4'
-  gem 'actionpack', '~> 4.2'
-end
-
 group :development do
   gem 'sdoc', '~> 0.4.1'
   gem 'pry', '~> 0.10.1'

README.md

@@ -5,8 +5,7 @@
 [![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).
+standalone app. Supposed to be used in webhook-mode in production, and poller-mode
-Supposed to be used in webhook-mode in production, and poller-mode
 in development, but you can use poller in production if you want.
 
 Package contains:
@@ -17,7 +16,6 @@ Package contains:
 - Middleware and routes helpers for production env.
 - Poller with automatic source-reloader for development env.
 - Rake tasks to update webhook urls.
-- Async requests for Telegram and/or Botan API. Let the queue adapter handle errors!
 
 Here is sample [telegram_bot_app](https://github.com/telegram-bot-rb/telegram_bot_app)
 with session, keyboards and inline queries.
@@ -133,10 +131,9 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
 
     # There are `chat` & `from` shortcut methods.
     response = from ? "Hello #{from['username']}!" : 'Hi there!'
-    # There is `respond_with` helper to set `chat_id` from received message:
+    # There is `reply_with` helper to set basic fields
-    respond_with :message, text: response
+    # like `reply_to_message` & `chat_id`.
-    # `reply_with` also sets `reply_to_message_id`:
+    reply_with :message, text: response
-    reply_with :photo, photo: File.open('party.jpg')
   end
 
   private
@@ -191,7 +188,7 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   end
 
   def read
-    respond_with :message, text: session[:text]
+    reply_with :message, text: session[:text]
   end
 
   private
@@ -217,23 +214,23 @@ class Telegram::WebhookController < Telegram::Bot::UpdatesController
   def rename(*)
     # set context for the next message
     save_context :rename
-    respond_with :message, text: 'What name do you like?'
+    reply_with :message, text: 'What name do you like?'
   end
 
   # register context handlers to handle this context
   context_handler :rename do |*words|
     update_name words[0]
-    respond_with :message, text: 'Renamed!'
+    reply_with :message, text: 'Renamed!'
   end
 
   # You can do it in other way:
   def rename(name = nil, *)
     if name
       update_name name
-      respond_with :message, text: 'Renamed!'
+      reply_with :message, text: 'Renamed!'
     else
       save_context :rename
-      respond_with :message, text: 'What name do you like?'
+      reply_with :message, text: 'What name do you like?'
     end
   end
 
@@ -354,11 +351,11 @@ or just add `botan` key in `secrets.yml`:
 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`:
+There are some helpers for controllers in `Telegram::Bot::UpdatesController::Botan`:
 
 ```ruby
 class Telegram::WebhookController < Telegram::Bot::UpdatesController
-  include Telegram::Bot::Botan::ControllerHelpers
+  include Telegram::Bot::UpdatesController::Botan
 
   # This will track with event: action_name & data: payload
   before_action :botan_track_action
@@ -375,20 +372,6 @@ 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.
-- Handle and retry network and other errors with queue adapter.
-- ???
-
-To enable this mode add `async: true` to bot's and botan'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).
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
@@ -400,16 +383,6 @@ 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
-```
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/telegram-bot-rb/telegram-bot.

lib/tasks/telegram-bot.rake

@@ -1,14 +1,9 @@
 namespace :telegram do
   namespace :bot do
-    desc 'Run poller. It broadcasts Rails.logger to STDOUT in dev like `rails s` do. ' \
+    desc 'Run poller'
-      'Use LOG_TO_STDOUT to enable/disable broadcasting.'
+    task poller: :environment do
-    task :poller do
+      console = ActiveSupport::Logger.new(STDERR)
-      ENV['BOT_POLLER_MODE'] = 'true'
+      Rails.logger.extend ActiveSupport::Logger.broadcast console
-      Rake::Task['environment'].invoke
-      if ENV.fetch('LOG_TO_STDOUT') { Rails.env.development? }.present?
-        console = ActiveSupport::Logger.new(STDERR)
-        Rails.logger.extend ActiveSupport::Logger.broadcast console
-      end
       Telegram::Bot::UpdatesPoller.start(ENV['BOT'].try!(:to_sym) || :default)
     end
 

lib/telegram/bot.rb

@@ -13,7 +13,6 @@ module Telegram
     # check response.
     class StaleChat < Error
       DESCRIPTIONS = [
-        'Bot was blocked',
         'bot was kicked',
         "can't write to",
         'group chat is deactivated',
@@ -27,12 +26,9 @@ module Telegram
       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 :UpdatesController,  'telegram/bot/updates_controller'
     autoload :UpdatesPoller,      'telegram/bot/updates_poller'

lib/telegram/bot/async.rb

@@ -1,162 +0,0 @@
-module Telegram
-  module Bot
-    # Telegram & Botan clients can perform requests in async way with
-    # any job adapter (ActiveJob by default). Using Rails you don't need any
-    # additional configuration. However you may want to enable async requests
-    # by default with `async: true` in `secrets.yml`. Botan client doesn't inherit
-    # async setting from client and must be configured separately.
-    #
-    #   telegram:
-    #     bots:
-    #       chat_async:
-    #         token: secret
-    #         async: true # enable async mode for client
-    #         botan: botan_token # in this way botan will not be async
-    #         botan: # in this way - it's in async mode
-    #           token: botan_token
-    #           async: true
-    #
-    # Without Rails To start using async requests
-    # initialize client with `id` kwarg and make sure the client is
-    # accessible via `Teletgram.bots[id]` in job worker. Or just use
-    # `Telegram.bots_config=` for configuration.
-    #
-    # Being in async mode `#request` enqueues job instead to perform
-    # http request instead of performing it directly.
-    # Async behavior is controlled with `#async=` writer
-    # and can be enabled/disabled for the block with `#async`:
-    #
-    #   client = Telegram::Bot::Client.new(**config, async: true)
-    #   client.send_message(message)
-    #   client.async(false) { client.send_message(other_one) }
-    #
-    # `#async=` sets global value for all threads,
-    # 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
-    # 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.
-    module Async
-      # Used to track missing key in a hash in local variable.
-      MISSING_VALUE = Object.new.freeze
-
-      module Job
-        class << self
-          def included(base)
-            base.singleton_class.send :attr_accessor, :client_class
-          end
-        end
-
-        def perform(client_id, *args)
-          client = self.class.client_class.wrap(client_id.to_sym)
-          client.async(false) { client.request(*args) }
-        end
-      end
-
-      module ClassMethods
-        def default_async_job
-          @default_async_job ||= begin
-            begin
-              ApplicationJob
-            rescue NameError
-              raise 'Define ApplicationJob class or setup #async= with custom job class'
-            end
-            klass = Class.new(ApplicationJob) { include Job }
-            klass.client_class = self
-            const_set(:AsyncJob, klass)
-          end
-        end
-
-        # This is used in specs.
-        def default_async_job=(val)
-          @default_async_job = val
-          remove_const(:AsyncJob) if const_defined?(:AsyncJob, false)
-        end
-
-        # Prepares argments for async job. ActiveJob doesn't support
-        # Symbol in argumens. Also we can encode json bodies only once here,
-        # so it would not be unnecessarily serialized-deserialized.
-        #
-        # This is stub method, which returns input. Every client class
-        # must prepare args itself.
-        def prepare_async_args(*args)
-          args
-        end
-
-        # Returns default_async_job if `true` is given,
-        # treats String as a constant name, or bypasses any other values.
-        def prepare_async_val(val)
-          case val
-          when true then default_async_job
-          when String then Object.const_get(val)
-          else val
-          end
-        end
-      end
-
-      class << self
-        def prepended(base)
-          base.extend(ClassMethods)
-        end
-
-        # Transforms symbols to strings in hash values.
-        def prepare_hash(hash)
-          return hash unless hash.is_a?(Hash)
-          hash = hash.dup
-          hash.each { |key, val| hash[key] = val.to_s if val.is_a?(Symbol) }
-        end
-
-        # Thread-local hash to store async config for every client.
-        def thread_store
-          Thread.current[:telegram_bot_async] ||= {}
-        end
-      end
-
-      attr_reader :id
-
-      def initialize(*, id: nil, async: nil, **)
-        @id = id
-        self.async = async
-        super
-      end
-
-      # Sets default async value for all threads.
-      # Uses `self.class.prepare_async_val` to prepare value.
-      def async=(val)
-        @async = self.class.prepare_async_val(val)
-      end
-
-      # Sets async value in a thread-safe way for the block.
-      # Uses `self.class.prepare_async_val` to prepare value.
-      #
-      # If no block is given returns previously set value or the global one,
-      # set by #async=.
-      def async(val = true)
-        thread_key = object_id
-        thread_store = Async.thread_store
-        return thread_store.fetch(thread_key) { @async } unless block_given?
-        begin
-          old_val = thread_store.fetch(thread_key) { MISSING_VALUE }
-          thread_store[thread_key] = self.class.prepare_async_val(val)
-          yield
-        ensure
-          if MISSING_VALUE == old_val
-            thread_store.delete(thread_key)
-          else
-            thread_store[thread_key] = old_val
-          end
-        end
-      end
-
-      # Uses job if #async is set.
-      def request(*args)
-        job_class = async
-        return super unless job_class
-        raise 'Can not enqueue job without client id' unless id
-        job_class.perform_later(id.to_s, *self.class.prepare_async_args(*args))
-      end
-    end
-  end
-end

lib/telegram/bot/botan.rb

@@ -3,37 +3,24 @@ module Telegram
     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)
+      def initialize(token)
         @client = HTTPClient.new
-        @token = token || options[:token]
+        @token = token
       end
 
       def track(event, uid, payload = {})
-        request(:post, TRACK_URI, {name: event, uid: uid}, payload.to_json)
+        res = http_request(
-      end
+          :post,
-
+          TRACK_URI,
-      def request(method, uri, query = {}, body = nil)
+          {token: token, name: event, uid: uid},
-        res = http_request(method, uri, query.merge(token: token), body)
+          payload.to_json,
+        )
         status = res.status
         return JSON.parse(res.body) if 300 > status
         result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
@@ -44,10 +31,6 @@ module Telegram
       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, **)
-          super
-          @botan = Botan.wrap(botan, id: id) if botan
-        end
-      end
-    end
-  end
-end

lib/telegram/bot/client.rb

@@ -2,6 +2,7 @@ require 'json'
 require 'httpclient'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/hash/keys'
+require 'telegram/bot/debug_client'
 
 module Telegram
   module Bot
@@ -9,14 +10,23 @@ module Telegram
       URL_TEMPLATE = 'https://api.telegram.org/bot%s/'.freeze
 
       autoload :TypedResponse, 'telegram/bot/client/typed_response'
-      extend Initializers
-      prepend Async
-      prepend Botan::ClientHelpers
       include DebugClient
 
       class << self
-        def by_id(id)
+        # Accepts different options to initialize bot.
-          Telegram.bots[id]
+        def wrap(input)
+          case input
+          when self then input
+          when Array then input.map(&method(__callee__))
+          when Hash then
+            input = input.stringify_keys
+            new input['token'], input['username'], botan: input['botan']
+          when Symbol
+            Telegram.bots[input] or
+              raise "Bot #{input} not configured, check Telegram.bots_config."
+          else
+            new(input)
+          end
         end
 
         # Prepend TypedResponse module.
@@ -31,19 +41,16 @@ module Telegram
             body[k] = val.to_json if val.is_a?(Hash) || val.is_a?(Array)
           end
         end
-
-        def prepare_async_args(action, body = {})
-          [action.to_s, Async.prepare_hash(prepare_body(body))]
-        end
       end
 
-      attr_reader :client, :token, :username, :base_uri
+      attr_reader :client, :token, :username, :base_uri, :botan
 
-      def initialize(token = nil, username = nil, **options)
+      def initialize(token, username = nil, botan: nil)
         @client = HTTPClient.new
-        @token = token || options[:token]
+        @token = token
-        @username = username || options[:username]
+        @username = username
-        @base_uri = format URL_TEMPLATE, self.token
+        @base_uri = format URL_TEMPLATE, token
+        @botan = Botan.new(botan) if botan
       end
 
       def request(action, body = {}) # rubocop:disable PerceivedComplexity
@@ -64,16 +71,11 @@ module Telegram
         answerCallbackQuery
         answerInlineQuery
         forwardMessage
-        getChat
-        getChatAdministrators
-        getChatMember
-        getChatMembersCount
         getFile
         getMe
         getUpdates
         getUserProfilePhotos
         kickChatMember
-        leaveChat
         sendAudio
         sendChatAction
         sendContact

lib/telegram/bot/client_stub.rb

@@ -9,7 +9,7 @@ module Telegram
           if self == ClientStub || !ClientStub.stub_all?
             super
           else
-            ClientStub.new(*args)
+            ClientStub.new(args[1])
           end
         end
       end
@@ -34,8 +34,8 @@ module Telegram
         end
       end
 
-      def initialize(token = nil, username = nil, **options)
+      def initialize(username = nil)
-        @username = username || options[:username] || token
+        @username = username
         reset
       end
 

lib/telegram/bot/config_methods.rb

@@ -14,21 +14,14 @@ module Telegram
       # It just tells routes helpers whether to add routed bots to
       # Bot::UpdatesPoller, so their config will be available by bot key in
       # Bot::UpdatesPoller.start.
-      #
-      # It's enabled by default in Rails dev environment and `rake telegram:bot:poller`
-      # task. Use `BOT_POLLER_MODE=true` envvar to set it manually.
       def bot_poller_mode?
         return @bot_poller_mode if defined?(@bot_poller_mode)
-        @bot_poller_mode = ENV.fetch('BOT_POLLER_MODE') do
+        Rails.env.development? if defined?(Rails)
-          Rails.env.development? if defined?(Rails)
-        end
       end
 
       # Hash of bots made with bots_config.
       def bots
-        @bots ||= bots_config.each_with_object({}) do |(id, config), h|
+        @bots ||= bots_config.transform_values(&Client.method(:wrap))
-          h[id] = Client.wrap(config, id: id)
-        end
       end
 
       # Default bot.
@@ -36,26 +29,17 @@ module Telegram
         @bot ||= bots[:default]
       end
 
-      # Hash of botan clients made from #bots.
-      def botans
-        @botans ||= bots.transform_values(&:botan)
-      end
-
       # Returns config for .bots method. By default uses `telegram['bots']` section
       # from `secrets.yml` merging `telegram['bot']` at `:default` key.
       #
       # Can be overwritten with .bots_config=
       def bots_config
-        @bots_config ||=
+        return @bots_config if @bots_config
-          if defined?(Rails)
+        telegram_config = Rails.application.secrets[:telegram]
-            telegram_config = Rails.application.secrets[:telegram] || {}
+        (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
-            (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
+          default = telegram_config['bot']
-              default = telegram_config['bot']
+          config[:default] = default if default
-              config[:default] = default if default
+        end
-            end
-          else
-            {}
-          end
       end
 
       # Resets all cached bots and their configs.
@@ -63,7 +47,6 @@ module Telegram
         @bots = nil
         @bot = nil
         @bots_config = nil
-        @botans = nil
       end
     end
   end

lib/telegram/bot/initializers.rb

@@ -1,19 +0,0 @@
-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/middleware.rb

@@ -1,8 +1,6 @@
 require 'active_support/concern'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/json'
 require 'action_dispatch/http/mime_type'
-require 'action_dispatch/http/request'
+require 'action_dispatch/middleware/params_parser'
 
 module Telegram
   module Bot
@@ -15,8 +13,7 @@ module Telegram
       end
 
       def call(env)
-        request = ActionDispatch::Request.new(env)
+        update = env['action_dispatch.request.request_parameters']
-        update = request.request_parameters
         controller.dispatch(bot, update)
         [200, {}, ['']]
       end

lib/telegram/bot/routes_helper.rb

@@ -20,7 +20,7 @@ module Telegram
         # Replaces colon with underscore so rails don't treat it as
         # route parameter.
         def escape_token(token)
-          token && token.tr(':', '_')
+          token.tr(':', '_')
         end
       end
 

lib/telegram/bot/updates_controller.rb

@@ -21,7 +21,7 @@ module Telegram
     #     end
     #
     #     def help(*)
-    #       respond_with :message, text:
+    #       reply_with :message, text:
     #     end
     #
     # To process plain text messages (without commands) or other updates just
@@ -29,7 +29,7 @@ module Telegram
     # as an argument.
     #
     #     def message(message)
-    #       respond_with :message, text: "Echo: #{message['text']}"
+    #       reply_with :message, text: "Echo: #{message['text']}"
     #     end
     #
     #     def inline_query(query)
@@ -59,10 +59,11 @@ module Telegram
       require 'telegram/bot/updates_controller/reply_helpers'
       autoload :CallbackQueyContext, 'telegram/bot/updates_controller/callback_query_context'
       autoload :MessageContext, 'telegram/bot/updates_controller/message_context'
+      autoload :Botan, 'telegram/bot/updates_controller/botan'
 
       include AbstractController::Callbacks
       # Redefine callbacks with default terminator.
-      if ActiveSupport::VERSION::MAJOR >= 5
+      if ActiveSupport.gem_version >= Gem::Version.new('5')
         define_callbacks  :process_action,
                           skip_after_callbacks_if_terminated: true
       else

lib/telegram/bot/updates_controller/botan.rb

@@ -1,8 +1,8 @@
 module Telegram
   module Bot
-    class Botan
+    class UpdatesController
       # Helpers for botan.io metrics.
-      module ControllerHelpers
+      module Botan
         class MissingFrom < Error; end
 
         protected

lib/telegram/bot/updates_controller/instrumentation.rb

@@ -6,7 +6,7 @@ module Telegram
       module Instrumentation
         class << self
           def prepended(base)
-            base.send :config_accessor, :logger
+            base.config_accessor :logger
             base.extend ClassMethods
           end
 
@@ -35,13 +35,13 @@ module Telegram
           end
         end
 
-        def respond_with(type, *)
+        def reply_with(type, *)
-          Instrumentation.instrument(:respond_with, type: type) { super }
+          Instrumentation.instrument(:reply_with, type: type) { super }
         end
 
         %i(answer_callback_query answer_inline_query).each do |type|
           define_method(type) do |*args|
-            Instrumentation.instrument(:respond_with, type: type) { super(*args) }
+            Instrumentation.instrument(:reply_with, type: type) { super(*args) }
           end
         end
 

lib/telegram/bot/updates_controller/log_subscriber.rb

@@ -22,8 +22,8 @@ module Telegram
           end
         end
 
-        def respond_with(event)
+        def reply_with(event)
-          info { "Responded with #{event.payload[:type]}" }
+          info { "Replied with #{event.payload[:type]}" }
         end
 
         def halted_callback(event)

lib/telegram/bot/updates_controller/reply_helpers.rb

@@ -2,23 +2,21 @@ module Telegram
   module Bot
     class UpdatesController
       module ReplyHelpers
-        # Helper to call bot's `send_#{type}` method with already set `chat_id`:
+        # Helper to call bot's `send_#{type}` method with already set `chat_id` and
+        # `reply_to_message_id`:
         #
-        #     respond_with :message, text: 'Hello!'
+        #     reply_with :message, text: 'Hello!'
-        #     respond_with :message, text: '__Hello!__', parse_mode: :Markdown
+        #     reply_with :message, text: '__Hello!__', parse_mode: :Markdown
-        #     respond_with :photo, photo: File.open(photo_to_send), caption: "It's incredible!"
+        #     reply_with :photo, photo: File.open(photo_to_send), caption: "It's incredible!"
-        def respond_with(type, params)
-          chat = self.chat
-          chat_id = chat && chat['id'] or raise 'Can not respond_with when chat is not present'
-          bot.public_send("send_#{type}", params.merge(chat_id: chat_id))
-        end
-
-        # Same as respond_with but also sets `reply_to_message_id`.
         def reply_with(type, params)
+          method = "send_#{type}"
+          chat = self.chat
           payload = self.payload
-          message_id = payload && payload['message_id']
+          params = params.merge(
-          params = params.merge(reply_to_message_id: message_id) if message_id
+            chat_id: (chat && chat['id'] or raise 'Can not reply_with when chat is not present'),
-          respond_with(type, params)
+            reply_to_message: payload && payload['message_id'],
+          )
+          bot.public_send(method, params)
         end
 
         # Same as reply_with, but for inline queries.

lib/telegram/bot/updates_poller.rb

@@ -64,7 +64,7 @@ module Telegram
       end
 
       def fetch_updates
-        response = bot.async(false) { bot.get_updates(offset: offset, timeout: timeout) }
+        response = bot.get_updates(offset: offset, timeout: timeout)
         return unless response['ok'] && response['result'].any?
         reload! do
           response['result'].each do |update|
@@ -77,25 +77,11 @@ module Telegram
 
       def reload!
         return yield unless reload
-        reloading_code do
+        ActionDispatch::Reloader.prepare!
-          if controller.is_a?(Class) && controller.name
+        if controller.is_a?(Class) && controller.name
-            @controller = Object.const_get(controller.name)
+          @controller = Object.const_get(controller.name)
-          end
-          yield
-        end
-      end
-
-      if defined?(Rails) && Rails.application.respond_to?(:reloader)
-        def reloading_code
-          Rails.application.reloader.wrap do
-            yield
-          end
-        end
-      else
-        def reloading_code
-          ActionDispatch::Reloader.prepare!
-          yield.tap { ActionDispatch::Reloader.cleanup! }
         end
+        yield.tap { ActionDispatch::Reloader.cleanup! }
       end
     end
   end

lib/telegram/bot/version.rb

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

spec/spec_helper.rb

@@ -17,8 +17,6 @@ require 'telegram/bot'
 require 'telegram/bot/updates_controller/rspec_helpers'
 require 'telegram/bot/types'
 
-Dir[GEM_ROOT.join('spec/support/**/*.rb')].each { |f| require f }
-
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     # This option will default to `true` in RSpec 4. It makes the `description`

spec/support/examples/async.rb

@@ -1,143 +0,0 @@
-RSpec.shared_examples 'async' do |request_args: -> {}|
-  let(:instance) { described_class.new(token: token, id: id, async: async) }
-  let(:id) { :default_bot }
-  let(:async) { true }
-  let!(:application_job_class) do
-    klass = Class.new do
-      def self.perform_later(*)
-      end
-    end
-    klass.tap { |x| stub_const('ApplicationJob', x) }
-  end
-  after { described_class.default_async_job = nil }
-
-  describe '#async' do
-    subject { ->(*args, &block) { instance.async(*args, &block) } }
-    its(:call) { should eq described_class.default_async_job }
-
-    context 'when async is disabled' do
-      let(:async) { false }
-      its(:call) { should eq false }
-    end
-
-    context 'when using with block' do
-      it 'sets value inside block' do
-        expect do
-          expect do
-            subject.call(false) do
-              expect do
-                subject.call(nil) { expect(subject[]).to eq nil }
-              end.to_not change(&subject).from false
-              raise 'TestError'
-            end
-          end.to raise_error(/TestError/)
-        end.to_not change(instance, :async).from(described_class.default_async_job)
-      end
-    end
-
-    context 'in multi-threaded environment' do
-      it 'changes only in current thread' do
-        thread = nil
-        expect do
-          thread = Thread.new do
-            expect do
-              subject.call(false) do
-                expect(subject[]).to eq false
-              end
-            end.to_not change(instance, :async).from(described_class.default_async_job)
-            sleep 0.2
-          end
-        end.to_not change(instance, :async).from(described_class.default_async_job)
-        thread.join
-      end
-
-      it 'uses default value after block' do
-        thread = Thread.new do
-          subject.call(false) {}
-          expect { sleep 0.2 }.to change(instance, :async).
-            from(described_class.default_async_job).to(nil)
-        end
-        sleep 0.1
-        instance.async = nil
-        thread.join
-      end
-    end
-  end
-
-  describe '#async=' do
-    subject { ->(val = new_val) { instance.async = val } }
-    let(:async) {}
-
-    context 'when true is given' do
-      let(:new_val) { true }
-      it { should change(instance, :async).to described_class.default_async_job }
-    end
-
-    context 'when false is given' do
-      let(:new_val) { false }
-      it { should change(instance, :async).to false }
-    end
-
-    context 'when string is given' do
-      let(:new_val) { 'Telegram::Bot::Client' }
-      it { should change(instance, :async).to Object.const_get(new_val) }
-    end
-
-    context 'in multi-threaded environment' do
-      subject { ->(val = new_val) { Thread.new { instance.async = val }.join } }
-      let(:new_val) { true }
-      it { should change(instance, :async).to described_class.default_async_job }
-    end
-  end
-
-  describe '.default_async_job' do
-    subject { described_class.default_async_job }
-    its(:superclass) { should eq application_job_class }
-    it { should include Telegram::Bot::Async::Job }
-    its(:client_class) { should eq described_class }
-
-    context 'when ApplicationJob is not defined' do
-      let(:application_job_class) {}
-      it { expect { subject }.to raise_error(/Define ApplicationJob/) }
-    end
-  end
-
-  describe '#request' do
-    subject { ->(*args) { instance.request(*(args.empty? ? self.args : args)) } }
-    let(:args, &request_args)
-    let(:result) { double(:result) }
-
-    shared_examples 'enqueues job' do
-      it 'enqueues job' do
-        expect(instance).to_not receive(:http_request)
-        expect(described_class).to receive(:prepare_async_args).with(*args) { args }
-        expect(instance.async).to receive(:perform_later).with(id.to_s, *args) { result }
-        expect(subject.call).to eq result
-      end
-    end
-
-    include_examples 'enqueues job'
-
-    context 'with custom job class' do
-      let(:async) { double(:job_class) }
-      include_examples 'enqueues job'
-    end
-
-    context 'when id is not set' do
-      let(:id) {}
-      it { should raise_error(/Can not enqueue/) }
-    end
-
-    context 'when async is disabled' do
-      let(:async) { false }
-      let(:result) { double(status: 200, body: '{"test":"ok"}') }
-      let(:args, &request_args)
-
-      it 'performs request immediately' do
-        expect(instance).to receive(:request).with(*args).and_call_original
-        expect(instance).to receive(:http_request) { result }
-        expect(subject[]).to eq 'test' => 'ok'
-      end
-    end
-  end
-end

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/async_spec.rb

@@ -1,28 +0,0 @@
-RSpec.describe Telegram::Bot::Async::Job do
-  let(:job_class) do
-    described_class = self.described_class
-    client_class = self.client_class
-    Class.new do
-      include described_class
-      self.client_class = client_class
-    end
-  end
-  let(:client_class) { Telegram::Bot::Client }
-  let(:instance) { job_class.new }
-
-  describe '#perform' do
-    subject { instance.perform(id, *args) }
-    let(:id) { 'bot_id' }
-    let(:args) { [double(:action), {body: :content}] }
-    let(:client) { Telegram::Bot::Client.new(async: custom_job_class) }
-    let(:custom_job_class) { Class.new }
-    let(:result) { double(status: 200, body: '{"test":"ok"}') }
-
-    it 'finds client and performs request' do
-      expect(client_class).to receive(:wrap).with(id.to_sym) { client }
-      expect(client).to receive(:request).with(*args).and_call_original
-      expect(client).to receive(:http_request) { result }
-      should eq 'test' => 'ok'
-    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_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
-  include_examples '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

@@ -3,8 +3,71 @@ RSpec.describe Telegram::Bot::Client do
   let(:token) { 'token' }
   let(:botan_token) { double(:botan_token) }
 
-  include_examples 'initializers'
+  describe '.wrap' do
-  include_examples 'async', request_args: -> { [double(:action), {body: :content}] }
+    subject { described_class.wrap(input) }
+    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
+    end
+
+    context 'when input is a hash' do
+      let(:input) { {token: token, username: username, ignore: :ignore} }
+
+      it 'extracts token & username' do
+        expect(described_class).to receive(:new).
+          with(token, username, botan: nil) { result }
+        should eq result
+      end
+
+      context 'when `botan` is given' do
+        let(:input) { super().merge(botan: botan_token) }
+
+        it 'passes it to initializer' do
+          expect(described_class).to receive(:new).
+            with(token, username, botan: botan_token) { 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) { :bot_1 }
+      before { allow(Telegram).to receive(:bots) { {bot_1: instance} } }
+      it { should eq Telegram.bots[:bot_1] }
+
+      context 'and there is no such bot' do
+        let(:input) { :invalid }
+        it { expect { subject }.to raise_error(/not configured/) }
+      end
+    end
+
+    context 'when input is an array' do
+      let!(:input) { ['other_token', instance, token: token, username: username] }
+      let(:result_2) { double(:result_2) }
+
+      it 'calls wrap for every element' do
+        expect(described_class).to receive(:new).with('other_token') { result }
+        expect(described_class).to receive(:new).with(token, username, botan: nil) { result_2 }
+        should eq [result, instance, result_2]
+      end
+    end
+  end
 
   describe '.prepare_body' do
     subject { described_class.prepare_body(input) }
@@ -25,27 +88,14 @@ RSpec.describe Telegram::Bot::Client do
     end
   end
 
-  describe '.prepare_async_args' do
+  describe '#botan' do
-    subject { described_class.prepare_async_args(*input) }
+    subject { instance.botan }
-    let(:input) { [:action, a: 1, b: :sym, c: [:other], 'd' => 'str'] }
+    it { should eq nil }
-    it { should eq ['action', a: 1, b: 'sym', c: '["other"]', 'd' => 'str'] }
-  end
 
-  describe '.new' do
+    context 'when botan token is set' do
-    subject { described_class.new(*args) }
+      let(:instance) { described_class.new token, botan: botan_token }
-
+      it { should be_instance_of Telegram::Bot::Botan }
-    context 'when multiple args are given' do
+      its(:token) { should eq botan_token }
-      let(:args) { %w(secret superbot) }
-      its(:token) { should eq args[0] }
-      its(:username) { should eq args[1] }
-      its(:base_uri) { should include args[0] }
-    end
-
-    context 'when hash is given' do
-      let(:args) { [token: 'secret', username: 'superbot'] }
-      its(:token) { should eq args[0][:token] }
-      its(:username) { should eq args[0][:username] }
-      its(:base_uri) { should include args[0][:token] }
     end
   end
 end

spec/telegram/bot/client_stub_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Telegram::Bot::ClientStub do
   describe '#stub_all!' do
     let(:client) { Telegram::Bot::Client.new('token', 'bot_name') }
-    let(:clients) { ['token', token: 'token2'].map(&Telegram::Bot::Client.method(:wrap)) }
+    let(:clients) { Telegram::Bot::Client.wrap(['token', token: 'token2']) }
 
     shared_examples 'constructors' do |expected_class|
       it 'makes Client.new return ClientStub' do
@@ -9,7 +9,7 @@ RSpec.describe Telegram::Bot::ClientStub do
         expect(client.username).to eq 'bot_name'
       end
 
-      it 'makes Client.wrap return ClientStub' do
+      it 'makes Client.wrap raturn ClientStub' do
         expect(clients).to contain_exactly instance_of(expected_class),
           instance_of(expected_class)
       end
@@ -35,19 +35,4 @@ RSpec.describe Telegram::Bot::ClientStub do
       include_examples 'constructors', Telegram::Bot::Client
     end
   end
-
-  describe '#new' do
-    subject { described_class.new(*args) }
-
-    context 'when only username is given' do
-      let(:args) { 'superbot' }
-      its(:username) { should eq args }
-    end
-
-    context 'when username and token are given' do
-      let(:args) { %w(token superbot) }
-      its(:token) { should eq nil }
-      its(:username) { should eq args[1] }
-    end
-  end
 end

spec/telegram/bot/config_methods_spec.rb

@@ -1,94 +0,0 @@
-RSpec.describe Telegram::Bot::ConfigMethods do
-  let(:registry) do
-    Object.new.tap do |x|
-      x.extend described_class
-      x.bots_config = config
-    end
-  end
-  let(:config) do
-    {
-      default: 'default_token',
-      chat: {
-        token: 'chat_token',
-        username: 'Chat',
-        botan: 'chat_botan_token',
-      },
-      other_chat: {
-        'token' => 'other_chat_token',
-        'username' => 'OtherChat',
-        'botan' => 'other_chat_botan_token',
-      },
-    }
-  end
-
-  describe '#bot' do
-    subject { registry.bot }
-    it { should eq registry.bots[:default] }
-  end
-
-  describe '#bots' do
-    context 'configured by token' do
-      subject { registry.bots[:default] }
-      its(:id) { should eq :default }
-      its(:token) { should eq config[:default] }
-    end
-
-    context 'configured by hash' do
-      subject { registry.bots[:chat] }
-      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
-      subject { registry.bots[:other_chat] }
-      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
-
-  describe '#bots_config' do
-    subject { registry.bots_config }
-    it { should eq config }
-
-    context 'when not configured' do
-      let(:registry) { Object.new.tap { |x| x.extend described_class } }
-      it { should eq({}) }
-
-      context 'in rails environment' do
-        before { stub_const('Rails', double(application: double(secrets: secrets))) }
-        let(:secrets) { {} }
-        it { should eq({}) }
-
-        context 'when there is telegram section in secrets' do
-          let(:secrets) { {telegram: config.stringify_keys} }
-          let(:config) do
-            {
-              bot: double(:bot_config),
-              bots: {
-                chat: double(:chat_config),
-                other_chat: double(:other_chat_config),
-              },
-            }
-          end
-          it { should include default: config[:bot] }
-          it { should include config[:bots] }
-        end
-      end
-    end
-  end
-end

spec/telegram/bot/middleware_spec.rb

@@ -1,5 +1,3 @@
-require 'rack/mock'
-
 RSpec.describe Telegram::Bot::Middleware do
   let(:instance) { described_class.new bot, controller }
   let(:bot) { double(:bot) }
@@ -8,25 +6,10 @@ RSpec.describe Telegram::Bot::Middleware do
   describe '#call' do
     subject { instance.call(env) }
     let(:env) { {'action_dispatch.request.request_parameters' => json_body} }
-    let(:update) { {'message' => {'id' => 1}} }
+    let(:json_body) { double(:json_body) }
-    let(:env) do
-      Rack::MockRequest.env_for('/',
-        method: :post,
-        input:  JSON.dump(update),
-        'CONTENT_TYPE' => 'application/json',
-      )
-    end
-
-    require 'action_pack/version'
-    if ActionPack::VERSION::MAJOR < 5
-      # Before Rails 5, params are parsed in middleware.
-      # In Rails 5, they are parsed in Request#request_parameters.
-      require 'action_dispatch/middleware/params_parser'
-      let(:instance) { ActionDispatch::ParamsParser.new(super()) }
-    end
 
     it 'calls dispatch on controller' do
-      expect(controller).to receive(:dispatch).with(bot, update)
+      expect(controller).to receive(:dispatch).with(bot, json_body)
       subject
     end
 

spec/telegram/bot/routes_helper_spec.rb

@@ -50,9 +50,8 @@ RSpec.describe Telegram::Bot::RoutesHelper do
 
     def assert_routes(*expected) # rubocop:disable AbcSize
       expected.each do |(bot, controller, route_name, options)|
-        expected_path = options.delete(:path) || "telegram/#{bot.token}"
         expect(mapper).to receive(:post) do |path, params|
-          expect(path).to eq expected_path
+          expect(path).to eq "telegram/#{bot.token}"
           middleware = params[:to]
           expect(middleware.controller).to eq(controller)
           expect(middleware.bot.token).to eq(bot.token)
@@ -71,27 +70,6 @@ RSpec.describe Telegram::Bot::RoutesHelper do
         assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
                       [other_bot, controller, 'other_telegram_webhook', option: :val]
       end
-
-      context 'and bot does not have configured token' do
-        let(:bot) { create_bot(nil) }
-        it 'creates routes for every bot and this controller' do
-          assert_routes [bot, controller, 'default_telegram_webhook', option: :val],
-                        [other_bot, controller, 'other_telegram_webhook', option: :val]
-        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',
-          ], [other_bot, controller, 'other_telegram_webhook', option: :val]
-        end
-      end
     end
 
     context 'when called with hash' do

spec/telegram/bot/updates_controller/botan_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe Telegram::Bot::Botan::ControllerHelpers do
+RSpec.describe Telegram::Bot::UpdatesController::Botan do
   include_context 'telegram/bot/updates_controller'
   let(:controller_class) do
     described_class = self.described_class

spec/telegram/bot/updates_controller/reply_helpers_spec.rb

@@ -1,49 +1,36 @@
 RSpec.describe Telegram::Bot::UpdatesController do
   include_context 'telegram/bot/updates_controller'
-  let(:params) { {arg: 1, 'other_arg' => 2} }
-  let(:respond_type) { :photo }
-  let(:result) { double(:result) }
-  let(:payload_type) { :message }
-  let(:payload) { {message_id: double(:message_id)} }
-  let(:chat) { {'id' => double(:chat_id)} }
-
-  shared_examples 'missing chat' do
-    context 'when chat is missing' do
-      let(:payload_type) { :some_type }
-      it { expect { subject }.to raise_error(/chat/) }
-    end
-  end
-
-  describe '#respond_with' do
-    subject { controller.respond_with respond_type, params }
-    include_examples 'missing chat'
-
-    it 'sets chat_id & reply_to_message_id' do
-      expect(controller).to receive(:chat) { chat }
-      expect(bot).to receive("send_#{respond_type}").
-        with(params.merge(chat_id: chat['id'])) { result }
-      should eq result
-    end
-  end
 
   describe '#reply_with' do
-    subject { controller.reply_with respond_type, params }
+    subject { controller.reply_with type, params }
-    include_examples 'missing chat'
+    let(:params) { {arg: 1, 'other_arg' => 2} }
+    let(:type) { :photo }
+    let(:result) { double(:result) }
+    let(:payload_type) { :message }
+    let(:payload) { {message_id: double(:message_id)} }
+    let(:chat) { {'id' => double(:chat_id)} }
 
-    it 'sets chat_id & reply_to_message_id' do
+    it 'sets chat_id & reply_to_message' do
       expect(controller).to receive(:chat) { chat }
-      expect(bot).to receive("send_#{respond_type}").with(params.merge(
+      expect(bot).to receive("send_#{type}").with(params.merge(
         chat_id: chat['id'],
-        reply_to_message_id: payload[:message_id],
+        reply_to_message: payload[:message_id],
       )) { result }
       should eq result
     end
 
+    context 'when chat is missing' do
+      let(:payload_type) { :some_type }
+      it { expect { subject }.to raise_error(/chat/) }
+    end
+
     context 'when update is not set' do
       let(:update) { {chat: chat} }
-      it 'sets chat_id' do
+      it 'sets chat_id & reply_to_message' do
-        expect(bot).to receive("send_#{respond_type}").
+        expect(bot).to receive("send_#{type}").with(params.merge(
-          with(params.merge(chat_id: chat['id'])) { result }
+          chat_id: chat['id'],
+          reply_to_message: nil,
+        )) { result }
         should eq result
       end
     end

spec/telegram/bot/updates_controller_spec.rb

@@ -225,12 +225,12 @@ RSpec.describe Telegram::Bot::UpdatesController do
       it { should change(controller, :acted).to true }
       its(:call) { should eq [nil, nil, args] }
 
-      context 'when callback halts chain' do
+      context 'when callback returns false' do
         before do
           controller_class.prepend(Module.new do
             def hook
               super
-              ActiveSupport::VERSION::MAJOR >= 5 ? throw(:abort) : false
+              false
             end
           end)
         end

spec/telegram/bot_spec.rb

@@ -17,9 +17,6 @@ RSpec.describe Telegram::Bot do
         expect(subject.call(
           'description' => 'Bad request: group chat is deactivated'
         )).to eq true
-        expect(subject.call(
-          'description' => 'Forbidden: Bot was blocked by the user'
-        )).to eq true
       end
     end
   end

telegram-bot.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '~> 2.0'
 
-  spec.add_dependency 'activesupport', '>= 4.0', '< 5.1'
+  spec.add_dependency 'activesupport', '~> 4.0'
-  spec.add_dependency 'actionpack', '>= 4.0', '< 5.1'
+  spec.add_dependency 'actionpack', '~> 4.0'
   spec.add_dependency 'httpclient', '~> 2.7'
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'