telegram_bot_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c01b6b954e0b513b8a0e29ef88b0f1554c9a50a
+  data.tar.gz: 0b0186efea939835e34f71aa34481e723a631218
+SHA512:
+  metadata.gz: 45c73516b817ccb7d12d38fd7220221a31ddabf27d3398869adcd85ce47265a633e4e3b5a7718acc27ee595cc3588510a92d882595f3b17603c6839887957830
+  data.tar.gz: 0d82339b0ae3fde83a6d209416862c1bbeef5dd218bcda50ec26213b885e433a7f0b07b6081b124a9dd54cd63caf795f4778d9f581950b72f8eccd87d264cf27

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.10.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in telegram_bot_ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Shou Ya
+
+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,87 @@
+# TelegramBotRuby
+
+**This project is not finished yet**
+
+
+utilizing telegram bots api in ruby
+([telegram api doc](https://core.telegram.org/bots/api))
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'telegram_bot_ruby'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install telegram_bot_ruby
+```
+
+## Usage
+
+### Set up client
+
+```ruby
+require 'telegram_bot_ruby'
+
+bot = TelegramBot.new(token: <token>)
+bot.listen(method: :webhook, url: '/meow/meow')
+# or
+bot.listen(method: :poll, interval: 5)
+```
+
+### Set up update listeners
+
+```ruby
+bot.on_command 'ping' do  # /ping
+  reply 'pong'
+end
+
+bot.on_command 'plus' do |num1, num2|  # /plus 1 2
+  reply (num1.to_i + num2.to_i).to_s
+end
+
+bot.on_text 'ping' do     # plain 'ping'
+  send_message 'pong'
+end
+
+# with block: false, message will keep passing through other listeners
+bot.on_text /(\d+)\+(\d+)\=\?/, block: false do
+  send_chat_action :typing
+  send_message ($1.to_i + $2.to_i).to_s
+  forward_message 2333
+  send_chat_action :upload_photo
+  send_photo <IO obj implements read>
+end
+
+# a simple history logger
+bot.anything do |msg|
+  Database.save [msg.from.username, msg.text] if !msg.text.empty?
+end
+```
+
+### Start && Stop
+
+```ruby
+# register service at telegram or start long polling
+bot.start!
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shouya/telegram-bot.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/telegram_bot/audio.rb

@@ -0,0 +1,10 @@
+class TelegramBot::Audio <
+      Struct.new(:id, :duration, :mime_type, :file_size)
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :file_id
+    }
+  end
+end

data/lib/telegram_bot/auto_from_methods.rb

@@ -0,0 +1,67 @@
+class TelegramBot
+  module AutoFromMethods
+    module ClassMethods
+      def from(id)
+        case id
+        when self
+          id
+        when nil
+          nil
+        when Hash
+          parse(id)
+        when Integer
+          new(id)
+        when others
+          warn "unknown stuff passed in [#{id}]"
+        end
+      end
+
+      def extra_types
+        {}
+      end
+
+      def hash_key_aliases
+        {}
+      end
+
+      def parse(hsh)
+        obj = new(*parse_attrs(hsh))
+        parse_extra_types
+        obj
+      end
+
+      private
+
+      def parse_attrs(hsh)
+        aliases = hash_key_aliases
+        members.map do |attr|
+          if aliases.include? attr
+            hash_attr = aliases[attr]
+          else
+            hash_attr = attr
+          end
+          hsh[attr] || hsh[hash_attr.to_s]
+        end
+      end
+
+      def parse_extra_types
+        extra_types.each do |attr, typ|
+          case typ
+          when Class
+            obj[attr] = typ.from(obj[attr])
+          when Array
+            obj[attr] = obj[attr].map { |x| typ[0].from(x) }
+          else
+            warn 'unknown type #{type}'
+          end
+        end
+      end
+
+    end
+
+    def self.included(clazz)
+      clazz.extend ClassMethods
+    end
+  end
+
+end

data/lib/telegram_bot/blank_slate.rb

@@ -0,0 +1,11 @@
+module TelegramBot
+  class BlankSlate < BasicObject
+    def extend(&block)
+      self.singleton_class.class_eval(&block)
+    end
+
+    def call(*args, &block)
+      self.instance_exec(*args, &block)
+    end
+  end
+end

data/lib/telegram_bot/chat.rb

@@ -0,0 +1,20 @@
+class Chat < Struct.new(:id)
+  def self.from(id)
+    case id
+    when Integer
+      Chat.new(id)
+    when GroupChat, User
+      id
+    when Hash
+      if id.has_key? 'title'
+        GroupChat.from(id)
+      elsif id.has_key? 'first_name'
+        User.from(id)
+      else
+        Chat.from(id['id'])
+      end
+    else
+      warn 'unknown chat'
+    end
+  end
+end

data/lib/telegram_bot/contact.rb

@@ -0,0 +1,13 @@
+class TelegramBot::Contact <
+      Struct.new(:id,
+                 :phone_number,
+                 :first_name,
+                 :last_name)
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :user_id
+    }
+  end
+end

data/lib/telegram_bot/date.rb

@@ -0,0 +1,32 @@
+require 'datetime'
+require 'time'
+
+class TelegramBot::Date < Struct.new()
+  include AutoFromMethods
+
+  def self.from(date)
+    case date
+    when ::DateTime, ::Date, ::Time
+      new(date)
+    when Integer
+      new(Time.at(date).to_datetime)
+    when String
+      new(Datetime.parse(date))
+    when TelegramBot::Date
+      date
+    else
+      super
+    end
+  end
+
+
+  attr_accessor :datetime
+
+  def initialize(datetime)
+    @self.datetime = datetime
+  end
+
+  def method_missing(sym, *args, &blk)
+    @datetime.send(sym, *args, &blk)
+  end
+end

data/lib/telegram_bot/document.rb

@@ -0,0 +1,16 @@
+class TelegramBot::Document <
+      Struct.new(:id, :thumb, :file_name, :meme_type, :file_size)
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :file_id
+    }
+  end
+
+  def self.extra_types
+    {
+      thumb: PhotoSize
+    }
+  end
+end

data/lib/telegram_bot/force_reply.rb

@@ -0,0 +1,5 @@
+class TelegramBot::ForceReply <
+      Struct.new(:force_reply,
+                 :selective)
+  include AutoFromMethods
+end

data/lib/telegram_bot/group_chat.rb

@@ -0,0 +1,3 @@
+class GroupChat < Struct.new(:id, :title)
+  include AutoFromMethods
+end

data/lib/telegram_bot/handler.rb

@@ -0,0 +1,72 @@
+require 'ostruct'
+require 'active_support/inflector'
+
+require_relative 'matcher'
+require_relative 'blank_slate'
+
+module TelegramBot
+  module EventHandler
+    class Handler
+      attr_accessor :type, :action, :pass
+
+      def initialize(matcher, action, pass)
+        @matcher = matcher
+        @action  = action
+        @pass    = pass
+      end
+
+      def pass?
+        @pass
+      end
+
+      def ===(msg)
+        @matcher === msg
+      end
+
+      def arguments(msg)
+        @matcher.arguments(msg)
+      end
+    end
+
+
+    def self.included(clazz)
+      clazz.send :prepend, Class.new do
+        attr_accessor :handlers
+
+        def initialize(*args, &block)
+          @handlers = []
+          super(*args, &block)
+        end
+      end
+    end
+
+
+    def on(type, *args, pass: false, &block)
+      matcher_class = "#{type}_matcher".classify
+      matcher = matcher_class.new(*args)
+      handler = Handler.new(matcher, block, pass)
+      @handlers << handler
+    end
+
+    def handle(msg)
+      env = BlankSlate.new
+      self.extend_env(env)
+      msg.extend_env(env)
+
+      @handlers.each do |hndlr|
+        next unless hndlr === msg
+
+        hndlr.matcher.extend_env(env, msg)
+
+        env.extend do
+          define_method :handler do
+            hndlr
+          end
+        end
+
+        env.call(handler.arguments(msg),
+                 &handler.action)
+      end
+    end
+  end
+end

data/lib/telegram_bot/location.rb

@@ -0,0 +1,12 @@
+class TelegramBot::Location < Field.new(:longitude, :latitude)
+  include AutoFromMethods
+
+  def self.from(hsh, lat = nil)
+    case hsh
+    when Integer
+      new(hsh, lat)
+    else
+      super
+    end
+  end
+end

data/lib/telegram_bot/matcher.rb

@@ -0,0 +1,75 @@
+module TelegramBot
+  class Matcher
+    def env(msg)
+      msg.extend(BasicObject.new)
+    end
+
+    def ===(_)
+      false
+    end
+
+    def arguments(msg)
+      []
+    end
+
+    def extend_env(obj, msg)
+      obj
+    end
+  end
+
+  class TextMatcher < Matcher
+    attr_accessor :pattern
+
+    def initialize(pat = nil)
+      @pattern = pat
+    end
+
+    def ===(msg)
+      return false unless msg.type == :text
+      return true  if @pattern.nil?
+      @pattern === msg.text
+    end
+
+    def extend_env(obj, msg)
+      obj = super
+
+      if Regexp === @pattern
+        md = @pattern.match(msg.text)
+        obj.extend do
+          md.names.each do |grp|
+            value = md[grp]
+            define_method grp { value }
+          end
+        end
+      end
+
+      obj
+    end
+  end
+
+  class CommandMatcher < Matcher
+    attr_accessor :command
+
+    def initialize(command)
+      @command = command
+    end
+
+    def ===(msg)
+      msg.type == :text and msg.text.start_with?("/#{@command}")
+    end
+
+    def arguments(msg)
+      msg.text.split[1..-1]
+    end
+  end
+
+  class AnythingMatcher < Matcher
+    def ===(_)
+      true
+    end
+  end
+
+  class FallbackMatcher < AnythingMatcher
+  end
+
+end

data/lib/telegram_bot/message.rb

@@ -0,0 +1,95 @@
+class TelegramBot::Message <
+      Struct(:id,
+             :from,
+             :date,
+             :chat,
+             :forward_from,
+             :forward_date,
+             :reply_to_message,
+             :text,
+             :audio,
+             :document,
+             :photo,
+             :sticker,
+             :video,
+             :contact,
+             :location,
+             :new_chat_participant,
+             :left_chat_participant,
+             :new_chat_title,
+             :new_chat_photo,
+             :delete_chat_photo,
+             :group_chat_created)
+
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :message_id,
+    }
+  end
+
+  def self.extra_types
+    {
+      from: User,
+      chat: Chat,
+      forward_from: User,
+      forward_date: Date,
+      reply_to_message: Message,
+      text: String,
+      audio: Audio,
+      document: Document,
+      photo: [PhotoSize],
+      sticker: Sticker,
+      video: Video,
+      contact: Contact,
+      location: Location,
+      new_chat_participant: User,
+      left_chat_participant: User
+    }
+  end
+
+  def type
+    case
+    when text                  then :text
+    when photo                 then :photo
+    when audio                 then :audio
+    when document              then :document
+    when sticker               then :sticker
+    when video                 then :video
+    when contact               then :contact
+    when location              then :location
+    when new_chat_participant  then :member_entered
+    when left_chat_participant then :member_left
+    when new_chat_title        then :chat_title_updatd
+    when new_chat_photo        then :chat_photo_updated
+    when delete_chat_photo     then :chat_photo_deleted
+    when group_chat_created    then :group_chat_created
+    end
+  end
+
+  def is_forward?
+    !!forward_from
+  end
+
+  def is_reply?
+    !!reply_to_message
+  end
+
+  def extend_env(obj)
+    msg = self
+    obj.instace_eval do
+      @message = msg
+    end
+
+    members = self.members
+
+    obj.extend do
+      attr_reader :message
+      def_delegators :@message, *members
+      def_delegators :@message, :is_forward?, :is_reply?
+    end
+
+    obj
+  end
+end

data/lib/telegram_bot/objects.rb

@@ -0,0 +1,14 @@
+require_relative 'auto_from_methods'
+
+require_relative 'user'
+require_relative 'chat'
+require_relative 'group_chat'
+require_relative 'message'
+require_relative 'photo_size'
+require_relative 'audio'
+require_relative 'document'
+require_relative 'video'
+require_relative 'contact'
+require_relative 'location'
+require_relative 'update'
+require_relative 'date'

data/lib/telegram_bot/photo_size.rb

@@ -0,0 +1,10 @@
+class TelegramBot::PhotoSize <
+      Struct.new(:id, :width, :height, :file_size)
+  include AutoFromMethods
+
+  def hash_key_aliases
+    {
+      :id => :file_id
+    }
+  end
+end

data/lib/telegram_bot/poll_listener.rb

@@ -0,0 +1,29 @@
+module TelegramBot
+  class PollListener
+    def initialize(client, interval)
+      @client    = client
+      @interval  = interval
+      @offset_id = nil
+    end
+
+    def message_received(msg)
+      @client.append_history(msg)
+      @client.handle(msg)
+    end
+
+    def start!
+      loop do
+        get_updates
+        sleep @interval
+      end
+    end
+
+    def get_updates
+      updates = @client.get_updates(@offset_id, 50)
+      updates.each do |update|
+        @offset_id = update.id
+        message_received(update.message)
+      end
+    end
+  end
+end

data/lib/telegram_bot/reply_keyboard_hide.rb

@@ -0,0 +1,5 @@
+class TelegramBot::ReplyKeyboardHide <
+      Struct.new(:hide_keyboard,
+                 :selective)
+  include AutoFromMethods
+end

data/lib/telegram_bot/reply_keyboard_markup.rb

@@ -0,0 +1,7 @@
+class TelegramBot::ReplyKeyboardMarkup <
+      Struct.new(:keyboard,
+                 :resize_keyboard,
+                 :one_time_keyboard,
+                 :selective)
+  include AutoFromMethods
+end

data/lib/telegram_bot/request.rb

@@ -0,0 +1,36 @@
+require 'rest-client'
+require 'json'
+require 'active_support/inflector'
+
+module TelegramBot
+  module Request
+    class PrependMethods
+      attr_accessor :token
+
+      def initialize(*args, token:, &block)
+        @token = token
+        super(*args, &block)
+      end
+    end
+
+    API_BASE = 'https://api.telegram.org/bot'
+
+    def self.included(clazz)
+      clazz.prepend PrependMethods
+    end
+
+    def request(method, params)
+      url  = construct_url(method)
+      resp = RestClient.post(url, params)
+      return JONS.parse(resp.body) if resp.code.to_s =~ /^2\d\d$/
+      raise Exception.new(resp)
+    end
+
+    private
+
+    def construct_url(method)
+      method_camelized = method.to_s.camelize(:lower)
+      "#{API_BASE}#{@token}/#{method_camelized}"
+    end
+  end
+end

data/lib/telegram_bot/request_methods.rb

@@ -0,0 +1,107 @@
+module TelegramBot
+  module RequestMethods
+    def get_updates(offset: nil, limit: nil, timeout: nil)
+      params = {
+        offset:  offset,
+        limit:   limit,
+        timouet: timeout
+      }.reject {|_,v| v.nil?}
+
+      request(:get_update, params).map do |update|
+        Update.from(update)
+      end
+    end
+
+    def get_me
+      User.from(request(:get_me, {}))
+    end
+
+    def send_message(chat, text,
+                     disable_web_page_preview: nil,
+                     reply_to: nil,
+                     reply_markup: nil)
+      params = {
+        chat_id: Chat.from(chat).id,
+        text: text,
+        disable_web_page_preview: disable_web_page_preview,
+        reply_to_message_id: Chat.from(reply_to).id
+        # TODO:
+        # reply_markup: reply_markup
+      }.reject {|_,v| v.nil?}
+
+      Message.from(request(:send_message, params))
+    end
+
+    def forward_message(msg, to, from = nil)
+      from_chat = from.nil? ? msg.chat : Chat.from(from)
+
+      params = {
+        chat_id: Chat.from(chat).id,
+        from_chat_id: from_chat.id,
+        message_id: Message.from(msg).id
+      }
+
+      Message.from(request(:forward_message, params))
+    end
+
+
+    CHAT_ACTIONS = [
+      :typing,
+      :upload_photo,
+      :record_video,
+      :update_video,
+      :record_audio,
+      :upload_audio,
+      :upload_document,
+      :find_location
+    ]
+
+    def send_chat_action(chat, action)
+      unless CHAT_ACTIONS.include?(action.intern)
+        warn "invalid chat action #{action}, available actions are" +
+             " #{CHAT_ACTIONS.join(', ')}."
+        action = CHAT_ACTIONS.first
+      end
+
+      params = {
+        chat_id: Chat.from(chat).id,
+        action: action.to_s
+      }
+
+      request(:send_chat_action, params)
+      nil
+    end
+
+    METHODS = [
+      :get_me,
+      :send_message,
+      :forward_message,
+      :send_photo,
+      :send_document,
+      :send_sticker,
+      :send_video,
+      :send_location,
+      :send_chat_action,
+      :get_user_profile_photos,
+      :get_updates,
+      :set_webhook
+    ]
+
+    METHODS.each do |method|
+      is_defined = self.instance_methods(false).include?(method)
+      unless is_defined
+        alias_method method, :todo
+      end
+
+      alias_method "#{method}_raw", method
+    end
+
+
+    private
+
+    def todo(*args, &block)
+      defn_at = self.method(__callee__).source_location
+      warn "#{defn_at[0]}:<#{__callee__}>: not implemented"
+    end
+  end
+end

data/lib/telegram_bot/sticker.rb

@@ -0,0 +1,17 @@
+class TelegramBot::Sticker <
+      Struct(:id, :width, :height, :thumb, :file_size)
+
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :file_id
+    }
+  end
+
+  def self.extra_types
+    {
+      thumb: PhotoSize
+    }
+  end
+end

data/lib/telegram_bot/update.rb

@@ -0,0 +1,16 @@
+class TelegramBot::Update < Strict(:id, :message)
+  include AutoFromMethods
+
+  def self.extra_types
+    {
+      message: Message
+    }
+  end
+
+  def self.hash_key_aliases
+    {
+      id: :update_id
+    }
+  end
+
+end

data/lib/telegram_bot/user.rb

@@ -0,0 +1,4 @@
+class TelegramBot::User <
+      Struct.new(:id, :first_name, :last_name, :username)
+  include AutoFromMethods
+end

data/lib/telegram_bot/version.rb

@@ -0,0 +1,3 @@
+class TelegramBot
+  VERSION = "0.1.0"
+end

data/lib/telegram_bot/video.rb

@@ -0,0 +1,25 @@
+class TelegramBot::Video <
+      Struct.new(:id,
+                 :width,
+                 :height,
+                 :duration,
+                 :thumb,
+                 :mime_type,
+                 :file_size,
+                 :caption)
+
+  include AutoFromMethods
+
+  def self.hash_key_aliases
+    {
+      :id => :file_id
+    }
+  end
+
+  def self.extra_types
+    {
+      thumb: PhotoSize
+    }
+  end
+
+end

data/lib/telegram_bot.rb

@@ -0,0 +1,57 @@
+require 'telegram_bot/version'
+require 'telegram_bot/objects'
+require 'telegram_bot/handler'
+require 'telegram_bot/request'
+require 'telegram_bot/request_methods'
+require 'telegram_bot/poll_listener'
+
+class TelegramBot
+  include TelegramBot::EventHandler
+  include TelegramBot::Request
+  include TelegramBot::RequestMethods
+
+  attr_accessor :token, :handlers, :history
+
+  def initialize(history: 50, token:)
+    @token = token
+    @handlers = []
+    @history = []
+    @history_length = 50
+  end
+
+  def listen(method: :poll, interval: 5, path: '/hook')
+    @listen = {
+      method:   method,
+      interval: interval,
+      path:     path
+    }
+  end
+
+  def extend_env(env)
+    telegram_bot = self
+    env.extend do
+      define_method :bot do
+        telegram_bot
+      end
+      alias_method :client, :bot
+
+      define_method :history do
+        telegram_bot.history
+      end
+    end
+  end
+
+  def append_history(message)
+    @history << message
+    @history = @history.last(@history_length || 0)
+  end
+
+  def start!
+    case @listen[:method]
+    when :poll
+      PollListener.new(self, @listen[:interval])
+    when :webhook
+      warn 'not implemented'
+    end
+  end
+end

data/telegram_bot_ruby.gemspec

@@ -0,0 +1,29 @@
+# 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_ruby"
+  spec.version       = TelegramBot::VERSION
+  spec.authors       = ["Shou Ya"]
+  spec.email         = ["shouyatf@gmail.com"]
+
+  spec.summary       = %q{This is a bot framework that utilizes telegram's bots api}
+  spec.homepage      = "https://github.com/shouya/telegram-bot"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rest-client'
+  spec.add_dependency 'active_support'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: telegram_bot_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shou Ya
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  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: active_support
+  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.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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:
+- shouyatf@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/telegram_bot.rb
+- lib/telegram_bot/audio.rb
+- lib/telegram_bot/auto_from_methods.rb
+- lib/telegram_bot/blank_slate.rb
+- lib/telegram_bot/chat.rb
+- lib/telegram_bot/contact.rb
+- lib/telegram_bot/date.rb
+- lib/telegram_bot/document.rb
+- lib/telegram_bot/force_reply.rb
+- lib/telegram_bot/group_chat.rb
+- lib/telegram_bot/handler.rb
+- lib/telegram_bot/location.rb
+- lib/telegram_bot/matcher.rb
+- lib/telegram_bot/message.rb
+- lib/telegram_bot/objects.rb
+- lib/telegram_bot/photo_size.rb
+- lib/telegram_bot/poll_listener.rb
+- lib/telegram_bot/reply_keyboard_hide.rb
+- lib/telegram_bot/reply_keyboard_markup.rb
+- lib/telegram_bot/request.rb
+- lib/telegram_bot/request_methods.rb
+- lib/telegram_bot/sticker.rb
+- lib/telegram_bot/update.rb
+- lib/telegram_bot/user.rb
+- lib/telegram_bot/version.rb
+- lib/telegram_bot/video.rb
+- telegram_bot_ruby.gemspec
+homepage: https://github.com/shouya/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: '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: This is a bot framework that utilizes telegram's bots api
+test_files: []