markov_chain_chat_bot 0.1.0

data/README

@@ -0,0 +1,44 @@
+== Markov chain chat bot
+
+
+A chat bot utilizing Markov chains. It speaks Russian and English.
+
+
+
+
+
+=== Examples
+
+
+Basic usage:
+
+  require 'chat_bot'
+  
+  bot = ChatBot.from(Hash.new)
+  bot.learn("one two three two one")
+  bot.answer("count up and down please")
+    #=> "one two three two three two one two one two three two one two one"
+  bot.learn("three four six")
+  bot.answer("count from three please")
+    #=> "three two one two one two three four six"
+
+One may save the bot's knowledge into key-value storage:
+
+  require 'chat_bot'
+  require 'auto_marshalling_map'
+  require 'gdbm'
+  
+  # 1.
+  kvs = GDBM.open("chat_bot.dat")
+  bot = ChatBot.from(AutoMarhsallingMap.new(kvs))
+  bot.learn("one two three two one")
+  kvs.close()
+  
+  # 2.
+  kvs = GDBM.open("chat_bot.dat")
+  bot = ChatBot.from(AutoMarhsallingMap.new(kvs))
+  bot.answer("count up and down please")
+    #=> "one two three two three two three two one two one"
+
+
+

data/lib/auto_marshalling_map.rb

@@ -0,0 +1,29 @@
+
+# 
+# A map which automatically marshals all keys and values passed to it.
+# 
+class AutoMarshallingMap
+
+  # 
+  # +backend+ is a Map from String to (String or nil). It will be used as
+  # a backend storage for the new AutoMarshallingMap.
+  # 
+  def initialize(backend)
+    @backend = backend
+  end
+
+  def [](key)
+    value_string = @backend[Marshal.dump(key)]
+    return nil if value_string.nil?
+    return Marshal.load value_string
+  end
+
+  def []=(key, value)
+    @backend[Marshal.dump(key)] = Marshal.dump(value)
+    return value
+  end
+
+  # +backend+ argument passed to #new().
+  attr_reader :backend
+
+end

data/lib/chat_bot.rb

@@ -0,0 +1,6 @@
+require 'markov_chain_chat_bot'
+
+# 
+# Deprecated. Use MarkovChainChatBot instead.
+# 
+ChatBot = MarkovChainChatBot

data/lib/markov_chain.rb

@@ -0,0 +1,93 @@
+
+class MarkovChain
+  
+  # 
+  # +data+ is #data() of the other MarkovChain. It becomes owned by the
+  # returned MarkovChain.
+  # 
+  def self.from(data)
+    new(data)
+  end
+  
+  # 
+  # creates an empty MarkovChain.
+  # 
+  # +data+ is a map which becomes owned by this MarkovChain.
+  # 
+  def initialize(data = {})
+    @data = data
+    @last_state = nil
+  end
+  
+  # 
+  # appends +states+ to the end of this MarkovChain.
+  # 
+  # +states+ are arbitrary objects.
+  # 
+  # It returns this (modified) MarkovChain.
+  # 
+  def append!(states)
+    for next_state in states
+      state_occurences_map = (@data[@last_state] or Hash.new)
+      state_occurences_map[next_state] ||= 0
+      state_occurences_map[next_state] += 1
+      @data[@last_state] = state_occurences_map
+      @last_state = next_state
+    end
+    return self
+  end
+  
+  #
+  # returns Enumerable of predicted states. The result may contain nils if
+  # the MarkovChain can not predict a state.
+  # 
+  def predict()
+    self.extend(Prediction)
+  end
+  
+  # 
+  # +data+ passed to #initialize().
+  # 
+  def data
+    @data
+  end
+  
+  private
+  
+  # :enddoc:
+  
+  # 
+  # This module is only intended for inclusion into MarkovChain.
+  # 
+  module Prediction
+    
+    include Enumerable
+    
+    def each
+      #
+      last_state = @last_state
+      loop do
+        #
+        next_state = begin
+          state_occurences_map = (@data[last_state] or Hash.new)
+          occurences_sum = state_occurences_map.reduce(0) do |sum, entry|
+            sum + entry[1]
+          end
+          choice = rand(occurences_sum + 1)
+          chosen_state_and_occurences = state_occurences_map.find do |state, occurences|
+            choice -= occurences
+            choice <= 0 
+          end
+          chosen_state_and_occurences ||= [nil, nil]
+          chosen_state_and_occurences[0]
+        end
+        #
+        yield next_state
+        #
+        last_state = next_state
+      end
+    end
+    
+  end
+  
+end

data/lib/markov_chain_chat_bot.rb

@@ -0,0 +1,560 @@
+# encoding: UTF-8
+require 'markov_chain'
+require 'stringio'
+
+# 
+# A chat bot utilizing MarkovChain.
+# 
+class MarkovChainChatBot
+  
+  private_class_method :new
+  
+  #
+  # +data+ is a map. It may be empty, in this case a brand new ChatBot is
+  # created. +data+ becomes owned by the returned ChatBot.
+  # 
+  # +answer_limit+ is maximum size of the result of #answer().
+  # 
+  def self.from(data, answer_limit = 1000)
+    new(data, answer_limit)
+  end
+  
+  def initialize(data, answer_limit)  # :nodoc:
+    @markov_chain =
+      if data.empty? then MarkovChain.new(data)
+      else MarkovChain.from(data)
+      end
+    @answer_limit = answer_limit
+  end
+  
+  # +data+ passed to #from().
+  def data
+    @markov_chain.data
+  end
+  
+  def learn(text)
+    @markov_chain.append!(tokenize(text)).append!([EndOfMessage.new])
+  end
+  
+  def answer(question)
+    answer = ""
+    previous_token = nil
+    catch :out_of_limit do
+      for token in @markov_chain.predict()
+        break if token.tkn_is_a? EndOfMessage or token.nil?
+        delimiter = 
+          if (previous_token.tkn_is_a? Word and token.tkn_is_a? Word) then " "
+          else ""
+          end
+        answer.append_limited(delimiter + token.tkn_value, @answer_limit)
+        previous_token = token
+      end
+    end
+    return answer
+  end
+  
+  private
+  
+  # :enddoc:
+  
+  class ::String
+    
+    # appends +appendment+ to this String or throws +:out_of_limit+ if
+    # this String will exceed +limit+ after the appending.
+    # 
+    # It returns this (modified) String.
+    # 
+    def append_limited(appendment, limit)
+      throw :out_of_limit if self.length + appendment.length > limit
+      self << appendment
+      return self
+    end
+    
+  end
+  
+  Token = Object
+  
+  class Token
+    
+    def tkn_value
+      self[1..-1]
+    end
+    
+    def tkn_is_a?(clazz)
+      clazz === self
+    end
+    
+  end
+  
+  class Word < Token
+    
+    def self.new(value)
+      "w" + value
+    end
+    
+    def self.===(x)
+      x.is_a? String and x[0] == "w"
+    end
+    
+  end
+  
+  class PunctuationMark < Token
+    
+    def self.new(value)
+      "p" + value
+    end
+    
+    def self.===(x)
+      x.is_a? String and x[0] == "p"
+    end
+    
+  end
+  
+  class EndOfMessage < Token
+    
+    def self.new()
+      nil
+    end
+    
+    def self.===(x)
+      x.nil?
+    end
+    
+  end
+  
+  #
+  # returns Array of Token-s.
+  # 
+  def tokenize(text)
+    yy_parse(StringIO.new(text))
+  end
+  
+
+      
+      # 
+      # +input+ is IO. It must have working IO#pos, IO#pos= and
+      # IO#set_encoding() methods.
+      # 
+      # It may raise YY_SyntaxError.
+      # 
+      def yy_parse(input)
+        input.set_encoding("UTF-8", "UTF-8")
+        context = YY_ParsingContext.new(input)
+        yy_from_pcv(
+          yy_nonterm1(context) ||
+          # TODO: context.worst_error can not be nil here. Prove it.
+          raise(context.worst_error)
+        )
+      end
+
+      # TODO: Allow to pass String to the entry point.
+    
+      
+      # :nodoc:
+      ### converts value to parser-compatible value (which is always non-false and
+      ### non-nil).
+      def yy_to_pcv(value)
+        if value.nil? then :yy_nil
+        elsif value == false then :yy_false
+        else value
+        end
+      end
+      
+      # :nodoc:
+      ### converts value got by #yy_to_pcv() to actual value.
+      def yy_from_pcv(value)
+        if value == :yy_nil then nil
+        elsif value == :yy_false then false
+        else value
+        end
+      end
+      
+      # :nodoc:
+      class YY_ParsingContext
+        
+        # +input+ is IO.
+        def initialize(input)
+          @input = input
+          @worst_error = nil
+        end
+        
+        attr_reader :input
+        
+        # It is YY_SyntaxExpectationError or nil.
+        attr_accessor :worst_error
+        
+        # adds possible error to this YY_ParsingContext.
+        # 
+        # +error+ is YY_SyntaxExpectationError.
+        # 
+        def << error
+          # Update worst_error.
+          if worst_error.nil? or worst_error.pos < error.pos then
+            @worst_error = error
+          elsif worst_error.pos == error.pos then
+            @worst_error = @worst_error.or error
+          end
+          # 
+          return self
+        end
+        
+      end
+      
+      # :nodoc:
+      def yy_string(context, string)
+        # 
+        string_start_pos = context.input.pos
+        # Read string.
+        read_string = context.input.read(string.bytesize)
+        # Set the string's encoding; check if it fits the argument.
+        unless read_string and (read_string.force_encoding(Encoding::UTF_8)) == string then
+          # 
+          context << YY_SyntaxExpectationError.new(yy_displayed(string), string_start_pos)
+          # 
+          return nil
+        end
+        # 
+        return read_string
+      end
+      
+      # :nodoc:
+      def yy_end?(context)
+        #
+        if not context.input.eof?
+          context << YY_SyntaxExpectationError.new("the end", context.input.pos)
+          return nil
+        end
+        #
+        return true
+      end
+      
+      # :nodoc:
+      def yy_begin?(context)
+        #
+        if not (context.input.pos == 0)
+          context << YY_SyntaxExpectationError.new("the beginning", context.input.pos)
+          return nil
+        end
+        #
+        return true
+      end
+      
+      # :nodoc:
+      def yy_char(context)
+        # 
+        char_start_pos = context.input.pos
+        # Read a char.
+        c = context.input.getc
+        # 
+        unless c then
+          #
+          context << YY_SyntaxExpectationError.new("a character", char_start_pos)
+          #
+          return nil
+        end
+        #
+        return c
+      end
+      
+      # :nodoc:
+      def yy_char_range(context, from, to)
+        # 
+        char_start_pos = context.input.pos
+        # Read the char.
+        c = context.input.getc
+        # Check if it fits the range.
+        # NOTE: c has UTF-8 encoding.
+        unless c and (from <= c and c <= to) then
+          # 
+          context << YY_SyntaxExpectationError.new(%(#{yy_displayed from}...#{yy_displayed to}), char_start_pos)
+          # 
+          return nil
+        end
+        #
+        return c
+      end
+      
+      # :nodoc:
+      ### The form of +string+ suitable for displaying in messages.
+      def yy_displayed(string)
+        if string.length == 1 then
+          char = string[0]
+          char_code = char.ord
+          case char_code
+          when 0x00...0x20, 0x2028, 0x2029 then %(#{yy_unicode_s char_code})
+          when 0x20...0x80 then %("#{char}")
+          when 0x80...Float::INFINITY then %("#{char} (#{yy_unicode_s char_code})")
+          end
+        else
+          %("#{string}")
+        end
+      end
+      
+      # :nodoc:
+      ### "U+XXXX" string corresponding to +char_code+.
+      def yy_unicode_s(char_code)
+        "U+#{"%04X" % char_code}"
+      end
+      
+      class YY_SyntaxError < Exception
+        
+        def initialize(message, pos)
+          super(message)
+          @pos = pos
+        end
+        
+        attr_reader :pos
+        
+      end
+      
+      # :nodoc:
+      class YY_SyntaxExpectationError < YY_SyntaxError
+        
+        # 
+        # +expectations+ are String-s.
+        # 
+        def initialize(*expectations, pos)
+          super(nil, pos)
+          @expectations = expectations
+        end
+        
+        # 
+        # returns other YY_SyntaxExpectationError with #expectations combined.
+        # 
+        # +other+ is another YY_SyntaxExpectationError.
+        # 
+        # #pos of this YY_SyntaxExpectationError and +other+ must be equal.
+        # 
+        def or other
+          raise %(can not "or" #{YY_SyntaxExpectationError}s with different pos) unless self.pos == other.pos
+          YY_SyntaxExpectationError.new(*(self.expectations + other.expectations), pos)
+        end
+        
+        def message
+          expectations = self.expectations.uniq
+          [expectations[0...-1].join(", "), expectations[-1]].join(" or ") + " is expected"
+        end
+        
+        protected
+        
+        # Private
+        attr_reader :expectations
+        
+      end
+    
+      # :nodoc:
+      def yy_nonterm1(yy_context)
+        val = :yy_nil
+        (begin
+       val = [] 
+      true
+    end and while true
+      yy_vare = yy_context.input.pos
+      if not begin; yy_var9 = yy_context.input.pos; (begin
+      yy_vara = yy_nontermf(yy_context)
+      if yy_vara then
+        w = yy_from_pcv(yy_vara)
+      end
+      yy_vara
+    end and begin
+       val << Word.new(w) 
+      true
+    end) or (yy_context.input.pos = yy_var9; (begin
+      yy_varb = yy_nonterm14(yy_context)
+      if yy_varb then
+        p = yy_from_pcv(yy_varb)
+      end
+      yy_varb
+    end and begin
+       val << PunctuationMark.new(p) 
+      true
+    end)) or (yy_context.input.pos = yy_var9; yy_nonterm20(yy_context) and while true
+      yy_vard = yy_context.input.pos
+      if not yy_nonterm20(yy_context) then
+        yy_context.input.pos = yy_vard
+        break true
+      end
+    end); end then
+        yy_context.input.pos = yy_vare
+        break true
+      end
+    end) and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nontermf(yy_context)
+        val = :yy_nil
+        (begin
+       val = "" 
+      true
+    end and begin; yy_varp = yy_context.input.pos; begin
+      yy_varq = yy_nontermx(yy_context)
+      if yy_varq then
+        val << yy_from_pcv(yy_varq)
+      end
+      yy_varq
+    end or (yy_context.input.pos = yy_varp; (begin
+      yy_varr = yy_string(yy_context, "-")
+      if yy_varr then
+        h = yy_from_pcv(yy_varr)
+      end
+      yy_varr
+    end and begin
+      yy_varu = yy_context.input.pos
+      yy_varv = yy_nontermx(yy_context)
+      yy_context.input.pos = yy_varu
+      yy_varv
+    end and begin
+       val << h 
+      true
+    end)); end and while true
+      yy_varw = yy_context.input.pos
+      if not begin; yy_varp = yy_context.input.pos; begin
+      yy_varq = yy_nontermx(yy_context)
+      if yy_varq then
+        val << yy_from_pcv(yy_varq)
+      end
+      yy_varq
+    end or (yy_context.input.pos = yy_varp; (begin
+      yy_varr = yy_string(yy_context, "-")
+      if yy_varr then
+        h = yy_from_pcv(yy_varr)
+      end
+      yy_varr
+    end and begin
+      yy_varu = yy_context.input.pos
+      yy_varv = yy_nontermx(yy_context)
+      yy_context.input.pos = yy_varu
+      yy_varv
+    end and begin
+       val << h 
+      true
+    end)); end then
+        yy_context.input.pos = yy_varw
+        break true
+      end
+    end) and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nontermx(yy_context)
+        val = :yy_nil
+        begin; yy_vary = yy_context.input.pos; begin
+      yy_varz = yy_char_range(yy_context, "a", "z")
+      if yy_varz then
+        val = yy_from_pcv(yy_varz)
+      end
+      yy_varz
+    end or (yy_context.input.pos = yy_vary; begin
+      yy_var10 = yy_char_range(yy_context, "A", "Z")
+      if yy_var10 then
+        val = yy_from_pcv(yy_var10)
+      end
+      yy_var10
+    end) or (yy_context.input.pos = yy_vary; begin
+      yy_var11 = yy_char_range(yy_context, "\u{430}", "\u{44f}")
+      if yy_var11 then
+        val = yy_from_pcv(yy_var11)
+      end
+      yy_var11
+    end) or (yy_context.input.pos = yy_vary; begin
+      yy_var12 = yy_char_range(yy_context, "\u{410}", "\u{42f}")
+      if yy_var12 then
+        val = yy_from_pcv(yy_var12)
+      end
+      yy_var12
+    end) or (yy_context.input.pos = yy_vary; begin
+      yy_var13 = yy_char_range(yy_context, "0", "9")
+      if yy_var13 then
+        val = yy_from_pcv(yy_var13)
+      end
+      yy_var13
+    end); end and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nonterm14(yy_context)
+        val = :yy_nil
+        (begin
+       val = "" 
+      true
+    end and while true
+      yy_var1b = yy_context.input.pos
+      if not begin
+      yy_var1a = yy_nonterm20(yy_context)
+      if yy_var1a then
+        val << yy_from_pcv(yy_var1a)
+      end
+      yy_var1a
+    end then
+        yy_context.input.pos = yy_var1b
+        break true
+      end
+    end and (begin
+      yy_var1p = yy_context.worst_error
+      begin
+        not begin
+      yy_var1q = yy_context.input.pos
+      yy_var1r = yy_nontermx(yy_context)
+      yy_context.input.pos = yy_var1q
+      yy_var1r
+    end
+      ensure
+        yy_context.worst_error = yy_var1p
+      end
+    end and begin
+      yy_var1s = yy_char(yy_context)
+      if yy_var1s then
+        val << yy_from_pcv(yy_var1s)
+      end
+      yy_var1s
+    end) and while true
+      yy_var1t = yy_context.input.pos
+      if not (begin
+      yy_var1p = yy_context.worst_error
+      begin
+        not begin
+      yy_var1q = yy_context.input.pos
+      yy_var1r = yy_nontermx(yy_context)
+      yy_context.input.pos = yy_var1q
+      yy_var1r
+    end
+      ensure
+        yy_context.worst_error = yy_var1p
+      end
+    end and begin
+      yy_var1s = yy_char(yy_context)
+      if yy_var1s then
+        val << yy_from_pcv(yy_var1s)
+      end
+      yy_var1s
+    end) then
+        yy_context.input.pos = yy_var1t
+        break true
+      end
+    end and while true
+      yy_var1z = yy_context.input.pos
+      if not begin
+      yy_var1y = yy_nonterm20(yy_context)
+      if yy_var1y then
+        val << yy_from_pcv(yy_var1y)
+      end
+      yy_var1y
+    end then
+        yy_context.input.pos = yy_var1z
+        break true
+      end
+    end) and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nonterm20(yy_context)
+        val = :yy_nil
+        (begin; yy_var23 = yy_context.input.pos; yy_char_range(yy_context, "\t", "\r") or (yy_context.input.pos = yy_var23; yy_string(yy_context, " ")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{85}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{a0}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{1680}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{180e}")) or (yy_context.input.pos = yy_var23; yy_char_range(yy_context, "\u{2000}", "\u{200a}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{2028}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{2029}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{202f}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{205f}")) or (yy_context.input.pos = yy_var23; yy_string(yy_context, "\u{3000}")); end and begin
+       val = " " 
+      true
+    end) and yy_to_pcv(val)
+      end
+      
+end
+

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: markov_chain_chat_bot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Lavir the Whiolet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-23 00:00:00.000000000 Z
+dependencies: []
+description: A chat bot utilizing Markov chains. It speaks Russian and English.
+email: Lavir.th.Whiolet@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- lib/auto_marshalling_map.rb
+- lib/chat_bot.rb
+- lib/markov_chain.rb
+- lib/markov_chain_chat_bot.rb
+- README
+homepage: https://github.com/LavirtheWhiolet/markov-chain-bot-module
+licenses:
+- Public Domain
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Markov chain chat bot
+test_files: []