plain_text 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0bbafc2df85dc7fab4a71b03126805e7f2e9916ae0e3fee91e31d9584e5a6ee
-  data.tar.gz: b385be9df6ce8d8c1081a8c5a233daaa60659ccc25c44722c4a333d8cb81a8c0
+  metadata.gz: e80b87e7f19d6f0e9799371f333126010239270db7026d001d7f97f11ec37146
+  data.tar.gz: 17882ccf6af631b485a7548e01b594423e525bdf154c246adebe97862bfc0d3a
 SHA512:
-  metadata.gz: c3fb2676c18ad0f3e637fc4bac35af7b7fba6d664c852265cd59485d0909dd4e6739c8a4dc12257016472ef31ac8719ed85be061abfe9955a4adf5fcb8b16d29
-  data.tar.gz: dfa034f4130c02aa7ba12817da0395b78f5d6dfcfd349a80966a20e8aa98652ec4c2d2b8c4762b65d25dbfbe39244c2375663085b2189077a04a732300ca6dc7
+  metadata.gz: 8faa943dddd4f29791e39403db20c5967fe101b7cb7c8b3d72e3d601d9d0abcafdac78eb3e3d8d6a0a82140651ff8e0d91fba759013d724ff1676c4c4275136b
+  data.tar.gz: 37dbb8cb4a40b8cd53e85c41158cf1a1da2740805138b4845de44b7212fc708b1e8759febc3950b8fc13555512616d0104d54c043950282eed37f660959dbb56

data/ChangeLog

@@ -1,3 +1,31 @@
+-----
+(Version: 0.5)
+2019-11-07  Masa Sakano
+  * bin/head.rb, bin/tail.rb (hence `lib/plain_text.rb`)
+    * "-p|--padding" option added.
+    * Algorithm in `PlainText#tail_regexp` well simplified.
+    * Some boundary-condtion bugs fixed.
+  * `PlainText#Split` (`lib/plain_text/split.rb`)
+    * Added public methods {#count_regexp} and {#count_lines} and their corresponding class methods.
+  * New Ruby executable script: `bin/yard2md_afterclean`
+
+-----
+2019-11-06  Masa Sakano
+  * head.rb, tail.rb
+    * "-i|--[no]-inverse" command-line option renamed to "-r|--[no-]reverse"
+    * "-i|--[no-]ignore-case" option added.
+    * "-m|--[no-]multi-line" option added.
+
+-----
+2019-11-06  Masa Sakano
+  * PlainText::Util (`plain_text/util.rb`)
+    * All the methods are now private.
+    * New dedicated test code file: `lib/plain_text/util.rb`
+  * PlainText::Part (`plain_text/part.rb`)
+    * Two new public methods `merge_para!` and `merge_para_if`
+  * head.rb, tail.rb (hence `plain_text.rb`)
+    * Fixed a critical bug in the null case with a Regexp option.
+
 -----
 (Version: 0.4)
 2019-10-29  Masa Sakano

data/README.en.rdoc

@@ -11,6 +11,11 @@ This package also provides a few command-line programs, such as counting the num
 of characters (especially useful for documents in Asian (CJK)
 chatacters) and advanced head/tail commands.
 
+The master of this README file, as well as the document for all the methods, is found in
+{RubyGems/plain_text}[https://rubygems.org/gems/plain_text]
+and in {Github}[https://github.com/masasakano/plain_text]
+where all the hyperlinks are active.
+
 == Design concept
 
 === PlainText - Module and root Namespace
@@ -104,6 +109,7 @@ help message.
 Counts the number of characters in a file(s) or STDIN.
 
 The simplest example to run the command-line script is
+
    countchar YourFile.txt
 
 === textclean
@@ -116,9 +122,9 @@ into 2.  See the reference of {PlainText.clean_text} for detail.
 
 This gives advanced functions, in addition to the standard +head+, including
 
-Regexp:: It can accept Ruby Regexp to determine the boundary (beginning to the first-matched line).
+Regexp:: It can accept Ruby Regexp to determine the boundary (beginning to the first-matched line), including ignore-case, multi-line, extra *padding-line* etc.
 Character-based:: With +--char+ option, it handles the file in units of a chracter, which is especially handy to deal with multi-byte characters like UTF-8.
-Inverse:: It can inverse the counting to ouput everything but initial NUM lines.
+Reverse:: It can *reverese* the behaviour - inverse the counting to ouput everything but initial NUM lines.
 
 A few examples are
 
@@ -130,10 +136,17 @@ A few examples are
     # The same as the UNIX command:  tail -n +5
   
   head.rb -e '^===+' try.txt
-    # => first line up to the line that begins with more than 3 "="
+    # => from the top up to the line that begins with more than 3 "="
   
   head.rb -x -e '^===+' try.txt
-    # => first line up to the line before what begins with more than 3 "="
+    # => from the top up to the line before what begins with more than 3 "="
+
+  head.rb -e '^===+' -p 3 try.txt
+    # => from the top up to 3 lines after what begins with more than 3 "="
+
+  head.rb -e '([a-z])\1$' --padding=-2 try.txt
+    # => from the top up to 2 lines before what ends with 2
+    #    consecutive same letters (case-insentive) like "AA" or "qQ"
 
 The suffix +.rb+ is used to distinguish this command from the UNIX-shell standard command.
 
@@ -141,9 +154,11 @@ The suffix +.rb+ is used to distinguish this command from the UNIX-shell standar
 
 This gives advanced functions, in addition to the standard +tail+, including
 
-Regexp:: It can accept Ruby Regexp to determine the boundary (last-matched line to the end).
+Regexp:: It can accept Ruby Regexp to determine the boundary (last-matched line to the end), including ignore-case, multi-line, extra *padding-line* etc.
 Character-based:: With +--char+ option, it handles the file in units of a chracter, which is especially handy to deal with multi-byte characters like UTF-8.
-Inverse:: It can inverse the counting to ouput everything but the last NUM lines.
+Reverse:: It can *reverese* the behaviour - inverse the counting to ouput everything but the last NUM lines.
+
+See +head.rb+ for practical examples.
 
 Note the UNIX form of
 
@@ -155,6 +170,18 @@ Note the UNIX form of
 
 The suffix +.rb+ is used to distinguish this command from the UNIX-shell standard command.
 
+=== yard2md_afterclean
+
+This stands for "yard to markdown - after-clean".  
+
+The standard conversion way of RDoc (written for yard) with +rdoc+ library
+
+RDoc::Markup::ToMarkdown.new.convert
+
+is limited, with the produced markdown having a fair number of flaws.
+This command tries to botch-fix it.  The result is
+still not perfect but does some good automation job.
+
 == Miscellaneous
 
 Module {PlainText::Split} contains an instance method (and class
@@ -188,19 +215,36 @@ Work in progress...
 This script requires {Ruby}[http://www.ruby-lang.org] Version 2.0
 or above (possibley 2.2 or above?).
 
-As for the command-line script file, it can be put in any of your command-line search
+For use of the library, if your Ruby script declares
+
+  require "plain_text"
+
+all the related libraries should be read.
+If you +include PlainText+ from String, it would be handy, though
+not mandatory to use this library.
+
+As for the command-line script files, they can be put in any of your command-line search
 paths.  Make sure the RUBYLIB environment
 variable contains the library directory to this gem, which is
+
    /THIS/GEM/LIBRARY/PATH/plain_text/lib
 
+(which should be set automatically, as long as you use the standard Gem environment).
 You may need to modify the first line (Shebang line) of the script to suit your
 environment (it should be unnecessary for Linux and MacOS), or run it
 explicitly with your Ruby command as
+
    Prompt% /YOUR/ENV/ruby /YOUR/INSTALLED/countchar
 
 == Developer's note
 
-The source code is maintained also in {Github}[https://github.com/masasakano/plain_text]
+The source codes are annotated in the {YARD}[https://yardoc.org/] format. You
+can view it in
+{RubyGems/plain_text}[https://rubygems.org/gems/plain_text] .
+
+The source code is maintained also in
+{Github}[https://github.com/masasakano/plain_text] (no intuitive
+interface for annotation)
 
 === Tests
 

data/bin/head.rb

@@ -13,10 +13,13 @@ __EOF__
 OPTS = {
   num: PlainText::DEF_HEADTAIL_N_LINES, 
   unit: :line,
+  ignore_case: false,
   inclusive: true,
-  inverse: false,  # unique option
+  inverse: false,  # Option --reverse
+  multi_line: false,
+  padding: 0,
   # :chatter => 3,        # Default
-  debug: false,
+  # debug: false,
 }
 
 # Function to handle the command-line arguments.
@@ -31,14 +34,19 @@ def handle_argv
   opt.on('-n NUM', '--line=NUM', sprintf("Number of lines (Def: %d).", PlainText::DEF_HEADTAIL_N_LINES), Integer) { |v| OPTS[:num]=v }
   opt.on('-c NUM', '--byte=NUM', sprintf("Number of bytes, instead of lines."), Integer) { |v| OPTS[:unit] = :byte; OPTS[:num]=v }
   opt.on(  '--char=NUM',    sprintf("Number of characters, instead of lines."), Integer) { |v| OPTS[:unit] = :char; OPTS[:num]=v }
-  opt.on('-e REGEXP', '--regexp=REGEXP', sprintf("Regexp for the boundary, instead of a number.", (!OPTS[:num]).inspect)) {|v| OPTS[:num] = Regexp.new v}
+  opt.on('-e REGEXP', '--regexp=REGEXP', sprintf("Regexp for the boundary, instead of a number.", (!OPTS[:num]).inspect)) {|v| OPTS[:num] = v}
+  opt.on('-i', '--[no-]ignore-case', sprintf("Ignore case distinctions in Regexp (Def: %s)", (!OPTS[:ignore_case]).inspect), TrueClass) {|v| OPTS[:ignore_case] = v}
+  opt.on('-m', '--[no-]multi-line', sprintf("Multi-line match (option m) in Regexp (Def: %s)", (!OPTS[:multi_line]).inspect), TrueClass) {|v| OPTS[:multi_line] = v}
   opt.on('-x', '--[no-]exclusive', sprintf("The line that matches is excluded? (Def: %s)", (!OPTS[:inclusive]).inspect), FalseClass) {|v| OPTS[:inclusive] = v}
-  opt.on('-i', '--[no-]inverse', sprintf("Inverse the result (print after NUM-th line) (Def: %s)", (!OPTS[:inverse]).inspect), TrueClass) {|v| OPTS[:inverse] = v}
+  opt.on('-p NUM', '--padding=NUM', sprintf("The number of lines included as 'padding' below the matched line (Def: %s)", (!OPTS[:padding]).inspect), Integer) {|v| OPTS[:padding] = v}
+  opt.on('-r', '--[no-]reverse', sprintf("Reverse the behaviour (run AFTER - (inc|ex)clusive and padding) (Def: %s)", (!OPTS[:inverse]).inspect), TrueClass) {|v| OPTS[:inverse] = v}  # WARNING-NOTE: the Hash keyword is "inverse" as opposed to "reverse"
   # opt.on(  '--version', "Display the version and exits.", TrueClass) {|v| OPTS[:version] = v}  # Consider opts.on_tail
   # opt.on(  '--[no-]debug', "Debug (Def: false)", TrueClass) {|v| OPTS[:debug] = v}
   # opt.separator ""        # Way to control a help message.
-  # opt.separator "Note:"
-  # opt.separator " Spaces are truncated in default."
+  opt.separator "Note:"
+  opt.separator "  Option -m means '.' includes a newline. '\\s' includes it regardless."
+  opt.separator "  'Padding' (-p) is calculated after Option -x is considered."
+  opt.separator "  Negative 'Padding' like '--padding=-3' reduces the number of lines by 3."
 
   begin
     opt.parse!(ARGV)
@@ -48,6 +56,12 @@ def handle_argv
     exit 1
   end
 
+  if OPTS[:num].respond_to? :to_str
+    # Regexp specified with --regexp=REGEXP
+    cond =  (0 | (OPTS[:ignore_case] ? Regexp::IGNORECASE : 0) | (OPTS[:multi_line] ? Regexp::MULTILINE : 0))
+    OPTS[:num] = Regexp.new OPTS[:num], cond
+  end
+
   OPTS
 end
 
@@ -67,19 +81,19 @@ end
 opts = handle_argv()
 num_in = opts[:num]
 is_inverse = opts[:inverse]
+# $DEBUG = true if opts[:debug]  # Better specify by running this script with ruby --debug
 
-%i(num inverse debug).each do |ek|
+%i(num ignore_case inverse multi_line debug).each do |ek|
   opts.delete ek if opts.has_key? ek
 end
 
 str = ARGF.read
 
-# A linebreak guaranteed at the end.
-if is_inverse
-  puts PlainText.head_inverse(str, num_in, **opts)
-else
-  puts PlainText.head(str, num_in, **opts)
-end
+method = (is_inverse ? :head_inverse : :head)
+sout = PlainText.public_send(method, str, num_in, **opts)
+
+# A linebreak guaranteed at the end, unless it is empty.
+puts sout if !sout.empty?
 
 exit
 

data/bin/tail.rb

@@ -13,10 +13,13 @@ __EOF__
 OPTS = {
   num: PlainText::DEF_HEADTAIL_N_LINES, 
   unit: :line,
+  ignore_case: false,
   inclusive: true,
-  inverse: false,  # unique option
+  inverse: false,  # Option --reverse
+  multi_line: false,
+  padding: 0,
   # :chatter => 3,        # Default
-  debug: false,
+  # debug: false,
 }
 
 # Function to handle the command-line arguments.
@@ -31,14 +34,21 @@ def handle_argv
   opt.on('-n NUM', '--line=NUM', sprintf("Number of lines (Def: %d).", PlainText::DEF_HEADTAIL_N_LINES), Integer) { |v| OPTS[:num]=v }
   opt.on('-c NUM', '--byte=NUM', sprintf("Number of bytes, instead of lines."), Integer) { |v| OPTS[:unit] = :byte; OPTS[:num]=v }
   opt.on(  '--char=NUM',    sprintf("Number of characters, instead of lines."), Integer) { |v| OPTS[:unit] = :char; OPTS[:num]=v }
-  opt.on('-e REGEXP', '--regexp=REGEXP', sprintf("Regexp for the boundary, instead of a number.", (!OPTS[:num]).inspect)) {|v| OPTS[:num] = Regexp.new v}
+  opt.on('-e REGEXP', '--regexp=REGEXP', sprintf("Regexp for the boundary, instead of a number.", (!OPTS[:num]).inspect)) {|v| OPTS[:num] = v}
+  opt.on('-i', '--[no-]ignore-case', sprintf("Ignore case distinctions in Regexp (Def: %s)", (!OPTS[:ignore_case]).inspect), TrueClass) {|v| OPTS[:ignore_case] = v}
+  opt.on('-m', '--[no-]multi-line', sprintf("Multi-line match (option m) in Regexp (Def: %s)", (!OPTS[:multi_line]).inspect), TrueClass) {|v| OPTS[:multi_line] = v}
   opt.on('-x', '--[no-]exclusive', sprintf("The line that matches is excluded? (Def: %s)", (!OPTS[:inclusive]).inspect), FalseClass) {|v| OPTS[:inclusive] = v}
-  opt.on('-i', '--[no-]inverse', sprintf("Inverse the result (print after NUM-th line) (Def: %s)", (!OPTS[:inverse]).inspect), TrueClass) {|v| OPTS[:inverse] = v}
+  opt.on('-p NUM', '--padding=NUM', sprintf("The number of lines included as 'padding' below the matched line (Def: %s)", (!OPTS[:padding]).inspect), Integer) {|v| OPTS[:padding] = v}
+  opt.on('-p NUM', '--padding=NUM', sprintf("The number of lines included as 'padding' below the matched line (Def: %s)", (!OPTS[:padding]).inspect), Integer) {|v| OPTS[:padding] = v}
+  opt.on('-r', '--[no-]reverse', sprintf("Reverse the behaviour (run AFTER - (inc|ex)clusive and padding) (Def: %s)", (!OPTS[:inverse]).inspect), TrueClass) {|v| OPTS[:inverse] = v}  # WARNING-NOTE: the Hash keyword is "inverse" as opposed to "reverse"
   # opt.on(  '--version', "Display the version and exits.", TrueClass) {|v| OPTS[:version] = v}  # Consider opts.on_tail
   # opt.on(  '--[no-]debug', "Debug (Def: false)", TrueClass) {|v| OPTS[:debug] = v}
   opt.separator ""        # Way to control a help message.
   opt.separator "Note:"
-  opt.separator "  UNIX command of 'tail -n +5' is equivalent to 'head.rb -i -n 5'"
+  opt.separator "  UNIX command of 'tail -n +5' is equivalent to 'head.rb --reverse -n 5'"
+  opt.separator "  Option -m means '.' includes a newline. '\\s' includes it regardless."
+  opt.separator "  'Padding' (-p) is calculated after Option -x is considered."
+  opt.separator "  Negative 'Padding' like '--padding=-3' reduces the number of lines by 3."
 
   begin
     opt.parse!(ARGV)
@@ -48,6 +58,12 @@ def handle_argv
     exit 1
   end
 
+  if OPTS[:num].respond_to? :to_str
+    # Regexp specified with --regexp=REGEXP
+    cond =  (0 | (OPTS[:ignore_case] ? Regexp::IGNORECASE : 0) | (OPTS[:multi_line] ? Regexp::MULTILINE : 0))
+    OPTS[:num] = Regexp.new OPTS[:num], cond
+  end
+
   OPTS
 end
 
@@ -67,19 +83,19 @@ end
 opts = handle_argv()
 num_in = opts[:num]
 is_inverse = opts[:inverse]
+# $DEBUG = true if opts[:debug]  # Better specify by running this script with ruby --debug
 
-%i(num inverse debug).each do |ek|
+%i(num ignore_case inverse multi_line debug).each do |ek|
   opts.delete ek if opts.has_key? ek
 end
 
 str = ARGF.read
 
-# A linebreak guaranteed at the end.
-if is_inverse
-  puts PlainText.tail_inverse(str, num_in, **opts)
-else
-  puts PlainText.tail(str, num_in, **opts)
-end
+method = (is_inverse ? :tail_inverse : :tail)
+sout = PlainText.public_send(method, str, num_in, **opts)
+
+# A linebreak guaranteed at the end, unless it is empty.
+puts sout if !sout.empty?
 
 exit
 

data/bin/yard2md_afterclean

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'optparse'
+require 'open3'
+require 'plain_text'
+
+BANNER = <<"__EOF__"
+USAGE: #{File.basename($0)} [options] [INFILE.txt] < STDIN
+  Clean the partially ill-formated (Github) Markdown converted from yard-Rdoc.
+__EOF__
+
+# Initialising the hash for the command-line options.
+OPTS = {
+  lang: 'ruby',
+  # :chatter => 3,        # Default
+  debug: false,
+}
+
+# Function to handle the command-line arguments.
+#
+# ARGV will be modified, and the constant variable OPTS is set.
+#
+# @return [Hash]  Optional-argument hash.
+#
+def handle_argv
+  opt = OptionParser.new(BANNER)
+  opt.on(  '--lang=LANGUAGE', sprintf("Programming Language like ruby (Def: %s).", OPTS[:lang])) { |v| OPTS[:lang]=v.strip }
+  # opt.on(  '--version', "Display the version and exits.", TrueClass) {|v| OPTS[:version] = v}  # Consider opts.on_tail
+  opt.on(  '--[no-]debug', "Debug (Def: false)", TrueClass) {|v| OPTS[:debug] = v}
+  # opt.separator ""        # Way to control a help message.
+  # opt.separator "Note:"
+  # opt.separator " Spaces are truncated in default."
+
+  opt.parse!(ARGV)
+
+  OPTS
+end
+
+def fix_string_based(str)
+  fix_def_list(
+    fix_inline_link(
+      fix_inline_code(str)
+    )
+  )
+end
+
+# Removes some markdown formatting (for definition list etc)
+def remove_mdfmt(str)
+  str.gsub(/`([^`\n]+)`/, '<tt>\1</tt>').gsub(/\*+([^*\n]+)\*+/, '<strong>\1</strong>').gsub(/\&/, '&amp;').gsub(/</, '&lt;').gsub(/>/, '&gt;').gsub(/"/, '&quot;')
+end
+
+# Removes some markdown formatting (for definition list etc)
+def remove_mdfmt_raw(str)
+  str.gsub(/`([^`\n]+)`/, '\1').gsub(/\*+([^*\n]+)\*+/, '\1').gsub(/\&/, '&amp;').gsub(/</, '&lt;').gsub(/>/, '&gt;').gsub(/"/, '&quot;')
+end
+
+
+# returns the string where the definition list is rewritten for github
+#
+# Similar to {#fix_inline_code} but for def list
+# 
+# @param str [String]
+# @return [String]
+def fix_def_list(str)
+  str.gsub(/^(\S+[^\n]*)\n:((?:\s+[^\n]+(?:\n|\z))+)/m){
+    sdt, sdd = $1, $2
+    "<dt>%s</dt>\n<dd>%s</dd>\n"%[remove_mdfmt_raw(sdt), remove_mdfmt(sdd.chop)]
+  }.gsub(/(\s+\n|\A)(<dt>)/m, '\1<dl>'+"\n"+'\2').gsub(%r@(</dd>[[:blank:]]*)(\n(?:\s+|\z))@, '\1'+"\n"+'</dl>\2')
+end
+
+# returns the string where inline code are fixed.
+#
+# More than 2 words are left like
+#
+#   +abc def+
+#
+# which should be converted into
+#
+#   `abc def`
+# 
+# This is assuming the current paragraph is not a code block.
+# This does not *properly* take into account the escape sequence.
+# For example, '+a\+ b+' is not properly taken into account
+# (though RDoc may not do, either)!
+# 
+# Note if words between '+' straddle over more than 2 lines, something may be wrong,
+# and hence they are ignored.
+# 
+# @param str [String]
+# @return [String]
+def fix_inline_code(str)
+  str.gsub(/(?<!\\)((?:\\\\)*)\+([^+\n]+)(\n[^+\n]+)?(?<!\\)(\\\\)*\+/m){
+    ($1 ? $1 : "")+'`'+$2+($3 ? ' '+$3[1..-1] : '')+'`'+($4 ? $4 : "")
+  }
+end
+
+# returns the string where multi-line links are fixed.
+#
+# Similar to {#fix_inline_code} but for links
+# 
+# @param str [String]
+# @return [String]
+def fix_inline_link(str)
+  str.gsub(%r@(?<!\\)((?:\\\\)*)\[([^\]\n]+)(\n[^\]\n]+)?(?<!\\)(\\\\)*\](\(https?://[^)]+\))@m){
+    ($1 ? $1 : "")+'['+$2+($3 ? ' '+$3[1..-1] : '')+']'+($4 ? $4 : "")+$5.gsub(/\s*\n+\s*/m, '')
+  }
+end
+
+# Indent of the current line
+#
+# @param str [String]
+# @param lb [String] Linebreak: default $/
+# @return [Integer]
+def indent_line(str)
+  /\A(\s*)/ =~ str 
+  $1.size
+end
+
+# Returns the minimum indent of the input String, excluding blank lines.
+#
+# @param str [String]
+# @param lb [String] Linebreak: default $/  (ignored so far)
+# @return [Integer]
+def min_indent(str, lb=$/)
+  return 0 if str.empty?
+  lines = PlainText::Part.parse(str).parts.join("\n").split("\n")
+  lines.map{|ec| indent_line(ec)}.min
+end
+
+# True if it looks like Markdown code block.
+#
+# Neither Github-style "```ruby" nor pandoc-style "~~~~{#mycode...}" is
+# assumed not to be used.
+# This is not accurate and can be cheated if it is already indented as list.
+#
+# @param str [String]
+# @param indent [Integer] Base indent.  If it is 0, 4 or more indents are the conditions.
+def md_code_block?(str, indent=0, *rest)
+  return nil if str.empty?
+  (min_indent(str, *rest) - indent) >= 4
+end
+
+# Returns the last indent of the paragraph if it ends with a list.
+#
+# @param str [String]
+# @param indent_prev [Integer] The minimum indent for an item to keep being in the list in the previous paragraph.
+# @param lb [String] Linebreak: default $/
+# @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")
+  # Note: numsps = 2  # "2." takes up 2 spaces, whereas "12." takes 3.
+  lines.each do |ec|
+    cind = indent_line(ec)
+    if cind - indent_prev >= 4  # Code block!  ##### Maybe deals with it in future!!
+        # This means it is indented more than 5 spaces from the previous.
+    elsif /^(\s*)(?:(\*\s)|(\d+\.(?:\s|$)))/ =~ ec
+      # Reset the indent
+      ind_now = $1.size + ($2 || $3).size + 1  # maybe +2 (for Rdoc2md?)
+      indent_prev = ind_now  # Deeper or shallower or same-level list.
+      # numsps = $3.size + 1 if $3 && !$3.empty?
+    elsif cind < indent_prev - 1  # 1 is a margin...
+      # Breaks out from the previous list.
+      indent_prev = cind
+    end
+  end
+  indent_prev
+end
+
+################################################
+# MAIN
+################################################
+
+$stdout.sync=true
+$stderr.sync=true
+
+#class String
+#  include PlainText
+#end
+
+# Handle the command-line options => OPTS
+opts = handle_argv()
+
+strin = ARGF.read
+## split to paras, fixing inline code blocks
+mdpart = PlainText::Part.parse(strin)
+
+indent_prev = last_indent(mdpart[0])
+mdpart.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
+  indent_prev = last_indent(pbp[2], indent_prev)
+  false
+}
+
+indent_next = 0
+mdpart = mdpart.map_part{|ec|
+  indent_prev = indent_next
+  indent_next = last_indent(ec, indent_prev)
+  next fix_string_based(ec) if !md_code_block?(ec, indent_prev)
+  inde = " "*indent_prev
+  st = ec.gsub(/^    /, '')
+  "%s```%s\n%s\n%s```"%[inde, opts[:lang], st, inde, opts[:lang]]
+}
+
+puts mdpart.join('')
+
+exit
+
+__END__
+

data/lib/plain_text/parse_rule.rb

@@ -89,6 +89,8 @@ module PlainText
   #
   class ParseRule
 
+    include PlainText::Util
+
     # Main Array of rules (Proc or Regexp).  Do not delete or add the contents, as it would have a knock-on effect, especially with {#names}!
     # Use {#rule_at} to get a rule for the index/key.
     # The private method {#rule_at}(-1) is the same as {#rules}[-1],
@@ -283,7 +285,8 @@ module PlainText
     # @param index_rules [Integer] Index for {#rules}. A negative index is allowed.
     # @return [Integer] Non-negative index where name is set; i.e., if index=-1 is specified for {#rules} with a size of 3, the returned value is 2 (the last index of it).
     def set_name_at(name, index_rules)
-      index = PlainText::Util.positive_array_index_checked(index_rules, @rules, accept_too_big: false, varname: 'rules')
+      index = positive_array_index_checked(index_rules, @rules, accept_too_big: false, varname: 'rules')
+      # index = PlainText::Util.positive_array_index_checked(index_rules, @rules, accept_too_big: false, varname: 'rules')
       if !name
         @names[index] = nil
         return index