glaemscribe 1.0.0

data/lib/api/sub_rule.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+#
+# Glǽmscribe (also written Glaemscribe) is a software dedicated to
+# the transcription of texts between writing systems, and more 
+# specifically dedicated to the transcription of J.R.R. Tolkien's 
+# invented languages to some of his devised writing systems.
+# 
+# Copyright (C) 2015 Benjamin Babut (Talagan).
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# any later version.
+# 
+# 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.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Glaemscribe
+  module API
+    class SubRule
+      
+      attr_reader :src_combination, :dst_combination
+      
+      def initialize(rule, src_combination, dst_combination)
+        @src_combination = src_combination
+        @dst_combination = dst_combination     
+      end
+      
+      def p
+        "#{@src_combination.inspect} => #{@dst_combination.inspect} \n"
+      end
+      
+    end
+  end
+end

data/lib/api/transcription_pre_post_processor.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+#
+# Glǽmscribe (also written Glaemscribe) is a software dedicated to
+# the transcription of texts between writing systems, and more 
+# specifically dedicated to the transcription of J.R.R. Tolkien's 
+# invented languages to some of his devised writing systems.
+# 
+# Copyright (C) 2015 Benjamin Babut (Talagan).
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# any later version.
+# 
+# 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.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Glaemscribe
+  module API
+    
+    class PrePostProcessorOperator
+      attr_reader :args
+      
+      def initialize(raw_args)
+        @raw_args = raw_args
+      end
+      
+      def eval_arg(arg, trans_options)
+        return nil if arg.nil?
+        if arg =~ /^\\eval\s/
+          to_eval = $'
+          return Eval::Parser.new().parse(to_eval, trans_options)
+        end
+        return arg 
+      end
+      
+      def finalize(trans_options)
+        @args = []
+        @raw_args.each{ |arg|
+          @args << eval_arg(arg, trans_options)
+        }
+      end
+      
+      def apply(l)
+        raise "Pure virtual method, should be overloaded."
+      end
+    end
+    
+    class TranscriptionPrePostProcessor
+      attr_reader :root_code_block
+      
+      attr_reader :operators
+      
+      def initialize(mode)
+        @mode             = mode
+        @root_code_block  = IfTree::CodeBlock.new 
+      end
+      
+      def descend_if_tree(code_block, trans_options)
+        code_block.terms.each{ |term|         
+          if(term.is_pre_post_processor_operators?)
+            term.operators.each{ |operator|
+              @operators << operator
+            } 
+          else
+            term.if_conds.each{ |if_cond|
+              
+              if_eval = Eval::Parser.new()
+              
+              if(if_eval.parse(if_cond.expression, trans_options) == true)
+                descend_if_tree(if_cond.child_code_block, trans_options)
+                break
+              end
+            }
+          end
+        }
+      end
+      
+      def finalize(trans_options)
+        @operators = []
+        # Select operators depending on conditions
+        descend_if_tree(@root_code_block, trans_options)
+        # Reevaluate operator arguments
+        @operators.each{ |op|
+          op.finalize(trans_options)
+        }
+      end
+      
+      # Apply all preprocessor rules consecutively
+      def apply(l)
+        ret = l
+        @operators.each{ |operator|
+          ret = operator.apply(ret)
+        } 
+        ret
+      end
+      
+    end
+    
+    class PreProcessorOperator < PrePostProcessorOperator
+    end
+    
+    class TranscriptionPreProcessor < TranscriptionPrePostProcessor      
+    end
+    
+    class PostProcessorOperator < PrePostProcessorOperator
+    end
+    
+    class TranscriptionPostProcessor < TranscriptionPrePostProcessor      
+    end   
+    
+  end
+end

data/lib/api/transcription_processor.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+#
+# Glǽmscribe (also written Glaemscribe) is a software dedicated to
+# the transcription of texts between writing systems, and more 
+# specifically dedicated to the transcription of J.R.R. Tolkien's 
+# invented languages to some of his devised writing systems.
+# 
+# Copyright (C) 2015 Benjamin Babut (Talagan).
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# any later version.
+# 
+# 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.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Glaemscribe
+  module API
+    class TranscriptionProcessor 
+           
+      attr_reader   :rule_groups
+      attr_reader   :mode
+      
+      attr_accessor :out_space
+      
+      def initialize(mode)
+        @mode         = mode
+        @rule_groups  = {}
+      end
+      
+      def add_subrule(sub_rule)
+        path = sub_rule.src_combination.join("")
+        @transcription_tree.add_subpath(path, sub_rule.dst_combination)
+      end
+      
+      def finalize(trans_options)
+        @errors = []
+        
+        @transcription_tree = TranscriptionTreeNode.new(nil,nil)
+        
+        # Add WORD_BOUNDARY and WORD_BREAKER in the tree
+        @transcription_tree.add_subpath(WORD_BOUNDARY,  [""])
+        @transcription_tree.add_subpath(WORD_BREAKER,   [""])
+        
+        rule_groups.each{ |rgname, rg| 
+          rg.finalize(trans_options) 
+        }
+        
+        # Build the input charset
+        @in_charset = {}
+        rule_groups.each{ |rgname, rg| 
+          rg.in_charset.each{ |char, group|
+            group_for_char = @in_charset[char]
+            if group_for_char
+              mode.errors << "Group #{rgname} uses input character #{char} which is also used by group #{group_for_char.name}. Input charsets should not intersect between groups." 
+            else
+              @in_charset[char] = group
+            end
+          }
+        }
+        
+        # Build the transcription tree
+        rule_groups.each{ |rgname, rg|
+          rg.rules.each { |r|
+            r.sub_rules.each{ |sr|      
+              add_subrule(sr)
+            }
+          }
+        }        
+      end
+      
+      def apply(l, out_charset)
+        ret = ""
+        current_group     = nil
+        accumulated_word  = ""
+        
+        out_space_str     = " "
+        out_space_str     = @out_space.map{ |token| out_charset[token].str }.join("") if @out_space
+        
+        l.split("").each{ |c|
+          case c
+          when " ", "\t" 
+            ret += transcribe_word(accumulated_word, out_charset)
+            ret += out_space_str
+            
+            accumulated_word = ""
+          when "\r", "\n"
+            ret += transcribe_word(accumulated_word, out_charset)
+            ret += c
+            
+            accumulated_word = ""
+          else
+            c_group = @in_charset[c]
+            if c_group == current_group
+              accumulated_word += c
+            else
+              ret += transcribe_word(accumulated_word, out_charset)
+              current_group    = c_group
+              accumulated_word = c
+            end
+          end            
+        }
+        # Just in case
+        ret += transcribe_word(accumulated_word, out_charset)
+        ret
+      end
+      
+      def transcribe_word(word, out_charset)
+        res = []
+        word = WORD_BOUNDARY + word + WORD_BOUNDARY
+        while word.length != 0
+          r, len = @transcription_tree.transcribe(word)       
+          word = word[len..-1]
+          res += r
+        end
+        ret = ""
+        res.each{ |token|
+          case token 
+          when ""
+          when UNKNOWN_CHAR_OUTPUT
+            ret += UNKNOWN_CHAR_OUTPUT
+          else
+            ret += out_charset[token].str
+          end        
+        }
+        ret
+      end
+      
+    end
+  end
+end

data/lib/api/transcription_tree_node.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+#
+# Glǽmscribe (also written Glaemscribe) is a software dedicated to
+# the transcription of texts between writing systems, and more 
+# specifically dedicated to the transcription of J.R.R. Tolkien's 
+# invented languages to some of his devised writing systems.
+# 
+# Copyright (C) 2015 Benjamin Babut (Talagan).
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# any later version.
+# 
+# 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.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Glaemscribe
+  module API
+    class TranscriptionTreeNode
+      attr_accessor :character, :siblings, :replacement
+  
+      def initialize(character, replacement)
+        @character    = character
+        @replacement  = replacement
+        @siblings     = {}
+      end
+  
+      def _p
+        puts "Node has #{@siblings.keys.count} siblings."
+        @siblings.each{ |k,v|
+          puts "#{k}, effective: #{v.effective?}"
+        }
+      end
+    
+      def _pchain(chain)
+        "[" + chain.map{|node| node.character||"ROOT"}.join(", ") + "]"
+      end
+  
+      def effective?
+        !@replacement.nil?
+      end
+  
+      def add_subpath(source, rep)
+        return if source.nil? || source.empty?
+        cc = source[0..0]
+      
+        sibling       = @siblings[cc]
+        sibling       = TranscriptionTreeNode.new(cc, nil) if !sibling
+        @siblings[cc] = sibling
+    
+        if source.length == 1 
+          # Sibling is effective
+          sibling.replacement = rep
+        else
+          sibling.add_subpath(source[1..-1], rep)
+        end
+      end
+  
+      def transcribe(string, chain=[])
+ 
+        chain << self
+ 
+        if !string.empty?
+          cc = string[0..0]
+          sibling = @siblings[cc]
+      
+          if sibling    
+            return sibling.transcribe(string[1..-1], chain)
+          end # Else we are at the end
+        end # Else we are at the end
+      
+        # puts "End of chain: #{chain.count}, #{_pchain(chain)}"
+      
+        # We are at the end of the chain
+        while chain.count > 1
+          last_node = chain.pop
+          return last_node.replacement, chain.count if last_node.effective?
+        end
+      
+        # Only the root node is in the chain, we could not find anything; return the "unknown char"
+        return [UNKNOWN_CHAR_OUTPUT], 1    
+      end
+    end
+  end
+end

data/lib/glaemscribe.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+#
+# Glǽmscribe (also written Glaemscribe) is a software dedicated to
+# the transcription of texts between writing systems, and more 
+# specifically dedicated to the transcription of J.R.R. Tolkien's 
+# invented languages to some of his devised writing systems.
+# 
+# Copyright (C) 2015 Benjamin Babut (Talagan).
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# any later version.
+# 
+# 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.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# Following tools are in the standard lib
+require "shellwords"
+require "unicode_utils/downcase"
+require "FileUtils" if !defined? FileUtils
+
+module Glaemscribe
+  module API
+    API_PATH = File.dirname(__FILE__)
+    
+    require API_PATH + "/api/debug.rb"
+    require API_PATH + "/api/constants.rb"
+    
+    require API_PATH + "/api/fragment.rb"
+    require API_PATH + "/api/sheaf_chain_iterator.rb"
+    require API_PATH + "/api/sheaf_chain.rb"
+    require API_PATH + "/api/sheaf.rb"
+  
+    require API_PATH + "/api/rule.rb"
+    require API_PATH + "/api/sub_rule.rb"
+    require API_PATH + "/api/rule_group.rb"
+    
+    require API_PATH + "/api/eval.rb"
+    require API_PATH + "/api/if_tree.rb"
+    
+    require API_PATH + "/api/transcription_tree_node.rb"  
+    
+    require API_PATH + "/api/transcription_pre_post_processor.rb"
+    require API_PATH + "/api/transcription_processor.rb"
+    
+    require API_PATH + "/api/charset.rb"
+    require API_PATH + "/api/mode.rb"
+    require API_PATH + "/api/option.rb"
+    
+    require API_PATH + "/api/resource_manager.rb"
+    require API_PATH + "/api/glaeml.rb"
+    require API_PATH + "/api/mode_parser.rb"
+    require API_PATH + "/api/charset_parser.rb"
+    
+    require API_PATH + "/api/pre_processor/elvish_numbers.rb"
+    require API_PATH + "/api/pre_processor/downcase.rb"
+    require API_PATH + "/api/pre_processor/substitute.rb"
+    require API_PATH + "/api/pre_processor/rxsubstitute.rb"
+    require API_PATH + "/api/pre_processor/up_down_tehta_split.rb"
+    require API_PATH + "/api/post_processor/reverse.rb"
+    
+  end
+end