lolspeak 1.0.0

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Dave Dribin
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,22 @@
+lolspeak is an English to LOLspeak translator. It contains a default
+dictionary and various helper methods. The main class is the
+LOLspeak::Tranzlator class. Since you typically don't need to use a custom
+dictionary, you will most likely use the default tranzlator,
+LOLspeak.default_tranzlator. Or better yet, use the extensions to String and
+REXML::Element. For example:
+
+  "Hi there! You have a cute cat.".to_lolspeak
+    -> "oh hai thar! u has cute kitteh."
+
+To install this via Ruby Gems:
+
+  % sudo gem install lolspeak
+
+It also includes a command line application called lolspeak:
+
+  % lolspeak "Hi there! You have a cute cat."
+  oh hai thar! u has cute kitteh.
+
+For more information and the latest version, visit:
+
+http://www.dribin.org/dave/lolspeak/

data/Rakefile

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift 'lib'
+require 'lolspeak/version'
+
+$KCODE = "UTF-8"
+
+task :default => [:test_units]
+
+desc "Run basic tests"
+Rake::TestTask.new("test_units") do |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = false
+  t.warning = true
+end
+
+PKG_NAME = 'lolspeak'
+PKG_VERSION = LOLspeak::VERSION
+PKG_FILES = FileList[
+  '[A-Z]*', 
+  'bin/**/*',
+  'lib/**/*.rb',
+  # Add this manually, because it's copied. If it doesn't exist at the time
+  # this is run, the wildcard won't pick it up, and it won't be included
+  # in the final package.
+  'lib/lolspeak/tranzlator.yml',
+  'test/**/*',
+]
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "#{PKG_NAME} -- A LOLspeak translator"
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'bin/*')
+end
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "LOLspeak translator"
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = PKG_FILES
+  s.has_rdoc = true
+  s.bindir = 'bin'
+  s.executables = ['lolspeak']
+  s.description = <<-EOF
+  Translates English text into LOLspeak.
+  EOF
+  
+  s.author = "Dave Dribin"
+  s.homepage = "http://www.dribin.org/dave/software/lolspeak/"
+  s.rubyforge_project = 'lolspeak'
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+
+SRC_TRANZ = "../tranzlator.yml"
+DEST_TRANZ = "lib/lolspeak/tranzlator.yml"
+
+if File.exists? SRC_TRANZ
+  file DEST_TRANZ => [SRC_TRANZ] do
+    safe_ln(SRC_TRANZ, DEST_TRANZ)
+  end
+  task :tranzlator => DEST_TRANZ
+  task :test_units => [:tranzlator]
+  task :package => [:tranzlator]
+end
+

data/bin/lolspeak

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#
+# Translate text into LOLspeak
+#
+# == Usage
+#
+#   lolspeak [OPTIONS] [<text> ...]
+#
+# == Options
+#  
+# -f, --file FILE:: Read input from a file.  Use <tt>-</tt> for standard
+#                   input.
+#
+# -x, --xml:: Parse input text as XML and translate only the text portions.
+#
+# -h, --help:: Prints a help message and exits.
+#
+# -v, --version:: Prints the version and exits.
+#
+# == Author
+# Dave Dribin
+#
+# == Copyright
+# Copyright (c)  2008 Dave Dribin
+# Licensed under the MIT license.
+
+# This makes STDIN and STDOUT both act as containing UTF-8.
+$KCODE = 'u'
+
+require 'lolspeak'
+require 'optparse'
+require 'ostruct'
+require 'set'
+
+class LOLspeakApp
+  COMMAND = File.basename($0)
+  USAGE = "Usage: #{COMMAND} [OPTIONS] [<text> ...]"
+  def initialize
+    @command = File.basename($0)
+
+    @options = OpenStruct.new
+    @options.inputFile = nil
+    @options.xml = false
+    @options.try_heuristics = false
+    @options.heuristics_exclude = Set.new
+  end
+  
+  def run(argv)
+    begin
+      if parse_options(argv)
+        main(argv)
+      end
+    rescue
+      STDERR.puts "#{COMMAND}: " + $!
+      return 1
+    end
+    return 0
+  end
+  
+  def parse_options(argv)
+    opts = OptionParser.new do |opts|
+      opts.banner = USAGE
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      opts.on("-f", "--file FILE", "Read input from a file") do |fileName|
+        @options.inputFile = fileName
+      end
+      
+      opts.on("-x", "--xml", "Parse text as XML") do |fileName|
+        @options.xml = true
+      end
+
+      opts.on("-H", "--heuristics", "Enable heuristics") do
+        @options.try_heuristics = true
+      end
+
+      opts.on("-X", "--heuristics-exclude FILE",
+        "List of words excluded from heuristics") do |path|
+        @options.try_heuristics = true
+        excludes = @options.heuristics_exclude
+        File.open(path) do |f|
+          f.each { |word| excludes.add(word.chomp) }
+        end
+      end
+      
+      opts.on_tail("-h", "--help", "Show a help message") do
+        puts opts
+        return false
+      end
+
+      opts.on_tail("-v", "--version", "Show version") do
+        puts "#{COMMAND} #{LOLspeak::VERSION}"
+        return false
+      end
+    end
+    
+    opts.parse!(argv)
+    return true
+  end
+  
+  def main(argv)
+    if @options.try_heuristics
+      LOLspeak.default_tranzlator.trace = true
+      LOLspeak.default_tranzlator.try_heuristics = true
+      LOLspeak.default_tranzlator.heuristics_exclude = @options.heuristics_exclude
+    end
+
+    if argv.length == 0 and @options.inputFile.nil?
+      @options.inputFile = "-"
+    end
+    
+    if @options.inputFile.nil?
+      argv.collect! { |a| a.to_lolspeak }
+      puts argv.join(" ")
+      return
+    end
+    
+    if (@options.inputFile == "-")
+      io = STDIN
+    else
+      io = File.open(@options.inputFile)
+    end
+    
+    if (@options.xml)
+      translate_xml_io(io)
+    else
+      translate_io(io)
+    end
+  end
+  
+  def translate_io(io)
+    begin
+      io.each { |l| puts l.to_lolspeak }
+    rescue Interrupt
+    end
+  end
+  
+  def translate_xml_io(io)
+    xml = io.read
+    puts xml.xml_to_lolspeak
+  end
+end
+
+app = LOLspeakApp.new
+rc = app.run(ARGV)
+exit rc

data/lib/lolspeak.rb

@@ -0,0 +1,292 @@
+$KCODE = "UTF-8"
+
+require 'lolspeak/version'
+require 'yaml'
+require 'rexml/document'
+require 'set'
+
+# This module encapsulates the English to LOLspeak translator.
+# See LOLspeak::Tranzlator for more information.
+module LOLspeak
+  # A class to perform English to LOLspeak translation based on a dictionary
+  # of words.
+  class Tranzlator
+    # (bool -> false) Wether or not to record translations
+    attr_accessor :trace
+    # (bool -> false) If true, try heurstics when translating words.  If
+    # false, only use the dictionary for translation.
+    attr_accessor :try_heuristics
+    # (Hash) Stores all translations, if trace is true.
+    attr_reader :traced_words
+    # (Hash) Stores all words translated via heuristics, if try_heuristics is
+    # true.
+    attr_reader :translated_heuristics
+    # (Set) Words to exclude if heuristics are on.
+    attr_accessor :heuristics_exclude
+    
+    class << Tranzlator
+      # Creates a Tranzlator using a dictionary from a YAML file
+      #
+      # :call-seq:
+      #   Tranzlator.from_file(file)        -> Tranzlator
+      #
+      def from_file(file)
+        dictionary = YAML::load_file(file)
+        return Tranzlator.new(dictionary)
+      end
+    end
+    
+    # Creates a Tranzlator from the given dictionary
+    #
+    # :call-seq:
+    #   initialize(dictionary) -> Tranzlator
+    #
+    def initialize(dictionary)
+      @dictionary = dictionary
+      @traced_words = {}
+      @try_heuristics = false
+      @translated_heuristics = {}
+      @heuristics_exclude = Set.new
+    end
+
+    # Translates a single word into LOLspeak. By default, the result is in all
+    # lower case:
+    #   
+    #   translator.translate_word("Hi") -> "oh hai"
+    #      
+    # If a block is given the word may
+    # be transformed.  You could use this to upper case or XML encode the
+    # result.  This example upper cases the result:
+    #
+    #   translator.translate_word("hi") { |w| w.upcase } -> "OH HAI"
+    #
+    # If heuristics are off, then only words in the dictionary are translated.
+    # If heuristics are on, then words not in the dictionary may be translated
+    # using standard LOLspeak heuristics, such as "*tion" -> "*shun".
+    #
+    # :call-seq:
+    #  translate_word(word)                       -> String
+    #  translate_word(word) { |word| transform }  -> String
+    #
+    def translate_word(word, &filter)
+      word = word.downcase
+      lol_word = @dictionary[word]
+      if lol_word.nil?
+        lol_word = @dictionary[word.gsub("’", "'")]
+      end
+      
+      if lol_word.nil? and word.match(/(.*)([\’\']\w+)$/)
+        prefix, suffix = $1, $2
+        lol_word = @dictionary[prefix]
+        lol_word += suffix if !lol_word.nil?
+      end
+      
+      if lol_word.nil? and @try_heuristics and !@heuristics_exclude.member?(word)
+        if (word =~ /(.*)tion(s?)$/)
+          lol_word = "#{$1}shun#{$2}"
+        elsif (word =~ /(.*)ed$/)
+          lol_word = "#{$1}d"
+        elsif (word =~ /(.*)ing$/)
+          lol_word = "#{$1}in"
+        elsif (word =~ /(.*)ss$/)
+          lol_word = "#{$1}s"
+        elsif (word =~ /(.*)er$/)
+          lol_word = "#{$1}r"
+        elsif (word !~ /ous$/) and (word =~ /^([0-9A-Za-z_]+)s$/)
+          lol_word = "#{$1}z"
+        end
+        if (word =~ /ph/)
+          lol_word = word.dup if lol_word.nil?
+          lol_word.gsub!(/ph/, 'f')
+        end
+
+        if !lol_word.nil?
+          @translated_heuristics[word] = lol_word
+        end
+      end
+
+      if lol_word.nil?
+        lol_word = word
+      else
+        @traced_words[word] = lol_word
+      end
+      
+      if !filter.nil?
+        lol_word = filter.call(lol_word)
+      end
+
+      return lol_word
+    end
+    
+    # Clears the trace word hash
+    def clear_traced_words
+      @traced_words = {}
+    end
+    
+    # Clears the hash storing words translated by heuristics
+    def clear_translated_heuristics
+      @translated_heuristics = {}
+    end
+    
+    # Translates all the words in a string. If a block is given, it is called
+    # to transform each individual word.
+    #
+    # :call-seq:
+    #  translate_words(words)                       -> String
+    #  translate_words(words) { |word| transform }  -> String
+    #
+    def translate_words(words, &filter)
+      lol_words = words.gsub(/(\w[\w’\']*)(\s*)/) do
+        word, space = $1, $2
+        lol_word = translate_word(word, &filter)
+
+        # Stick the space back on, as long is it's not empty
+        lol_word += space if lol_word != ""
+        lol_word
+      end
+      return lol_words
+    end
+  
+    # Translates the REXML::Text parts of a single REXML::Element. The element
+    # is modified in place.
+    #
+    # If a block is given, it is called to transform each individual word. By
+    # default, each word is XML escaped, so this transform applies on top of
+    # that.
+    #
+    # :call-seq:
+    #  translate_xml_element!(xml_element)
+    #  translate_xml_element!(xml_element) { |word| transform }
+    #
+    def translate_xml_element!(xml_element, &filter)
+      xml_element.texts.each do |text|
+        string = REXML::Text::unnormalize(text.to_s)
+        string = self.translate_words(string) do |w|
+          w = REXML::Text::normalize(w)
+          w = filter.call(w) if !filter.nil?
+          w
+        end
+        new_text = REXML::Text.new(string, true, nil, true)
+        text.replace_with(new_text)
+      end
+    end
+
+    # Translates the REXML::Text parts of an REXML::Element and all child
+    # elements. The elements are modified in place.
+    #
+    # If a block is given, it iscalled to transform each individual word. By
+    # default, each word is XML escaped, so this transform applies on top of
+    # that.
+    #
+    # :call-seq:
+    #  translate_xml_element!(xml_element)
+    #  translate_xml_element!(xml_element) { |word| transform }
+    #
+    def translate_xml_element_recursive!(xml_element, &filter)
+      xml_element.each_recursive { |e| translate_xml_element!(e, &filter) }
+    end
+  
+    # Translates the text parts of a well-formed XML string.  It parses the
+    # string using REXML and then translates the root element using
+    # translate_xml_element_recursive!.
+    #
+    # If a block is given, it is called to transform each individual word.
+    #
+    # :call-seq:
+    #   translate_xml_string(xml_string)                      -> String
+    #   translate_xml_string(xml_string) { |word| transform } -> String
+    #
+    def translate_xml_string(xml_string, &filter)
+      xml_doc = REXML::Document.new xml_string
+      translate_xml_element_recursive!(xml_doc, &filter)
+      return xml_doc.to_s
+    end
+  end
+
+  class << self
+    @@default_tranzlator = nil
+    
+    # Sets the default Tranzlator to new_tranzlator
+    #
+    def default_tranzlator=(new_tranzlator)
+      return @@default_tranzlator = new_tranzlator
+    end
+
+    # Returns the default Tranzlator.  On the first time it is called, it
+    # creates a Translator using the built-in dictionary.
+    #
+    def default_tranzlator
+      if @@default_tranzlator.nil?
+        default_file = File.join(File.dirname(__FILE__), "lolspeak",
+          "tranzlator.yml")
+        @@default_tranzlator = Tranzlator.from_file(default_file)
+      end
+      return @@default_tranzlator
+    end
+  end
+end
+
+class String
+  # Translates all the words in this string.  Calls Tranzlator.translate_words
+  # on the receiver using the default Tranzlator.
+  #
+  #   "Hi cat".to_lospeak -> "oh hai kitteh"
+  #
+  # See also: LOLspeak.default_tranzlator
+  #     
+  # :call-seq:
+  #   to_lolspeak                       -> String
+  #   to_lolspeak { |word| transform }  -> String
+  #
+  def to_lolspeak(&filter)
+    return LOLspeak::default_tranzlator.translate_words(self, &filter)
+  end
+  
+  # Treats the string as XML and translates all the text in this string. Calls
+  # Tranzlator.translate_xml_string on the receiver using the default
+  # Tranzlator.
+  #
+  # See also: LOLspeak.default_tranzlator
+  #
+  # :call-seq:
+  #   xml_to_lolspeak                       -> String
+  #   xml_to_lolspeak { |word| transform }  -> String
+  #
+  def xml_to_lolspeak(&filter)
+    return LOLspeak::default_tranzlator.translate_xml_string(self, &filter)
+  end
+end
+
+module REXML # :nodoc:
+  class Element
+    
+    # Translates each REXML::Text of this element.  Calls
+    # Tranzlator.translate_xml_element! on the receiver using the default
+    # tranzlator.
+    #
+    # See also: LOLspeak.default_tranzlator
+    #
+    # :call-seq:
+    #   to_lolspeak!
+    #   to_lolspeak! { |word| transform }
+    #
+    def to_lolspeak!(&filter)
+      LOLspeak::default_tranzlator.translate_xml_element!(self, &filter)
+    end
+  
+    # Translates each REXML::Text of this element and all child elements.
+    # Calls Tranzlator.translate_xml_element_recusvie! on the receiver using
+    # the default tranzlator.
+    #
+    # See also: LOLspeak.default_tranzlator
+    #
+    # :call-seq:
+    #   to_lolspeak_recursive!
+    #   to_lolspeak_recursive! { |word| transform }
+    #
+    def to_lolspeak_recursive!(&filter)
+      t = LOLspeak::default_tranzlator
+      t.translate_xml_element_recursive!(self, &filter)
+    end
+  end
+end