glaemscribe 1.3.0 → 1.3.1

data/lib/api/charset.rb

@@ -1,22 +1,22 @@
 # 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 
+# 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/>.
 
@@ -24,53 +24,94 @@ module Glaemscribe
   module API
     class Charset
       attr_reader   :name
-      
+
       attr_accessor :errors
       attr_reader   :chars
       attr_reader   :virtual_chars
-            
+      attr_reader   :swaps
+
+      class Swap
+        attr_accessor :line
+        attr_accessor :trigger
+        attr_accessor :targets
+
+        def initialize(trigger, target_list)
+          @trigger = trigger
+          @targets = {}
+
+          @target_list = target_list
+        end
+
+        def finalize(charset)
+          @lookup_table = {}
+
+          trig = charset.n2c(@trigger)
+
+          if !trig
+            charset.errors << Glaeml::Error.new(@line, "Swap operator triggers #{@trigger} which does not exist in charset.")
+          end
+
+          @target_list.each{ |target_id|
+            c = charset.n2c(target_id)
+            if !c
+               charset.errors << Glaeml::Error.new(@line, "Swap operator targets #{target_id} which does not exist in charset.")
+            else
+              c.names.each{ |n|
+                @targets[n]  = c
+              }
+            end
+          }
+
+          trig
+        end
+
+        def has_target?(tname)
+          (@targets[tname] != nil)
+        end
+      end
+
       class Char
         attr_accessor :line     # Line num in the sourcecode
         attr_accessor :code     # Position in unicode
         attr_accessor :names    # Names
         attr_accessor :str      # How does this char resolve as a string
         attr_accessor :charset  # Pointer to parent charset
-        
+
         def initialize
           @names = {}
         end
-        
+
         def virtual?
           false
         end
-        
+
         def sequence?
           false
         end
       end
-      
-      class VirtualChar # Could have had inheritance here ... 
+
+      class VirtualChar # Could have had inheritance here ...
         attr_accessor :line
         attr_accessor :names
         attr_accessor :classes
         attr_accessor :charset
         attr_accessor :reversed
         attr_accessor :default
-        
+
         class VirtualClass
           attr_accessor :target
           attr_accessor :triggers
         end
-        
+
         def initialize
           @classes      = {} # result_char_1 => [trigger_char_1, trigger_char_2 ...] , result_char_1 => ...
           @lookup_table = {}
           @reversed     = false
           @default      = nil
         end
-        
+
         def str
-          
+
           # Will be called if the virtual char could not be replaced and still exists at the end of the transcription chain
           if @default
             @charset[@default].str
@@ -78,14 +119,14 @@ module Glaemscribe
             VIRTUAL_CHAR_OUTPUT
           end
         end
-        
+
         def finalize
           @lookup_table = {}
           @classes.each{ |vc|
-            
+
             result_char   = vc.target
             trigger_chars = vc.triggers
-            
+
             trigger_chars.each{ |trigger_char|
               found = @lookup_table[trigger_char]
               if found
@@ -93,90 +134,91 @@ module Glaemscribe
               else
                 rc = @charset[result_char]
                 tc = @charset[trigger_char]
-        
+
                 if rc.nil?
                   @charset.errors << Glaeml::Error.new(@line, "Trigger char #{trigger_char} points to unknown result char #{result_char}.")
                 elsif tc.nil?
-                  @charset.errors << Glaeml::Error.new(@line, "Unknown trigger char #{trigger_char}.")  
+                  @charset.errors << Glaeml::Error.new(@line, "Unknown trigger char #{trigger_char}.")
                 elsif rc.class == VirtualChar
                   @charset.errors << Glaeml::Error.new(@line, "Trigger char #{trigger_char} points to another virtual char #{result_char}. This is not supported!")
                 else
                   tc.names.each{|trigger_char_name| # Don't forget to match all name variants for that trigger char!
                     @lookup_table[trigger_char_name] = rc
-                  }              
-                end  
-              end              
+                  }
+                end
+              end
             }
           }
           if @default
             c = @charset[@default]
             if !c
-              @charset.errors << Glaeml::Error.new(@line, "Default char #{@default} does not match any real character in the charset.")             
+              @charset.errors << Glaeml::Error.new(@line, "Default char #{@default} does not match any real character in the charset.")
             elsif c.virtual?
               @charset.errors << Glaeml::Error.new(@line, "Default char #{@default} is virtual, it should be real only.")
             end
           end
         end
-        
+
         def [](trigger_char_name)
           @lookup_table[trigger_char_name]
         end
-        
+
         def virtual?
           true
         end
-        
+
         def sequence?
           false
         end
       end
-      
+
       class SequenceChar
         attr_accessor :line     # Line of code
         attr_accessor :names    # Names
         attr_accessor :sequence # The sequence of chars
         attr_accessor :charset  # Pointer to parent charset
-        
+
         def virtual?
           false
         end
-        
+
         def sequence?
           true
-        end   
-        
+        end
+
         def str
           # A sequence char should never arrive unreplaced
           VIRTUAL_CHAR_OUTPUT
         end
-        
-        def finalize          
+
+        def finalize
           if @sequence.count == 0
-            @charset.errors << Glaeml::Error.new(@line, "Sequence for sequence char is empty.")    
+            @charset.errors << Glaeml::Error.new(@line, "Sequence for sequence char is empty.")
           end
-          
+
           @sequence.each{ |symbol|
             # Check that the sequence is correct
             found = @charset[symbol]
             if !found
               @charset.errors << Glaeml::Error.new(@line, "Sequence char #{symbol} cannot be found in the charset.")
             end
-          }    
+          }
         end
-        
+
       end
-      
+
       def initialize(name)
         @name           = name
         @chars          = []
         @errors         = []
         @virtual_chars  = []
+        @swaps          = []
       end
-      
+
       # Pass integer (utf8 num) and array (of strings)
       def add_char(line, code, names)
         return if names.empty? || names.include?("?") # Ignore characters with '?'
-        
+
         c         = Char.new
         c.line    = line
         c.code    = code
@@ -185,10 +227,10 @@ module Glaemscribe
         c.charset = self
         @chars << c
       end
-      
+
       def add_virtual_char(line, classes, names, reversed = false, default = nil)
         return if names.empty? || names.include?("?") # Ignore characters with '?'
-        
+
         c           = VirtualChar.new
         c.line      = line
         c.names     = names
@@ -196,25 +238,34 @@ module Glaemscribe
         c.charset   = self
         c.reversed  = reversed
         c.default   = default
-        @chars << c   
+        @chars << c
       end
-      
+
       def add_sequence_char(line, names, seq)
         return if names.empty? || names.include?("?") # Ignore characters with '?'
-        
+
         c             = SequenceChar.new
         c.line        = line
         c.names       = names
-        c.sequence    = seq.split.reject{|token| token.empty? }    
+        c.sequence    = seq.split.reject{|token| token.empty? }
         c.charset     = self
         @chars << c
       end
-      
+
+      def add_swap(line, target, triggers)
+        return if target.empty? || triggers.empty?
+
+        s             = Swap.new(target, triggers)
+        s.line        = line
+        @swaps << s
+      end
+
       def finalize
         @errors         = []
         @lookup_table   = {}
         @virtual_chars  = [] # A convenient filtered array
-        
+        @swap_lookup    = {}
+
         @chars.each { |c|
           c.names.each { |cname|
             found = @lookup_table[cname]
@@ -225,27 +276,43 @@ module Glaemscribe
             end
           }
         }
-        
+
         @chars.each{ |c|
           if c.class == VirtualChar
             c.finalize
             @virtual_chars << c
           end
         }
-        
+
         @chars.each{|c|
           if c.class == SequenceChar
             c.finalize
           end
         }
-        
+
+        @swaps.each{ |s|
+          trig = s.finalize(self)
+          if trig
+            trig.names.each{ |n|
+              @swap_lookup[n] = s
+            }
+          end
+        }
         API::Debug::log("Finalized charset '#{@name}', #{@lookup_table.count} symbols loaded.")
       end
-      
+
       def [](symbol)
         @lookup_table[symbol]
       end
-      
+
+      def n2c(symbol)
+        self[symbol]
+      end
+
+      def swap_for_trigger(trigger_name)
+        @swap_lookup[trigger_name]
+      end
+
     end
   end
-end
+end

data/lib/api/charset_parser.rb

@@ -1,37 +1,37 @@
 # 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 
+# 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 CharsetParser
-      
+
       def initialize()
         @charset = nil
       end
-      
+
       def parse(file_path)
-        @charset = Charset.new(ResourceManager::charset_name_from_file_path(file_path))  
-        
+        @charset = Charset.new(ResourceManager::charset_name_from_file_path(file_path))
+
         raw = File.open(file_path,"rb:utf-8").read
         doc = Glaeml::Parser.new.parse(raw)
 
@@ -39,33 +39,40 @@ module Glaemscribe
           @charset.errors = doc.errors
           return @charset
         end
-        
+
         # TODO : verify charset glaeml like we do with modes
-        
+
         doc.root_node.gpath("char").each { |char_element|
           code   = char_element.args[0].hex
           names  = char_element.args[1..-1].map{|cname| cname.strip }.reject{ |cname| cname.empty? }
           @charset.add_char(char_element.line,code,names)
         }
-               
-        doc.root_node.gpath("seq").each{ |seq_elemnt| 
+
+        doc.root_node.gpath("seq").each{ |seq_elemnt|
           names       = seq_elemnt.args
           child_node  = seq_elemnt.children.first
           seq         = (child_node && child_node.text?)?(child_node.args.first):("")
           @charset.add_sequence_char(seq_elemnt.line,names,seq)
         }
-        
+
+        doc.root_node.gpath("swap").each{ |element|
+          trigger_one      = element.args.first
+          text_lines       = element.children.select{ |c| c.text? }.map{ |c| c.args.first }
+          second_triggers  = text_lines.join(" ").split(/\s/).select{ |e| e != '' }
+          @charset.add_swap(element.line, trigger_one, second_triggers)
+        }
+
         doc.root_node.gpath("virtual").each { |virtual_element|
           names     = virtual_element.args
-          reversed  = false        
+          reversed  = false
           default   = nil
           classes   = []
-          
+
           virtual_element.gpath("class").each { |class_element|
             vc =  Charset::VirtualChar::VirtualClass.new
             vc.target    = class_element.args[0]
             vc.triggers  = class_element.args[1..-1].map{|cname| cname.strip }.reject{ |cname| cname.empty? }
-            
+
             # Allow triggers to be defined inside the body of the class element
             text_lines      = class_element.children.select { |c| c.text? }.map{ |c| c.args.first}
             inner_triggers  = text_lines.join(" ").split(/\s/).select{ |e| e != '' }
@@ -73,21 +80,21 @@ module Glaemscribe
 
             classes << vc
           }
-          virtual_element.gpath("reversed").each { |reversed_element| 
+          virtual_element.gpath("reversed").each { |reversed_element|
             reversed = true
           }
-          virtual_element.gpath("default").each { |default_element| 
+          virtual_element.gpath("default").each { |default_element|
             default  = default_element.args[0]
           }
-          
+
           @charset.add_virtual_char(virtual_element.line,classes,names,reversed,default)
         }
-        
+
         @charset.finalize
-             
-        @charset 
+
+        @charset
       end
-      
+
     end
   end
 end

data/lib/api/post_processor/resolve_virtuals.rb

@@ -1,22 +1,22 @@
 # 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 
+# 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/>.
 
@@ -24,25 +24,25 @@ module Glaemscribe
   module API
 
     class ResolveVirtualsPostProcessorOperator < PostProcessorOperator
-      
+
       def finalize(trans_options)
         super(trans_options)
         @last_triggers = {} # Allocate the lookup here to optimize
       end
-      
+
       def reset_trigger_states(charset)
         # For each virtual char in charset, maintain a state.
         charset.virtual_chars.each{ |vc|
           @last_triggers[vc] = nil # Clear the state
         }
       end
-      
+
       def apply_loop(charset, tokens, new_tokens, reversed, token, idx)
         if token == '*SPACE' || token =='*LF'
           reset_trigger_states(charset)
           return
         end
-        
+
         # Check if token is a virtual char
         c = charset[token]
         return if c.nil? # May happen for empty tokens
@@ -54,14 +54,14 @@ module Glaemscribe
             token           = new_tokens[idx]           # Consider the token replaced, being itself a potential trigger for further virtuals (cascading virtuals)
           end
         end
-        
+
         # Update states of virtual classes
         charset.virtual_chars.each{|vc|
           rc                  = vc[token]
-          @last_triggers[vc]  = rc if rc != nil 
+          @last_triggers[vc]  = rc if rc != nil
         }
       end
-      
+
       def apply_sequences(charset,tokens)
         ret = []
         tokens.each { |token|
@@ -74,21 +74,43 @@ module Glaemscribe
         }
         ret
       end
-      
+
+      def apply_swaps(charset, tokens)
+
+        idx = 0
+        while idx < tokens.length - 1
+          tok = tokens[idx]
+          tgt = tokens[idx+1]
+
+          trig = charset.swap_for_trigger(tok)
+
+          if trig && trig.has_target?(tgt)
+            tokens[idx+1] = tok
+            tokens[idx]   = tgt
+          end
+
+          idx += 1
+        end
+
+        tokens
+      end
+
       def apply(tokens,charset)
         # Apply sequence chars
         tokens = apply_sequences(charset,tokens)
-      
+
+        tokens = apply_swaps(charset, tokens)
+
         # Clone the tokens so that we can perform ligatures AND diacritics without interferences
         new_tokens = tokens.clone
-        
+
         # Handle l to r virtuals (diacritics ?)
-        reset_trigger_states(charset)       
+        reset_trigger_states(charset)
         tokens.each_with_index{ |token,idx|
           apply_loop(charset,tokens,new_tokens,false,token,idx)
         }
         # Handle r to l virtuals (ligatures ?)
-        reset_trigger_states(charset)       
+        reset_trigger_states(charset)
         tokens.reverse_each.with_index{ |token,idx|
           apply_loop(charset,tokens,new_tokens,true,token,tokens.count - 1 - idx)
         }
@@ -96,7 +118,7 @@ module Glaemscribe
       end
     end
 
-    ResourceManager::register_post_processor_class("resolve_virtuals", ResolveVirtualsPostProcessorOperator)    
+    ResourceManager::register_post_processor_class("resolve_virtuals", ResolveVirtualsPostProcessorOperator)
 
   end
 end