rivescript 0.1.1

data/lib/rivescript/sessions.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# RiveScript Ruby port
+# Byte <byte@jvmlab.org>, https://jvmlab.org/
+# MIT License
+
+class RiveScript
+  # SessionManager is the interface for session managers that store user
+  # variables for RiveScript. User variables include those set with the
+  # <set> tag or set_uservar, as well as recent reply history and private
+  # internal state variables.
+  #
+  # The default session manager keeps the variables in memory. To use a
+  # custom backend, subclass SessionManager and pass an instance to
+  # RiveScript.new(session_manager: manager).
+  class SessionManager
+    # Set user variables for +username+. +data+ is a Hash of key/value pairs.
+    # A value of +nil+ for a variable means it should be deleted.
+    def set(username, data)
+      raise NotImplementedError
+    end
+
+    # Retrieve a stored variable for a user.
+    # Returns +nil+ if the user does not exist, or the string "undefined"
+    # if the user exists but the key does not.
+    def get(username, key)
+      raise NotImplementedError
+    end
+
+    # Retrieve all stored user variables for +username+.
+    # Returns +nil+ if the user does not exist.
+    def get_any(username)
+      raise NotImplementedError
+    end
+
+    # Retrieve all variables about all users.
+    def get_all
+      raise NotImplementedError
+    end
+
+    # Reset all variables stored about a particular user.
+    def reset(username)
+      raise NotImplementedError
+    end
+
+    # Reset all data about all users.
+    def reset_all
+      raise NotImplementedError
+    end
+
+    # Make a snapshot of the user's variables so that they can be restored
+    # later via thaw.
+    def freeze(username)
+      raise NotImplementedError
+    end
+
+    # Restore the frozen snapshot of variables for a user.
+    # +action+ may be "thaw" (default), "discard", or "keep".
+    def thaw(username, action = "thaw")
+      raise NotImplementedError
+    end
+
+    # Default session variables for a new user.
+    def default_session
+      { "topic" => "random" }
+    end
+  end
+
+  # Default in-memory session store for RiveScript.
+  class MemorySessionManager < SessionManager
+    def initialize
+      super
+      @users = {}
+      @frozen = {}
+      @mutex = Mutex.new
+    end
+
+    def init(username)
+      @users[username] = default_session if @users[username].nil?
+    end
+
+    def set(username, data)
+      @mutex.synchronize do
+        init(username)
+        data.each do |key, value|
+          if value.nil?
+            @users[username].delete(key)
+          else
+            @users[username][key] = value
+          end
+        end
+        nil
+      end
+    end
+
+    def get(username, key)
+      @mutex.synchronize do
+        return nil if @users[username].nil?
+
+        if @users[username].key?(key)
+          @users[username][key]
+        else
+          "undefined"
+        end
+      end
+    end
+
+    def get_any(username)
+      @mutex.synchronize do
+        return nil if @users[username].nil?
+
+        Utils.clone(@users[username])
+      end
+    end
+
+    def get_all
+      @mutex.synchronize { Utils.clone(@users) }
+    end
+
+    def reset(username)
+      @mutex.synchronize do
+        @users.delete(username)
+        @frozen.delete(username)
+        nil
+      end
+    end
+
+    def reset_all
+      @mutex.synchronize do
+        @users = {}
+        @frozen = {}
+        nil
+      end
+    end
+
+    def freeze(username)
+      @mutex.synchronize do
+        if @users[username].nil?
+          raise "freeze(#{username}): user not found"
+        end
+
+        @frozen[username] = Utils.clone(@users[username])
+        nil
+      end
+    end
+
+    def thaw(username, action = "thaw")
+      @mutex.synchronize do
+        if @frozen[username].nil?
+          raise "thaw(#{username}): no frozen variables found"
+        end
+
+        case action
+        when "thaw"
+          @users[username] = Utils.clone(@frozen[username])
+          @frozen.delete(username)
+        when "discard"
+          @frozen.delete(username)
+        when "keep"
+          @users[username] = Utils.clone(@frozen[username])
+        else
+          raise "bad thaw action"
+        end
+
+        nil
+      end
+    end
+  end
+
+  # Session manager that does not remember any user variables.
+  # Mostly useful for unit tests.
+  class NullSessionManager < SessionManager
+    def set(_username, _data)
+      nil
+    end
+
+    def get(_username, _key)
+      "undefined"
+    end
+
+    def get_any(_username)
+      nil
+    end
+
+    def get_all
+      {}
+    end
+
+    def reset(_username)
+      nil
+    end
+
+    def reset_all
+      nil
+    end
+
+    def freeze(_username)
+      nil
+    end
+
+    def thaw(_username, _action = "thaw")
+      nil
+    end
+  end
+end

data/lib/rivescript/sorting.rb

@@ -0,0 +1,158 @@
+# RiveScript Ruby port, https://jvmlab.org/, MIT License
+
+# Data sorting functions
+
+require_relative "utils"
+
+class RiveScript
+  module Sorting
+    module_function
+
+    # Sort a group of triggers in an optimal sorting order.
+    def sort_trigger_set(triggers, exclude_previous = true, say = nil)
+      say ||= ->(_what) {}
+
+      prior = { "0" => [] }
+
+      triggers.each do |trig|
+        if exclude_previous && !trig[1]["previous"].nil?
+          next
+        end
+
+        match = trig[0].match(/\{weight=(\d+)\}/i)
+        weight = "0"
+        weight = match[1] if match && match[1]
+
+        prior[weight] ||= []
+        prior[weight].push(trig)
+      end
+
+      running = []
+      prior_sort = prior.keys.sort_by { |k| -k.to_i }
+
+      prior_sort.each do |p|
+        say.call("Sorting triggers with priority #{p}")
+
+        inherits = -1
+        highest_inherits = -1
+        track = { inherits => init_sort_track }
+
+        prior[p].each do |trig|
+          pattern = trig[0]
+          say.call("Looking at trigger: #{pattern}")
+
+          match = pattern.match(/\{inherits=(\d+)\}/i)
+          if match
+            inherits = match[1].to_i
+            highest_inherits = inherits if inherits > highest_inherits
+            say.call("Trigger belongs to a topic that inherits other topics. Level=#{inherits}")
+            pattern = pattern.gsub(/\{inherits=\d+\}/i, "")
+            trig[0] = pattern
+          else
+            inherits = -1
+          end
+
+          track[inherits] ||= init_sort_track
+
+          if pattern.include?("_")
+            cnt = Utils.word_count(pattern)
+            say.call("Has a _ wildcard with #{cnt} words.")
+            if cnt > 0
+              track[inherits]["alpha"][cnt] ||= []
+              track[inherits]["alpha"][cnt].push(trig)
+            else
+              track[inherits]["under"].push(trig)
+            end
+          elsif pattern.include?("#")
+            cnt = Utils.word_count(pattern)
+            say.call("Has a # wildcard with #{cnt} words.")
+            if cnt > 0
+              track[inherits]["number"][cnt] ||= []
+              track[inherits]["number"][cnt].push(trig)
+            else
+              track[inherits]["pound"].push(trig)
+            end
+          elsif pattern.include?("*")
+            cnt = Utils.word_count(pattern)
+            say.call("Has a * wildcard with #{cnt} words.")
+            if cnt > 0
+              track[inherits]["wild"][cnt] ||= []
+              track[inherits]["wild"][cnt].push(trig)
+            else
+              track[inherits]["star"].push(trig)
+            end
+          elsif pattern.include?("[")
+            cnt = Utils.word_count(pattern)
+            say.call("Has optionals with #{cnt} words.")
+            track[inherits]["option"][cnt] ||= []
+            track[inherits]["option"][cnt].push(trig)
+          else
+            cnt = Utils.word_count(pattern)
+            say.call("Totally atomic trigger with #{cnt} words.")
+            track[inherits]["atomic"][cnt] ||= []
+            track[inherits]["atomic"][cnt].push(trig)
+          end
+        end
+
+        track[highest_inherits + 1] = track[-1]
+        track.delete(-1)
+
+        track_sorted = track.keys.sort
+        track_sorted.each do |ip|
+          say.call("ip=#{ip}")
+
+          %w[atomic option alpha number wild].each do |kind|
+            kind_sorted = track[ip][kind].keys.sort.reverse
+            kind_sorted.each do |wordcnt|
+              sorted_by_length = track[ip][kind][wordcnt].sort { |a, b| b[0].length <=> a[0].length }
+              running.concat(sorted_by_length)
+            end
+          end
+
+          under_sorted = track[ip]["under"].sort { |a, b| b[0].length <=> a[0].length }
+          pound_sorted = track[ip]["pound"].sort { |a, b| b[0].length <=> a[0].length }
+          star_sorted = track[ip]["star"].sort { |a, b| b[0].length <=> a[0].length }
+          running.concat(under_sorted)
+          running.concat(pound_sorted)
+          running.concat(star_sorted)
+        end
+      end
+
+      running
+    end
+
+    # Sort a list of strings by their word counts and lengths.
+    def sort_list(items)
+      track = {}
+
+      items.each do |item|
+        cnt = Utils.word_count(item, true)
+        track[cnt] ||= []
+        track[cnt].push(item)
+      end
+
+      output = []
+      sorted = track.keys.sort.reverse
+      sorted.each do |count|
+        bylen = track[count].sort_by { |a| -a.length }
+        output.concat(bylen)
+      end
+
+      output
+    end
+
+    def init_sort_track
+      {
+        "atomic" => {},
+        "option" => {},
+        "alpha" => {},
+        "number" => {},
+        "wild" => {},
+        "pound" => [],
+        "under" => [],
+        "star" => []
+      }
+    end
+    private_class_method :init_sort_track
+  end
+end

data/lib/rivescript/utils.rb

@@ -0,0 +1,116 @@
+# RiveScript Ruby port, https://jvmlab.org/, MIT License
+
+# Miscellaneous utility functions.
+
+class RiveScript
+  module Utils
+    module_function
+
+    def strip(text)
+      text.gsub(/^[\s\t]+/, "").gsub(/[\s\t]+$/, "").gsub(/[\x0D\x0A]+/, "")
+    end
+
+    def trim(text)
+      text.gsub(/^[\x0D\x0A\s\t]+/, "").gsub(/[\x0D\x0A\s\t]+$/, "")
+    end
+
+    def extend(a, b)
+      b.each do |attr, value|
+        a[attr] = value
+      end
+    end
+
+    def word_count(trigger, all = false)
+      words = if all
+                trigger.split(/\s+/)
+              else
+                trigger.split(/[\s\*#_\|]+/)
+              end
+      words.count { |word| !word.empty? }
+    end
+
+    def strip_nasties(string, utf8)
+      if utf8
+        string.gsub(/[\\<>]+/, "")
+      else
+        string.gsub(/[^A-Za-z0-9 ]/, "")
+      end
+    end
+
+    def quotemeta(string)
+      unsafe = "\\.+*?[^]$(){}=!<>|:".chars
+      unsafe.each do |char|
+        string = string.gsub(char, "\\#{char}")
+      end
+      string
+    end
+
+    def is_atomic(trigger)
+      specials = ["*", "#", "_", "(", "[", "<", "@"]
+      specials.none? { |special| trigger.include?(special) }
+    end
+
+    def string_format(type, string)
+      case type
+      when "uppercase"
+        string.upcase
+      when "lowercase"
+        string.downcase
+      when "sentence"
+        string = string.to_s
+        string[0].upcase + string[1..]
+      when "formal"
+        string.split(/\s+/).map do |word|
+          word[0].upcase + word[1..]
+        end.join(" ")
+      else
+        string
+      end
+    end
+
+    def parse_call_args(str)
+      result = []
+      buff = ""
+      inside_a_string = false
+
+      str.each_char do |c|
+        if c.match?(/\s/) && !inside_a_string
+          unless buff.empty?
+            result.push(buff)
+            buff = ""
+          end
+        elsif c == '"'
+          unless inside_a_string
+            # opening quote - don't add to buff
+          else
+            result.push(buff) unless buff.empty?
+            buff = ""
+          end
+          inside_a_string = !inside_a_string
+        else
+          buff += c
+        end
+      end
+
+      result.push(buff) unless buff.empty?
+      result
+    end
+
+    def clone(obj)
+      case obj
+      when nil
+        nil
+      when Array
+        obj.map { |item| clone(item) }
+      when Hash
+        obj.transform_values { |v| clone(v) }
+      else
+        obj
+      end
+    end
+
+    def n_index_of(string, match, index)
+      string.split(match, index).join(match).length
+    end
+  end
+end

data/lib/rivescript/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# RiveScript Ruby port
+# Byte <byte@jvmlab.org>, https://jvmlab.org/
+# MIT License
+
+class RiveScript
+  VERSION = "0.1.1"
+end