mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/bbcode.rb

@@ -0,0 +1,397 @@
+# = BBCode
+#
+# = Synopsis
+#
+# The BBCode module helps ease the separation of core and frontend with the
+# core (or submodules) being still able to say, what colors shall be used
+# in it's responses. This is achieved by encoding formatting information
+# using the BBCode tokens. This enables you to "pipe" layout information
+# such as colors, style, fonttype, size and alignment through the core to
+# the frontend.
+#
+# Additionally it converts markups/codes between ANSI, HTML and BBCode
+# almost freely ;)
+#
+# == Usage
+#
+#   # Converting a bbcode string to ANSI and XHTML
+#
+#   str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
+#   print( BBCode.bbcode_to_ansi(str) )
+#   print( BBCode.bbcode_to_html(str) )
+#
+# == Authors
+#
+# * Thomas-Ivo Heinen
+#
+# == Copying
+#
+# Copyright (c) 2002 Thomas-Ivo Heinen
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+# = BBCode
+#
+# The BBCode module helps ease the separation of core and frontend with the
+# core (or submodules) being still able to say, what colors shall be used
+# in it's responses. This is achieved by encoding formatting information
+# using the BBCode tokens. This enables you to "pipe" layout information
+# such as colors, style, fonttype, size and alignment through the core to
+# the frontend.
+#
+# Additionally it converts markups/codes between ANSI, HTML and BBCode
+# almost freely ;)
+#
+# == Usage
+#
+#   # Converting a bbcode string to ANSI and XHTML
+#
+#   str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
+#   print( BBCode.bbcode_to_ansi(str) )
+#   print( BBCode.bbcode_to_html(str) )
+#
+module BBCode
+
+  ## ANSIname => ANSIcode LUT
+  ANSINAME2CODE= {  "reset"     => "\e[0m",    "bold"       => "\e[1m",
+                    "underline" => "\e[4m",    "blink"      => "\e[5m",
+                    "reverse"   => "\e[7m",    "invisible"  => "\e[8m",
+                    "black"     => "\e[0;30m", "darkgrey"   => "\e[1;30m",
+                    "red"       => "\e[0;31m", "lightred"   => "\e[1;31m",
+                    "green"     => "\e[0;32m", "lightgreen" => "\e[1;32m",
+                    "brown"     => "\e[0;33m", "yellow"     => "\e[1;33m",
+                    "blue"      => "\e[0;34m", "lightblue"  => "\e[1;34m",
+                    "purple"    => "\e[0;35m", "magenta"    => "\e[1;35m",
+                    "cyan"      => "\e[1;36m", "lightcyan"  => "\e[1;36m",
+                    "grey"      => "\e[0;37m", "white"      => "\e[1;37m",
+                    "bgblack"   => "\e[40m",   "bgred"      => "\e[41m",
+                    "bggreen"   => "\e[42m",   "bgyellow"   => "\e[43m",
+                    "bgblue"    => "\e[44m",   "bgmagenta"  => "\e[45m",
+                    "bgcyan"    => "\e[46m",   "bgwhite"    => "\e[47m"
+                  }
+
+  ## BBColor => ANSIname LUT
+  BBCOLOR2ANSI  = { "skyblue"   => "blue",     "royalblue" => "blue",
+                    "blue"      => "blue",     "darkblue"  => "blue",
+                    "orange"    => "red",      "orangered" => "red",
+                    "crimson"   => "red",      "red"       => "lightred",
+                    "firebrick" => "red",      "darkred"   => "red",
+                    "green"     => "green",    "limegreen" => "green",
+                    "seagreen"  => "green",    "darkgreen" => "green",
+                    "deeppink"  => "magenta",  "tomato"    => "red",
+                    "coral"     => "cyan",     "purple"    => "purple",
+                    "indigo"    => "blue",     "burlywood" => "red",
+                    "sandybrown"=> "red",      "sierra"    => "sierra",
+                    "chocolate" => "brown",    "teal"      => "teal",
+                    "silver"    => "white",
+                    "black"     => "black",    "yellow"    => "yellow",
+                    "magenta"   => "magenta",  "cyan"      => "cyan",
+                    "white"     => "white"
+                  }
+
+  ## ANSInames => BBCode LUT
+  ANSINAME2BBCODE = { "bold" => "B", "underline" => "U", "reverse" => "I",
+
+                      "red"    => "COLOR=red",      "blue"   => "COLOR=blue",
+                      "green"  => "COLOR=green",    "cyan"   => "COLOR=cyan",
+                      "magenta"=> "COLOR=deeppink", "purple" => "COLOR=purple",
+                      "black"  => "COLOR=black",    "white"  => "COLOR=white",
+                      "yellow" => "COLOR=yellow",   "brown"  => "COLOR=chocolate"
+                    }
+
+  ## Needed for alignments
+  @@width = 80
+
+
+  # ---------------------------
+
+  # Returns the ANSI sequence for given color, if existant
+  def BBCode.ansi(colorname)
+      colorname.strip!
+      return ANSINAME2CODE[ colorname.downcase ]
+  end
+
+  # --- strip_bbcode( string )
+  # Will strip any BBCode tags from the given string.
+  def BBCode.strip_bbcode(string)
+      string.strip!
+      return string.gsub(/\[[A-Za-z0-9\/=]+\]/, "")
+  end
+
+  # Returns the string with all ansi escape sequences converted to BBCodes
+  def BBCode.ansi_to_bbcode(string)
+      return "" if string.nil? || string.to_s.strip.empty?
+      result = ""
+      tagstack = []
+
+      ## Iterate over input lines
+      string.split("\n").each do |line|
+          ansi = line.scan(/\e\[[0-9;]+m/)
+          continue if ansi.nil? || ansi.empty?
+
+          ## Iterate over found ansi sequences
+          ansi.each do |seq|
+              ansiname = ANSINAME2CODE.invert["#{seq}"]
+
+              ## Pop last tag and form closing tag
+              if ansiname == "reset"
+                  lasttag = tagstack.pop
+                  bbname = "/" + String.new( lasttag.split("=")[0] )
+
+              ## Get corresponding BBCode tag + Push to stack
+              else
+                  bbname   = ANSINAME2BBCODE[ansiname]
+                  tagstack.push(bbname)
+              end
+
+              ## Replace ansi sequence by BBCode tag
+              replace = sprintf("[%s]", bbname)
+              line.sub!("#{Regexp.quote(seq)}", replace)
+          end
+
+          ## Append converted line
+          result << sprintf("%s\n", line)
+      end
+
+
+      ## Some tags are unclosed
+      while !tagstack.empty?
+          result << sprintf("[/%s]", String.new(tagstack.pop.split("=")[0])  )
+      end
+
+      return result
+  end
+
+  # Converts a BBCode string to one with ANSI sequences.
+  # Returns the string with all formatting instructions in BBCodes converted
+  # to ANSI code sequences / aligned with spaces to specified width.
+  def BBCode.bbcode_to_ansi(string, usecolors = true)
+      return "" if string.nil? || string.to_s.strip.empty?
+      result = ""
+
+      return BBCode.strip_bbcode(string) if !usecolors
+
+      ## Iterate over lines
+      string.split("\n").each do |line|
+
+          ## TODO: stacking? other styles!
+          ANSINAME2BBCODE.each do |key,val|
+              line.gsub!(/\[#{val}\]/, ANSINAME2CODE[key])
+              line.gsub!(/\[\/#{val}\]/, ANSINAME2CODE["reset"])
+          end
+
+          ## Fonttypes and sizes not available
+          line.gsub!(/\[SIZE=\d\]/, "")
+          line.gsub!(/\[\/SIZE\]/, "")
+          line.gsub!(/\[FONT=[^\]]*\]/, "")
+          line.gsub!(/\[\/FONT\]/, "")
+
+          ## Color-mapping
+          colors = line.scan(/\[COLOR=(.*?)\]/i)
+          colors = colors.collect{|s|  s[0].to_s} if !colors.nil?
+          colors.each do |col|
+              name = BBCOLOR2ANSI[col.downcase]
+              name = BBCOLOR2ANSI["white"] if name.nil?
+              code = ANSINAME2CODE[name]
+
+              line.gsub!(/\[COLOR=#{col}\]/i, code)
+          end
+          line.gsub!(/\[\/COLOR\]/, ANSINAME2CODE["reset"])
+
+          ## TODO: Alignment
+          ## TODO: IMGs
+          ## TODO: EMAILs
+          ## TODO: URLs
+          ## TODO: QUOTEs
+          ## TODO: LISTs
+
+          result << sprintf("%s\n", line)
+      end
+
+      return result
+  end
+
+  # Converts a HTML string into one with BBCode markup (TODO)
+  # Returns the (X)HTML markup string as BBCode
+  def BBCode.html_to_bbcode(string)
+      return "" if string.nil? || string.to_s.strip.empty?
+      result = ""
+
+      ## Iterate over lines
+      string.split(/<br *\/?>/i).each do |line|
+          styles = { "strong" => "b", "b" => "b",
+                      "em"     => "i", "i" => "i",
+                      "u"      => "u" }
+
+          ## preserve B, I, U
+          styles.each do |html,code|
+              line.gsub!(/<#{html}>/i, "[#{code.upcase}]")
+              line.gsub!(/<\/#{html}>/i, "[/#{code.upcase}]")
+          end
+
+          ## TODO: COLORs
+          ## TODO: SIZEs
+          ## TODO: FONTs
+
+          ## EMAIL
+          line.gsub!(/<a +href *= *\"mailto:(.*?)\".*?>.*?<\/a>/i, "[EMAIL]\\1[/EMAIL]")
+
+          ## URL
+          line.gsub!(/<a +href *= *\"((?:https?|ftp):\/\/.*?)\".*?>(.*?)<\/a>/i, "[URL=\\1]\\2[/URL]")
+
+          ## Other refs + closing tags => throw away
+          line.gsub!(/<a +href *= *\".*?\".*?>/i, "")
+          line.gsub!(/<\/a>/i,            "")
+
+          ## IMG
+          #line.gsub!(/<img +src *= *\"(.*?)\".*?\/?>/i, "[IMG=\\1]")
+          line.gsub!(/<img +src *= *\"(.*?)\".*?\/?>/i, "[IMG]\\1[/IMG]")
+
+          ## CENTER (right/left??)
+          line.gsub!(/<center>/i,   "[ALIGN=center]")
+          line.gsub!(/<\/center>/i, "[/ALIGN]")
+
+          ## QUOTE
+          line.gsub!(/<(?:xmp|pre)>/i,   "[QUOTE]")
+          line.gsub!(/<\/(?:xmp|pre)>/i, "[/QUOTE]")
+
+          ## LIST
+          line.gsub!(/<ul>/i,      "\n[LIST]\n")
+          line.gsub!(/<\/ul>/i,    "\n[/LIST]\n")
+          line.gsub!(/<li *\/?> */i, "\n[*] ")
+
+          ## Unkown tags => throw away
+          line.gsub!(/<.*? *\/?>/, "")
+
+          result << sprintf("%s<br />\n", line)
+      end
+
+      return result.gsub!(/<br *\/?>/i, "\n")
+  end
+
+  # Converts a BBCode string to one with HTML markup.
+  # Returns the string with all formatting instructions in
+  # BBCodes converted to XHTML markups.
+  def BBCode.bbcode_to_html(string)
+      return "" if string.nil? || string.to_s.strip.empty?
+      result = ""
+      quote = 0
+
+      ## Iterate over lines
+      string.split("\n").each do |line|
+          styles = { "b" => "strong", "i" => "em", "u" => "u" }
+
+          ## preserve B, I, U
+          styles.each do |code,html|
+              line.gsub!(/\[#{code}\]/i, "<#{html}>")
+              line.gsub!(/\[\/#{code}\]/i, "</#{html}>")
+          end
+
+          ## COLOR => font color=... (TODO: should be numeric!)
+          line.gsub!(/\[COLOR=(.*?)\]/i, "<font color=\"\\1\">")
+          line.gsub!(/\[\/COLOR\]/i,     "</font>")
+
+          ## SIZE => font size=...
+          line.gsub!(/\[SIZE=(.*?)\]/i, "<font size=\"\\1\">")
+          line.gsub!(/\[\/SIZE\]/i,     "</font>")
+
+          ## URL
+          line.gsub!(/\[URL\]([^\[]+?)\[\/URL\]/i, "<a href=\"\\1\">\\1</a>")
+          line.gsub!(/\[URL=(.*?)\](.+?)\[\/URL\]/i, "<a href=\"\\1\">\\2</a>")
+
+          ## IMG
+          line.gsub!(/\[IMG=(.*?)\]/i, "<img src=\"\\1\" />")
+
+          ## ALIGN=center (TODO: right, left)
+          line.gsub!(/\[ALIGN=center\]/i, "<center>")
+          line.gsub!(/\[ALIGN=right\]/i,  "<center>")
+          line.gsub!(/\[ALIGN=left\]/i,   "<center>")
+          line.gsub!(/\[\/ALIGN\]/i,      "</center>")
+
+          ## QUOTE
+          quote+=1 if line =~ /\[QUOTE\]/i
+          quote-=1 if (line =~ /\[\/QUOTE\]/i) && (quote > -1)
+          line.gsub!(/\[QUOTE\]/i,   "<pre>\n")
+          line.gsub!(/\[\/QUOTE\]/i, "</pre>\n")
+          line.gsub!(/^/, "&#62;"*quote) if quote > 0
+
+          ## EMAIL
+          line.gsub!(/\[EMAIL\](.*?)\[\/EMAIL\]/i, "<a href=\"mailto:\\1\">\\1</a>")
+
+          ## LIST (TODO: LIST=1, LIST=A)
+          line.gsub!(/\[LIST(?:=(.*?))?\]/i, "\n<ul>\n")
+          line.gsub!(/\[\/LIST\]/i,          "\n</ul>\n")
+          line.gsub!(/\[\*\]/i,              "\n<li />")
+
+          ## FONT => font ??????
+          ## ?BLUR?, FADE?
+
+          result << sprintf("%s<br />\n", line)
+      end
+
+      return result
+  end
+
+
+  # -- Transitive methods ---------------
+
+  # Converts a ANSI string to one with HTML markup.
+  # Returns the string with ANSI code sequences converted to XHTML markup.
+  def BBCode.ansi_to_html(string)
+      bbcoded = BBCode.ansi_to_bbcode(string )
+      htmled  = BBCode.bbcode_to_html(bbcoded)
+
+      return htmled
+  end
+
+  # Returns the (X)HTML markup code as ANSI sequences
+  def BBCode.html_to_ansi(string)
+      bbcoded = BBCode.html_to_bbcode(string )
+      ansied  = BBCode.bbcode_to_ansi(bbcoded)
+
+      return ansied
+  end
+
+end #module BBCode
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_BBCode < Test::Unit::TestCase
+
+    def test_to_ansi
+      str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
+      out = "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n"
+      assert_equal( out, BBCode.bbcode_to_ansi(str) )
+    end
+
+    def test_to_html
+      str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
+      out = "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n"
+      assert_equal( out, BBCode.bbcode_to_html(str) )
+    end
+
+  end
+
+=end
+
+
+# CREDIT Thomas-Ivo Heinen
+

data/lib/gems/facets-2.4.5/lib/more/facets/bicrypt.rb

@@ -0,0 +1,265 @@
+# = BiCrypt
+#
+# A simple two-way encryption class.
+#
+# == Authors
+#
+# * Trans
+#
+# == Copying
+#
+# Copyright (c) 2007 Trans
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'stringio'
+require 'facets/string/xor'
+
+# = BiCrypt
+#
+# A simple two-way encryption class.
+#
+class BiCrypt
+
+  ULONG   = 0x100000000
+
+  def block_size
+    return(8)
+  end
+
+  def initialize(userKey)
+
+    # These are the S-boxes given in Applied Cryptography 2nd Ed., p. 333
+    @sBox = [
+      [4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],
+      [14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9],
+      [5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11],
+      [7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3],
+      [6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2],
+      [4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14],
+      [13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12],
+      [1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12]
+    ]
+
+    # These are the S-boxes given in the GOST source code listing in Applied
+    # Cryptography 2nd Ed., p. 644.  They appear to be from the DES S-boxes
+    # [13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 ],
+    # [ 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 ],
+    # [12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 ],
+    # [ 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 ],
+    # [ 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 ],
+    # [10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 ],
+    # [15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 ],
+    # [14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 ]
+
+    # precalculate the S table
+    @sTable = precalculate_S_table()
+
+    # derive the 32-byte key from the user-supplied key
+    userKeyLength = userKey.length
+    @key = userKey[0..31].unpack('C'*32)
+    if (userKeyLength < 32)
+      userKeyLength.upto(31) { @key << 0 }
+    end
+  end
+
+
+  def precalculate_S_table()
+    sTable = [[], [], [], []]
+    0.upto(3) { |i|
+      0.upto(255) { |j|
+        t = @sBox[2*i][j % 16] | (@sBox[2*i+1][j/16] << 4)
+        u = (8*i + 11) % 32
+        v = (t << u) | (t >> (32-u))
+        sTable[i][j] = (v % ULONG)
+      }
+    }
+    return(sTable)
+  end
+
+
+  def f(longWord)
+    longWord = longWord % ULONG
+    a, b, c, d = [longWord].pack('L').unpack('CCCC')
+    return(@sTable[3][d] ^ @sTable[2][c] ^ @sTable[1][b] ^ @sTable[0][a])
+  end
+
+  def encrypt_pair(xl, xr)
+    3.times {
+      xr ^= f(xl+@key[0])
+      xl ^= f(xr+@key[1])
+      xr ^= f(xl+@key[2])
+      xl ^= f(xr+@key[3])
+      xr ^= f(xl+@key[4])
+      xl ^= f(xr+@key[5])
+      xr ^= f(xl+@key[6])
+      xl ^= f(xr+@key[7])
+    }
+    xr ^= f(xl+@key[7])
+    xl ^= f(xr+@key[6])
+    xr ^= f(xl+@key[5])
+    xl ^= f(xr+@key[4])
+    xr ^= f(xl+@key[3])
+    xl ^= f(xr+@key[2])
+    xr ^= f(xl+@key[1])
+    xl ^= f(xr+@key[0])
+    return([xr, xl])
+  end
+
+
+  def decrypt_pair(xl, xr)
+    xr ^= f(xl+@key[0])
+    xl ^= f(xr+@key[1])
+    xr ^= f(xl+@key[2])
+    xl ^= f(xr+@key[3])
+    xr ^= f(xl+@key[4])
+    xl ^= f(xr+@key[5])
+    xr ^= f(xl+@key[6])
+    xl ^= f(xr+@key[7])
+    3.times {
+      xr ^= f(xl+@key[7])
+      xl ^= f(xr+@key[6])
+      xr ^= f(xl+@key[5])
+      xl ^= f(xr+@key[4])
+      xr ^= f(xl+@key[3])
+      xl ^= f(xr+@key[2])
+      xr ^= f(xl+@key[1])
+      xl ^= f(xr+@key[0])
+    }
+    return([xr, xl])
+  end
+
+  def encrypt_block(block)
+    xl, xr = block.unpack('NN')
+    xl, xr = encrypt_pair(xl, xr)
+    encrypted = [xl, xr].pack('NN')
+    return(encrypted)
+  end
+
+
+  def decrypt_block(block)
+    xl, xr = block.unpack('NN')
+    xl, xr = decrypt_pair(xl, xr)
+    decrypted = [xl, xr].pack('NN')
+    return(decrypted)
+  end
+
+  # When this module is mixed in with an encryption class, the class
+  # must provide three methods: encrypt_block(block) and decrypt_block(block)
+  # and block_size()
+
+  def generate_initialization_vector(words)
+    srand(Time.now.to_i)
+    vector = ""
+    words.times {
+      vector << [rand(ULONG)].pack('N')
+    }
+    return(vector)
+  end
+
+
+  def encrypt_stream(plainStream, cryptStream)
+    # Cypher-block-chain mode
+
+    initVector = generate_initialization_vector(block_size() / 4)
+    chain = encrypt_block(initVector)
+    cryptStream.write(chain)
+
+    while ((block = plainStream.read(block_size())) && (block.length == block_size()))
+      block = block ^ chain
+      encrypted = encrypt_block(block)
+      cryptStream.write(encrypted)
+      chain = encrypted
+    end
+
+    # write the final block
+    # At most block_size()-1 bytes can be part of the message.
+    # That means the final byte can be used to store the number of meaningful
+    # bytes in the final block
+    block = '' if block.nil?
+    buffer = block.split('')
+    remainingMessageBytes = buffer.length
+    # we use 7-bit characters to avoid possible strange behavior on the Mac
+    remainingMessageBytes.upto(block_size()-2) { buffer << rand(128).chr }
+    buffer << remainingMessageBytes.chr
+    block = buffer.join('')
+    block = block ^ chain
+    encrypted = encrypt_block(block)
+    cryptStream.write(encrypted)
+  end
+
+
+  def decrypt_stream(cryptStream, plainStream)
+    # Cypher-block-chain mode
+    chain = cryptStream.read(block_size())
+
+    while (block = cryptStream.read(block_size()))
+      decrypted = decrypt_block(block)
+      plainText = decrypted ^ chain
+      plainStream.write(plainText) unless cryptStream.eof?
+      chain = block
+    end
+
+    # write the final block, omitting the padding
+    buffer = plainText.split('')
+    remainingMessageBytes = buffer.last.unpack('C').first
+    remainingMessageBytes.times { plainStream.write(buffer.shift) }
+  end
+
+
+  def carefully_open_file(filename, mode)
+    begin
+      aFile = File.new(filename, mode)
+    rescue
+      puts "Sorry. There was a problem opening the file <#{filename}>."
+      aFile.close() unless aFile.nil?
+      raise
+    end
+    return(aFile)
+  end
+
+
+  def encrypt_file(plainFilename, cryptFilename)
+    plainFile = carefully_open_file(plainFilename, 'rb')
+    cryptFile = carefully_open_file(cryptFilename, 'wb+')
+    encrypt_stream(plainFile, cryptFile)
+    plainFile.close unless plainFile.closed?
+    cryptFile.close unless cryptFile.closed?
+  end
+
+
+  def decrypt_file(cryptFilename, plainFilename)
+    cryptFile = carefully_open_file(cryptFilename, 'rb')
+    plainFile = carefully_open_file(plainFilename, 'wb+')
+    decrypt_stream(cryptFile, plainFile)
+    cryptFile.close unless cryptFile.closed?
+    plainFile.close unless plainFile.closed?
+  end
+
+
+  def encrypt_string(plainText)
+    plainStream = StringIO.new(plainText)
+    cryptStream = StringIO.new('')
+    encrypt_stream(plainStream, cryptStream)
+    cryptText = cryptStream.string
+    return(cryptText)
+  end
+
+
+  def decrypt_string(cryptText)
+    cryptStream = StringIO.new(cryptText)
+    plainStream = StringIO.new('')
+    decrypt_stream(cryptStream, plainStream)
+    plainText = plainStream.string
+    return(plainText)
+  end
+
+end
+