aws-lex-conversation 0.5.0

data/lib/aws-lex-conversation.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'aws/lex/conversation'

data/lib/aws/lex/conversation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'conversation/base'
+
+module Aws
+  module Lex
+    class Conversation
+      include Support::Responses
+
+      attr_accessor :event, :context, :lex
+
+      def initialize(opts = {})
+        self.event = opts.fetch(:event)
+        self.context = opts.fetch(:context)
+        self.lex = Type::Event.shrink_wrap(event)
+      end
+
+      def chain
+        @chain ||= []
+      end
+
+      def handlers=(list)
+        last = nil
+
+        reversed = list.reverse.map do |element|
+          handler = element.fetch(:handler).new(
+            options: element.fetch(:options) { {} },
+            successor: last
+          )
+          last = handler
+          handler
+        end
+
+        @chain = reversed.reverse
+      end
+
+      def handlers
+        chain.map(&:class)
+      end
+
+      def respond
+        chain.first.handle(self)
+      end
+
+      def intent_name
+        lex.current_intent.name
+      end
+
+      def slots
+        lex.current_intent.slots
+      end
+
+      def session
+        lex.session_attributes
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shrink/wrap'
+
+require_relative 'version'
+require_relative 'response/base'
+require_relative 'response/close'
+require_relative 'response/confirm_intent'
+require_relative 'response/delegate'
+require_relative 'response/elicit_intent'
+require_relative 'response/elicit_slot'
+require_relative 'support/responses'
+require_relative 'support/inflector'
+require_relative 'type/base'
+require_relative 'type/enumeration'
+require_relative 'type/sentiment_label'
+require_relative 'type/sentiment_score'
+require_relative 'type/sentiment_response'
+require_relative 'type/invocation_source'
+require_relative 'type/dialog_action_type'
+require_relative 'type/confirmation_status'
+require_relative 'type/fulfillment_state'
+require_relative 'type/recent_intent_summary_view'
+require_relative 'type/slot_resolution'
+require_relative 'type/slot_detail'
+require_relative 'type/current_intent'
+require_relative 'type/output_dialog_mode'
+require_relative 'type/bot'
+require_relative 'type/message/content_type'
+require_relative 'type/message'
+require_relative 'type/response_card/content_type'
+require_relative 'type/response_card/button'
+require_relative 'type/response_card/generic_attachment'
+require_relative 'type/response_card'
+require_relative 'type/response'
+require_relative 'type/event'
+require_relative 'handler/base'
+require_relative 'handler/echo'
+require_relative 'handler/delegate'

data/lib/aws/lex/conversation/handler/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Handler
+        class Base
+          attr_accessor :successor, :options
+
+          def initialize(opts = {})
+            self.successor = opts[:successor]
+            self.options = opts[:options]
+          end
+
+          def will_respond?(conversation)
+            callable = options.fetch(:respond_on) { ->(_c) { false } }
+            callable.call(conversation)
+          end
+
+          def response(_conversation)
+            raise NotImplementedError, 'define #response in a subclass'
+          end
+
+          def handle(conversation)
+            return response(conversation) if will_respond?(conversation)
+            return unless successor # end of chain - return nil
+
+            successor.handle(conversation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/handler/delegate.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Handler
+        class Delegate < Base
+          def response(conversation)
+            conversation.delegate(
+              slots: conversation.lex.current_intent.slots
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/handler/echo.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Handler
+        class Echo < Base
+          def response(conversation)
+            content = options.fetch(:content) { conversation.lex.input_transcript }
+            content_type = options.fetch(:content_type) { Type::Message::ContentType.new('PlainText') }
+            fulfillment_state = options.fetch(:fulfillment_state) { Type::FulfillmentState.new('Fulfilled') }
+            conversation.close(
+              fulfillment_state: fulfillment_state,
+              message: Type::Message.new(
+                content: content,
+                content_type: content_type
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class Base
+          attr_accessor :session_attributes, :recent_intent_summary_view
+
+          def initialize(opts = {})
+            self.session_attributes = opts[:session_attributes]
+            self.recent_intent_summary_view = opts[:recent_intent_summary_view]
+          end
+
+          def dialog_action
+            raise NotImplementedError, 'define dialog_action in a subclass'
+          end
+
+          def to_lex
+            Type::Response.new(
+              session_attributes: session_attributes,
+              recent_intent_summary_view: recent_intent_summary_view,
+              dialog_action: dialog_action
+            ).to_lex
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/close.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class Close < Base
+          attr_accessor :fulfillment_state, :message, :response_card
+
+          def initialize(opts = {})
+            super
+            self.fulfillment_state = opts.fetch(:fulfillment_state)
+            self.message = opts[:message]
+            self.response_card = opts[:response_card]
+          end
+
+          def dialog_action
+            {
+              type: 'Close',
+              fulfillmentState: fulfillment_state,
+              message: message,
+              responseCard: response_card
+            }.reject { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/confirm_intent.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class ConfirmIntent < Base
+          attr_accessor :intent_name, :message, :response_card, :slots
+
+          def initialize(opts = {})
+            super
+            self.intent_name = opts.fetch(:intent_name)
+            self.slots = opts[:slots]
+            self.message = opts[:message]
+            self.response_card = opts[:response_card]
+          end
+
+          def dialog_action
+            {
+              type: 'ConfirmIntent',
+              intentName: intent_name,
+              slots: slots,
+              message: message,
+              responseCard: response_card
+            }.reject { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/delegate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class Delegate < Base
+          attr_accessor :slots, :kendra_query_request_payload, :kendra_query_filter_string
+
+          def initialize(opts = {})
+            super
+            self.slots = opts[:slots]
+            self.kendra_query_request_payload = opts[:kendra_query_request_payload]
+            self.kendra_query_filter_string = opts[:kendra_query_filter_string]
+          end
+
+          def dialog_action
+            {
+              type: 'Delegate',
+              slots: slots,
+              kendraQueryRequestPayload: kendra_query_request_payload,
+              kendraQueryFilterString: kendra_query_filter_string
+            }.reject { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/elicit_intent.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class ElicitIntent < Base
+          attr_accessor :message, :response_card
+
+          def initialize(opts = {})
+            super
+            self.message = opts[:message]
+            self.response_card = opts[:response_card]
+          end
+
+          def dialog_action
+            {
+              type: 'ElicitIntent',
+              message: message,
+              responseCard: response_card
+            }.reject { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/response/elicit_slot.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Response
+        class ElicitSlot < Base
+          attr_accessor :intent_name, :message, :response_card, :slots, :slot_to_elicit
+
+          def initialize(opts = {})
+            super
+            self.intent_name = opts.fetch(:intent_name)
+            self.slot_to_elicit = opts.fetch(:slot_to_elicit)
+            self.slots = opts.fetch(:slots)
+            self.message = opts[:message]
+            self.response_card = opts[:response_card]
+          end
+
+          def dialog_action
+            {
+              type: 'ElicitSlot',
+              intentName: intent_name,
+              slots: slots,
+              slotToElicit: slot_to_elicit,
+              message: message,
+              responseCard: response_card
+            }.reject { |_, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/support/inflector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Support
+        class Inflector
+          attr_accessor :input
+
+          def initialize(input)
+            self.input = input.to_s
+          end
+
+          def to_snake_case
+            # shamelessly borrowed from ActiveSupport
+            input
+              .gsub(/::/, '/')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .tr('-', '_')
+              .gsub(/\W/, '_')
+              .downcase
+          end
+
+          def to_camel_case(style = :lower)
+            parts = input.split('_')
+            first = parts.shift
+            rest = parts.map(&:capitalize)
+
+            case style
+            when :lower
+              rest.unshift(first).join
+            when :upper
+              rest.unshift(first.capitalize).join
+            else
+              raise ArgumentError, "invalid option: `#{style.inspect}`"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/support/responses.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Support
+        module Responses
+          def close(opts = {})
+            params = {
+              session_attributes: lex.session_attributes,
+              recent_intent_summary_view: lex.recent_intent_summary_view
+            }.merge(opts)
+            Response::Close.new(params).to_lex
+          end
+
+          def confirm_intent(opts = {})
+            params = {
+              session_attributes: lex.session_attributes,
+              recent_intent_summary_view: lex.recent_intent_summary_view,
+              intent_name: lex.current_intent.name,
+              slots: lex.current_intent.slots
+            }.merge(opts)
+            Response::ConfirmIntent.new(params).to_lex
+          end
+
+          def delegate(opts = {})
+            params = {
+              session_attributes: lex.session_attributes,
+              recent_intent_summary_view: lex.recent_intent_summary_view,
+              slots: lex.current_intent.slots
+            }.merge(opts)
+            Response::Delegate.new(params).to_lex
+          end
+
+          def elicit_intent(opts = {})
+            params = {
+              session_attributes: lex.session_attributes,
+              recent_intent_summary_view: lex.recent_intent_summary_view
+            }.merge(opts)
+            Response::ElicitIntent.new(params).to_lex
+          end
+
+          def elicit_slot(opts = {})
+            params = {
+              session_attributes: lex.session_attributes,
+              recent_intent_summary_view: lex.recent_intent_summary_view,
+              slots: lex.current_intent.slots,
+              intent_name: lex.current_intent.name
+            }.merge(opts)
+            Response::ElicitSlot.new(params).to_lex
+          end
+        end
+      end
+    end
+  end
+end