rubylabs 0.5.4

data/lib/elizalab.rb

@@ -0,0 +1,523 @@
+#! /usr/bin/env ruby
+
+=begin rdoc
+
+== ELIZA
+  
+Joseph Weizenbaum's ELIZA program in Ruby.  Students can play with the Doctor script,
+which mimics a Rogerian psychiatrist, and experiment by adding new rules to Doctor or
+writing their own scripts.
+
+=end
+
+require 'priorityqueue'
+
+require 'readline'
+include Readline
+
+
+class String
+  
+=begin rdoc
+A useful operation on strings -- call +s.unquote+ to remove double quotes from
+the beginning and end of string +s+.
+=end
+
+	def unquote
+		if self[0] == ?" && self[-1] == ?"
+			return self.slice(1..-2)
+		else
+			return self
+		end
+	end
+	
+end
+
+=begin rdoc
+  
+A transformation rule is associated with a key word, and is triggered
+when that word is found in an input sentence.  Rules have integer
+priorities, and if more than one rule is enabled ELIZA applies the one
+with the highest priority.  Each rule has an ordered list of patterns, 
+and each pattern has a list of reassembly rules.  
+
+To apply a rule, scan the patterns, and for the first pattern that matches 
+a sentence, build the output using the current reassembly rule.
+
+=end
+
+class Rule
+  
+	attr_accessor :key, :priority, :patterns
+	
+=begin rdoc
+  Specify the key word for a rule when the rule is created.
+=end
+	def initialize(key, priority = 1)
+		@key = key
+		@priority = priority
+		@patterns = Array.new
+	end
+	
+	def addPattern(expr)
+		if expr.class == Pattern
+			@patterns << expr
+		else
+			if expr.class == String
+				expr = Regexp.new(expr.slice(1..-2))
+			end
+			@patterns << Pattern.new(expr)
+		end
+	end
+	
+	def [](n)
+		@patterns[n]
+	end
+	
+	def addReassembly(line, n = -1)
+		@patterns[n].addText(line)
+	end
+	
+	
+=begin rdoc
+  Rule application -- try the patterns in order.  When the line matches a pattern,
+  return the next reassembly for that pattern.  Apply variable substitutions to both
+  the patterns and the reassemblies if they contain variables.
+=end
+	
+	
+	def apply(s, post = {}, verbose = false)
+		@patterns.each do |p|
+			if verbose
+			  print "trying pattern "
+				p p.regexp
+			end
+			res = p.apply( s, post, verbose )
+			return res if ! res.nil?
+		end
+		return nil		
+	end
+	
+	def to_s
+		s = @key + " / " + @priority.to_s + "\n"
+		@patterns.each { |r| s += "  " + r.to_s + "\n" }
+		return s
+	end
+	
+	def inspect
+		s = @key.inspect
+		s += " [#{@priority}]" if @priority > 1
+		s += " --> [\n" + @patterns.join("\n") + "]"
+		return s
+	end
+
+end
+
+=begin rdoc
+
+A Pattern represents one way to transform an input sentence into a
+response.  A Pattern instance has a regular expression and a list of
+one or more reassembly strings that can refer to groups in the expression.
+There is also an index to record the last reassembly string used, so
+the application can cycle through the strings.
+
+For convenience the constructor inserts word break anchors and attaches
+a /i to the expression as needed.  NOTE: the inspect method removes these
+automatic items so the printed string is cleaner; to see the real Regexp
+call the regexp accessor.  Example:
+
+  >> p = Pattern.new(/hi/,"hello")
+  => /hi/ -> ["hello"] [0]
+  >> p.regexp
+  => /\bhi\b/i
+  
+=end
+
+
+class Pattern
+	attr_accessor :regexp, :list, :index
+	
+	def initialize(expr, text = nil)
+		re = expr.inspect
+		re.insert(1,'\b') if re =~ /^\/\w/
+		re.insert(-2,'\b') if re =~ /\w\/$/
+		re += "i" unless re =~ /\/i$/
+		@regexp = eval(re)
+		
+		if text.nil?
+			@list = Array.new
+		elsif text.class == String
+			@list = [text]
+		elsif text.class == Array
+			@list = text
+		else
+			raise "Pattern.initialize: text argument must be nil, String, or Array"
+		end
+		
+		@index = 0
+	end
+	
+	def addText(line)
+		@list << line
+	end
+	
+	def inc
+		n = @index
+		@index = (@index + 1) % @list.length
+		return n
+	end
+		
+	def apply(s, post = {}, verbose = false)
+		md = s.match(@regexp)
+		return nil if @list.empty? || md == nil
+		res = @list[inc()].clone
+		return res if res[0] == ?@
+		puts "reassembling '#{res}'" if verbose
+		res.gsub!(/\$\d+/) do |ns|
+			n = ns.slice(1..-1).to_i				# strip leading $, convert to int
+			if n && md[n]
+				puts "postprocess #{md[n]}" if verbose
+				md[n].gsub(/[a-z\-$']+/i) do |w| 
+					(post.has_key?(w) && post[w][0] != ?$) ? post[w] : w
+				end
+			else
+				warn "Pattern.apply: bad argument #{ns} in #{res}"
+				""
+			end
+		end
+		return res
+	end
+	
+	def cleanRegexp
+		res = @regexp.inspect
+		res.gsub!(/\\b/,"")
+		res.gsub!(/i$/,"")
+		return res
+	end
+	
+	def to_s
+		s = cleanRegexp + "\n"
+		@list.each { |x| s += "    \"" + x + "\"\n" }
+		return s
+	end
+	
+	def inspect
+		return cleanRegexp + ": " + @list.inspect 
+	end
+	
+end
+
+
+module Eliza
+	
+	# These top level constants define the "application" processed by ELIZA -- the rule
+	# sets used to transform inputs to outputs.  The arrays are all initially empty.
+	# The 'load' method reads and parses rules and fills in these arrays.  The 'reset'
+	# method empties them.
+	
+	@@script = nil
+	@@aliases = Hash.new
+	@@vars = Hash.new
+	@@starts = Array.new
+	@@stops = Array.new
+	@@pre = Hash.new
+	@@post = Hash.new
+	@@default = nil
+	@@rules = Hash.new
+	@@queue = PriorityQueue.new
+	
+	@@word = /[a-z\-$']+/i				# pattern for a "word" in the input language
+	@@iword = /^[a-z\-$']+/i			# same, but must be the first item on the line
+	@@var = /\$\d+/								# variable name in reassembly string
+	
+	@@verbose = false
+	
+	def Eliza.rules
+		return @@rules
+	end
+	
+	def Eliza.queue
+		return @@queue
+	end
+	
+	def Eliza.aliases
+		return @@aliases
+	end
+	
+	def Eliza.vars
+		return @@vars
+	end
+		
+	def Eliza.pre
+		return @@pre
+	end
+	
+	def Eliza.post
+		return @@post
+	end
+	
+	def Eliza.verbose
+		@@verbose = true
+	end
+	
+	def Eliza.quiet
+		@@verbose = false
+	end
+			
+	# First pass over the input -- scan each word, apply preprocessing substitutions,
+	# add rule names to the priority queue.  NOTE: this method does a destructive
+	# update to the input line....
+		
+	def Eliza.scan(line, queue)
+		line.gsub!(@@word) { |w| @@pre.has_key?(w) ? @@pre[w] : w }
+		puts "preprocess: line = '#{line}'" if @@verbose
+		line.scan(@@word) do |w|
+			w.downcase!
+			if r = @@rules[w]
+				queue.insert(r) 
+				puts "add rule for '#{w}' to queue" if @@verbose
+			end
+			if (x = @@aliases[w]) && (r = @@rules[x])
+				queue.insert(r)
+				puts "add rule for '#{x}' to queue" if @@verbose
+			end
+		end
+		# queue.each { |r| puts r.key }
+	end
+		
+	def Eliza.apply(line, rule)
+		puts "applying rule: key = '#{rule.key}'" if @@verbose
+		if res = rule.apply(line, @@post, @@verbose)		
+			if res[0] == ?@
+				rulename = res.slice(1..-1)
+				if @@rules[rulename]
+					return Eliza.apply( line, @@rules[rulename] )
+				else
+					warn "Eliza.apply: no rule for #{rulename}"
+					return nil
+				end
+			else
+				return res
+			end
+		else
+			return nil
+		end
+	end
+	
+	# The heart of the program -- apply transformation rules to an input sentence.
+	
+	def Eliza.transform(s)
+		s.sub!(/[\n\.\?!\-]*$/,"")				# strip trailing punctuation
+		s.downcase!
+
+		@@queue = PriorityQueue.new
+		@@queue << @@default							# initialize queue with default rule
+
+		Eliza.scan(s, @@queue)						# add rules for recognized key words
+
+		while @@queue.length > 0					# apply rules in order of priority
+			p @@queue.collect { |r| r.key } if @@verbose
+			rule = @@queue.shift
+			if result = Eliza.apply(s, rule)
+				return result
+			end
+		end
+
+		warn "No rules applied" if @@queue.empty?
+		return nil
+	end
+		
+	# The parser calls this method to deal with directives (lines where the first
+	# word begins with a colon)
+	
+	def Eliza.parseDirective(line)
+		word = Eliza.detachWord(line)
+		case word
+		when "alias"
+			if line.empty? || line[0] != ?$
+				warn "symbol after :alias must be a variable name; ignoring '#{word} #{line}'"
+				return
+			else
+				sym = Eliza.detachWord(line)
+				@@vars[sym] = Array.new
+				line.split.each do |s| 
+					@@aliases[s] = sym
+					@@vars[sym] << s
+				end
+			end
+		when "start"
+			@@starts << line.unquote
+		when "stop"
+			@@stops << line.unquote
+		when "pre"
+			sym = Eliza.detachWord(line)
+			@@pre[sym] = line.unquote
+		when "post"
+			sym = Eliza.detachWord(line)
+			@@post[sym] = line.unquote
+		when "default"
+			@@default = line[@@word]
+		else
+			warn "unknown directive: :#{word} (ignored)"
+		end
+	end
+	
+	# Remove a word from the front of a line
+	
+	def Eliza.detachWord(line)
+		word = line[@@word]									# pattern matches the first word
+		if line.index(" ")
+			line.slice!(0..line.index(" "))		# delete up to end of the word
+			line.lstrip!											# in case there are extra spaces after word
+		else
+			line.slice!(0..-1)								# line just had the one word
+		end
+		return word
+	end
+	
+	# Check each pattern's regular expression and replace var names by alternation
+	# constructs.  If the script specified a default rule name look up that
+	# rule and save it as the default.
+	
+	def Eliza.compileRules
+		@@rules.each do |key,val|
+			a = val.patterns()
+			a.each do |p|
+				expr = p.regexp.inspect
+				expr.gsub!(/\$\w+/) { |x| @@vars[x].join("|") }
+				p.regexp = eval(expr)
+			end
+		end
+		if @@default.class == String
+			@@default = @@rules[@@default]
+		end
+	end
+		
+	# Parse rules in file f, store them in global arrays.  Strategy: use a local
+	# var named 'rule', initially set to nil.  New rules start with a single word
+	# at the start of a line.  When such a line is found in the input file, create a
+	# new Rule object and store it in 'rule'.  Subsequent lines that are part of the
+	# current rule (lines that contain regular expressions or strings) are added to 
+	# current Rule object.  Directives indicate the end of a rule, so 'rule' is reset 
+	# to nil when a directive is seen.
+	
+	def Eliza.load(filename)
+		begin
+		  Eliza.reset
+			rule = nil
+			File.open(filename).each do |line|
+				line.strip!
+				next if line.empty? || line[0] == ?#
+				if line[0] == ?:
+					Eliza.parseDirective(line)
+					rule = nil
+				else
+					if line =~ @@iword
+						rulename, priority = line.split
+						rule = priority ? Rule.new(rulename, priority.to_i) : Rule.new(rulename)
+						@@rules[rule.key] = rule
+					elsif rule.nil?
+						warn "missing rule name? unexpected input '#{line}'"
+					elsif line[0] == ?/
+						if line[-1] == ?/
+							rule.addPattern(line)
+						else
+							warn "badly formed expression (missing /): '#{line}'"
+						end
+					elsif line[0] == ?"
+						if line[-1] == ?"
+							rule.addReassembly(line.unquote)
+						else
+							warn "badly formed string (missing \"): '#{line}'"
+						end
+					elsif line[0] == ?@
+						rule.addReassembly(line)
+					else
+						warn "unexpected line in rule for #{rulename}: '#{line}'"
+					end
+				end
+			end
+			Eliza.compileRules
+			@@script = filename
+		rescue
+			puts "Error processing #{filename}: #{$!}"
+			return false
+		end
+		return true
+	end
+	
+	def Eliza.dump
+		puts "Script: #{@@script}"
+		print "Starts:\n  "; p @@starts
+		print "Stops:\n  "; p @@stops
+		print "Vars:\n  "; p @@vars
+		print "Aliases:\n  "; p @@aliases
+		print "Pre:\n  "; p @@pre
+		print "Post:\n  "; p @@post
+		print "Default:\n  "; p @@default
+		print "Queue:\n  "; p @@queue.collect { |r| r.key }
+		puts
+		@@rules.each { |key,val| puts val }
+		return nil
+	end
+	
+	def Eliza.info
+		puts "Script: #{@@script}"
+		puts "#{@@rules.size} rules"
+		puts "Keys: "
+		
+		keys = Array.new
+		@@rules.each_key { |k| keys << k unless k[0] == ?$ }
+		keys += @@aliases.keys
+		puts "  " + keys.sort.join(", ")
+	end
+	
+	# Initialization -- reset all the aliases, etc, and make a single rule
+	# that echoes the input.
+	
+	def Eliza.reset
+		@@script = nil
+		@@aliases.clear
+		@@vars.clear
+		@@starts.clear
+		@@stops.clear
+		@@pre.clear
+		@@post.clear
+		@@rules.clear
+		@@queue.clear
+		
+		@@default = Rule.new(:default)
+		@@default.addPattern(/(.*)/)
+		@@default.addReassembly("$1")
+	end
+	
+	def Eliza.run
+		puts @@starts[rand(@@starts.length)] if ! @@starts.empty?
+	  loop do 
+      s = readline("  H: ", true)
+			return if s.nil?
+			s.chomp!
+		  next if s.empty?
+			if s == "bye" || s == "quit"
+				puts @@stops[rand(@@stops.length)] if ! @@stops.empty?
+				return
+			end
+		  puts "  C: " + Eliza.transform(s)
+		end
+	end
+
+end
+
+# When invoked from command line load the script specified by the command line
+# argument and then start ELIZA
+
+if !defined? IRB
+	filename = ARGV.shift or abort "Usage: eliza.rb F\n  Run ELIZA using rules in file F"
+	Eliza.verbose if ARGV[0] == "-v"
+  if Eliza.load(filename)
+		Eliza.run
+	end
+else
+	Eliza.reset
+end
+

data/lib/encryptionlab.rb

@@ -0,0 +1,42 @@
+
+=begin rdoc
+  
+== Encryption Lab
+
+Ruby implementation of Caesar cypher and RSA encryption.
+
+=end
+
+module RubyLabs
+	
+module EncryptionLab
+
+=begin rdoc
+  Caesar cipher -- single letter substitution based on "rotating" each letter +n+ places.
+=end
+
+# :begin :caesar
+def caesar(s, n = 3)
+  res = String.new
+  s.each_byte do |byte|
+    if byte >= ?a && byte <= ?z
+      res << rot(byte, ?a, n)
+    elsif byte >= ?A && byte <= ?Z
+      res << rot(byte, ?A, n)
+    else
+      res << byte
+    end
+  end
+  return res
+end
+# :end :caesar
+
+def rot(char, base, n)
+  return ((char - base) + n) % 26 + base
+end
+
+
+
+end # EncryptionLab
+
+end # RubyLabs