socrates 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83c1f9e21bcee220a261ff122a3e705e3e0c6887
-  data.tar.gz: 6a4ccc95e6b65cb45d92c9ff17376061d12d2e7b
+  metadata.gz: 5888e238834056167ec5db70cabf1a25c59aa1f7
+  data.tar.gz: 360b99fbb350f111fadd4c9ad8596e3c3f7351fc
 SHA512:
-  metadata.gz: 6a5b772caa5b5232f329972cfc4750a44c9bd1a741864811d58037e9814881d38f9b661494d067df006af32f359c6dc1af820c54d871ad5c1dfc815b2dd616f5
-  data.tar.gz: b9083e36dba73f3e215a495e42cfd7cc1d921891debef8ed10d79c69d0fa3cdad29c7968e5718e8e42bb7d915ff470f42b882d07857f043fc50c74a55d64a91c
+  metadata.gz: 3404c0d12161fa105efaa44085f47af4780490102f4ca836ac1c2d5db0995c21a565c6e9185ee9cec9f65fcc027bfc92ff449924f385529550b3bcc1b64d787c
+  data.tar.gz: 51192c1becf7d53506895b13e9a4f0fc933996f786bfa34c74075c1ee62a0c08a1a1bf07223ade0a9182b1a015f75e764c35f86b25ce23ef89eb0f8b7d86b143

data/lib/socrates/adapters/console.rb

@@ -3,24 +3,37 @@ require "socrates/adapters/stubs"
 module Socrates
   module Adapters
     class Console
-      CLIENT_ID = "CONSOLE"
+      include StubUserDirectory
 
-      attr_accessor :email, :users
+      CLIENT_ID = "CONSOLE"
+      CHANNEL   = "C1"
 
       def initialize(name: "@socrates")
-        @name  = name
-        @users = []
+        super()
+        @name = name
       end
 
-      def client_id_from_context(_context)
+      def client_id_from(context: nil, user: nil)
+        raise ArgumentError, "Must provide one of :context or :user" if context.nil? && user.nil?
+
         CLIENT_ID
       end
 
-      def send_message(message, *)
+      def channel_from(context: nil, user: nil)
+        raise ArgumentError, "Must provide one of :context or :user" if context.nil? && user.nil?
+
+        CHANNEL
+      end
+
+      def send_message(message, channel)
+        raise ArgumentError, "Channel is required" unless channel.present?
+
         puts "\n#{colorize(@name, "32;1")}: #{message}"
       end
 
-      def send_direct_message(message, user, *)
+      def send_direct_message(message, user)
+        raise ArgumentError, "User is required" unless user.present?
+
         name =
           if user.respond_to?(:name)
             user.name
@@ -33,18 +46,6 @@ module Socrates
         puts "\n[DM] #{colorize(name, "34;1")}: #{message}"
       end
 
-      def add_user(id: nil, name: nil, first: nil, last: nil, email: nil)
-        users << User.new(id, name, Profile.new(first, last, email))
-      end
-
-      def users_list(*)
-        Response.new(users)
-      end
-
-      def lookup_email(*)
-        email
-      end
-
       private
 
       def colorize(str, color_code)

data/lib/socrates/adapters/memory.rb

@@ -3,45 +3,67 @@ require "socrates/adapters/stubs"
 module Socrates
   module Adapters
     class Memory
+      include StubUserDirectory
+
       CLIENT_ID = "MEMORY"
+      CHANNEL   = "C1"
 
-      attr_reader :history, :dms
-      attr_accessor :email, :users
+      attr_reader :history
+      attr_accessor :client_id
 
       def initialize
-        @history = []
-        @dms     = Hash.new { |hash, key| hash[key] = [] }
-        @users   = []
+        super()
+        @history = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def client_id_from(context: nil, user: nil)
+        raise ArgumentError, "Must provide one of :context or :user" if context.nil? && user.nil?
+
+        @client_id || CLIENT_ID
+      end
+
+      def channel_from(context: nil, user: nil)
+        raise ArgumentError, "Must provide one of :context or :user" if context.nil? && user.nil?
+
+        user.nil? ? CHANNEL : users_channel(user)
       end
 
-      def client_id_from_context(_context)
-        CLIENT_ID
+      def send_message(message, channel)
+        raise ArgumentError, "Channel is required" unless channel.present?
+
+        @history[channel] << message
       end
 
-      def send_message(message, *)
-        @history << message
+      def send_direct_message(message, user)
+        raise ArgumentError, "User is required" unless user.present?
+
+        @history[users_channel(user)] << message
       end
 
-      def send_direct_message(message, user, *)
-        user = user.id if user.respond_to?(:id)
+      #
+      # Methods for fetching messages and dms in specs...
+      #
 
-        @dms[user] << message
+      def msgs
+        @history[CHANNEL]
       end
 
-      def last_message
-        @history.last
+      def last_msg
+        msgs[-1]
       end
 
-      def add_user(id: nil, name: nil, first: nil, last: nil, email: nil)
-        users << User.new(id, name, Profile.new(first, last, email))
+      def dms(user)
+        @history[users_channel(user)]
       end
 
-      def users_list(*)
-        Response.new(users)
+      def last_dm(user)
+        dms(user)[-1]
       end
 
-      def lookup_email(*)
-        email
+      private
+
+      def users_channel(user)
+        user.respond_to?(:id) ? user.id : user
       end
     end
   end

data/lib/socrates/adapters/slack.rb

@@ -7,20 +7,35 @@ module Socrates
         @real_time_client = real_time_client
       end
 
-      def client_id_from_context(context)
-        raise ArgumentError, "Context cannot be nil" if context.nil?
-        raise ArgumentError, "Expected context to respond to :user" unless context.respond_to?(:user)
-
-        context.user
+      def client_id_from(context: nil, user: nil)
+        unless context.nil?
+          raise ArgumentError, "Expected :context to respond to :user" unless context.respond_to?(:user)
+          return context.user
+        end
+        unless user.nil?
+          raise ArgumentError, "Expected :user to respond to :id" unless user.respond_to?(:id)
+          return user.id
+        end
+        raise ArgumentError, "Must provide one of :context or :user"
       end
 
-      def send_message(message, context:)
-        raise ArgumentError, "Expected context to respond to :channel" unless context.respond_to?(:channel)
+      def channel_from(context: nil, user: nil)
+        unless context.nil?
+          raise ArgumentError, "Expected :context to respond to :channel" unless context.respond_to?(:channel)
+          return context.channel
+        end
+        unless user.nil?
+          # raise ArgumentError, "Expected :user to respond to :id" unless user.respond_to?(:id)
+          return lookup_im_channel(user)
+        end
+        raise ArgumentError, "Must provide one of :context or :user"
+      end
 
-        @real_time_client.message(text: message, channel: context.channel)
+      def send_message(message, channel)
+        @real_time_client.message(text: message, channel: channel)
       end
 
-      def send_direct_message(message, user, *)
+      def send_direct_message(message, user)
         raise ArgumentError, "Expected user to respond to :id" unless user.respond_to?(:id)
 
         im_channel = lookup_im_channel(user)
@@ -38,7 +53,7 @@ module Socrates
       end
 
       def lookup_email(context:)
-        raise ArgumentError, "Expected context to respond to :user" unless context.respond_to?(:user)
+        raise ArgumentError, "Expected :context to respond to :user" unless context.respond_to?(:user)
 
         client = @real_time_client.web_client
         info   = client.users_info(user: context.user)

data/lib/socrates/adapters/stubs.rb

@@ -1,7 +1,48 @@
 module Socrates
   module Adapters
+    #
+    # Response, User, Profile are POROs that represent keys concepts that exist in Slack (or other chat systems).
+    #
     Response = Struct.new(:members)
-    User     = Struct.new(:id, :name, :profile)
-    Profile  = Struct.new(:first_name, :last_name, :email)
+
+    User = Struct.new(:id, :name, :tz_offset, :profile) do
+      def real_name
+        return "" if profile.nil?
+
+        "#{profile.first_name} #{profile.last_name}"
+      end
+    end
+
+    Profile = Struct.new(:first_name, :last_name, :email)
+
+    #
+    # StubUserDirectory provides some simple stub behavior for adding stubbed users and querying against them. This are
+    # to be used by stubbed versions of adapters (like Console, Memory, etc).
+    #
+    module StubUserDirectory
+      attr_accessor :email, :users
+
+      def initialize
+        @users = []
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def add_user(id: nil, name: nil, first: nil, last: nil, email: nil, tz_offset: 0)
+        users << User.new(id, name, tz_offset, Profile.new(first, last, email))
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def users_list(*)
+        Response.new(users)
+      end
+
+      def lookup_user(email:)
+        users.find { |user| email == user.profile&.email }
+      end
+
+      def lookup_email(*)
+        email
+      end
+    end
   end
 end

data/lib/socrates/core/dispatcher.rb

@@ -20,31 +20,72 @@ module Socrates
         @error_message = Socrates.config.error_message || DEFAULT_ERROR_MESSAGE
       end
 
-      # rubocop:disable Metrics/AbcSize
       def dispatch(message, context: {})
-        message = message.strip
+        client_id = @adapter.client_id_from(context: context)
+        channel   = @adapter.channel_from(context: context)
 
-        client_id = @adapter.client_id_from_context(context)
+        do_dispatch(message, client_id, channel)
+      end
+
+      def start_conversation(user, state_id)
+        client_id = @adapter.client_id_from(user: user)
+        channel   = @adapter.channel_from(user: user)
+
+        return false unless conversation_state(user).nil?
+
+        # Create state data to match the request.
+        state_data = Socrates::Core::StateData.new(state_id: state_id, state_action: :ask)
+
+        persist_state_data(client_id, state_data)
+
+        do_dispatch(nil, client_id, channel)
+        true
+      end
+
+      def conversation_state(user)
+        client_id = @adapter.client_id_from(user: user)
+
+        return nil unless @storage.has_key?(client_id)
 
-        @logger.info %(#{client_id} recv: "#{message}")
+        begin
+          snapshot   = @storage.get(client_id)
+          state_data = StateData.deserialize(snapshot)
+          state_data = nil if state_data_expired?(state_data)
+        rescue => e
+          @logger.warn "Error while fetching state_data for client id '#{client_id}'."
+          @logger.warn e
+          state_data = nil
+        end
+
+        state_data
+      end
+
+      private
+
+      DEFAULT_ERROR_MESSAGE = "Sorry, an error occurred. We'll have to start over..."
+
+      def do_dispatch(message, client_id, channel)
+        message = message&.strip
+
+        @logger.info %Q(#{client_id} recv: "#{message}")
 
         # In many cases, a two actions will run in this loop: :listen => :ask, but it's possible that a chain of 2 or
         # more :ask actions could run, before stopping at a :listen (and waiting for the next input).
         loop do
-          state_data = fetch_snapshot(client_id)
-          state      = instantiate_state(state_data, context)
+          state_data = fetch_state_data(client_id)
+          state      = instantiate_state(state_data, channel)
 
           args = [state.data.state_action]
           args << message if state.data.state_action == :listen
 
-          msg = %(#{client_id} processing :#{state.data.state_id} / :#{args.first})
-          msg += %( / message: "#{args.second}") if args.count > 1
+          msg = "#{client_id} processing :#{state.data.state_id} / :#{args.first}"
+          msg += %Q( / message: "#{args.second}") if args.count > 1
           @logger.debug msg
 
           begin
             state.send(*args)
           rescue => e
-            handle_action_error(e, client_id, state, context)
+            handle_action_error(e, client_id, state, channel)
             return
           end
 
@@ -52,28 +93,23 @@ module Socrates
           state.data.state_id     = state.next_state_id
           state.data.state_action = state.next_state_action
 
-          @logger.debug %(#{client_id} transition to :#{state.data.state_id} / :#{state.data.state_action})
+          @logger.debug "#{client_id} transition to :#{state.data.state_id} / :#{state.data.state_action}"
 
-          persist_snapshot(client_id, state.data)
+          persist_state_data(client_id, state.data)
 
           # Break from the loop if there's nothing left to do, i.e. no more state transitions.
           break if done_transitioning?(state)
         end
       end
-      # rubocop:enable Metrics/AbcSize
-
-      private
-
-      DEFAULT_ERROR_MESSAGE = "Sorry, an error occurred. We'll have to start over..."
 
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      def fetch_snapshot(client_id)
+      def fetch_state_data(client_id)
         if @storage.has_key?(client_id)
           begin
             snapshot   = @storage.get(client_id)
             state_data = StateData.deserialize(snapshot)
           rescue => e
-            @logger.warn "Error while fetching snapshot for client id '#{client_id}', resetting state: #{e.message}"
+            @logger.warn "Error while fetching state_data for client id '#{client_id}', resetting state: #{e.message}"
             @logger.warn e
           end
         end
@@ -100,19 +136,19 @@ module Socrates
       end
       # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
-      def persist_snapshot(client_id, state_data)
+      def persist_state_data(client_id, state_data)
         state_data.reset_elapsed_time
         @storage.put(client_id, state_data.serialize)
       end
 
       def state_data_expired?(state_data)
-        return unless state_data.timestamp.present?
+        return false unless state_data.last_interaction_timestamp.present?
 
         state_data.elapsed_time > (Socrates.config.expired_timeout || 30.minutes)
       end
 
-      def instantiate_state(state_data, context)
-        @state_factory.build(state_data: state_data, adapter: @adapter, context: context)
+      def instantiate_state(state_data, channel)
+        @state_factory.build(state_data: state_data, adapter: @adapter, channel: channel)
       end
 
       def done_transitioning?(state)
@@ -123,16 +159,16 @@ module Socrates
         state.data.state_id.nil? || state.data.state_id == State::END_OF_CONVERSATION
       end
 
-      def handle_action_error(e, client_id, state, context)
+      def handle_action_error(e, client_id, state, channel)
         @logger.warn "Error while processing action #{state.data.state_id}/#{state.data.state_action}: #{e.message}"
         @logger.warn e
 
-        @adapter.send_message(@error_message, context: context)
+        @adapter.send_message(@error_message, channel)
         state.data.clear
         state.data.state_id     = nil
         state.data.state_action = nil
 
-        persist_snapshot(client_id, state.data)
+        persist_state_data(client_id, state.data)
       end
     end
   end

data/lib/socrates/core/state.rb

@@ -11,10 +11,10 @@ module Socrates
     module State
       attr_reader :data, :context
 
-      def initialize(data: StateData.new, adapter:, context: nil)
+      def initialize(data: StateData.new, adapter:, channel:)
         @data              = data
         @adapter           = adapter
-        @context           = context
+        @channel           = channel
         @next_state_id     = nil
         @next_state_action = nil
         @logger            = Socrates.config.logger || Socrates::Logger.default
@@ -46,15 +46,15 @@ module Socrates
 
         return if message.empty?
 
-        @logger.info %(#{client_id} send: "#{format_for_logging(message)}")
-        @adapter.send_message(message, context: @context)
+        @logger.info %Q(#{@channel} send: "#{format_for_logging(message)}")
+        @adapter.send_message(message, @channel)
       end
 
       def send_message(to:, message:)
         displayable_to = to.respond_to?(:id) ? to.id : to
 
-        @logger.info %(#{client_id} send direct to #{displayable_to}: "#{format_for_logging(message)}")
-        @adapter.send_direct_message(message, to, context: @context)
+        @logger.info %Q(#{@channel} send direct to #{displayable_to}: "#{format_for_logging(message)}")
+        @adapter.send_direct_message(message, to)
       end
 
       def transition_to(state_id, action: nil, data: {})
@@ -102,10 +102,6 @@ module Socrates
         (%i[ask listen] - [current_action]).first
       end
 
-      def client_id
-        @adapter.client_id_from_context(@context)
-      end
-
       def format_for_logging(message)
         message.gsub("\n", "\\n")
       end

data/lib/socrates/core/state_data.rb

@@ -6,22 +6,21 @@ require "active_support/core_ext/time"
 module Socrates
   module Core
     class StateData
-      attr_accessor :state_id, :state_action, :timestamp
+      attr_accessor :state_id, :state_action, :last_interaction_timestamp
 
-      def initialize(state_id: nil, state_action: nil, data: {}, temporary_keys: [])
+      def initialize(state_id: nil, state_action: nil, data: {})
         @state_id       = state_id
         @state_action   = state_action
-        @timestamp      = Time.current
         @data           = data
-        @temporary_keys = temporary_keys
+        @temporary_keys = []
       end
 
       def elapsed_time
-        Time.current - @timestamp
+        Time.current - @last_interaction_timestamp
       end
 
       def reset_elapsed_time
-        @timestamp = Time.current
+        @last_interaction_timestamp = Time.current
       end
 
       def keys

data/lib/socrates/sample_states.rb

@@ -14,11 +14,11 @@ module Socrates
         :expired
       end
 
-      def build(state_data:, adapter:, context: nil)
+      def build(state_data:, adapter:, channel:)
         classname = StringHelpers.underscore_to_classname(state_data.state_id)
 
         Object.const_get("Socrates::SampleStates::#{classname}")
-          .new(data: state_data, adapter: adapter, context: context)
+          .new(data: state_data, adapter: adapter, channel: channel)
       end
     end
 

data/lib/socrates/storage/memory.rb

@@ -20,6 +20,10 @@ module Socrates
       def put(key, value)
         @memory[key] = value
       end
+
+      def clear_all
+        @memory.clear
+      end
     end
   end
 end

data/lib/socrates/version.rb

@@ -1,3 +1,3 @@
 module Socrates
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/socrates.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.5"
   spec.add_development_dependency "rspec", "~> 3.5"
-  spec.add_development_dependency "rubocop", "~> 0.48.1"
+  spec.add_development_dependency "rubocop", "~> 0.49.1"
   spec.add_development_dependency "timecop", "~> 0.8.1"
 
   spec.add_dependency "activesupport", ">= 5.0.2"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: socrates
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Christian Nelson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-18 00:00:00.000000000 Z
+date: 2017-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.48.1
+        version: 0.49.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.48.1
+        version: 0.49.1
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement