ralyxa-lambda 1.8.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ralyxa'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ralyxa.rb

@@ -0,0 +1,36 @@
+require 'ralyxa/version'
+require 'ralyxa/configuration'
+require 'ralyxa/register_intents'
+require 'ralyxa/skill'
+
+module Ralyxa
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      yield configuration if block_given?
+    end
+
+    def method_missing(m, *args, &block)
+      if configuration.respond_to?(m)
+        configuration.send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(m, include_private = false)
+      configuration.respond_to?(m) || super
+    end
+
+    private
+
+    def setup_configuration
+      @configuration = Ralyxa::Configuration.new
+    end
+  end
+
+  setup_configuration
+end
+
+Ralyxa::RegisterIntents.run

data/lib/ralyxa/configuration.rb

@@ -0,0 +1,18 @@
+module Ralyxa
+  class Configuration
+    attr_accessor :validate_requests, :require_secure_urls
+
+    def initialize
+      @validate_requests = true
+      @require_secure_urls = true
+    end
+
+    def validate_requests?
+      validate_requests
+    end
+
+    def require_secure_urls?
+      require_secure_urls
+    end
+  end
+end

data/lib/ralyxa/errors.rb

@@ -0,0 +1,4 @@
+module Ralyxa
+  class UnsecureUrlError < StandardError
+  end
+end

data/lib/ralyxa/handler.rb

@@ -0,0 +1,47 @@
+require_relative './response_builder'
+require_relative './response_entities/card'
+
+# Handler Base Class. Each Intent Handler inherits from this, and overwrites the #handle method.
+module Ralyxa
+  class Handler
+    def initialize(request)
+      @request = request
+    end
+
+    def handle
+      raise NotImplementedError
+    end
+
+    def respond(response_text = '', response_details = {}, response_builder = Ralyxa::ResponseBuilder)
+      options = response_details
+      options[:response_text] = response_text if response_text
+
+      response_builder.build(options)
+    end
+
+    def tell(response_text = '', response_details = {})
+      respond(response_text, response_details.merge(end_session: true))
+    end
+
+    def card(title, body, image_url = nil, card_class = Ralyxa::ResponseEntities::Card)
+      card_class.as_hash(title, body, image_url)
+    end
+
+    def audio_player
+      Ralyxa::ResponseEntities::Directives::AudioPlayer
+    end
+
+    def link_account_card(card_class = Ralyxa::ResponseEntities::Card)
+      card_class.link_account
+    end
+
+    def log(level, message)
+      puts "[#{Time.new}] [#{@request.user_id}] #{level} - #{message}"
+    end
+
+    alias ask respond
+
+    attr_reader :request
+    private :request, :respond, :tell, :ask
+  end
+end

data/lib/ralyxa/register_intents.rb

@@ -0,0 +1,45 @@
+require_relative './skill'
+
+module Ralyxa
+  class RegisterIntents
+    DEFAULT_INTENTS_DIRECTORY = './intents'.freeze
+
+    def initialize(intents_directory, alexa_skill_class)
+      @intents_directory = intents_directory
+      @alexa_skill_class = alexa_skill_class
+    end
+
+    def self.run(intents_directory = DEFAULT_INTENTS_DIRECTORY, alexa_skill_class = Ralyxa::Skill)
+      new(intents_directory, alexa_skill_class).run
+    end
+
+    def run
+      warn NO_INTENT_DECLARATIONS_FOUND if intent_declarations.empty?
+
+      intent_declarations.each do |intent_declaration|
+        alexa_skill_class.class_eval intent_declaration
+      end
+    end
+
+    private
+
+    attr_reader :intents_directory, :alexa_skill_class
+
+    def intent_declarations
+      @intent_declarations ||=
+        Dir.glob("#{intents_directory}/*.rb")
+           .map { |relative_path| File.expand_path(relative_path) }
+           .map { |intent_declaration_path| File.open(intent_declaration_path).read }
+    end
+
+    heredoc = <<~HEREDOC
+      \e[33m
+      WARNING: You haven't defined any intent declarations.
+
+      Please define intent declarations inside a directory called 'intents',
+      on the same directory level as the runfile for your server application.
+      \e[0m
+    HEREDOC
+    NO_INTENT_DECLARATIONS_FOUND = heredoc.freeze
+  end
+end

data/lib/ralyxa/request_entities/request.rb

@@ -0,0 +1,63 @@
+require 'json'
+require 'forwardable'
+require 'alexa_verifier'
+require_relative './user'
+
+module Ralyxa
+  module RequestEntities
+    class Request
+      extend Forwardable
+      INTENT_REQUEST_TYPE = 'IntentRequest'.freeze
+
+      def_delegator :@user, :id, :user_id
+      def_delegator :@user, :access_token, :user_access_token
+      def_delegator :@user, :access_token_exists?, :user_access_token_exists?
+
+      attr_reader :request
+
+      def initialize(original_request, user_class = Ralyxa::RequestEntities::User)
+        validate_request(original_request) if Ralyxa.configuration.validate_requests?
+
+        @request = JSON.parse(original_request.body.read)
+        attempt_to_rewind_request_body(original_request)
+
+        @user = user_class.build(@request)
+      end
+
+      def intent_name
+        return @request['request']['type'] unless intent_request?
+        @request['request']['intent']['name']
+      end
+
+      def slot_value(slot_name)
+        @request['request']['intent']['slots'][slot_name]['value']
+      end
+
+      def new_session?
+        @request['session']['new']
+      end
+
+      def session_attributes
+        @request['session']['attributes']
+      end
+
+      def session_attribute(attribute_name)
+        session_attributes[attribute_name]
+      end
+
+      private
+
+      def intent_request?
+        @request['request']['type'] == INTENT_REQUEST_TYPE
+      end
+
+      def validate_request(request)
+        AlexaVerifier.valid!(request)
+      end
+
+      def attempt_to_rewind_request_body(original_request)
+        original_request.body&.rewind
+      end
+    end
+  end
+end

data/lib/ralyxa/request_entities/user.rb

@@ -0,0 +1,25 @@
+module Ralyxa
+  module RequestEntities
+    class User
+      attr_reader :id, :access_token
+
+      def initialize(id:, access_token: nil)
+        @id = id
+        @access_token = access_token
+      end
+
+      def self.build(request)
+        user_hash = request.dig('session', 'user') || request.dig('context', 'System', 'user') || {}
+
+        new(
+          id: user_hash['userId'],
+          access_token: user_hash['accessToken']
+        )
+      end
+
+      def access_token_exists?
+        !@access_token.nil?
+      end
+    end
+  end
+end

data/lib/ralyxa/response_builder.rb

@@ -0,0 +1,65 @@
+require 'json'
+require_relative './response_entities/response'
+
+module Ralyxa
+  class ResponseBuilder
+    def initialize(response_class, output_speech_class, reprompt_class, options)
+      @response_class      = response_class
+      @output_speech_class = output_speech_class
+      @reprompt_class      = reprompt_class
+      @options             = options
+    end
+
+    def self.build(options = {}, response_class = Ralyxa::ResponseEntities::Response, output_speech_class = Ralyxa::ResponseEntities::OutputSpeech, reprompt_class = Ralyxa::ResponseEntities::Reprompt)
+      new(response_class, output_speech_class, reprompt_class, options).build
+    end
+
+    def build
+      merge_output_speech if response_text_exists?
+      merge_reprompt if reprompt_exists?
+      merge_card if card_exists?
+
+      @response_class.as_hash(@options).to_json
+    end
+
+    private
+
+    def merge_output_speech
+      @options.merge!(output_speech: output_speech)
+    end
+
+    def merge_reprompt
+      @options.merge!(reprompt: reprompt)
+    end
+
+    def merge_card
+      @options[:card] = @options[:card].to_h
+    end
+
+    def card_exists?
+      @options[:card]
+    end
+
+    def response_text_exists?
+      @options[:response_text]
+    end
+
+    def reprompt_exists?
+      @options[:reprompt]
+    end
+
+    def output_speech
+      output_speech_params = { speech: @options.delete(:response_text) }
+      output_speech_params[:ssml] = @options.delete(:ssml) if @options[:ssml]
+
+      @output_speech_class.as_hash(output_speech_params)
+    end
+
+    def reprompt
+      reprompt_params = { reprompt_speech: @options.delete(:reprompt) }
+      reprompt_params[:reprompt_ssml] = @options.delete(:reprompt_ssml) if @options[:reprompt_ssml]
+
+      @reprompt_class.as_hash(reprompt_params)
+    end
+  end
+end

data/lib/ralyxa/response_entities/card.rb

@@ -0,0 +1,89 @@
+require_relative '../errors'
+
+module Ralyxa
+  module ResponseEntities
+    class Card
+      LINK_ACCOUNT_CARD_TYPE = 'LinkAccount'.freeze
+      SIMPLE_CARD_TYPE       = 'Simple'.freeze
+      STANDARD_CARD_TYPE     = 'Standard'.freeze
+
+      def initialize(options)
+        @options = options
+      end
+
+      def self.as_hash(title, body, small_image_url = nil, large_image_url = small_image_url)
+        new(title: title, body: body, small_image_url: small_image_url, large_image_url: large_image_url).to_h
+      end
+
+      def self.link_account
+        new(link_account: true).to_h
+      end
+
+      def to_h
+        {}.tap do |card|
+          add_type(card)
+          add_title(card) if @options[:title]
+          add_body(card)  if @options[:body]
+          add_image(card) if standard?
+        end
+      end
+
+      private
+
+      def add_type(card)
+        return card[:type] = LINK_ACCOUNT_CARD_TYPE if link_account?
+        card[:type]        = SIMPLE_CARD_TYPE       if simple?
+        card[:type]        = STANDARD_CARD_TYPE     if standard?
+      end
+
+      def add_title(card)
+        card[:title] = @options[:title]
+      end
+
+      def add_body(card)
+        card[:content] = @options[:body] if simple?
+        card[:text]    = @options[:body] if standard?
+      end
+
+      def add_image(card)
+        raise Ralyxa::UnsecureUrlError, "Card images must be available at an SSL-enabled (HTTPS) endpoint. Your current image urls are: (small: #{@options[:small_image_url]}, large: #{@options[:large_image_url]}" unless secure_images?
+        card[:image] = {}
+
+        small_image = @options[:small_image_url] || @options[:large_image_url]
+        large_image = @options[:large_image_url] || @options[:small_image_url]
+
+        card[:image][:smallImageUrl] = small_image if small_image
+        card[:image][:largeImageUrl] = large_image if large_image
+      end
+
+      def link_account?
+        !@options[:link_account].nil?
+      end
+
+      def simple?
+        !@options[:small_image_url] && !@options[:large_image_url]
+      end
+
+      def standard?
+        @options[:small_image_url] || @options[:large_image_url]
+      end
+
+      def secure_images?
+        small_secure = secure_uri?(@options[:small_image_url])
+        large_secure = secure_uri?(@options[:large_image_url])
+
+        small_secure && large_secure
+      end
+
+      # Given a uri string, retutrn true if:
+      #   * the scheme is https
+      #   * or if we are not interested in the uri being secure
+      #   * or if the value that has been passed is nil
+      def secure_uri?(uri_string)
+        return true if uri_string.nil?
+
+        (URI.parse(uri_string).scheme == 'https' || !Ralyxa.require_secure_urls?)
+      end
+    end
+  end
+end

data/lib/ralyxa/response_entities/directives.rb

@@ -0,0 +1,9 @@
+require_relative './directives/audio'
+require_relative './directives/audio_player'
+
+module Ralyxa
+  module ResponseEntities
+    module Directives
+    end
+  end
+end