plain_text 0.5.1 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60f47c9a9c507596cfd75eef54b85fdbd21e82a005c0708c6e30533d9260080f
-  data.tar.gz: f8026cb15e06f85ce18d60446c1086deced870a80e9c9c6325afd1d968754134
+  metadata.gz: daeda100de65b1faf0ed6c93ba5cb698761d9ac6bd0c9e7ed896832ce04598e7
+  data.tar.gz: 7d2edcae09978ed8d1630e9526d4ef2611a96da0ecd8c1d859936dd266f78619
 SHA512:
-  metadata.gz: a29d52f5a51ca13b6a190937265aea43f80d665e838682f479f8aaf9d2771f0fbda885433e82cac87b2d928ab8dfdfdba5373431a5b7b9fa7b532c412b178bb6
-  data.tar.gz: 1408761cf59637779a122c7b6c497b4a3f45cc42358b089bef4e4f17b8b590fb9679dc69c5feb790094dac3f026b3769d9b73feb261bdc46c04e7edf6ee5d09a
+  metadata.gz: d2ffb6c2482e623dfa077c893417e64648be555c8eb8f4fc141f8a0b108839e6e041d15527d5564b2339087edc26d49eef9e40828c00233369b560f12c1c70db
+  data.tar.gz: 164757b808185ebff8ab4e24bbef211c1afb46634e6156cc27bd237bb301bfc3323f2b8ea988721720e0c6b3f83ec560112f1324ebf53ab8fdc314821e3f7d9a

data/ChangeLog

@@ -1,3 +1,8 @@
+-----
+(Version: 0.6)
+2019-11-07  Masa Sakano
+  * Introduces a new concept "Para" and accordingly renamed some methods like Part#parts to Part#paras
+
 -----
 (Version: 0.5.1)
 2019-11-07  Masa Sakano

data/README.en.rdoc

@@ -30,9 +30,9 @@ such as, {PlainText.clean_text} and {PlainText.count_char}.
 === PlainText::Part - Core class to describe the logical structure
 
 In the namespace of this module, it contains {PlainText::Part} class,
-which is the heart to describe the logical structure of documents.
+which is the heart to describe the logical structure of a document.
 It is basically a container class and indeed a sub-class of Array. It
-can contain either of another {PlainText::Part} or more basic
+can contain either of other (multiple) {PlainText::Part} or more basic
 components of either of {PlainText::Part::Paragraph} and
 {PlainText::Part::Boundary}, both of which are sub-classes of String.
 
@@ -64,7 +64,7 @@ An example instance looks like this:
      (5) Boundary::General
    )
 
-where the name of subclasses (or constants) here arbitrary, except for
+where the names of the subclasses (or constants) here are arbitrary, except for
 {PlainText::Part::Paragraph::Empty} and
 {PlainText::Part::Boundary::Empty}, which are pre-defined. Users can
 define their own subclasses to help organize the logical structure at
@@ -73,9 +73,18 @@ their will.
 Basically, at every layer, every {PlainText::Part} or
 {PlainText::Part::Paragraph} is sandwiched by
 {PlainText::Part::Boundary}, except for the very first one.
+The former contains something significant on its own, whereas the
+latter (Boundary) contains nothing significant on its own, except they
+may indicate the type of the following (or preceding) entity, such as
+a title or section.
 
-By performing +join+ method, one can retrieve the entire document as a
-String instance any time.
+In this library (document, classes and modules), the former and latter
+are collectively referred to as Para (or Paras) and Boundary (or
+Boundaries), respectively.  Namely, a Para means either of
+{PlainText::Part} and {PlainText::Part::Paragraph}.
+
+By performing +Part#join+ method, one can retrieve the entire document as a
+String instance any time, just like +Array#join+.
 
 === PlainText::ParseRule - Class to describe the rule of how to parse
 
@@ -87,13 +96,13 @@ A rule, Proc, is defined by a user and is designed to receive either
 String (the first application only) or {PlainText::ParseRule} (Array)
 and to return a fully (or partially) parsed {PlainText::ParseRule}.
 In short, the rule descries how to determine from where to where a
-paragraphs and boundaries are located, and maybe what and where the
-sections and sub-sections and so on are.
+Paras and Boundaries are located — for example, what and where the
+sections and sub-sections are and so on are.
 
 For example, if a rule is Regexp, it describes how to split a String;
 it is applied to String in the first application, but if it is
-applied (and maybe registered as such) at the second or later stage,
-it is applied to each Paragraph and Section separately to split them further.
+applied (and maybe registered as such) at the second or later stages,
+it is applied to each Para separately to split them further.
 
 {PlainText::ParseRule#apply} and {PlainText::Part.parse} are the
 standard methods to apply the rules to an object (either String or

data/bin/yard2md_afterclean

@@ -124,7 +124,7 @@ end
 # @return [Integer]
 def min_indent(str, lb=$/)
   return 0 if str.empty?
-  lines = PlainText::Part.parse(str).parts.join("\n").split("\n")
+  lines = PlainText::Part.parse(str).paras.join("\n").split("\n")
   lines.map{|ec| indent_line(ec)}.min
 end
 
@@ -149,7 +149,7 @@ end
 # @return [Integer]
 def last_indent(str, indent_prev=0, lb=$/)
   return indent_prev if !str || str.empty?
-  lines = PlainText::Part.parse(str).parts.join("\n").split("\n")
+  lines = PlainText::Part.parse(str).paras.join("\n").split("\n")
   # Note: numsps = 2  # "2." takes up 2 spaces, whereas "12." takes 3.
   lines.each do |ec|
     cind = indent_line(ec)
@@ -184,10 +184,10 @@ opts = handle_argv()
 
 strin = ARGF.read
 ## split to paras, fixing inline code blocks
-mdpart = PlainText::Part.parse(strin)
+mdpara = PlainText::Part.parse(strin)
 
-indent_prev = last_indent(mdpart[0])
-mdpart.merge_para_if{ |pbp, _, _|
+indent_prev = last_indent(mdpara[0])
+mdpara.merge_para_if{ |pbp, _, _|
   prev_cb = md_code_block?(pbp[0], indent_prev)
   next_cb = md_code_block?(pbp[2], indent_prev)
   next true if prev_cb && next_cb
@@ -196,7 +196,7 @@ mdpart.merge_para_if{ |pbp, _, _|
 }
 
 indent_next = 0
-mdpart = mdpart.map_part{|ec|
+mdpara = mdpara.map_para{|ec|
   indent_prev = indent_next
   indent_next = last_indent(ec, indent_prev)
   next fix_string_based(ec) if !md_code_block?(ec, indent_prev)
@@ -205,7 +205,7 @@ mdpart = mdpart.map_part{|ec|
   "%s```%s\n%s\n%s```"%[inde, opts[:lang], st, inde, opts[:lang]]
 }
 
-puts mdpart.join('')
+puts mdpara.join('')
 
 exit
 

data/lib/plain_text.rb

@@ -336,9 +336,9 @@ module PlainText
     # Linebreaks and spaces
     case lbs_style
     when :truncate,   :t
-      prt.parts.each{|ec| ec.gsub!(/\n{2,}/m, "\n")}
+      prt.paras.each{|ec| ec.gsub!(/\n{2,}/m, "\n")}
     when :delete,   :d
-      prt.parts.each{|ec| ec.gsub!(/\n/m, "")}
+      prt.paras.each{|ec| ec.gsub!(/\n/m, "")}
     when :none, :n
       # Does nothing
     else
@@ -350,13 +350,13 @@ module PlainText
 
     # Linebreaks become spaces
     if lb_is_space
-      prt.parts.each{|ec| ec.gsub!(/\n/m, " ")}
+      prt.paras.each{|ec| ec.gsub!(/\n/m, " ")}
       clean_text_sps!(prt, sps_style: sps_style, is_debug: is_debug) if sps_style == :truncate
     end
 
     # Ignore spaces between, before, and after Asian characters.
     if delete_asian_space
-      prt.parts.each do |ea_p|
+      prt.paras.each do |ea_p|
         PlainText.extend_this(ea_p)
         ea_p.delete_spaces_bw_cjk_european!  # Destructive change in prt.
       end
@@ -380,9 +380,9 @@ module PlainText
     # Head of each line
     case linehead_style
     when :truncate, :t
-      prt.parts.each{|ec| ec.gsub!(/^[[:blank:]]+/, " ")}
+      prt.paras.each{|ec| ec.gsub!(/^[[:blank:]]+/, " ")}
     when :delete, :d
-      prt.parts.each{|ec| ec.gsub!(/^[[:blank:]]+/, "")}
+      prt.paras.each{|ec| ec.gsub!(/^[[:blank:]]+/, "")}
     when :none, :n
       # Do nothing
     else
@@ -392,13 +392,13 @@ module PlainText
     # Tail of each line
     case linetail_style
     when :truncate, :t
-      prt.parts.each{|ec| ec.gsub!(/[[:blank:]]+$/, " ")}
+      prt.paras.each{|ec| ec.gsub!(/[[:blank:]]+$/, " ")}
     when :delete, :d
-      prt.parts.each{|ec| ec.gsub!(/[[:blank:]]+$/, "")}
+      prt.paras.each{|ec| ec.gsub!(/[[:blank:]]+$/, "")}
     when :markdown, :m
       # Two spaces are preserved
-      prt.parts.each{|ec| ec.gsub!(/(?:^|(?<![[:blank:]]))[[:blank:]]$/, "")}  # A single space is deleted.
-      prt.parts.each{|ec| ec.gsub!(/[[:blank:]]+  $/, "  ")}  # 3 or more spaces are truncated into 2 spaces, only IF the last two spaces are the ASCII spaces.
+      prt.paras.each{|ec| ec.gsub!(/(?:^|(?<![[:blank:]]))[[:blank:]]$/, "")}  # A single space is deleted.
+      prt.paras.each{|ec| ec.gsub!(/[[:blank:]]+  $/, "  ")}  # 3 or more spaces are truncated into 2 spaces, only IF the last two spaces are the ASCII spaces.
     when :none, :n
       # Do nothing
     else
@@ -499,10 +499,10 @@ module PlainText
         is_debug: false
       )
 
-    prt.parts.each do |e_pa|
+    prt.paras.each do |e_pa|
       # Each line treated as a Paragraph, and [[:space:]]+ between them as a Boundary.
       # Then, to work on anything within a line except for line-head/tail is easy.
-      prt_para = Part.parse(e_pa, rule: ParseRule::RuleEachLineStrip).map_part { |e_li|
+      prt_para = Part.parse(e_pa, rule: ParseRule::RuleEachLineStrip).map_para { |e_li|
         case sps_style
         when :truncate, :t
           e_li.gsub(/[[:blank:]]{2,}/m, " ")
@@ -513,7 +513,7 @@ module PlainText
         else
           raise ArgumentError
         end
-      } # map_part
+      } # map_para
       e_pa.replace prt_para.join
     end
   end

data/lib/plain_text/parse_rule.rb

@@ -12,8 +12,8 @@ module PlainText
   # which returns an Array (referred to as +ary+ hereafter).
   #
   # The returned array +ary+ may contain Strings at the basic level.  In that case,
-  # any even elements are semantically {PlainText::Part::Boundary} and any odd elements are
-  # semantically {PlainText::Part::Paragraph} or {PlainText::Part}, which can be further parsed
+  # any odd-index elements are semantically Boundaries ({PlainText::Part::Boundary}) and any even-index elements are
+  # semantically Paras ({PlainText::Part::Paragraph} or {PlainText::Part}), which can be further parsed
   # in the later processing.
   #
   # Alternatively, the returned array +ary+ may contain
@@ -78,7 +78,7 @@ module PlainText
   #
   # Then,
   #
-  #   pt1.parts[0].parts[1] # => Paragraph::Title("Breaking!")
+  #   pt1.paras[0].paras[1] # => Paragraph::Title("Breaking!")
   #   pt1.boundaries[1]     # => Boundary("\n======\n")
   #
   # @todo

data/lib/plain_text/part.rb

@@ -42,7 +42,7 @@ module PlainText
   #     (5) Boundary::General
   #   )
   #
-  # A Section (Part) always has an even number of elements: pairs of ({Part}|{Paragraph}) and {Boundary} in this order.
+  # A Section (Part) always has an even number of elements: pairs of a Para ({Part}|{Paragraph}) and {Boundary} in this order.
   #
   # Note some standard destructive Array operations, most notably +#delete+, +#delete_if+, +#reject!+,
   # +#select!+, +#filter!+, +#keep_if+, +#flatten!+, +#uniq!+ may alter the content in a way
@@ -83,7 +83,7 @@ module PlainText
     }
     private_constant :ERR_MSGS
 
-    # @param arin [Array] of [Paragraph1, Boundary1, Para2, Bd2, ...] or Part/Paragraph if boundaries is given
+    # @param arin [Array] of [Paragraph1, Boundary1, Para2, Bd2, ...] or just Paragraphs if boundaries is given as the second arguments
     # @param boundaries [Array] of Boundary
     # @option recursive: [Boolean] if true (Default), normalize recursively.
     # @option compact: [Boolean] if true (Default), pairs of nil paragraph and boundary are removed.  Otherwise, nil is converted to an empty string.
@@ -122,10 +122,10 @@ module PlainText
     # Unique instance methods (not existing in Array)
     ##########
 
-    # Returns an array of boundary parts (odd-number-index parts), consisting of Boundaries
+    # Returns an array of boundaries (odd-number-index elements), consisting of Boundaries
     #
     # @return [Array<Boundary>]
-    # @see #parts
+    # @see #paras
     def boundaries
       select.with_index { |_, i| i.odd? } rescue select.each_with_index { |_, i| i.odd? } # Rescue for Ruby 2.1 or earlier
     end
@@ -167,20 +167,20 @@ module PlainText
       map_boundary_core(map: false, with_index: true, **kwd, &bl)
     end
 
-    # each method for parts only, providing also the index (always an even number) to the block.
+    # each method for Paras only, providing also the index (always an even number) to the block.
     #
-    # For just looping over the elements of {#parts}, do simply
+    # For just looping over the elements of {#paras}, do simply
     #
-    #   parts.each do |ec|
+    #   paras.each do |ec|
     #   end
     #
     # The indices provided in this method are for the main Array,
-    # and hence different from {#parts}.each_with_index
+    # and hence different from {#paras}.each_with_index
     #
-    # @param (see #map_part_with_index)
+    # @param (see #map_para_with_index)
     # @return as self
-    def each_part_with_index(**kwd, &bl)
-      map_part_core(map: false, with_index: false, **kwd, &bl)
+    def each_para_with_index(**kwd, &bl)
+      map_para_core(map: false, with_index: false, **kwd, &bl)
     end
 
     # The first significant (=non-empty) element.
@@ -210,7 +210,7 @@ module PlainText
     #
     # @param i [Integer] index for the array of self
     # @option skip_check: [Boolean] if true (Default: false), skip conversion of the negative index to positive.
-    # @see #parts
+    # @see #paras
     def index_para?(i, skip_check: false)
       skip_check ? i.even? : positive_array_index_checked(i, self).even?
     end
@@ -261,9 +261,9 @@ module PlainText
       map_boundary_core(with_index: true, **kwd, &bl)
     end
 
-    # map method for parts only, returning a copied self.
+    # map method for Paras only, returning a copied self.
     #
-    # If recursive is true (Default), any Paragraphs in the descendant Parts are also handled.
+    # If recursive is true (Default), any Paras in the descendant Parts are also handled.
     #
     # If a Paragraph is set nil or empty, along with the following Boundary,
     # the pair is removed from the returned instance in Default (:compact and :compacter options
@@ -272,30 +272,30 @@ module PlainText
     # @option recursive: [Boolean] if true (Default), map is performed recursively.
     # @return as self
     # @see #initialize for the other options (:compact and :compacter)
-    def map_part(**kwd, &bl)
-      map_part_core(with_index: false, **kwd, &bl)
+    def map_para(**kwd, &bl)
+      map_para_core(with_index: false, **kwd, &bl)
     end
 
-    # map method for parts only, providing also the index (always an even number) to the block, returning a copied self.
+    # map method for paras only, providing also the index (always an even number) to the block, returning a copied self.
     #
-    # @param (see #map_part)
+    # @param (see #map_para)
     # @return as self
-    def map_part_with_index(**kwd, &bl)
-      map_part_core(with_index: false, **kwd, &bl)
+    def map_para_with_index(**kwd, &bl)
+      map_para_core(with_index: false, **kwd, &bl)
     end
 
-    # merge parts/paragraphs if they satisfy the conditions.
+    # merge Paras if they satisfy the conditions.
     #
-    # A group of two Parts/Paragraphs and the Boundaries in between and before and after
+    # A group of two Paras and the Boundaries in between and before and after
     # is passed to the block consecutively.
     #
     # @yield [ary, b1, b2, i] Returns true if the two paragraphs should be merged.
     # @yieldparam [Array] ary of [Para1st, BoundaryBetween, Para2nd]
-    # @yieldparam [Boundary] b1 Boundary-String before the first part/paragraph (nil for the first one)
-    # @yieldparam [Boundary] b2 Boundary-String after the second part/paragraph
+    # @yieldparam [Boundary] b1 Boundary-String before the first Para (nil for the first one)
+    # @yieldparam [Boundary] b2 Boundary-String after the second Para
     # @yieldparam [Integer] i Index of the first Para
     # @yieldreturn [Boolean, Symbol] True if they should be merged.  :abort if cancel it.
-    # @return [self, false] false if no pairs of parts/paragraphs are merged, else self.
+    # @return [self, false] false if no pairs of Paras are merged, else self.
     def merge_para_if()
       arind2del = []  # Indices to delete (both paras and boundaries)
       each_index do |ei|
@@ -328,7 +328,7 @@ module PlainText
     # @overload set(range)
     #   With a range of the indices to merge. Unless use_para_index is true, this means the main Array index. See the first overload set about it.
     #   @param range [Range] describe value param
-    # @param use_para_index: [Boolean] If false (Default), the indices are for the main indices (alternative between Parts/Paragraphs and Boundaries, starting from Part/Paragraph). If true, the indices are as obtained with {#parts}, namely the array containing only Parts/Paragraphs.
+    # @param use_para_index: [Boolean] If false (Default), the indices are for the main indices (alternative between Paras and Boundaries, starting from Para). If true, the indices are as obtained with {#paras}, namely the array containing only Paras.
     # @return [self, nil] nil if nothing is merged (because of wrong indices).
     def merge_para!(*rest, use_para_index: false)
 $myd = true
@@ -449,11 +449,11 @@ $myd = false
     end
 
 
-    # Returns an array of substantial parts (even-number-index parts), consisting of Part and/or Paragraph
+    # Returns an array of Paras (even-number-index elements), consisting of Part and/or Paragraph
     #
     # @return [Array<Part, Paragraph>]
     # @see #boundaries
-    def parts
+    def paras
       select.with_index { |_, i| i.even? } rescue select.each_with_index { |_, i| i.even? } # Rescue for Ruby 2.1 or earlier
       # ret.freeze
     end
@@ -581,7 +581,7 @@ $myd = false
     # @param other [Object]
     def ==(other)
       return false if !other.class.method_defined?(:to_ary)
-      %i(parts boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
+      %i(paras boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
         return false if !other.class.method_defined?(ea_m) || (self.public_send(ea_m) != other.public_send(ea_m))  # public_send() defined in Ruby 2.0 (1.9?) and later
       end
       super
@@ -603,20 +603,20 @@ $myd = false
     # @return as self
     def +(other)
       # ## The following is strict, but a bit redundant.
-      # # is_part = true  # Whether "other" is a Part class instance.
-      # # %i(to_ary parts boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
-      # #   is_part &&= other.class.method_defined?(ea_m)
+      # # is_para = true  # Whether "other" is a Part class instance.
+      # # %i(to_ary paras boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
+      # #   is_para &&= other.class.method_defined?(ea_m)
       # # end
 
       # begin
       #   other_even_odd = 
-      #     ([other.parts, other.boundaries] rescue even_odd_arrays(self, size_even: true, filler: ""))
+      #     ([other.paras, other.boundaries] rescue even_odd_arrays(self, size_even: true, filler: ""))
       # rescue NoMethodError
       #   raise TypeError, sprintf("no implicit conversion of %s into %s", other.class.name, self.class.name)
       # end
 
       # # eg., if self is PlainText::Part::Section, the returned object is the same.
-      # ret = self.class.new(self.parts+other_even_odd[0], self.boundaries+other_even_odd[1])
+      # ret = self.class.new(self.paras+other_even_odd[0], self.boundaries+other_even_odd[1])
       ret = self.class.new super
       ret.normalize!
     end
@@ -733,7 +733,7 @@ $myd = false
       # The result may not be in an even number anymore.  Correct it.
       Boundary.insert_original_b4_part(size, "") if size.odd?
 
-      # Original method may fill some part of the array with String or even nil.  
+      # Original method may fill some elements of the array with String or even nil.  
       normalize!
       ret
     end
@@ -892,7 +892,7 @@ $myd = false
     # @return [Integer, nil] nil if a too large index is specified.
     def get_valid_ipos_for_boundary(index)
       i_pos = positive_array_index_checked(index, self)
-      raise ArgumentError, "Index #{index} specified was for Part/Paragraph, which should be for Boundary." if index_para?(i_pos, skip_check: true)
+      raise ArgumentError, "Index #{index} specified was for Para, which should be for Boundary." if index_para?(i_pos, skip_check: true)
       (i_pos > size - 1) ? nil : i_pos
     end
     private :get_valid_ipos_for_boundary
@@ -920,16 +920,16 @@ $myd = false
     end
     private :map_boundary_core
 
-    # Core routine for {#map_part}
+    # Core routine for {#map_para}
     #
     # @option map: [Boolean] if true (Default), map is performed. Else just each.
     # @option with_index: [Boolean] if true (Default: false), yield with also index
     # @option recursive: [Boolean] if true (Default), map is performed recursively.
     # @return as self
     # @see #initialize for the other options (:compact and :compacter)
-    def map_part_core(map: true, with_index: false, recursive: true, **kwd, &bl)
+    def map_para_core(map: true, with_index: false, recursive: true, **kwd, &bl)
       ind = -1
-      new_parts = parts.map{ |ec|
+      new_paras = paras.map{ |ec|
         ind += 1
         if recursive && ec.class.method_defined?(__method__)
           ec.public_send(__method__, recursive: true, **kwd, &bl)
@@ -937,9 +937,9 @@ $myd = false
           with_index ? yield(ec, ind) : yield(ec)
         end
       }
-      self.class.new new_parts, boundaries, recursive: recursive, **kwd if map
+      self.class.new new_paras, boundaries, recursive: recursive, **kwd if map
     end
-    private :map_part_core
+    private :map_para_core
 
     # Core routine for {#normalize!} and {#normalize}
     #
@@ -1051,7 +1051,7 @@ class Array
   # @param other [Object]
   def ==(other)
     return false if !other.class.method_defined?(:to_ary)
-    %i(parts boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
+    %i(paras boundaries).each do |ea_m|  # %i(...) defined in Ruby 2.0 and later
       return equal_original_b4_part?(other) if !other.class.method_defined?(ea_m)
       return false if !self.class.method_defined?(ea_m) || (self.public_send(ea_m) != other.public_send(ea_m))  # public_send() defined in Ruby 2.0 (1.9?) and later
     end

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.5.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.6".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|

data/test/test_plain_text_part.rb

@@ -50,7 +50,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     # p pt1.to_a.class
     assert_equal a1[0], pt1[0]
     assert_equal a1[1], pt1[1]
-    assert_equal ap1,   pt1.parts
+    assert_equal ap1,   pt1.paras
     assert_equal ab1,   pt1.boundaries
     assert_equal a1,    pt1.to_a
     assert_operator a1,  '!=', pt1
@@ -59,7 +59,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     pt2 = Pt.new(a2)
     assert_equal a2[0], pt2[0]
     assert_equal a2[2], pt2[2]
-    assert_equal ap2,   pt2.parts
+    assert_equal ap2,   pt2.paras
     assert_equal ab2,   pt2.boundaries
     assert_equal a2+[""], pt2.to_a  # An empty String is appended.
     assert_operator a2,  '!=', pt2
@@ -196,7 +196,7 @@ class TestUnitPlainTextPart < MiniTest::Test
 
     pt2 = pt1[0, 4]
     assert_equal pt1.class,            pt2.class
-    assert_equal pt1.parts[0, 2],      pt2.parts
+    assert_equal pt1.paras[0, 2],      pt2.paras
     assert_equal pt1.boundaries[0, 2], pt2.boundaries
 
     # negative or too-big out-of-bound begin
@@ -337,7 +337,7 @@ class TestUnitPlainTextPart < MiniTest::Test
     #     0 1  2 3  4 5  6 7  8 9
     pt1 = Pt.parse s1
     assert_equal 10, pt1.size
-    assert_equal  5, pt1.parts.size
+    assert_equal  5, pt1.paras.size
     assert_equal "b\n\n",      pt1[2..3].join
 
     pt2 = pt1.dup
@@ -417,8 +417,8 @@ class TestUnitPlainTextPart < MiniTest::Test
     s1 = "a\n\n\nb\n\n\nc\n\n"
     pt1 = Pt.parse s1
     assert_equal 6, pt1.size
-    assert_equal 3, pt1.parts.size
-    assert_equal %w(a b c), pt1.parts
+    assert_equal 3, pt1.paras.size
+    assert_equal %w(a b c), pt1.paras
     assert_equal Pt::Paragraph, pt1[0].class
     assert_equal Pt::Boundary,  pt1[1].class
     assert_equal s1,  pt1.join

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plain_text
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: '0.6'
 platform: ruby
 authors:
 - Masa Sakano