rubotnik 0.1.1

data/lib/rubotnik/message_dispatch.rb

@@ -0,0 +1,77 @@
+require 'rubotnik/helpers'
+require 'rubotnik/commands'
+
+module Rubotnik
+  # Routing for messages
+  class MessageDispatch
+    include Rubotnik::Helpers
+    include Commands
+
+    attr_reader :message, :user
+
+    def initialize(message)
+      @message = message
+      p @message.class
+      p @message
+      @user = UserStore.instance.find_or_create_user(@message.sender['id'])
+    end
+
+    def route(&block)
+      if @user.current_command
+        command = @user.current_command
+        execute(command)
+        puts "Command #{command} is executed for user #{@user.id}" # log
+      else
+        bind_commands(&block)
+      end
+    rescue StandardError => error
+      raise unless ENV["DEBUG"] == "true"
+      stop_thread
+      say "There was an error: #{error}"
+    end
+
+    private
+
+    def bind_commands(&block)
+      @matched = false
+      instance_eval(&block)
+    end
+
+    def bind(*regex_strings, all: false, to: nil, reply_with: {})
+      regexps = regex_strings.map { |rs| /\b#{rs}/i }
+      proceed = regexps.any? { |regex| @message.text =~ regex }
+      proceed = regexps.all? { |regex| @message.text =~ regex } if all
+      return unless proceed
+      @matched = true
+      if block_given?
+        yield
+        return
+      end
+      handle_command(to, reply_with)
+    end
+
+    def handle_command(to, reply_with)
+      if reply_with.empty?
+        puts "Command #{to} is executed for user #{@user.id}"
+        execute(to)
+        @user.reset_command
+        puts "Command is reset for user #{@user.id}"
+      else
+        say(reply_with[:text], quick_replies: reply_with[:quick_replies])
+        @user.assign_command(to)
+        puts "Command #{to} is set for user #{@user.id}"
+      end
+    end
+
+    def default
+      return if @matched
+      puts 'None of the commands were recognized' # log
+      yield
+      @user.reset_command
+    end
+
+    def execute(command)
+      method(command).call
+    end
+  end
+end

data/lib/rubotnik/postback_dispatch.rb

@@ -0,0 +1,64 @@
+require 'rubotnik/helpers'
+require 'rubotnik/commands'
+
+module Rubotnik
+  # Routing for postbacks
+  class PostbackDispatch
+    include Rubotnik::Helpers
+    include Commands
+
+    attr_reader :postback, :user
+
+    def initialize(postback)
+      @postback = postback
+      p @postback.class
+      p @postback
+      @user = UserStore.instance.find_or_create_user(@postback.sender['id'])
+    end
+
+    def route(&block)
+      @matched = false
+      instance_eval(&block)
+    rescue StandardError => error
+      raise unless ENV["DEBUG"] == "true"
+      stop_thread
+      say "There was an error: #{error}"
+    end
+
+    private
+
+    def bind(regex_string, to: nil, reply_with: {})
+      return unless @postback.payload == regex_string.upcase
+      clear_user_state
+      @matched = true
+      puts "Matched #{regex_string} to #{to.nil? ? 'block' : to}"
+      if block_given?
+        yield
+        return
+      end
+      handle_commands(to, reply_with)
+    end
+
+    def handle_commands(to, reply_with)
+      if reply_with.empty?
+        execute(to)
+        puts "Command #{to} is executed for user #{@user.id}"
+        @user.reset_command
+        puts "Command is reset for user #{@user.id}"
+      else
+        say(reply_with[:message], quick_replies: reply_with[:quick_replies])
+        @user.assign_command(to)
+        puts "Command #{to} is set for user #{@user.id}"
+      end
+    end
+
+    def clear_user_state
+      @user.reset_command # Stop any current interaction
+      @user.session = {} # Reset whatever you stored in the user
+    end
+
+    def execute(command)
+      method(command).call
+    end
+  end
+end

data/lib/rubotnik/user.rb

@@ -0,0 +1,22 @@
+class User
+  attr_reader :id
+  attr_accessor :session
+
+  def initialize(id)
+    @id = id
+    @commands = []
+    @session = {}
+  end
+
+  def current_command
+    @commands.last
+  end
+
+  def assign_command(command)
+    @commands << command
+  end
+
+  def reset_command
+    @commands = []
+  end
+end

data/lib/rubotnik/user_store.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+require_relative 'user'
+# In-memory storage for users
+class UserStore
+  include Singleton
+  attr_reader :users
+  
+  def initialize
+    @users = []
+  end
+
+  def find_or_create_user(id)
+    find(id) || add(User.new(id))
+  end
+
+  def add(user)
+    @users << user
+    user = @users.last
+    if user
+      p "user #{user.inspect} added to store"
+      p "we got #{@users.count} users: #{@users}"
+    else
+      p 'user not found in store yet'
+    end
+    user
+  end
+
+  def find(id)
+    user = @users.find { |u| u.id == id }
+    p "user #{user} found in store" if user
+    p "we got #{@users.count} users: #{@users}" if user
+    user
+  end
+end

data/lib/rubotnik/version.rb

@@ -0,0 +1,3 @@
+module Rubotnik
+  VERSION = "0.1.1"
+end

data/lib/rubotnik.rb

@@ -0,0 +1,39 @@
+require 'rubotnik/version'
+require 'rubotnik/message_dispatch'
+require 'rubotnik/postback_dispatch'
+require 'rubotnik/user_store'
+require 'rubotnik/user'
+require 'rubotnik/cli'
+require 'rubotnik/generator'
+require 'rubotnik/autoloader'
+require 'ui/fb_button_template'
+require 'ui/fb_carousel'
+require 'ui/image_attachment'
+require 'ui/quick_replies'
+require 'sinatra'
+require 'facebook/messenger'
+include Facebook::Messenger
+
+module Rubotnik
+  def self.subscribe(token)
+    Facebook::Messenger::Subscriptions.subscribe(access_token: token)
+  end
+
+  def self.route(event, &block)
+    Bot.on(event, &block) unless [:message, :postback].include?(event)
+    Bot.on event do |e|
+      case e
+      when Facebook::Messenger::Incoming::Message
+        Rubotnik::MessageDispatch.new(e).route(&block)
+      when Facebook::Messenger::Incoming::Postback
+        Rubotnik::PostbackDispatch.new(e).route(&block)
+      end
+    end
+  end
+
+  def self.set_profile(*payloads)
+    payloads.each do |payload|
+      Facebook::Messenger::Profile.set(payload, access_token: ENV['ACCESS_TOKEN'])
+    end
+  end
+end

data/lib/ui/fb_button_template.rb

@@ -0,0 +1,47 @@
+# rubocop:disable Metrics/MethodLength
+
+module UI
+  ########################### BUTTON TEMPLATE #############################
+  # https://developers.facebook.com/docs/messenger-platform/send-api-reference/button-template
+  class FBButtonTemplate
+    def initialize(text, buttons)
+      @template = {
+        recipient: {
+          id: nil
+        },
+        message: {
+          attachment: {
+            type: 'template',
+            payload: {
+              template_type: 'button',
+              text: text,
+              buttons: parse_buttons(buttons)
+            }
+          }
+        }
+      }
+    end
+
+    # Sends the valid JSON to Messenger API
+    def send(user)
+      formed = build(user)
+      Bot.deliver(formed, access_token: ENV['ACCESS_TOKEN'])
+    end
+
+    # Use this method to return a valid hash and save it for later
+    def build(user)
+      @template[:recipient][:id] = user.id
+      @template
+    end
+
+    private
+
+    def parse_buttons(buttons)
+      return [] if buttons.nil? || buttons.empty?
+      buttons.map do |button|
+        button[:type] = button[:type].to_s
+        button
+      end
+    end
+  end
+end

data/lib/ui/fb_carousel.rb

@@ -0,0 +1,65 @@
+# rubocop:disable Metrics/MethodLength
+module UI
+  ################## GENERIC TEMPLATE (aka CAROUSEL) #######################
+  # https://developers.facebook.com/docs/messenger-platform/send-api-reference/generic-template
+  class FBCarousel
+    def initialize(elements)
+      @template = {
+        recipient: { id: nil },
+        message: {
+          attachment: {
+            type: 'template',
+            payload: {
+              template_type: 'generic',
+              image_aspect_ratio: 'horizontal',
+              elements: parse_elements(elements)
+            }
+          }
+        }
+      }
+    end
+
+    # Sends the valid JSON to Messenger API
+    def send(user)
+      template = build(user)
+      Bot.deliver(template, access_token: ENV['ACCESS_TOKEN'])
+    end
+
+    # Use this method to return a valid hash and save it for later
+    def build(user)
+      @template[:recipient][:id] = user.id
+      @template
+    end
+
+    # set image aspect ratio to 'square'
+    def square_images
+      @template[:message][:attachment][:payload][:image_aspect_ratio] = 'square'
+      self
+    end
+
+    # set image aspect ratio to 'square'
+    def horizontal_images
+      hrz = 'horizontal'
+      @template[:message][:attachment][:payload][:image_aspect_ratio] = hrz
+      self
+    end
+
+    private
+
+    def parse_elements(elements)
+      elements = [elements] if elements.class == Hash
+      elements.map do |elt|
+        elt[:buttons] = parse_buttons(elt[:buttons])
+        elt
+      end
+    end
+
+    def parse_buttons(buttons)
+      return [] if buttons.nil? || buttons.empty?
+      buttons.map do |button|
+        button[:type] = button[:type].to_s
+        button
+      end
+    end
+  end
+end

data/lib/ui/image_attachment.rb

@@ -0,0 +1,31 @@
+# rubocop:disable Metrics/MethodLength
+module UI
+  # https://developers.facebook.com/docs/messenger-platform/send-api-reference/image-attachment
+  class ImageAttachment
+    def initialize(url)
+      @template = {
+        recipient: {
+          id: nil
+        },
+        message: {
+          attachment: {
+            type: 'image',
+            payload: {
+              url: url
+            }
+          }
+        }
+      }
+    end
+
+    def send(user)
+      formed = build(user)
+      Bot.deliver(formed, access_token: ENV['ACCESS_TOKEN'])
+    end
+
+    def build(user)
+      @template[:recipient][:id] = user.id
+      @template
+    end
+  end
+end

data/lib/ui/quick_replies.rb

@@ -0,0 +1,39 @@
+module UI
+  # https://developers.facebook.com/docs/messenger-platform/send-api-reference/quick-replies
+  class QuickReplies
+    def self.build(*replies)
+      replies.map do |reply|
+        case reply
+        when Hash then build_from_hash(reply)
+        when Array then build_from_array(reply)
+        when String then build_from_string(reply)
+        else
+          raise ArgumentError, 'Arguments should be hashes or arrays of two'
+        end
+      end
+    end
+
+    def self.location
+      [{ content_type: 'location' }]
+    end
+
+    private_class_method def self.build_from_hash(reply)
+      unless reply.key?(:content_type)
+        reply[:content_type] = 'text'
+        error_msg = "type 'text' should have a payload"
+        raise ArgumentError, error_msg unless reply.key?(:payload)
+      end
+      reply
+    end
+
+    private_class_method def self.build_from_string(reply)
+      build_from_array([reply, reply.upcase])
+    end
+
+    private_class_method def self.build_from_array(reply)
+      error_msg = 'Only accepts arrays of two elements'
+      raise ArgumentError, error_msg if reply.length != 2
+      { content_type: 'text', title: reply[0].to_s, payload: reply[1].to_s }
+    end
+  end
+end

data/rubotnik.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubotnik/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubotnik"
+  spec.version       = Rubotnik::VERSION
+  spec.authors       = ["Andy Barnov"]
+  spec.email         = ["andy.barnov@gmail.com"]
+
+  spec.summary       = %q{Ruby "bot-end" micro-framework for Facebook Messenger}
+  spec.homepage      = "https://github.com/progapandist/rubotnik"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'facebook-messenger'
+  spec.add_dependency 'addressable'
+  spec.add_dependency 'dotenv'
+  spec.add_dependency 'httparty'
+  spec.add_dependency 'puma'
+  spec.add_dependency 'sinatra'
+  spec.add_dependency 'thor'
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/templates/.env

@@ -0,0 +1,3 @@
+VERIFY_TOKEN=verify_me
+ACCESS_TOKEN=PUT_YOUR_ACCESS_TOKEN_HERE
+DEBUG=true

data/templates/.gitignore

@@ -0,0 +1 @@
+.env

data/templates/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'rubotnik'

data/templates/Procfile

@@ -0,0 +1 @@
+web: bundle exec puma -C config/puma.rb

data/templates/bot.rb

@@ -0,0 +1,91 @@
+require 'rubotnik'
+# require_relative all files in "bot" folder or do it by hand
+Rubotnik::Autoloader.load('bot')
+
+# Subscribe your bot to a Facebook Page (put access and verify tokens in .env)
+Rubotnik.subscribe(ENV['ACCESS_TOKEN'])
+
+# Set welcome screen, "get started" button and a menu (all optional)
+# Edit profile.rb before uncommenting the following lines:
+
+# Rubotnik.set_profile(
+#   Profile::START_BUTTON, Profile::START_GREETING, Profile::SIMPLE_MENU
+# )
+
+# Generates a location prompt for quick_replies
+LOCATION_PROMPT = UI::QuickReplies.location
+
+####################### HANDLE INCOMING MESSAGES ##############################
+
+Rubotnik.route :message do
+  # Will work for all variations of these three greetings
+  bind 'hi', 'hello', 'bonjour' do
+    say 'Hello from your new bot!'
+  end
+
+  # Start a thread (and provide an opening message with optional quick replies).
+  # You have to define method named as a symbol inside a Command module
+  # and treat user's response to your "reply_with" message there.
+  # commands/commands.rb already has this start_conversation method
+  # defined as an example.
+
+  bind 'how', 'do', 'you', all: true, to: :start_conversation, reply_with: {
+     text: "I'm doing fine! You?",
+     quick_replies: [['Good!', 'OK'], ['Not so well', 'NOT_OK']]
+     # second item in nested array will be the contents of message.quick_reply,
+     # once the user makes a selection. Quick reply text in ALL CAPS will be
+     # used as default values of payloads if you pass strings instead of arrays
+     # (e.g. quick_replies: ['Yes', 'No'], payloads "YES" and "NO" are inferred)
+   }
+
+   # Use 'all' flag if you want to trigger a command only if all words
+   # are present in a message (will trigger with each of them by default)
+   bind 'what', 'my', 'name', all: true do
+     info = get_user_info(:first_name) # helper to get fields from Graph API
+     say info[:first_name]
+   end
+
+   # Look for example of an API call with HTTParty in commands/location.rb
+   bind 'where', 'am', 'I', all: true, to: :lookup_location, reply_with: {
+      text: 'Let me know your location',
+      quick_replies: LOCATION_PROMPT
+    }
+
+    # Look for more UI examples in commands/ui_examples.rb
+    # Rubotnik currently supports Image, Button Template and Carousel
+    bind 'image', to: :show_image
+
+   # Invoked if none of the commands recognized. Has to come last, after all binds
+   default do
+     say "Sorry I did not get it"
+   end
+end
+
+####################### HANDLE INCOMING POSTBACKS ##############################
+
+Rubotnik.route :postback do
+  # postback from "Get Started" button
+  bind 'START' do
+    say "Welcome!"
+  end
+end
+
+####################### HANDLE OTHER REQUESTS (NON-FB) #########################
+
+get '/' do
+  'I can have a landing page too!'
+end
+
+############################ TEST ON LOCALHOST #################################
+
+# 0. Have both Heroku CLI and ngrok
+# 1. Set up "Messenger" app on Facebook for Developers, fill in .env
+# 2. Run 'heroku local' from console, it will load Puma on port 5000
+# 3. Expose port 5000 to the Internet with 'ngrok http 5000'
+# 4. Provide your ngrok http_s_(!) address in Facebook Developer Dashboard
+#    for webhook validation.
+# 5. Open Messenger and talk to your bot!
+
+# P.S. While you have DEBUG environment variable set to "true" (default in .env)
+# All StandardError exceptions will go to the message dialog instead of
+# breaking the server.

data/templates/commands.rb

@@ -0,0 +1,38 @@
+module Commands
+  # You can write all your commands as methods here
+
+  # If the command is bound with reply_with specified,
+  # you have to deal with user response to the last message and react on it.
+  def start_conversation
+    # Quick replies are accessible through message object's quick_reply property,
+    # by default it's the quick reply text in ALL CAPS
+    # you can also react on the text itself
+    message.typing_on
+    case message.quick_reply
+    when 'OK'
+      say "Glad you're doing well!"
+      stop_thread
+    when 'NOT_OK'
+      say "Too bad. What happened?"
+      next_command :appear_nice
+    else
+      say "🤖"
+      # it's always a good idea to have an else, quick replies don't
+      # prevent user from typing any message in the dialogue
+      stop_thread
+    end
+    message.typing_off
+  end
+
+  def appear_nice
+    message.typing_on
+    case message.text
+    when /job/i then say "We've all been there"
+    when /family/i then say "That's just life"
+    else
+      say "It shall pass"
+    end
+    message.typing_off
+    stop_thread # future messages from user will be handled from top-level bindings
+  end
+end

data/templates/config.ru

@@ -0,0 +1,12 @@
+# require 'dotenv/load' # Use this if you want plain 'rackup' over 'heroku local'
+require 'facebook/messenger'
+require 'sinatra'
+
+require_relative './bot/bot.rb'
+
+map('/webhook') do
+  run Facebook::Messenger::Server
+end
+
+# run regular Sinatra too
+run Sinatra::Application

data/templates/location.rb

@@ -0,0 +1,36 @@
+module Commands
+  API_URL = 'https://maps.googleapis.com/maps/api/geocode/json?latlng='.freeze
+
+  # Lookup based on location data from user's device
+  def lookup_location
+    if message_contains_location?
+      handle_user_location
+    else
+      say("Please try your request again and use 'Send location' button")
+    end
+    stop_thread
+  end
+
+  def handle_user_location
+    coords = message.attachments.first['payload']['coordinates']
+    lat = coords['lat']
+    long = coords['long']
+    message.typing_on
+    parsed = get_parsed_response(API_URL, "#{lat},#{long}")
+    address = extract_full_address(parsed)
+    say "Coordinates of your location: Latitude #{lat}, Longitude #{long}. " \
+        "Looks like you're at #{address}"
+    message.typing_off
+  end
+
+  # Talk to API
+  def get_parsed_response(url, query)
+    response = HTTParty.get(url + query)
+    parsed = JSON.parse(response.body)
+    parsed['status'] != 'ZERO_RESULTS' ? parsed : nil
+  end
+
+  def extract_full_address(parsed)
+    parsed['results'].first['formatted_address']
+  end
+end