glaemscribe 1.2.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,49 +39,62 @@ 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? }     
+            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 != '' }
+            vc.triggers    += inner_triggers
+
             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/mode.rb

@@ -22,6 +22,23 @@
 
 module Glaemscribe
   module API
+    
+    class ModeDebugContext
+      attr_accessor :preprocessor_output, 
+        :processor_pathes, 
+        :processor_output, 
+        :postprocessor_output,
+        :tts_output
+        
+      def initialize
+        @preprocessor_output  = ""
+        @processor_pathes     = []
+        @processor_output     = []
+        @postprocessor_output = ""
+        @tts_output = ""
+      end
+    end
+    
     class Mode
       
       attr_accessor :errors
@@ -46,8 +63,6 @@ module Glaemscribe
       
       attr_reader   :latest_option_values
          
-      
-         
       def initialize(name)
         @name               = name
         @errors             = []
@@ -141,13 +156,14 @@ module Glaemscribe
         @raw_mode = loaded_raw_mode.deep_clone
       end
       
-      def strict_transcribe(content, charset = nil)
+      def strict_transcribe(content, charset, debug_context)
         charset = default_charset if !charset
         return false, "*** No charset usable for transcription. Failed!" if !charset
   
         if has_tts
           begin
             content = TTS.ipa(content, @current_tts_voice, (raw_mode != nil) )['ipa']
+            debug_context.tts_output += content
           rescue StandardError => e
             return false, "TTS pre-transcription failed : #{e}."
           end
@@ -160,9 +176,16 @@ module Glaemscribe
             l[-1] = "" 
             restore_lf = true
           end
+          
           l = @pre_processor.apply(l)
-          l = @processor.apply(l)
+          debug_context.preprocessor_output += l + "\n"
+ 
+          l = @processor.apply(l, debug_context)
+          debug_context.processor_output += l
+
           l = @post_processor.apply(l, charset)
+          debug_context.postprocessor_output += l + "\n"
+
           l += "\n" if restore_lf
           l
         }.join
@@ -170,32 +193,34 @@ module Glaemscribe
       end
       
       def transcribe(content, charset = nil)
+        debug_context = ModeDebugContext.new
         if raw_mode
           chunks = content.split(/({{.*?}})/m)
           ret = ''
           res = true
           chunks.each{ |c|
             if c =~ /{{(.*?)}}/m
-              succ, r = raw_mode.strict_transcribe($1,charset)
+              succ, r = raw_mode.strict_transcribe($1, charset, debug_context)
       
               if !succ
-                return false, r # Propagate error
+                return false, r, debug_context # Propagate error
               end
       
               ret += r
             else
-              succ, r = strict_transcribe(c,charset)
+              succ, r = strict_transcribe(c,charset,debug_context)
 
               if !succ
-                return false, r # Propagate error 
+                return false, r, debug_context # Propagate error 
               end
       
               ret += r
             end
           }
-          return res,ret
+          return res, ret, debug_context
         else
-          strict_transcribe(content,charset)
+          succ, r = strict_transcribe(content, charset, debug_context)
+          return succ, r, debug_context
         end
       end
       

data/lib/api/mode_parser.rb

@@ -83,7 +83,11 @@ module Glaemscribe
         doc.root_node.gpath("preprocessor.if").each{ |e| validate_presence_of_args(e,  1) }    
         doc.root_node.gpath("preprocessor.elsif").each{ |e| validate_presence_of_args(e,  1) }    
         doc.root_node.gpath("postprocessor.if").each{ |e| validate_presence_of_args(e,  1) }    
-        doc.root_node.gpath("postprocessor.elsif").each{ |e| validate_presence_of_args(e,  1) }    
+        doc.root_node.gpath("postprocessor.elsif").each{ |e| validate_presence_of_args(e,  1) }  
+        
+        doc.root_node.children.each { |c|
+          @mode.errors << Glaeml::Error.new(c.line, "'if' conditions are not allowed in that scope.") if c.name == 'if'
+        }  
       end
       
       def create_if_cond_for_if_term(line, if_term, cond)      
@@ -245,7 +249,7 @@ module Glaemscribe
           if !operator_class
             @mode.errors << Glaeml::Error.new(element.line,"Operator #{operator_name} is unknown.")
           else            
-            term.operators << operator_class.new(element.clone)
+            term.operators << operator_class.new(@mode, element.clone)
           end  
         }  
 
@@ -391,22 +395,27 @@ module Glaemscribe
           }
           traverse_if_tree(processor_context, text_procedure, element_procedure )
         }
-                                                              
-        
+
         espeak_option = @mode.options['espeak_voice']
         if espeak_option
           # Singleton lazy load the TTS engine
           # If the mode relies on espeak
-          TTS::load_engine
           @mode.has_tts = true
           
-          # Check if all voices are supported
-          espeak_option.values.keys.each { |vname|
-            voice = TTS::option_name_to_voice(vname)
-            if !(TTS::voice_list.include? voice)
-              @mode.errors << Glaeml::Error.new(espeak_option.line, "Option has unhandled voice #{voice}.")   
-            end
-          }
+          begin
+            TTS::load_engine
+            
+            # Check if all voices are supported
+            espeak_option.values.keys.each { |vname|
+              voice = TTS::option_name_to_voice(vname)
+              if !(TTS::voice_list.include? voice)
+                @mode.errors << Glaeml::Error.new(espeak_option.line, "Option has unhandled voice #{voice}.")   
+              end
+            }
+          rescue
+            @mode.errors << Glaeml::Error.new(espeak_option.line, "Failed to load TTS engine.")  
+          end
+
         end
         
         @mode.finalize(mode_options) if !@mode.errors.any?