glaemscribe 1.1.14 → 1.2.0

data/lib/api/fragment.rb

@@ -41,7 +41,7 @@ module Glaemscribe
       EQUIVALENCE_RX_OUT    = /(\(.*?\))/
       EQUIVALENCE_RX_IN     = /\((.*?)\)/
     
-      # Should pass a fragment expression, e.g. : "h(a|ä)(i|ï)"
+      # Should pass a fragment expression, e.g. : "h(a,ä)(i,ï)"
       def initialize(sheaf, expression)
         @sheaf      = sheaf
         @mode       = sheaf.mode
@@ -49,16 +49,16 @@ module Glaemscribe
         @expression = expression
         
         # Split the fragment, turn it into an array of arrays, e.g. [[h],[a,ä],[i,ï]]
-        equivalences = expression.split(EQUIVALENCE_RX_OUT).map{ |eq| eq.strip }
+        equivalences = expression.split(EQUIVALENCE_RX_OUT).map{ |eq| eq.strip }.reject{ |eq| eq == '' }
         equivalences = equivalences.map{ |eq|           
           eq =~ EQUIVALENCE_RX_IN
           if $1
             eq = $1.split(EQUIVALENCE_SEPARATOR,-1).map{ |elt| 
               elt = elt.strip
-              elt.split(/\s/)
-            } 
+              elt.split(/\s/).map{ |leaf| finalize_fragment_leaf(leaf) }
+            }
           else
-            eq = [eq.split(/\s/)] # This equivalence has only one possibility
+            eq = [eq.split(/\s/).map{ |leaf| finalize_fragment_leaf(leaf) }] # This equivalence has only one possibility
           end
         }   
           
@@ -87,6 +87,7 @@ module Glaemscribe
         # Calculate all combinations for this fragment (productize the array of arrays)
         res = equivalences[0]
     
+        # ((eq0 x eq1) x eq2) x eq3 ) ... )))))
         (equivalences.length-1).times { |i|
           prod  = res.product(equivalences[i+1]).map{ |x,y| x+y}
           res   = prod
@@ -95,6 +96,26 @@ module Glaemscribe
         @combinations = res
       end   
       
+      def finalize_fragment_leaf(leaf)
+        if src?
+          
+          # Replace {UNI_XXXX} by its value to allow any unicode char to be found in the transcription tree
+          leaf = leaf.gsub(RuleGroup::UNICODE_VAR_NAME_REGEXP_OUT) { |cap_var|
+            unival = $1
+            new_char = [unival.hex].pack("U")
+            new_char = "\u0001" if new_char == '_'
+            new_char
+          }
+
+          # Replace '_' (word boundary) by '\u0000' to allow 
+          # the real underscore to be used in the transcription tree
+          # (Do it after replacing the uni_xxx vars because they have underscores inside)
+          leaf = leaf.gsub(WORD_BOUNDARY_LANG, WORD_BOUNDARY_TREE) 
+          leaf = leaf.gsub("\u0001","_")        
+        end
+
+        leaf
+      end
       
       def p
         ret = "---- " + @expression + "\n"

data/lib/api/if_tree.rb

@@ -24,14 +24,36 @@ module Glaemscribe
   module API
     module IfTree
       
+      # A branching if condition
       class IfCond
         attr_accessor :line, :expression, :parent_if_term, :child_code_block
         def initialize(line, parent_if_term, expression)
           @parent_if_term     = parent_if_term
           @expression         = expression
         end
+        def offset
+          parent_if_term.offset + " "
+        end
+        def prefix
+          offset + "|-"
+        end
+        def inspect
+          "#{prefix} IF #{expression}\n" + 
+          "#{child_code_block.inspect}"
+        end
+      end
+      
+      # A line of code
+      class CodeLine
+        attr_accessor :expression, :line
+        def initialize(expression, line)
+          @expression   = expression
+          @line         = line
+        end
       end
       
+      # A node (code lines / preprocessor operators / ... )
+      # A node may have children or not depending on their nature
       class Term
         attr_accessor :parent_code_block
         def initialize(parent_code_block)
@@ -43,24 +65,30 @@ module Glaemscribe
         def is_pre_post_processor_operators?
           false
         end
+        def is_macro_deploy?
+          false
+        end
+        def offset
+          parent_code_block.offset + " "
+        end
+        def prefix
+          offset + "|- "
+        end
       end
  
+      # A ifterm may have multiple ifconds (if,elsif,elsif,...,else)
       class IfTerm < Term
         attr_accessor :if_conds
         def initialize(parent_code_block)
           super(parent_code_block)  
           @if_conds = []
         end
-      end
-      
-      class CodeLine
-        attr_accessor :expression, :line
-        def initialize(expression, line)
-          @expression   = expression
-          @line         = line
+        def inspect
+          "#{prefix} CONDITIONAL BLOCK\n" +
+            @if_conds.map{ |c| c.inspect }.join("\n")          
         end
       end
-      
+         
       class PrePostProcessorOperatorsTerm < Term
         attr_accessor :operators
         def initialize(parent_code_block)
@@ -70,6 +98,9 @@ module Glaemscribe
         def is_pre_post_processor_operators?
           true
         end
+        def inspect
+          "#{prefix} OPERATORS (#{@operators.count})"
+        end
       end
       
       class CodeLinesTerm < Term
@@ -81,6 +112,25 @@ module Glaemscribe
         def is_code_lines?
           true
         end
+        def inspect
+          "#{prefix} CODE LINES (#{@code_lines.count})"
+        end
+      end
+      
+      class MacroDeployTerm < Term
+        attr_accessor :macro, :line, :arg_value_expressions
+        def initialize(macro, line, parent_code_block, arg_value_expressions)
+          super(parent_code_block)
+          @line                   = line
+          @macro                  = macro
+          @arg_value_expressions  = arg_value_expressions
+        end
+        def is_macro_deploy?
+          true
+        end
+        def inspect
+          "#{prefix} MACRO DEPLOY (#{macro.name})"
+        end
       end
       
       class CodeBlock
@@ -89,6 +139,18 @@ module Glaemscribe
           @parent_if_cond = parent_if_cond
           @terms          = []
         end
+        def offset
+          ((parent_if_cond)?(parent_if_cond.offset):("")) + " "
+        end
+        def prefix
+          offset + "|- "
+        end
+        def inspect
+          ret = ""
+          ret += "|-ROOT\n" if !parent_if_cond
+          ret += "#{prefix} Code block\n" +
+          @terms.map{|t| t.inspect}.join("\n")
+        end
       end
 
     end

data/lib/api/macro.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 Macro
+      attr_reader :name, :rule_group, :mode, :arg_names
+      
+      attr_reader :root_code_block
+      
+      def initialize(rule_group,name,arg_names)
+        @rule_group       = rule_group
+        @mode             = rule_group.mode
+        @name             = name
+        @arg_names        = arg_names
+        @root_code_block  = IfTree::CodeBlock.new       
+      end
+      
+    end
+  end
+end

data/lib/api/mode.rb

@@ -41,8 +41,13 @@ module Glaemscribe
       
       attr_accessor :world, :invention
       
+      attr_accessor :has_tts
+      attr_reader   :current_tts_voice
+      
       attr_reader   :latest_option_values
          
+      
+         
       def initialize(name)
         @name               = name
         @errors             = []
@@ -50,6 +55,8 @@ module Glaemscribe
         @supported_charsets = {}
         @options            = {}
         @last_raw_options   = nil
+        @has_tts            = false
+        @current_tts_voice  = nil
        
         @pre_processor    = TranscriptionPreProcessor.new(self)
         @processor        = TranscriptionProcessor.new(self)
@@ -95,7 +102,7 @@ module Glaemscribe
     
         trans_options_converted = {}
 
-        # Do a conversion to values space
+        # Do a conversion from names to values space
         trans_options.each{ |oname,valname| 
           trans_options_converted[oname] = @options[oname].value_for_value_name(valname)
         }
@@ -117,7 +124,13 @@ module Glaemscribe
         @processor.finalize(@latest_option_values)
     
         raw_mode.finalize options if raw_mode
-          
+        
+        # Update the current espeak voice
+        if @has_tts
+          espeak_option       = @options['espeak_voice'].value_name_for_value(@latest_option_values['espeak_voice'])
+          @current_tts_voice  = TTS.option_name_to_voice(espeak_option)
+        end
+        
         self
       end
       
@@ -128,16 +141,18 @@ module Glaemscribe
         @raw_mode = loaded_raw_mode.deep_clone
       end
       
-      def replace_specials(l)
-        l.
-          gsub("_",SPECIAL_CHAR_UNDERSCORE).
-          gsub("\u00a0",SPECIAL_CHAR_NBSP)
-      end
-      
       def strict_transcribe(content, charset = nil)
         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']
+          rescue StandardError => e
+            return false, "TTS pre-transcription failed : #{e}."
+          end
+        end
+  
         # Parser works line by line
         ret = content.lines.map{ |l| 
           restore_lf = false
@@ -146,7 +161,6 @@ module Glaemscribe
             restore_lf = true
           end
           l = @pre_processor.apply(l)
-          l = replace_specials(l)
           l = @processor.apply(l)
           l = @post_processor.apply(l, charset)
           l += "\n" if restore_lf
@@ -163,12 +177,20 @@ module Glaemscribe
           chunks.each{ |c|
             if c =~ /{{(.*?)}}/m
               succ, r = raw_mode.strict_transcribe($1,charset)
-              res = res && succ
-              ret += r if succ
+      
+              if !succ
+                return false, r # Propagate error
+              end
+      
+              ret += r
             else
               succ, r = strict_transcribe(c,charset)
-              res = res && succ
-              ret += r if succ
+
+              if !succ
+                return false, r # Propagate error 
+              end
+      
+              ret += r
             end
           }
           return res,ret

data/lib/api/mode_parser.rb

@@ -94,7 +94,13 @@ module Glaemscribe
         ifcond            
       end
       
-      def traverse_if_tree(root_code_block, root_element, text_procedure, element_procedure)
+      def traverse_if_tree(context, text_procedure, element_procedure)
+
+        owner         = context[:owner]           # The root object of the if tree
+        root_element  = context[:root_element]    # The glaeml root_element of that if tree
+        rule_group    = context[:rule_group]      # The rule group in which this traversal happens (may be null for pre/post processors)
+
+        root_code_block           = owner.root_code_block
         current_parent_code_block = root_code_block
         
         root_element.children.each{ |child|
@@ -145,7 +151,65 @@ module Glaemscribe
               end
               
               current_parent_code_block       = if_term.parent_code_block
+            when 'macro'
+        
+              # Macro definition, cannot be defined in conditional blocks
+              if current_parent_code_block.parent_if_cond || root_element.name != "rules"
+                @mode.errors << Glaeml::Error.new(child.line, "Macros can only defined in the 'rules' scope, not in a conditional block (because they are replaced and used at parsing time) or a macro block (local macros are not handled).")
+                return
+              end
+              
+              if !child.args || child.args.count == 0
+                @mode.errors << Glaeml::Error.new(child.line, "Macro misses a name.")
+                return   
+              end
+
+              macro_args = child.args.clone
+              macro_name = macro_args.shift
+              macro_args.each{ |arg|
+                if(!arg =~ /[0-9A-Z_]+/)
+                  @mode.errors << Glaeml::Error.new(child.line, "Macro argument name #{arg} has wrong format.")
+                  return
+                end
+              }
+              
+              if rule_group.macros[macro_name]
+                @mode.errors << Glaeml::Error.new(child.line, "Redefining macro #{macro_name}.")
+                return
+              end
               
+              macro = Macro.new(rule_group,macro_name,macro_args)
+              macro_context = {:owner => macro, :root_element => child, :rule_group => rule_group}
+              traverse_if_tree(macro_context, text_procedure, element_procedure)
+
+              rule_group.macros[macro_name] = macro
+
+            when 'deploy'
+
+              if !rule_group
+                @mode.errors << Glaeml::Error.new(child.line, "Macros can only be deployed in a rule group.")
+                return
+              end
+
+              macro_args = child.args.clone
+              macro_name = macro_args.shift
+              macro      = rule_group.macros[macro_name]
+
+              if !macro
+                @mode.errors << Glaeml::Error.new(child.line, "Macro '#{macro_name}' not found in rule group '#{rule_group.name}'.")
+                return
+              end
+
+              wanted_argcount = macro.arg_names.count
+              given_argcount  = macro_args.count
+              if wanted_argcount != given_argcount
+                @mode.errors << Glaeml::Error.new(child.line, "Macro '#{macro_name}' takes #{wanted_argcount} arguments, not #{given_argcount}.")
+                return
+              end
+
+              macro_node = IfTree::MacroDeployTerm.new(macro, child.line, current_parent_code_block, macro_args)
+              current_parent_code_block.terms << macro_node
+
             else
               # Do something with this child element
               element_procedure.call(current_parent_code_block, child)            
@@ -184,10 +248,13 @@ module Glaemscribe
             term.operators << operator_class.new(element.clone)
           end  
         }  
-        
-        root_code_block = ((pre_not_post)?(@mode.pre_processor.root_code_block):(@mode.post_processor.root_code_block))
-               
-        self.traverse_if_tree(root_code_block, processor_element, text_procedure, element_procedure )                       
+
+        processor_context = {
+            owner: ((pre_not_post)?(@mode.pre_processor):(@mode.post_processor)),
+            root_element: processor_element,
+            rule_group: nil
+        }
+        traverse_if_tree(processor_context, text_procedure, element_procedure )
       end
       
       def parse(file_path, mode_options = {})
@@ -219,6 +286,7 @@ module Glaemscribe
         doc.root_node.gpath("options.option").each{ |option_element|
           values      = {}
           visibility  = nil
+          is_radio    = false
   
           option_element.gpath("value").each{ |value_element|
             value_name                = value_element.args.first
@@ -227,6 +295,8 @@ module Glaemscribe
           option_element.gpath("visible_when").each{ |visible_element|
             visibility = visible_element.args.first
           }
+          
+          option_element.gpath('radio').each{|e| is_radio = true}
         
           option_name_at          = option_element.args[0]
           option_default_val_at   = option_element.args[1]
@@ -236,8 +306,9 @@ module Glaemscribe
             @mode.errors << Glaeml::Error.new(option_element.line, "Missing option default value.")
           end
             
-          option        = Option.new(@mode, option_name_at, option_default_val_at, values, visibility)
-          @mode.options[option.name] = option
+          option                      = Option.new(@mode, option_name_at, option_default_val_at, values, option_element.line, visibility)
+          option.is_radio             = is_radio
+          @mode.options[option.name]  = option
         }
         
         # Read the supported font list
@@ -301,6 +372,7 @@ module Glaemscribe
                                    
             lcount  = element.line
             element.args[0].lines.to_a.each{ |l| 
+              # Split into lines of code and count the lines
               l       = l.strip
               term.code_lines << IfTree::CodeLine.new(l, lcount)           
               lcount  += 1                         
@@ -310,13 +382,35 @@ module Glaemscribe
           element_procedure = Proc.new { |current_parent_code_block, element|
             # This is fatal.
             @mode.errors << Glaeml::Error.new(element.line, "Unknown directive #{element.name}.")      
-          }  
-          
-          self.traverse_if_tree( rule_group.root_code_block, rules_element, text_procedure, element_procedure )                 
+          }
+
+          processor_context = {
+              owner:           rule_group,
+              root_element:   rules_element,
+              rule_group:     rule_group
+          }
+          traverse_if_tree(processor_context, text_procedure, element_procedure )
         }
-                                                         
-        @mode.finalize(mode_options) if !@mode.errors.any?
+                                                              
+        
+        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
+          }
+        end
         
+        @mode.finalize(mode_options) if !@mode.errors.any?
+    
         @mode
       end
     end