interscript 2.1.0rc4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 467a62a606d559e17a097273bf77322bab4925dc83b7207d2950aa7d9f2ae39e
-  data.tar.gz: 61964b5809ba483de5da3d79b4cba60863eaf42c36b27aeed99494087b34f8a8
+  metadata.gz: f92a8060d3eee8e0eb4815795294c045ccc7ad341c92a6ba48cb825be4598b95
+  data.tar.gz: 6b977f41c3b1ba80bf25ef1d120666a228bcfd050f31f0a87a9c9ceeb86f5007
 SHA512:
-  metadata.gz: 0b790e39724a37d8dbc52247a5b87b6773dc05f91ce578aeb2fe8103891f7221cf61a22277024cc6167f146649898584d749bc16885e5e6f42a08e4ec888502e
-  data.tar.gz: 9986e5e6dbe057c4fa4714998719c85b56ca3218b4f31f5369967ac14c4c49fad5e82aa8a98859fec7c55b86718c27886f0cfa3799956c077a49f67546c752dc
+  metadata.gz: 2fc32770358443ca0baae5416a918032b4a169fdc98b32d493fe1a487599fbdf9c5005fb53b98a25e5962f18f2ff52a1667010bda48394e891998437b2a2f1b6
+  data.tar.gz: a96e1cc807ebc83c9630b1a78f5b9c26558f771954b55622ec55d0f0b0ff17601a27a5753ab407dc49ec0db8d960940c811148c2872ba9c56e1b19baa3a7ccb7

data/Gemfile

@@ -26,10 +26,4 @@ unless ENV["SKIP_JS"]
   end
 end
 
-group :rababa do
-  gem 'rababa', github: 'interscript/rababa', ref: '70051da'
-end
-
-gem 'pry'
-
 gem 'simplecov', require: false, group: :test

data/Rakefile

@@ -20,10 +20,7 @@ task :compile, [:compiler, :target] do |t, args|
 
   maplist = {}
 
-  maps = Interscript.maps
-  maps = Interscript.exclude_maps(maps, compiler: compiler, platform: false)
-  
-  maps.each do |map|
+  Interscript.maps.each do |map|
     code = compiler.(map).code
     File.write(args[:target] + "/" + map + "." + ext, code)
     maplist[map] = nil
@@ -71,7 +68,6 @@ task :generate_metadata_json do
   require "fileutils"
   require "json"
   require "interscript"
-  require "interscript/compiler/javascript"
 
   FileUtils.rm_rf(file = __dir__+"/metadata.json")
 
@@ -79,10 +75,6 @@ task :generate_metadata_json do
     parsed_map = Interscript.parse(map)
     md = parsed_map.metadata.to_hash
     md["test"] = parsed_map.tests&.data&.first
-    md["skip_js"] = Interscript.exclude_maps([map],
-                      compiler: Interscript::Compiler::Javascript,
-                      platform: false,
-                    ).empty?
     [map, md]
   end.to_h
 

data/bin/console

@@ -3,8 +3,12 @@
 require "bundler/setup"
 require "interscript"
 
-require "interscript/utils/helpers"
-include Interscript::Utils::Helpers
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
 
-require "pry"
-Pry.start
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/interscript.gemspec

@@ -27,6 +27,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor"
-  spec.add_dependency "interscript-maps", "~> #{Interscript::VERSION.split('.')[0,2].join(".")}.0a"
-  spec.add_dependency "text"
+  spec.add_dependency "interscript-maps"
 end

data/lib/interscript/compiler/javascript.rb

@@ -53,7 +53,6 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
 
   def compile_rule(r, map = @map, wrapper = false)
     c = ""
-    return c if r.reverse_run == true
     case r
     when Interscript::Node::Stage
       c += "map.stages.#{r.name} = function(s) {\n"
@@ -76,7 +75,6 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
           raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
           raise ArgumentError, "Can't parallelize rules with :not_after" if i.not_after
 
-          next if i.reverse_run == true
           a << [compile_item(i.from, map, :par), compile_item(i.to, map, :parstr)]
         end
         ah = a.hash.abs
@@ -90,8 +88,7 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
         a = []
         Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|
           raise ArgumentError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
-          
-          next if i.reverse_run == true
+
           a << [build_regexp(i, map), compile_item(i.to, map, :parstr)]
         end
         ah = a.hash.abs
@@ -105,8 +102,6 @@ class Interscript::Compiler::Javascript < Interscript::Compiler
       from = %{"#{build_regexp(r, map).gsub("/", "\\\\/")}"}
       if r.to == :upcase
         to = 'function(a){return a.toUpperCase();}'
-      elsif r.to == :downcase
-        to = 'function(a){return a.toLowerCase();}'
       else
         to = compile_item(r.to, map, :str)
       end

data/lib/interscript/compiler/ruby.rb

@@ -42,7 +42,6 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
 
   def compile_rule(r, map = @map, wrapper = false)
     c = ""
-    return c if r.reverse_run == true
     case r
     when Interscript::Node::Stage
       c += "Interscript::Maps.add_map_stage \"#{@map.name}\", #{r.name.inspect} do |s|\n"
@@ -66,7 +65,6 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
           raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
           raise ArgumentError, "Can't parallelize rules with :not_after" if i.not_after
 
-          next if i.reverse_run == true
           a << [compile_item(i.from, map, :par), compile_item(i.to, map, :parstr)]
         end
         ah = a.hash.abs
@@ -81,7 +79,6 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
         Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|
           raise ArgumentError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
 
-          next if i.reverse_run == true
           a << [build_regexp(i, map), compile_item(i.to, map, :parstr)]
         end
         ah = a.hash.abs
@@ -95,8 +92,6 @@ class Interscript::Compiler::Ruby < Interscript::Compiler
       from = "/#{build_regexp(r, map).gsub("/", "\\\\/")}/"
       if r.to == :upcase
         to = '&:upcase'
-      elsif r.to == :downcase
-        to = '&:downcase'
       else
         to = compile_item(r.to, map, :str)
       end

data/lib/interscript/dsl/document.rb

@@ -37,11 +37,10 @@ class Interscript::DSL::Document
     @node.dep_aliases[dep.name] = dep if dep.name
   end
 
-  def stage(name = :main, dont_reverse: false, &block)
+  def stage(name = :main, &block)
     puts "stage(#{name}) from #{self.inspect}" if $DEBUG
     stage = Interscript::DSL::Stage.new(name, &block)
     stage.node.doc_name = @node.name
-    stage.node.dont_reverse = dont_reverse
     @node.stages[name] = stage.node
   end
 end

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

@@ -1,6 +1,6 @@
 class Interscript::DSL::Group::Parallel < Interscript::DSL::Group
-  def initialize(reverse_run: nil, &block)
-    @node = Interscript::Node::Group::Parallel.new(reverse_run: reverse_run)
+  def initialize(&block)
+    @node = Interscript::Node::Group::Parallel.new
     self.instance_exec(&block)
   end
 end

data/lib/interscript/dsl/group.rb

@@ -8,16 +8,16 @@ class Interscript::DSL::Group
     self.instance_exec(&block)
   end
 
-  def run(stage, **kwargs)
+  def run(stage)
     if stage.class != Interscript::Node::Item::Stage
       raise TypeError, "I::Node::Item::Stage expected, got #{stage.class}"
     end
-    @node.children << Interscript::Node::Rule::Run.new(stage, **kwargs)
+    @node.children << Interscript::Node::Rule::Run.new(stage)
   end
 
   def sub(from, to, **kwargs, &block)
-    puts "sub(#{from.inspect},#{to}, kwargs = #{
-      kwargs.inspect
+    puts "sub(#{from.inspect},#{to}, kargs = #{
+      kargs.inspect
     }) from #{self.inspect}" if $DEBUG
 
     rule = Interscript::Node::Rule::Sub.new(from, to, **kwargs)
@@ -25,7 +25,6 @@ class Interscript::DSL::Group
   end
 
   def upcase; :upcase; end
-  def downcase; :downcase; end
 
   Interscript::Stdlib.available_functions.each do |fun|
     define_method fun do |**kwargs|
@@ -36,9 +35,9 @@ class Interscript::DSL::Group
     end
   end
 
-  def parallel(**kwargs, &block)
+  def parallel(&block)
     puts "parallel(#{chars.inspect}) from #{self.inspect}" if $DEBUG
-    group = Interscript::DSL::Group::Parallel.new(**kwargs, &block)
+    group = Interscript::DSL::Group::Parallel.new(&block)
     @node.children << group.node
   end
 end

data/lib/interscript/dsl/tests.rb

@@ -6,7 +6,7 @@ class Interscript::DSL::Tests
     self.instance_exec(&block)
   end
 
-  def test(from, to, reverse_run: nil)
-    @node << [from, to, reverse_run]
+  def test(from,to)
+    @node << [from, to]
   end
 end

data/lib/interscript/dsl.rb

@@ -2,45 +2,12 @@ require "yaml"
 
 module Interscript::DSL
   @cache = {}
-  def self.parse(map_name, reverse: true)
+  def self.parse(map_name)
     # map name aliases? here may be a place to wrap it
 
     return @cache[map_name] if @cache[map_name]
-
-    # This is a composition, so let's make a new virtual map
-    # that calls all maps in a sequence.
-    if map_name.include? "|"
-      map_parts = map_name.split("|").map(&:strip)
-
-      doc = Interscript::DSL::Document.new(map_name) do
-        map_parts.each_with_index do |i, idx|
-          dependency i, as: :"part#{idx}"
-        end
-
-        stage {
-          map_parts.each_with_index do |i, idx|
-            run map[:"part#{idx}"].stage.main
-          end
-        }
-      end.node
-
-      return @cache[map_name] = doc
-    end
-
-    path = begin
-      Interscript.locate(map_name)
-    rescue Interscript::MapNotFoundError => e
-      # But maybe we called the map in a reversed fashion?
-      begin
-        raise e if reverse == false # Protect from an infinite loop
-        reverse_name = Interscript::Node::Document.reverse_name(map_name)
-        return @cache[map_name] = parse(reverse_name, reverse: false).reverse
-      rescue Interscript::MapNotFoundError
-        raise e
-      end
-    end
+    path = Interscript.locate(map_name)
     library = path.end_with?(".iml")
-
     map_name = File.basename(path, ".imp")
     map_name = File.basename(map_name, ".iml")
 

data/lib/interscript/interpreter.rb

@@ -76,7 +76,6 @@ class Interscript::Interpreter < Interscript::Compiler
     end
 
     def execute_rule r
-      return if r.reverse_run == true
       case r
       when Interscript::Node::Group::Parallel
         if r.cached_tree
@@ -97,7 +96,6 @@ class Interscript::Interpreter < Interscript::Compiler
               raise ArgumentError, "Can't parallelize rules with :after" if i.after
               raise ArgumentError, "Can't parallelize rules with :not_before" if i.not_before
               raise ArgumentError, "Can't parallelize rules with :not_after" if i.not_after
-              next if i.reverse_run == true
               subs_array << [build_item(i.from, :par), build_item(i.to, :parstr)]
             end
             tree = Interscript::Stdlib.parallel_replace_compile_tree(subs_array) #.sort_by{|k,v| -k.length})
@@ -110,7 +108,7 @@ class Interscript::Interpreter < Interscript::Compiler
             subs_array = []
             Interscript::Stdlib.deterministic_sort_by_max_length(r.children).each do |i|  # rule.from.max_length gives somewhat better test results, why is that
               raise ArgumentError, "Can't parallelize #{i.class}" unless Interscript::Node::Rule::Sub === i
-              next if i.reverse_run == true
+
               subs_array << [build_regexp(i), build_item(i.to, :parstr)]
             end
             r.subs_regexp = Interscript::Stdlib.parallel_regexp_compile(subs_array)
@@ -131,8 +129,6 @@ class Interscript::Interpreter < Interscript::Compiler
       when Interscript::Node::Rule::Sub
         if r.to == :upcase
           @str = @str.gsub(Regexp.new(build_regexp(r)), &:upcase)
-        elsif r.to == :downcase
-          @str = @str.gsub(Regexp.new(build_regexp(r)), &:downcase)
         else
           @str = @str.gsub(Regexp.new(build_regexp(r)), build_item(r.to, :str))
         end

data/lib/interscript/node/alias_def.rb

@@ -7,12 +7,6 @@ class Interscript::Node::AliasDef < Interscript::Node
     @data = data
   end
 
-  def ==(other)
-    super &&
-    self.name == other.name &&
-    self.data == other.data
-  end
-
   def to_hash
     { :class => self.class.to_s,
       :name => @name,

data/lib/interscript/node/dependency.rb

@@ -4,22 +4,6 @@ class Interscript::Node::Dependency < Interscript::Node
   def initialize
   end
 
-  def reverse
-    rdep = self.class.new
-    rdep.name = name
-    rdep.full_name = Interscript::Node::Document.reverse_name(full_name)
-    rdep.import = import
-    rdep.document = document&.reverse
-    rdep
-  end
-
-  def ==(other)
-    super &&
-    self.full_name == other.full_name &&
-    self.import == other.import &&
-    self.name == other.name
-  end
-
   def to_hash
     { :class => self.class.to_s,
       :name => @name,

data/lib/interscript/node/document.rb

@@ -1,7 +1,6 @@
 class Interscript::Node::Document
   attr_accessor :metadata, :tests, :name
   attr_accessor :dependencies, :aliases, :stages, :dep_aliases
-  attr_accessor :reversed_from
 
   def initialize
     puts "Interscript::Node::Document.new " if $DEBUG
@@ -35,39 +34,6 @@ class Interscript::Node::Document
     end
   end
 
-  def reverse
-    @reverse ||= self.class.new.tap do |rdoc|
-      rdoc.name = self.class.reverse_name(name)
-      rdoc.metadata = metadata&.reverse
-      rdoc.tests = tests&.reverse
-      rdoc.dependencies = dependencies.map(&:reverse)
-      rdoc.stages = stages.transform_values(&:reverse)
-      rdoc.dep_aliases = dep_aliases.transform_values(&:reverse)
-      rdoc.aliases = aliases
-    end
-  end
-
-  def self.reverse_name(name)
-    newname = (name || "noname").split("-")
-    newname[2], newname[3] = newname[3], newname[2] if newname.length >= 4
-    newname = newname.join("-")
-    if newname == name
-      newname.gsub!("-reverse", "")
-    end
-    if newname == name
-      newname += "-reverse"
-    end
-    newname
-  end
-
-  def ==(other)
-    self.class == other.class &&
-    self.metadata == other.metadata &&
-    self.tests == other.tests &&
-    self.stages == other.stages &&
-    self.aliases == other.aliases
-  end
-
   def to_hash
     { :class => self.class.to_s, :metadata => @metadata&.to_hash,
       :tests => @tests&.to_hash,

data/lib/interscript/node/group.rb

@@ -1,8 +1,7 @@
 class Interscript::Node::Group < Interscript::Node
-  attr_accessor :children, :reverse_run
+  attr_accessor :children
 
-  def initialize(reverse_run: nil)
-    @reverse_run = reverse_run
+  def initialize
     @children = []
   end
 
@@ -21,21 +20,11 @@ class Interscript::Node::Group < Interscript::Node
     self
   end
 
-  def reverse
-    self.class.new(reverse_run: reverse_run.nil? ? nil : !reverse_run).tap do |r|
-      r.children = self.children.reverse.map(&:reverse)
-    end
-  end
-
   def to_hash
     { :class => self.class.to_s,
       :children => @children.map{|x| x.to_hash} }
   end
 
-  def ==(other)
-    super && self.children == other.children && self.reverse_run == other.reverse_run
-  end
-
   def inspect
     @children.map(&:inspect).join("\n").gsub(/^/, "  ")
   end

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

@@ -10,10 +10,6 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     !map && Interscript::Stdlib::ALIASES.has_key?(name)
   end
 
-  def boundary_like?
-    Interscript::Stdlib.boundary_like_alias?(name)
-  end
-
   def max_length
     if stdlib?
       ([:none].include? name) ? 0 : 1
@@ -23,10 +19,6 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     end
   end
 
-  # Not implemented properly
-  def downcase; self; end
-  def upcase; self; end
-
   def first_string
     self
   end
@@ -40,10 +32,6 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
     }
   end
 
-  def ==(other)
-    super && self.name == other.name && self.map == other.map
-  end
-
   def inspect
     if map
       "map.#{map}.#{name}"

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

@@ -25,9 +25,6 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
     end
   end
 
-  def downcase; self.class.new(self.data.map(&:downcase)); end
-  def upcase; self.class.new(self.data.map(&:upcase)); end
-
   def first_string
     case @value
     when Array
@@ -73,10 +70,6 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
     hash
   end
 
-  def ==(other)
-    super && self.data == other.data
-  end
-
   def inspect
     "any(#{value.inspect})"
   end

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

@@ -15,18 +15,11 @@ class Interscript::Node::Item::CaptureGroup < Interscript::Node::Item
     data.nth_string
   end
 
-  def downcase; self.dup.tap { |i| i.data = i.data.downcase }; end
-  def upcase; self.dup.tap { |i| i.data = i.data.upcase }; end
-
   def to_hash
     { :class => self.class.to_s,
       :data => self.data.to_hash }
   end
 
-  def ==(other)
-    super && self.data == other.data
-  end
-
   def inspect
     "capture(#{@data.inspect})"
   end
@@ -51,10 +44,6 @@ class Interscript::Node::Item::CaptureRef < Interscript::Node::Item
       :id => self.id }
   end
 
-  def ==(other)
-    super && self.id == other.id
-  end
-
   def inspect
     "ref(#{@id.inspect})"
   end

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

@@ -10,35 +10,11 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
   def +(item)
     item = Interscript::Node::Item.try_convert(item)
     out = self.dup
-    if Interscript::Node::Item::Group === item
-      out.children += item.children
-    else
-      out.children << item
-    end
+    out.children << item
     out.verify!
     out
   end
 
-  def compact
-    out = self.dup do |n|
-      n.children = n.children.reject do |i|
-        (Interscript::Node::Alias === i && i.name == :none) ||
-        (Interscript::Node::String === i && i.data == "")
-      end
-    end
-
-    if out.children.count == 0
-      Interscript::Node::Alias.new(:none)
-    elsif out.children.count == 1
-      out.children.first
-    else
-      out
-    end
-  end
-
-  def downcase; self.dup.tap { |i| i.children = i.children.map(&:downcase) }; end
-  def upcase; self.dup.tap { |i| i.children = i.children.map(&:upcase) }; end
-
   # Verify if a group is valid
   def verify!
     wrong = @children.find do |i|
@@ -69,10 +45,6 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
       :children => self.children.map{|x| x.to_hash} }
   end
 
-  def ==(other)
-    super && self.children == other.children
-  end
-
   def inspect
     @children.map(&:inspect).join("+")
   end

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

@@ -22,10 +22,6 @@ class Interscript::Node::Item::Repeat < Interscript::Node::Item
       :data => self.data.to_hash }
   end
 
-  def ==(other)
-    super && self.data == other.data
-  end
-
   def inspect
     str = case self
     when Interscript::Node::Item::Maybe

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

@@ -13,10 +13,6 @@ class Interscript::Node::Item::Stage < Interscript::Node::Item
     }
   end
 
-  def ==(other)
-    super && self.name == other.name && self.map == other.map
-  end
-
   def inspect
     if map
       "map.#{@map}.stage.#{@name}"

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

@@ -17,9 +17,6 @@ class Interscript::Node::Item::String < Interscript::Node::Item
     self.data
   end
 
-  def downcase; self.dup.tap { |i| i.data = i.data.downcase }; end
-  def upcase; self.dup.tap { |i| i.data = i.data.upcase }; end
-
   alias nth_string first_string
 
   def + other
@@ -36,10 +33,6 @@ class Interscript::Node::Item::String < Interscript::Node::Item
     end
   end
 
-  def ==(other)
-    super && self.data == other.data
-  end
-
   def inspect
     @data.inspect
   end

data/lib/interscript/node/item.rb

@@ -36,10 +36,6 @@ class Interscript::Node::Item < Interscript::Node
       :item => self.item }
   end
 
-  def ==(other)
-    super
-  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

data/lib/interscript/node/metadata.rb

@@ -11,16 +11,6 @@ class Interscript::Node::MetaData < Interscript::Node
     @data[k]
   end
 
-  def reverse
-    self.class.new(data.dup, **{}).tap do |rmd|
-      rmd[:source_script], rmd[:destination_script] = rmd[:destination_script], rmd[:source_script]
-    end
-  end
-
-  def ==(other)
-    super && self.data == other.data
-  end
-
   def to_hash
     {:class => self.class.to_s,
       :data => @data}

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

@@ -1,8 +1,7 @@
 class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
-  attr_accessor :name, :kwargs, :reverse_run
-  def initialize name, reverse_run: nil, **kwargs
+  attr_accessor :name, :kwargs
+  def initialize name, **kwargs
     @name = name
-    @reverse_run = reverse_run
     @kwargs = kwargs
   end
 
@@ -13,15 +12,6 @@ class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
     }
   end
 
-  def reverse
-    self.class.new(Interscript::Stdlib.reverse_function[@name.to_sym],
-      reverse_run: reverse_run.nil? ? nil : !reverse_run, **kwargs)
-  end
-
-  def ==
-    super && self.name == other.name && self.kwargs == other.kwargs
-  end
-
   def inspect
     "#{@name} #{kwargs.inspect[1..-2]}"
   end