plain_text 0.7.1 → 0.8

data/lib/plain_text/util.rb

@@ -47,8 +47,8 @@ module PlainText
     # @param size_even [Boolean] if true (Def: false), the sizes of the returned arrays are guaranteed to be identical.
     # @param filler [Object] if size_even: is true and if matching is performed, this filler is added at the end of the last element.
     def even_odd_arrays(ary, size_even: false, filler: "")
-      ar_even = select.with_index { |_, i| i.even? } rescue select.each_with_index { |_, i| i.even? } # Rescue for Ruby 2.1 or earlier
-      ar_odd  = select.with_index { |_, i| i.odd? }  rescue select.each_with_index { |_, i| i.odd? }  # Rescue for Ruby 2.1 or earlier
+      ar_even = ary.select.with_index { |_, i| i.even? } rescue ary.select.each_with_index { |_, i| i.even? } # Rescue for Ruby 2.1 or earlier
+      ar_odd  = ary.select.with_index { |_, i| i.odd? }  rescue ary.select.each_with_index { |_, i| i.odd? }  # Rescue for Ruby 2.1 or earlier
       if size_even && (ar_even.size != ar_odd.size)
         ar_odd.push filler
         raise "Should not happern." if (ar_even.size != ar_odd.size)
@@ -61,14 +61,15 @@ module PlainText
     # If positive or zero, it returns i.
     # If the negative index is out of range, it returns nil.
     #
+    # @see #positive_array_index_checked
     # @param i [Integer]
-    # @param ary [Array, Integer, nil] Reference Array or its size (Array#size) or nil (interpreted as self#size (untested)).
+    # @param arysize [Array, Integer] Reference Array or its size (Array#size).
     # @return [Integer, NilClass] nil if out of range to the negative.  Note in most cases in Ruby default, it raises IndexError.  See the code of {#positive_array_index_checked}
     # @raise [TypeError] if non-integer is specified.
-    # @raise [ArgumentError] if ary is neither an Array nor Integer, or more specifically, it does not have size method or ary.size does not return Integer or similar.
-    def positive_array_index(i, ary=nil)
-      arysize = (ary ? (ary.respond_to?(:to_int) ? ary.to_int : ary.size) : size)
-      i2 = i.to_int rescue (raise TypeError, sprintf("no implicit conversion of #{i.class} into Integer (i=#{i.inspect},ary=#{ary.inspect})"))
+    # @raise [ArgumentError] if arysize is neither an Array nor Integer, or more specifically, it does not have size method or arysize.size does not return Integer or similar.
+    def positive_array_index(i, arysize=nil)
+      arysize = (arysize.respond_to?(:to_int) ? arysize.to_int : arysize.size)
+      i2 = i.to_int rescue (raise TypeError, sprintf("no implicit conversion of #{i.class} into Integer (i=#{i.inspect},arysize=#{arysize.inspect})"))
       return i2 if i2 >= 0
       ret = arysize + i2 rescue (raise ArgumentError, "Reference is neither an Array nor Integer.")
       (ret < 0) ? nil : ret
@@ -82,20 +83,20 @@ module PlainText
     # Wrapper for {#positive_array_index}
     #
     # @param index_in [Integer] Index to check and convert from. Potentially negative integer.
-    # @param ary [Array, Integer, nil] Reference Array or its size (Array#size) or nil (interpreted as self#size (untested)).
+    # @param arysize [Array, Integer] Reference Array or its size (Array#size).
     # @param accept_too_big [Boolean, NilClass] if true (Default), a positive index larger than the last array index is returned as it is. If nil, the last index + 1 is accepted but raises an Exception for anything larger.  If false, any index larger than the last index raises an Exception.
     # @param varname [NilClass, String] Name of the variable (or nil) to be used for error messages.
     # @return [Integer] Non-negative index; i.e., if index=-1 is specified for an Array with a size of 3, the returned value is 2 (the last index of it).
     # @raise [IndexError] if the index is out of the range to negative.
-    # @raise [ArgumentError] if ary is neither an Array nor Integer, or more specifically, it does not have size method or ary.size does not return Integer or similar.
-    def positive_array_index_checked(index_in, ary=nil, accept_too_big: true, varname: nil)
-      # def self.positive_valid_index_for_array(index_in, ary, varname: nil)
+    # @raise [ArgumentError] if arysize is neither an Array nor Integer, or more specifically, it does not have size method or arysize.size does not return Integer or similar.
+    def positive_array_index_checked(index_in, arysize, accept_too_big: true, varname: nil)
+      # def self.positive_valid_index_for_array(index_in, arysize, varname: nil)
       errmsgs = {}
       %w(of for).each do |i|
         errmsgs[i] = (varname ? "." : sprintf(" %s %s.", i, varname)) 
       end
   
-      arysize = (ary ? (ary.respond_to?(:to_int) ? ary.to_int : ary.size) : size)
+      arysize = (arysize.respond_to?(:to_int) ? arysize.to_int : arysize.size)
       index = positive_array_index(index_in, arysize)  # guaranteed to be Integer or nil (or ArgumentError)
       raise IndexError, sprintf("index (%s) too small for array; minimum: -%d", index_in, arysize) if !index  # Ruby default Error message (except the variable "index" as opposed to "index_in is used in the true Ruby default).
       if index_in >= 0

data/lib/plain_text.rb

@@ -8,12 +8,17 @@
 # Many of the methods work on tha basis of a line.  For example, {#head} and {#tail} methods
 # work like the respective UNIX-shell commands, returning a specified line at the head/tail parts of self.
 #
-# Most methods in this module are meant to be included in String, except for a few module functions.
-# It is however debatable whether it is a good practice to include a third-party module in the core class.
-# This module contains a helper module function {PlainText.extend_this}, with which an object extends this module easily as Singleton if this module is not already included.
+# Many of the methods contained directly in this module are meant to be
+# included in String. Obviously, though, it is debatable if it is
+# a good practice to include a third-party module in the core class.
+#
+# Several module functions are also available.
+# This module contains a helper module function {PlainText.extend_this}, with which
+# an object extends this module easily as Singleton if this module is not already included.
 #
 # A few methods in this module assume that {PlainText::Split} is included in String,
 # which in default is the case, as soon as this file is read (by Ruby's require).
+# The specification may be subject to change in the future release.
 #
 # @author Masa Sakano (Wise Babel Ltd)
 #
@@ -185,7 +190,7 @@ module PlainText
       # Also, deepcopy is needed, as this method is destructive.
       prt = (preserve_paragraph ? prt : Part.new([prt.join])).deepcopy
     end
-    prt.squash_boundaryies!  # Boundaries are squashed.
+    prt.squash_boundaries!  # Boundaries are squashed.
 
     # Handles Boundary
     clean_text_boundary!(prt, boundary_style: boundary_style)
@@ -407,7 +412,7 @@ module PlainText
   end # self.clean_text_line_head_tail!
   private_class_method :clean_text_line_head_tail!
 
-  # @param prt [PlainText:Part] (see PlainText.clean_text#prt)
+  # @param prt [PlainText::Part] (see PlainText.clean_text#prt)
   # @param firstlbs_style [Symbol, String] (see PlainText.clean_text#firstlbs_style)
   # @param lastsps_style [Symbol, String]  (see PlainText.clean_text#lastsps_style)
   # @return [void]
@@ -419,7 +424,6 @@ module PlainText
         lastsps_style:  ,
         is_debug: false
       )
-
     # Handles the beginning of the given Part.
     obj = prt.first_significant_element || return
     # The first significant element is either Paragraph or Background.
@@ -1050,8 +1054,8 @@ module PlainText
 
 end # module PlainText
 
-require "plain_text/part"
-require "plain_text/parse_rule"
-require "plain_text/split"
-require "plain_text/util"
+require_relative "plain_text/part"
+require_relative "plain_text/parse_rule"
+require_relative "plain_text/split"
+require_relative "plain_text/util"
 

data/plain_text.gemspec

@@ -5,7 +5,7 @@ require 'date'
 
 Gem::Specification.new do |s|
   s.name = %q{plain_text}.sub(/.*/){|c| (c == File.basename(Dir.pwd)) ? c : raise("ERROR: s.name=(#{c}) in gemspec seems wrong!")}
-  s.version = "0.7.1".sub(/.*/){|c| fs = Dir.glob('changelog{,.*}', File::FNM_CASEFOLD); raise('More than one ChangeLog exist!') if fs.size > 1; warn("WARNING: Version(s.version=#{c}) already exists in #{fs[0]} - ok?") if fs.size == 1 && !IO.readlines(fs[0]).grep(/^\(Version: #{Regexp.quote c}\)$/).empty? ; c }  # n.b., In macOS, changelog and ChangeLog are identical in default.
+  s.version = "0.8".sub(/.*/){|c| fs = Dir.glob('changelog{,.*}', File::FNM_CASEFOLD); raise('More than one ChangeLog exist!') if fs.size > 1; warn("WARNING: Version(s.version=#{c}) already exists in #{fs[0]} - ok?") if fs.size == 1 && !IO.readlines(fs[0]).grep(/^\(Version: #{Regexp.quote c}\)$/).empty? ; c }  # n.b., In macOS, changelog and ChangeLog are identical in default.
   # s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.bindir = 'bin'
   %w(countchar textclean head.rb tail.rb yard2md_afterclean).each do |f|
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
     File.executable?(path) ? s.executables << f : raise("ERROR: Executable (#{path}) is not executable!")
   end
   s.authors = ["Masa Sakano"]
-  s.date = %q{2022-09-09}.sub(/.*/){|c| (Date.parse(c) == Date.today) ? c : raise("ERROR: s.date=(#{c}) is not today!")}
+  s.date = %q{2022-09-14}.sub(/.*/){|c| (Date.parse(c) == Date.today) ? c : raise("ERROR: s.date=(#{c}) is not today!")}
   s.summary = %q{Module to handle Plain-Text}
   s.description = %q{This module provides utility functions and methods to handle plain text, classes Part/Paragraph/Boundary to represent the logical structure of a document and ParseRule to describe the rules to parse plain text to produce a Part-type Ruby instance. A few handy Ruby executable scripts to make use of them are included.}
   # s.email = %q{abc@example.com}
@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
 
   # s.require_paths = ["lib"]	# Default "lib"
-  s.required_ruby_version = '>= 2.0', '< 3.2'
+  s.required_ruby_version = '>= 2.0'
   s.test_files = Dir['test/**/*.rb']
   s.test_files.reject! { |fn| File.symlink? fn }
   # s.requirements << 'libmagick, v6.0' # Simply, info to users.

data/test/test_plain_text.rb

@@ -2,11 +2,26 @@
 
 # Author: M. Sakano (Wise Babel Ltd)
 
-require 'plain_text'
-
 $stdout.sync=true
 $stderr.sync=true
+
 # print '$LOAD_PATH=';p $LOAD_PATH
+arlibbase = %w(plain_text)
+
+arlibrelbase = arlibbase.map{|i| "../lib/"+i}
+
+arlibrelbase.each do |elibbase|
+  require_relative elibbase
+end	# arlibbase.each do |elibbase|
+
+print "NOTE: Running: "; p File.basename(__FILE__)
+print "NOTE: Library relative paths: "; p arlibrelbase
+arlibbase4full = arlibbase.map{|i| i.sub(%r@^(../)+@, "")}
+puts  "NOTE: Library full paths for #{arlibbase4full.inspect}: "
+arlibbase4full.each do |elibbase|
+  ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+  print elibbase+": " if ar.empty?; p ar
+end
 
 #################################################
 # Unit Test

data/test/test_plain_text_parse_rule.rb

@@ -2,12 +2,26 @@
 
 # Author: M. Sakano (Wise Babel Ltd)
 
-require 'plain_text'
-require 'plain_text/parse_rule'
-
 $stdout.sync=true
 $stderr.sync=true
+
 # print '$LOAD_PATH=';p $LOAD_PATH
+arlibbase = %w(plain_text plain_text/parse_rule)
+
+arlibrelbase = arlibbase.map{|i| "../lib/"+i}
+
+arlibrelbase.each do |elibbase|
+  require_relative elibbase
+end	# arlibbase.each do |elibbase|
+
+print "NOTE: Running: "; p File.basename(__FILE__)
+print "NOTE: Library relative paths: "; p arlibrelbase
+arlibbase4full = arlibbase.map{|i| i.sub(%r@^(../)+@, "")}
+puts  "NOTE: Library full paths for #{arlibbase4full.inspect}: "
+arlibbase4full.each do |elibbase|
+  ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+  print elibbase+": " if ar.empty?; p ar
+end
 
 #################################################
 # Unit Test

data/test/test_plain_text_part.rb

@@ -2,11 +2,27 @@
 
 # Author: M. Sakano (Wise Babel Ltd)
 
-require 'plain_text'
-
 $stdout.sync=true
 $stderr.sync=true
+
 # print '$LOAD_PATH=';p $LOAD_PATH
+arlibbase = %w(plain_text)
+
+arlibrelbase = arlibbase.map{|i| "../lib/"+i}
+
+arlibrelbase.each do |elibbase|
+  require_relative elibbase
+end	# arlibbase.each do |elibbase|
+
+print "NOTE: Running: "; p File.basename(__FILE__)
+print "NOTE: Library relative paths: "; p arlibrelbase
+arlibbase4full = arlibbase.map{|i| i.sub(%r@^(../)+@, "")}+%w(part part/paragraph part/boundary plain_text/util builtin_type part/string_type)
+puts  "NOTE: Library full paths for #{arlibbase4full.inspect}: "
+arlibbase4full.each do |elibbase|
+  #ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+  ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(elibbase)}(\.rb)?$/).uniq
+  print elibbase+": " if ar.empty?; p ar
+end
 
 #################################################
 # Unit Test
@@ -24,6 +40,15 @@ require 'minitest/autorun'
 require 'rubygems' if !defined? Gem  # for Ruby 1
 IS_VER_2 = (Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3'))
 
+# defines user-defined subclasses.
+class PlainText::Part
+  class Section < self
+    class Subsection < self; end  # It must be a child class!
+  end
+end
+class PlainText::Part::Boundary::MyA < PlainText::Part::Boundary
+end
+
 class TestUnitPlainTextPart < MiniTest::Test
   T = true
   F = false
@@ -67,7 +92,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_equal a2[2], pt2[2]
     assert_equal ap2,   pt2.paras
     assert_equal ab2,   pt2.boundaries
-    assert_equal a2+[""], pt2.to_a  # An empty String is appended.
+    assert_equal a2+[""], pt2.to_a, "former=#{a2+['']} <=> #{pt2.to_a}"  # An empty String is appended.
     assert_operator a2,  '!=', pt2
     assert_operator pt2, '!=', a2
   end
@@ -82,12 +107,19 @@ class TestUnitPlainTextPart < MiniTest::Test
 
     pt11 = Pt.new(a1)
     pt12 = Pt.new(ap1, ab1)
-    assert_equal pt11, pt12
+    assert_equal pt11, pt12, "pt11.inspect=#{pt11.inspect}"
     pt21 = Pt.new(a2)
     pt22 = Pt.new(ap2, ab2)
     assert_equal pt21, pt22
   end
 
+  def test_new03
+    assert_raises(ArgumentError){ Pt.new(?a) }
+    assert_raises(ArgumentError){ Pt.new(3) }
+    assert_raises(TypeError){ Pt.new([Pt::Boundary.new(""),  Pt::Boundary.new("\n") ]) }
+    assert_raises(TypeError){ Pt.new([Pt::Paragraph.new(""), Pt::Paragraph.new("a")]) }
+  end
+
   def test_size2extract01
     a1  = ["a", "\n\n\n", "b", "\n\n\n", "c", "\n\n"]
     pt1 = Pt.new(a1)
@@ -113,7 +145,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_raises(IndexError){ pt1.send(:size2extract, (-9..-9), ignore_error: false, skip_renormalize: false) }
   end
 
-   
+
   def test_equal01
     a1  = ["a", "\n\n\n", "b", "\n\n\n", "c", "\n\n"]
     pt1 = Pt.new(a1)
@@ -121,17 +153,31 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt2 = Pt.new(a2)
 
     assert_operator pt1, '==', Pt.new(a1)
+    assert_operator pt1, '==', Pt.new(a1.dup)
+    assert_operator pt1, '==', Pt.new(pt1.deepcopy.to_a)
     assert_operator a1,  '==', pt1.to_a
     assert_operator a1,  '!=', pt1
     assert_operator pt1, '!=', a1
-    assert_operator a1,  '!=', ?a
-    assert_operator ?a,  '!=', a1
     assert_operator pt1, '!=', pt2
     assert_operator pt2, '!=', pt1
     assert_operator pt1, '!=', ?a
     assert_operator ?a,  '!=', pt1
   end
 
+  def test_equal02_para_boundary
+    pa1 = Pt::Paragraph.new("abc")
+    bo1 = Pt::Boundary.new("\n\n")
+    assert_equal pa1, "abc"
+    assert_equal "abc", pa1
+    assert_equal pa1, Pt::Paragraph.new("abc")
+    assert_equal bo1, "\n\n"
+    assert_equal "\n\n", bo1
+    assert_equal bo1, Pt::Boundary.new("\n\n")
+
+    assert_respond_to pa1, :+
+    assert_respond_to bo1, :gsub!
+  end
+
   def test_nomethoderror01
     a1  = ["a", "\n\n\n", "b", "\n\n\n", "c", "\n\n"]
     pt1 = Pt.new(a1)
@@ -149,7 +195,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_equal a1+["d", ""], pt3.to_a
     assert_equal pt1.class,    pt3.class
     assert_equal Pt.new(a3),   pt3    # Boundary("") is appended.
-    assert_equal Pt::Boundary, pt3.to_a[-1].class  if IS_VER_2  # Not in Ruby 3 (see note at the top)
+    assert_equal Pt::Boundary, pt3.to_a[-1].class
     assert_equal pt3, pt1 + ["d", ""]
 
     assert_equal a3.class, ([]+pt3).class  # The latter, too, is an Array (NOT PlainText::Part)
@@ -176,10 +222,11 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_nil   pt1[-99]
     assert_nil   pt1[98]
 
-    assert_equal pt1.class, pt1[0, 6].class  if IS_VER_2  # Not in Ruby 3 (see note at the top)
+    assert_equal pt1.class, pt1[0, 6].class
     assert_equal a1,        pt1[0, 6].to_a
     assert_equal a1[0, 6],  pt1[0, 6].to_a
-    oper = (IS_VER_2 ? :!= : :==)  # Because PlainText::Part#== is redefined and pt1 is Part in Ruby 2, the following is unequal, whereas pt1 is Array in Ruby 3!
+    # oper = (IS_VER_2 ? :!= : :==)  # Because PlainText::Part#== is redefined and pt1 is Part in Ruby 2, the following is unequal, whereas pt1 is Array in Ruby 3!
+    oper = :!=  # In Ver.0.8, it is redefined as unequal.
     assert_operator pt1[0, 6], oper, a1
     assert_operator a1,        oper, pt1[0, 6]
 
@@ -187,7 +234,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_equal a1,        pt1[0, 98].to_a
     assert_equal a1[0, 99], pt1[0, 98].to_a
 
-    assert_equal pt1.class, pt1[0..1].class  if IS_VER_2  # Not in Ruby 3 (see note at the top)
+    assert_equal pt1.class, pt1[0..1].class
     assert_equal a1[0..1],  pt1[0..1].to_a
     assert_equal a1[0, 2],  pt1[0..1].to_a
     assert_equal a1[0..5],  pt1[0..5].to_a
@@ -202,14 +249,12 @@ class TestUnitPlainTextPart < MiniTest::Test
 
     assert_equal pt1[0..-1], pt1[0..99]
     assert_equal pt1[0, 6],  pt1[0..-1]
-    assert_equal pt1,        pt1[0..99]  if IS_VER_2  # Not in Ruby 3 (see note at the top)
+    assert_equal pt1,        pt1[0..99]
 
-    if IS_VER_2  # Not in Ruby 3 (see note at the top)
-      pt2 = pt1[0, 4]
-      assert_equal pt1.class,            pt2.class
-      assert_equal pt1.paras[0, 2],      pt2.paras
-      assert_equal pt1.boundaries[0, 2], pt2.boundaries
-    end
+    pt2 = pt1[0, 4]
+    assert_equal pt1.class,            pt2.class
+    assert_equal pt1.paras[0, 2],      pt2.paras
+    assert_equal pt1.boundaries[0, 2], pt2.boundaries
 
     # negative or too-big out-of-bound begin
     assert_nil   a1[-99..2]
@@ -218,7 +263,6 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_nil   pt1[98..99]
 
     # other out-of-bounds: Empty
-    assert_equal Pt.new([]),  pt1[2..1]  if IS_VER_2  # Not in Ruby 3 (see note at the top)
     assert_equal a1[-2..2],   pt1[-2..2].to_a
     assert_equal a1[-2...3],  pt1[-2...3].to_a
 
@@ -235,12 +279,10 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_nil   pt1[pt1.size]
     assert_nil   pt1[pt1.size, -2]
     assert_raises(TypeError){ pt1[pt1.size, ?a] }
-    if IS_VER_2  # Not in Ruby 3 (see note at the top)
-      assert_equal Pt.new([]), pt1[pt1.size, 2]
-      assert_equal Pt.new([]), pt1[pt1.size, 98]
-      assert_equal Pt.new([]), pt1[pt1.size..99]
-      assert_equal Pt.new([]), pt1[pt1.size..1]
-    end
+    assert_equal Pt.new([]), pt1[pt1.size, 2]
+    assert_equal Pt.new([]), pt1[pt1.size, 98]
+    assert_equal Pt.new([]), pt1[pt1.size..99]
+    assert_equal Pt.new([]), pt1[pt1.size..1]
   end
 
   # Tests of slice! to delete
@@ -261,12 +303,12 @@ class TestUnitPlainTextPart < MiniTest::Test
 
     assert_equal a11[4, 2],  a1.slice!(4, 2)
     ptp =                   pt1.slice!(4, 2)
-    assert_equal    pt1.class, ptp.class  if IS_VER_2  # Not in Ruby 3 (see note at the top)  # PlainText::Part
+    assert_equal    pt1.class, ptp.class
     assert_equal    a11[4, 2], ptp.to_a
-    assert_operator a11[4, 2], :!=, ptp  if IS_VER_2   # PlainText::Part != Array
+    assert_operator a11[4, 2], :!=, ptp   # PlainText::Part != Array
     assert_equal a11[0..3],  a1
     assert_equal a11[0..3], pt1.to_a
-    assert_equal pt2[0..3], pt1  if IS_VER_2  # Not in Ruby 3 (see note at the top)
+    assert_equal pt2[0..3], pt1
 
     # Negative size (Index, Size)
     a1  = a11.clone
@@ -282,9 +324,9 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt1 = Pt.new(a11.clone)
     assert_equal a11[4, 6],  a1.slice!(4, 6)
     ptp =                   pt1.slice!(4, 6)
-    assert_equal    pt1.class, ptp.class  if IS_VER_2  # Not in Ruby 3 (see note at the top)  # PlainText::Part
+    assert_equal    pt1.class, ptp.class  # PlainText::Part
     assert_equal    a11[4, 2], ptp.to_a
-    assert_operator a11[4, 2], :!=, ptp  if IS_VER_2  # Not in Ruby 3 (see note at the top)   # PlainText::Part != Array
+    assert_operator a11[4, 2], :!=, ptp   # PlainText::Part != Array
     assert_equal a11[0..3],  a1
 
     # Range exceeding (Range)
@@ -292,10 +334,10 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt1 = Pt.new(a11.clone)
     assert_equal a11[4..9],  a1.slice!(4..9)
     ptp =                   pt1.slice!(4..9)
-    assert_equal    pt1.class, ptp.class  if IS_VER_2  # Not in Ruby 3 (see note at the top)  # PlainText::Part
+    assert_equal    pt1.class, ptp.class  # PlainText::Part
     assert_equal    a11[4..-1],ptp.to_a
     assert_equal    a11[4..9], ptp.to_a
-    assert_operator a11[4..9], :!=, ptp  if IS_VER_2  # Not in Ruby 3 (see note at the top)   # PlainText::Part != Array
+    assert_operator a11[4..9], :!=, ptp   # PlainText::Part != Array
     assert_equal a11[0..3],  a1
     assert_equal a11[0..3], pt1.to_a
 
@@ -315,9 +357,9 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt1 = Pt.new(a11.clone)
     assert_equal a11[-6, 2],  a1.slice!(-6, 2)
     ptp =                    pt1.slice!(-6, 2)
-    assert_equal    pt1.class, ptp.class  if IS_VER_2  # Not in Ruby 3 (see note at the top)  # PlainText::Part
+    assert_equal    pt1.class, ptp.class  # PlainText::Part
     assert_equal    a11[0..1], ptp.to_a
-    assert_operator a11[0..1], :!=, ptp  if IS_VER_2  # Not in Ruby 3 (see note at the top)   # PlainText::Part != Array
+    assert_operator a11[0..1], :!=, ptp   # PlainText::Part != Array
     assert_equal a11[2..-1],  a1
     assert_equal a11[2..-1], pt1.to_a
 
@@ -326,9 +368,9 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt1 = Pt.new(a11.clone)
     assert_equal a11[-6..-5],  a1.slice!(-6..-5)
     ptp =                     pt1.slice!(-6..-5)
-    assert_equal    pt1.class, ptp.class  if IS_VER_2  # Not in Ruby 3 (see note at the top)  # PlainText::Part
+    assert_equal    pt1.class, ptp.class  # PlainText::Part
     assert_equal    a11[0..1], ptp.to_a
-    assert_operator a11[0..1], :!=, ptp  if IS_VER_2  # Not in Ruby 3 (see note at the top)   # PlainText::Part != Array
+    assert_operator a11[0..1], :!=, ptp   # PlainText::Part != Array
     assert_equal a11[2..-1],  a1
     assert_equal a11[2..-1], pt1.to_a
 
@@ -355,48 +397,56 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_equal "b\n\n",      pt1[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2,3,4)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2,3,4, 5)
     assert_equal s1, pt2.join
-    assert_equal  8, pt2.size
+    assert_equal  8, pt2.size, "Size should be 8: pt2="+pt2.inspect
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2..4)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2..5)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2...6)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(2...-4)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(1..2, use_para_index: true)
     assert_equal s1, pt2.join
     assert_equal  8, pt2.size
     assert_equal "b\n\nc\n\n", pt2[2..3].join
 
     pt2 = pt1.dup
+    assert_equal 10, pt2.size, "Sanity check should pass: #{pt2.inspect}"
     pt2.merge_para!(8..12)
     assert_equal s1, pt2.join
     assert_equal 10, pt2.size
@@ -407,7 +457,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     s1 = "a\n\nb\n\nc\n\nd\n\ne\n\n"
     #     0 1  2 3  4 5  6 7  8 9
     pt1 = Pt.parse s1
-    
+
     pt2 = pt1.dup
     assert pt2.merge_para_if{|ary,bi,bf|
       ary[0] == ?b && ary[2] == ?c
@@ -438,9 +488,127 @@ class TestUnitPlainTextPart < MiniTest::Test
     assert_equal s1,  pt1.join
   end
 
+  # subclass_name defined in /lib/plain_text/builtin_type.rb
+  def test_subclass_name
+    bo1 = Pt::Boundary::MyA.new("\n===\n")
+    assert_equal "Part::Boundary::MyA", bo1.subclass_name
+    assert_equal       "Boundary::MyA", bo1.subclass_name(index_ini: 1)
+    assert_equal                 "MyA", bo1.subclass_name(index_ini: 2)
+
+    ss = PlainText::Part::Section::Subsection.new ["abc"]
+    assert_equal "Part::Section::Subsection", ss.subclass_name
+    assert_equal       "Section::Subsection", ss.subclass_name(index_ini: 1)
+  end
+
+  def test_dup
+    pa1 = Pt::Paragraph.new("b")
+    bo1 = Pt::Boundary::MyA.new("\n===\n")
+    para1 = [Pt::Paragraph.new("a"), pa1, Pt::Paragraph.new("c")]
+    boun1 = [Pt::Boundary.new("\n"), bo1, Pt::Boundary.new("\n")]
+    pt1 = Pt.new(para1, boun1)
+    assert_equal pt1[2],           pa1
+    refute_equal pt1[2].object_id, pa1.object_id, "New one should be given a different object_id (unicode_normalized)"
+
+    pt2 = pt1.dup
+    refute_equal pt1.object_id,          pt2.object_id
+    refute_equal pt1.instance.object_id, pt2.instance.object_id
+    assert_equal pt1[2].object_id,       pt2[2].object_id
+    assert_equal pt1.paras[1].object_id, pt2[2].object_id
+    assert_equal pt1.paras[1].object_id, pt2.paras[1].object_id
+    assert_equal pt1.boundaries[1].object_id, pt2.boundaries[1].object_id
+
+    pa2 = pa1.dup
+    assert_equal pa1,   pa2
+    refute_equal pa1.object_id,          pa2.object_id
+    refute_equal pa1.instance.object_id, pa2.instance.object_id
+    pa2.replace("x")
+    refute_equal pa1,   pa2
+
+    bo2 = bo1.dup
+    assert_equal bo1,   bo2
+    refute_equal bo1.object_id,          bo2.object_id
+    refute_equal bo1.instance.object_id, bo2.instance.object_id
+    bo2.replace("x")
+    refute_equal bo1,   bo2
+  end
+
+  def test_deepcopy
+    para1 = [Pt::Paragraph.new("a"), Pt::Paragraph.new("b"), Pt::Paragraph.new("c")]
+    boun1 = [Pt::Boundary.new("\n"), Pt::Boundary::MyA.new("\n===\n"), Pt::Boundary.new("\n")]
+    pt1 = Pt.new(para1, boun1)
+    pt2 = pt1.deepcopy
+    assert_equal pt1, pt2
+    assert_equal Pt::Paragraph,     pt1.to_a[0].class
+    assert_equal Pt::Boundary,      pt1.to_a[1].class
+    assert_equal Pt::Paragraph,     pt1.to_a[2].class
+    assert_equal Pt::Boundary::MyA, pt1.to_a[3].class
+    assert_equal "Part::Boundary::MyA", pt1.to_a[3].subclass_name, "subclass_name should be equal: pt1: #{pt1.to_a[3].inspect}"
+    assert_equal "Part::Boundary::MyA", pt2.to_a[3].subclass_name
+    refute_equal pt1.object_id,         pt2.object_id
+    refute_equal pt1.to_a[3].object_id, pt2.to_a[3].object_id
+    refute_equal pt1.to_a[3].to_s.object_id, pt2.to_a[3].to_s.object_id
+    refute_equal pt1.to_a[4].object_id, pt2.to_a[4].object_id
+    refute_equal pt1.to_a[4].to_s.object_id, pt2.to_a[4].to_s.object_id
+  end
+
+  def test_insert
+    a1  = ["a", "\n\n\n", "b", "\n\n\n", "c"]
+    pt1 = Pt.new(a1)
+    assert_equal 6, pt1.size,       "Sanity check 1"
+    assert_equal a1+[""], pt1.to_a, "Sanity check 2"
+    pt2 = pt1.deepcopy
+    err = assert_raises(IndexError){ pt2.insert(-99, ?d, "\n") }
+    assert_raises(IndexError){ pt2.insert(-99) }
+    assert_match(/\btoo small for array\b/i, err.message)
+    assert_raises(IndexError){ pt2.insert(7, ?d, "\n") }
+    assert_raises(ArgumentError){ pt2.insert(-1, ?d) }
+    assert_raises(ArgumentError){ pt2.concat([?d]) }
+    assert_raises(ArgumentError){ pt2.push(   ?d) }
+    assert_raises(ArgumentError){ pt2.insert(-1, ?d, "", ?e) }
+    assert_raises(TypeError){ pt2.insert(-1, Pt::Boundary.new("\n"), Pt::Paragraph.new(?d)) }
+    assert_raises(TypeError){ pt2.insert(-1, Pt::Paragraph.new(?d),  Pt::Paragraph.new(?d)) }
+    assert_raises(TypeError){ pt2.insert(-2, Pt::Paragraph.new(?d),  Pt::Boundary.new("\n")) }
+    assert_raises(TypeError){ pt2.insert(-2, Pt::Boundary.new("\n"), Pt::Boundary.new("\n")) }
+    assert_raises(TypeError){ pt2.insert(-2, Pt.new([?d]), Pt::Boundary.new("\n")) }
+    pt2 = pt1.deepcopy  # required, as @array is altered.
+    assert_equal pt1, pt2
+    assert_equal pt1, pt2.insert(-1), "Insert with no second arguments should alter nothing."
+    assert_equal pt1, pt2.insert(0)
+    assert_equal pt1, pt2.insert(1)
+
+    pt2.insert(-1, ?e, "\n")
+    assert_equal 8, pt2.size
+    assert_equal [?e, "\n"], pt2.to_a[-2..-1]
+    assert pt2[-2].paragraph?
+    assert pt2[-1].boundary?
+
+    bo5 = Pt::Boundary.new("==")
+    pt2.insert(5, bo5, ?d)
+    assert_equal 10, pt2.size
+    assert_equal ["==", ?d, "", ?e, "\n"], pt2.to_a[-5..-1]
+    assert pt2[-2].paragraph?
+    assert pt2[-1].boundary?
+    assert_equal bo5, pt2[5]
+    assert pt2[5].boundary?
+    assert_equal "d", pt2[6]
+    assert pt2[6].paragraph?
+
+    pt2.insert(2, pt1, "")
+    assert_equal 12, pt2.size
+    assert_equal "a\n\n\na\n\n\nb\n\n\ncb\n\n\nc==de\n", pt2.join
+end
+
+  def test_array_methods
+    a1  = ["a", "\n\n\n", "b", "\n\n\n", "c"]
+    pt1 = Pt.new(a1)
+    assert_equal 6, pt1.size
+    assert_equal a1+[""], pt1.to_a
+    assert_raises(NoMethodError){ pt1.delete_at(0) }
+    assert_raises(NoMethodError){ pt1 << ?d }
+  end
+
     #assert ( /_rails_db\.sql$/ =~ s1.outfile )
     #assert_nil            fkeys
-    #assert_match(/^\s*ADD CONSTRAINT/ , s1.instance_eval{ @strall })
 end	# class TestUnitPlainTextPart < MiniTest::Test
 
 #end	# if $0 == __FILE__