interscript 0.1.6 → 2.1.0a9

data/lib/interscript/node/dependency.rb

@@ -0,0 +1,13 @@
+class Interscript::Node::Dependency < Interscript::Node
+  attr_accessor :name, :full_name, :import, :document
+
+  def initialize
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :name => @name,
+      :full_name => @full_name,
+      :import => @import }
+  end
+end

data/lib/interscript/node/document.rb

@@ -0,0 +1,45 @@
+class Interscript::Node::Document
+  attr_accessor :metadata, :tests, :name
+  attr_accessor :dependencies, :aliases, :stages, :dep_aliases
+
+  def initialize
+    puts "Interscript::Node::Document.new " if $DEBUG
+    @metadata = nil
+    @tests = nil
+    @dependencies = []
+    @dep_aliases = {}
+    @aliases = {}
+    @stages = {}
+  end
+
+  def imported_aliases
+    aliases = @aliases
+    @dependencies.select(&:import).each do |d|
+      aliases = d.document.aliases.merge(aliases)
+    end
+    aliases
+  end
+
+  def imported_stages
+    stages = @stages
+    @dependencies.select(&:import).each do |d|
+      stages = d.document.stages.merge(stages)
+    end
+    stages
+  end
+
+  def all_dependencies
+    (dependencies + dependencies.map { |i| i.document.dependencies }).flatten.uniq_by do |i|
+      i.full_name
+    end
+  end
+
+  def to_hash
+    { :class => self.class.to_s, :metadata => @metadata&.to_hash,
+      :tests => @tests&.to_hash,
+      :dependencies => @dependencies.map{|x| x.to_hash},
+      :dep_aliases => @dep_aliases.transform_values(&:to_hash),
+      :aliases => @aliases.transform_values(&:to_hash),
+      :stages => @stages.transform_values(&:to_hash) }
+  end
+end

data/lib/interscript/node/group.rb

@@ -0,0 +1,34 @@
+class Interscript::Node::Group < Interscript::Node
+  attr_accessor :children
+
+  def initialize
+    @children = []
+  end
+
+  def reorder_children(source,target)
+    @children[source], @children[target] = @children[target], @children[source]
+    self
+  end
+
+  def apply_order(order)
+    children_new = [nil] * @children.size
+    order.each_with_index do |pos,idx|
+      children_new[idx] = @children[pos]
+    end
+    @children = children_new
+    #@children[source], @children[target] = @children[target], @children[source]
+    self
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :children => @children.map{|x| x.to_hash} }
+  end
+
+  def inspect
+    @children.map(&:inspect).join("\n").gsub(/^/, "  ")
+  end
+end
+
+require "interscript/node/group/parallel"
+require "interscript/node/group/sequential"

data/lib/interscript/node/group/parallel.rb

@@ -0,0 +1,9 @@
+class Interscript::Node::Group::Parallel < Interscript::Node::Group
+  # A place for Interpreter to store a compiled form of the tree
+  attr_accessor :cached_tree
+  attr_accessor :subs_regexp, :subs_replacements, :subs_array
+
+  def inspect
+    "parallel {\n#{super}\n}"
+  end
+end

data/lib/interscript/node/group/sequential.rb

@@ -0,0 +1,2 @@
+class Interscript::Node::Group::Sequential < Interscript::Node::Group
+end

data/lib/interscript/node/item.rb

@@ -0,0 +1,52 @@
+class Interscript::Node::Item < Interscript::Node
+  attr_accessor :item
+  def initialize item
+    raise NotImplementedError, "You can't construct a Node::Item directly"
+  end
+
+  def + other
+    this = self
+
+    this  = this.children  if Interscript::Node::Item::Group === this
+    other = other.children if Interscript::Node::Item::Group === other
+
+    this  = Array(this)
+    other = Array(other)
+
+    this  = this.map  { |i| Interscript::Node::Item.try_convert(i) }
+    other = other.map { |i| Interscript::Node::Item.try_convert(i) }
+
+    middle = []
+
+    if Interscript::Node::Item::String === this.last &&
+       Interscript::Node::Item::String === other.first
+
+       middle = [this.last + other.first]
+       this = this[0..-2]
+       other = this[1..-1]
+    end
+
+    g = Interscript::Node::Item::Group.new(*this, *middle, *other)
+    g.verify!
+    g
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :item => self.item }
+  end
+
+  def self.try_convert(i)
+    i = Interscript::Node::Item::String.new(i) if i.class == ::String
+    raise TypeError, "Wrong type #{i.class}, expected I::Node::Item" unless Interscript::Node::Item === i
+    i
+  end
+end
+
+require "interscript/node/item/alias"
+require "interscript/node/item/string"
+require "interscript/node/item/group"
+require "interscript/node/item/any"
+require "interscript/node/item/stage"
+require "interscript/node/item/capture"
+require "interscript/node/item/repeat"

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

@@ -0,0 +1,42 @@
+class Interscript::Node::Item::Alias < Interscript::Node::Item
+  attr_accessor :name
+  attr_accessor :map
+  def initialize(name, map: nil)
+    self.name = name
+    self.map = map
+  end
+
+  def stdlib?
+    !map && Interscript::Stdlib::ALIASES.has_key?(name)
+  end
+
+  def max_length
+    if stdlib?
+      ([:none].include? name) ? 0 : 1
+    else
+      return 1 if name == :unicode_hangul
+      raise NotImplementedError, "can't get a max length of this alias"
+    end
+  end
+
+  def first_string
+    self
+  end
+
+  alias nth_string first_string
+
+  def to_hash
+    { :class => self.class.to_s,
+      :name => name,
+      :map => map,
+    }
+  end
+
+  def inspect
+    if map
+      "map.#{map}.#{name}"
+    else
+      "#{name}"
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+class Interscript::Node::Item::Any < Interscript::Node::Item
+  attr_accessor :value
+  def initialize data
+    case data
+    when Array, ::String, Range
+      self.value = data
+    when Interscript::Node::Item::Group # debug alalc-ara-Arab-Latn-1997  line 683
+      self.value = data.children
+    when Interscript::Node::Item::Alias # debug mofa-jpn-Hrkt-Latn-1989 line 116
+      self.value = Interscript::Stdlib::ALIASES[data.name]
+    else
+      puts data.inspect
+      raise TypeError, "Wrong type #{data[0].class}, excepted Array, String or Range"
+    end
+  end
+
+  def data
+    case @value
+    when Array
+      value.map { |i| Interscript::Node::Item.try_convert(i) }
+    when ::String
+      value.split("").map { |i| Interscript::Node::Item.try_convert(i) }
+    when Range
+      value.map { |i| Interscript::Node::Item.try_convert(i) }
+    end
+  end
+
+  def first_string
+    case @value
+    when Array
+      Interscript::Node::Item.try_convert(value.first).first_string
+    when ::String
+      value[0]
+    when Range
+      value.begin
+    end
+  end
+
+  def nth_string
+    return first_string unless $select_nth_string
+
+    d = data
+    Fiber.yield(:prepare)
+    id = Fiber.yield(:select_nth_string, d.count, self.hash)
+    Fiber.yield(:selection)
+    Interscript::Node::Item.try_convert(value[id]).nth_string
+  end
+
+  def max_length
+    self.data.map(&:max_length).max
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :data => self.data.map { |i| i.to_hash } }
+  end
+
+  def inspect
+    "any(#{value.inspect})"
+  end
+end

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

@@ -0,0 +1,50 @@
+# (...)
+class Interscript::Node::Item::CaptureGroup < Interscript::Node::Item
+  attr_accessor :data
+
+  def initialize(data)
+    data = Interscript::Node::Item.try_convert(data)
+    @data = data
+  end
+
+  def first_string
+    data.first_string
+  end
+
+  def nth_string
+    data.nth_string
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :data => self.data.to_hash }
+  end
+
+  def inspect
+    "capture(#{@data.inspect})"
+  end
+end
+
+# \1
+class Interscript::Node::Item::CaptureRef < Interscript::Node::Item
+  attr_accessor :id
+
+  def initialize(id)
+    @id = id
+  end
+
+  def first_string
+    self
+  end
+
+  alias nth_string first_string
+
+  def to_hash
+    { :class => self.class.to_s,
+      :id => self.id }
+  end
+
+  def inspect
+    "ref(#{@id.inspect})"
+  end
+end

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

@@ -0,0 +1,51 @@
+class Interscript::Node::Item::Group < Interscript::Node::Item
+  attr_accessor :children
+
+  def initialize *children
+    @children = children.flatten.map do |i|
+      Interscript::Node::Item.try_convert(i)
+    end
+  end
+
+  def +(item)
+    item = Interscript::Node::Item.try_convert(item)
+    out = self.dup
+    out.children << item
+    out.verify!
+    out
+  end
+
+  # Verify if a group is valid
+  def verify!
+    wrong = @children.find do |i|
+      Interscript::Node::Item::Stage === i ||
+      ! (Interscript::Node::Item === i) ||
+      i.class == Interscript::Node::Item
+    end
+
+    if wrong
+      raise TypeError, "An I::Node::Item::Group can't contain an #{wrong.class} item."
+    end
+  end
+
+  def first_string
+    self.children.map(&:first_string).reduce(&:+)
+  end
+
+  def nth_string
+    self.children.map(&:nth_string).reduce(&:+)
+  end
+
+  def max_length
+    @children.map { |i| i.max_length }.sum
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :children => self.children.map{|x| x.to_hash} }
+  end
+
+  def inspect
+    @children.map(&:inspect).join("+")
+  end
+end

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

@@ -0,0 +1,40 @@
+class Interscript::Node::Item::Repeat < Interscript::Node::Item
+  attr_accessor :data
+  def initialize data
+    data = Interscript::Node::Item.try_convert(data)
+    @data = data
+  end
+
+  def first_string
+    data.first_string
+  end
+
+  def nth_string
+    data.nth_string
+  end
+
+  def max_length
+    data.max_length
+  end
+
+  def to_hash
+    { :class => self.class.to_s,
+      :data => self.data.to_hash }
+  end
+
+  def inspect
+    str = case self
+    when Interscript::Node::Item::Maybe
+      "maybe"
+    when Interscript::Node::Item::MaybeSome
+      "maybe_some"
+    when Interscript::Node::Item::Some
+      "some"
+    end
+    "#{str}(#{@data.inspect})"
+  end
+end
+
+class Interscript::Node::Item::Maybe < Interscript::Node::Item::Repeat; end
+class Interscript::Node::Item::MaybeSome < Interscript::Node::Item::Repeat; end
+class Interscript::Node::Item::Some < Interscript::Node::Item::Repeat; end

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