interscript 2.4.5 → 3.0.0

data/lib/interscript/dsl/items.rb

@@ -1,54 +1,60 @@
 module Interscript::DSL::Items
   include Interscript::DSL::SymbolMM
 
+  # standard:disable Style/MissingRespondToMissing (DSL method_missing catches unknown method names by design)
   def method_missing sym, *args, **kwargs, &block
+    # standard:enable Style/MissingRespondToMissing
     super if args.length > 0
     super if kwargs.length > 0
-    super if sym.to_s =~ /[?!=]\z/
-    super unless sym.to_s =~ /\A[\w\d]+\z/
+    super if /[?!=]\z/.match?(sym.to_s)
+    super unless /\A[\w\d]+\z/.match?(sym.to_s)
     super if block_given?
 
     Interscript::Node::Item::Alias.new(sym)
   end
 
   def any(*chars)
-    puts "any(#{chars.inspect}) from #{self.inspect}" if $DEBUG
+    puts "any(#{chars.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::Any.new(*chars)
   end
 
   # a?
   def maybe(*chars)
-    puts "maybe(#{chars.inspect}) from #{self.inspect}" if $DEBUG
+    puts "maybe(#{chars.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::Maybe.new(*chars)
   end
 
   def maybe_some(*chars)
-    puts "maybe_some(#{chars.inspect}) from #{self.inspect}" if $DEBUG
+    puts "maybe_some(#{chars.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::MaybeSome.new(*chars)
   end
 
   def some(*chars)
-    puts "some(#{chars.inspect}) from #{self.inspect}" if $DEBUG
+    puts "some(#{chars.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::Some.new(*chars)
   end
 
   # (...)
   def capture(expr)
-    puts "capture(#{expr.inspect}) from #{self.inspect}" if $DEBUG
+    puts "capture(#{expr.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::CaptureGroup.new(expr)
   end
 
   # \1
   def ref(int)
-    puts "ref(#{int.inspect}) from #{self.inspect}" if $DEBUG
+    puts "ref(#{int.inspect}) from #{inspect}" if $DEBUG
     Interscript::Node::Item::CaptureRef.new(int)
   end
 
   # Implementation of `map.x`
-  def map; Interscript::DSL::Items::Maps; end
+  def map
+    Interscript::DSL::Items::Maps
+  end
 
   # Implementation of `stage.x`
-  def stage; Stages.new; end
+  def stage
+    Stages.new
+  end
 
   # Implementation of `map.x`
   module Maps
@@ -58,32 +64,38 @@ module Interscript::DSL::Items
         Symbol === map or raise Interscript::MapLogicError, "A map name must be a Symbol, not #{alias_name.class}"
         Map.new(map)
       end
-      alias method_missing []
+      alias_method :method_missing, :[]
     end
   end
 
   # Implementation of `map.x.aliasname` and `map.x.stage.stagename`
   class Map
-    def initialize name; @name = name; end
+    def initialize name
+      @name = name
+    end
 
     # Implementation of `map.x.aliasname`
     def [] alias_name
       Symbol === alias_name or raise Interscript::MapLogicError, "An alias name must be a Symbol, not #{alias_name.class}"
       Interscript::Node::Item::Alias.new(alias_name, map: @name)
     end
-    alias method_missing []
+    alias_method :method_missing, :[]
 
     # Implementation of `map.x.stage.stagename`
-    def stage; Stages.new(@name); end
+    def stage
+      Stages.new(@name)
+    end
   end
 
   # Implementation of `map.x.stage.stagename` and `stage.stagename`
   class Stages
-    def initialize map=nil; @map = map; end
+    def initialize map = nil
+      @map = map
+    end
 
     def [] stage
       Interscript::Node::Item::Stage.new(stage, map: @map)
     end
-    alias method_missing []
+    alias_method :method_missing, :[]
   end
 end

data/lib/interscript/dsl/metadata.rb

@@ -1,4 +1,4 @@
-require 'date'
+require "date"
 
 class Interscript::DSL::Metadata
   attr_accessor :node
@@ -7,27 +7,29 @@ class Interscript::DSL::Metadata
     raise Interscript::MapLogicError, "Can't evaluate metadata from Ruby context" unless yaml
     @map_name = map_name
     @node = Interscript::Node::MetaData.new
-    self.instance_exec(&block)
+    instance_exec(&block)
     @node[:nonstandard] = {}
 
-    NECESSARY_KEYS.each do |i|
-      unless @node.data.key? i
-        warn "[#{@map_name}] Necessary key #{i} wasn't defined. Defaulting to an empty string"
-        @node[i] = ""
+    unless library
+      NECESSARY_KEYS.each do |i|
+        unless @node.data.key? i
+          warn "[#{@map_name}] Necessary key #{i} wasn't defined. Defaulting to an empty string"
+          @node[i] = ""
+        end
       end
-    end unless library
+    end
   end
 
-  STANDARD_STRING_KEYS = %i{authority_id id
-  language source_script destination_script
-  name creation_date adoption_date description
-  character source confirmation_date original_description}
+  STANDARD_STRING_KEYS = %i[authority_id id
+    language source_script destination_script
+    name creation_date adoption_date description
+    character source confirmation_date original_description]
 
-  STANDARD_ARRAY_KEYS = %i{notes implementation_notes original_notes url}
+  STANDARD_ARRAY_KEYS = %i[notes implementation_notes original_notes url]
 
-  NONSTANDARD_KEYS = %i{special_rules}
-  
-  NECESSARY_KEYS = %i{name language source_script destination_script}
+  NONSTANDARD_KEYS = %i[special_rules]
+
+  NECESSARY_KEYS = %i[name language source_script destination_script]
 
   STANDARD_STRING_KEYS.each do |sym|
     define_method sym do |stuff|
@@ -35,6 +37,7 @@ class Interscript::DSL::Metadata
       when String, Integer, Date
         @node[sym] = stuff.to_s
       when NilClass
+        nil # accepted silently
       else
         warn "[#{@map_name}] Metadata key #{sym} expects a String, but #{stuff.class} was given"
         @node[sym] = stuff.inspect
@@ -44,9 +47,7 @@ class Interscript::DSL::Metadata
 
   STANDARD_ARRAY_KEYS.each do |sym|
     define_method sym do |stuff|
-      stuff = Array(stuff)
-
-      stuff.map do |i|
+      @node[sym] = Array(stuff).map do |i|
         case i
         when String
           i

data/lib/interscript/dsl/stage.rb

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

data/lib/interscript/dsl/symbol_mm.rb

@@ -1,9 +1,11 @@
 module Interscript::DSL::SymbolMM
+  # standard:disable Style/MissingRespondToMissing (DSL method_missing catches unknown method names by design)
   def method_missing sym, *args, **kwargs, &block
+    # standard:enable Style/MissingRespondToMissing
     super if args.length > 0
     super if kwargs.length > 0
-    super if sym.to_s =~ /[?!=]\z/
-    super unless sym.to_s =~ /\A[\w\d]+\z/
+    super if /[?!=]\z/.match?(sym.to_s)
+    super unless /\A[\w\d]+\z/.match?(sym.to_s)
     super if block_given?
 
     sym.to_sym

data/lib/interscript/dsl/tests.rb

@@ -3,7 +3,7 @@ class Interscript::DSL::Tests
 
   def initialize(&block)
     @node = Interscript::Node::Tests.new
-    self.instance_exec(&block)
+    instance_exec(&block)
   end
 
   def test(from, to, reverse_run: nil)

data/lib/interscript/dsl.rb

@@ -39,9 +39,15 @@ module Interscript::DSL
         raise e
       end
     end
+    # ISC documents route through the ISC parser, not the .imp DSL.
+    # The parse is expensive (the whole grammar over the map) — cache it like
+    # the .imp path does, or every transliterate call re-parses the map.
+    return @cache[map_name] = Interscript::Compiler.parse_isc(path) if path.end_with?(".isc")
+
     library = path.end_with?(".iml")
 
-    map_name = File.basename(path, ".imp")
+    map_name = File.basename(path, ".isc")
+    map_name = File.basename(map_name, ".imp")
     map_name = File.basename(map_name, ".iml")
 
     ruby = []
@@ -52,7 +58,7 @@ module Interscript::DSL
 
     md_reading = false
     md_indent = nil
-    md_inner_indent = nil
+    nil
     file.each do |l|
       if md_reading && l =~ /\A#{md_indent}\}\s*\z/
         md_reading = false
@@ -73,7 +79,7 @@ module Interscript::DSL
     obj = Interscript::DSL::Document.new(map_name)
     obj.instance_eval ruby, exc_fname, 1
 
-    yaml = if yaml =~ /\A\s*\z/
+    yaml = if /\A\s*\z/.match?(yaml)
       {}
     else
       unsafe_load = if YAML.respond_to? :unsafe_load
@@ -85,7 +91,7 @@ module Interscript::DSL
     end
 
     md = Interscript::DSL::Metadata.new(yaml: true, map_name: map_name, library: library) do
-      yaml.each do |k,v|
+      yaml.each do |k, v|
         public_send(k.to_sym, v)
       end
     end
@@ -95,12 +101,14 @@ module Interscript::DSL
   end
 end
 
-require 'interscript/dsl/symbol_mm'
-require 'interscript/dsl/items'
-
-require 'interscript/dsl/document'
-require 'interscript/dsl/group'
-require 'interscript/dsl/stage'
-require 'interscript/dsl/metadata'
-require 'interscript/dsl/tests'
-require 'interscript/dsl/aliases'
+module Interscript::DSL
+  # Autoload all DSL modules (OCP: new DSL section = one autoload).
+  autoload :SymbolMM, "interscript/dsl/symbol_mm"
+  autoload :Items, "interscript/dsl/items"
+  autoload :Document, "interscript/dsl/document"
+  autoload :Group, "interscript/dsl/group"
+  autoload :Stage, "interscript/dsl/stage"
+  autoload :Metadata, "interscript/dsl/metadata"
+  autoload :Tests, "interscript/dsl/tests"
+  autoload :Aliases, "interscript/dsl/aliases"
+end

data/lib/interscript/interpreter.rb

@@ -1,13 +1,12 @@
 class Interscript::Interpreter < Interscript::Compiler
   attr_accessor :map
-  def compile(map, _:nil)
+  def compile(map, _: nil)
     @map = map
     self
   end
 
-  def call(str, stage=:main, each: false, &block)
+  def call(str, stage = :main, each: false, &block)
     stage = @map.stages[stage]
-    s =
     if each
       e = Enumerator.new do |yielder|
         options = []
@@ -20,9 +19,13 @@ class Interscript::Interpreter < Interscript::Compiler
           result = nil
 
           f = Fiber.new do
+            # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
             $select_nth_string = true
+            # standard:enable Style/GlobalVars
             result = Stage.new(@map, str).execute_rule(stage)
+            # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
             $select_nth_string = false
+            # standard:enable Style/GlobalVars
             Fiber.yield(:end)
           end
 
@@ -35,7 +38,7 @@ class Interscript::Interpreter < Interscript::Compiler
             # unsure how it can be handled.
             #
             # This scenario is described in a commented out test.
-            type, value, hash = f.resume
+            _, value, _ = f.resume
             if options_set
               f.resume(choices[i][iter])
             else
@@ -49,7 +52,7 @@ class Interscript::Interpreter < Interscript::Compiler
             options_set = true
 
             opts = options.map { |i| (0...i).to_a }
-            choices = opts[0].product(*opts[1..-1])
+            choices = opts[0].product(*opts[1..])
           end
 
           yielder.yield(result)
@@ -82,10 +85,12 @@ class Interscript::Interpreter < Interscript::Compiler
         if r.cached_tree
           @str = Interscript::Stdlib.parallel_replace_tree(@str, r.cached_tree)
         elsif r.subs_regexp && r.subs_replacements
-          if $DEBUG_RE
-            @str = Interscript::Stdlib.parallel_regexp_gsub_debug(@str, r.subs_regexp, r.subs_replacements)
+          # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
+          @str = if $DEBUG_RE
+            # standard:enable Style/GlobalVars
+            Interscript::Stdlib.parallel_regexp_gsub_debug(@str, r.subs_regexp, r.subs_replacements)
           else
-            @str = Interscript::Stdlib.parallel_regexp_gsub(@str, r.subs_regexp, r.subs_replacements)
+            Interscript::Stdlib.parallel_regexp_gsub(@str, r.subs_regexp, r.subs_replacements)
           end
         else
           begin
@@ -100,7 +105,7 @@ class Interscript::Interpreter < Interscript::Compiler
               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})
+            tree = Interscript::Stdlib.parallel_replace_compile_tree(subs_array) # .sort_by{|k,v| -k.length})
             @str = Interscript::Stdlib.parallel_replace_tree(@str, tree)
             r.cached_tree = tree
             # $using_tree = true
@@ -115,9 +120,13 @@ class Interscript::Interpreter < Interscript::Compiler
             end
             r.subs_regexp = Interscript::Stdlib.parallel_regexp_compile(subs_array)
             r.subs_replacements = subs_array.map(&:last)
+            # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
             if $DEBUG_RE
+              # standard:enable Style/GlobalVars
               # puts subs_array.inspect
+              # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
               $subs_array = subs_array
+              # standard:enable Style/GlobalVars
               @str = Interscript::Stdlib.parallel_regexp_gsub_debug(@str, r.subs_regexp, r.subs_replacements)
             else
               @str = Interscript::Stdlib.parallel_regexp_gsub(@str, r.subs_regexp, r.subs_replacements)
@@ -129,12 +138,12 @@ class Interscript::Interpreter < Interscript::Compiler
           execute_rule(t)
         end
       when Interscript::Node::Rule::Sub
-        if r.to == :upcase
-          @str = @str.gsub(Regexp.new(build_regexp(r)), &:upcase)
+        @str = if r.to == :upcase
+          @str.gsub(Regexp.new(build_regexp(r)), &:upcase)
         elsif r.to == :downcase
-          @str = @str.gsub(Regexp.new(build_regexp(r)), &:downcase)
+          @str.gsub(Regexp.new(build_regexp(r)), &:downcase)
         else
-          @str = @str.gsub(Regexp.new(build_regexp(r)), build_item(r.to, :str))
+          @str.gsub(Regexp.new(build_regexp(r)), build_item(r.to, :str))
         end
       when Interscript::Node::Rule::Funcall
         @str = Interscript::Stdlib::Functions.public_send(r.name, @str, **r.kwargs)
@@ -168,12 +177,12 @@ class Interscript::Interpreter < Interscript::Compiler
       re
     end
 
-    def build_item i, target=nil, doc=@map
+    def build_item i, target = nil, doc = @map
       i = i.nth_string if %i[str parstr].include? target
       i = Interscript::Node::Item.try_convert(i)
       target = :par if target == :parstr
 
-      out = case i
+      case i
       when Interscript::Node::Item::Alias
         if i.map
           d = doc.dep_aliases[i.map].document
@@ -193,14 +202,14 @@ class Interscript::Interpreter < Interscript::Compiler
       when Interscript::Node::Item::String
         if [:str, :par].include? target
           i.data
-        else#if target == :re
+        else # if target == :re
           Regexp.escape(i.data)
         end
       when Interscript::Node::Item::Group
         if target == :par
           i.children.map do |j|
             build_item(j, target, doc)
-          end.reduce([""]) do |j,k|
+          end.reduce([""]) do |j, k|
             Array(j).product(Array(k)).map(&:join)
           end
         else
@@ -215,9 +224,9 @@ class Interscript::Interpreter < Interscript::Compiler
            Interscript::Node::Item::MaybeSome,
            Interscript::Node::Item::Some
 
-        resuffix = { Interscript::Node::Item::Maybe     => "?" ,
-                     Interscript::Node::Item::Some      => "+" ,
-                     Interscript::Node::Item::MaybeSome => "*" }[i.class]
+        resuffix = {Interscript::Node::Item::Maybe => "?",
+                    Interscript::Node::Item::Some => "+",
+                    Interscript::Node::Item::MaybeSome => "*"}[i.class]
 
         if target == :par
           raise Interscript::SystemConversionError, "Can't use a MaybeSome in a #{target} context"
@@ -242,7 +251,7 @@ class Interscript::Interpreter < Interscript::Compiler
           case i.value
           when Array
             data = i.data.map { |j| build_item(j, target, doc) }
-            "(?:"+data.join("|")+")"
+            "(?:" + data.join("|") + ")"
           when String
             "[#{Regexp.escape(i.value)}]"
           when Range
@@ -252,4 +261,6 @@ class Interscript::Interpreter < Interscript::Compiler
       end
     end
   end
+  # standard:disable Layout/TrailingEmptyLines (deliberate)
 end
+# standard:enable Layout/TrailingEmptyLines