rbender 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b890be6a91b37ef81fbf86ff6dd52a3ba3d1edbb
+  data.tar.gz: cdf21a6de8c3cf294d185b8a5afeb7136354d530
+SHA512:
+  metadata.gz: 8f4323aac3697a92d4946b40cabdbe34a307c8cf5701c0bffa98da76b771a1c974dc35548a9a4ba4a1b6de31c06e58840a8e01463f1805f7ac9c85a588c92387
+  data.tar.gz: 33391ad4a580ff4b19a8d0b744f7084c60b6a7a56ba30b834814d299fc50f40f89ac2bed5fdbe55d2bfd97e3c619ccc0a5be0de8534eb123daef23adc091a5c8

data/bin/rbender

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# require 'rbender'
+
+
+if ARGV.any?
+
+	require 'optparse'
+	OptionParser.new do |op|
+		op.on("new NAME", 'creates new bot\'s environment') do |name|
+			puts name.to_s
+			puts 'here'
+		end
+	end.parse!(ARGV.dup)
+end
+

data/lib/rbender/base.rb

@@ -0,0 +1,169 @@
+# require_relative '../rbender'
+# require_relative 'sessionmanager'
+
+require 'rbender/sessionmanager'
+require 'rbender/keyboard_inline'
+require 'rbender/mongo_client'
+require 'rbender/state'
+
+require 'telegram/bot'
+
+
+class RBender::Base
+  attr_accessor :api
+  include RBender::SessionManager
+
+  def initialize
+    @states = {}
+    @global_state = nil
+    @modules_block
+  end
+
+  def modules(&modules_block)
+    @modules_block = modules_block
+  end
+
+  # Runs the bot with server
+  public
+  def run!
+    puts "Bot is loading...".green
+    puts "Bot is running...".green
+    Telegram::Bot::Client.run(@token) do |bot|
+      @api = bot.api
+
+      unless @modules_block.nil?
+        instance_exec(@api, @mongo_client, &@modules_block)
+      end
+      bot.listen do |message| # When message has gotten
+        # begin
+          _process_message(message)
+        # rescue => ex
+        #   puts ex.message
+        # end
+      end
+    end
+  end
+
+  public
+  def _process_message(message)
+    chat_id = message.from.id # Unique chat ID
+
+    if has_session?(chat_id)
+      session = load_session(chat_id)
+
+    else # If user is new
+      session = {_state: :start,
+                 _state_stack: [],
+                 _keyboard_switchers: {},
+                 _keyboard_switch_groups: {},
+                 _lang: :default
+      }
+
+    end
+    session[:user] = {chat_id: chat_id,
+                      first_name: message.from.first_name,
+                      last_name: message.from.last_name,
+                      username: message.from.username
+    }
+
+    session[:user].freeze # User's data must be immutable!
+
+    if is_start_message? message
+      session[:_state] = :start
+      session[:_state_stack] = []
+    end
+
+    state = session[:_state] # User's state
+    state_block = @states[state] # Block of the state
+    state_object = RBender::State.new message, # Object to invoke
+                                      @api,
+                                      session,
+                                      &state_block
+    state_object.instance_eval(&@global_state) unless @global_state.nil?
+    state_object._build
+    state_object._invoke
+    save_session session
+
+    state_new = session[:_state] # New user's state
+
+    unless state_new == state # If state has changed
+      state_object._invoke_after if state_object.has_after? #invoke after hook for an old state
+
+      state_new_block = @states[state_new]
+      state_object = RBender::State.new message,
+                                        @api,
+                                        session,
+                                        &state_new_block
+
+      state_object.instance_eval(&@global_state) unless @global_state.nil?
+      state_object._build
+
+      if state_object.has_keyboard? # Invoke a keyboard if it's exists
+        state_object._build_keyboard
+        state_object._invoke_keyboard
+      end
+
+      state_object._invoke_before if state_object.has_before? #invoke before hook for a new state
+    else
+      if state_object.has_keyboard? # Invoke a keyboard if it's exists
+        unless state_object._keyboard.one_time? or not state_object._keyboard.force_invoked?
+          state_object._build_keyboard
+          state_object._invoke_keyboard
+        end
+      end
+    end
+  end
+
+  def is_start_message?(message)
+    if message.instance_of? Telegram::Bot::Types::Message
+      if message.text == '/start'
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # @param [Hash] params - hash with params
+  #
+  # Available parameters:
+  # * mongo_server_ip (required)
+  # * mongo server_port  (required)
+  # * bot_name (required)
+  # * token (required)
+  # * localizations(optional) default = :default
+  def set_params(params)
+    RBender::MongoClient.setup(params[:bot_name],
+                               params[:mongo_server_ip],
+                               params[:mongo_server_port])
+
+    session_setup(RBender::MongoClient.client)
+
+    @token = params[:token]
+    # if params.has_key? localizations
+    #
+    # end
+  end
+
+
+  # Adds new state to the bot.
+  # @param [String] state_name - name of the state
+  # @param [Block] block - actions while state has invoked
+  #
+  public
+  def state(state_name, &block)
+    unless @states.has_key? state_name
+      @states[state_name] = block
+    else
+      raise "State name is duplicated!"
+    end
+  end
+
+
+  def global(&block)
+    @global_state = block
+  end
+
+end
+
+

data/lib/rbender/keyboard.rb

@@ -0,0 +1,143 @@
+class RBender::Keyboard
+
+  attr_accessor :markup,
+                :localizations,
+                :actions,
+                :response,
+                :switchers,
+                :markup_tg,
+                :markup_final,
+                :switch_groups,
+                :session
+
+  def initialize(response)
+    @response = response
+    @actions = {}
+    @markup = []
+    @localizations = {}
+    @switchers = {}
+    @markup_tg = nil
+    @markup_final = {}
+    @switch_groups = {}
+    @button_switch_group = {}
+    @one_time = false
+    @session = nil
+    @hide_on_action = false
+    @resize = false
+    @force_invoke = false
+  end
+
+  def hide_on_action
+    @hide_on_action = true
+  end
+
+  def force_invoked?
+    @force_invoke
+  end
+
+  # Adds button to the keyboard
+  #
+  # Example:
+  # button :btn_test, "Test button" do
+  #     some_actions
+  # end
+  #
+  # button :btn_with_loc, {ru: "Кнопка", en: "Button"} do
+  #     some_actions
+  # end
+
+  def button(id, localizations, *icons, &action)
+    @actions[id] = action
+    @localizations[id] = localizations
+  end
+
+  # Checks keyboard one time or not
+  def one_time?
+    @one_time
+  end
+
+  # makes a keyboard one time
+  def one_time
+    @one_time = true
+  end
+
+  # Add a line to markup
+  def add_line (*buttons)
+    @markup += [buttons]
+  end
+
+  # Set response when keyboard is invoked
+  def set_response(new_response)
+    @response = new_response
+  end
+
+  # Adds switcher to buttons
+  def switcher(id, *switches)
+    @switchers[id] = switches
+  end
+
+  # Adds switch group
+  def switch_group(group_name, *buttons)
+    @switch_groups[group_name] = buttons
+  end
+
+  # Resize telegram buttons
+  def resize
+    @resize = true
+  end
+
+  # Adds button switch group
+  def button_switch_group(button_id)
+    @switch_groups.each do |group, buttons|
+      if buttons.include? button_id
+        return group
+      end
+    end
+    nil
+  end
+
+  # Method to initialize a keyboard
+  #
+  def _build(session)
+    #TODO: add localization support
+    markup = []
+    @markup.each do |line|
+      buf_line = []
+      line.each do |button_id|
+        btn_id = button_id # used for replacing group mask
+        if @switch_groups.member? button_id # if it's switch group mask
+          button_num = 0
+          if session[:_keyboard_switch_groups].member? btn_id
+            button_num = session[:_keyboard_switch_groups][btn_id]
+          else
+            session[:_keyboard_switch_groups][btn_id] = 0
+          end
+          button = @localizations[@switch_groups[button_id][button_num]].dup
+          btn_id = @switch_groups[btn_id][button_num]
+        else # if it's normal button
+          button = @localizations[btn_id].dup
+        end
+
+        if @switchers.member? btn_id # Code for switcher
+          switch_num = 0
+          if session[:_keyboard_switchers].member? btn_id # If switcher inside session
+            switch_num = session[:_keyboard_switchers][btn_id]
+          else
+            session[:_keyboard_switchers][btn_id] = 0 # Switcher init
+          end
+          switcher = @switchers[btn_id][switch_num]
+          button << " " << switcher unless switcher.empty?
+        end
+
+        buf_line << button
+        @markup_final[btn_id] = button
+      end
+      markup << buf_line
+    end
+    # puts @keyboard.markup_final
+    @markup_tg = Telegram::Bot::Types::ReplyKeyboardMarkup
+                     .new(keyboard: markup,
+                          one_time_keyboard: one_time?,
+                          resize_keyboard: @resize)
+  end
+end

data/lib/rbender/keyboard_inline.rb

@@ -0,0 +1,72 @@
+CALLBACK_SPLITTER = '|'
+
+class RBender::KeyboardInline
+  attr_accessor :markup_tg,
+                :buttons_actions
+
+  def initialize(name, session, block)
+    @name = name
+    @buttons_callback = {}
+    @buttons_inline = {}
+    @buttons_links = {}
+    @buttons_actions = {}
+    @markup = []
+    @markup_tg = []
+    @session = session
+    @keyboard_block = block
+  end
+
+  def session
+    @session
+  end
+
+  # Adds button with callback
+  def button(name, description, &action)
+    callback = @name.to_s + RBender::CALLBACK_SPLITTER + name.to_s
+    @buttons_callback[name] = Telegram::Bot::Types::InlineKeyboardButton.new(text: description,
+                                                                             callback_data: callback)
+    @buttons_actions[name.to_s] = action
+  end
+
+  # Adds link button
+  def button_link(name, description, link)
+    @buttons_links[name] = Telegram::Bot::Types::InlineKeyboardButton.new(text: description,
+                                                                          url: link)
+  end
+
+  # Adds inline switch mode button
+  def button_inline(name, description, inline_query)
+    @buttons_inline[name] = Telegram::Bot::Types::InlineKeyboardButton.new(text: description,
+                                                                           switch_inline_query: inline_query)
+  end
+
+  # Adds a line to markup
+  def add_line(*buttons)
+    @markup += [buttons]
+  end
+
+  def _invoke
+    instance_eval(&@keyboard_block)
+  end
+
+  def _build
+    @markup = []
+    _invoke
+
+    buttons = {}
+    buttons.merge! @buttons_callback
+    buttons.merge! @buttons_links
+    buttons.merge! @buttons_inline
+
+    markup = []
+    @markup.each do |btn_row|
+      line = []
+      btn_row.each do |btn|
+        raise "The #{buttons[btn]} doesn't exists" if btn.nil?
+        line << buttons[btn]
+      end
+      markup << line
+    end
+    @markup_tg = Telegram::Bot::Types::InlineKeyboardMarkup.new(inline_keyboard: markup)
+  end
+end

data/lib/rbender/mongo_client.rb

@@ -0,0 +1,25 @@
+require 'mongo'
+require 'singleton'
+
+class RBender::MongoClient
+  include Singleton
+  attr_reader :mongo_client
+
+  public
+  def self.client
+    instance.mongo_client
+  end
+
+  def self.setup(bot_name, mongo_server_ip, mongo_server_port)
+    instance.setup(bot_name, mongo_server_ip, mongo_server_port)
+  end
+
+  def setup(bot_name, mongo_server_ip, mongo_server_port)
+    @bot_name = bot_name
+    @mongo_server_ip = mongo_server_ip
+    @mongo_server_port = mongo_server_port
+    @mongo_client = Mongo::Client.new(["#{mongo_server_ip}:#{mongo_server_port}"], :database => bot_name)
+
+    Mongo::Logger.logger.level = ::Logger::FATAL
+  end
+end

data/lib/rbender/sessionmanager.rb

@@ -0,0 +1,52 @@
+module RBender
+  module SessionManager
+
+    private
+    def session_setup(mongo_client)
+      @mongo_client = mongo_client
+      @sessions_mongo = @mongo_client[:sessions]
+    end
+
+    def load_session(chat_id)
+      result = nil
+      @sessions_mongo.find(chat_id: chat_id).each do |document|
+        result = document[:session]
+      end
+      result
+    end
+
+    def save_session(session)
+      @sessions_mongo.update_one({chat_id: session[:user][:chat_id]},
+                                 {'$set' => {session: session}},
+                                 {upsert: true})
+    end
+
+    def has_session?(chat_id)
+      count = @sessions_mongo.find(chat_id: chat_id).count
+      count > 0 ? true : false
+    end
+
+    public
+    def self.chatid_list
+      sessions = RBender::MongoClient.client[:sessions]
+      result = sessions.distinct('chat_id')
+      chatid_list = []
+      result.each do |doc|
+        chatid_list << doc
+      end
+      chatid_list
+    end
+  end
+end
+
+#
+# Mongo scheme:
+# Session
+# {chat_id: {session_key: session_value}}
+#
+# States
+# {chat_id: state}
+#
+#
+#
+#

data/lib/rbender/state.rb

@@ -0,0 +1,288 @@
+require_relative '../r_bender'
+
+class RBender::State
+  def initialize(message, api, session, &state_block)
+    @message = message
+    @api = api
+    @session = session
+    @state_block = state_block
+    @keyboard = nil
+    @inline_keyboards = {}
+    @action_after = nil
+    @action_before = nil
+    @text_action = nil
+    @helpers_block = nil
+  end
+
+  def _keyboard
+    @keyboard
+  end
+
+  # Invokes states and processes user's input
+  def _invoke
+    case message
+      when Telegram::Bot::Types::CallbackQuery
+        _process_callback
+      when Telegram::Bot::Types::Message
+        _process_text_message
+      else
+        puts "This type isn't available: #{message.class}"
+    end
+  end
+
+  # Process if message is just text
+  def _process_text_message
+
+    unless @keyboard.nil? # if state has keyboard
+      @keyboard.instance_eval(&@helpers_block) unless @helpers_block.nil?
+      _build_keyboard
+
+      @keyboard.markup_final.each do |btn, final_btn|
+        if message.text == final_btn
+          instance_exec(&@keyboard.actions[btn])
+
+          unless (group_id = @keyboard.button_switch_group(btn)).nil? # Switch group's logic
+            group_size = @keyboard.switch_groups[group_id].size
+            @session[:_keyboard_switch_groups][group_id] += 1
+            @session[:_keyboard_switch_groups][group_id] %= group_size
+          end
+          if @keyboard.switchers.member? btn # Switcher's Logic
+            switcher_size = @keyboard.switchers[btn].size
+            @session[:_keyboard_switchers][btn] += 1
+            @session[:_keyboard_switchers][btn] %= switcher_size
+          end
+          return
+        end
+      end
+    end
+
+    unless @text_action.nil?
+
+      instance_exec(@message.text, &@text_action)
+    end
+
+  end
+
+  # Process if message is inline keyboard callback
+  def _process_callback
+    keyboard_name, action = @message.data.split(RBender::CALLBACK_SPLITTER)
+    keyboard = @inline_keyboards[keyboard_name.to_sym]
+    keyboard.instance_eval(&@helpers_block) unless @helpers_block.nil?
+    keyboard._invoke unless keyboard.nil?
+
+    unless keyboard.nil?
+      unless keyboard.buttons_actions[action].nil?
+        instance_eval(&keyboard.buttons_actions[action])
+      else
+        raise "There is no action called '#{action}'"
+      end
+    else
+      edit_message_text text: "deleted"
+    end
+  end
+
+  def _build
+    instance_exec(&@state_block)
+  end
+
+  def _build_keyboard
+    @keyboard._build(@session)
+  end
+
+  def _invoke_keyboard
+
+    @api.send_message(chat_id: message.from.id,
+                      text: @keyboard.response,
+                      reply_markup: @keyboard.markup_tg)
+  end
+
+  def _invoke_before
+    instance_eval(&@action_before)
+  end
+
+  def has_after?
+    @action_after.nil? ? false : true
+  end
+
+  def has_before?
+    @action_before.nil? ? false : true
+  end
+
+  def _invoke_after
+    instance_eval(&@action_after)
+  end
+
+  def has_keyboard?
+    @keyboard.nil? ? false : true
+  end
+
+  #--------------
+  # User methods
+  #--------------
+
+  def keyboard(response_message, &keyboard_block)
+    @keyboard = RBender::Keyboard.new response_message
+    @keyboard.session = @session
+    @keyboard.instance_eval(&keyboard_block)
+  end
+
+  #initialize helper methods
+  def helpers(&helpers_block)
+    @helpers_block = helpers_block
+    instance_eval(&helpers_block)
+  end
+
+  # Set message user gets while keyboard has invoked
+  def set_response(new_response)
+    @keyboard.set_response(new_response)
+  end
+
+  # Returns session hash
+  def session
+    @session
+  end
+
+  # Returns message object
+  def message
+    @message
+  end
+
+  # adds inline keyboard
+  def keyboard_inline(inline_keyboard_name, &inline_keyboard_block)
+    keyboard = @inline_keyboards[inline_keyboard_name] = RBender::KeyboardInline.new(inline_keyboard_name,
+                                                                                     @session,
+                                                                                     inline_keyboard_block)
+  end
+
+  def inline_markup(name)
+
+    raise "Keyboard #{name} doesn't exists!" unless @inline_keyboards.member? name
+    keyboard = @inline_keyboards[name]
+    keyboard.instance_eval(&@helpers_block) unless @helpers_block.nil?
+    keyboard._build
+    keyboard.markup_tg
+  end
+
+  def switch(state_to)
+    @session[:_state_stack].push(@session[:_state])
+    @session[:_state] = state_to
+  end
+
+  def switch_prev
+    @session[:_state] = @session[:_state_stack].pop
+  end
+
+  def switcher_state(id)
+    session[:_keyboard_switchers][id]
+  end
+
+  #before hook
+  def before(&action)
+    if @action_before.nil?
+      @action_before = action
+    else
+      raise 'Too many before hooks!'
+    end
+  end
+
+  #after hook
+  def after(&action)
+    if @action_after.nil?
+      @action_after = action
+    else
+      raise 'Too many after hooks!'
+    end
+  end
+
+  # Text callbacks
+  def text(&action)
+    if @text_action.nil?
+      @text_action = action
+    else
+      raise 'Too many text processors!'
+    end
+  end
+
+
+  #--------------
+  # API METHODS
+  #--------------
+  # Hides inline keyboard
+  # Must be called from any inline keyboard state
+  def hide_inline
+    edit_message_reply_markup
+  end
+
+  # Hides keyboard's markup.
+  def hide_keyboard
+
+  end
+
+  #
+  # @param text [String] string
+  #
+  def answer_callback_query(text: nil,
+                            show_alert: nil)
+    begin
+      @api.answer_callback_query callback_query_id: @message.id,
+                                 text: text,
+                                 show_alert: show_alert
+    rescue
+    end
+  end
+
+  def send_message(text:,
+                   chat_id: @message.from.id,
+                   parse_mode: nil,
+                   disable_web_page_preview: nil,
+                   disable_notification: nil,
+                   reply_to_message_id: nil,
+                   reply_markup: nil)
+
+    if text.strip.empty?
+      raise "A text can't be empty or consists of space symbols only"
+    end
+    @api.send_message chat_id: chat_id,
+                      text: text,
+                      disable_web_page_preview: disable_web_page_preview,
+                      disable_notification: disable_notification,
+                      reply_to_message_id: reply_to_message_id,
+                      parse_mode: parse_mode,
+                      reply_markup: reply_markup
+  end
+
+
+  def edit_message_text(inline_message_id: nil,
+                        text:,
+                        message_id: @message.message.message_id,
+                        parse_mode: nil,
+                        disable_web_page_preview: nil,
+                        reply_markup: nil)
+    begin
+      @api.edit_message_text chat_id: @message.from.id,
+                             message_id: message_id,
+                             text: text,
+                             inline_message_id: inline_message_id,
+                             parse_mode: parse_mode,
+                             disable_web_page_preview: disable_web_page_preview,
+                             reply_markup: reply_markup
+    rescue
+    end
+  end
+
+  def edit_message_reply_markup(chat_id: @message.from.id,
+                                message_id: @message.message.message_id,
+                                inline_message_id: nil,
+                                reply_markup: nil)
+    begin
+      @api.edit_message_reply_markup chat_id: chat_id,
+                                     message_id: message_id,
+                                     inline_message_id: inline_message_id,
+                                     reply_markup: reply_markup
+    rescue
+    end
+
+
+  end
+end
+

data/lib/rbender.rb

@@ -0,0 +1,39 @@
+require 'rbender/base'
+require 'colorize'
+
+module RBender
+  VERSION = '0.2.30'
+  @@bot = RBender::Base.new
+
+  def self.instance
+    @@bot
+  end
+
+  def self.reload
+    @@bot = RBender::Base.new
+  end
+end
+
+
+def method_missing(m, *args, &block)
+  if RBender::Base.method_defined? m
+    if block_given?
+      if args.empty?
+        RBender.instance.send(m, &block)
+      else
+        args = args[0] if args.count == 1
+        RBender.instance.send(m, args, &block)
+      end
+    else
+      if args.empty?
+        RBender.instance.send(m)
+      else
+        args = args[0] if args.count == 1
+        RBender.instance.send(m, args)
+      end
+    end
+  else
+    raise NoMethodError, 'Method is missing'
+  end
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: rbender
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Arthur
+- Korochansky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-18 00:00:00.000000000 Z
+dependencies: []
+description: Gem provides domain specific language for messengers bot creation.
+email: art2rik.desperado@gmail.com
+executables:
+- rbender
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rbender
+- lib/rbender.rb
+- lib/rbender/base.rb
+- lib/rbender/keyboard.rb
+- lib/rbender/keyboard_inline.rb
+- lib/rbender/mongo_client.rb
+- lib/rbender/sessionmanager.rb
+- lib/rbender/state.rb
+homepage: https://github.com/art2rik/RBender
+licenses: []
+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.10
+signing_key: 
+specification_version: 4
+summary: BenderBot is a tool for fast develop and test bots for messengers.
+test_files: []