telegram-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 32045c7d423551f7c28bf5cb2a2461e70f04cf07
+  data.tar.gz: ae807568c5f7806f718f4177a3bd52b2abb6b6d6
+SHA512:
+  metadata.gz: d77da4d52528321a44a3815f188062f5ef935873c010a1afc869013043ad4af2247b6997fce9602e01f441fe89c5bfb9b866c91ffda4a31f49c723a22b1bb8ab
+  data.tar.gz: e773a1c9ab1dd94de058d7fb3e206bfb360c753f689c7fa88428f9987220f66dc2dd636636ebe963155c08876ae9f1398d35e10c23c3eb08e1caf43f6f0de289

data/README.md

@@ -0,0 +1,52 @@
+# Telegram::Rails
+
+## Work in progress
+
+Rails integration for [`telegram-rabbit`](https://github.com/govorov/telegram-rabbit).
+
+Gives you http-like routes and controllers. Allows you to write such a code:
+
+```
+#routes.rb
+Rails.application.routes.draw do
+
+  telegram 'main/start', to: 'telegram/message#start'
+  telegram 'main/stop',  to: 'telegram/message#stop'
+  telegram 'main',       to: 'telegram/message'
+
+end
+
+#message_controller.rb
+class Telegram::MessageController < Telegram::Controller
+
+  def start
+    respond_with 'received /start'
+  end
+
+
+  def stop
+    respond_with 'received /stop'
+  end
+
+
+  def process
+    respond_with 'other commands'
+  end
+
+end
+
+```
+
+## TODO
+
+* Sessions
+* Callbacks
+* `rescue_from`
+* `respond_to`
+* ...and so on from vanilla rails controllers
+* Documentation
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "telegram/rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

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

data/lib/telegram/client_adapter.rb

@@ -0,0 +1,84 @@
+require 'telegram/rails/action_dispatcher'
+
+
+module Telegram
+  class ClientAdapter
+
+    class ApiProxy
+      def initialize adapter
+        @adapter = adapter
+      end
+
+      def method_missing command, *args
+        puts "call adapter with #{command}"
+        p args
+        @adapter.send_command command, *args
+      end
+    end
+
+
+    attr_accessor :connection
+    attr_accessor :queue_namespace
+    attr_accessor :options
+    attr_accessor :bot_name
+
+
+    def configure
+      yield self
+      self
+    end
+
+
+    def start
+      send_queue_name    = "#{queue_prefix}.commands"
+      receive_queue_name = "#{queue_prefix}.messages"
+
+      @channel       = connection.create_channel
+      @send_queue    = @channel.queue send_queue_name
+      @receive_queue = @channel.queue receive_queue_name
+
+      @receive_queue.subscribe do |info,metadata,raw_data|
+        data = Marshal.load(raw_data)
+        @receive_callbacks.each do |callback|
+          callback.call(data)
+        end
+      end
+
+      @api_proxy = ApiProxy.new(self)
+    end
+
+
+    def on_message_received &block
+      @receive_callbacks ||= []
+      @receive_callbacks << block
+    end
+
+
+    def api
+      @api_proxy
+    end
+
+
+    def send_message payload
+      api.send_message payload
+    end
+
+
+    def send_command command, payload
+      raw_data = Marshal.dump(serialize_command(command,payload))
+      @channel.default_exchange.publish raw_data, routing_key: @send_queue.name
+    end
+
+
+    private
+
+    def serialize_command command, payload
+      {command: command, payload: payload}
+    end
+
+    def queue_prefix
+      "#{queue_namespace}.#{bot_name}"
+    end
+
+  end # ClientAdapter
+end # Telegram

data/lib/telegram/controller.rb

@@ -0,0 +1,102 @@
+require 'telegram/utils/responder'
+require 'telegram/utils/keyboard_builder'
+
+
+module Telegram
+  class Controller
+
+    def bots= adapters
+      @bots = adapters
+    end
+
+
+    def bot_name= name
+      @bot_name = name
+    end
+
+
+    def message= payload
+      @message = payload
+    end
+
+
+    def explicit_response?
+      @explicit_response
+    end
+
+
+    private
+
+    def bot
+      @bots[@bot_name]
+    end
+
+
+    def bots
+      @bots
+    end
+
+
+    def request
+      @message
+    end
+
+
+    def send_message *args
+      bot.api.send_message *args
+      @explicit_response = true
+    end
+
+
+    def default_response
+      { chat_id: @message.chat.id }
+    end
+
+
+    def respond_with payload
+      response = payload.clone
+      # WIP угадывать тип, посмотреть какие есть типы ответа
+      unless response.is_a? Hash
+        response = {text: response.to_s}
+      end
+
+      # :keyboard        => :reply_markup, call :keyboard
+      # :inline_keyboard => :reply_markup, call :inline_keyboard
+      if response.has_key? :keyboard
+        response[:reply_markup] = keyboard(response[:keyboard])
+        response.delete :keyboard
+      end
+
+      if response.has_key? :inline_keyboard
+        response[:reply_markup] = inline_keyboard(response[:inline_keyboard])
+        response.delete :inline_keyboard
+      end
+
+      if response.has_key?(:remove_keyboard) && response[:remove_keyboard]
+        response[:reply_markup] = remove_keyboard
+        response.delete :remove_keyboard
+      end
+
+      send_message default_response.merge(response)
+    end
+
+
+    keyboard_builder = Telegram::Utils::KeyboardBuilder
+
+    define_method :keyboard do |buttons|
+      keyboard_builder.keyboard buttons
+    end
+
+
+    define_method :inline_keyboard do |buttons|
+      keyboard_builder.inline_keyboard buttons
+    end
+
+
+    define_method :remove_keyboard do
+      res = keyboard_builder.remove_keyboard
+    end
+
+
+  end # Controller
+end # Telegram

data/lib/telegram/errors/common_error.rb

@@ -0,0 +1,6 @@
+module Telegram
+  module Errors
+    class CommonError < StandardError
+    end
+  end
+end

data/lib/telegram/errors/configuration/token_missing_error.rb

@@ -0,0 +1,13 @@
+require 'telegram/errors/common_error'
+
+module Telegram
+  module Errors
+    module Configuration
+      class TokenMissingError < Telegram::Errors::CommonError
+        def initialize name
+          super "No token were provided for bot \"#{name}\""
+        end
+      end
+    end
+  end
+end

data/lib/telegram/errors/controller/block_not_given_error.rb

@@ -0,0 +1,13 @@
+require 'telegram/errors/common_error'
+
+module Telegram
+  module Errors
+    module Controller
+      class BlockNotGivenError < Telegram::Errors::CommonError
+        def initialize
+          super "Block not given"
+        end
+      end
+    end
+  end
+end

data/lib/telegram/errors/routing/bad_route_error.rb

@@ -0,0 +1,14 @@
+require 'telegram/errors/common_error'
+
+
+module Telegram
+  module Errors
+    module Routing
+      class BadRouteError < Telegram::Errors::CommonError
+        def initialize route
+          super "Bad route \"#{route}\""
+        end
+      end
+    end
+  end
+end

data/lib/telegram/errors/routing/bot_not_found_error.rb

@@ -0,0 +1,14 @@
+require 'telegram/errors/common_error'
+
+#WIP--
+module Telegram
+  module Errors
+    module Routing
+      class BotNotFoundError < Telegram::Errors::CommonError
+        def initialize name
+          super "Bot \"#{name}\" was not found"
+        end
+      end
+    end
+  end
+end

data/lib/telegram/rails/action_dispatcher.rb

@@ -0,0 +1,121 @@
+require 'active_support/inflector'
+
+
+module Telegram
+  module Rails
+    class ActionDispatcher
+
+      ROUTE_DELIMETER        = "/"
+      ENDPOINT_DELIMETER     = "#"
+      COMMAND_START_SYMBOL   = "/"
+      COMMAND_ARGS_SEPARATOR = /\s+/
+      DEFAULT_ACTION_NAME    = :process
+
+
+      def initialize adapters
+        @adapters = adapters
+        @routes   = []
+      end
+
+
+      def register_route route_data
+        route = parse_route(route_data)
+        @routes << route
+      end
+
+
+      def dispatch_message bot_name, message
+        adapter = find_adapter_for bot_name
+        return unless adapter
+
+        command, args = extract_command_from message
+        route = find_route_for bot_name, command
+        return unless route
+
+        process_message message, with: route
+      end
+
+
+      private
+
+      def find_adapter_for name
+        @adapters[name]
+      end
+
+
+      def find_route_for bot_name, command
+        @routes.find do |route|
+          route_match? bot_name, command, route
+        end
+      end
+
+
+      def route_match? bot_name, command, route
+        bot_name == route[:bot_name] &&
+        (command == route[:command] || route[:command].nil?)
+      end
+
+
+      def process_message message, opts
+        route = opts[:with]
+        controller = route[:controller_class].new
+        controller.tap do |c|
+          c.bots     = @adapters
+          c.bot_name = route[:bot_name]
+          c.message  = message
+        end
+
+        begin
+          # WIP check explicit response...
+          controller.send route[:action_name]
+        rescue StandardError => e
+          puts "RESCUE FROM"
+          puts "RESCUE FROM"
+          puts "RESCUE FROM"
+          puts "RESCUE FROM"
+          #HERE rescue_from!!!
+          raise e
+        end
+      end
+
+
+      #TODO test coverage
+      def parse_route route_data
+        route_string = route_data[:route]
+        options      = route_data[:options]
+
+        segments = route_string.split ROUTE_DELIMETER, 2
+        bot_name, command = segments
+
+        bot_name = bot_name.to_sym if bot_name
+        command  = command.to_sym if command
+
+        endpoint = options[:to]
+        controller_name, action_name = endpoint.to_s.split ENDPOINT_DELIMETER, 2
+
+        controller_class = "#{controller_name}_controller".classify.constantize
+        action_name      = action_name ? action_name.to_sym : DEFAULT_ACTION_NAME
+
+        {
+          bot_name:         bot_name,
+          command:          command,
+          controller_class: controller_class,
+          action_name:      action_name,
+        }
+      end
+
+
+      # get command name from payload
+      def extract_command_from payload
+        command_str = payload.text
+        if command_str && command_str.starts_with?(COMMAND_START_SYMBOL)
+          command_str.slice!(0)
+          command,*args = command_str.split COMMAND_ARGS_SEPARATOR
+          return [command.to_sym, args] if command && command.length
+        end
+        return [nil,nil]
+      end
+
+    end # ActionDispatcher
+  end # Rails
+end # Telegram

data/lib/telegram/rails/railtie.rb

@@ -0,0 +1,75 @@
+require 'bunny'
+require 'active_support/notifications'
+
+require 'telegram/rails/routes_helper'
+require 'telegram/client_adapter'
+
+require 'telegram/errors/configuration/token_missing_error'
+require 'telegram/errors/routing/bot_not_found_error'
+require 'telegram/controller'
+require 'telegram/bot'
+
+
+module Telegram
+  module Rails
+    class Railtie < ::Rails::Railtie
+
+      # add config section
+      config.telegram = ActiveSupport::OrderedOptions.new
+      notifications   = ActiveSupport::Notifications
+
+      #add route helper
+      config.before_initialize do
+        ::ActionDispatch::Routing::Mapper.send(:include, Telegram::Rails::RoutesHelper)
+      end
+
+      initializer "telegram_rails.run_client_adapters" do |app|
+
+        @options ||= default_options.merge(app.config.telegram)
+        @adapters = {}
+        dispatcher = Telegram::Rails::ActionDispatcher.new @adapters
+
+        @connection = Bunny.new(get_option :bunny).start
+        at_exit { @connection.close }
+
+        #create adapter for each bot
+        get_option(:bots).each do |pair; name,options|
+          name, options = pair
+
+          adapter = Telegram::ClientAdapter.new.configure do |c|
+            c.bot_name        = name
+            c.options         = options
+            c.connection      = @connection
+            c.queue_namespace = get_option(:queue_namespace)
+          end
+
+          adapter.on_message_received do |message|
+            #TODO logging
+            dispatcher.dispatch_message name, message
+          end
+
+          @adapters[name] = adapter
+          adapter.start
+        end
+
+        notifications.subscribe "telegram.register_route" do |name, started, finished, id, data|
+          dispatcher.register_route data
+        end
+
+      end # initializer
+
+
+      private
+
+      def get_option *args
+        (@options || {}).dig *args
+      end
+
+
+      def default_options
+        Hash.new
+      end
+
+    end # Railtie
+  end # Rails
+end # Telegram

data/lib/telegram/rails/routes_helper.rb

@@ -0,0 +1,11 @@
+module Telegram
+  module Rails
+    module RoutesHelper
+
+      def telegram route, options
+        ActiveSupport::Notifications.instrument "telegram.register_route", route: route, options: options
+      end
+
+    end #RoutesHelper
+  end #Rails
+end #Telegram

data/lib/telegram/rails/version.rb

@@ -0,0 +1,5 @@
+module Telegram
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/telegram/rails.rb

@@ -0,0 +1,8 @@
+require "telegram/rails/version"
+
+module Telegram
+  module Rails
+  end
+end
+
+require "telegram/rails/railtie" if defined?(Rails)

data/lib/telegram/utils/keyboard_builder.rb

@@ -0,0 +1,37 @@
+require 'telegram/bot'
+
+module Telegram
+  module Utils
+    module KeyboardBuilder
+      class << self
+
+        def keyboard buttons
+          btnClass = Telegram::Bot::Types::KeyboardButton
+          kbClass  = Telegram::Bot::Types::ReplyKeyboardMarkup
+          build :keyboard, buttons, btnClass, kbClass
+        end
+
+
+        def inline_keyboard buttons
+          btnClass = Telegram::Bot::Types::InlineKeyboardButton
+          kbClass  = Telegram::Bot::Types::InlineKeyboardMarkup
+          build :keyboard, buttons, btnClass, kbClass
+        end
+
+
+        def remove_keyboard
+          Telegram::Bot::Types::ReplyKeyboardRemove.new(remove_keyboard: true)
+        end
+
+
+        private
+        def build key, buttons, btnClass, kbClass
+          keyboard = buttons.map do |button|
+            btnClass.new button
+          end
+          kbClass.new({ key => keyboard })
+        end
+      end
+    end
+  end # Utils
+end # Telegram

data/lib/telegram/utils/responder.rb

@@ -0,0 +1,117 @@
+require 'active_support/inflector'
+require 'telegram/errors/controller/block_not_given_error'
+#WIP-- `ag byebug`
+require 'byebug'
+
+#WIP move to ...::Controller, продумать
+
+module Telegram
+  module Utils
+    class Responder
+
+      class << self
+        private
+        def register_type type
+          instance_eval do
+            define_method type do |&block|
+              set_respond_to type, &block
+            end
+          end
+        end
+      end
+
+
+      RESPONSE_TYPES = [
+        :from,
+        :date,
+        :chat,
+        :forward_from,
+        :forward_from_chat,
+        :forward_from_message_id,
+        :forward_date,
+        :reply_to_message,
+        :edit_date,
+        :text,
+        :entities,
+        :audio,
+        :document,
+        :game,
+        :photo,
+        :sticker,
+        :video,
+        :voice,
+        :caption,
+        :contact,
+        :location,
+        :venue,
+        :new_chat_member,
+        :left_chat_member,
+        :new_chat_title,
+        :new_chat_photo,
+        :delete_chat_photo,
+        :group_chat_created,
+        :supergroup_chat_created,
+        :channel_chat_created,
+        :migrate_to_chat_id,
+        :migrate_from_chat_id,
+        :pinned_message,
+        # Telegram::Bot::Types::ReplyKeyboardMarkup,
+        # Telegram::Bot::Types::ReplyKeyboardRemove,
+        # Telegram::Bot::Types::ForceReply,
+        # Telegram::Bot::Types::InlineKeyboardMarkup
+      ]
+
+
+      RESPONSE_TYPES.each do |type_const|
+        register_type type_const.to_s.underscore.to_sym
+      end
+
+
+      def current_message= message
+        @message = message
+      end
+
+
+      def current_message
+        @message
+      end
+
+
+      def clear_current_message
+        @message = nil
+      end
+
+
+      def any &block
+        set_respond_to :any, &block
+      end
+
+
+      #TEST
+      #match first not nil attribute
+      def set_respond_to type, &block
+        @stack ||= []
+        @stack.push type
+        if block && @block.nil?
+          # check if message matches stack
+          has_attr = @stack.find do |format|
+            format == :any || !current_message.send(format).nil?
+          end
+
+          if has_attr
+            @block = block
+          end
+
+          @stack.clear
+        end
+
+      end
+
+
+      def block
+        @block or raise Telegram::Errors::Controller::BlockNotGivenError
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: telegram-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stanislav E. Govorov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: telegram-bot-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wisper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- govorov.st@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/console
+- bin/setup
+- lib/telegram/client_adapter.rb
+- lib/telegram/controller.rb
+- lib/telegram/errors/common_error.rb
+- lib/telegram/errors/configuration/token_missing_error.rb
+- lib/telegram/errors/controller/block_not_given_error.rb
+- lib/telegram/errors/routing/bad_route_error.rb
+- lib/telegram/errors/routing/bot_not_found_error.rb
+- lib/telegram/rails.rb
+- lib/telegram/rails/action_dispatcher.rb
+- lib/telegram/rails/railtie.rb
+- lib/telegram/rails/routes_helper.rb
+- lib/telegram/rails/version.rb
+- lib/telegram/utils/keyboard_builder.rb
+- lib/telegram/utils/responder.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Rails integration for telegram-bot-rabbit
+test_files: []