xip 0.0.1 → 2.0.0.beta2

data/lib/xip/migrations/configurator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Xip
+  module Migrations
+    class InternalConfigurationsProxy
+
+      attr_reader :configurations
+
+      def initialize(configurations)
+        @configurations = configurations
+      end
+
+      def on(config_key)
+        if @configurations[config_key] && block_given?
+          @configurations[config_key] = yield(@configurations[config_key]) || @configurations[config_key]
+        end
+        @configurations[config_key]
+      end
+    end
+
+    class Configurator
+      def self.load_configurations
+        self.new
+        @env_config ||= Rails.application.config.database_configuration
+        ActiveRecord::Base.configurations = @env_config
+        @env_config
+      end
+
+      def self.environments_config
+        proxy = InternalConfigurationsProxy.new(load_configurations)
+        yield(proxy) if block_given?
+      end
+
+      def initialize(options = {})
+        default_schema = ENV['SCHEMA'] || ActiveRecord::Tasks::DatabaseTasks.schema_file(ActiveRecord::Base.schema_format)
+        defaults = {
+          config:       "config/database.yml",
+          migrate_dir:  "db/migrate",
+          seeds:        "db/seeds.rb",
+          schema:       default_schema
+        }
+        @options = defaults.merge(options)
+
+        Rails.application.config.root = Pathname.pwd
+        Rails.application.config.paths["config/database"] = config
+      end
+
+      def config
+        @options[:config]
+      end
+
+      def migrate_dir
+        @options[:migrate_dir]
+      end
+
+      def seeds
+        @options[:seeds]
+      end
+
+      def schema
+        @options[:schema]
+      end
+
+      def config_for_all
+        Configurator.load_configurations.dup
+      end
+
+      def config_for(environment)
+        config_for_all[environment.to_s]
+      end
+    end
+  end
+end

data/lib/xip/migrations/generators.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Xip
+  module Migrations
+    class Generator
+      def self.migration(name, options="")
+        generator_params = [name] + options.split(" ")
+        Rails::Generators.invoke("active_record:migration", generator_params,
+          destination_root: Xip.root
+        )
+      end
+    end
+  end
+end

data/lib/xip/migrations/railtie_config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Xip
+  module Migrations
+    class RailtieConfig < Rails::Application
+      config.generators.options[:rails] = { orm: :active_record }
+
+      config.generators.options[:active_record] = {
+        :migration => true,
+        :timestamps => true
+      }
+    end
+  end
+end

data/lib/xip/migrations/tasks.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Xip
+  module Migrations
+    class Tasks
+
+      class << self
+        def configure
+          configurator = Configurator.new
+
+          paths = Rails.application.config.paths
+
+          paths.add "config/database", with: configurator.config
+          paths.add "db/migrate", with: configurator.migrate_dir
+          paths.add "db/seeds.rb", with: configurator.seeds
+        end
+
+        def load_tasks
+          return unless defined?(ActiveRecord)
+
+          configure
+
+          Configurator.environments_config do |proxy|
+            ActiveRecord::Tasks::DatabaseTasks.database_configuration = proxy.configurations
+          end
+
+          RailtieConfig.load_tasks
+
+          # %w(
+          #   connection
+          #   environment
+          #   db/new_migration
+          # ).each do
+          #   |task| load "xip/migrations/tasks/#{task}.rake"
+          # end
+
+          load "active_record/railties/databases.rake"
+        end
+      end
+
+    end
+  end
+end

data/lib/xip/nlp/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Xip
+  module Nlp
+    class Client
+
+      def client
+        nil
+      end
+
+      def understand(query:)
+        nil
+      end
+
+      def understand_speech(audio_file:, audio_config: nil)
+        nil
+      end
+    end
+
+  end
+end

data/lib/xip/nlp/result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Xip
+  module Nlp
+    class Result
+
+      ENTITY_TYPES = %i(number currency email percentage phone age
+                        url ordinal geo dimension temp datetime duration
+                        key_phrase name)
+
+      attr_reader :result
+
+      def initialize(result:)
+        @result = result
+      end
+
+      def parsed_result
+        nil
+      end
+
+      def intent_id
+        nil
+      end
+
+      def intent
+        nil
+      end
+
+      def intent_score
+        nil
+      end
+
+      def raw_entities
+        {}
+      end
+
+      def entities
+        {}
+      end
+
+      # :postive, :negative, :neutral
+      def sentiment
+        nil
+      end
+
+      def sentiment_score
+        nil
+      end
+
+      def present?
+        parsed_result.present?
+      end
+
+    end
+  end
+end

data/lib/xip/reloader.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+module Xip
+  class Reloader
+
+    def initialize
+      @reloader = Class.new(ActiveSupport::Reloader)
+      @loader = Zeitwerk::Loader.new
+      # @loader.logger = method(:puts)
+      @loader
+    end
+
+    def load_bot!
+      load_autoload_paths!
+      enable_reloading!
+      enable_eager_load!
+      @loader.setup
+    end
+
+    def load_autoload_paths!
+      if Xip.config.autoload_paths.present?
+        Xip.config.autoload_paths.each do |autoload_path|
+          @loader.push_dir(autoload_path)
+        end
+
+        # Bot-specific ignores
+        Xip.config.autoload_ignore_paths.each do |autoload_ignore_path|
+          @loader.ignore(autoload_ignore_path)
+        end
+
+        # Ignore setup files
+        @loader.ignore(File.join(Xip.root, 'config', 'initializers'))
+        @loader.ignore(File.join(Xip.root, 'config', 'boot.rb'))
+        @loader.ignore(File.join(Xip.root, 'config', 'environment.rb'))
+        @loader.ignore(File.join(Xip.root, 'config', 'puma.rb'))
+      end
+    end
+
+    def enable_eager_load!
+      if Xip.config.eager_load
+        @loader.eager_load
+        Xip::Logger.l(topic: 'xip', message: 'Eager loading enabled.')
+      end
+    end
+
+    def enable_reloading!
+      if Xip.config.hot_reload
+        @checker = ActiveSupport::EventedFileUpdateChecker.new([], files_to_watch) do
+          reload!
+        end
+
+        @loader.enable_reloading
+        Xip::Logger.l(topic: 'xip', message: 'Hot reloading enabled.')
+      end
+    end
+
+    # Only reloads if a change has been detected in one of the autoload files`
+    def reload
+      if Xip.config.hot_reload
+        @checker.execute_if_updated
+      end
+    end
+
+    # Force reloads reglardless of filesystem changes
+    def reload!
+      if Xip.config.hot_reload
+        @loader.reload
+      end
+    end
+
+    def call
+      @reloader.wrap do
+        reload
+        yield
+      end
+    end
+
+    private
+
+      def files_to_watch
+        Xip.config.autoload_paths.map do |path|
+          [path, 'rb']
+        end.to_h
+      end
+
+  end
+end

data/lib/xip/reply.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Xip
+  class Reply
+
+    attr_accessor :reply_type, :reply
+
+    def initialize(unstructured_reply:)
+      @reply_type = unstructured_reply["reply_type"]
+      @reply = unstructured_reply
+    end
+
+    def [](key)
+      @reply[key]
+    end
+
+    def []=(key, value)
+      @reply[key] = value
+    end
+
+    def delay?
+      reply_type == 'delay'
+    end
+
+    def self.dynamic_delay
+      self.new(
+        unstructured_reply: {
+          'reply_type' => 'delay',
+          'duration' => 'dynamic'
+        }
+      )
+    end
+
+  end
+end

data/lib/xip/scheduled_reply.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Xip
+
+  class ScheduledReplyJob < Xip::Jobs
+    sidekiq_options queue: :xip_replies, retry: false
+
+    def perform(service, user_id, flow, state, target_id=nil)
+      service_message = ServiceMessage.new(service: service)
+      service_message.sender_id = user_id
+      service_message.target_id = target_id
+      controller = BotController.new(service_message: service_message)
+      controller.step_to(flow: flow, state: state)
+    end
+  end
+
+end

data/lib/xip/server.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'multi_json'
+
+module Xip
+  class Server < Sinatra::Base
+
+    def self.get_or_post(url, &block)
+      get(url, &block)
+      post(url, &block)
+    end
+
+    get '/' do
+      <<~WELCOME
+        <html>
+          <head>
+            <title>Xip</title>
+          </head>
+          <body>
+            <center>
+              <a href='https://xipkit.com'>
+                <img src='http://cdn.xipkit.com/logo-light.svg' height='120' alt='Xip Logo' aria-label='xipkit.com' />
+              </a>
+            </center>
+          </body>
+        </html>
+      WELCOME
+    end
+
+    get_or_post '/incoming/:service' do
+      Xip::Logger.l(topic: params[:service], message: 'Received webhook.')
+
+      # JSON params need to be parsed and added to the params
+      if request.env['CONTENT_TYPE']&.match(/application\/json/i)
+        json_params = MultiJson.load(request.body.read)
+        params.merge!(json_params)
+      end
+
+      dispatcher = Xip::Dispatcher.new(
+        service: params[:service],
+        params: params,
+        headers: get_helpers_from_request(request)
+      )
+
+      headers 'Access-Control-Allow-Origin' => '*',
+              'Access-Control-Allow-Methods' => ['OPTIONS', 'GET', 'POST']
+      # content_type 'audio/mp3'
+      content_type 'application/octet-stream'
+
+      dispatcher.coordinate
+    end
+
+    private
+
+      def get_helpers_from_request(request)
+        request.env.select do |header, value|
+          %w[HTTP_HOST].include?(header)
+        end
+      end
+
+  end
+end

data/lib/xip/service_message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Xip
+  class ServiceMessage
+
+    attr_accessor :sender_id, :target_id, :timestamp, :service, :message,
+                  :location, :attachments, :payload, :referral, :nlp_result,
+                  :catch_all_reason
+
+    def initialize(service:)
+      @service = service
+      @attachments = []
+      @location = {}
+    end
+
+  end
+end