interscript 2.4.5 → 3.0.0

data/lib/interscript/node/dependency.rb

@@ -15,15 +15,15 @@ class Interscript::Node::Dependency < Interscript::Node
 
   def ==(other)
     super &&
-    self.full_name == other.full_name &&
-    self.import == other.import &&
-    self.name == other.name
+      full_name == other.full_name &&
+      import == other.import &&
+      name == other.name
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :name => @name,
-      :full_name => @full_name,
-      :import => @import }
+    {class: self.class.to_s,
+     name: @name,
+     full_name: @full_name,
+     import: @import}
   end
 end

data/lib/interscript/node/document.rb

@@ -62,18 +62,18 @@ class Interscript::Node::Document
 
   def ==(other)
     self.class == other.class &&
-    self.metadata == other.metadata &&
-    self.tests == other.tests &&
-    self.stages == other.stages &&
-    self.aliases == other.aliases
+      metadata == other.metadata &&
+      tests == other.tests &&
+      stages == other.stages &&
+      aliases == other.aliases
   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) }
+    {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

@@ -6,34 +6,34 @@ class Interscript::Node::Group < Interscript::Node
     @children = []
   end
 
-  def reorder_children(source,target)
+  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|
+    order.each_with_index do |pos, idx|
       children_new[idx] = @children[pos]
     end
     @children = children_new
-    #@children[source], @children[target] = @children[target], @children[source]
+    # @children[source], @children[target] = @children[target], @children[source]
     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)
+      r.children = children.reverse.map(&:reverse)
     end
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :children => @children.map{|x| x.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
+    super && children == other.children && reverse_run == other.reverse_run
   end
 
   def inspect
@@ -41,5 +41,7 @@ class Interscript::Node::Group < Interscript::Node
   end
 end
 
-require "interscript/node/group/parallel"
-require "interscript/node/group/sequential"
+class Interscript::Node::Group
+  autoload :Parallel, "interscript/node/group/parallel"
+  autoload :Sequential, "interscript/node/group/sequential"
+end

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

@@ -16,7 +16,7 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
 
   def max_length
     if stdlib?
-      ([:none].include? name) ? 0 : 1
+      [:none].include?(name) ? 0 : 1
     else
       return 1 if name == :unicode_hangul
       raise NotImplementedError, "can't get a max length of this alias"
@@ -24,31 +24,35 @@ class Interscript::Node::Item::Alias < Interscript::Node::Item
   end
 
   # Not implemented properly
-  def downcase; self; end
-  def upcase; self; end
+  def downcase
+    self
+  end
+
+  def upcase
+    self
+  end
 
   def first_string
     self
   end
 
-  alias nth_string first_string
+  alias_method :nth_string, :first_string
 
   def to_hash
-    { :class => self.class.to_s,
-      :name => name,
-      :map => map,
-    }
+    {class: self.class.to_s,
+     name: name,
+     map: map}
   end
 
   def ==(other)
-    super && self.name == other.name && self.map == other.map
+    super && name == other.name && map == other.map
   end
 
   def inspect
     if map
       "map.#{map}.#{name}"
     else
-      "#{name}"
+      name.to_s
     end
   end
 end

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

@@ -19,14 +19,19 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
     when Array
       value.map { |i| Interscript::Node::Item.try_convert(i) }
     when ::String
-      value.split("").map { |i| Interscript::Node::Item.try_convert(i) }
+      value.chars.map { |i| Interscript::Node::Item.try_convert(i) }
     when Range
       value.map { |i| Interscript::Node::Item.try_convert(i) }
     end
   end
 
-  def downcase; self.class.new(self.data.map(&:downcase)); end
-  def upcase; self.class.new(self.data.map(&:upcase)); end
+  def downcase
+    self.class.new(data.map(&:downcase))
+  end
+
+  def upcase
+    self.class.new(data.map(&:upcase))
+  end
 
   def first_string
     case @value
@@ -40,21 +45,23 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
   end
 
   def nth_string
+    # standard:disable Style/GlobalVars (deliberate $DEBUG / -d-flag debug idiom)
     return first_string unless $select_nth_string
+    # standard:enable Style/GlobalVars
 
     d = data
     Fiber.yield(:prepare)
-    id = Fiber.yield(:select_nth_string, d.count, self.hash)
+    id = Fiber.yield(:select_nth_string, d.count, hash)
     Fiber.yield(:selection)
     Interscript::Node::Item.try_convert(value[id]).nth_string
   end
 
   def max_length
-    self.data.map(&:max_length).max
+    data.map(&:max_length).max
   end
 
   def to_hash
-    hash = { :class => self.class.to_s }
+    hash = {class: self.class.to_s}
 
     case @value
     when Array
@@ -74,7 +81,7 @@ class Interscript::Node::Item::Any < Interscript::Node::Item
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def inspect

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

@@ -15,16 +15,21 @@ 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 downcase
+    dup.tap { |i| i.data = i.data.downcase }
+  end
+
+  def upcase
+    dup.tap { |i| i.data = i.data.upcase }
+  end
 
   def to_hash
-    { :class => self.class.to_s,
-      :data => self.data.to_hash }
+    {class: self.class.to_s,
+     data: data.to_hash}
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def inspect
@@ -44,15 +49,15 @@ class Interscript::Node::Item::CaptureRef < Interscript::Node::Item
     self
   end
 
-  alias nth_string first_string
+  alias_method :nth_string, :first_string
 
   def to_hash
-    { :class => self.class.to_s,
-      :id => self.id }
+    {class: self.class.to_s,
+     id: id}
   end
 
   def ==(other)
-    super && self.id == other.id
+    super && id == other.id
   end
 
   def inspect

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

@@ -7,23 +7,23 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
     end
   end
 
-  def +(item)
-    item = Interscript::Node::Item.try_convert(item)
-    out = self.dup
-    if Interscript::Node::Item::Group === item
-      out.children += item.children
+  def +(other)
+    other = Interscript::Node::Item.try_convert(other)
+    out = dup
+    if Interscript::Node::Item::Group === other
+      out.children += other.children
     else
-      out.children << item
+      out.children << other
     end
     out.verify!
     out
   end
 
   def compact
-    out = self.dup do |n|
+    out = dup do |n|
       n.children = n.children.reject do |i|
         (Interscript::Node::Alias === i && i.name == :none) ||
-        (Interscript::Node::String === i && i.data == "")
+          (Interscript::Node::String === i && i.data == "")
       end
     end
 
@@ -36,15 +36,20 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
     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
+  def downcase
+    dup.tap { |i| i.children = i.children.map(&:downcase) }
+  end
+
+  def upcase
+    dup.tap { |i| i.children = i.children.map(&:upcase) }
+  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
+        !(Interscript::Node::Item === i) ||
+        i.instance_of?(Interscript::Node::Item)
     end
 
     if wrong
@@ -53,11 +58,11 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
   end
 
   def first_string
-    self.children.map(&:first_string).reduce(&:+)
+    children.map(&:first_string).reduce(&:+)
   end
 
   def nth_string
-    self.children.map(&:nth_string).reduce(&:+)
+    children.map(&:nth_string).reduce(&:+)
   end
 
   def max_length
@@ -65,12 +70,12 @@ class Interscript::Node::Item::Group < Interscript::Node::Item
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :children => self.children.map{|x| x.to_hash} }
+    {class: self.class.to_s,
+     children: children.map { |x| x.to_hash }}
   end
 
   def ==(other)
-    super && self.children == other.children
+    super && children == other.children
   end
 
   def inspect

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

@@ -18,12 +18,12 @@ class Interscript::Node::Item::Repeat < Interscript::Node::Item
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :data => self.data.to_hash }
+    {class: self.class.to_s,
+     data: data.to_hash}
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def inspect

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

@@ -7,14 +7,13 @@ class Interscript::Node::Item::Stage < Interscript::Node::Item
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :name => name,
-      :map => map,
-    }
+    {class: self.class.to_s,
+     name: name,
+     map: map}
   end
 
   def ==(other)
-    super && self.name == other.name && self.map == other.map
+    super && name == other.name && map == other.map
   end
 
   def inspect

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

@@ -5,39 +5,44 @@ class Interscript::Node::Item::String < Interscript::Node::Item
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :data => self.data }
+    {class: self.class.to_s,
+     data: data}
   end
 
   def max_length
-    self.data.length
+    data.length
   end
 
   def first_string
-    self.data
+    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
+  def downcase
+    dup.tap { |i| i.data = i.data.downcase }
+  end
+
+  def upcase
+    dup.tap { |i| i.data = i.data.upcase }
+  end
 
-  alias nth_string first_string
+  alias_method :nth_string, :first_string
 
   def + other
-    if self.data == ""
+    if data == ""
       Interscript::Node::Item.try_convert(other)
     elsif Interscript::Node::Item::String === self &&
-      (Interscript::Node::Item::String === other || ::String === other)
+        (Interscript::Node::Item::String === other || ::String === other)
 
       other = Interscript::Node::Item.try_convert(other)
 
-      Interscript::Node::Item::String.new(self.data + other.data)
+      Interscript::Node::Item::String.new(data + other.data)
     else
       super
     end
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def inspect
@@ -47,12 +52,12 @@ end
 
 # stdext
 class String
-  alias plus_before_interscript +
+  alias_method :plus_before_interscript, :+
   def + other
     if Interscript::Node === other
       Interscript::Node::Item.try_convert(self) + other
     else
-      self.plus_before_interscript(other)
+      plus_before_interscript(other)
     end
   end
 end

data/lib/interscript/node/item.rb

@@ -7,23 +7,23 @@ class Interscript::Node::Item < Interscript::Node
   def + other
     this = self
 
-    this  = this.children  if Interscript::Node::Item::Group === this
+    this = this.children if Interscript::Node::Item::Group === this
     other = other.children if Interscript::Node::Item::Group === other
 
-    this  = Array(this)
+    this = Array(this)
     other = Array(other)
 
-    this  = this.map  { |i| Interscript::Node::Item.try_convert(i) }
+    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
+        Interscript::Node::Item::String === other.first
 
-       middle = [this.last + other.first]
-       this = this[0..-2]
-       other = this[1..-1]
+      middle = [this.last + other.first]
+      this = this[0..-2]
+      other = this[1..]
     end
 
     g = Interscript::Node::Item::Group.new(*this, *middle, *other)
@@ -32,8 +32,8 @@ class Interscript::Node::Item < Interscript::Node
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :item => self.item }
+    {class: self.class.to_s,
+     item: item}
   end
 
   def ==(other)
@@ -41,16 +41,26 @@ class Interscript::Node::Item < Interscript::Node
   end
 
   def self.try_convert(i)
-    i = Interscript::Node::Item::String.new(i) if i.class == ::String
+    i = Interscript::Node::Item::String.new(i) if i.instance_of?(::String)
     raise Interscript::MapLogicError, "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"
+class Interscript::Node::Item
+  # Autoload all item types (OCP: new item type = one autoload).
+  autoload :Alias, "interscript/node/item/alias"
+  autoload :String, "interscript/node/item/string"
+  autoload :Group, "interscript/node/item/group"
+  autoload :Any, "interscript/node/item/any"
+  autoload :Stage, "interscript/node/item/stage"
+  autoload :CaptureGroup, "interscript/node/item/capture"
+  autoload :Repeat, "interscript/node/item/repeat"
+  # Maybe, MaybeSome, Some are subclasses of Repeat defined in
+  # the same file. Autoload points to repeat.rb which defines all of them.
+  autoload :Maybe, "interscript/node/item/repeat"
+  autoload :MaybeSome, "interscript/node/item/repeat"
+  autoload :Some, "interscript/node/item/repeat"
+  # standard:disable Layout/TrailingEmptyLines (deliberate)
+end
+# standard:enable Layout/TrailingEmptyLines

data/lib/interscript/node/metadata.rb

@@ -1,12 +1,13 @@
 class Interscript::Node::MetaData < Interscript::Node
   attr_accessor :data
-  def initialize data={}
+  def initialize data = {}
     @data = data
   end
 
-  def []=(k,v)
+  def []=(k, v)
     @data[k] = v
   end
+
   def [](k)
     @data[k]
   end
@@ -18,11 +19,11 @@ class Interscript::Node::MetaData < Interscript::Node
   end
 
   def ==(other)
-    super && self.data == other.data
+    super && data == other.data
   end
 
   def to_hash
-    {:class => self.class.to_s,
-      :data => @data}
+    {class: self.class.to_s,
+     data: @data}
   end
 end

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

@@ -7,10 +7,9 @@ class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :name => self.name,
-      :kwargs => self.kwargs
-    }
+    {class: self.class.to_s,
+     name: name,
+     kwargs: kwargs}
   end
 
   def reverse
@@ -19,7 +18,7 @@ class Interscript::Node::Rule::Funcall < Interscript::Node::Rule
   end
 
   def ==
-    super && self.name == other.name && self.kwargs == other.kwargs
+    super && name == other.name && kwargs == other.kwargs
   end
 
   def inspect

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

@@ -6,18 +6,17 @@ class Interscript::Node::Rule::Run < Interscript::Node::Rule
   end
 
   def to_hash
-    { :class => self.class.to_s,
-      :stage => self.stage.to_hash }
+    {class: self.class.to_s,
+     stage: stage.to_hash}
   end
 
   def reverse
     Interscript::Node::Rule::Run.new(stage,
-      reverse_run: reverse_run.nil? ? nil : !reverse_run
-    )
+      reverse_run: reverse_run.nil? ? nil : !reverse_run)
   end
 
   def ==(other)
-    super && self.stage == other.stage
+    super && stage == other.stage
   end
 
   def inspect