xip 0.0.1 → 2.0.0.beta2

data/lib/xip/service_reply.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Xip
+  class ServiceReply
+
+    attr_accessor :recipient_id, :replies, :yaml_reply, :context
+
+    def initialize(recipient_id:, yaml_reply:, context:, preprocessor: :none)
+      @recipient_id = recipient_id
+      @yaml_reply = yaml_reply
+      @context = context
+
+      processed_reply = case preprocessor
+      when :erb
+        preprocess_erb
+      when :none
+        @yaml_reply
+      end
+
+      if yaml_reply.is_a?(Array)
+        @replies = load_replies(@yaml_reply)
+      else
+        @replies = load_replies(YAML.load(processed_reply))
+      end
+    end
+
+    private
+
+      def load_replies(unstructured_replies)
+        unstructured_replies.collect do |reply|
+          Xip::Reply.new(unstructured_reply: reply)
+        end
+      end
+
+      def preprocess_erb
+        begin
+          ERB.new(yaml_reply).result(context)
+        rescue NameError => e
+          raise(Xip::Errors::UndefinedVariable, e.message)
+        end
+      end
+
+  end
+end

data/lib/xip/services/base_client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'xip/services/base_reply_handler'
+require 'xip/services/base_message_handler'
+
+require 'xip/services/jobs/handle_message_job'
+
+module Xip
+  module Services
+    class BaseClient
+
+      attr_reader :reply
+
+      def initialize(reply:)
+        @reply = reply
+      end
+
+      def transmit
+        raise(Xip::Errors::ServiceImpaired, "Service implementation does not implement 'transmit'")
+      end
+
+    end
+  end
+end

data/lib/xip/services/base_message_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Xip
+  module Services
+    class BaseMessageHandler
+
+      attr_reader :params, :headers
+
+      def initialize(params:, headers:)
+        @params = params
+        @headers = headers
+      end
+
+      # Should respond with a Rack response (https://github.com/sinatra/sinatra#return-values)
+      def coordinate
+        raise(Xip::Errors::ServiceImpaired, "Service request handler does not implement 'process'")
+      end
+
+      # After coordinate responds to the service, an optional async job
+      # may be fired that will continue the work via this method
+      def process
+
+      end
+
+    end
+  end
+end

data/lib/xip/services/base_reply_handler.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Xip
+  module Services
+    class BaseReplyHandler
+
+      attr_reader :recipient_id, :reply
+
+      def initialize(recipient_id:, reply:)
+        @recipient_id = recipient_id
+        @reply = reply
+      end
+
+      def text
+        reply_format_not_supported(format: 'text')
+      end
+
+      def image
+        reply_format_not_supported(format: 'image')
+      end
+
+      def audio
+        reply_format_not_supported(format: 'audio')
+      end
+
+      def video
+        reply_format_not_supported(format: 'video')
+      end
+
+      def file
+        reply_format_not_supported(format: 'file')
+      end
+
+      def cards
+        reply_format_not_supported(format: 'cards')
+      end
+
+      def list
+        reply_format_not_supported(format: 'list')
+      end
+
+      def receipt
+        reply_format_not_supported(format: 'receipt')
+      end
+
+      def mark_seen
+        reply_format_not_supported(format: 'mark_seen')
+      end
+
+      def enable_typing_indicator
+        reply_format_not_supported(format: 'enable_typing_indicator')
+      end
+
+      def disable_typing_indicator
+        reply_format_not_supported(format: 'disable_typing_indicator')
+      end
+
+      def delay
+        reply_format_not_supported(format: 'delay')
+      end
+
+      def speech
+        reply_format_not_supported(format: 'speech')
+      end
+
+      def ssml
+        reply_format_not_supported(format: 'ssml')
+      end
+
+    end
+  end
+end

data/lib/xip/services/jobs/handle_message_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Xip
+  module Services
+
+    class HandleMessageJob < Xip::Jobs
+      sidekiq_options queue: :xip_webhooks, retry: false
+
+      def perform(service, params, headers)
+        dispatcher = Xip::Dispatcher.new(
+          service: service,
+          params: params,
+          headers: headers
+        )
+
+        dispatcher.process
+      end
+    end
+
+  end
+end

data/lib/xip/session.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Xip
+  class Session
+
+    include Xip::Redis
+
+    SLUG_SEPARATOR = '->'
+
+    attr_reader :flow, :state, :id, :type
+    attr_accessor :session
+
+    # Session types:
+    #   - :primary
+    #   - :previous
+    #   - :back_to
+    def initialize(id: nil, type: :primary)
+      @id = id
+      @type = type
+
+      if id.present?
+        unless defined?($redis) && $redis.present?
+          raise(
+            Xip::Errors::RedisNotConfigured,
+            "Please make sure REDIS_URL is configured before using sessions"
+          )
+        end
+
+        get_session
+      end
+
+      self
+    end
+
+    def self.flow_and_state_from_session_slug(slug:)
+      {
+        flow: slug&.split(SLUG_SEPARATOR)&.first,
+        state: slug&.split(SLUG_SEPARATOR)&.last
+      }
+    end
+
+    def self.slugify(flow:, state:)
+      unless flow.present? && state.present?
+        raise(ArgumentError, 'A flow and state must be specified.')
+      end
+
+      [flow, state].join(SLUG_SEPARATOR)
+    end
+
+    def flow
+      return nil if flow_string.blank?
+
+      @flow ||= FlowMap.new.init(flow: flow_string, state: state_string)
+    end
+
+    def state
+      flow&.current_state
+    end
+
+    def flow_string
+      session&.split(SLUG_SEPARATOR)&.first
+    end
+
+    def state_string
+      session&.split(SLUG_SEPARATOR)&.last
+    end
+
+    def get_session
+      @session ||= get_key(session_key)
+    end
+
+    def set_session(new_flow:, new_state:)
+      @flow = nil # override @flow's memoization
+      existing_session = session # tmp backup for previous_session storage
+      @session = self.class.canonical_session_slug(
+        flow: new_flow,
+        state: new_state
+      )
+
+      Xip::Logger.l(
+        topic: [type, 'session'].join('_'),
+        message: "User #{id}: setting session to #{new_flow}->#{new_state}"
+      )
+
+      if primary_session?
+        store_current_to_previous(existing_session: existing_session)
+      end
+
+      persist_key(key: session_key, value: session)
+    end
+
+    def clear_session
+      $redis.del(session_key)
+    end
+
+    def present?
+      session.present?
+    end
+
+    def blank?
+      !present?
+    end
+
+    def +(steps)
+      return nil if flow.blank?
+      return self if steps.zero?
+
+      new_state = self.state + steps
+      new_session = Xip::Session.new(id: self.id)
+      new_session.session = self.class.canonical_session_slug(
+        flow: self.flow_string,
+        state: new_state
+      )
+
+      new_session
+    end
+
+    def -(steps)
+      return nil if flow.blank?
+
+      if steps < 0
+        return self + steps.abs
+      else
+        return self + (-steps)
+      end
+    end
+
+    def ==(other_session)
+      self.flow_string == other_session.flow_string &&
+        self.state_string == other_session.state_string &&
+        self.type == other_session.type &&
+        self.id == other_session.id
+    end
+
+    def self.is_a_session_string?(string)
+      session_regex = /(.+)(#{SLUG_SEPARATOR})(.+)/
+      !!string.match(session_regex)
+    end
+
+    def self.canonical_session_slug(flow:, state:)
+      [flow, state].join(SLUG_SEPARATOR)
+    end
+
+    def session_key
+      case type
+      when :primary
+        id
+      when :previous
+        previous_session_key
+      when :back_to
+        back_to_key
+      end
+    end
+
+    def primary_session?
+      type == :primary
+    end
+
+    def previous_session?
+      type == :previous
+    end
+
+    def back_to_session?
+      type == :back_to
+    end
+
+    def to_s
+      [flow_string, state_string].join(SLUG_SEPARATOR)
+    end
+
+    private
+
+      def previous_session_key
+        [id, 'previous'].join('-')
+      end
+
+      def back_to_key
+        [id, 'back_to'].join('-')
+      end
+
+      def store_current_to_previous(existing_session:)
+        # Prevent previous_session from becoming current_session
+        if session == existing_session
+          Xip::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: skipping setting to #{session}"\
+                     ' because it is the same as current_session'
+          )
+        else
+          Xip::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: setting to #{existing_session}"
+          )
+
+          persist_key(
+            key: previous_session_key,
+            value: existing_session
+          )
+        end
+      end
+
+  end
+end

data/lib/xip/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
 module Xip
-  VERSION = "0.0.1"
+  module Version
+    def self.version
+      File.read(File.join(File.dirname(__FILE__), '../..', 'VERSION')).strip
+    end
+  end
+
+  VERSION = Version.version
 end

data/logo.svg

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="925px" height="220px" viewBox="0 0 925 220" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Dark bg</title>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="Dark-bg">
+            <rect id="Rectangle" fill="#0D1117" x="0" y="0" width="925" height="220"></rect>
+            <path d="M629.337829,63 L629.33697,98.175 L629.375,98.1953125 L661.083984,63 L700.844727,63 L654.360352,112.472656 L703.999023,162.692383 L662.329102,162.692383 L629.375,126.334961 L629.33697,126.199 L629.337829,162.692383 L598.95697,162.692383 L598.95697,63 L629.337829,63 Z M747.441437,163 L747.441437,63.3076172 L717.060578,63.3076172 L717.060578,163 L747.441437,163 Z M838.098602,163 L838.098602,89.0400391 L881.760711,89.0400391 L881.760711,63.3076172 L764.055633,63.3076172 L764.055633,89.0400391 L807.717743,89.0400391 L807.717743,163 L838.098602,163 Z" id="KIT" fill="#9CA3AF" fill-rule="nonzero"></path>
+            <path d="M265.038178,163 L298.324311,126.642578 L331.278412,163 L372.948334,163 L323.309662,112.780273 L369.794037,63.3076172 L330.033295,63.3076172 L298.324311,98.5029297 L266.781342,63.3076172 L226.522553,63.3076172 L273.338959,112.780273 L223.949311,163 L265.038178,163 Z M416.28714,163 L416.28714,63.3076172 L385.906281,63.3076172 L385.906281,163 L416.28714,163 Z M470.333954,163 L470.333954,139.010742 L525.11911,139.010742 C528.384084,139.010742 531.593719,138.817057 534.748016,138.429688 C539.451792,137.931641 543.436167,136.631185 546.701141,134.52832 C554.72523,129.60319 558.764943,118.148112 558.820282,100.163086 C558.87562,94.0205078 558.183889,88.1546224 556.745086,82.5654297 C554.476206,73.2685547 548.720998,67.5133464 539.479461,65.2998047 C535.052378,64.2483724 530.182586,63.6396484 524.870086,63.4736328 L524.870086,63.4736328 L512.252899,63.3076172 L439.953094,63.3076172 L439.953094,163 L470.333954,163 Z M508.600555,113.27832 L470.333954,113.27832 L470.333954,89.0400391 L507.385507,89.0404626 C512.836071,89.0480857 516.94877,89.1586217 519.723602,89.3720703 C525.423472,89.7594401 528.328745,93.4394531 528.439422,100.412109 C528.439422,104.230469 527.77536,107.301758 526.447235,109.625977 C525.285126,111.728841 522.490529,112.890951 518.063446,113.112305 L518.063446,113.112305 L508.600555,113.27832 Z" id="XIP" fill="#9CA3AF" fill-rule="nonzero"></path>
+            <g id="Attempt-2" transform="translate(34.000000, 28.000000)" fill-rule="nonzero">
+                <path d="M35.5079177,0.152082297 L77.9343246,42.5784892 L77.8572,42.6550823 L77.7222,77.722 L42.585,77.858 L42.6852,77.7570823 L0.3292,35.4010823 L0.2292,35.502 L0.3647,0.3647 L35.4302,0.229082297 L35.5079177,0.152082297 Z" id="Combined-Shape" fill="#60A5FA"></path>
+                <path d="M135.585,0.2293 L170.722,0.3647 L170.858,35.4323 L170.933918,35.5079177 L128.507511,77.9343246 L128.43,77.8573 L93.365,77.722 L93.229,42.585 L93.329,42.6843 L135.685,0.3283 L135.585,0.2293 Z" id="Combined-Shape" fill="#34D399"></path>
+                <path d="M128.502,91.229 L128.401675,91.329 L170.757675,133.685 L170.858,133.585 L170.722,168.722 L135.653675,168.858 L135.579082,168.933918 L93.1526754,126.507511 L93.2286754,126.431 L93.365,91.365 L128.502,91.229 Z" id="Combined-Shape" fill="#60A5FA"></path>
+                <path d="M42.5789892,91.1526754 L42.6545823,91.2286754 L77.7222,91.365 L77.8576,126.502 L77.7575823,126.401675 L35.4015823,168.757675 L35.5019,168.858 L0.3647,168.722 L0.228582297,133.654675 L0.152582297,133.579082 L42.5789892,91.1526754 Z" id="Combined-Shape" fill="#34D399"></path>
+            </g>
+        </g>
+    </g>
+</svg>

data/spec/configuration_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "Xip::Configuration" do
+
+  describe "accessing via method calling" do
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'support', 'services.yml')) }
+    let(:parsed_config) { YAML.load(ERB.new(services_yml).result)[Xip.env] }
+    let(:config) { Xip.load_services_config!(services_yml) }
+
+    it "should return the root node" do
+      expect(config.facebook).to eq parsed_config['facebook']
+    end
+
+    it "should access deeply nested nodes" do
+      expect(config.facebook.setup.greeting).to eq parsed_config['facebook']['setup']['greeting']
+    end
+
+    it "should handle values that are arrays correctly" do
+      expect(config.facebook.setup.persistent_menu).to be_a(Array)
+    end
+
+    it "should retain the configuration at the class level" do
+      expect(Xip.config.facebook.setup.greeting).to eq parsed_config['facebook']['setup']['greeting']
+    end
+
+    it "should handle multiple keys at the root level" do
+      expect(config.twilio_sms.account_sid).to eq parsed_config['twilio_sms']['account_sid']
+    end
+
+    it "should return nil if the key is not present at the node" do
+      expect(config.twilio_sms.api_key).to be nil
+    end
+
+    it "should raise a NoMethodError when accessing multi-levels of missing nodes" do
+      expect { config.slack.api_key }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "config files with ERB" do
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'support', 'services_with_erb.yml')) }
+    let(:config) { Xip.load_services_config!(services_yml) }
+
+    it "should replace available embedded env vars" do
+      ENV['FACEBOOK_VERIFY_TOKEN'] = 'it works'
+      expect(config.facebook.verify_token).to eq 'it works'
+    end
+
+    it "should replace unavailable embedded env vars with nil" do
+      expect(config.facebook.challenge).to be_nil
+    end
+
+    it "should not reload the configuration file if one already exists" do
+      Xip.load_services_config(services_yml)
+      expect(config.facebook.challenge).to be_nil
+    end
+  end
+
+  describe "configuring with default values" do
+    let(:config) {
+      Xip::Configuration.new(
+        { 'a' => nil, 'x' => 0, 'y' => false, 'z' => '' }
+      )
+    }
+
+    it 'should replace a nil value' do
+      config.set_default('a', 99)
+      expect(config.a).to eq 99
+    end
+
+    it 'should NOT replace a zero value' do
+      config.set_default('x', 99)
+      expect(config.x).to eq 0
+    end
+
+    it 'should NOT replace a false value' do
+      config.set_default('y', 99)
+      expect(config.y).to be false
+    end
+
+    it 'should NOT replace a blank string value' do
+      config.set_default('z', 99)
+      expect(config.z).to eq ''
+    end
+
+    it 'should replace a not-set key' do
+      config.set_default('zz', 99)
+      expect(config.zz).to eq 99
+    end
+  end
+
+end