interscript 2.4.5 → 3.0.0

data/lib/interscript/node/rule/sub.rb

@@ -5,23 +5,23 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
   attr_accessor :reverse_run
   attr_accessor :priority
 
-  def initialize (from, to,
-                  before: nil, not_before: nil,
-                  after: nil, not_after: nil,
-                  priority: nil, reverse_run: nil)
+  def initialize(from, to,
+    before: nil, not_before: nil,
+    after: nil, not_after: nil,
+    priority: nil, reverse_run: nil)
     self.from = Interscript::Node::Item.try_convert from
-    if to == :upcase
-      self.to = :upcase
+    self.to = if to == :upcase
+      :upcase
     elsif to == :downcase
-      self.to = :downcase
+      :downcase
     else
-      self.to = Interscript::Node::Item.try_convert to
+      Interscript::Node::Item.try_convert to
     end
 
     self.priority = priority
 
-    #raise TypeError, "Can't supply both before and not_before" if before && not_before
-    #raise TypeError, "Can't supply both after and not_after" if after && not_after
+    # raise TypeError, "Can't supply both before and not_before" if before && not_before
+    # raise TypeError, "Can't supply both after and not_after" if after && not_after
 
     self.reverse_run = reverse_run
 
@@ -32,34 +32,33 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
   end
 
   def max_length
-    len = self.from.max_length
-    len += self.before.max_length if self.before
-    len += self.after.max_length if self.after
-    len += self.not_before.max_length if self.not_before
-    len += self.not_after.max_length if self.not_after
-    len += self.priority if self.priority
+    len = from.max_length
+    len += before.max_length if before
+    len += after.max_length if after
+    len += not_before.max_length if not_before
+    len += not_after.max_length if not_after
+    len += priority if priority
     len
   end
 
   def to_hash
-    puts self.from.inspect if $DEBUG
+    puts from.inspect if $DEBUG
     puts params.inspect if $DEBUG
-    hash = { :class => self.class.to_s,
-      :from => self.from.to_hash,
-      :to => Symbol === self.to ? self.to : self.to.to_hash,
-      :reverse_run => self.reverse_run,
-      :before => self.before&.to_hash,
-      :not_before => self.not_before&.to_hash,
-      :after => self.after&.to_hash,
-      :not_after => self.not_after&.to_hash,
-      :priority => self.priority
-    }
-
-    hash[:before] = self.before&.to_hash if self.before
-    hash[:not_before] = self.not_before&.to_hash if self.not_before
-    hash[:after] = self.after&.to_hash if self.after
-    hash[:not_after] = self.not_after&.to_hash if self.not_after
-    hash[:priority] = self.priority if self.priority
+    hash = {class: self.class.to_s,
+            from: from.to_hash,
+            to: (Symbol === to) ? to : to.to_hash,
+            reverse_run: reverse_run,
+            before: before&.to_hash,
+            not_before: not_before&.to_hash,
+            after: after&.to_hash,
+            not_after: not_after&.to_hash,
+            priority: priority}
+
+    hash[:before] = before&.to_hash if before
+    hash[:not_before] = not_before&.to_hash if not_before
+    hash[:after] = after&.to_hash if after
+    hash[:not_after] = not_after&.to_hash if not_after
+    hash[:priority] = priority if priority
 
     hash
   end
@@ -76,12 +75,12 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     end
 
     # A special case: sub "a", "" shouldn't be present in a reverse map
-    rrun = self.reverse_run.nil? ? nil : !self.reverse_run
+    rrun = reverse_run.nil? ? nil : !reverse_run
     if rrun.nil? && !has_assertions? &&
-      (xfrom == "" ||
-        (Interscript::Node::Item::String === xfrom && xfrom.data == '') ||
-        (Interscript::Node::Item::Alias === xfrom && xfrom.name == :none)
-      )
+        (xfrom == "" ||
+          (Interscript::Node::Item::String === xfrom && xfrom.data == "") ||
+          (Interscript::Node::Item::Alias === xfrom && xfrom.name == :none)
+        )
 
       rrun = true
     end
@@ -92,10 +91,9 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
 
       reverse_run: rrun,
 
-      priority: priority ? -priority : nil
-    )
+      priority: priority ? -priority : nil)
   end
-  
+
   def has_assertions?
     !!(before || not_before || not_after || after)
   end
@@ -116,7 +114,7 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
         to = out.compact
 
         from = from.dup.tap do |i|
-          i.children = i.children[1..-1]
+          i.children = i.children[1..]
         end.compact
       end
 
@@ -140,10 +138,10 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     end
 
     # This part is about moving backreferences
-    state = {left:[], right:[]}
+    state = {left: [], right: []}
 
-    from  = reverse_transfer_visit(from, :from, state)
-    to    = reverse_transfer_visit(to,   :to,   state)
+    from = reverse_transfer_visit(from, :from, state)
+    to = reverse_transfer_visit(to, :to, state)
 
     [from, to]
   end
@@ -198,23 +196,23 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
 
   def ==(other)
     super &&
-    self.from == other.from &&
-    self.to == other.to &&
-    self.before == other.before &&
-    self.after == other.after &&
-    self.not_before == other.not_before &&
-    self.not_after == other.not_after &&
-    self.priority == other.priority
+      from == other.from &&
+      to == other.to &&
+      before == other.before &&
+      after == other.after &&
+      not_before == other.not_before &&
+      not_after == other.not_after &&
+      priority == other.priority
   end
 
   def inspect
     out = "sub "
     params = []
     params << @from.inspect
-    if Symbol === @to
-      params << @to.to_s
+    params << if Symbol === @to
+      @to.to_s
     else
-      params << @to.inspect
+      @to.inspect
     end
     params << "reverse_run: #{@reverse_run.inspect}" unless @reverse_run.nil?
 
@@ -226,4 +224,6 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     params << "priority: #{@priority.inspect}" if @priority
     out << params.join(", ")
   end
+  # standard:disable Layout/TrailingEmptyLines (deliberate)
 end
+# standard:enable Layout/TrailingEmptyLines

data/lib/interscript/node/rule.rb

@@ -1,9 +1,10 @@
 class Interscript::Node::Rule < Interscript::Node
+  # Autoload all rule types (OCP: new rule type = one autoload).
+  autoload :Sub, "interscript/node/rule/sub"
+  autoload :Run, "interscript/node/rule/run"
+  autoload :Funcall, "interscript/node/rule/funcall"
+
   def ==(other)
-    super && self.reverse_run == other.reverse_run
+    super && reverse_run == other.reverse_run
   end
 end
-
-require "interscript/node/rule/sub"
-require "interscript/node/rule/run"
-require "interscript/node/rule/funcall"

data/lib/interscript/node/stage.rb

@@ -9,34 +9,31 @@ class Interscript::Node::Stage < Interscript::Node::Group::Sequential
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :name => name,
-      :children => @children.map{|x| x.to_hash} }
+    {class: self.class.to_s,
+     name: name,
+     children: @children.map { |x| x.to_hash }}
   end
 
   def reverse
     return self if dont_reverse
 
-    @reverse ||= begin
-      self.class.new(name,
-        doc_name: Interscript::Node::Document.reverse_name(doc_name),
-        reverse_run: reverse_run.nil? ? nil : !reverse_run
-      ).tap do |r|
-        r.children = self.children.reverse.map(&:reverse)
-      end
+    @reverse ||= self.class.new(name,
+      doc_name: Interscript::Node::Document.reverse_name(doc_name),
+      reverse_run: reverse_run.nil? ? nil : !reverse_run).tap do |r|
+      r.children = children.reverse.map(&:reverse)
     end
   end
 
   def ==(other)
     super &&
-    self.name == other.name &&
-    self.reverse_run == other.reverse_run &&
-    self.dont_reverse == other.dont_reverse
+      name == other.name &&
+      reverse_run == other.reverse_run &&
+      dont_reverse == other.dont_reverse
   end
 
   def inspect
     args = []
-    args << "#{@name}" if @name != :main
+    args << @name.to_s if @name != :main
     args << "dont_reverse: true" if dont_reverse
     name = ""
     name = "(#{args.join(", ")})" unless args.empty?

data/lib/interscript/node/tests.rb

@@ -1,6 +1,6 @@
 class Interscript::Node::Tests < Interscript::Node
   attr_accessor :data
-  def initialize data=[]
+  def initialize data = []
     @data = data
   end
 
@@ -9,17 +9,17 @@ class Interscript::Node::Tests < Interscript::Node
   end
 
   def reverse
-    self.class.new(data.map do |from,to,reverse_run|
-      [to, from, reverse_run == nil ? nil : !reverse_run]
+    self.class.new(data.map do |from, to, reverse_run|
+      [to, from, reverse_run.nil? ? nil : !reverse_run]
     end)
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :data => @data }
+    {class: self.class.to_s,
+     data: @data}
   end
 end

data/lib/interscript/node.rb

@@ -1,5 +1,16 @@
-
 class Interscript::Node
+  # Autoload all node types. Adding a new node type = one autoload
+  # line here. No require_relative (OCP).
+  autoload :Group, "interscript/node/group"
+  autoload :Document, "interscript/node/document"
+  autoload :MetaData, "interscript/node/metadata"
+  autoload :AliasDef, "interscript/node/alias_def"
+  autoload :Dependency, "interscript/node/dependency"
+  autoload :Tests, "interscript/node/tests"
+  autoload :Stage, "interscript/node/stage"
+  autoload :Rule, "interscript/node/rule"
+  autoload :Item, "interscript/node/item"
+
   def initialize
     raise NotImplementedError, "You can't construct a Node directly"
   end
@@ -9,21 +20,7 @@ class Interscript::Node
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :question => "is something missing?"
-    }
+    {class: self.class.to_s,
+     question: "is something missing?"}
   end
 end
-
-
-require "interscript/node/group"
-require "interscript/node/document"
-
-require "interscript/node/metadata"
-require 'interscript/node/alias_def'
-require 'interscript/node/dependency'
-require 'interscript/node/tests'
-
-require "interscript/node/stage"
-require "interscript/node/rule"
-require "interscript/node/item"

data/lib/interscript/stdlib/functions/rababa_adapter.rb

@@ -0,0 +1,56 @@
+class Interscript::Stdlib
+  module Functions
+    class RababaAdapter
+      @rababa_diacritizers = {}
+      @mutex = Mutex.new
+
+      class << self
+        def call(output, config:)
+          diacritizer = diacritizer_for(config)
+          diacritizer.diacritize_text(output)
+        end
+
+        def reverse(output, config: nil)
+          # The legacy rababa reverse path strips harakat directly. It does
+          # not need the model loaded — keep it dependency-free so maps
+          # that only call `rababa_reverse` work without Rababa installed.
+          output.gsub(/[ًٌٍَُِّْ]/, "")
+        end
+
+        def reset_cache
+          @mutex.synchronize { @rababa_diacritizers.clear }
+        end
+
+        private
+
+        def diacritizer_for(config_key)
+          require_rababa!
+          @mutex.synchronize do
+            @rababa_diacritizers[config_key] ||= build_diacritizer(config_key)
+          end
+        end
+
+        def build_diacritizer(config_key)
+          config_value = Interscript.rababa_configs.fetch(config_key) do
+            raise Interscript::ExternalUtilError,
+              "No rababa config registered under '#{config_key}'"
+          end
+          model_uri = config_value["model"]
+          rababa_config = config_value["config"]
+          model_path = Interscript.rababa_provision(config_key, model_uri)
+          Rababa::Diacritizer.new(model_path, rababa_config)
+        end
+
+        def require_rababa!
+          return if defined?(Rababa)
+          begin
+            require "rababa"
+          rescue LoadError
+            raise Interscript::ExternalUtilError,
+              "Rababa is not loaded. Please read docs/Usage_with_Rababa.adoc"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interscript/stdlib/functions/secryst_adapter.rb

@@ -0,0 +1,37 @@
+class Interscript::Stdlib
+  module Functions
+    class SecrystAdapter
+      @translators = {}
+      @mutex = Mutex.new
+
+      class << self
+        def call(output, model:)
+          translator = translator_for(model)
+          output.split("\n").map(&:chomp).map { |line| translator.translate(line) }.join("\n")
+        end
+
+        def reset_cache
+          @mutex.synchronize { @translators.clear }
+        end
+
+        private
+
+        def translator_for(model_key)
+          require_secryst!
+          @mutex.synchronize do
+            @translators[model_key] ||= build_translator(model_key)
+          end
+        end
+
+        def build_translator(model_key)
+          Interscript.secryst_index_locations.each do |remote|
+            Interscript::ML::Provisioning.add_remote(remote)
+          end
+          Interscript::ML::Translator.new(model_file: model_key)
+        end
+
+
+      end
+    end
+  end
+end

data/lib/interscript/stdlib/functions.rb

@@ -0,0 +1,49 @@
+class Interscript::Stdlib
+  module Functions
+    autoload :RababaAdapter, "interscript/stdlib/functions/rababa_adapter"
+    autoload :SecrystAdapter, "interscript/stdlib/functions/secryst_adapter"
+
+    def self.title_case(output, word_separator: " ")
+      output = output.gsub(/^(.)/, &:upcase)
+      output = output.gsub(/#{word_separator}(.)/, &:upcase) unless word_separator == ""
+      output
+    end
+
+    def self.downcase(output, word_separator: nil)
+      if word_separator
+        output = output.gsub(/^(.)/, &:downcase)
+        output.gsub(/#{word_separator}(.)/, &:downcase) unless word_separator == ""
+      else
+        output.downcase
+      end
+    end
+
+    def self.compose(output, _: nil)
+      output.unicode_normalize(:nfc)
+    end
+
+    def self.decompose(output, _: nil)
+      output.unicode_normalize(:nfd)
+    end
+
+    def self.separate(output, separator: " ")
+      output.chars.join(separator)
+    end
+
+    def self.unseparate(output, separator: " ")
+      output.split(separator).join("")
+    end
+
+    def self.secryst(output, model:)
+      SecrystAdapter.call(output, model: model)
+    end
+
+    def self.rababa(output, config:)
+      RababaAdapter.call(output, config: config)
+    end
+
+    def self.rababa_reverse(output, config: nil)
+      RababaAdapter.reverse(output)
+    end
+  end
+end

data/lib/interscript/stdlib.rb

@@ -1,6 +1,6 @@
 class Interscript::Stdlib
   ALIASES = {
-    any_character: '.',
+    any_character: ".",
     none: "",
     space: " ",
     whitespace: "[\\b \\t\\0\\r\\n]",
@@ -19,7 +19,7 @@ class Interscript::Stdlib
   }
 
   def self.re_only_alias?(a)
-    ! %i[none space].include?(a)
+    !%i[none space].include?(a)
   end
 
   def self.boundary_like_alias?(a)
@@ -30,10 +30,10 @@ class Interscript::Stdlib
 
   def self.parallel_regexp_compile(subs_hash)
     # puts subs_hash.inspect
-    regexp = subs_hash.each_with_index.map do |p,i|
-      "(?<_%d>%s)" % [i,p[0]]
+    regexp = subs_hash.each_with_index.map do |p, i|
+      "(?<_%d>%s)" % [i, p[0]]
     end.join("|")
-    subs_regexp = Regexp.compile(regexp)
+    Regexp.compile(regexp)
     # puts subs_regexp.inspect
   end
 
@@ -41,16 +41,20 @@ class Interscript::Stdlib
     string.gsub(subs_regexp) do |match|
       lm = Regexp.last_match
       # Extract the match name
-      idx = lm.named_captures.compact.keys.first[1..-1].to_i
+      idx = lm.named_captures.compact.keys.first[1..].to_i
       subs_hash[idx]
     end
   end
 
   def self.parallel_regexp_gsub_debug(string, subs_regexp, subs_array)
     # only gathering debug info, test data is available in maps_analyze_staging
+    # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
     $subs_matches = []
+    # standard:enable Style/GlobalVars
+    # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
     $subs_regexp = subs_regexp
-    #$subs_array = subs_array
+    # standard:enable Style/GlobalVars
+    # $subs_array = subs_array
     string.gsub(subs_regexp) do |match|
       lm = Regexp.last_match
       # puts lm.inspect
@@ -58,35 +62,36 @@ class Interscript::Stdlib
       matched = lm.named_captures.compact.keys.first
       # puts matched.inspect
       # puts [lm.begin(matched), lm.end(matched)].inspect
-      idx = matched[1..-1].to_i
+      idx = matched[1..].to_i
       debug_info = {begin: lm.begin(matched), end: lm.end(matched), idx: idx, result: subs_array[idx]}
+      # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
       $subs_matches << debug_info
+      # standard:enable Style/GlobalVars
       subs_array[idx]
     end
   end
 
-
   def self.parallel_replace_compile_hash(a)
     h = {}
-    a.each do |from,to|
+    a.each do |from, to|
       h[from] = to
     end
     h
   end
 
-  def self.parallel_replace_hash(str,h)
+  def self.parallel_replace_hash(str, h)
     newstr = ""
     len = str.length
     max_key_len = h.keys.map(&:length).max
     i = 0
     while i < len
       max_key_len.downto(1).each do |checked_len|
-        substr = str[i,checked_len]
+        substr = str[i, checked_len]
         if h[substr]
           newstr << h[substr]
           i += substr.length
-        elsif checked_len==1
-          newstr << str[i,1]
+        elsif checked_len == 1
+          newstr << str[i, 1]
           i += 1
         end
       end
@@ -105,7 +110,7 @@ class Interscript::Stdlib
         from = Array(from)
         from.each do |f|
           branch = tree
-          chars = f.split("")
+          chars = f.chars
           chars[0..-2].each do |c|
             branch[c.ord] ||= {}
             branch = branch[c.ord]
@@ -130,8 +135,8 @@ class Interscript::Stdlib
       match, repl = nil, nil
 
       j = 0
-      while j < len-i
-        cc = str[i+j]
+      while j < len - i
+        cc = str[i + j]
         if branch.include? cc.ord
           branch = branch[cc.ord]
           sub << cc
@@ -167,7 +172,7 @@ class Interscript::Stdlib
     # Deterministic on Linux:
     # ary.sort_by{ |rule| -rule.max_length }
 
-    ary.each_with_index.sort_by{ |rule,idx| -rule.max_length*100000 + idx }.map(&:first)
+    ary.each_with_index.sort_by { |rule, idx| -rule.max_length * 100000 + idx }.map(&:first)
   end
 
   def self.available_functions
@@ -186,84 +191,9 @@ class Interscript::Stdlib
       unseparate: :separate,
 
       rababa: :rababa_reverse,
-      rababa_reverse: :rababa,
+      rababa_reverse: :rababa
     }
   end
 
-  module Functions
-    def self.title_case(output, word_separator: " ")
-      output = output.gsub(/^(.)/, &:upcase)
-      output = output.gsub(/#{word_separator}(.)/, &:upcase) unless word_separator == ''
-      output
-    end
-
-    def self.downcase(output, word_separator: nil)
-      if word_separator
-        output = output.gsub(/^(.)/, &:downcase)
-        output = output.gsub(/#{word_separator}(.)/, &:downcase) unless word_separator == ''
-      else
-        output.downcase
-      end
-    end
-
-    def self.compose(output, _:nil)
-      output.unicode_normalize(:nfc)
-    end
-
-    def self.decompose(output, _:nil)
-      output.unicode_normalize(:nfd)
-    end
-
-    def self.separate(output, separator: " ")
-      output.split("").join(separator)
-    end
-
-    def self.unseparate(output, separator: " ")
-      output.split(separator).join("")
-    end
-
-    @secryst_models = {}
-    def self.secryst(output, model:)
-      require "secryst" rescue nil # Try to load secryst, but don't fail hard if not possible.
-      unless defined? Secryst
-        raise Interscript::ExternalUtilError, "Secryst is not loaded. Please read docs/Usage_with_Secryst.adoc"
-      end
-      Interscript.secryst_index_locations.each do |remote|
-        Secryst::Provisioning.add_remote(remote)
-      end
-      @secryst_models[model] ||= Secryst::Translator.new(model_file: model)
-      output.split("\n").map(&:chomp).map do |i|
-        @secryst_models[model].translate(i)
-      end.join("\n")
-    end
-
-    def self.rababa(output, config:)
-      require "rababa" rescue nil # Try to load rababa, but don't fail hard if not possible.
-      unless defined? Rababa
-        raise Interscript::ExternalUtilError, "Rababa is not loaded. Please read docs/Usage_with_Rababa.adoc"
-      end
-
-      config_value = Interscript.rababa_configs[config]
-      model_uri = config_value['model']
-      rababa_config = config_value['config']
-      model_path = Interscript.rababa_provision(config, model_uri)
-
-      @rababa_diacritizer ||= Rababa::Diacritizer.new(model_path, rababa_config)
-
-      @rababa_diacritizer.diacritize_text(output)
-    end
-
-    def self.rababa_reverse(output, config:)
-      # require "rababa" rescue nil # Try to load rababa, but don't fail hard if not possible.
-      # unless defined? Rababa
-      #   raise StandardError, "Rababa is not loaded. Please read docs/Usage_with_Rababa.adoc"
-      # end
-
-      # A call to allocate allows us to remove diacritics without initializing the model
-      # Rababa::Diacritizer.allocate.remove_diacritics(output)
-
-      # Unfortunately, this is broken as of now.
-      output.gsub(/[\u064e\u064b\u064f\u064c\u0650\u064d\u0652\u0651]/, '')
-    end
-  end
+  autoload :Functions, "interscript/stdlib/functions"
 end