alexa_ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93ed501db9265d681f6b82b67eefff6879c60cdd
-  data.tar.gz: 62dcf0154f9e5dc67d091f45d0bff9ccef19ebfa
+  metadata.gz: 05efe37b6e97b7278bbfe995867983640c07b90d
+  data.tar.gz: '08e039b53252f7a87961e7d21cd02a45a2917c64'
 SHA512:
-  metadata.gz: d771952eb751937874abe1f2143b0e3d029ebd19b0c058fd91e23fadc70f0bf61673ba2ed330ef7dee57fd2dd63202349cbfb925ffeb86b95697946b1a6668b2
-  data.tar.gz: '0082c8ee544e27754be23a0132e7ddeb42924840e19684182891d6094325bb56c1300624d418d876d2fbb9fc86279a4fd6e9bdb4facea0daa2cf73207b5ec703'
+  metadata.gz: 75606a0692119854f7ed8492892b64be91e52554c6d271b0e8a4b3d04f545f254942b16e616144945bfccd0fba79fdd58f366a1df195e44352a49a724c67dab7
+  data.tar.gz: 632e697b97175adfe62a22a8b1978b9bae2027d6c69fb901d1c6de4f06e4dacd0557a7faa9ea80b28eb45316bc40508876d6148bf51ac985fc9d02be6cee0722

data/README.md

@@ -1,5 +1,63 @@
 # AlexaRuby
 
+[![Gem Version](https://badge.fury.io/rb/alexa_ruby.svg)](https://badge.fury.io/rb/alexa_ruby)
 [![Build Status](https://travis-ci.org/mulev/alexa-ruby.svg?branch=master)](https://travis-ci.org/mulev/alexa-ruby)
 
-Originally forked from damianFC's AlexaRubykit, this gem implements a back-end service for interaction with Amazon Alexa API.
+Originally forked from [damianFC's AlexaRubykit](https://github.com/damianFC/alexa-rubykit), this gem implements a back-end service for interaction with Amazon Alexa API.
+
+## Installation
+
+To install and use gem in your project just add this to your Gemfile:
+
+```ruby
+gem 'alexa_ruby'
+```
+
+And bundle it with:
+
+```bash
+$ bundle install
+```
+
+Or install it as a separate gem:
+
+```bash
+$ gem install alexa_ruby
+```
+
+## Usage
+
+Gem provides methods to handle requests from Amazon Alexa skill and to sent it a proper response.
+
+You can quickly try it with that sample code:
+
+```ruby
+require 'alexa_ruby'
+
+response = AlexaRuby::Response.new
+response.add_speech('Yay, ruby is running!')
+response.build_response
+```
+
+It will generate valid outspeech JSON:
+
+```JSON
+{
+  "version": "1.0",
+  "response": {
+    "outputSpeech": {
+      "type": "PlainText",
+      "text": "Yay, ruby is running!"
+    },
+    "shouldEndSession": true
+  }
+}
+```
+
+## Testing
+
+Run the tests using
+
+```bash
+bundle exec rspec --color --format=documentation
+```

data/lib/alexa_ruby/request/audio_player_request.rb

@@ -0,0 +1,50 @@
+module AlexaRuby
+  # AudioPlayerRequest class implements Alexa "AudioPlayer" request type
+  class AudioPlayerRequest < Request
+    attr_accessor :playback_state, :playback_offset, :error_type,
+                  :error_message, :error_playback_token, :error_player_activity
+
+    # Initialize new AudioPlayer request
+    #
+    # @param json [Hash] valid JSON request from Amazon
+    def initialize(json)
+      @type = :audio_player
+      req = json[:request]
+      @playback_state = req[:type].gsub!('AudioPlayer.', '')
+      @playback_offset = current_offset(req)
+      define_error_params(req) if @playback_state == 'PlaybackFailed'
+      super
+    end
+
+    # Outputs the launch requestID
+    #
+    # @return [String] launch request ID
+    def to_s
+      "AudioPlayerRequest requestID: #{request_id}"
+    end
+
+    private
+
+    # Get current playback offset from request
+    #
+    # @param json [Hash] "request" part of json request from Amazon
+    # @return [Integer] playback offset in milliseconds at the moment of request
+    def current_offset(json)
+      if @playback_state == 'PlaybackFailed'
+        json[:currentPlaybackState][:offsetInMilliseconds]
+      else
+        json[:offsetInMilliseconds]
+      end
+    end
+
+    # Define all error parameters if an error occured during playback
+    #
+    # @param json [Hash] "request" part of json request from Amazon
+    def define_error_params(json)
+      @error_type = json[:error][:type]
+      @error_message = json[:error][:message]
+      @error_playback_token = json[:currentPlaybackState][:token]
+      @error_player_activity = json[:currentPlaybackState][:playerActivity]
+    end
+  end
+end

data/lib/alexa_ruby/request/intent_request/slot.rb

@@ -0,0 +1,23 @@
+module AlexaRuby
+  # Class that encapsulates each slot
+  class Slot
+    attr_accessor :name, :value
+
+    # Initialize slot and define its name and value
+    #
+    # @param name [String] slot name
+    # @param value [String] slot value
+    def initialize(name, value)
+      raise ArgumentError, 'Need a name and a value' if name.nil? || value.nil?
+      @name = name
+      @value = value
+    end
+
+    # Outputs Slot name and value
+    #
+    # @return [String] Slot name and value
+    def to_s
+      "Slot Name: #{name}, Value: #{value}"
+    end
+  end
+end

data/lib/alexa_ruby/request/intent_request.rb

@@ -0,0 +1,61 @@
+require 'alexa_ruby/request/intent_request/slot'
+
+module AlexaRuby
+  # IntentRequest class implements Alexa "IntentRequest" request type
+  class IntentRequest < Request
+    attr_accessor :intent, :name, :slots
+
+    # Initialize new Intent request
+    #
+    # @param json [JSON] valid JSON request from Amazon
+    def initialize(json)
+      @intent = json[:request][:intent]
+      if @intent.nil?
+        raise ArgumentError, 'Intent should exist on an IntentRequest'
+      end
+
+      @type = :intent
+      @name = @intent[:name]
+      @slots = @intent[:slots]
+
+      super
+    end
+
+    # Takes a Hash object with slots and add it to slots node
+    #
+    # @param slots [Hash] hash with slots data
+    def add_hash_slots(slots)
+      raise ArgumentError, 'Slots can\'t be empty' if slots.nil?
+      slots.each do |slot|
+        @slots[:slot[:name]] = Slot.new(slot[:name], slot[:value])
+      end
+      @slots
+    end
+
+    # Takes a JSON with slots and add it to slots node
+    #
+    # @param slots [JSON] json object with slots data
+    def add_slots(slots)
+      slot_hash = Oj.load(slots, symbol_keys: true)
+      add_hash_slots(slot_hash)
+    end
+
+    # Adds a slot from a name and a value
+    #
+    # @param name [String] slot name
+    # @param value [String] slot value
+    # @return [Object] new slot object
+    def add_slot(name, value)
+      slot = Slot.new(name, value)
+      @slots[:name] = slot
+      slot
+    end
+
+    # Outputs the Intent Name, request Id and slot information
+    #
+    # @return [String] Intent Name, request Id and slot information
+    def to_s
+      "IntentRequest: #{name} requestID: #{request_id}  Slots: #{slots}"
+    end
+  end
+end

data/lib/alexa_ruby/request/launch_request.rb

@@ -0,0 +1,19 @@
+module AlexaRuby
+  # LaunchRequest class implements Alexa "LaunchRequest" request type
+  class LaunchRequest < Request
+    # Initialize new launch request
+    #
+    # @param json [JSON] valid JSON request from Amazon
+    def initialize(json)
+      @type = :launch
+      super
+    end
+
+    # Outputs the launch requestID
+    #
+    # @return [String] launch request ID
+    def to_s
+      "LaunchRequest requestID: #{request_id}"
+    end
+  end
+end

data/lib/alexa_ruby/request/session_ended_request.rb

@@ -0,0 +1,23 @@
+# Session end request class.
+module AlexaRuby
+  # Class for Amazon "SessionEndedRequest" request type
+  class SessionEndedRequest < Request
+    attr_accessor :reason
+
+    # Initialize new SessionEndedRequest
+    #
+    # @param json [JSON] valid JSON request from Amazon
+    def initialize(json)
+      @type = :session_ended
+      @reason = json[:request][:reason]
+      super
+    end
+
+    # Ouputs the request_id and the reason of session end
+    #
+    # @return [String] request_id and the reason of session end
+    def to_s
+      "Session Ended for requestID: #{request_id} with reason #{reason}"
+    end
+  end
+end

data/lib/alexa_ruby/request.rb

@@ -1,47 +1,28 @@
+require 'alexa_ruby/session'
+
+# AlexaRuby implements a back-end service for interaction with Amazon Alexa API
 module AlexaRuby
-# Echo can send 3 types of requests
-# - LaunchRequest: The start of the app.
-# - IntentRequest: The intent of the app.
-# - SessionEndedRequest: Session has ended.
+  # Abstract request class
   class Request
-    require 'json'
-    require 'alexa_ruby/session'
     attr_accessor :version, :type, :session, :json # global
     attr_accessor :request_id, :locale # on request
 
-    def initialize(json_request)
-      @request_id = json_request['request']['requestId']
-      raise ArgumentError, 'Request ID should exist on all Requests' if @request_id.nil?
-      @version = json_request['version']
-      @locale = json_request['request']['locale']
-      @json   = json_request
+    # Initialize new request object and set object parameters
+    #
+    # @param json [JSON] valid JSON request from Amazon
+    def initialize(json)
+      @request_id = json[:request][:requestId]
+      if @request_id.nil?
+        raise ArgumentError, 'Request ID should exist on all Requests'
+      end
+      @version = json[:version]
+      @locale = json[:request][:locale]
+      @json = json
 
-      # TODO: We probably need better session handling.
-      @session = AlexaRuby::Session.new(json_request['session'])
-    end
-  end
+      return if @type == :audio_player
 
-  # Builds a new request for Alexa.
-  def self.build_request(json_request)
-    raise ArgumentError, 'Invalid Alexa Request.' unless AlexaRuby.valid_alexa?(json_request)
-    @request = nil
-    case json_request['request']['type']
-      when /Launch/
-        @request = LaunchRequest.new(json_request)
-      when /Intent/
-        @request = IntentRequest.new(json_request)
-      when /SessionEnded/
-        @request = SessionEndedRequest.new(json_request)
-      else
-        raise ArgumentError, 'Invalid Request Type.'
+      # TODO: We probably need better session handling
+      @session = AlexaRuby::Session.new(json[:session])
     end
-    @request
-  end
-
-  # Take keys of hash and transform those to a symbols
-  def self.transform_keys_to_symbols(value)
-    return value if not value.is_a?(Hash)
-    hash = value.inject({}){|memo,(k,v)| memo[k.to_sym] = self.transform_keys_to_symbols(v); memo}
-    return hash
   end
 end

data/lib/alexa_ruby/response/audio_player.rb

@@ -1,33 +1,51 @@
+require 'securerandom'
+require 'uri'
+
 module AlexaRuby
   # AudioPlayer class encapsulates all Alexa audio player directives
   class AudioPlayer
+    attr_accessor :directive
+
+    # Initialize new directive object
+    def initialize
+      @directive = {}
+    end
+
     # Build an AudioPlayer.Play directive
     #
-    # @param url [String] audio stream URL
-    # @param token [String] some token that represents the audio stream
-    # @param offset [Integer] the timestamp in the stream from which Alexa should begin playback
+    # @param opts [Hash] optional request parameters:
+    #                     - streaming URL
+    #                     - radio station token
+    #                     - expected previous station token
+    #                     - playback offset
     # @return [Hash] AudioPlayer.Play directive
-    def play_directive(url, token, offset)
-      {
-        type: 'AudioPlayer.Play',
-        playBehavior: 'REPLACE_ALL',
-        audioItem: {
-          stream: {
-            token: token,
-            url: url,
-            offsetInMilliseconds: offset
-          }
-        }
-      }
+    def build_play_directive(opts)
+      raise ArgumentError, 'Invalid streaming URL' unless valid_url?(opts[:url])
+      token = opts[:token] || SecureRandom.uuid
+      offset = opts[:offset] || 0
+      @directive[:type] = 'AudioPlayer.Play'
+      @directive[:playBehavior] = 'REPLACE_ALL'
+      @directive[:audioItem] = { stream: {} }
+      @directive[:audioItem][:stream][:url] = opts[:url]
+      @directive[:audioItem][:stream][:token] = token
+      @directive[:audioItem][:stream][:offsetInMilliseconds] = offset
     end
 
     # Build AudioPlayer.Stop directive
     #
     # @return [Hash] AudioPlayer.Stop directive
-    def stop_directive
-      {
-        type: 'AudioPlayer.Stop'
-      }
+    def build_stop_directive
+      @directive[:type] = 'AudioPlayer.Stop'
+    end
+
+    private
+
+    # Is it a valid URL?
+    #
+    # @param url [String] streaming URL
+    # @return [Boolean]
+    def valid_url?(url)
+      url =~ /\A#{URI.regexp(['https'])}\z/
     end
   end
 end

data/lib/alexa_ruby/response/card.rb

@@ -0,0 +1,25 @@
+module AlexaRuby
+  # Class for Amazon Alexa app cards
+  class Card
+    attr_accessor :obj
+
+    # Initialize new card object
+    def initialize
+      @obj = {}
+    end
+
+    # Build card object
+    #
+    # @param opts [Hash] card parameters:
+    #                     - type - card type
+    #                     - title - card title
+    #                     - subtitle - card subtitle
+    #                     - content - card body content
+    def build(opts)
+      @obj[:type] = opts[:type]
+      @obj[:title] = opts[:title] unless opts[:title].nil?
+      @obj[:subtitle] = opts[:subtitle] unless opts[:subtitle].nil?
+      @obj[:content] = opts[:content] unless opts[:content].nil?
+    end
+  end
+end

data/lib/alexa_ruby/response.rb

@@ -1,101 +1,132 @@
+require 'alexa_ruby/response/audio_player'
+require 'alexa_ruby/response/card'
+
 module AlexaRuby
+  # Class implements response for Amazon Alexa API
   class Response
-    require 'json'
-    require 'alexa_ruby/response/audio_player'
-    attr_accessor :version, :session, :response_object, :session_attributes, :speech, :reprompt, :response, :card
+    attr_accessor :version, :session, :response_object, :session_attributes,
+                  :speech, :reprompt, :response, :card
 
-    # Every response needs a shouldendsession and a version attribute
-    # We initialize version to 1.0, use add_version to set your own.
+    # Initialize new response and set response version
+    #
+    # @param version [String] response version
     def initialize(version = '1.0')
-      @session_attributes = Hash.new
+      @session_attributes = {}
       @version = version
       @directives = []
     end
 
-    # Adds a key,value pair to the session object.
+    # Adds a key => value pair to the session object
+    #
+    # @param key [String] attribute key
+    # @param value [String] attribute value
     def add_session_attribute(key, value)
       @session_attributes[key.to_sym] = value
     end
 
+    # Add output speech to response object.
+    # Speech can be plain text or SSML text, default type is plain text
+    #
+    # @param speech_text [String] output speech
+    # @param ssml [Boolean] is it an SSML speech or not
     def add_speech(speech_text, ssml = false)
-      if ssml
-        @speech = { :type => 'SSML', :ssml => check_ssml(speech_text) }
-      else
-        @speech = { :type => 'PlainText', :text => speech_text }
-      end
+      @speech =
+        if ssml
+          { type: 'SSML', ssml: check_ssml(speech_text) }
+        else
+          { type: 'PlainText', text: speech_text }
+        end
       @speech
     end
 
-    # Add a directive to start audio playback
-    def start_audio_playback(url, token = '', offset = 0)
-      player = AudioPlayer.new
-      @directives = [ player.play_directive(url, token, offset) ]
-    end
-
-    # Add directive to stop audio playback
-    def stop_audio_playback
+    # Add AudioPlayer directive
+    #
+    # @param directive [String] audio player directive type,
+    #                           can be :start or :stop
+    # @param opts [Hash] optional request parameters
+    def add_audio_player_directive(directive, opts = {})
       player = AudioPlayer.new
-      @directives = [ player.stop_directive ]
+      @directives = []
+      case directive.to_sym
+      when :start
+        player.build_play_directive(opts)
+      when :stop
+        player.build_stop_directive
+      end
+      @directives << player.directive
     end
 
+    # Add reprompt to outputSpeech node
+    #
+    # @param speech_text [String] output speech
+    # @param ssml [Boolean] is it an SSML speech or not
     def add_reprompt(speech_text, ssml = false)
-      if ssml
-        @reprompt = { "outputSpeech" => { :type => 'SSML', :ssml => check_ssml(speech_text) } }
-      else
-        @reprompt = { "outputSpeech" => { :type => 'PlainText', :text => speech_text } }
-      end
+      @reprompt =
+        if ssml
+          { outputSpeech: { type: 'SSML', ssml: check_ssml(speech_text) } }
+        else
+          { outputSpeech: { type: 'PlainText', text: speech_text } }
+        end
       @reprompt
     end
 
+    # Add card that will be shown in Amazon Alexa app on user smartphone/tablet
     #
-    #"type": "string",
-    #    "title": "string",
-    #    "subtitle": "string",
-    #    "content": "string"
-    def add_card(type = nil, title = nil , subtitle = nil, content = nil)
-      # A Card must have a type which the default is Simple.
-      @card = Hash.new()
-      @card[:type] = type || 'Simple'
-      @card[:title] = title unless title.nil?
-      @card[:subtitle] = subtitle unless subtitle.nil?
-      @card[:content] = content unless content.nil?
-      @card
+    # @param opts [Hash] hash with card parameters
+    # @return [Hash] card object
+    def add_card(opts = {})
+      opts[:type] = 'Simple' if opts[:type].nil?
+      card = Card.new
+      card.build(opts)
+      @card = card.obj
     end
 
-    # The JSON Spec says order shouldn't matter.
-    def add_hash_card(card)
-      card[:type] = 'Simple' if card[:type].nil?
-      @card = card
-      @card
-    end
-
-    # Adds a speech to the object, also returns a outputspeech object.
+    # Adds a speech to the object, also returns a outputspeech object
+    #
+    # @param speech [String] output speech
+    # @param end_session [Boolean] is it a final response, or not
+    # @param ssml [Boolean] is it an SSML speech or not
     def say_response(speech, end_session = true, ssml = false)
-      output_speech = add_speech(speech,ssml)
-      { :outputSpeech => output_speech, :shouldEndSession => end_session }
+      output_speech = add_speech(speech, ssml)
+      { outputSpeech: output_speech, shouldEndSession: end_session }
     end
 
     # Incorporates reprompt in the SDK 2015-05
-    def say_response_with_reprompt(speech, reprompt_speech, end_session = true, speech_ssml = false, reprompt_ssml = false)
-      output_speech = add_speech(speech,speech_ssml)
-      reprompt_speech = add_reprompt(reprompt_speech,reprompt_ssml)
-      { :outputSpeech => output_speech, :reprompt => reprompt_speech, :shouldEndSession => end_session }
+    #
+    # @param speech [String] output speech
+    # @param reprompt_speech [String] output repromt speech
+    # @param end_session [Boolean] is it a final response, or not
+    # @param speech_ssml [Boolean] is it an SSML speech or not
+    # @param reprompt_ssml [Boolean] is it an SSML repromt speech or not
+    def say_response_with_reprompt(speech, reprompt_speech, end_session = true,
+                                   speech_ssml = false, reprompt_ssml = false)
+      output_speech = add_speech(speech, speech_ssml)
+      reprompt_speech = add_reprompt(reprompt_speech, reprompt_ssml)
+      {
+        outputSpeech: output_speech,
+        reprompt: reprompt_speech,
+        shouldEndSession: end_session
+      }
     end
 
-
     # Creates a session object. We pretty much only use this in testing.
+    # If it's empty assume user doesn't need session attributes
+    #
+    # @return [Hash] user session parameters
     def build_session
-      # If it's empty assume user doesn't need session attributes.
-      @session_attributes = Hash.new if @session_attributes.nil?
-      @session = { :sessionAttributes => @session_attributes }
+      @session_attributes = {} if @session_attributes.nil?
+      @session = { sessionAttributes: @session_attributes }
       @session
     end
 
     # The response object (with outputspeech, cards and session end)
     # Should rename this, but Amazon picked their names.
     # The only mandatory field is end_session which we default to true.
+    #
+    # @param session_end [Boolean] is it a final response, or not
+    # @return [Hash] response parameters
     def build_response_object(session_end = true)
-      @response = Hash.new
+      @response = {}
       @response[:outputSpeech] = @speech unless @speech.nil?
       @response[:directives] = @directives unless @directives.empty?
       @response[:card] = @card unless @card.nil?
@@ -105,26 +136,41 @@ module AlexaRuby
     end
 
     # Builds a response.
-    # Takes the version, response and should_end_session variables and builds a JSON object.
+    # Takes the version, response, should_end_session variables
+    # and builds a JSON object
+    #
+    # @param session_end [Boolean] is it a final response, or not
+    # @return [JSON] json response for Amazon Alexa
     def build_response(session_end = true)
       response_object = build_response_object(session_end)
-      response = Hash.new
+      response = {}
       response[:version] = @version
-      response[:sessionAttributes] = @session_attributes unless @session_attributes.empty?
+      unless @session_attributes.empty?
+        response[:sessionAttributes] = @session_attributes
+      end
       response[:response] = response_object
-      response.to_json
+      Oj.to_json(response)
     end
 
     # Outputs the version, session object and the response object.
+    #
+    # @return [String] version, session object and the response object
     def to_s
-      "Version => #{@version}, SessionObj => #{@session}, Response => #{@response}"
+      "Version => #{@version}, SessionObj => #{@session}, " \
+        "Response => #{@response}"
     end
 
     private
 
-      def check_ssml(ssml_string)
-        ssml_string = ssml_string.strip[0..6] == "<speak>" ? ssml_string : "<speak>" + ssml_string
-        ssml_string.strip[-8..1] == "</speak>" ? ssml_string : ssml_string + "</speak>"
-      end
+    # Check and fix SSML speech
+    #
+    # @param ssml [String] SSML string
+    # @return [String] valid SSML string
+    def check_ssml(ssml)
+      open_tag = ssml.strip[0..6]
+      close_tag = ssml.strip[-8..1]
+      ssml = open_tag == '<speak>' ? ssml : "<speak>#{ssml}"
+      close_tag == '</speak>' ? ssml : "#{ssml}</speak>"
+    end
   end
 end

data/lib/alexa_ruby/session.rb

@@ -1,36 +1,54 @@
 module AlexaRuby
-  # Handles the session object in request.
+  # Class handles the session object in request
   class Session
     attr_accessor :new, :session_id, :attributes, :user
-    def initialize (session)
-      raise ArgumentError, 'Invalid Session' if session.nil? || session['new'].nil? || session['sessionId'].nil?
-      @new = session['new']
-      @session_id = session['sessionId']
-      session['attributes'].nil? ? @attributes = Hash.new  : @attributes = session['attributes']
-      @user = session['user']
+
+    # Initialize new user session
+    #
+    # @param session [JSON] part of json request from Amazon with user session
+    def initialize(session)
+      if session.nil? || session[:new].nil? || session[:sessionId].nil?
+        raise ArgumentError, 'Invalid Session'
+      end
+
+      @new = session[:new]
+      @session_id = session[:sessionId]
+      @attributes = session[:attributes].nil? ? {} : session[:attributes]
+      @user = session[:user]
     end
 
-    # Returns whether this is a new session or not.
+    # Is it a new user session?
+    #
+    # @return [Boolean]
     def new?
-      !!@new
+      @new
     end
 
-    # Returns true if a user is defined.
+    # Is user defined?
+    #
+    # @return [Boolean]
     def user_defined?
-      !@user.nil? || !@user['userId'].nil?
+      !@user.nil? || !@user[:userId].nil?
     end
 
-    # Returns the user_id.
+    # Get user ID
+    #
+    # @return [String] Amazon user ID
     def user_id
-      @user['userId'] if @user
+      @user[:userId] if @user
     end
 
+    # Get user access token
+    #
+    # @return [String] Amazon user access token
     def access_token
-      @user['accessToken'] if @user
+      @user[:accessToken] if @user
     end
 
-    # Check to see if attributes are present.
-    def has_attributes?
+    # Session attributes present?
+    #
+    # @return [Boolean]
+    def attributes?
       !@attributes.empty?
     end
   end

data/lib/alexa_ruby/version.rb

@@ -1,3 +1,3 @@
 module AlexaRuby
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/alexa_ruby.rb

@@ -1,24 +1,85 @@
+require 'oj'
+
 require 'alexa_ruby/request'
 require 'alexa_ruby/version'
 require 'alexa_ruby/response'
-require 'alexa_ruby/intent_request'
-require 'alexa_ruby/launch_request'
-require 'alexa_ruby/session_ended_request'
+require 'alexa_ruby/request/intent_request'
+require 'alexa_ruby/request/launch_request'
+require 'alexa_ruby/request/session_ended_request'
+require 'alexa_ruby/request/audio_player_request'
 
+# AlexaRuby implements a back-end service for interaction with Amazon Alexa API
 module AlexaRuby
-  # Prints a JSON object.
-  def self.print_json(json)
-    p json
-  end
+  class << self
+    # Prints some JSON
+    #
+    # @param json [JSON] some JSON object
+    def print_json(json)
+      p json
+    end
 
-  # Prints the Gem version.
-  def self.print_version
-    p AlexaRuby::VERSION
-  end
+    # Prints the Gem version
+    def print_version
+      p AlexaRuby::VERSION
+    end
+
+    # Builds a new request for Alexa
+    #
+    # @param json_request [JSON] json request from Amazon Alexa
+    # @return [Object] instance of request class
+    def build_request(json_request)
+      json = load_json(json_request)
+
+      unless AlexaRuby.valid_request?(json)
+        raise ArgumentError, 'Invalid Alexa Request'
+      end
+
+      @request = define_request(json)
+      raise ArgumentError, 'Invalid Request Type' if @request.nil?
+      @request
+    end
+
+    # Check if it is a valid Amazon Alexa request
+    #
+    # @param json [JSON] json request from Amazon Alexa
+    # @return [Boolean]
+    def valid_request?(json)
+      session =
+        if json[:request].nil? || /AudioPlayer/.match(json[:request][:type])
+          true
+        else
+          !json[:session].nil?
+        end
+      !json.nil? && session && !json[:version].nil? && !json[:request].nil?
+    end
+
+    # Define proper request class and instantinate it
+    #
+    # @param json [JSON] json request from Amazon Alexa
+    # @return [Object] instance of request class
+    def define_request(json)
+      case json[:request][:type]
+      when /Launch/
+        LaunchRequest.new(json)
+      when /Intent/
+        IntentRequest.new(json)
+      when /SessionEnded/
+        SessionEndedRequest.new(json)
+      when /AudioPlayer/
+        AudioPlayerRequest.new(json)
+      end
+    end
+
+    private
 
-  # Returns true if all the Alexa request objects are set.
-  def self.valid_alexa?(request_json)
-    !request_json.nil? && !request_json['session'].nil? &&
-        !request_json['version'].nil? && !request_json['request'].nil?
+    # Parse JSON request, validate it and convert it to hash
+    #
+    # @param request [String] json request from Amazon Alexa
+    # @return [Hash] loaded and validated request
+    def load_json(request)
+      Oj.load(request, symbol_keys: true)
+    rescue StandardError
+      raise ArgumentError, 'Invalid JSON in request'
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alexa_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Mulev
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -91,13 +105,16 @@ files:
 - README.md
 - Rakefile
 - lib/alexa_ruby.rb
-- lib/alexa_ruby/intent_request.rb
-- lib/alexa_ruby/launch_request.rb
 - lib/alexa_ruby/request.rb
+- lib/alexa_ruby/request/audio_player_request.rb
+- lib/alexa_ruby/request/intent_request.rb
+- lib/alexa_ruby/request/intent_request/slot.rb
+- lib/alexa_ruby/request/launch_request.rb
+- lib/alexa_ruby/request/session_ended_request.rb
 - lib/alexa_ruby/response.rb
 - lib/alexa_ruby/response/audio_player.rb
+- lib/alexa_ruby/response/card.rb
 - lib/alexa_ruby/session.rb
-- lib/alexa_ruby/session_ended_request.rb
 - lib/alexa_ruby/version.rb
 homepage: https://github.com/mulev/alexa-ruby
 licenses:

data/lib/alexa_ruby/intent_request.rb

@@ -1,60 +0,0 @@
-module AlexaRuby
-  class IntentRequest < Request
-    attr_accessor :intent, :name, :slots
-
-    # We still don't know if all of the parameters in the request are required.
-    # Checking for the presence of intent on an IntentRequest.
-    def initialize(json_request)
-      super
-      @intent = json_request['request']['intent']
-      raise ArgumentError, 'Intent should exist on an IntentRequest' if @intent.nil?
-      @type = 'INTENT_REQUEST'
-      @name  = @intent['name']
-      @slots = @intent['slots']
-    end
-
-    # Takes a Hash object.
-    def add_hash_slots(slots)
-      raise ArgumentError, 'Slots can\'t be empty'
-      slots.each do |slot|
-        @slots[:slot[:name]] = Slot.new(slot[:name], slot[:value])
-      end
-      @slots
-    end
-
-    # Takes a JSON Object and symbolizes its keys.
-    def add_slots(slots)
-      slot_hash = AlexaRuby.transform_keys_to_symbols(value)
-      add_hash_slots(slot_hash)
-    end
-
-    # Adds a slot from a name and a value.
-    def add_slot(name, value)
-      slot = Slot.new(name, value)
-      @slots[:name] = slot
-      slot
-    end
-
-    # Outputs the Intent Name, request Id and slot information.
-    def to_s
-      "IntentRequest: #{name} requestID: #{request_id}  Slots: #{slots}"
-    end
-  end
-
-  # Class that encapsulates each slot.
-  class Slot
-    attr_accessor :name, :value
-
-    # Each slot has a name and a value.
-    def initialize(name, value)
-      raise ArgumentError, 'Need a name and a value' if name.nil? || value.nil?
-      @name = name
-      @value = value
-    end
-
-    # Outputs Slot name and value.
-    def to_s
-      "Slot Name: #{name}, Value: #{value}"
-    end
-  end
-end

data/lib/alexa_ruby/launch_request.rb

@@ -1,15 +0,0 @@
-module AlexaRuby
-  class LaunchRequest  < Request
-    # We still don't know if all of the parameters in the request are required.
-    # Checking for the presence of intent on an IntentRequest.
-    def initialize(json_request)
-      super
-      @type = 'LAUNCH_REQUEST'
-    end
-
-    # Outputs the launch requestID.
-    def to_s
-      "LaunchRequest requestID: #{request_id}"
-    end
-  end
-end

data/lib/alexa_ruby/session_ended_request.rb

@@ -1,20 +0,0 @@
-# Session end request class.
-module AlexaRuby
-  class SessionEndedRequest < Request
-    attr_accessor :reason
-
-    # TODO: Validate the reason.
-    # We still don't know if all of the parameters in the request are required.
-    # Checking for the presence of intent on an IntentRequest.
-    def initialize(json_request)
-      super
-      @type = 'SESSION_ENDED_REQUEST'
-      @reason = json_request['request']['reason']
-    end
-
-    # Ouputs the request_id and the reason why.
-    def to_s
-      "Session Ended for requestID: #{request_id} with reason #{reason}"
-    end
-  end
-end