rufus-mnemo 1.0 → 1.1.0

data/README.txt

@@ -1,16 +1,14 @@
 
 = rufus-mnemo
 
-This gem was previously known as the "openwferu-kotoba" gem (http://jmettraux.wordpress.com/2007/04/23/gem-install-openwferu-kotoba/)
-
-It provides methods for turning integer into easier to remember 'words' and vice-versa.
+This gem provides methods for turning integer into easier to remember 'words' and vice-versa.
 
 The module Rufus::Mnemo has all the explanation.
 
 
 == getting it
 
-    sudo gem install rufus-mnemo
+  sudo gem install rufus-mnemo
 
 or at
 
@@ -19,18 +17,26 @@ http://rubyforge.org/frs/?group_id=4812
 
 == usage
 
-    require 'rubygems'
-    require 'rufus/mnemo'
-    
-    s = Rufus::Mnemo::from_integer 125704
-    
-    puts s
-        # => 'karasu'
-    
-    i = Rufus::Mnemo::to_integer s
-    
-    puts i
-        # => 125704
+  require 'rubygems'
+  require 'rufus/mnemo'
+  
+  s = Rufus::Mnemo::from_integer 125704
+  
+  puts s
+    # => 'karasu'
+  
+  i = Rufus::Mnemo::to_integer s
+  
+  puts i
+    # => 125704
+
+
+== about negative integers
+
+They are prefixed with the "wi" syllable (Thanks Stephan Wehner).
+
+  p Rufus::Mnemo::from_integer -173866
+    # => 'winamote'
 
 
 = dependencies
@@ -42,7 +48,7 @@ None.
 
 On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
 
-    http://groups.google.com/group/rufus-ruby
+  http://groups.google.com/group/rufus-ruby
 
 
 == issue tracker
@@ -52,9 +58,9 @@ http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
 
 == source
 
-http://rufus.rubyforge.org/svn/trunk/mnemo
+http://github.com/jmettraux/rufus-mnemo
 
-    svn checkout http://rufus.rubyforge.org/svn/trunk/mnemo
+  git checkout git://github.com/jmettraux/rufus-mnemo.git
 
 
 == author
@@ -63,6 +69,11 @@ John Mettraux, jmettraux@gmail.com
 http://jmettraux.wordpress.com
 
 
+== the rest of Rufus
+
+http://rufus.rubyforge.org
+
+
 == license
 
 MIT

data/lib/rufus/mnemo.rb

@@ -1,6 +1,5 @@
-#
 #--
-# Copyright (c) 2007-2008, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2007-2009, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -8,10 +7,10 @@
 # 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
@@ -19,224 +18,222 @@
 # 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.
-#++
-#
-
-#
-# "made in Japan"
-#
-# John Mettraux at openwfe.org
 #
+# Made in Japan.
+#++
 
 module Rufus
 
-#
-# = Rufus::Mnemo
-# 
-# This module contains methods for converting plain integers (base 10)
-# into words that are easier to read and remember.
-#
-# For example, the equivalent of the (base 10) integer 1329724967 is
-# "takeshimaya".
-#
-# Mnemo uses 70 of the syllables of the Japanese language, it is thus
-# a base 10 to base 70 converter.
-#
-# Mnemo is meant to be used for generating human readable (or more
-# easily rememberable) identifiers. Its first usage is within the 
-# OpenWFEru Ruby workflow and bpm engine for generating 'kawaii' 
-# business process instance ids.
-#
-#     require 'rubygems'
-#     require 'rufus/mnemo'
-#     
-#     s = Rufus::Mnemo::from_integer 125704
-#     
-#     puts s
-#         # => 'karasu'
-#     
-#     i = Rufus::Mnemo::to_integer s
-#     
-#     puts i
-#         # => 125704
-#
-#
-# == Mnemo from the command line
-#
-# You can use Mnemo directly from the command line :
-#
-#     $ ruby mnemo.rb kotoba
-#     141260
-#     $ ruby mnemo.rb rubi
-#     3432
-#     $ ruby mnemo.rb 2455
-#     nada
-#
-# might be useful when used from some scripts.
-#
-module Mnemo
-
-    V = %w{ a e i o u }
-    C = %w{ b d g h j k m n p r s t z }
+  #
+  # = Rufus::Mnemo
+  #
+  # This module contains methods for converting plain integers (base 10)
+  # into words that are easier to read and remember.
+  #
+  # For example, the equivalent of the (base 10) integer 1329724967 is
+  # "takeshimaya".
+  #
+  # Mnemo uses 70 of the syllables of the Japanese language, it is thus
+  # a base 10 to base 70 converter.
+  #
+  # Mnemo is meant to be used for generating human readable (or more
+  # easily rememberable) identifiers. Its first usage is within the
+  # OpenWFEru Ruby workflow and bpm engine for generating 'kawaii'
+  # business process instance ids.
+  #
+  #   require 'rubygems'
+  #   require 'rufus/mnemo'
+  #
+  #   s = Rufus::Mnemo::from_integer 125704
+  #
+  #   puts s
+  #     # => 'karasu'
+  #
+  #   i = Rufus::Mnemo::to_integer s
+  #     # => 125704
+  #
+  #
+  # == Mnemo from the command line
+  #
+  # You can use Mnemo directly from the command line :
+  #
+  #   $ ruby mnemo.rb kotoba
+  #   141260
+  #   $ ruby mnemo.rb rubi
+  #   3432
+  #   $ ruby mnemo.rb 2455
+  #   nada
+  #
+  # might be useful when used from some scripts.
+  #
+  module Mnemo
+
+    VERSION = '1.1.0'
+
+    V = %w[ a e i o u ]
+    C = %w[ b d g h j k m n p r s t z ]
 
     SYL = []
 
     C.each do |s|
-        V.each do |v|
-            SYL << s + v
-        end
+      V.each do |v|
+        SYL << s + v
+      end
     end
 
-    SYL << "wa"
-    SYL << "wo"
+    SYL << 'wa'
+    SYL << 'wo'
 
-    SYL << "ya"
-    SYL << "yo"
-    SYL << "yu"
+    SYL << 'ya'
+    SYL << 'yo'
+    SYL << 'yu'
 
-    SPECIAL = [ 
-        [ "hu", "fu" ],
-        [ "si", "shi" ],
-        [ "ti", "chi" ],
-        [ "tu", "tsu" ],
-        [ "zi", "tzu" ]
+    SPECIAL = [
+      [ 'hu', 'fu' ],
+      [ 'si', 'shi' ],
+      [ 'ti', 'chi' ],
+      [ 'tu', 'tsu' ],
+      [ 'zi', 'tzu' ]
     ]
 
-    #SYL2 = SYL.collect do |syl|
-    #    s = syl
-    #    SPECIAL.each do |a, b|
-    #        if s == a
-    #            s = b
-    #            break
-    #        end
-    #    end
-    #    s
-    #end
+    NEG = 'wi'
+    NEGATIVE = /^#{NEG}(.+)$/
 
-    #
     # Turns the given integer into a Mnemo word.
     #
     def Mnemo.from_integer (integer)
-        s = from_i(integer)
-        to_special(s)
+
+      return "#{NEG}#{from_integer(-integer)}" if integer < 0
+
+      s = from_i(integer)
+      to_special(s)
     end
 
-    #
     # Turns the given Mnemo word to its equivalent integer.
-    # 
+    #
     def Mnemo.to_integer (string)
-        s = from_special(string)
-        to_i(s)
+
+      s = from_special(string)
+      to_i(s)
     end
 
-    #
     # Turns a simple syllable into the equivalent number.
     # For example Mnemo::to_number("fu") will yield 19.
     #
     def Mnemo.to_number (syllable)
-        SYL.each_with_index do |s, index|
-            return index if syllable == s
-        end
-        raise "did not find syllable '#{syllable}'"
+
+      SYL.each_with_index do |s, index|
+        return index if syllable == s
+      end
+      raise "did not find syllable '#{syllable}'"
     end
 
-    #
     # Given a Mnemo 'word', will split into its list of syllables.
-    # For example, "tsunashima" will be split into 
+    # For example, "tsunashima" will be split into
     # [ "tsu", "na", "shi", "ma" ]
     #
     def Mnemo.split (word)
-        word = from_special(word)
-        a = string_split(word)
-        a_to_special(a)
+
+      word = from_special(word)
+      a = string_split(word)
+
+      a_to_special(a)
     end
 
-    #
-    # Returns if the string is a Mnemo word, like "fugu" or 
+    # Returns if the string is a Mnemo word, like "fugu" or
     # "toriyamanobashi".
     #
     def Mnemo.is_mnemo_word (string)
-        begin
-            to_integer(string)
-            true
-        rescue #Exception => e
-            false
-        end
+
+      begin
+        to_integer(string)
+        true
+      rescue #Exception => e
+        false
+      end
     end
 
     private
 
-        def Mnemo.string_split (s, result=[])
-            return result if s.length < 1
-            result << s[0, 2]
-            string_split(s[2..-1], result)
-        end
+    def Mnemo.string_split (s, result=[])
 
-        def Mnemo.a_to_special (a)
-            a.collect do |syl|
-                SPECIAL.each do |a, b|
-                    if syl == a
-                        syl = b
-                        break
-                    end
-                end
-                syl
-            end
-        end
+      return result if s.length < 1
 
-        def Mnemo.to_special (s)
-            SPECIAL.each do |a, b|
-                s = s.gsub(a, b)
-            end
-            s
-        end
+      result << s[0, 2]
+
+      string_split(s[2..-1], result)
+    end
+
+    def Mnemo.a_to_special (a)
 
-        def Mnemo.from_special (s)
-            SPECIAL.each do |a, b|
-                s = s.gsub(b, a)
-            end
-            s
+      a.collect do |syl|
+        SPECIAL.each do |a, b|
+          if syl == a
+            syl = b
+            break
+          end
         end
+        syl
+      end
+    end
 
-        def Mnemo.from_i (integer)
+    def Mnemo.to_special (s)
 
-            return '' if integer == 0
+      SPECIAL.inject(s) { |s, (a, b)| s.gsub(a, b) }
+    end
 
-            mod = integer % SYL.length
-            rest = integer / SYL.length
+    def Mnemo.from_special (s)
 
-            from_i(rest) + SYL[mod]
-        end
+      SPECIAL.inject(s) { |s, (a, b)| s.gsub(b, a) }
+    end
 
-        def Mnemo.to_i (s)
-            return 0 if s.length == 0
-            SYL.length * to_i(s[0..-3]) + to_number(s[-2, 2])
-        end
-end
+    def Mnemo.from_i (integer)
+
+      return '' if integer == 0
+
+      mod = integer % SYL.length
+      rest = integer / SYL.length
+
+      from_i(rest) + SYL[mod]
+    end
+
+    def Mnemo.to_i (s)
+
+      return 0 if s.length == 0
+
+      if m = s.match(NEGATIVE)
+        return -1 * to_i(m[1])
+      end
+
+      SYL.length * to_i(s[0..-3]) + to_number(s[-2, 2])
+    end
+  end
 end
 
 #
 # command line interface for Mnemo
 
 if __FILE__ == $0
-    arg = ARGV[0]
-    if arg and arg != "-h" and arg != "--help"
-        begin
-            puts Rufus::Mnemo::from_integer(Integer(arg))
-        rescue
-            puts Rufus::Mnemo::to_integer(arg)
-        end
-    else
-        puts
-        puts "ruby #{$0} {arg}"
-        puts
-        puts "  If the arg is a 'Mnemo' word, will turn it into the equivalent"
-        puts "  integer."
-        puts "  Else, it will consider the arg as an integer and attempt at"
-        puts "  turning it into a Mnemo [word]."
-        puts
-        puts "  Mnemo uses #{Rufus::Mnemo::SYL.length} syllables."
-        puts
+
+  arg = ARGV[0]
+
+  if arg and arg != "-h" and arg != "--help"
+    begin
+      puts Rufus::Mnemo::from_integer(Integer(arg))
+    rescue
+      puts Rufus::Mnemo::to_integer(arg)
     end
+  else
+    puts
+    puts "ruby #{$0} {arg}"
+    puts
+    puts "  If the arg is a 'Mnemo' word, will turn it into the equivalent"
+    puts "  integer."
+    puts "  Else, it will consider the arg as an integer and attempt at"
+    puts "  turning it into a Mnemo [word]."
+    puts
+    puts "  Mnemo uses #{Rufus::Mnemo::SYL.length} syllables."
+    puts
+  end
 end
 

data/lib/rufus-mnemo.rb

@@ -0,0 +1,3 @@
+
+require 'rufus/mnemo'
+

data/test/test.rb

@@ -7,6 +7,8 @@
 # Sun Mar 18 13:29:37 JST 2007
 #
 
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
 require 'test/unit'
 require 'rufus/mnemo'
 
@@ -16,58 +18,78 @@ require 'rufus/mnemo'
 
 class MnemoTest < Test::Unit::TestCase
 
-    #def setup
-    #end
-
-    #def teardown
-    #end
-
-    def test_0
-
-        t = Time.now
-        #puts t.to_f
-        
-        st = t.to_f * 1000 * 10
-        
-        #puts st
-        
-        st = Integer(st) % (10 * 1000 * 60 * 60)
-        #st = 28340469
-        
-        s = Rufus::Mnemo::from_integer(st)
-        
-        st2 = Rufus::Mnemo::to_integer(s)
-        s2 = Rufus::Mnemo::from_integer(st2)
-        
-        #puts st
-        #puts s
-        
-        #puts st2
-        #puts s2
-
-        assert_equal s, s2
-        assert_equal st, st2
-
-        a = Rufus::Mnemo::split(s)
-
-        assert_equal a.join, s
-
-        #puts Rufus::Mnemo::to_integer("tunashima")
-        #puts Rufus::Mnemo::to_integer("tsunashima")
-
-        assert Rufus::Mnemo::is_mnemo_word("takeshi")
-
-        assert Rufus::Mnemo::is_mnemo_word("tsunasima")
-        assert Rufus::Mnemo::is_mnemo_word("tunashima")
-
-        assert (not Rufus::Mnemo::is_mnemo_word("dsfadf"))
-        assert (not Rufus::Mnemo::is_mnemo_word("takeshin"))
-    end
-end
+  #def setup
+  #end
 
-#require 'pp'
-#pp Rufus::Mnemo::split(s2)
-#
-#puts Rufus::Mnemo::is_mnemo_word("asdfadsg")
-#puts Rufus::Mnemo::is_mnemo_word(s2)
+  #def teardown
+  #end
+
+  def test_0
+
+    t = Time.now
+    #puts t.to_f
+
+    st = t.to_f * 1000 * 10
+
+    #puts st
+
+    st = Integer(st) % (10 * 1000 * 60 * 60)
+    #st = 28340469
+
+    s = Rufus::Mnemo::from_integer(st)
+
+    st2 = Rufus::Mnemo::to_integer(s)
+    s2 = Rufus::Mnemo::from_integer(st2)
+
+    #puts st
+    #puts s
+
+    #puts st2
+    #puts s2
+
+    assert_equal s, s2
+    assert_equal st, st2
+
+    a = Rufus::Mnemo::split(s)
+
+    assert_equal a.join, s
+
+    #puts Rufus::Mnemo::to_integer("tunashima")
+    #puts Rufus::Mnemo::to_integer("tsunashima")
+
+    assert Rufus::Mnemo::is_mnemo_word("takeshi")
+
+    assert Rufus::Mnemo::is_mnemo_word("tsunasima")
+    assert Rufus::Mnemo::is_mnemo_word("tunashima")
+
+    assert (not Rufus::Mnemo::is_mnemo_word("dsfadf"))
+    assert (not Rufus::Mnemo::is_mnemo_word("takeshin"))
+  end
+
+  def test_zero
+
+    assert_equal '', Rufus::Mnemo::from_integer(0)
+    assert_equal 0, Rufus::Mnemo::to_integer('')
+  end
+
+  def test_negatives
+
+    assert_equal -35, Rufus::Mnemo::to_integer('wina')
+    assert_equal 'wina', Rufus::Mnemo::from_integer(-35)
+
+    assert_equal -1, Rufus::Mnemo::to_integer('wibe')
+    assert_equal 'wibe', Rufus::Mnemo::from_integer(-1)
+  end
+
+  def test_wi_bad_position
+
+     %w(wi wiwi bewi nawi nabewi nawibe nawiwi).each do |bad_mnemo|
+
+       error = assert_raise RuntimeError do
+         Rufus::Mnemo::to_integer(bad_mnemo)
+       end
+       assert_equal "did not find syllable 'wi'", error.to_s
+     end
+   end
+end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rufus-mnemo
 version: !ruby/object:Gem::Version 
-  version: "1.0"
+  version: 1.1.0
 platform: ruby
 authors: 
 - John Mettraux
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-25 00:00:00 +09:00
+date: 2009-07-21 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
-description: 
+description: Turning (large) integers into japanese sounding words and vice versa
 email: jmettraux@gmail.com
 executables: []
 
@@ -22,12 +22,14 @@ extensions: []
 extra_rdoc_files: 
 - README.txt
 files: 
-- lib/rufus
 - lib/rufus/mnemo.rb
+- lib/rufus-mnemo.rb
 - test/test.rb
 - README.txt
 has_rdoc: true
 homepage: http://rufus.rubyforge.org/rufus-mnemo
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -47,10 +49,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 0.9.5
+rubyforge_project: rufus
+rubygems_version: 1.3.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Turning (large) integers into japanese sounding words and vice versa
 test_files: 
 - test/test.rb