interscript 0.1.7 → 2.1.0b1

data/lib/interscript/node/item/stage.rb

@@ -0,0 +1,23 @@
+class Interscript::Node::Item::Stage < Interscript::Node::Item
+  attr_accessor :name
+  attr_accessor :map
+  def initialize(name, map: nil)
+    self.name = name
+    self.map = map
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :name => name,
+      :map => map,
+    }
+  end
+
+  def inspect
+    if map
+      "map.#{@map}.stage.#{@name}"
+    else
+      "stage.#{@name}"
+    end
+  end
+end

data/lib/interscript/node/item/string.rb

@@ -0,0 +1,51 @@
+class Interscript::Node::Item::String < Interscript::Node::Item
+  attr_accessor :data
+  def initialize data
+    self.data = data
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :data => self.data }
+  end
+
+  def max_length
+    self.data.length
+  end
+
+  def first_string
+    self.data
+  end
+
+  alias nth_string first_string
+
+  def + other
+    if self.data == ""
+      Interscript::Node::Item.try_convert(other)
+    elsif Interscript::Node::Item::String === self &&
+      (Interscript::Node::Item::String === other || ::String === other)
+
+      other = Interscript::Node::Item.try_convert(other)
+
+      Interscript::Node::Item::String.new(self.data + other.data)
+    else
+      super
+    end
+  end
+
+  def inspect
+    @data.inspect
+  end
+end
+
+# stdext
+class String
+  alias plus_before_interscript +
+  def + other
+    if Interscript::Node === other
+      Interscript::Node::Item.try_convert(self) + other
+    else
+      self.plus_before_interscript(other)
+    end
+  end
+end

data/lib/interscript/node/metadata.rb

@@ -0,0 +1,18 @@
+class Interscript::Node::MetaData < Interscript::Node
+  attr_accessor :data
+  def initialize data={}
+    @data = data
+  end
+
+  def []=(k,v)
+    @data[k] = v
+  end
+  def [](k)
+    @data[k]
+  end
+
+  def to_hash
+    {:class => self.class.to_s,
+      :data => @data}
+  end
+end

data/lib/interscript/node/rule.rb

@@ -0,0 +1,6 @@
+class Interscript::Node::Rule < Interscript::Node
+end
+
+require "interscript/node/rule/sub"
+require "interscript/node/rule/run"
+require "interscript/node/rule/funcall"

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

@@ -0,0 +1,18 @@
+class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
+  attr_accessor :name, :kwargs
+  def initialize name, **kwargs
+    @name = name
+    @kwargs = kwargs
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :name => self.name,
+      :kwargs => self.kwargs
+    }
+  end
+
+  def inspect
+    "#{@name} #{kwargs.inspect[1..-2]}"
+  end
+end

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

@@ -0,0 +1,15 @@
+class Interscript::Node::Rule::Run < Interscript::Node::Rule
+  attr_accessor :stage
+  def initialize stage
+    @stage = stage
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :stage => self.stage.to_hash }
+  end
+
+  def inspect
+    "run #{@stage.inspect}"
+  end
+end

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

@@ -0,0 +1,68 @@
+class Interscript::Node::Rule::Sub < Interscript::Node::Rule
+  attr_accessor :from, :to
+  attr_accessor :before, :not_before, :after, :not_after
+  attr_accessor :priority
+
+  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
+    else
+      self.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
+
+    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
+    self.not_after = Interscript::Node::Item.try_convert(not_after) if not_after
+  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
+  end
+
+  def to_hash
+    puts self.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
+    }
+
+    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
+  end
+
+  def inspect
+    out = "sub "
+    params = []
+    params << @from.inspect
+    if @to == :upcase
+      params << "upcase"
+    else
+      params << @to.inspect
+    end
+    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
+end

data/lib/interscript/node/stage.rb

@@ -0,0 +1,19 @@
+class Interscript::Node::Stage < Interscript::Node::Group::Sequential
+  attr_accessor :name, :doc_name
+
+  def initialize name = :main
+    @name = name
+    super()
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :name => name,
+      :children => @children.map{|x| x.to_hash} }
+  end
+
+  def inspect
+    name = "(#{@name})" if @name != :main
+    "stage#{name} {\n#{super}\n}"
+  end
+end

data/lib/interscript/node/tests.rb

@@ -0,0 +1,15 @@
+class Interscript::Node::Tests < Interscript::Node
+  attr_accessor :data
+  def initialize data=[]
+    @data = data
+  end
+
+  def <<(pair)
+    @data << pair
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :data => @data }
+  end
+end

data/lib/interscript/stdlib.rb

@@ -0,0 +1,211 @@
+class Interscript::Stdlib
+  ALIASES = {
+    any_character: '.',
+    none: "",
+    space: " ",
+    whitespace: "[\\b \\t\\0\\r\\n]",
+    boundary: "\\b",
+    non_word_boundary: "\\B",
+    word: "\\w",
+    not_word: "\\W",
+    alpha: "[a-zA-Z]",
+    not_alpha: "[^a-zA-Z]",
+    digit: "\\d",
+    not_digit: "\\D",
+    line_start: "^",
+    line_end: "$",
+    string_start: "\\A",
+    string_end: "\\z"
+  }
+
+  def self.re_only_alias?(a)
+    ! %i[none space].include?(a)
+  end
+
+  @treecache = {}
+
+  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]]
+    end.join("|")
+    subs_regexp = Regexp.compile(regexp)
+    # puts subs_regexp.inspect
+  end
+
+  def self.parallel_regexp_gsub(string, subs_regexp, subs_hash)
+    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
+      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
+    $subs_matches = []
+    $subs_regexp = subs_regexp
+    #$subs_array = subs_array
+    string.gsub(subs_regexp) do |match|
+      lm = Regexp.last_match
+      # puts lm.inspect
+      # Extract the match name
+      matched = lm.named_captures.compact.keys.first
+      # puts matched.inspect
+      # puts [lm.begin(matched), lm.end(matched)].inspect
+      idx = matched[1..-1].to_i
+      debug_info = {begin: lm.begin(matched), end: lm.end(matched), idx: idx, result: subs_array[idx]}
+      $subs_matches << debug_info
+      subs_array[idx]
+    end
+  end
+
+
+  def self.parallel_replace_compile_hash(a)
+    h = {}
+    a.each do |from,to|
+      h[from] = to
+    end
+    h
+  end
+
+  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]
+        if h[substr]
+          newstr << h[substr]
+          i += substr.length
+        elsif checked_len==1
+          newstr << str[i,1]
+          i += 1
+        end
+      end
+    end
+    newstr
+  end
+
+  # hash can be either a hash or a hash-like array
+  def self.parallel_replace_compile_tree(hash)
+    hh = hash.hash
+    if @treecache[hh]
+      tree = @treecache[hh]
+    else
+      tree = {}
+      hash.each do |from, to|
+        from = Array(from)
+        from.each do |f|
+          branch = tree
+          chars = f.split("")
+          chars[0..-2].each do |c|
+            branch[c.ord] ||= {}
+            branch = branch[c.ord]
+          end
+          branch[chars.last.ord] ||= {}
+          branch[chars.last.ord][nil] = to
+        end
+      end
+      @treecache[hh] = tree
+    end
+  end
+
+  def self.parallel_replace_tree(str, tree)
+    newstr = ""
+    len = str.length
+    i = 0
+    while i < len
+      c = str[i]
+
+      sub = ""
+      branch = tree
+      match, repl = nil, nil
+
+      j = 0
+      while j < len-i
+        cc = str[i+j]
+        if branch.include? cc.ord
+          branch = branch[cc.ord]
+          sub << cc
+          if branch.include? nil
+            match = sub.dup
+            repl = branch[nil]
+          end
+          j += 1
+        else
+          break
+        end
+      end
+
+      if match
+        i += match.length
+        newstr << repl
+      else
+        newstr << c
+        i += 1
+      end
+    end
+    newstr
+  end
+
+  def self.parallel_replace(str, hash)
+    tree = parallel_replace_compile_tree(hash)
+    parallel_replace_tree(str, tree)
+  end
+
+  # On Windows at least, sort_by is non-deterministic. Let's add some determinism
+  # to our efforts.
+  def self.deterministic_sort_by_max_length(ary)
+    # 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)
+  end
+
+  def self.available_functions
+    %i[title_case downcase compose decompose separate secryst]
+  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, _:nil)
+      output.downcase
+    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
+
+    @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 StandardError, "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
+  end
+end