telegram-bot 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d30226c4449c1cbe5ebd12cf4ec90203532fea57
+  data.tar.gz: 8fc903c5a4cf84377bf258584f7d2adf04741ef5
+SHA512:
+  metadata.gz: 1a436e375c7b22d18c5c18be2a55e4189f909e473106350b0c8e7d0d8336b55e5b76c5cf625800e753627715f665300049c282f96c74e48200ed39d36f9e1094
+  data.tar.gz: d2c166e8ffaeec12fb83a3a391cc7aa05b431ad5a6151614ca0bbe3449ce0f4c5bf5e33538cbb0ba1d75923dc86e4ae600dc971755367f22916abf3834df38c6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,27 @@
+Rails: {Enabled: true}
+
+Style/Alias: {Enabled: false}
+Style/AlignParameters:
+  # Disable, till rubocop supports combination of styles.
+  # Use one of this styles where appropriate, keep it clean, compact and readable.
+  Enabled: false
+  # EnforcedStyle:
+  # - with_first_parameter
+  # - with_fixed_indentation
+Style/ClosingParenthesisIndentation: {Enabled: false}
+Style/Documentation: {Enabled: false}
+Style/DotPosition: {EnforcedStyle: trailing}
+Style/IfUnlessModifier: {Enabled: false}
+Style/ModuleFunction: {Enabled: false}
+Style/MultilineOperationIndentation: {EnforcedStyle: indented}
+Style/NestedParenthesizedCalls: {Enabled: false}
+Style/PredicateName: {Enabled: false}
+Style/SignalException: {EnforcedStyle: only_raise}
+Style/SpaceInsideHashLiteralBraces: {EnforcedStyle: no_space}
+Style/TrailingCommaInArguments: {Enabled: false}
+Style/TrailingCommaInLiteral: {EnforcedStyleForMultiline: comma}
+
+Metrics/AbcSize: {Max: 21}
+Metrics/LineLength: {Max: 100}
+Metrics/MethodLength: {Max: 30}
+Metrics/CyclomaticComplexity: {Max: 8}

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.3
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'sdoc', '~> 0.4.1'
+  gem 'pry', '~> 0.10.1'
+  gem 'pry-byebug', '~> 3.2.0'
+
+  gem 'rspec', '~> 3.3.0'
+  gem 'rspec-its', '~> 1.1.0'
+
+  gem 'rubocop', '~> 0.37.0'
+
+  gem 'coveralls', '~> 0.8.2', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Max Melentiev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# Telegram::Bot
+
+[![Gem Version](https://badge.fury.io/rb/telegram-bot.svg)](http://badge.fury.io/rb/telegram-bot)
+[![Code Climate](https://codeclimate.com/github/printercu/telegram-bot/badges/gpa.svg)](https://codeclimate.com/github/printercu/telegram-bot)
+[![Build Status](https://travis-ci.org/printercu/telegram-bot.svg)](https://travis-ci.org/printercu/telegram-bot)
+
+Tools for developing bot for Telegram. Best used with Rails, but can be be used in
+standalone app. Supposed to be used in webhook-mode in production, and poller mode
+in development, but you can use poller in production if you want.
+
+Package contains:
+
+- Ligthweight client to bot API (with fast and thread-safe
+  [httpclient](https://github.com/nahi/httpclient) is under the hood.)
+- Controller with message parser. Allows to write separate methods for each command.
+- Middleware and routes helpers for production env.
+- Poller with automatic source-reloader for development env.
+- Rake tasks to update webhook urls.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'telegram-bot'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install telegram-bot
+
+## Usage
+
+### Configuration
+
+Add `telegram` section into `secrets.yml`:
+
+```yml
+telegram:
+  bots:
+    # just set the token
+    chat: TOKEN_1
+    # or add username to support commands with mentions (/help@ChatBot)
+    auction:
+      token: TOKEN_2
+      username: ChatBot
+
+  # Single bot can be specified like this
+  bot: TOKEN
+  # or
+  bot:
+    token: TOKEN
+    username: SomeBot
+```
+
+### Client
+
+From now clients will be accessible with `Telegram.bots[:chat]` or `Telegram.bots[:auction]`.
+Single bot can be accessed with `Telegram.bot` or `Telegram.bots[:default]`.
+
+You can create clients manually with `Telegram::Bot.new(token, username)`.
+Username is optional and used only to parse commands with mentions.
+
+Client has all available methods in underscored style
+(`answer_inline_query` instead of `answerInlineQuery`).
+All this methods just post given params to specific URL.
+
+```ruby
+bot.send_message chat_id: chat_id, text: 'Test'
+```
+
+### Controller
+
+```ruby
+class Telegram::WebhookController < Telegram::Bot::UpdatesController
+  # use callbacks like in any other controllers
+  around_action :set_locale
+
+  # Every update can have one of: message, inline_query & chosen_inline_result.
+  # Define method with same name to respond to this updates.
+  def message(message)
+    # message can be also accessed via instance method
+    message == self.payload # true
+    # store_message(message['text'])
+  end
+
+  # Define public methods to respond to commands.
+  # Command arguments will be parsed and passed to the method.
+  # Be sure to use splat args and default values to not get errors when
+  # someone passed more or less arguments in the message.
+  #
+  # For some commands like /message or /123 method names should start with
+  # `on_` to avoid conflicts.
+  def start(data = nil, *)
+    # do_smth_with(data)
+
+    # There are `chat` & `from` shortcut methods.
+    response = from ? "Hello #{from['username']}!" : 'Hi there!'
+    # There is `reply_with` helper to set basic fields
+    # like `reply_to_message` & `chat_id`.
+    reply_with :message, text: response
+  end
+
+  private
+
+  def set_locale(&block)
+    I18n.with_locale(locale_for_update, &block)
+  end
+
+  def locale_for_update
+    if from
+      # locale for user
+    elsif chat
+      # locale for chat
+    end
+  end
+end
+```
+
+### Routes
+
+Use `telegram_webhooks` helper to add routes. It will create routes for bots
+at "telegram/#{bot.token}" path.
+
+```ruby
+# Create routes for all Telegram.bots to use same controller:
+telegram_webhooks TelegramController
+
+# Or pass custom bots usin any of supported config options:
+telegram_webhooks TelegramController,
+                 bot,
+                 {token: token, username: username},
+                 other_bot_token
+
+# Use different controllers for each bot:
+telegram_webhooks bot => TelegramChatController,
+                  other_bot => TelegramAuctionController
+
+# telegram_webhooks creates named routes.
+# Route name depends on `Telegram.bots`.
+# When there is single bot it will use 'telegram_webhook'.
+# When there are it will use bot's key in the `Telegram.bots` as prefix
+# (eg. `chat_telegram_webhook`).
+# You can override this options or specify others:
+telegram_webhooks TelegramController, as: :my_webhook
+telegram_webhooks bot => [TelegramChatController, as: :chat_webhook],
+                  other_bot => [TelegramAuctionController,
+```
+
+For Rack applications you can also use `Telegram::Bot::Middleware` or just
+call `.dispatch(bot, update)` on controller.
+
+### Development & Debugging
+
+Use `rake telegram:bot:poller BOT=chat` to run poller. It'll automatically load
+changes without restart in development env. This task will not if you don't use
+`telegram_webhooks`.
+
+You can run poller manually with
+`Telegram::Bot::UpdatesPoller.start(bot, controller_class)`.
+
+### Deploying
+
+Use `rake telegram:bot:set_webhook` to update webhook url for all configured bots.
+Certificate can be specified with `CERT=path/to/cert`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/printercu/telegram-bot.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+require 'sdoc'
+RDoc::Task.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+
+  rdoc.title = 'RailsStuff'
+
+  rdoc.options << '--markup' << 'markdown'
+  rdoc.options << '-e' << 'UTF-8'
+  rdoc.options << '--format' << 'sdoc'
+  rdoc.options << '--template' << 'rails'
+  rdoc.options << '--all'
+
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'telegram/bot'
+
+require 'pry'
+Pry.start

data/bin/git-hooks/pre-commit

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+pattern=$(echo -n '\.rb
+\.gemspec
+\.jbuilder
+\.rake
+config\.ru
+Gemfile
+Rakefile' | tr "\\n" '|')
+
+files=`git diff --cached --name-status | grep -E "^[AM].*($pattern)$" | cut -f2-`
+if [ -n "$files" ]; then
+  bundle exec rubocop $files --force-exclusion
+fi

data/bin/install_git_hooks

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path('../../', __FILE__)
+hooks_dir = "#{root}/bin/git-hooks"
+
+`ls -1 #{hooks_dir}`.each_line.map(&:strip).each do |file|
+  `ln -sf #{hooks_dir}/#{file} #{root}/.git/hooks/#{file}`
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+bin/install_git_hooks
+
+# Do any other automated setup that you need to do here

data/lib/tasks/telegram-bot.rake

@@ -0,0 +1,22 @@
+namespace :telegram do
+  namespace :bot do
+    desc 'Run poller'
+    task poller: :environment do
+      console = ActiveSupport::Logger.new(STDERR)
+      Rails.logger.extend ActiveSupport::Logger.broadcast console
+      Telegram::Bot::UpdatesPoller.start(ENV['BOT'].try!(:to_sym) || :default)
+    end
+
+    desc 'Set webhook urls for all bots'
+    task set_webhook: :environment do
+      routes = Rails.application.routes.url_helpers
+      cert_file = ENV['CERT']
+      cert = File.open(cert_file) if cert_file
+      Telegram.bots.each_value do |bot|
+        route_name = Telegram::RoutesHelper.route_name_for_bot(bot)
+        url = routes.send("#{route_name}_url")
+        bot.set_webhook(url: url, certificate: cert)
+      end
+    end
+  end
+end

data/lib/telegram/bot/middleware.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+require 'action_dispatch/http/mime_type'
+require 'action_dispatch/middleware/params_parser'
+
+module Telegram
+  class Bot
+    class Middleware
+      attr_reader :bot, :controller
+
+      def initialize(bot, controller)
+        @bot = bot
+        @controller = controller
+      end
+
+      def call(env)
+        update = env['action_dispatch.request.request_parameters']
+        controller.dispatch(bot, update)
+        [200, {}, '']
+      end
+
+      def inspect
+        "#<#{self.class.name}(#{controller.try!(:name)})>"
+      end
+    end
+  end
+end

data/lib/telegram/bot/railtie.rb

@@ -0,0 +1,33 @@
+require 'telegram/bot/routes_helper'
+
+module Telegram
+  class Bot
+    class Railtie < Rails::Railtie
+      config.telegram_updates_controller = ActiveSupport::OrderedOptions.new
+
+      rake_tasks do
+        load 'tasks/telegram-bot.rake'
+      end
+
+      config.before_initialize do
+        ::ActionDispatch::Routing::Mapper.send(:include, RoutesHelper)
+      end
+
+      initializer 'telegram.bot.updates_controller.set_config' do |app|
+        options = app.config.telegram_updates_controller
+
+        ActiveSupport.on_load('telegram.bot.updates_controller') do
+          self.logger = options.logger || Rails.logger
+        end
+      end
+
+      initializer 'telegram.bot.updates_controller.add_ar_runtime' do
+        ActiveSupport.on_load('telegram.bot.updates_controller') do
+          if defined?(ActiveRecord::Railties::ControllerRuntime)
+            include ActiveRecord::Railties::ControllerRuntime
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telegram/bot/routes_helper.rb

@@ -0,0 +1,58 @@
+require 'telegram/bot'
+
+module Telegram
+  class Bot
+    module RoutesHelper
+      class << self
+        # Returns route name for given bot. Result depends on `Telegram.bots`.
+        # When there is single bot it returns 'telegram_webhook'.
+        # When there are it will use bot's key in the `Telegram.bots` as prefix
+        # (eg. `chat_telegram_webhook`).
+        def route_name_for_bot(bot)
+          bots = Telegram.bots
+          if bots.size != 1
+            name = bots.invert[bot]
+            name && "#{name}_telegram_webhook"
+          end || 'telegram_webhook'
+        end
+      end
+
+      #   # Create routes for all Telegram.bots to use same controller:
+      #   telegram_webhooks TelegramController
+      #
+      #   # Or pass custom bots usin any of supported config options:
+      #   telegram_webhooks TelegramController,
+      #                     bot,
+      #                     {token: token, username: username},
+      #                     other_bot_token
+      #
+      #   # Use different controllers for each bot:
+      #   telegram_webhooks bot => TelegramChatController,
+      #                     other_bot => TelegramAuctionController
+      #
+      #   # telegram_webhooks creates named routes. See
+      #   # RoutesHelper.route_name_for_bot for more info.
+      #   # You can override this options or specify others:
+      #   telegram_webhooks TelegramController, as: :my_webhook
+      #   telegram_webhooks bot => [TelegramChatController, as: :chat_webhook],
+      #                     other_bot => [TelegramAuctionController,
+      def telegram_webhooks(controllers, bots = nil, **options)
+        unless controllers.is_a?(Hash)
+          bots = bots ? Array.wrap(bots) : Telegram.bots.values
+          controllers = Hash[bots.map { |x| [x, controllers] }]
+        end
+        controllers.each do |bot, controller|
+          bot = Bot.wrap(bot)
+          controller, bot_options = controller if controller.is_a?(Array)
+          params = {
+            to: Middleware.new(bot, controller),
+            as: RoutesHelper.route_name_for_bot(bot),
+            format: false,
+          }.merge!(options).merge!(bot_options || {})
+          post("telegram/#{bot.token}", params)
+          UpdatesPoller.add(bot, controller) if Telegram.bot_poller_mode?
+        end
+      end
+    end
+  end
+end

data/lib/telegram/bot/updates_controller/instrumentation.rb

@@ -0,0 +1,79 @@
+module Telegram
+  class Bot
+    class UpdatesController
+      # Most methods are taken from ActionController::Instrumentation,
+      # some are slightly modified.
+      module Instrumentation
+        class << self
+          def prepended(base)
+            base.config_accessor :logger
+            base.extend ClassMethods
+          end
+
+          def instrument(action, *args, &block)
+            ActiveSupport::Notifications.instrument(
+              "#{action}.updates_controller.bot.telegram",
+              *args,
+              &block
+            )
+          end
+        end
+
+        def process_action(*args)
+          raw_payload = {
+            controller: self.class.name,
+            action:     action_name,
+            update:     update,
+          }
+          Instrumentation.instrument(:start_processing, raw_payload.dup)
+          Instrumentation.instrument(:process_action, raw_payload) do |payload|
+            begin
+              super
+            ensure
+              append_info_to_payload(payload)
+            end
+          end
+        end
+
+        def reply_with(type, *)
+          Instrumentation.instrument(:reply_with, type: type) { super }
+        end
+
+        private
+
+        # A hook invoked every time a before callback is halted.
+        def halted_callback_hook(filter)
+          Instrumentation.instrument(:halted_callback, filter: filter)
+        end
+
+        # A hook which allows you to clean up any time taken into account in
+        # views wrongly, like database querying time.
+        #
+        #   def cleanup_view_runtime
+        #     super - time_taken_in_something_expensive
+        #   end
+        #
+        # :api: plugin
+        def cleanup_view_runtime #:nodoc:
+          yield
+        end
+
+        # Every time after an action is processed, this method is invoked
+        # with the payload, so you can add more information.
+        # :api: plugin
+        def append_info_to_payload(_payload) #:nodoc:
+        end
+
+        module ClassMethods
+          # A hook which allows other frameworks to log what happened during
+          # controller process action. This method should return an array
+          # with the messages to be added.
+          # :api: plugin
+          def log_process_action(_payload) #:nodoc:
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telegram/bot/updates_controller/log_subscriber.rb

@@ -0,0 +1,38 @@
+require 'active_support/log_subscriber'
+
+module Telegram
+  class Bot
+    class UpdatesController
+      class LogSubscriber < ActiveSupport::LogSubscriber
+        def start_processing(event)
+          info do
+            payload = event.payload
+            "Processing by #{payload[:controller]}##{payload[:action]}\n" \
+            "  Update: #{payload[:update].to_json}"
+          end
+        end
+
+        def process_action(event)
+          info do
+            payload   = event.payload
+            additions = UpdatesController.log_process_action(payload)
+            message = "Completed in #{event.duration.round}ms"
+            message << " (#{additions.join(' | ')})" unless additions.blank?
+            message
+          end
+        end
+
+        def reply_with(event)
+          info { "Replied with #{event.payload[:type]}" }
+        end
+
+        def halted_callback(event)
+          info { "Filter chain halted at #{event.payload[:filter].inspect}" }
+        end
+
+        delegate :logger, to: UpdatesController
+        attach_to 'updates_controller.bot.telegram'
+      end
+    end
+  end
+end

data/lib/telegram/bot/updates_controller.rb

@@ -0,0 +1,105 @@
+require 'abstract_controller'
+require 'active_support/callbacks'
+
+module Telegram
+  class Bot
+    class UpdatesController < AbstractController::Base
+      include AbstractController::Callbacks
+      include AbstractController::Translation
+
+      require 'telegram/bot/updates_controller/log_subscriber'
+      require 'telegram/bot/updates_controller/instrumentation'
+      prepend Instrumentation
+
+      PAYLOAD_TYPES = %w(
+        message
+        inline_query
+        chosen_inline_result
+      ).freeze
+      CMD_REGEX = %r{\A/([a-z\d_]{,31})(@(\S+))?(\s|$)}i
+      CONFLICT_CMD_REGEX = Regexp.new("^(#{PAYLOAD_TYPES.join('|')}|\\d)")
+      abstract!
+
+      class << self
+        def dispatch(*args)
+          new(*args).dispatch
+        end
+
+        # Overrid it to filter or transform commands.
+        # Default implementation is to convert to downcase and add `on_` prefix
+        # for conflicting commands.
+        def action_for_command(cmd)
+          cmd.downcase!
+          cmd.match(CONFLICT_CMD_REGEX) ? "on_#{cmd}" : cmd
+        end
+
+        # Fetches command from text message. All subsequent words are returned
+        # as arguments.
+        # If command has mention (eg. `/test@SomeBot`), it returns commands only
+        # for specified username. Set `username` to `true` to accept
+        # any commands.
+        def command_from_text(text, username = nil)
+          return unless text
+          match = text.match CMD_REGEX
+          return unless match
+          return if match[3] && username != true && match[3] != username
+          [match[1], text.split(' ').drop(1)]
+        end
+      end
+
+      attr_internal_reader :update, :bot, :payload, :payload_type, :is_command
+      alias_method :command?, :is_command
+      delegate :username, to: :bot, prefix: true, allow_nil: true
+
+      def initialize(bot = nil, update = nil)
+        @_update = update
+        @_bot = bot
+
+        update && PAYLOAD_TYPES.find do |type|
+          item = update[type]
+          next unless item
+          @_payload = item
+          @_payload_type = type
+        end
+      end
+
+      def dispatch
+        @_is_command, action, args = action_for_payload
+        process(action, *args)
+      end
+
+      # Calculates action name and args for payload.
+      # If payload is a message with command, then returned action is an
+      # action for this command. Otherwise it's the same as payload type.
+      # Returns array `[is_command?, action, args]`.
+      def action_for_payload
+        case payload_type
+        when 'message'
+          cmd, args = self.class.command_from_text(payload['text'], bot_username)
+          cmd &&= self.class.action_for_command(cmd)
+          [true, cmd, args] if cmd
+        end || [false, payload_type, [payload]]
+      end
+
+      # Silently ignore unsupported messages.
+      # Params are `action, *args`.
+      def action_missing(*)
+      end
+
+      %w(chat from).each do |field|
+        define_method(field) { payload[field] }
+      end
+
+      def reply_with(type, params)
+        method = "send_#{type}"
+        params = params.merge(
+          chat_id: chat['id'],
+          reply_to_message: payload['message_id'],
+        )
+        bot.public_send(method, params)
+      end
+
+      ActiveSupport.run_load_hooks('telegram.bot.updates_controller', self)
+    end
+  end
+end

data/lib/telegram/bot/updates_poller.rb

@@ -0,0 +1,88 @@
+module Telegram
+  class Bot
+    # Supposed to be used in development environments only.
+    class UpdatesPoller
+      class << self
+        @@instances = {} # rubocop:disable ClassVars
+
+        def instances
+          @@instances
+        end
+
+        # Create, start and add poller instnace to tracked instances list.
+        def add(bot, controller)
+          new(bot, controller).tap { |x| instances[bot] = x }
+        end
+
+        def start(bot_id, controller = nil)
+          bot = bot_id.is_a?(Symbol) ? Telegram.bots[bot_id] : Bot.wrap(bot_id)
+          instance = controller ? new(bot, controller) : instances[bot]
+          raise "Poller not found for #{bot_id.inspect}" unless instance
+          instance.start
+        end
+      end
+
+      DEFAULT_TIMEOUT = 5
+
+      attr_reader :bot, :controller, :timeout, :offset, :logger, :running, :reload
+
+      def initialize(bot, controller, **options)
+        @logger = options.fetch(:logger) { defined?(Rails) && Rails.logger }
+        @bot = bot
+        @controller = controller
+        @timeout = options.fetch(:timeout) { DEFAULT_TIMEOUT }
+        @offset = options[:offset]
+        @reload = options.fetch(:reload) { defined?(Rails) && Rails.env.development? }
+      end
+
+      def log(&block)
+        logger.info(&block) if logger
+      end
+
+      def start
+        return if running
+        @running = true
+        log { 'Started bot poller.' }
+        while running
+          begin
+            fetch_updates do |update|
+              controller.dispatch(bot, update)
+            end
+          rescue Interrupt
+            @running = false
+          rescue => e
+            logger.error { ([e.message] + e.backtrace).join("\n") } if logger
+          end
+        end
+        log { 'Stop polling bot updates.' }
+      end
+
+      def stop
+        return unless running
+        log { 'Killing polling thread.' }
+        @running = false
+      end
+
+      def fetch_updates
+        response = bot.get_updates(offset: offset, timeout: timeout)
+        return unless response['ok'] && response['result'].any?
+        reload! do
+          response['result'].each do |update|
+            @offset = update['update_id'] + 1
+            yield update
+          end
+        end
+      rescue Timeout::Error # rubocop:disable HandleExceptions
+      end
+
+      def reload!
+        return yield unless reload
+        ActionDispatch::Reloader.prepare!
+        if controller.is_a?(Class) && controller.name
+          @controller = Object.const_get(controller.name)
+        end
+        yield.tap { ActionDispatch::Reloader.cleanup! }
+      end
+    end
+  end
+end

data/lib/telegram/bot/version.rb

@@ -0,0 +1,9 @@
+module Telegram
+  class Bot
+    VERSION = '0.3.0'.freeze
+
+    def self.gem_version
+      Gem::Version.new VERSION
+    end
+  end
+end

data/lib/telegram/bot.rb

@@ -0,0 +1,98 @@
+require 'httpclient'
+require 'json'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/array/wrap'
+require 'telegram/bottable'
+
+module Telegram
+  extend Bottable
+
+  class Bot
+    class Error < StandardError; end
+    class NotFound < Error; end
+
+    autoload :Middleware,         'telegram/bot/middleware'
+    autoload :UpdatesController,  'telegram/bot/updates_controller'
+    autoload :UpdatesPoller,      'telegram/bot/updates_poller'
+
+    URL_TEMPLATE = 'https://api.telegram.org/bot%s/'.freeze
+
+    class << self
+      # Accepts different options to initialize bot.
+      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']
+        else
+          new(input)
+        end
+      end
+    end
+
+    attr_reader :client, :token, :username, :base_uri
+
+    def initialize(token, username = nil)
+      @client = HTTPClient.new
+      @token = token
+      @username = username
+      @base_uri = format URL_TEMPLATE, token
+    end
+
+    def debug!(dev = STDOUT)
+      client.debug_dev = dev
+    end
+
+    def debug_off!
+      client.debug_dev = nil
+    end
+
+    def request(action, data = {})
+      res = http_request("#{base_uri}#{action}", data)
+      status = res.status
+      return JSON.parse(res.body) if 300 > status
+      result = JSON.parse(res.body) rescue nil # rubocop:disable RescueModifier
+      err_msg = "#{res.reason}: #{result && result['description'] || '-'}"
+      # NotFound is raised only for valid responses from Telegram
+      raise NotFound, err_msg if 404 == status && result
+      raise Error, err_msg
+    end
+
+    %w(
+      answerInlineQuery
+      forwardMessage
+      getFile
+      getMe
+      getUpdates
+      getUserProfilePhotos
+      sendAudio
+      sendChatAction
+      sendDocument
+      sendLocation
+      sendMessage
+      sendPhoto
+      sendSticker
+      sendVideo
+      sendVoice
+      setWebhook
+    ).each do |method|
+      define_method(method.underscore) { |*args| request(method, *args) }
+    end
+
+    # Endpoint for low-level request. For easy host highjacking & instrumentation.
+    # Params are not used directly but kept for instrumentation purpose.
+    # You probably don't want to use this method directly.
+    def http_request(uri, body)
+      client.post(uri, body)
+    end
+
+    def inspect
+      "#<Telegram::Bot##{object_id}(#{@username})>"
+    end
+  end
+end
+
+require 'telegram/bot/railtie' if defined?(Rails)

data/lib/telegram/bottable.rb

@@ -0,0 +1,41 @@
+module Telegram
+  module Bottable
+    # Overwrite config.
+    attr_writer :bots_config
+
+    # Keep this setting here, so we can avoid loading Bot::UpdatesPoller
+    # when polling is disabled.
+    attr_writer :bot_poller_mode
+
+    # 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.
+    def bot_poller_mode?
+      return @bot_poller_mode if defined?(@bot_poller_mode)
+      Rails.env.development? if defined?(Rails)
+    end
+
+    # Hash of bots made with bots_config.
+    def bots
+      @bots ||= bots_config.transform_values(&Bot.method(:wrap))
+    end
+
+    # Default bot.
+    def bot
+      @bot ||= bots[:default]
+    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
+      return @bots_config if @bots_config
+      telegram_config = Rails.application.secrets[:telegram]
+      (telegram_config['bots'] || {}).symbolize_keys.tap do |config|
+        default = telegram_config['bot']
+        config[:default] = default if default
+      end
+    end
+  end
+end

data/telegram-bot.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'telegram/bot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'telegram-bot'
+  spec.version       = Telegram::Bot::VERSION
+  spec.authors       = ['Max Melentiev']
+  spec.email         = ['melentievm@gmail.com']
+
+  spec.summary       = 'Library for building Telegram Bots with Rails integration'
+  spec.homepage      = 'https://github.com/printercu/telegram-bot'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^spec/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_dependency 'activesupport', '~> 4.0'
+  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'
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: telegram-bot
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Max Melentiev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- melentievm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/git-hooks/pre-commit
+- bin/install_git_hooks
+- bin/setup
+- lib/tasks/telegram-bot.rake
+- lib/telegram/bot.rb
+- lib/telegram/bot/middleware.rb
+- lib/telegram/bot/railtie.rb
+- lib/telegram/bot/routes_helper.rb
+- lib/telegram/bot/updates_controller.rb
+- lib/telegram/bot/updates_controller/instrumentation.rb
+- lib/telegram/bot/updates_controller/log_subscriber.rb
+- lib/telegram/bot/updates_poller.rb
+- lib/telegram/bot/version.rb
+- lib/telegram/bottable.rb
+- telegram-bot.gemspec
+homepage: https://github.com/printercu/telegram-bot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Library for building Telegram Bots with Rails integration
+test_files: []