interscript 2.1.0rc4 → 2.1.0

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

@@ -1,8 +1,7 @@
 class Interscript::Node::Rule::Run < Interscript::Node::Rule
-  attr_accessor :stage, :reverse_run
-  def initialize stage, reverse_run: nil
+  attr_accessor :stage
+  def initialize stage
     @stage = stage
-    @reverse_run = reverse_run
   end
 
   def to_hash
@@ -10,19 +9,7 @@ class Interscript::Node::Rule::Run < Interscript::Node::Rule
       :stage => self.stage.to_hash }
   end
 
-  def reverse
-    Interscript::Node::Rule::Run.new(stage,
-      reverse_run: reverse_run.nil? ? nil : !reverse_run
-    )
-  end
-
-  def ==(other)
-    super && self.stage == other.stage
-  end
-
   def inspect
-    out = "run #{@stage.inspect}"
-    out += ", reverse_run: #{@reverse_run.inspect}" unless reverse_run.nil?
-    out
+    "run #{@stage.inspect}"
   end
 end

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

@@ -1,19 +1,12 @@
 class Interscript::Node::Rule::Sub < Interscript::Node::Rule
   attr_accessor :from, :to
   attr_accessor :before, :not_before, :after, :not_after
-  attr_accessor :reverse_before, :reverse_not_before, :reverse_after, :reverse_not_after
-  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
     self.from = Interscript::Node::Item.try_convert from
     if to == :upcase
       self.to = :upcase
-    elsif to == :downcase
-      self.to = :downcase
     else
       self.to = Interscript::Node::Item.try_convert to
     end
@@ -23,8 +16,6 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     #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
-
     self.before = Interscript::Node::Item.try_convert(before) if before
     self.after = Interscript::Node::Item.try_convert(after) if after
     self.not_before = Interscript::Node::Item.try_convert(not_before) if not_before
@@ -46,13 +37,7 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     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
+      :to => Symbol === self.to ? self.to : self.to.to_hash
     }
 
     hash[:before] = self.before&.to_hash if self.before
@@ -64,165 +49,19 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     hash
   end
 
-  def reverse
-    if to == :upcase
-      xfrom = from.downcase
-      xto = :downcase
-    elsif to == :downcase
-      xfrom = from.upcase
-      xto = :upcase
-    else
-      xto, xfrom = reverse_transfer(from, to)
-    end
-
-    # A special case: sub "a", "" shouldn't be present in a reverse map
-    rrun = self.reverse_run.nil? ? nil : !self.reverse_run
-    if rrun.nil? && !has_assertions? &&
-      (xfrom == "" ||
-        (Interscript::Node::Item::String === xfrom && xfrom.data == '') ||
-        (Interscript::Node::Item::Alias === xfrom && xfrom.name == :none)
-      )
-
-      rrun = true
-    end
-
-    Interscript::Node::Rule::Sub.new(xfrom, xto,
-      before: before, after: after,
-      not_before: not_before, not_after: not_after,
-
-      reverse_run: rrun,
-
-      priority: priority ? -priority : nil
-    )
-  end
-  
-  def has_assertions?
-    !!(before || not_before || not_after || after)
-  end
-
-  # Attempt to transfer some references to boundary/line_begin around.
-  # Those in general should go into before/after clauses, but for now
-  # let's try to get the best compatibility possible. Also, CaptureGroup,
-  # CaptureRef need to be shifted around
-  def reverse_transfer from, to
-    # This part is about moving initial and final boundary like aliases
-    case from
-    when Interscript::Node::Item::Group
-      first = from.children.first
-      last = from.children.last
-
-      if Interscript::Node::Item::Alias === first && first.boundary_like?
-        out = Interscript::Node::Item::Group.new + first + to
-        to = out.compact
-
-        from = from.dup.tap do |i|
-          i.children = i.children[1..-1]
-        end.compact
-      end
-
-      if Interscript::Node::Item::Alias === last && last.boundary_like?
-        out = Interscript::Node::Item::Group.new + to + last
-        to = out.compact
-
-        from = from.dup.tap do |i|
-          i.children = i.children[0..-2]
-        end.compact
-      end
-    when Interscript::Node::Item::Alias
-      if from.boundary_like?
-        to = if from.name.to_s.end_with? "_end"
-          Interscript::Node::Item::Group.new + to + from
-        else
-          Interscript::Node::Item::Group.new + from + to
-        end
-        from = Interscript::Node::Item::Alias.new(:none)
-      end
-    end
-
-    # This part is about moving backreferences
-    state = {left:[], right:[]}
-
-    from  = reverse_transfer_visit(from, :from, state)
-    to    = reverse_transfer_visit(to,   :to,   state)
-
-    [from, to]
-  end
-
-  private def reverse_transfer_visit(node, type, state)
-    node = Interscript::Node::Item.try_convert(node)
-
-    case node
-    when Interscript::Node::Item::Alias
-      if node.name == :kor_maybedash
-        state[:left] << node
-        Interscript::Node::Item::CaptureRef.new(state[:left].length)
-      else
-        node
-      end
-    when Interscript::Node::Item::String
-      node
-    when Interscript::Node::Item::Any
-      if Array === node.value
-        node.dup.tap do |i|
-          i.value = i.value.map { |c| reverse_transfer_visit(c, type, state) }
-        end
-      else
-        node
-      end
-    when Interscript::Node::Item::Group
-      node.dup.tap do |i|
-        i.children = i.children.map { |c| reverse_transfer_visit(c, type, state) }
-      end
-    when Interscript::Node::Item::Repeat
-      node.dup.tap do |i|
-        i.data = reverse_transfer_visit(i.data, type, state)
-      end
-    when Interscript::Node::Item::CaptureRef
-      if type == :from
-        node
-      elsif state[:right][node.id]
-        node
-      else
-        state[:right][node.id] = true
-        state[:left][node.id - 1] or raise "Capture count doesn't match"
-      end
-    when Interscript::Node::Item::CaptureGroup
-      state[:left] << node
-      out = Interscript::Node::Item::CaptureRef.new(state[:left].length)
-      reverse_transfer_visit(node.data, type, state) # Visit but don't care
-      out
-    else
-      raise "Type #{node.class} unhandled!"
-    end
-  end
-
-  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
-  end
-
   def inspect
     out = "sub "
     params = []
     params << @from.inspect
-    if Symbol === @to
-      params << @to.to_s
+    if @to == :upcase
+      params << "upcase"
     else
       params << @to.inspect
     end
-    params << "reverse_run: #{@reverse_run.inspect}" unless @reverse_run.nil?
-
     params << "before: #{@before.inspect}" if @before
     params << "after: #{@after.inspect}" if @after
     params << "not_before: #{@not_before.inspect}" if @not_before
     params << "not_after: #{@not_after.inspect}" if @not_after
-
     params << "priority: #{@priority.inspect}" if @priority
     out << params.join(", ")
   end

data/lib/interscript/node/rule.rb

@@ -1,7 +1,4 @@
 class Interscript::Node::Rule < Interscript::Node
-  def ==(other)
-    super && self.reverse_run == other.reverse_run
-  end
 end
 
 require "interscript/node/rule/sub"

data/lib/interscript/node/stage.rb

@@ -1,11 +1,9 @@
 class Interscript::Node::Stage < Interscript::Node::Group::Sequential
-  attr_accessor :name, :doc_name, :dont_reverse
+  attr_accessor :name, :doc_name
 
-  def initialize(name = :main, reverse_run: nil, doc_name: nil, dont_reverse: false)
+  def initialize name = :main
     @name = name
-    @doc_name = doc_name
-    @dont_reverse = dont_reverse
-    super(reverse_run: reverse_run)
+    super()
   end
 
   def to_hash
@@ -14,32 +12,8 @@ class Interscript::Node::Stage < Interscript::Node::Group::Sequential
       :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
-    end
-  end
-
-  def ==(other)
-    super &&
-    self.name == other.name &&
-    self.reverse_run == other.reverse_run &&
-    self.dont_reverse == other.dont_reverse
-  end
-
   def inspect
-    args = []
-    args << "#{@name}" if @name != :main
-    args << "dont_reverse: true" if dont_reverse
-    name = ""
-    name = "(#{args.join(", ")})" unless args.empty?
+    name = "(#{@name})" if @name != :main
     "stage#{name} {\n#{super}\n}"
   end
 end

data/lib/interscript/node/tests.rb

@@ -8,16 +8,6 @@ class Interscript::Node::Tests < Interscript::Node
     @data << pair
   end
 
-  def reverse
-    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
-  end
-
   def to_hash
     { :class => self.class.to_s,
       :data => @data }

data/lib/interscript/node.rb

@@ -4,10 +4,6 @@ class Interscript::Node
     raise NotImplementedError, "You can't construct a Node directly"
   end
 
-  def ==(other)
-    self.class == other.class
-  end
-
   def to_hash
     { :class => self.class.to_s,
       :question => "is something missing?"

data/lib/interscript/stdlib.rb

@@ -22,10 +22,6 @@ class Interscript::Stdlib
     ! %i[none space].include?(a)
   end
 
-  def self.boundary_like_alias?(a)
-    %i[line_start line_end string_start string_end boundary non_word_boundary].include?(a)
-  end
-
   @treecache = {}
 
   def self.parallel_regexp_compile(subs_hash)
@@ -171,20 +167,7 @@ class Interscript::Stdlib
   end
 
   def self.available_functions
-    %i[title_case downcase compose decompose separate unseparate secryst rababa]
-  end
-
-  def self.reverse_function
-    {
-      title_case: :downcase, # Those two are best-effort,
-      downcase: :title_case, # but probably wrong.
-
-      compose: :decompose,
-      decompose: :compose,
-
-      separate: :unseparate,
-      unseparate: :separate
-    }
+    %i[title_case downcase compose decompose separate secryst]
   end
 
   module Functions
@@ -194,13 +177,8 @@ class Interscript::Stdlib
       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
+    def self.downcase(output, _:nil)
+      output.downcase
     end
 
     def self.compose(output, _:nil)
@@ -215,10 +193,6 @@ class Interscript::Stdlib
       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.
@@ -233,21 +207,5 @@ class Interscript::Stdlib
         @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 StandardError, "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
   end
 end

data/lib/interscript/version.rb

@@ -1,3 +1,3 @@
 module Interscript
-  VERSION = "2.1.0rc4"
+  VERSION = "2.1.0"
 end

data/lib/interscript/visualize/json.rb

@@ -10,7 +10,6 @@ class Interscript::Node::Group
         more << "after: #{rule.after.to_html(map)}" if rule.after
         more << "<nobr>not before:</nobr> #{rule.not_before.to_html(map)}" if rule.not_before
         more << "<nobr>not after:</nobr> #{rule.not_after.to_html(map)}" if rule.not_after
-        more << "<nobr>reverse run:</nobr> #{rule.reverse_run}" unless rule.reverse_run.nil?
         more = more.join(", ")
 
         out << {
@@ -25,14 +24,11 @@ class Interscript::Node::Group
           children: rule.to_visualization_array(map)
         }
       when Interscript::Node::Rule::Funcall
-        more = rule.kwargs.map do |k,v|
-          "#{k.to_s.gsub("_", " ")}: #{v}"
-        end
-        more << "<nobr>reverse run:</nobr> #{rule.reverse_run}" unless rule.reverse_run.nil?
-
         out << {
           type: rule.name.to_s.gsub("_", " ").gsub(/^(.)/, &:upcase),
-          more: more.join(", ")
+          more: rule.kwargs.map do |k,v|
+            "#{k.to_s.gsub("_", " ")}: #{v}"
+          end.join(", ")
         }
       when Interscript::Node::Rule::Run
         if rule.stage.map
@@ -43,14 +39,10 @@ class Interscript::Node::Group
           stage = rule.stage.name
         end
 
-        more = []
-        more << "<nobr>reverse run:</nobr> #{rule.reverse_run}" unless rule.reverse_run.nil?
-
         out << {
           type: "Run",
           doc: doc.name,
-          stage: stage,
-          more: more.join(", "),
+          stage: stage
         }
       else
         out << {

data/lib/interscript.rb

@@ -53,16 +53,6 @@ module Interscript
       output_file
     end
 
-    # Detects the transliteration that gives the most close approximation
-    # of transliterating source into destination.
-    #
-    # Set multiple: true to get a full report.
-    def detect(source, destination, **kwargs)
-      detector = Detector.new
-      detector.set_from_kwargs(**kwargs)
-      detector.(source, destination)
-    end
-
     def map_gems
       @map_gems ||= Gem.find_latest_files('interscript-maps.yaml').map do |i|
         [i, YAML.load_file(i)]
@@ -86,56 +76,6 @@ module Interscript
       end.compact.flatten
     end
 
-    def rababa_configs
-      @rababa_configs ||= map_gems.map do |i,v|
-        v["rababa-configs"]
-      end.compact.inject({}) do |a,b|
-        a.merge(b)
-      end
-    end
-
-    # This code is borrowed from Secryst and should end up in Rababa, but for now,
-    # let's keep it here.
-    def rababa_provision(model_name, model_uri)
-      require 'fileutils'
-      require 'open-uri'
-
-      # We provision the environment in the following way:
-      # First, we try the RABABA_DATA environment variable. If that's available,
-      # we use it to store the Rababa data we need. Otherwise, we try the following
-      # paths:
-
-      possible_paths = [
-        "/var/lib/rababa",
-        "/usr/local/share/rababa",
-        "/usr/share/rababa",
-        File.join(Dir.home, ".local/share/rababa")
-      ]
-
-      # We find the first writable path
-
-      write_path = nil
-
-      ([ENV["RABABA_DATA"]] + possible_paths).compact.each do |path|
-        FileUtils.mkdir_p(path)
-        write_path = path unless write_path
-      rescue
-      end
-
-      raise StandardError, "Can't find a writable path for Rababa. Consider setting a RABABA_DATA environment variable" unless write_path
-
-      model_path = "#{write_path}/model-#{model_name}.onnx"
-
-      # Redownload every hour
-      if File.exist?(model_path) && File.mtime(model_path) + 3600 >= Time.now
-        return model_path
-      else
-        data = URI.open(model_uri).read
-        File.write(model_path, data)
-        return model_path
-      end
-    end
-
     def map_aliases
       return @map_aliases if @map_aliases
 
@@ -159,22 +99,6 @@ module Interscript
 
       basename ? imps.map { |j| File.basename(j, ".#{ext}") } : imps
     end
-
-    # Removes the excluded maps for a given compiler and RUBY_PLATFORM.
-    # To be used by tests
-    # and builders. It uses the `skip` directive in interscript-maps.yaml
-    def exclude_maps(maps, compiler:, platform: true)
-      map_gems.each do |i,v|
-        [compiler.name, (Gem::Platform.local.os if platform)].compact.each do |name|
-          skips = v.dig('skip', name) || []
-          skips.each do |skip|
-            skip_re = /#{Regexp.escape(skip).gsub("\\*", ".*?")}/
-            maps = maps.grep_v(skip_re)
-          end
-        end
-      end
-      maps
-    end
   end
 end
 
@@ -185,5 +109,3 @@ require "interscript/interpreter"
 
 require 'interscript/dsl'
 require 'interscript/node'
-
-require 'interscript/detector'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interscript
 version: !ruby/object:Gem::Version
-  version: 2.1.0rc4
+  version: 2.1.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -26,20 +26,6 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: interscript-maps
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.0a
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.0a
-- !ruby/object:Gem::Dependency
-  name: text
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -84,7 +70,6 @@ files:
 - lib/interscript/compiler.rb
 - lib/interscript/compiler/javascript.rb
 - lib/interscript/compiler/ruby.rb
-- lib/interscript/detector.rb
 - lib/interscript/dsl.rb
 - lib/interscript/dsl/aliases.rb
 - lib/interscript/dsl/document.rb
@@ -119,7 +104,6 @@ files:
 - lib/interscript/node/stage.rb
 - lib/interscript/node/tests.rb
 - lib/interscript/stdlib.rb
-- lib/interscript/utils/helpers.rb
 - lib/interscript/utils/regexp_converter.rb
 - lib/interscript/version.rb
 - lib/interscript/visualize.rb
@@ -145,9 +129,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
 signing_key: 

data/lib/interscript/detector.rb

@@ -1,60 +0,0 @@
-require "text"
-
-class Interscript::Detector
-  attr_accessor :compiler
-  attr_accessor :distance_computer
-  attr_accessor :map_pattern
-
-  # TODO: use transliterate_each
-  attr_accessor :each
-
-  attr_accessor :load_path
-  attr_accessor :cache
-
-  # Returns a summary of all detected transliterations
-  attr_accessor :multiple
-
-  def initialize
-    @compiler = Interscript::Interpreter
-    @distance_computer = DistanceComputer::Levenshtein
-    @map_pattern = "*"
-
-    @each = false
-
-    @load_path = false
-    @cache = CACHE
-  end
-
-  def set_from_kwargs(**kwargs)
-    kwargs.each do |k,v|
-      self.public_send(:"#{k}=", v)
-    end
-  end
-
-  def call(source, destination)
-    maps = Interscript.maps(select: @map_pattern, load_path: @load_path)
-
-    summary = maps.map do |map|
-      try_dest = Interscript.transliterate(map, source, compiler: @compiler)
-
-      [map, try_dest]
-    end.map do |map, try_dest|
-      dist = @distance_computer.(try_dest, destination)
-      
-      [map, dist]
-    end.sort_by(&:last).to_h
-
-    if @multiple
-      summary.to_h
-    else
-      summary.first.first
-    end
-  end
-
-  CACHE = {}
-
-  # A DistanceComputer needs to respond to #call(source, destination)
-  module DistanceComputer
-    Levenshtein = Text::Levenshtein.method(:distance)
-  end
-end