formosa 0.0.1

data/lib/ext/native_syllable_composer/compose.cpp

@@ -0,0 +1,67 @@
+#include "compose.h"
+#include <string>
+#include <stdio.h>
+#include "LibHolo.h"
+
+using namespace std;
+using namespace LibHolo;
+
+#include "ruby.h"
+
+VALUE ComposeTLSyllable(int inputType, int outputType, const char *syllable)
+{
+	int c;
+	bool composing = false;
+	HoloSyllable syl;
+	string output;
+	
+	if (inputType != 0 && inputType != 1)
+		syl.setInputType(TLSyllable);
+	else
+		syl.setInputType((SyllableType)inputType);
+	
+	while (1) {
+		c = *syllable++;
+		
+		if (isalpha(c)) {
+			if (!composing) composing = true;
+			syl.insertCharacterAtCursor(c);
+		}
+		else {
+			if (composing) {
+				int finaltone = 0;
+				int emitchar = 0;
+				
+				// some UNIX doesn't have isnumber(c)
+				if (c >= '0' && c <= '9') {
+					finaltone = c - '0';
+				}
+				else {
+					// since it's non-numeric char, we'll emit it after the composed syllable
+					emitchar = c;
+				}
+				
+				syl.normalize(finaltone);
+				
+				if (outputType == POJSyllable)
+					output += syl.convertToPOJSyllable().composedForm();
+				else
+					output += syl.convertToTLSyllable().composedForm();
+				
+				if (emitchar) {
+					output += string(1, emitchar);
+				}
+				
+				composing = false;
+				syl.clear();
+			}
+			else {
+				if (c) output += string(1, c);
+			}
+		}
+		
+		if (!c) break;
+	}
+	
+	return rb_str_new2(output.c_str());
+}

data/lib/ext/native_syllable_composer/compose.h

@@ -0,0 +1,11 @@
+#include "ruby.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+	VALUE ComposeTLSyllable(int inputType, int outputType, const char *syllable);
+
+#ifdef __cplusplus
+}
+#endif

data/lib/ext/native_syllable_composer/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+# replace TRY_LINK's CC into CXX because we want to use g++ as linker
+CONFIG['LDSHARED'].gsub!(/cc/, "g++")
+CONFIG['LDSHARED'].gsub!(/\(CC\)/, "(CXX)")
+
+create_makefile "native_syllable_composer/native_syllable_composer"

data/lib/ext/native_syllable_composer/native_syllable_composer.c

@@ -0,0 +1,34 @@
+// cf. http://www.rubyinside.com/how-to-create-a-ruby-extension-in-c-in-under-5-minutes-100.html
+// cf. http://cesare.seesaa.net/article/32850625.html
+#include "ruby.h"
+#include "compose.h"
+VALUE syllable_composer = Qnil;
+
+void Init_native_syllable_composer();
+VALUE native_syllable_composer_compose(VALUE self, VALUE rInputType, VALUE rOutputType, VALUE rSyllable);
+
+void Init_native_syllable_composer() {
+	syllable_composer = rb_define_module("NativeSyllableComposer");
+	rb_define_singleton_method(syllable_composer, "compose", native_syllable_composer_compose, 3);
+}
+
+VALUE native_syllable_composer_compose(VALUE self, VALUE rInputType, VALUE rOutputType, VALUE rSyllable) {
+	int inputType = NUM2INT(rInputType);
+	int outputType = NUM2INT(rOutputType);
+	
+	VALUE rStr = StringValue(rSyllable);
+	
+	size_t rStrLen = RSTRING(rStr)->len;
+	char *rStrPtr = RSTRING(rStr)->ptr;
+	
+	if (!rStrPtr) return Qnil;
+	
+	char *string = (char*)calloc(1, rStrLen);
+	memcpy(string, rStrPtr,rStrLen);
+
+	VALUE result = ComposeTLSyllable(inputType, outputType, string);
+	free(string);
+		
+	return result;
+}
+

data/lib/formosa/syllable_utility.rb

@@ -0,0 +1,86 @@
+module Formosa
+  # Holo language (Southern Min) module
+  module Holo
+    # Syllable type supported by Formosa    
+    module SyllableType
+      POJ = 0
+      TL = 1
+    end
+  
+    # Holo syllable utiliy
+    module SyllableUtility
+      # Compose Holo syllable from the query form ("ASCII form")
+      #
+      # * input_type: can be either SyllableType::POJ or Syllable::TL
+      # * output_type: same as above
+      # * syllable: the query form of the syllable, such as "goa2", "tai5"
+      #
+      # Conversion is done automatically when input and output types are different
+      def self.compose_syllable(input_type, output_type, syllable)
+        NativeSyllableComposer.compose(input_type, output_type, syllable)
+      end
+
+      TONE_SAMPLE = ["a", "a", "á", "à", "a", "â", "ǎ", "ā", "a̍", "a̋"]
+      LOOKUP_TABLE = {}
+
+      9.times do |index|
+        t = TONE_SAMPLE[index]
+        c = t.chars.decompose
+
+        if c.size > 1
+          tone_char = [c[1]].pack("U")
+          LOOKUP_TABLE[tone_char] = index
+        end
+      end    
+
+      # Converts a long text of composed syllables into the query form
+      def self.convert_text_into_query_form(input_type, input_string)
+        output_string = ""
+
+        input_string.split(/([^A-Za-z\x7f-\xff])/).each do |str|
+          qform = self.convert_syllable_into_query_form(input_type, str)
+          output_string += qform
+        end
+
+        output_string
+      end
+      
+      # Converts a composed syllable (the "composed form") into the query form.
+      # For example, "guá" is converted to "gua2"
+      def self.convert_syllable_into_query_form(input_type, string)
+        c = string.chars
+
+        # decomposed code points
+        dcps = c.decompose
+
+        loudest_tone = 0
+
+        composed = []
+
+        dcps.size.times do |index|
+          chr = [dcps[index]].pack("U")
+
+          if t = LOOKUP_TABLE[chr]
+            loudest_tone = t
+          else      
+            composed << dcps[index]
+          end
+        end
+
+        result = composed.pack("U*") + (loudest_tone > 0 ? loudest_tone.to_s : "")
+      
+        if input_type == SyllableType::TL
+          result.gsub!(/O\315\230/, "OO")
+          result.gsub!(/o\315\230/, "oo")
+        else
+          result.gsub!(/O\315\230/, "OU")
+          result.gsub!(/o\315\230/, "ou")
+        end
+      
+        result.gsub!(/ⁿ/, "nn")
+        result
+      end
+    
+    end
+  end
+end

data/lib/formosa/version.rb

@@ -0,0 +1,9 @@
+module Formosa #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/formosa.rb

@@ -0,0 +1,31 @@
+# Authors:: Lukhnos D. Liu (mailto:lukhnos@handlino.com)
+# Copyright:: Copyright (c) 2007 Lukhnos D. Liu
+# License:: Distributed under the New BSD License
+#
+# Formosa is a Ruby library for processing Taiwanese languages. Major languages 
+# spoken in Taiwan include Holo, Hakka, Mandarin and those of the indigenous
+# people. Formosa is the Ruby branch of the lib-formosa project
+# (http://code.google.com/p/lib-formosa/).
+#
+# Currently, we focus on the processing of the Holo (Southern Min) language,
+# with necessary tools such as SyllableComposer available for general use.
+#
+# The following example shows how to use Formosa:
+#
+#   $KCODE="u"          # set the Ruby environment to use UTF-8
+#   require "rubygems"
+#   require "formosa"
+#   include Formosa::Holo
+#   poj = SyllableType::POJ
+#   tl = SyllableType::TL
+#   SyllableUtility.compose_syllable(poj, tl, "goa2")  # => guá
+#   SyllableUtility.compose_syllable(tl, poj, "gua2")  # => goá
+
+require 'active_support'
+require 'formosa/version'
+require "native_syllable_composer/native_syllable_composer"
+require 'formosa/syllable_utility'
+
+module Formosa
+end
+

data/scripts/txt2html

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/formosa/version.rb'
+
+version  = Formosa::VERSION::STRING
+download = 'http://rubyforge.org/projects/formosa'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</
>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)