telegram_meetup_bot 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0b6bb180e431520c43ac177e3afbc0b705f16cf
+  data.tar.gz: eab2300653e6d119aeecb18573e86955153a80b0
+SHA512:
+  metadata.gz: 453de1b09b75f1350be93ea83b4ffcbc5e0908d372826a489c9268f7e97ae673e7b91830f40f80f17a89067a4126b9a157f3d18f77f7c5c6bf438320688389fc
+  data.tar.gz: 700aa76255a6106c6473014bdbf7b7dfdbe35c310bfa4758bcf55b7f4a5846bd6a7d7415d3c9bbb86114346c1de4965ea29482d83d62338af54ce216cc40b5fd

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+cache: bundler
+rvm:
+ - "2.2"
+script: bundle exec rspec spec

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Timur Yanberdin
+
+MIT License
+
+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,50 @@
+# TelegramMeetupBot
+
+[![Build Status](https://travis-ci.org/mendab1e/telegram_meetup_bot.svg)](https://travis-ci.org/mendab1e/telegram_meetup_bot)
+
+Telegram bot for meetups organisation. It suits really well for small communities, where people want to attend a place together, but not on regular basis.
+
+![chat example](https://cloud.githubusercontent.com/assets/854386/9875843/23b37e8a-5bba-11e5-8c6f-c4777c8a1eff.png)
+
+## Installation
+
+Install redis: http://redis.io/
+
+Install the gem:
+
+    $ gem install telegram_meetup_bot
+
+## Usage
+
+Register your bot and [obtain a token](https://core.telegram.org/bots#botfather)
+
+Run redis server:
+
+    $ redis-server
+
+Generate sample configurations:
+
+    $ telegram_meetup_bot --generate
+
+You should specify your bot_token in ```~/.telegram_meetup_bot/config.yml```.
+```
+bot_token: 'insert your token here'
+redis_host: 'localhost'
+redis_port: '6379'
+redis_key: 'meetup_bot'
+```
+If you use more than one bot per redis server, use different redis_keys for each of them.
+
+Also you could change sample responses in ```~/.telegram_meetup_bot/responses.yml```. It uses templates ```%first_name%``` and ```%date%``` to display actual name and date in messages.
+
+Run your bot:
+
+    $ telegram_meetup_bot
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/telegram_meetup_bot/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/bin/telegram_meetup_bot

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'telegram_meetup_bot'
+
+config_path = File.join(ENV['HOME'], '.telegram_meetup_bot')
+
+if ARGV.first == '--generate'
+  FileUtils.mkdir(config_path) unless Dir.exist?(config_path)
+  samples_dir = File.expand_path('../../config_samples', __FILE__)
+  %w(config.yml responses.yml).each do |sample|
+    file = File.join(samples_dir, sample)
+    FileUtils.cp(file, config_path)
+    puts "#{config_path}/#{sample} generated"
+  end
+else
+  TelegramMeetupBot.run config_path
+end

data/config_samples/config.yml

@@ -0,0 +1,4 @@
+bot_token: 'insert your token here'
+redis_host: 'localhost'
+redis_port: '6379'
+redis_key: 'meetup_bot'

data/config_samples/responses.yml

@@ -0,0 +1,20 @@
+today: "We are waiting for you today, %first_name%."
+today_list: "Today visitors:"
+today_cancel: "We are waiting for you next time, %first_name%."
+date: "We are waiting for you on %date%, %first_name%."
+date_list: "%date% visitors:"
+date_cancel: "We are waiting for you next time, %first_name%."
+wrong_date_format: "Error: wrong date format. Correct formats are dd, dd.mm or dd.mm.yy."
+old_date: "This date is too old."
+nobody: "No one planned to come on %date%."
+not_subscribed: "You wasn't subscribed on %date%."
+no_username: "%first_name%, please set a username in the Telegram settings."
+help: |
+  Hi, %first_name%. Use this commands list:
+  /today 14:00 - add yourself to the today list (time is optional);
+  /today_list - display the today list;
+  /today_cancel - remove yourself from the today list;
+  /date 23 14:00 - add yourself to the list on 23rd of the current month (time is optional);
+  /date_list 23.04 - display the list for April 23 of the current year;
+  /date_cancel 23.04.16 - remove yourself from the list on 23.04.16;
+  There are 3 formats for date available: 14 - day, 14.09 - day and month, 14.09.15 - day, month and year;

data/lib/telegram_meetup_bot/calendar.rb

@@ -0,0 +1,58 @@
+module TelegramMeetupBot
+  class Calendar
+    attr_reader :storage, :user, :date, :time
+
+    def initialize(args)
+      @storage = Initializers::ConfigLoader.storage
+      @date = args.fetch(:date)
+      @user = args.fetch(:user)
+      @time = args[:time]
+    end
+
+    def self.formated_users_for_date(date)
+      storage = Initializers::ConfigLoader.storage
+      users = storage.get_users_for_date(date)
+      users.map! do |user|
+        username = user[:username] ? " @#{user[:username]}" : ''
+        "#{user[:first_name]}#{username} #{user[:time]}"
+      end
+      users.join("\n")
+    end
+
+    def add_user_to_date
+      process_user do |users, saved_user|
+        return if saved_user == user_hash
+        users.delete(saved_user) if saved_user
+        users << user_hash
+        storage.set_users_to_date(users, date)
+      end
+    end
+
+    def delete_user_from_date
+      process_user do |users, saved_user|
+        if saved_user
+          users.delete(saved_user)
+          storage.set_users_to_date(users, date)
+          true
+        end
+      end
+    end
+
+    private
+
+    def process_user(&block)
+      users = storage.get_users_for_date(date)
+      saved_user = users.find { |u| u[:id] == user.id }
+
+      yield users, saved_user
+    end
+
+    def user_hash
+      @user_hash ||= if time
+        user.to_h.merge(time: time)
+      else
+        user.to_h
+      end
+    end
+  end
+end

data/lib/telegram_meetup_bot/client.rb

@@ -0,0 +1,24 @@
+module TelegramMeetupBot
+  class Client
+    attr_reader :token
+
+    def initialize(token)
+      @token = token
+    end
+
+    def run
+      begin
+        Telegram::Bot::Client.run(token) do |bot|
+          bot.listen do |message|
+            messenger = Messenger.new(api: bot.api, chat_id: message.chat.id)
+            CommandsHandler.new(message: message, messenger: messenger).process
+          end
+        end
+      rescue Telegram::Bot::Exceptions::ResponseError => e
+        puts e
+        sleep 1
+        run # run again on telegram server error
+      end
+    end
+  end
+end

data/lib/telegram_meetup_bot/commands_handler.rb

@@ -0,0 +1,108 @@
+module TelegramMeetupBot
+  class CommandsHandler
+    COMMANDS = %w(today today_list today_cancel date date_list date_cancel help)
+    attr_reader :command, :params, :author, :messenger
+
+    def initialize(args)
+      parser = MessageParser.new(args.fetch(:message))
+      @messenger = args.fetch(:messenger)
+      @command = COMMANDS.include?(parser.command) ? parser.command : 'help'
+      @params = parser.params
+      @author = parser.author
+    end
+
+    def process
+      if method(command).arity == 0
+        send command
+      else
+        send command, params
+      end
+
+      no_username_notification unless author.username
+    end
+
+    private
+
+    def today(params)
+      time = ParamsParser.new(params.first).parse_time if params.first
+      handle_date(Date.today, time)
+    end
+
+    def date(params)
+      date = ParamsParser.new(params.first).parse_date
+      time = ParamsParser.new(params[1]).parse_time if params[1]
+      handle_date(date, time) if date_is_valid?(date)
+    end
+
+    def handle_date(date, time)
+      Calendar.new(date: date, user: author, time: time).add_user_to_date
+      messenger.send build_response(date: date)
+    end
+
+    def today_list
+      handle_date_list Date.today
+    end
+
+    def date_list(params)
+      date = ParamsParser.new(params.first).parse_date
+      handle_date_list(date) if date_is_valid?(date)
+    end
+
+    def handle_date_list(date)
+      users = Calendar.formated_users_for_date(date)
+      messenger.send list_response(date, users)
+    end
+
+    def today_cancel
+      handle_date_cancel Date.today
+    end
+
+    def date_cancel(params)
+      date = ParamsParser.new(params.first).parse_date
+      handle_date_cancel(date) if date_is_valid?(date)
+    end
+
+    def handle_date_cancel(date)
+      calendar = Calendar.new(date: date, user: author)
+      deleted = calendar.delete_user_from_date
+      args = deleted ? {} : {key: 'not_subscribed', date: date}
+      messenger.send build_response(args)
+    end
+
+    def help
+      messenger.send build_response
+    end
+
+    def no_username_notification
+      messenger.send build_response(key: 'no_username')
+    end
+
+    def date_is_valid?(date)
+      if date.nil?
+        messenger.send build_response(key: 'wrong_date_format')
+        return false
+      elsif date < Date.today
+        messenger.send build_response(key: 'old_date')
+        return false
+      end
+      true
+    end
+
+    def list_response(date, list)
+      if list.empty?
+        build_response(key: 'nobody', date: date)
+      else
+        build_response(date: date) { |response| "#{response}\n#{list}" }
+      end
+    end
+
+    def build_response(args = {})
+      response_key = args.fetch(:key) { command }
+      response = Initializers::ResponsesLoader.responses[response_key].dup
+      response.gsub!('%first_name%', author.first_name)
+      response.gsub!('%date%', args[:date].strftime('%d %h %Y')) if args[:date]
+
+      block_given? ? yield(response) : response
+    end
+  end
+end

data/lib/telegram_meetup_bot/initializers/base.rb

@@ -0,0 +1,37 @@
+module TelegramMeetupBot
+  module Initializers
+    class Base
+      private
+
+      class << self
+        def preload(config_path)
+          @configurations ||= begin
+            file = File.join(config_path, self::FILE_NAME)
+            check_if_exist(file)
+            config = YAML.load(File.open(file).read)
+            validate(config.keys, file)
+            config.map { |_,v| v.freeze }
+            config
+          end
+        end
+
+        def check_if_exist(file)
+          unless File.exist? file
+            puts "Error: file not found #{file}"
+            exit
+          end
+        end
+
+        def validate(keys, file)
+          missing_keys = self::AVAILABLE_KEYS - keys
+
+          if missing_keys.any?
+            puts "Error: missing params in #{file}\n#{missing_keys.join(', ')}"
+            exit
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/telegram_meetup_bot/initializers/config_loader.rb

@@ -0,0 +1,34 @@
+require 'redis'
+
+module TelegramMeetupBot
+  module Initializers
+    class ConfigLoader < Base
+      FILE_NAME = 'config.yml'
+      AVAILABLE_KEYS = %w(bot_token redis_key redis_port redis_host)
+
+      class << self
+        def storage
+          @storage ||= Storage.new(redis: redis, redis_key: redis_key)
+        end
+
+        def token
+          @configurations['bot_token']
+        end
+
+        private
+
+        def redis_key
+          @configurations['redis_key']
+        end
+
+        def redis
+          @redis ||= Redis.new(
+            host: @configurations['redis_host'],
+            port: @configurations['redis_port']
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/telegram_meetup_bot/initializers/responses_loader.rb

@@ -0,0 +1,13 @@
+module TelegramMeetupBot
+  module Initializers
+    class ResponsesLoader < Base
+      FILE_NAME = 'responses.yml'
+      AVAILABLE_KEYS = %w(today today_list today_cancel date date_list
+        date_cancel wrong_date_format old_date nobody not_subscribed help)
+
+      def self.responses
+        @configurations
+      end
+    end
+  end
+end

data/lib/telegram_meetup_bot/initializers.rb

@@ -0,0 +1,5 @@
+require 'yaml'
+
+require 'telegram_meetup_bot/initializers/base'
+require 'telegram_meetup_bot/initializers/responses_loader'
+require 'telegram_meetup_bot/initializers/config_loader'

data/lib/telegram_meetup_bot/message_parser.rb

@@ -0,0 +1,31 @@
+module TelegramMeetupBot
+  class MessageParser
+    attr_reader :message
+    User = Struct.new(:id, :username, :first_name)
+
+    def initialize(message)
+      @message = message
+    end
+
+    def author
+      from = message.from
+      User.new(from.id, from.username, from.first_name)
+    end
+
+    def command
+      parse_message { |words| words.first }
+    end
+
+    def params
+      parse_message { |words| words.drop(1) } || []
+    end
+
+    private
+
+    def parse_message(&block)
+      if message.text[0] == '/' && message.text.length > 1
+        yield message.text[1..-1].split(' ')
+      end
+    end
+  end
+end

data/lib/telegram_meetup_bot/messenger.rb

@@ -0,0 +1,14 @@
+module TelegramMeetupBot
+  class Messenger
+    attr_reader :api, :chat_id
+
+    def initialize(args)
+      @api = args.fetch(:api)
+      @chat_id = args.fetch(:chat_id)
+    end
+
+    def send(text)
+      api.send_message(chat_id: chat_id, text: text)
+    end
+  end
+end

data/lib/telegram_meetup_bot/params_parser.rb

@@ -0,0 +1,29 @@
+require 'date'
+require 'time'
+
+module TelegramMeetupBot
+  class ParamsParser
+    attr_reader :arg
+
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def parse_date
+      format = case arg
+      when /^[0-9]{,2}\.[0-9]{,2}\.[0-9][0-9]$/
+        "%d.%m.%y"
+      when /^[0-9]{,2}\.[0-9]{,2}$/
+        "%d.%m"
+      when /^[0-9]{,2}$/
+        "%d"
+      end
+
+      Date.strptime(arg, format) rescue nil
+    end
+
+    def parse_time
+      Time.parse(arg).strftime('%R') rescue nil
+    end
+  end
+end

data/lib/telegram_meetup_bot/storage.rb

@@ -0,0 +1,19 @@
+module TelegramMeetupBot
+  class Storage
+    attr_reader :redis, :key
+
+    def initialize(args)
+      @redis = args.fetch(:redis)
+      @key = args.fetch(:redis_key)
+    end
+
+    def get_users_for_date(date)
+      users_yml = redis.hget(key, date)
+      users_yml.nil? ? [] : YAML.load(users_yml)
+    end
+
+    def set_users_to_date(users, date)
+      redis.hset(key, date, users.to_yaml)
+    end
+  end
+end

data/lib/telegram_meetup_bot/version.rb

@@ -0,0 +1,3 @@
+module TelegramMeetupBot
+  VERSION = "0.0.1"
+end

data/lib/telegram_meetup_bot.rb

@@ -0,0 +1,21 @@
+require 'telegram/bot'
+
+require "telegram_meetup_bot/version"
+require "telegram_meetup_bot/initializers"
+require "telegram_meetup_bot/client"
+require "telegram_meetup_bot/messenger"
+require "telegram_meetup_bot/message_parser"
+require "telegram_meetup_bot/storage"
+require "telegram_meetup_bot/calendar"
+require "telegram_meetup_bot/commands_handler"
+require "telegram_meetup_bot/params_parser"
+# require 'pry'
+
+module TelegramMeetupBot
+  def self.run(config_path)
+    Initializers::ResponsesLoader.preload(config_path)
+    Initializers::ConfigLoader.preload(config_path)
+
+    Client.new(Initializers::ConfigLoader.token).run
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'telegram_meetup_bot'
+require File.expand_path('../../lib/telegram_meetup_bot.rb', __FILE__)
+
+RSpec.configure do |config|
+end

data/spec/telegram_meetup_bot/calendar_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe TelegramMeetupBot::Calendar do
+  let(:storage) { double('storage') }
+  let(:user) { TelegramMeetupBot::MessageParser::User.new(1, 'Ikari01', 'Shinji') }
+  before { allow(TelegramMeetupBot::Initializers::ConfigLoader).to receive(:storage).and_return(storage)}
+  subject { described_class.new(user: user, date: Date.today, time: '10:00') }
+
+  describe '#delete_user_from_date' do
+    before { allow(storage).to receive(:set_users_to_date) }
+
+    context "when user exists in storage on selected date" do
+      before { allow(storage).to receive(:get_users_for_date).and_return([user.to_h]) }
+
+      it { expect(subject.delete_user_from_date).to eq(true) }
+      it 'set array without user to storage' do
+        expect(storage).to receive(:set_users_to_date).with([], Date.today)
+        subject.delete_user_from_date
+      end
+    end
+
+    context "when user doesn't exists in storage on selected date" do
+      before { allow(storage).to receive(:get_users_for_date).and_return([]) }
+
+      it { expect(subject.delete_user_from_date).to eq(nil) }
+      it 'set array without user to storage' do
+        expect(storage).not_to receive(:set_users_to_date)
+        subject.delete_user_from_date
+      end
+    end
+  end
+
+  describe '#add_user_to_date' do
+    before { allow(storage).to receive(:set_users_to_date) }
+
+    context "when user exists in storage on selected date with equal hash" do
+      before { allow(storage).to receive(:get_users_for_date).and_return([user.to_h.merge(time: '10:00')]) }
+
+      it "doesn't update storage" do
+        expect(storage).not_to receive(:set_users_to_date)
+        subject.add_user_to_date
+      end
+    end
+
+    context "when user exists in storage on selected date with different hash" do
+      before { allow(storage).to receive(:get_users_for_date).and_return([user.to_h.merge(time: '11:00')]) }
+
+      it "updates storage with new user hash" do
+        expect(storage).to receive(:set_users_to_date).with([user.to_h.merge(time: '10:00')], Date.today)
+        subject.add_user_to_date
+      end
+    end
+
+    context "when user doesn't exist in storage on selected date " do
+      before { allow(storage).to receive(:get_users_for_date).and_return([]) }
+
+      it "updates storage with new user hash" do
+        expect(storage).to receive(:set_users_to_date).with([user.to_h.merge(time: '10:00')], Date.today)
+        subject.add_user_to_date
+      end
+    end
+  end
+end

data/spec/telegram_meetup_bot/message_parser_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe TelegramMeetupBot::MessageParser do
+  let(:from) { instance_double('from', id: 1, username: 'Ikari01', first_name: 'Shinji') }
+  let(:message) { instance_double('message', text: '/today', from: from) }
+  subject { described_class.new(message) }
+
+  describe '#command_with_params' do
+    context "when message doesn't start with / " do
+      let(:message) { instance_double('message', text: 'today', from: from) }
+
+      it { expect(subject.command).to eq(nil) }
+      it { expect(subject.params).to eq([]) }
+    end
+
+    context "when message contain only / " do
+      let(:message) { instance_double('message', text: '/', from: from) }
+
+      it { expect(subject.command).to eq(nil) }
+      it { expect(subject.params).to eq([]) }
+    end
+
+    context "when message without params" do
+      let(:message) { instance_double('message', text: '/today', from: from) }
+
+      it { expect(subject.command).to eq('today') }
+      it { expect(subject.params).to eq([]) }
+    end
+
+    context "when message with params" do
+      let(:message) { instance_double('message', text: '/date 08.11.1998', from: from) }
+
+      it { expect(subject.command).to eq('date') }
+      it { expect(subject.params).to eq(['08.11.1998']) }
+    end
+  end
+
+  describe '#author' do
+    context "returns struct with author's data" do
+      user = TelegramMeetupBot::MessageParser::User.new(1, 'Ikari01', 'Shinji')
+      it { expect(subject.author).to eq(user) }
+    end
+  end
+end

data/spec/telegram_meetup_bot/params_parser_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'date'
+
+RSpec.describe TelegramMeetupBot::ParamsParser do
+  describe '#parse_date' do
+    context 'fulldate' do
+      let(:dates) { %w(3.02.07 3.2.07 03.02.07 03.2.07) }
+
+      it 'works' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_date).to eq(Date.parse('2007-02-03'))
+        end
+      end
+    end
+
+    context 'day with month' do
+      let(:dates) { %w(3.02 3.2 03.02 03.2) }
+      let(:year) { Date.today.year }
+
+      it 'works' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_date).to eq(Date.parse("#{year}-02-03"))
+        end
+      end
+    end
+
+    context 'only day' do
+      let(:dates) { %w(3 03) }
+
+      it 'works' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_date).to eq(Date.parse("03"))
+        end
+      end
+    end
+
+    context 'wrong format' do
+      let(:dates) { %w(abc 3.02.2007 3.02.7 2007.02.03 3-02-07 32.03.07 32) }
+
+      it 'returns nil' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_date).to eq(nil)
+        end
+      end
+    end
+  end
+
+  describe '#parse_time' do
+    context 'correct' do
+      let(:dates) { %w(01:05 1:05 1:5) }
+
+      it 'works' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_time).to eq('01:05')
+        end
+      end
+    end
+
+    context 'wrong_format' do
+      let(:dates) { %w(abc 25:05 01:61 -3) }
+
+      it 'works' do
+        dates.each do |date|
+          expect(described_class.new(date).parse_time).to eq(nil)
+        end
+      end
+    end
+  end
+end

data/telegram_meetup_bot.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'telegram_meetup_bot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "telegram_meetup_bot"
+  spec.version       = TelegramMeetupBot::VERSION
+  spec.authors       = ["Timur Yanberdin"]
+  spec.email         = ["yanberdint@gmail.com"]
+  spec.summary       = "Telegram bot for meetups organisation"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = "telegram_meetup_bot"
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency 'redis'
+  spec.add_dependency 'telegram-bot-ruby'
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: telegram_meetup_bot
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Timur Yanberdin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: 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'
+description: 
+email:
+- yanberdint@gmail.com
+executables:
+- telegram_meetup_bot
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/telegram_meetup_bot
+- config_samples/config.yml
+- config_samples/responses.yml
+- lib/telegram_meetup_bot.rb
+- lib/telegram_meetup_bot/calendar.rb
+- lib/telegram_meetup_bot/client.rb
+- lib/telegram_meetup_bot/commands_handler.rb
+- lib/telegram_meetup_bot/initializers.rb
+- lib/telegram_meetup_bot/initializers/base.rb
+- lib/telegram_meetup_bot/initializers/config_loader.rb
+- lib/telegram_meetup_bot/initializers/responses_loader.rb
+- lib/telegram_meetup_bot/message_parser.rb
+- lib/telegram_meetup_bot/messenger.rb
+- lib/telegram_meetup_bot/params_parser.rb
+- lib/telegram_meetup_bot/storage.rb
+- lib/telegram_meetup_bot/version.rb
+- spec/spec_helper.rb
+- spec/telegram_meetup_bot/calendar_spec.rb
+- spec/telegram_meetup_bot/message_parser_spec.rb
+- spec/telegram_meetup_bot/params_parser_spec.rb
+- telegram_meetup_bot.gemspec
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Telegram bot for meetups organisation
+test_files:
+- spec/spec_helper.rb
+- spec/telegram_meetup_bot/calendar_spec.rb
+- spec/telegram_meetup_bot/message_parser_spec.rb
+- spec/telegram_meetup_bot/params_parser_spec.rb