rufus-mnemo 1.0

data/README.txt

@@ -0,0 +1,69 @@
+
+= 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.
+
+The module Rufus::Mnemo has all the explanation.
+
+
+== getting it
+
+    sudo gem install rufus-mnemo
+
+or at
+
+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
+
+
+= dependencies
+
+None.
+
+
+== mailing list
+
+On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
+
+    http://groups.google.com/group/rufus-ruby
+
+
+== issue tracker
+
+http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
+
+
+== source
+
+http://rufus.rubyforge.org/svn/trunk/mnemo
+
+    svn checkout http://rufus.rubyforge.org/svn/trunk/mnemo
+
+
+== author
+
+John Mettraux, jmettraux@gmail.com 
+http://jmettraux.wordpress.com
+
+
+== license
+
+MIT
+

data/lib/rufus/mnemo.rb

@@ -0,0 +1,242 @@
+#
+#--
+# Copyright (c) 2007-2008, 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
+# 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+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 }
+
+    SYL = []
+
+    C.each do |s|
+        V.each do |v|
+            SYL << s + v
+        end
+    end
+
+    SYL << "wa"
+    SYL << "wo"
+
+    SYL << "ya"
+    SYL << "yo"
+    SYL << "yu"
+
+    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
+
+    #
+    # Turns the given integer into a Mnemo word.
+    #
+    def Mnemo.from_integer (integer)
+        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)
+    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}'"
+    end
+
+    #
+    # Given a Mnemo 'word', will split into its list of syllables.
+    # 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)
+    end
+
+    #
+    # 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
+    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.a_to_special (a)
+            a.collect do |syl|
+                SPECIAL.each do |a, b|
+                    if syl == a
+                        syl = b
+                        break
+                    end
+                end
+                syl
+            end
+        end
+
+        def Mnemo.to_special (s)
+            SPECIAL.each do |a, b|
+                s = s.gsub(a, b)
+            end
+            s
+        end
+
+        def Mnemo.from_special (s)
+            SPECIAL.each do |a, b|
+                s = s.gsub(b, a)
+            end
+            s
+        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
+            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
+    end
+end
+

data/test/test.rb

@@ -0,0 +1,73 @@
+
+#
+# Testing rufus-mnemo
+#
+# John Mettraux at openwfe.org
+#
+# Sun Mar 18 13:29:37 JST 2007
+#
+
+require 'test/unit'
+require 'rufus/mnemo'
+
+#
+# testing misc things
+#
+
+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
+
+#require 'pp'
+#pp Rufus::Mnemo::split(s2)
+#
+#puts Rufus::Mnemo::is_mnemo_word("asdfadsg")
+#puts Rufus::Mnemo::is_mnemo_word(s2)
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: rufus-mnemo
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- John Mettraux
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-25 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jmettraux@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- lib/rufus
+- lib/rufus/mnemo.rb
+- test/test.rb
+- README.txt
+has_rdoc: true
+homepage: http://rufus.rubyforge.org/rufus-mnemo
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: Turning (large) integers into japanese sounding words and vice versa
+test_files: 
+- test/test.rb