telegram-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5eca42b752465bba38de5c76c31efdc2782c402f
+  data.tar.gz: 4dc3258d4b4d17c4b245320e3eb37e1f6458bb91
+SHA512:
+  metadata.gz: fd11d9f7e7db37260933db545884a9306f54317fd727d24dbdb6fc9007f78b2181dc8d4eb0d89275d6fec334bb6c69e491f8f8bd218735417f8af82470ddc818
+  data.tar.gz: c3572018df7cba228ec57c5d6f82c133efcaf5aad283e31112ec0bd8e52069e0c5fe2ff36eaf0ed8b9ef8699174bd16808bfcbe802cff8d7e80616b1858e0522

data/.gitignore

@@ -0,0 +1,42 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# OS X
+.DS_Store
+
+# Telegram
+telegram-cli
+tg-server.pub

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'eventmachine'
+gem 'em-synchrony'
+gem 'oj'
+
+# irb
+gem 'rubysl-irb'

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 SuHun Han
+
+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,14 @@
+# Telegram API for Ruby!
+
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ssut/telegram-rb?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+[![Code Climate](https://codeclimate.com/github/ssut/telegram-rb/badges/gpa.svg)](https://codeclimate.com/github/ssut/telegram-rb)
+
+A Ruby wrapper that communicates with the [Telegram-CLI](https://github.com/vysheng/tg).
+
+## Installation
+
+### Requirements
+
+* You need to install the [Telegram-CLI](https://github.com/vysheng/tg) first.
+

data/example.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+lib = File.join(File.dirname(__FILE__), 'lib')
+$:.unshift lib unless $:.include?(lib)
+
+require 'eventmachine'
+require 'telegram'
+
+EM.run do
+  telegram = Telegram::Client.new do |cfg|
+    cfg.daemon = './telegram-cli'
+    cfg.key = '/Users/ssut/tmp/tg/tg-server.pub'
+  end
+
+  telegram.connect do
+    puts telegram.profile
+    telegram.contacts.each do |contact|
+      puts contact
+    end
+    telegram.chats.each do |chat|
+      puts chat
+    end
+    
+    telegram.on[Telegram::EventType::RECEIVE_MESSAGE] = Proc.new { |ev|
+      
+    }
+
+  end
+end

data/lib/telegram.rb

@@ -0,0 +1,3 @@
+require 'telegram/version'
+require 'telegram/client'
+

data/lib/telegram/api.rb

@@ -0,0 +1,115 @@
+module Telegram
+  class API
+    def update!(&cb)
+      done = false
+      EM.synchrony do
+        multi = EM::Synchrony::Multi.new
+        multi.add :profile, update_profile!
+        multi.add :contacts, update_contacts!
+        multi.add :chats, update_chats!
+        multi.perform
+        done = true
+      end
+
+      check_done = Proc.new {
+        if done
+          @starts_at = Time.now
+          cb.call unless cb.nil?
+          logger.info("Successfully loaded all information")
+        else
+          EM.next_tick(&check_done)
+        end
+      }
+      EM.add_timer(0, &check_done)
+    end
+
+    def update_profile!
+      assert!
+      callback = Callback.new
+      @profile = nil
+      @connection.communicate('get_self') do |success, data|
+        if success
+          callback.trigger(:success)
+          contact = TelegramContact.pick_or_new(self, data)
+          @contacts << contact unless self.contacts.include?(contact)
+          @profile = contact
+        else
+          raise "Couldn't fetch the user profile."
+        end
+      end
+      callback
+    end
+
+    def update_contacts!
+      assert!
+      callback = Callback.new
+      @contacts = []
+      @connection.communicate('contact_list') do |success, data|
+        if success and data.class == Array
+          callback.trigger(:success)
+          data.each { |contact|
+            contact = TelegramContact.pick_or_new(self, contact)
+            @contacts << contact unless self.contacts.include?(contact)
+          }
+        else
+          raise "Couldn't fetch the contact list."
+        end
+      end
+      callback
+    end
+
+    def update_chats!
+      assert!
+      callback = Callback.new
+      collected = 0
+
+      collect_done = Proc.new { |id, data, count|
+        collected += 1
+        @chats << TelegramChat.new(self, data)
+        callback.trigger(:success) if collected == count
+      }
+      collect = Proc.new { |id, count|
+        @connection.communicate(['chat_info', "chat\##{id}"]) do |success, data|
+          collect_done.call(id, data, count) if success
+        end
+      }
+
+      @chats = []
+      @connection.communicate('dialog_list') do |success, data|
+        if success and data.class == Array
+          chatsize = data.count { |chat| chat['type'] == 'chat' }
+          data.each { |chat|
+            if chat['type'] == 'chat'
+              collect.call(chat['id'], chatsize)
+            elsif chat['type'] == 'user'
+              @chats << TelegramChat.new(self, chat)
+            end
+          }
+        else
+          raise "Couldn't fetch the dialog(chat) list."
+        end
+      end
+      callback
+    end
+
+    def msg(target, text, &callback)
+      assert!
+      @connection.communicate(['msg', target, text], &callback)
+    end
+
+    def chat_add_user(chat, user, &callback)
+      assert!
+      @connection.communicate(['chat_add_user', chat.to_tg, user.to_tg], &callback)
+    end
+
+    def chat_del_user(chat, user, &callback)
+      assert!
+      @connection.communicate(['chat_del_user', chat.to_tg, user.to_tg], &callback)
+    end
+
+    protected
+    def assert!
+      raise "It appears that the connection to the telegram-cli is disconnected." unless connected?
+    end
+  end
+end

data/lib/telegram/callback.rb

@@ -0,0 +1,29 @@
+module Telegram
+  class Callback
+    attr_reader :data
+
+    def initialize
+      @success = nil
+      @fail = nil
+      @data = nil
+    end
+
+    def callback(&cb)
+      @success = cb
+    end
+
+    def errback(&cb)
+      @fail = cb
+    end
+
+    def trigger(type = :success, data = nil)
+      @data = data
+      case type
+      when :success
+        @success.call
+      when :fail
+        @fail.call
+      end
+    end
+  end
+end

data/lib/telegram/client.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+require 'eventmachine'
+require "em-synchrony"
+require 'em-synchrony/fiber_iterator'
+require 'ostruct'
+require 'oj'
+require 'shellwords'
+require 'date'
+
+require 'telegram/logger'
+require 'telegram/connection'
+require 'telegram/connection_pool'
+require 'telegram/callback'
+require 'telegram/api'
+require 'telegram/models'
+require 'telegram/events'
+
+module Telegram
+  class Client < API
+    include Logging
+
+    attr_reader :connection
+
+    attr_reader :profile
+    attr_reader :contacts
+    attr_reader :chats
+
+    attr_accessor :on
+
+    def initialize(&b)
+      @config = OpenStruct.new(:daemon => 'bin/telegram', :key => 'tg-server.pub', :sock => 'tg.sock', :size => 5)
+      yield @config
+      @connected = 0
+      @stdout = nil
+      @connect_callback = nil
+      @on = {}
+
+      @profile = nil
+      @contacts = []
+      @chats = []
+      @starts_at = nil
+      @events = EM::Queue.new
+
+      logger.info("Initialized")
+    end
+
+    def execute
+      command = "'#{@config.daemon}' -Ck '#{@config.key}' -I -WS '#{@config.sock}' --json"
+      @stdout = IO.popen(command)
+      loop do
+        if t = @stdout.readline then
+          break if t.include?('I: config')
+        end
+      end
+      proc {}
+    end
+
+    def poll
+      data = ''
+      logger.info("Start polling for events")
+      loop do
+        begin
+          byte = @stdout.read_nonblock 1
+        rescue IO::WaitReadable
+          IO.select([@stdout])
+          retry
+        rescue EOFError
+          logger.error("EOFError occurred during the polling")
+          return
+        end
+        data << byte unless @starts_at.nil?
+        if byte.include?("\n")
+          begin
+            brace = data.index('{')
+            data = data[brace..-2]
+            data = Oj.load(data)
+            @events << data
+          rescue
+          end
+          data = ''
+        end
+      end
+    end
+
+    def process_data
+      process = Proc.new { |data|
+        begin
+          type = case data['event']
+          when 'message'
+            if data['from']['id'] != @profile.id
+              EventType::RECEIVE_MESSAGE
+            else
+              EventType::SEND_MESSAGE
+            end
+          end
+
+          action = data.has_key?('action') ? case data['action']
+            when 'chat_add_user'
+              ActionType::CHAT_ADD_USER
+            else
+              ActionType::UNKNOWN_ACTION
+            end : ActionType::NO_ACTION
+
+          event = Event.new(self, type, action, data)
+          @on[type].call(event) if @on.has_key?(type)
+        rescue Exception => e
+          logger.error("Error occurred during the processing: #{data}\n #{e.inspect} #{e.backtrace}")
+        end
+        @events.pop(&process)
+      }
+      @events.pop(&process)
+    end
+
+    def connect(&block)
+      logger.info("Trying to start telegram-cli and then connect")
+      @connect_callback = block
+      process_data
+      EM.defer(execute, create_pool)
+    end
+
+    def create_pool
+      @connection = ConnectionPool.new(@config.size) do
+        client = EM.connect_unix_domain(@config.sock, Connection)
+        client.on_connect = self.method(:on_connect)
+        client.on_disconnect = self.method(:on_disconnect)
+        client
+      end
+      proc {}
+    end
+
+    def on_connect
+      @connected += 1
+      if connected?
+        logger.info("Successfully connected to the Telegram CLI")
+        EM.defer(&method(:poll))
+        update!(&@connect_callback)
+      end
+    end
+
+    def on_disconnect
+      @connected -= 1
+    end
+
+    def connected?
+      @connected == @config.size
+    end
+  end
+end

data/lib/telegram/connection.rb

@@ -0,0 +1,73 @@
+module Telegram
+  class Connection < EM::Connection
+    def initialize
+      super
+      @connected = false
+      @on_connect = nil
+      @on_disconnect = nil
+      @callback = nil
+      @available = true
+    end
+
+    def available?
+      @available
+    end
+
+    def communicate(*messages, &callback)
+      @available = false
+      @callback = callback
+      messages = messages.each_with_index.map { |m, i|
+        if i > 0
+          m = "\"#{m}\""
+        end
+        m
+      }.join(' ') << "\n"
+      send_data(messages)
+    end
+
+    def on_connect=(block)
+      @on_connect = block
+    end
+
+    def on_disconnect=(block)
+      @on_disconnect = block
+    end
+
+    # @api private
+    def connection_completed
+      @connected = true
+      @on_connect.call unless @on_connect.nil?
+    end
+
+    def unbind
+      @connected = false
+      @on_disconnect.call unless @on_disconnect.nil?
+    end
+
+    def connected?
+      @connected
+    end
+
+    def receive_data(data)
+      begin
+        result = _receive_data(data)
+      rescue
+        result = nil
+      end
+      @callback.call(!result.nil?, result) unless @callback.nil?
+      @callback = nil
+      @available = true
+    end
+
+    protected
+    def _receive_data(data)
+      if data[0..6] == 'ANSWER '
+        lf = data.index("\n") + 1
+        lflf = data.index("\n\n", lf) - 1
+        data = data[lf..lflf]
+        data = Oj.load(data)
+      end
+      data
+    end
+  end
+end

data/lib/telegram/connection_pool.rb

@@ -0,0 +1,37 @@
+module Telegram
+  class ConnectionPool < Array
+    include Logging
+
+    attr_reader :size
+
+    def initialize(size=10, &block)
+      size.times do 
+        self << block.call if block_given?
+      end
+    end
+
+    def communicate(*messages, &block)
+      begin
+        acquire do |conn|
+          conn.communicate(*messages, &block)
+        end
+      rescue Exception => e
+        logger.error("Error occurred during the communicating: #{e.inspect} #{e.backtrace}")
+      end
+
+    end
+
+    def acquire(&callback)
+      acq = Proc.new {
+        conn = self.find { |conn| conn.available? }
+        if not conn.nil? and conn.connected?
+          callback.call(conn)
+        else
+          logger.warning("Failed to acquire available connection, retry after 0.1 second")
+          EM.add_timer(0.1, &acq)
+        end
+      }
+      EM.add_timer(0, &acq)
+    end
+  end
+end

data/lib/telegram/events.rb

@@ -0,0 +1,117 @@
+module Telegram
+  module EventType
+    UNKNOWN_EVENT = -1
+    SERVICE = 0
+    RECEIVE_MESSAGE = 1
+    SEND_MESSAGE = 2
+    ONLINE_STATUS = 3
+  end
+
+  module ActionType
+    UNKNOWN_ACTION = -1
+    NO_ACTION = 0
+    CHAT_ADD_USER = 1
+    CHAT_DEL_USER = 2
+    CHAT_RENAME = 3
+  end
+
+  class Message < Struct.new(:text, :type, :from, :from_type, :raw_from, :to, :to_type, :raw_to); end
+
+  class Event
+    # @return [Number]
+    attr_reader :id
+
+    # @return [EventType]
+    attr_reader :event
+
+    # @return [ActionType]
+    attr_reader :action
+
+    # @return [Time]
+    attr_reader :time
+
+    # @return [Message]
+    attr_reader :message
+
+    # @return [TelegramMessage]
+    attr_reader :tgmessage
+
+    def initialize(client, event = EventType::UNKNOWN_EVENT, action = ActionType::NO_ACTION, data = {})
+      @client = client
+      @message = nil
+      @tgmessage = nil
+      @raw_data = data
+      @time = nil
+
+      @event = event
+      @action = action
+
+      @time = Time.at(data['date'].to_i) if data.has_key?('date')
+      @time = DateTime.strptime(data['when'], "%Y-%m-%d %H:%M:%S") if @time.nil? and data.has_key?('when')
+
+      case event
+      when EventType::SERVICE
+        foramt_service
+      when EventType::RECEIVE_MESSAGE, EventType::SEND_MESSAGE
+        format_message
+        @tgmessage = TelegramMessage.new(@client, self)
+      when EventType::ONLINE_STATUS
+        foramt_status
+      end
+    end
+
+    def format_service
+
+    end
+
+    def format_message
+      message = Message.new
+      message.text = @raw_data['text']
+      message.type = @raw_data.has_key?('media') ? @raw_data['media']['type'] : 'text'
+      message.raw_from = @raw_data['from']['id']
+      message.from_type = @raw_data['from']['type']
+      message.raw_to = @raw_data['to']['id']
+      message.to_type = @raw_data['to']['type']
+
+      from = @client.contacts.find { |c| c.id == message.raw_from }
+      to = @client.contacts.find { |c| c.id == message.raw_to }
+      to = @client.chats.find { |c| c.id == message.raw_to } if to.nil?
+
+      message.from = from
+      message.to = to
+
+      @message = message
+
+      if @message.from.nil?
+        user = @raw_data['from']
+        user = TelegramContact.pick_or_new(@client, user)
+        @client.contacts << user unless @client.contacts.include?(user)
+        @message.from = user
+      end
+
+      if @message.to.nil?
+        type = @raw_data['to']['type']
+        if type == 'chat'
+          chat = @raw_data['to']
+          chat = TelegramChat.pick_or_new(@client, chat)
+          @client.chats << chat unless @client.chats.include?(chat)
+          @message.from = chat
+        elsif type == 'user'
+          user = @raw_data['to']
+          user = TelegramContact.pick_or_new(@client, user)
+          @client.contacts << user unless @client.contacts.include?(user)
+          @message.to = user
+        elsif type == 'encr_chat'
+          chat = @raw_data['to']
+          chat = TelegramChat.pick_or_new(@client, chat)
+          @client.chats << chat unless @client.chats.include?(chat)
+          @message.to = chat
+        end
+      end
+    end
+
+    def to_s
+      "<Event Type=#{@event} Action=#{@action} Time=#{@time} Message=#{@message}>"
+    end
+  end
+end

data/lib/telegram/logger.rb

@@ -0,0 +1,29 @@
+require 'logger'
+
+module Telegram
+  module Logging
+    def logger
+      @logger ||= Logging.logger_for(self.class.name)
+    end
+
+    @loggers = {}
+    class << self
+      def logger_for(klass)
+        @loggers[klass] ||= configure_logger_for(klass)
+      end
+
+      def configure_logger_for(klass)
+        logger = Logger.new(STDOUT)
+        logger.progname = klass
+        logger.level = Logger::DEBUG
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          date_format = datetime.strftime('%Y-%m-%d %H:%M:%S')
+          blanks = severity.size == 4 ? '  ' : ' '
+          "[#{date_format}] #{severity}#{blanks}(#{progname}): #{msg}\n"
+        end
+
+        logger
+      end
+    end
+  end
+end

data/lib/telegram/models.rb

@@ -0,0 +1,167 @@
+module Telegram
+  class TelegramBase
+    attr_reader :client
+    attr_reader :id
+
+    def send_message(text, refer)
+      target = case @type
+      when 'encr_chat'
+        "#{@title}"
+      else
+        to_tg
+      end
+      @client.msg(target, text)
+    end
+
+    def send_sticker()
+
+    end
+
+    def send_image(path, refer, &callback)
+
+    end
+
+    def send_image_url(url, refer, &callback)
+
+    end
+  end
+
+  class TelegramChat < TelegramBase
+    attr_reader :name
+    attr_reader :members
+    attr_reader :type
+
+    def self.pick_or_new(client, chat)
+      ct = client.chats.find { |c| c.id == chat['id'] }
+      return ct unless ct.nil?
+      TelegramChat.new(client, chat)
+    end
+
+    def initialize(client, chat)
+      @client = client
+      @chat = chat
+
+      @id = chat['id']
+      @title = chat.has_key?('title') ? chat['title'] : chat['print_name']
+      @type = chat['type']
+
+      @members = []
+      if chat.has_key?('members')
+        chat['members'].each { |user|
+          @members << TelegramContact.pick_or_new(client, user)
+        }
+      elsif @type == 'user' and chat['user']
+        @members << TelegramContact.pick_or_new(client, chat)
+      end
+    end
+
+    def leave!
+      @client.chat_del_user(self, @client.profile)
+    end
+
+    def to_tg
+      "#{@type}\##{@id}"
+    end
+
+    def to_s
+      "<TelegramChat #{@title}(#{@type}\##{@id}) members=#{@members.size}>"
+    end
+  end
+
+  class TelegramContact < TelegramBase
+    attr_reader :name
+    attr_reader :phone
+    attr_reader :type
+
+    def self.pick_or_new(client, contact)
+      ct = client.contacts.find { |c| c.id == contact['id'] }
+      return ct unless ct.nil?
+      TelegramContact.new(client, contact)
+    end
+
+    def initialize(client, contact)
+      @client = client
+      @contact = contact
+
+      @id = contact['id']
+      @type = 'user'
+      @username = contact.has_key?('username') ? contact['username'] : ''
+      @name = contact['print_name']
+      @phone = contact.has_key?('phone') ? contact['phone'] : ''
+
+      @client.contacts << self unless @client.contacts.include?(self)
+    end
+
+    def chats
+      @client.chats.select { |c| c.member.include?(self) }
+    end
+
+    def to_tg
+      "#{@type}\##{@id}"
+    end
+
+    def to_s
+      "<TelegramContact #{@name}(#{@id}) username=#{@username}>"
+    end
+  end
+
+  class TelegramMessage
+    # @return [Telegram]
+    attr_reader :client
+
+    # @return [String]
+    attr_reader :raw
+
+    # @return [Integer]
+    attr_reader :id
+
+    # @return [Time]
+    attr_reader :time
+
+    # @return [TelegramContact] The user who sent this message
+    attr_reader :user
+
+    # targets to send a message
+    attr_reader :raw_target
+    attr_reader :target
+
+    # @return [TelegramChat]
+    attr_reader :chat
+
+    def initialize(client, event)
+      @event = event
+      
+      @id = event.id
+      @raw = event.message.text
+      @time = event.time
+      @content_type = event.message.type
+
+      @raw_sender = event.message.raw_from
+      @raw_receiver = event.message.raw_to
+
+      @user = @sender = event.message.from
+      @receiver = event.message.to
+
+      @target = case @receiver.type
+      when 'user'
+        @sender
+      when 'chat', 'encr_chat'
+        @receiver
+      end
+    end
+
+    def reply_user(type, content)
+
+    end
+
+    def reply(type, content, target=nil, &cb)
+      target = @target if target.nil?
+      if type == :text
+        target.send_message(content, self)
+      elsif type == :sticker 
+      elsif type == :image
+      end
+
+    end
+  end
+end

data/lib/telegram/version.rb

@@ -0,0 +1,4 @@
+module Telegram
+  # version of the library
+  VERSION = '0.1.0'
+end

data/telegram-rb.gemspec

@@ -0,0 +1,17 @@
+lib = File.join(File.dirname(__FILE__), 'lib')
+$:.unshift lib unless $:.include?(lib)
+
+require 'telegram/version'
+
+Gem::Specification.new do |s|
+  s.date        = Date.today.to_s
+  s.name        = 'telegram-rb'
+  s.version     = Telegram::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = 'A Ruby wrapper that communicates with the telegram-cli.'
+  s.description = "A Ruby wrapper that communicates with the telegram-cli."
+  s.authors     = ["SuHun Han (ssut)"]
+  s.email       = 'ssut@ssut.me'
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = 'https://github.com/ssut/telegram-rb'
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: telegram-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SuHun Han (ssut)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-06 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby wrapper that communicates with the telegram-cli.
+email: ssut@ssut.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- example.rb
+- lib/telegram.rb
+- lib/telegram/api.rb
+- lib/telegram/callback.rb
+- lib/telegram/client.rb
+- lib/telegram/connection.rb
+- lib/telegram/connection_pool.rb
+- lib/telegram/events.rb
+- lib/telegram/logger.rb
+- lib/telegram/models.rb
+- lib/telegram/version.rb
+- telegram-rb.gemspec
+homepage: https://github.com/ssut/telegram-rb
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A Ruby wrapper that communicates with the telegram-cli.
+test_files: []