glaemscribe 1.0.0

data/lib/api/rule.rb

@@ -0,0 +1,99 @@
+# 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 Rule
+      
+      attr_accessor :line
+      attr_accessor :src_sheaf_chain, :dst_sheaf_chain
+      attr_reader   :sub_rules
+      attr_reader   :mode
+      attr_reader   :errors
+      
+      def initialize(line, rule_group)
+        @line       = line
+        @rule_group = rule_group
+        @mode       = @rule_group.mode
+        @sub_rules  = []
+        @errors     = []
+      end
+
+      def finalize(cross_schema)
+        
+        if(@errors.any?)
+          @errors.each { |e|
+            @mode.errors << Glaeml::Error.new(@line, e)
+          }
+          return         
+        end
+        
+        srccounter  = SheafChainIterator.new(@src_sheaf_chain)
+        dstcounter  = SheafChainIterator.new(@dst_sheaf_chain, cross_schema)
+        
+        if(srccounter.errors.any?)
+          srccounter.errors.each{ |e| @mode.errors << Glaeml::Error.new(@line, e) }
+          return
+        end
+        
+        if(dstcounter.errors.any?)
+          dstcounter.errors.each{ |e| @mode.errors << Glaeml::Error.new(@line, e) }
+          return
+        end     
+      
+        srcp = srccounter.prototype
+        dstp = dstcounter.prototype
+            
+        if srcp != dstp
+          @mode.errors << Glaeml::Error.new(@line, "Source and destination are not compatible (#{srcp} vs #{dstp})")
+          return
+        end
+        
+        begin 
+   
+          # All equivalent combinations ...
+          src_combinations  = srccounter.combinations 
+   
+          # ... should be sent to one destination
+          dst_combination   = dstcounter.combinations.first
+       
+          src_combinations.each{ |src_combination|
+            @sub_rules << SubRule.new(self, src_combination, dst_combination)
+          }
+      
+          dstcounter.iterate()
+        end while srccounter.iterate()
+        
+      end
+      
+      def p
+        ret = ("=" * 30) + "\n"
+        @sub_rules.each{ |sr|
+          ret += sr.p
+        }
+        ret
+      end
+      
+    end
+  end
+end
+

data/lib/api/rule_group.rb

@@ -0,0 +1,159 @@
+# 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 RuleGroup
+  
+      VAR_NAME_REGEXP     = /{([0-9A-Z_]+)}/
+      VAR_DECL_REGEXP     = /^\s*{([0-9A-Z_]+)}\s+===\s+(.+?)\s*$/
+      RULE_REGEXP         = /^\s*(.*?)\s+-->\s+(.+?)\s*$/
+      CROSS_RULE_REGEXP   = /^\s*(.*?)\s+-->\s+([\s0-9,]+)\s+-->\s+(.+?)\s*$/
+  
+      attr_reader :root_code_block, :name, :mode, :in_charset, :rules
+  
+      def initialize(mode,name)
+        @name             = name
+        @mode             = mode
+        @root_code_block  = IfTree::CodeBlock.new       
+      end
+  
+      def add_var(var_name, value)
+        @vars[var_name] = value
+      end
+  
+      # Replace all vars in expression
+      def apply_vars(line, string)
+        ret = string.gsub(VAR_NAME_REGEXP) { |cap_var|
+          rep = @vars[$1]
+          if !rep
+            @mode.errors << Glaeml::Error.new(line, "In expression: #{string}: failed to evaluate variable: #{cap_var}.") 
+            return nil
+          end
+          rep
+        }
+        ret
+      end
+      
+      def descend_if_tree(code_block, trans_options)
+        code_block.terms.each{ |term|         
+          if(term.is_code_lines?)
+            term.code_lines.each{ |cl|
+              finalize_code_line(cl) 
+            } 
+          else
+            term.if_conds.each{ |if_cond|
+              
+              if_eval = Eval::Parser.new()
+              
+              begin
+                if(if_eval.parse(if_cond.expression,trans_options) == true)
+                  descend_if_tree(if_cond.child_code_block, trans_options)
+                  break
+                end
+              rescue IfEvalError => e
+                @mode.errors << Glaeml::Error.new(if_cond.line, "Failed to evaluate condition '#{if_cond.expression}' (#{e})")
+              end 
+                
+            }
+          end
+        }
+      end
+            
+      def finalize_rule(line, match_exp, replacement_exp, cross_schema = nil)
+        
+        match                 = apply_vars(line, match_exp)
+        replacement           = apply_vars(line, replacement_exp)
+        
+        return if !match || !replacement # Failed
+              
+        rule                  = Rule.new(line, self)                             
+        rule.src_sheaf_chain  = SheafChain.new(rule,match,true)
+        rule.dst_sheaf_chain  = SheafChain.new(rule,replacement,false)
+              
+        rule.finalize(cross_schema)
+      
+        self.rules << rule
+      end
+      
+      def finalize_code_line(code_line)
+        begin
+          
+          if code_line.expression =~ VAR_DECL_REGEXP
+
+            var_name      = $1
+            var_value_ex  = $2
+            var_value     = apply_vars(code_line.line, var_value_ex)
+        
+            if !var_value
+              @mode.errors << Glaeml::Error.new(code_line.line, "Thus, variable {#{var_name}} could not be declared.")
+              return
+            end
+        
+            add_var(var_name,var_value)
+ 
+          elsif code_line.expression =~ CROSS_RULE_REGEXP
+        
+            match         = $1
+            cross         = $2
+            replacement   = $3      
+      
+            finalize_rule(code_line.line, match, replacement, cross)
+      
+          elsif code_line.expression =~ RULE_REGEXP
+  
+            match         = $1
+            replacement   = $2
+
+            finalize_rule(code_line.line, match, replacement)
+         
+          elsif code_line.expression.empty?
+            # puts "Empty"
+          else
+            @mode.errors << Glaeml::Error.new(code_line.line,"Cannot understand: #{code_line.expression}")
+          end  
+        end
+      end 
+    
+      def finalize(trans_options)
+        @vars             = {}       
+        @in_charset       = {}
+        @rules            = []
+        
+        add_var("NULL","")
+        
+        descend_if_tree(@root_code_block, trans_options)
+                            
+        # Now that we have selected our rules, create the in_charset of the rule_group 
+        rules.each{ |r| 
+          r.sub_rules.each { |sr|
+            sr.src_combination.join("").split(//).each{ |inchar|
+              # Add the character to the map of input characters
+              # Ignore '_' (bounds of word) and '|' (word breaker)
+              @in_charset[inchar] = self if inchar != WORD_BREAKER && inchar != WORD_BOUNDARY
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/api/sheaf.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/>.
+#
+# A Sheaf is a bundle of Fragments. They are used to factorize the writing process of rules, and thus represent parallel rules.
+# For exemple [(a|ä),b,c] => [1,2,3] means that we send one sheaf to another, defining 4 rules:
+# a => 1
+# ä => 1
+# b => 2
+# c => 3
+
+module Glaemscribe
+  module API
+    class Sheaf
+      
+      attr_reader :fragments
+      attr_reader :sheaf_chain 
+      attr_reader :mode
+      attr_reader :rule
+       
+      SHEAF_SEPARATOR    = "*"
+      
+      def src?; @sheaf_chain.src?; end
+      def dst?; @sheaf_chain.dst?; end
+            
+      # Should pass a sheaf expression, e.g. : "h, s, t"
+      def initialize(sheaf_chain, expression)
+        
+        @sheaf_chain  = sheaf_chain
+        @mode         = sheaf_chain.mode
+        @rule         = sheaf_chain.rule
+        @expression   = expression
+        
+        # Split members using "*" separator, KEEP NULL MEMBERS (this is legal)
+        fragment_exps = expression.split(SHEAF_SEPARATOR,-1).map{|fragment_exp| fragment_exp.strip } 
+        fragment_exps = [""] if fragment_exps.empty? # For NULL
+                 
+        # Build the fragments inside
+        @fragments = fragment_exps.map{ |fragment_exp|  Fragment.new(self, fragment_exp) }
+      end
+      
+      def p
+        ret = "-- " + @expression + "\n"
+        @fragments.each{ |l|
+          ret += l.p
+        }
+        ret
+      end
+   
+    end
+  end
+end

data/lib/api/sheaf_chain.rb

@@ -0,0 +1,86 @@
+# 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/>.
+#
+# A sheaf chain is a sequence of sheaves. e.g. :
+#
+# With a global rule of : src => res
+# Where src = "[a,b,c][d,e,f]"
+# and   res = "[x,y,z][1,2,3]"
+#
+# The generated rules is a list of 9 parallel rules: 
+# ad => x1, ae => x2, af => res => x3
+# bd => y1, be => y2, etc...
+#
+# Or, more complicated: "[m,(b|p)](h|y)[a,e]"
+# Will generate the following equivalences:
+# mha = mya
+# mhe = mye
+# bha = pha = bya = pya
+# bhe = phe = bye = phe
+
+module Glaemscribe
+  module API
+    class SheafChain
+  
+      SHEAF_REGEXP_IN    = /\[(.*?)\]/
+      SHEAF_REGEXP_OUT    = /(\[.*?\])/
+  
+      attr_reader :is_src
+      attr_reader :sheaves
+      attr_reader :mode
+      attr_reader :rule
+      
+      def src? ; is_src ; end
+      def dst? ; !is_src ; end
+                 
+      # Pass in the whole member of a rule src => dst (src or dst)
+      def initialize(rule, expression, is_src)      
+        @rule       = rule
+        @mode       = rule.mode
+        @is_src     = is_src
+        @expression = expression
+                
+        # Split expression with '[...]' patterns. e.g. 'b[a*c*d]e' => [b, a*c*d, e]
+        sheaf_exps = expression.split(SHEAF_REGEXP_OUT).map{ |elt| elt.strip }.reject{ |elt| elt.empty? }
+        sheaf_exps = sheaf_exps.map { |sheaf_exp| 
+          sheaf_exp =~ SHEAF_REGEXP_IN
+          sheaf_exp = $1 if $1 # Take the interior of the brackets it was a [...] expression
+          sheaf_exp.strip
+        }
+            
+        @sheaves    = sheaf_exps.map{ |sheaf_exp| Sheaf.new(self,sheaf_exp) }
+        @sheaves    = [Sheaf.new(self,"")] if @sheaves.empty?         
+      end
+      
+      def p
+        ret = ("*" * 30) 
+        ret += "\n"
+        ret += @expression + "\n"
+        @sheaves.each{ |s|
+          ret += s.p
+        }
+        ret
+      end
+      
+    end
+  end
+end

data/lib/api/sheaf_chain_iterator.rb

@@ -0,0 +1,108 @@
+# 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 SheafChainIterator
+  
+      attr_accessor :sheaf_chain
+      attr_accessor :cross_map
+      attr_accessor :errors
+  
+      # If a cross schema is passed, the prototype of the chain will be permutated
+      def initialize(sheaf_chain, cross_schema = nil)
+        @sheaf_chain            = sheaf_chain
+        # Sizes contains the number of fragments/sheaf
+        @sizes                  = sheaf_chain.sheaves.map { |sheaf| sheaf.fragments.count }
+        # An array of counters, one for each sheaf, to increment on fragments
+        @iterators              = Array.new(@sizes.count,0)
+    
+        @errors                 = []
+    
+        # Construct the identity array
+        identity_cross_array    = []
+        sheaf_count             = sheaf_chain.sheaves.count
+        sheaf_count.times{|i| identity_cross_array << i+1}  
+
+        # Construct the cross array
+        if cross_schema
+          @cross_array          = cross_schema.split(",").map{ |i| i.to_i }
+          ca_count              = @cross_array.count
+          @errors << "#{sheaf_count} sheafs found in right predicate, but #{ca_count} elements in cross rule."  if ca_count != sheaf_count  
+          @errors << "Cross rule should contain each element of #{identity_cross_array} once and only once."    if identity_cross_array != @cross_array.sort
+        else
+          @cross_array = identity_cross_array
+        end    
+      end
+  
+      # Calculate the prototype of the chain
+      def prototype
+        res   = @sizes.clone
+        res2  = @sizes.clone 
+        
+        res.count.times{ |i| res2[i] = res[@cross_array[i]-1] }
+        res   = res2
+    
+        # Remove all sheaves of size 1 (which are constant)
+        res.delete(1)
+        
+        # Create a prototype string
+        res = res.join("x")
+        res = "1" if res.empty?
+        res
+      end
+  
+      def iterate
+        pos = 0
+        while pos < @sizes.count do
+          realpos = @cross_array[pos]-1
+          @iterators[realpos] += 1
+          if @iterators[realpos] >= @sizes[realpos]
+            @iterators[realpos] = 0
+            pos += 1
+          else
+            return true
+          end
+        end
+        # Wrapped!
+        return false
+      end
+  
+      # Calculate all cominations for the chain
+      def combinations
+        resolved = []
+        @iterators.each_with_index{ |counter, index|
+          sheaf     = sheaf_chain.sheaves[index]
+          fragment  = sheaf.fragments[counter]
+          
+          resolved << fragment.combinations
+        }
+        res = resolved[0]
+        (resolved.count-1).times { |i|
+          res = res.product(resolved[i+1]).map{|e1,e2| e1+e2} 
+        }
+        res
+      end
+  
+    end
+  end
+end