interscript 2.4.5 → 3.0.0

data/lib/interscript/utils/helpers.rb

@@ -1,6 +1,8 @@
+# rubocop:disable Style/GlobalVars
+# spec-support globals; deliberate process-level state
 module Interscript::Utils
   module Helpers
-    def document name=nil, &block
+    def document name = nil, &block
       $example_id ||= 0
       $example_id += 1
       name ||= "example-#{$example_id}"
@@ -20,14 +22,14 @@ module Interscript::Utils
 end
 
 class Interscript::Node::Document
-  def call(str, stage=:main, compiler=$compiler || Interscript::Interpreter, **kwargs)
-    compiler.(self).(str, stage, **kwargs)
+  def call(str, stage = :main, compiler = $compiler || Interscript::Interpreter, **kwargs)
+    compiler.call(self).call(str, stage, **kwargs)
   end
 end
 
 module Interscript::DSL
   class << self
-    alias original_parse parse
+    alias_method :original_parse, :parse
     def parse(map_name, **kwargs)
       if $documents && $documents[map_name]
         $documents[map_name]
@@ -36,4 +38,5 @@ module Interscript::DSL
       end
     end
   end
-end
+end
+# rubocop:enable Style/GlobalVars

data/lib/interscript/utils/regexp_converter.rb

@@ -1,81 +1,80 @@
-require 'regexp_parser'
-
+require "regexp_parser"
 
 def process(node)
   children = if node.respond_to?(:expressions) && node.expressions
-               children = node.expressions.map.each { |expr| process(expr) }
-             end
+    node.expressions.map.each { |expr| process(expr) }
+  end
   # puts node.inspect
   out = case node
-        when Regexp::Expression::Root
-          children
-        when Regexp::Expression::Assertion::Lookbehind
-          [:lookbehind_start, children, :lookbehind_stop]
-        when Regexp::Expression::Assertion::NegativeLookbehind
-          [:negative_lookbehind_start, children, :negative_lookbehind_stop]
-        when Regexp::Expression::Assertion::Lookahead
-          [:lookahead_start, children, :lookahead_stop]
-        when Regexp::Expression::Assertion::NegativeLookahead
-          [:negative_lookahead_start, children, :negative_lookahead_stop]
-        when Regexp::Expression::Group::Capture
-          [:capture_start, children, :capture_stop]
-        when Regexp::Expression::CharacterSet
-          # puts children.inspect
-          if children.flatten.include? (:range_start) #or children.size > 1
-            [:characterset_start, :array_start, children, :array_stop, :characterset_stop]
-          else
-            [:characterset_start, children, :characterset_stop]
-          end
-        when Regexp::Expression::Alternation
-          [:alternation_start, children, :alternation_stop]
-        when Regexp::Expression::Alternative
-          [:alternative_start, children, :alternative_stop]
-        when Regexp::Expression::CharacterSet::Range
-          lit1 = node.expressions[0].text
-          lit2 = node.expressions[1].text
-          [:range_start, lit1, :range_mid, lit2, :range_stop]
-        when Regexp::Expression::Anchor::WordBoundary
-          :boundary
-        when Regexp::Expression::Anchor::NonWordBoundary
-          :non_word_boundary
-        when Regexp::Expression::EscapeSequence::Backspace
-          :boundary # most probably boundary
-        when Regexp::Expression::CharacterType::Space
-          :space
-        when Regexp::Expression::Anchor::BeginningOfLine
-          :line_start
-        when Regexp::Expression::Anchor::EndOfLine
-          :line_end
-        when Regexp::Expression::CharacterType::Any
-          :any_character
-        when Regexp::Expression::Literal
-          node.text
-        when Regexp::Expression::EscapeSequence::Literal
-          node.text
-        when Regexp::Expression::EscapeSequence::Codepoint
-          node.text
-        when Regexp::Expression::PosixClass
-          '[' + node.text + ']'
-        when Regexp::Expression::UnicodeProperty::Script
-          node.text
-        when Regexp::Expression::Backreference::Number # why is there a space before after node.number?
-          [:backref_num_start, node.number, :backref_num_stop]
-        else
-          out = [:missing, node.class]
+  when Regexp::Expression::Root
+    children
+  when Regexp::Expression::Assertion::Lookbehind
+    [:lookbehind_start, children, :lookbehind_stop]
+  when Regexp::Expression::Assertion::NegativeLookbehind
+    [:negative_lookbehind_start, children, :negative_lookbehind_stop]
+  when Regexp::Expression::Assertion::Lookahead
+    [:lookahead_start, children, :lookahead_stop]
+  when Regexp::Expression::Assertion::NegativeLookahead
+    [:negative_lookahead_start, children, :negative_lookahead_stop]
+  when Regexp::Expression::Group::Capture
+    [:capture_start, children, :capture_stop]
+  when Regexp::Expression::CharacterSet
+    # puts children.inspect
+    if children.flatten.include?(:range_start) # or children.size > 1
+      [:characterset_start, :array_start, children, :array_stop, :characterset_stop]
+    else
+      [:characterset_start, children, :characterset_stop]
+    end
+  when Regexp::Expression::Alternation
+    [:alternation_start, children, :alternation_stop]
+  when Regexp::Expression::Alternative
+    [:alternative_start, children, :alternative_stop]
+  when Regexp::Expression::CharacterSet::Range
+    lit1 = node.expressions[0].text
+    lit2 = node.expressions[1].text
+    [:range_start, lit1, :range_mid, lit2, :range_stop]
+  when Regexp::Expression::Anchor::WordBoundary
+    :boundary
+  when Regexp::Expression::Anchor::NonWordBoundary
+    :non_word_boundary
+  when Regexp::Expression::EscapeSequence::Backspace
+    :boundary # most probably boundary
+  when Regexp::Expression::CharacterType::Space
+    :space
+  when Regexp::Expression::Anchor::BeginningOfLine
+    :line_start
+  when Regexp::Expression::Anchor::EndOfLine
+    :line_end
+  when Regexp::Expression::CharacterType::Any
+    :any_character
+  when Regexp::Expression::Literal
+    node.text
+  when Regexp::Expression::EscapeSequence::Literal
+    node.text
+  when Regexp::Expression::EscapeSequence::Codepoint
+    node.text
+  when Regexp::Expression::PosixClass
+    "[" + node.text + "]"
+  when Regexp::Expression::UnicodeProperty::Script
+    node.text
+  when Regexp::Expression::Backreference::Number # why is there a space before after node.number?
+    [:backref_num_start, node.number, :backref_num_stop]
+  else
+    out = [:missing, node.class]
 
-          out << children if node.respond_to? :expressions
-           if node.respond_to? :quantifier and node.quantifier
-            # TODO add quantifier support
-            pp node
-            # out << process(node.quantifier)
-          end
-          out
-        end
+    out << children if node.respond_to? :expressions
+    if node.respond_to?(:quantifier) && node.quantifier
+      # TODO add quantifier support
+      pp node
+      # out << process(node.quantifier)
+    end
+    out
+  end
   if node.respond_to?(:quantifier) && node.quantifier&.token.to_s == "interval" && node.quantifier.max == node.quantifier.min
     out = [out] * node.quantifier.max
   elsif node.respond_to?(:quantifier) && node.quantifier
     qname = node.quantifier.token.to_s
-    out = ["#{qname}_start".to_sym, [out], "#{qname}_stop".to_sym]
+    out = [:"#{qname}_start", [out], :"#{qname}_stop"]
   end
   out
 end
@@ -83,76 +82,76 @@ end
 def process_root(node)
   node2 = node.dup
   root = {}
-  if before = node.select { |x| x[0] == :lookbehind_start }
+  if (before = node.select { |x| x[0] == :lookbehind_start })
     # root[:before] = before[1]
     # node2.delete(before)
     if before.size == 1
       root[:before] = before[0][1]
       node2.delete(before[0])
-    elsif before.size >1
+    elsif before.size > 1
       # pp not_before
 
       a = [:alternation_start]
-      a << before.map{|x| [:alternative_start, x[1], :alternative_stop] }
+      a << before.map { |x| [:alternative_start, x[1], :alternative_stop] }
       a << [:alternation_stop]
       root[:before] = a
       # pp root[:not_before]
-      before.each{|n| node2.delete(n)}
+      before.each { |n| node2.delete(n) }
     end
 
   end
-  if not_before = node.select { |x| x[0] == :negative_lookbehind_start }
+  if (not_before = node.select { |x| x[0] == :negative_lookbehind_start })
     # root[:not_before] = not_before[1]
     # node2.delete(not_before)
 
     if not_before.size == 1
       root[:not_before] = not_before[0][1]
       node2.delete(not_before[0])
-    elsif not_before.size >1
+    elsif not_before.size > 1
       # pp not_before
 
       a = [:alternation_start]
-      a << not_before.map{|x| [:alternative_start, x[1], :alternative_stop] }
+      a << not_before.map { |x| [:alternative_start, x[1], :alternative_stop] }
       a << [:alternation_stop]
       root[:not_before] = a
       # pp root[:not_before]
-      not_before.each{|n| node2.delete(n)}
+      not_before.each { |n| node2.delete(n) }
     end
   end
-  if after = node.select { |x| x[0] == :lookahead_start }
+  if (after = node.select { |x| x[0] == :lookahead_start })
     # root[:after] = after[1]
     # node2.delete(after)
 
     if after.size == 1
       root[:after] = after[0][1]
       node2.delete(after[0])
-    elsif after.size >1
+    elsif after.size > 1
       # pp not_before
 
       a = [:alternation_start]
-      a << after.map{|x| [:alternative_start, x[1], :alternative_stop] }
+      a << after.map { |x| [:alternative_start, x[1], :alternative_stop] }
       a << [:alternation_stop]
       root[:after] = a
       # pp root[:not_before]
-      after.each{|n| node2.delete(n)}
+      after.each { |n| node2.delete(n) }
     end
 
   end
-  if not_after = node.select { |x| x[0] == :negative_lookahead_start }
+  if (not_after = node.select { |x| x[0] == :negative_lookahead_start })
     # root[:not_after] = not_after[1]
     # node2.delete(not_after)
     if not_after.size == 1
       root[:not_after] = not_after[0][1]
       node2.delete(not_after[0])
-    elsif not_after.size >1
+    elsif not_after.size > 1
       # pp not_after
 
       a = [:alternation_start]
-      a << not_after.map{|x| [:alternative_start, x[1], :alternative_stop] }
+      a << not_after.map { |x| [:alternative_start, x[1], :alternative_stop] }
       a << [:alternation_stop]
       root[:not_after] = a
       # pp root[:not_after]
-      not_after.each{|n| node2.delete(n)}
+      not_after.each { |n| node2.delete(n) }
     end
 
   end
@@ -163,57 +162,57 @@ end
 def stringify(node)
   tokens = node.flatten
   subs = {
-    characterset_start: 'any(',
-    characterset_stop: ')',
-    array_start: '[',
-    array_stop: ']',
-    capture_start: 'capture(',
-    capture_stop: ')',
-    zero_or_one_start: 'maybe(',
-    zero_or_one_stop: ')',
-    zero_or_more_start: 'maybe_some(',
-    zero_or_more_stop: ')',
-    one_or_more_start: 'some(',
-    one_or_more_stop: ')',
-    alternation_start: 'any([',
-    alternation_stop: '])',
-    alternative_start: '',
-    alternative_stop: '',
-    boundary: 'boundary',
-    non_word_boundary: 'non_word_boundary',
-    space: 'space',
-    line_start: 'line_start',
-    line_end: 'line_end',
-    any_character: 'any_character',
-    range_start: 'any(',
-    range_mid: '..',
-    range_stop: ')',
-    backref_num_start: 'ref(',
-    backref_num_stop: ')'
+    characterset_start: "any(",
+    characterset_stop: ")",
+    array_start: "[",
+    array_stop: "]",
+    capture_start: "capture(",
+    capture_stop: ")",
+    zero_or_one_start: "maybe(",
+    zero_or_one_stop: ")",
+    zero_or_more_start: "maybe_some(",
+    zero_or_more_stop: ")",
+    one_or_more_start: "some(",
+    one_or_more_stop: ")",
+    alternation_start: "any([",
+    alternation_stop: "])",
+    alternative_start: "",
+    alternative_stop: "",
+    boundary: "boundary",
+    non_word_boundary: "non_word_boundary",
+    space: "space",
+    line_start: "line_start",
+    line_end: "line_end",
+    any_character: "any_character",
+    range_start: "any(",
+    range_mid: "..",
+    range_stop: ")",
+    backref_num_start: "ref(",
+    backref_num_stop: ")"
   }
 
   str = []
   tokens.each_with_index do |token, idx|
     prev = tokens[idx - 1] if idx > 0
     left_side = %i[characterset_stop capture_stop
-           zero_or_one_stop zero_or_more_stop one_or_more_stop
-           boundary non_word_boundary
-           line_start any_character range_stop space
-                                           backref_num_stop]
+      zero_or_one_stop zero_or_more_stop one_or_more_stop
+      boundary non_word_boundary
+      line_start any_character range_stop space
+      backref_num_stop]
     right_side = %i[characterset_start capture_start
-            zero_or_one_start zero_or_more_start one_or_more_start
-            boundary non_word_boundary
-            line_end any_character range_start space
-                                       backref_num_start]
-    #if prev==:range_stop and token==:range_start
+      zero_or_one_start zero_or_more_start one_or_more_start
+      boundary non_word_boundary
+      line_end any_character range_start space
+      backref_num_start]
+    # if prev==:range_stop and token==:range_start
     #  str << ' :adding_ranges '
-    #end
-    if (prev.instance_of?(String) && right_side.include?(token)) or
-      (left_side.include?(prev) && token.instance_of?(String)) or
-      (left_side.include?(prev) && right_side.include?(token))
-      str << ' + '
+    # end
+    if (prev.instance_of?(String) && right_side.include?(token)) ||
+        (left_side.include?(prev) && token.instance_of?(String)) ||
+        (left_side.include?(prev) && right_side.include?(token))
+      str << " + "
     end
-    str << ', ' if prev == :alternative_stop and token == :alternative_start
+    str << ", " if prev == :alternative_stop && token == :alternative_start
     # str << '[' if prev == :characterset_start and token == :range_start
     # str << ']' if prev == :range_stop and token ==:characterset_stop
     if subs.include? token
@@ -234,48 +233,48 @@ def stringify(node)
 end
 
 def stringify_root(root, indent: 0)
-  warning = ''
+  warning = ""
   root[:from] = [""] if root[:from] == []
-  str = " "*indent+"sub #{stringify(root[:from])}, #{root[:to]}"
+  str = " " * indent + "sub #{stringify(root[:from])}, #{root[:to]}"
   [:before, :not_before, :after, :not_after].each do |look|
     # puts "#{look.inspect} = #{root[look]}"
     next unless root[look]
     str_look = stringify(root[look])
-    str_look = "\"\"" if root[look] == [] || root[look] == nil
-    #if str_look.empty?  #apparently it is empty sometimes. iso-mal-Mlym-Latn for example
+    str_look = "\"\"" if root[look] == [] || root[look].nil?
+    # if str_look.empty?  #apparently it is empty sometimes. iso-mal-Mlym-Latn for example
     #  warning << "warning: #{look} is empty string;"
-    #else
-      str << ", #{look}: #{str_look}"
-    #end
+    # else
+    str << ", #{look}: #{str_look}"
+    # end
   end
-  str = " "*indent+"# #{str} # warning: :" if str =~ /[^\[]:[^ \]]/
-  str = " "*indent+"# #{str} # #{warning}" if !warning.empty?
+  str = " " * indent + "# #{str} # warning: :" if /[^\[]:[^ \]]/.match?(str)
+  str = " " * indent + "# #{str} # #{warning}" if !warning.empty?
 
-  str = " "*indent+"# #{str} # warning: :missing unimplemented" if str.include?(':missing')
-  str = " "*indent+"# #{str} # warning: :interval unimplemented" if str.include?(':interval')
-  str = " "*indent+"# #{str} # warning: :adding_ranges unimplemented" if str.include?(':adding_ranges')
-  if str.include?('zero_or_one')
-    str = " "*indent+"# #{str} # warning: zero_or_one"
+  str = " " * indent + "# #{str} # warning: :missing unimplemented" if str.include?(":missing")
+  str = " " * indent + "# #{str} # warning: :interval unimplemented" if str.include?(":interval")
+  str = " " * indent + "# #{str} # warning: :adding_ranges unimplemented" if str.include?(":adding_ranges")
+  if str.include?("zero_or_one")
+    str = " " * indent + "# #{str} # warning: zero_or_one"
     puts "str.includes 'zero_or_one'"
     pp root
   end
   # str = " "*indent+"# #{str} # warning: one_or_more" if str.include?('one_or_more')
-   str = " "*indent+"# #{str} # warning: :lookahead_start" if str.include?(':lookahead_start')
+  str = " " * indent + "# #{str} # warning: :lookahead_start" if str.include?(":lookahead_start")
   # str += " # original: #{root[:from]}"
   str
 end
 
 if __FILE__ == $0
-  rs = File.open(__dir__+"/../../docs/utils/regexp_examples.txt").read.gsub(/([^\\^])\\u/, '\\1\\\\u').gsub(/\\\\b/, '\b')
+  rs = File.read(__dir__ + "/../../docs/utils/regexp_examples.txt").gsub(/([^\\^])\\u/, '\\1\\\\u').gsub("\\\\b", '\b')
   rs = rs.split("\n")
   rs.each do |r|
     puts r
-    tree = Regexp::Parser.parse(r, 'ruby/2.1')
+    tree = Regexp::Parser.parse(r, "ruby/2.1")
     conv = process(tree)
     pp conv
     root = process_root(conv)
     pp root
-    root[:to] = ['X']
+    root[:to] = ["X"]
     str = stringify_root(root)
     puts str
     puts "\n\n"

data/lib/interscript/version.rb

@@ -1,3 +1,3 @@
 module Interscript
-  VERSION = "2.4.5"
+  VERSION = "3.0.0"
 end

data/lib/interscript/visualize/json.rb

@@ -1,8 +1,8 @@
 class Interscript::Node::Group
-  def to_visualization_array(map=self)
+  def to_visualization_array(map = self)
     out = []
 
-    self.children.each do |rule|
+    children.each do |rule|
       case rule
       when Interscript::Node::Rule::Sub
         more = []
@@ -16,7 +16,7 @@ class Interscript::Node::Group
         out << {
           type: "Replace",
           from: rule.from.to_html(map),
-          to: Symbol === rule.to ? rule.to : rule.to.to_html(map),
+          to: (Symbol === rule.to) ? rule.to : rule.to.to_html(map),
           more: more
         }
       when Interscript::Node::Group::Parallel
@@ -25,22 +25,21 @@ 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}"
+        more = rule.kwargs.map do |k, v|
+          "#{k.to_s.tr("_", " ")}: #{v}"
         end
         more << "<nobr>reverse run:</nobr> #{rule.reverse_run}" unless rule.reverse_run.nil?
 
         out << {
-          type: rule.name.to_s.gsub("_", " ").gsub(/^(.)/, &:upcase),
+          type: rule.name.to_s.tr("_", " ").gsub(/^(.)/, &:upcase),
           more: more.join(", ")
         }
       when Interscript::Node::Rule::Run
-        if rule.stage.map
-          doc = map.dep_aliases[rule.stage.map].document
-          stage = rule.stage.name
+        stage = rule.stage.name
+        doc = if rule.stage.map
+          map.dep_aliases[rule.stage.map].document
         else
-          doc = map
-          stage = rule.stage.name
+          map
         end
 
         more = []
@@ -50,7 +49,7 @@ class Interscript::Node::Group
           type: "Run",
           doc: doc.name,
           stage: stage,
-          more: more.join(", "),
+          more: more.join(", ")
         }
       else
         out << {
@@ -62,4 +61,4 @@ class Interscript::Node::Group
 
     out
   end
-end
+end

data/lib/interscript/visualize/nodes.rb

@@ -3,9 +3,9 @@ class Interscript::Node::Item
     def to_html(doc)
       if map
         n = doc.dep_aliases[map].full_name
-        "#{name.to_s.gsub("_", " ")} from map #{n}"
+        "#{name.tr("_", " ")} from map #{n}"
       else
-        "#{name.to_s.gsub("_", " ")}"
+        name.to_s.tr("_", " ")
       end
     end
   end
@@ -14,9 +14,9 @@ class Interscript::Node::Item
     def to_html(doc)
       if map
         n = doc.dep_aliases[map].full_name
-        "stage #{name.to_s.gsub("_", " ")} from map #{n}"
+        "stage #{name.tr("_", " ")} from map #{n}"
       else
-        "#{name.to_s.gsub("_", " ")}"
+        name.to_s.tr("_", " ")
       end
     end
   end
@@ -26,15 +26,15 @@ class Interscript::Node::Item
       "<nobr>any (</nobr>" +
         case @value
         when Array
-          value.map(&Interscript::Node::Item.method(:try_convert)).map{|i|i.to_html(doc)}.join(", ")
+          value.map(&Interscript::Node::Item.method(:try_convert)).map { |i| i.to_html(doc) }.join(", ")
         when ::String
-          value.split("").map(&Interscript::Node::Item.method(:try_convert)).map{|i|i.to_html(doc)}.join(", ")
+          value.chars.map(&Interscript::Node::Item.method(:try_convert)).map { |i| i.to_html(doc) }.join(", ")
         when Range
-          [value.begin, value.end].map(&Interscript::Node::Item.method(:try_convert)).map{|i|i.to_html(doc)}.join(" to ")
+          [value.begin, value.end].map(&Interscript::Node::Item.method(:try_convert)).map { |i| i.to_html(doc) }.join(" to ")
         else
           h(value.inspect)
         end +
-      ")"
+        ")"
     end
   end
 
@@ -42,7 +42,7 @@ class Interscript::Node::Item
     def to_html(doc)
       "<nobr>capture group (</nobr>" +
         data.to_html(doc) +
-      ")"
+        ")"
     end
   end
 
@@ -50,13 +50,13 @@ class Interscript::Node::Item
     def to_html(_)
       "<nobr>capture reference (</nobr>" +
         id.to_s +
-      ")"
+        ")"
     end
   end
 
   class Group < self
     def to_html(doc)
-      @children.map{|i|i.to_html(doc)}.join(" + ")
+      @children.map { |i| i.to_html(doc) }.join(" + ")
     end
   end
 
@@ -77,7 +77,7 @@ class Interscript::Node::Item
   class String < self
     def to_html(_)
       out = ""
-      self.data.each_char do |i|
+      data.each_char do |i|
         out << "<ruby>"
         out << "<kbd>#{h i}</kbd>"
         out << "<rt>#{"%04x" % i.ord}</rt>"
@@ -86,4 +86,4 @@ class Interscript::Node::Item
       out
     end
   end
-end
+end