help_parser 8.0.210917 → 8.2.230210

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89d031ef15e33460fc4f23ccec23cc98f01cb9808fd77bb478c63be6a638f034
-  data.tar.gz: 9521262caa0b0a1617fc52bdeec42c4e305a4fc4ce34c5871128c64eecf5aae7
+  metadata.gz: f19d24ec56736d0d1bbcce1e0a847ac45e9d82defc89c7799c7b9c8c7c4ae078
+  data.tar.gz: fe92cf2d740771329bee184dd205d59bc72c1265d79ac50af3a6c4d0fa735297
 SHA512:
-  metadata.gz: 4e6c0faa99fd04e8b8e2f289b0f1894538747defaeb557400b36904f7c330961b9cc068aa8bdbe06493f8339af19cd4397cfdca9e1f82bc20ddbf84b91553955
-  data.tar.gz: 135b86c92d72faa5b49cdfedd7b6c66a9e568e592ae5b8afc86c612efa23020c828acb45693435d5f5349679f61a963bac81041da6d6bdae9549c1ab2de3214b
+  metadata.gz: f20dad3a1453e625236af9cb176328652352e9f2f35f00da02cc6ab1853671c82ae13d5ec8226247be116cbd82bdbb4aee24490200f04b2ddba79e380822f36b
+  data.tar.gz: 0aebde782784afb644dd1047f32af8de07d07af4c53435ec47ed8c8f7e54a3997a6e6a08c372f23e1a38f37c10f6e0604c26afcb5f16b8d7677120891f10ed71

data/README.md

@@ -1,6 +1,6 @@
 # Help Parser VIII: Helpland
 
-* [VERSION 8.0.210917](https://github.com/carlosjhr64/help_parser/releases)
+* [VERSION 8.2.230210](https://github.com/carlosjhr64/help_parser/releases)
 * [github](https://www.github.com/carlosjhr64/help_parser)
 * [rubygems](https://rubygems.org/gems/help_parser)
 
@@ -11,11 +11,9 @@ Do you have your help text?
 Let's parse!
 
 ## INSTALL:
-
 ```console
 $ gem install help_parser
 ```
-
 ## SYNOPSIS:
 <!-- The following PREVIEW has been approved for ALL PROGRAMMERS by CarlosJHR64.
 For the README validator that checks against me lying....
@@ -32,7 +30,6 @@ end
 The following gem has been rated
 | M | Mature |
 -->
-
 ```ruby
 require "help_parser"
 
@@ -96,19 +93,19 @@ OPTIONS.args?.class          #=> Array
 OPTIONS.arg? and OPTIONS.arg #=> false
 OPTIONS.arg?.class           #=> FalseClass
 ```
-
 ## Features
 
+* `ARGV` setup for `ARGF` when one of the "Types:" given is "ARGF"
 * `$DEBUG=true` on --debug
 * `$VERBOSE=true` on --verbose
 * -h and --help simultaneously will check help string for errors
-* `HelpParser::REDTTY[msg]` will red color output `msg` to `STDERR`.
+* `HelpParser::REDTTY[msg]` will red color output `msg` to `$stderr`.
 
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2021 CarlosJHR64
+Copyright (c) 2023 CarlosJHR64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/help_parser/aliases.rb

@@ -1,14 +1,14 @@
 module HelpParser
   class NoDupHash < Hash
     def []=(k,v)
-      raise HelpError, MSG[DUP_KEY,k]  if self.has_key?(k)
+      raise HelpError, MSG[DUP_KEY,k] if key?(k)
       super
     end
   end
 
   class ArgvHash < Hash
     def []=(k,v)
-      raise UsageError, MSG[DUP_KEY,k] if self.has_key?(k)
+      raise UsageError, MSG[DUP_KEY,k] if key?(k)
       super
     end
   end

data/lib/help_parser/completion.rb

@@ -3,36 +3,50 @@ module HelpParser
     def initialize(hash, specs)
       @hash,@specs = hash,specs
       @cache = NoDupHash.new
-      usage or diagnose  if @specs.has_key?(USAGE)
+      usage or diagnose if @specs.key?(USAGE)
       pad
-      types  if @specs.has_key?(TYPES)
+      if @specs.key?(TYPES)
+        k2t = types
+        handle_argf(k2t) if k2t.detect{|_,v|v=='ARGF'}
+      end
+    end
+
+    # Prepare ARGV for ARGF.
+    def handle_argf(k2t)
+      files = @hash.select{|k,_|k2t[k]=='ARGF'}.map{|_,v|v}.flatten
+      e = files.reject{File.exist?_1}.join(', ')
+      raise UsageError, MSG[NOT_EXIST, e] unless e.empty?
+      ARGV.replace files
     end
 
     # Which usage does the user's command options match?
     def usage
       @specs[USAGE].each do |cmd|
-        begin
-          i = matches(cmd)
-          raise NoMatch unless @hash.size==i
-          @cache.each{|k,v|@hash[k]=v} # Variables
-          return true # Good! Found matching usage.
-        rescue NoMatch
-          next
-        ensure
-          @cache.clear
-        end
+        i = matches(cmd)
+        raise NoMatch unless @hash.size==i
+        @cache.each{|k,v|@hash[k]=v} # Variables
+        return true # Good! Found matching usage.
+      rescue NoMatch
+        next
+      ensure
+        @cache.clear
       end
-      return false # Bad! Did not match any of the expected usage.
+      false # Bad! Did not match any of the expected usage.
     end
 
     # Diagnose user's usage.
     def diagnose
       dict = {}
-      @specs.each do |k,v|
-        next if RESERVED.include? k
-        v.flatten.map{_1.scan(/\w+/).first}.each{dict[_1]=true}
+      @specs.each do |section,list|
+        next if RESERVED.include? section
+        list.flatten.select{_1[0]=='-'}.each do |key_type|
+          key_type.scan(/\w+/) do |key|
+            dict[key]=true
+            break
+          end
+        end
       end
-      typos = @hash.keys.select{|k|k.is_a? String and not dict[k]}
+      typos = @hash.keys.select{_1.is_a?(String) && !dict[_1]}
       raise UsageError, MSG[UNRECOGNIZED, typos] unless typos.empty?
 
       raise UsageError, MATCH_USAGE
@@ -41,32 +55,31 @@ module HelpParser
     def types
       t2r,k2t = HelpParser.t2r(@specs),HelpParser.k2t(@specs)
       @hash.each do |key,value|
-        next unless key.is_a?(String)
-        if type = k2t[key]
-          regex = t2r[type]
-          case value
-          when String
-            unless value=~regex
-              raise UsageError, "--#{key}=#{value} !~ #{type}=#{regex.inspect}"
-            end
-          when Array
-            value.each do |string|
-              unless string=~regex
-                raise UsageError,
-                  "--#{key}=#{string} !~ #{type}=#{regex.inspect}"
-              end
+        next unless key.is_a?(String) && (type=k2t[key])
+        regex = t2r[type]
+        case value
+        when String
+          unless value=~regex
+            raise UsageError, "--#{key}=#{value} !~ #{type}=#{regex.inspect}"
+          end
+        when Array
+          value.each do |string|
+            unless string=~regex
+              raise UsageError,
+                "--#{key}=#{string} !~ #{type}=#{regex.inspect}"
             end
-          else
-            raise UsageError, "--#{key} !~ #{type}=#{regex.inspect}"
           end
+        else
+          raise UsageError, "--#{key} !~ #{type}=#{regex.inspect}"
         end
       end
+      k2t
     end
 
     def pad
       # Synonyms and defaults:
       @specs.each do |section,options|
-        next if section==USAGE || section==TYPES
+        next if RESERVED.any?{section==_1}
         options.each do |words|
           next unless words.size>1
           first,second,default = words[0],words[1],words[2]
@@ -74,12 +87,12 @@ module HelpParser
             if second[0]=='-'
               i = second.index('=') || 0
               short,long = first[1],second[2..(i-1)]
-              if @hash.has_key?(short)
-                if @hash.has_key?(long)
+              if @hash.key?(short)
+                if @hash.key?(long)
                   raise UsageError, MSG[REDUNDANT, short, long]
                 end
-                @hash[long] = (default.nil?) ? true : default
-              elsif value = @hash[long]
+                @hash[long] = default.nil? ? true : default
+              elsif (value=@hash[long])
                 @hash[short] = true
                 if value==true && !default.nil?
                   @hash.delete(long) # ArgvHash reset
@@ -95,6 +108,8 @@ module HelpParser
                 @hash[long] = default
               end
             end
+          else
+            raise SoftwareError, MSG[UNEXPECTED, words]
           end
         end
       end
@@ -110,20 +125,20 @@ module HelpParser
             # OK, NEVERMIND!
           end
           next
-        elsif m=FLAG_GROUP.match(token)
+        elsif (m=FLAG_GROUP.match token)
           group,plus = m[:k],m[:p]
           key = keys[i]
-          raise NoMatch if key.nil? || key.is_a?(Integer)
+          raise NoMatch unless key.is_a? String
           list = @specs[group].flatten.select{|f|f[0]=='-'}.map{|f| F2K[f]}
           raise NoMatch unless list.include?(key)
           unless plus.nil?
             loop do
               key = keys[i+1]
-              break if key.nil? || key.is_a?(Integer) || !list.include?(key)
+              break unless key.is_a?(String) && list.include?(key)
               i+=1
             end
           end
-        elsif m=VARIABLE.match(token)
+        elsif (m=VARIABLE.match(token))
           key = keys[i]
           raise NoMatch unless key.is_a?(Integer)
           variable,plus = m[:k],m[:p]
@@ -146,7 +161,7 @@ module HelpParser
         end
         i += 1
       end
-      return i
+      i
     end
   end
 end

data/lib/help_parser/constants.rb

@@ -1,6 +1,6 @@
 module HelpParser
-  V,VSN = 'v','version'
-  H,HLP = 'h','help'
+  VSN = %w[v version]
+  HLP = %w[h help]
   VRBS,DBG = 'verbose','debug'
 
   # reserved name
@@ -13,22 +13,22 @@ module HelpParser
   RESERVED = [USAGE,TYPES,EXCLUSIVE,INCLUSIVE,CONDITIONAL]
 
   # sections
-  SECTION_NAME = /^[A-Z]\w+:$/
+  SECTION_NAME = /^(?<name>[A-Z]\w+):$/
 
   # usage
-  FLAG       = /^[-][-]?(?<k>\w+)$/
+  FLAG       = /^--?(?<k>\w+)$/
   LITERAL    = /^(?<k>\w[\w.-]*:?)$/
   VARIABLE   = /^<(?<k>\w+)(=(?<t>[A-Z]+))?>(?<p>[+])?$/
   FLAG_GROUP = /^:(?<k>\w+)(?<p>[+])?$/
 
   # spec --?w+
-  SHORT = /^[-](?<s>\w)$/
-  LONG  = /^[-][-](?<k>\w+)(=(?<t>[A-Z]+))?(,?\s+(?<d>[^-\s]\S*))?$/
+  SHORT = /^-(?<s>\w)$/
+  LONG  = /^--(?<k>\w+)(=(?<t>[A-Z]+))?(,?\s+(?<d>[^-\s]\S*))?$/
 
   # spec -w,? --w+
-  SHORT_LONG         = /^[-](?<s>\w),?\s+[-][-](?<k>\w+)$/
+  SHORT_LONG         = /^-(?<s>\w),?\s+--(?<k>\w+)$/
   SHORT_LONG_DEFAULT =
-    /^[-](?<s>\w),?\s+[-][-](?<k>\w+)(=(?<t>[A-Z]+))?,?\s+(?<d>[^-\s]\S*)$/
+    /^-(?<s>\w),?\s+--(?<k>\w+)(=(?<t>[A-Z]+))?,?\s+(?<d>\S*)$/
 
   # spec W+ /~/
   TYPE_DEF = /^(?<t>[A-Z]+),?\s+\/(?<r>\S+)\/$/
@@ -73,15 +73,16 @@ module HelpParser
   NOT_FLOATS          = 'Not all Floats'
   NOT_INTEGER         = 'Not an Integer'
   NOT_INTEGERS        = 'Not all Integers'
+  NOT_EXIST           = 'Does not exist'
   # error messages, full:
   NO_MATCH            = 'Software Error: NoMatch was not caught by HelpParser.'
   MATCH_USAGE         = 'Please match usage.'
   EXTRANEOUS_SPACES   = 'Extraneous spaces in help.'
 
   # lambda utilities
-  MSG = lambda{|msg,*keys| "#{msg}:  #{keys.join(' ')}"}
-  F2K = lambda{|f| f[1]=='-' ? f[2..((f.index('=')||0)-1)] : f[1]}
-  REDTTY = lambda{|msg,out=$stderr|
+  MSG = ->(msg,*keys){"#{msg}:  #{keys.join(' ')}"}
+  F2K = ->(f){f[1]=='-' ? f[2..((f.index('=')||0)-1)] : f[1]}
+  REDTTY = lambda do |msg,out=$stderr|
     out.tty? ? out.puts("\033[0;31m#{msg}\033[0m"): out.puts(msg)
-  }
+  end
 end

data/lib/help_parser/exceptions.rb

@@ -1,6 +1,8 @@
 module HelpParser
   class HelpParserException < Exception
-    def _init; @code = 1; end
+    def _init
+      @code = 1
+    end
 
     # Must give message
     def initialize(message)
@@ -9,35 +11,45 @@ module HelpParser
     end
 
     def exit
-      if @code > 0
-        REDTTY[self.message]
+      if @code.positive?
+        REDTTY[message]
       else
-        $stdout.puts self.message
+        $stdout.puts message
       end
       Kernel.exit @code
     end
   end
 
   class VersionException < HelpParserException
-    def _init; @code = 0; end
+    def _init
+      @code = 0
+    end
   end
 
   class HelpException < HelpParserException
-    def _init; @code = 0; end
+    def _init
+      @code = 0
+    end
   end
 
   class UsageError < HelpParserException
-    def _init; @code = EX_USAGE; end
+    def _init
+      @code = EX_USAGE
+    end
   end
 
   class SoftwareError < HelpParserException
     # Stuff that should not happen
-    def _init; @code = EX_SOFTWARE; end
+    def _init
+      @code = EX_SOFTWARE
+    end
   end
 
   class NoMatch < HelpParserException
     # used to short-circuit out
-    def _init; @code = EX_SOFTWARE; end
+    def _init
+      @code = EX_SOFTWARE
+    end
 
     # Forces it's own message
     def initialize
@@ -46,6 +58,8 @@ module HelpParser
   end
 
   class HelpError < HelpParserException
-    def _init; @code = EX_CONFIG; end
+    def _init
+      @code = EX_CONFIG
+    end
   end
 end

data/lib/help_parser/k2t2r.rb

@@ -1,13 +1,16 @@
 module HelpParser
+  # k2t is an acronym for the "key to type" mapping
   def self.k2t(specs)
     k2t = NoDupHash.new
-    tokens = specs.select{|k,v| !(k==TYPES)}.values.flatten
-      .select{|v|v.include?('=')}
+    # If specs section is not a RESERVED section, it's an options list.
+    tokens = specs.select{|k,_| k==USAGE or !RESERVED.include?(k)}
+      # Tokens associating a key to a type.
+      .values.flatten.select{|v|v.include?('=')}
     tokens.each do |token|
-      if match = VARIABLE.match(token) || LONG.match(token)
+      if (match = VARIABLE.match(token) || LONG.match(token))
         name, type = match[:k], match[:t]
-        if _=k2t[name]
-          raise HelpError, MSG[INCONSISTENT,name,type,_]  unless type==_
+        if (_=k2t[name])
+          raise HelpError, MSG[INCONSISTENT,name,type,_] unless type==_
         else
           k2t[name] = type
         end
@@ -16,11 +19,12 @@ module HelpParser
         raise SoftwareError, MSG[UNEXPECTED,token]
       end
     end
-    return k2t
+    k2t
   end
 
+  # t2r is an acronym for "type to regexp"
   def self.t2r(specs)
-    if types = specs[TYPES]
+    if (types=specs[TYPES])
       t2r = NoDupHash.new
       types.each do |pair|
         type, pattern = *pair
@@ -32,6 +36,6 @@ module HelpParser
       end
       return t2r
     end
-    return nil
+    nil
   end
 end

data/lib/help_parser/macros.rb

@@ -1,201 +1,145 @@
 module HelpParser
   def self.string(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      s = @hash['#{name}']
-      raise UsageError, MSG[NOT_STRING,'#{name}'] unless s.is_a?(String)
-      return s
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          s = @hash[name.to_s]
+          raise UsageError, MSG[NOT_STRING,name] unless s.is_a?(String)
+          s
+        end
+      end
     end
   end
 
   def self.string?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      s = @hash['#{name}']
-      raise UsageError, MSG[NOT_STRING,'#{name}'] unless s.nil? ||
-        s.is_a?(String)
-      return s
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          s = @hash[name.to_s]
+          raise UsageError,MSG[NOT_STRING,name] unless s.nil? || s.is_a?(String)
+          s
+        end
+      end
     end
   end
 
   def self.strings(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      a = @hash['#{name}']
-      raise UsageError, MSG[NOT_STRINGS,'#{name}'] unless a.is_a?(Array)
-      return a
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          a = @hash[name.to_s]
+          raise UsageError, MSG[NOT_STRINGS,name] unless a.is_a?(Array)
+          a
+        end
+      end
     end
   end
 
   def self.strings?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      a = @hash['#{name}']
-      raise UsageError, MSG[NOT_STRINGS,'#{name}'] unless a.nil? ||
-        a.is_a?(Array)
-      return a
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          a = @hash[name.to_s]
+          raise UsageError,MSG[NOT_STRINGS,name] unless a.nil? || a.is_a?(Array)
+          a
+        end
+      end
     end
   end
 
   def self.float(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      f = @hash['#{name}']
-      raise if f.nil?
-      f.to_f
-    rescue
-      raise UsageError, MSG[NOT_FLOAT,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          @hash[name.to_s]&.to_f or raise
+        rescue
+          raise UsageError, MSG[NOT_FLOAT,name]
+        end
+      end
     end
   end
 
   def self.float?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      f = @hash['#{name}']
-      f = f.to_f if f
-      return f
-    rescue
-      raise UsageError, MSG[NOT_FLOAT,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          @hash[name.to_s]&.to_f
+        rescue
+          raise UsageError, MSG[NOT_FLOAT,name]
+        end
+      end
     end
   end
 
   def self.floats(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      f = @hash['#{name}']
-      raise unless f.is_a?(Array)
-      f.map{_1.to_f}
-    rescue
-      raise UsageError, MSG[#{NOT_FLOATS},'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          @hash[name.to_s].map(&:to_f)
+        rescue
+          raise UsageError, MSG[NOT_FLOATS,name]
+        end
+      end
     end
   end
 
   def self.floats?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      f = @hash['#{name}']
-      return nil unless f
-      raise unless f.is_a?(Array)
-      f.map{_1.to_f}
-    rescue
-      raise UsageError, MSG[NOT_FLOATS,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          @hash[name.to_s]&.map(&:to_f)
+        rescue
+          raise UsageError, MSG[NOT_FLOATS,name]
+        end
+      end
     end
   end
 
   def self.int(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      f = @hash['#{name}']
-      raise if f.nil?
-      f.to_i
-    rescue
-      raise UsageError, MSG[NOT_INTEGER,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          @hash[name.to_s]&.to_i or raise
+        rescue
+          raise UsageError, MSG[NOT_INTEGER,name]
+        end
+      end
     end
   end
 
   def self.int?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      f = @hash['#{name}']
-      f = f.to_i if f
-      return f
-    rescue
-      raise UsageError, MSG[NOT_INTEGER,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          @hash[name.to_s]&.to_i
+        rescue
+          raise UsageError, MSG[NOT_INTEGER,name]
+        end
+      end
     end
   end
 
   def self.ints(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}
-      f = @hash['#{name}']
-      raise unless f.is_a?(Array)
-      f.map{_1.to_i}
-    rescue
-      raise UsageError, MSG[NOT_INTEGERS,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method(name) do
+          @hash[name.to_s].map(&:to_i)
+        rescue
+          raise UsageError, MSG[NOT_INTEGERS,name]
+        end
+      end
     end
   end
 
   def self.ints?(*names)
     names.each do |name|
-      code = <<-CODE
-  class Options
-    def #{name}?
-      f = @hash['#{name}']
-      return nil unless f
-      raise unless f.is_a?(Array)
-      f.map{_1.to_i}
-    rescue
-      raise UsageError, MSG[NOT_INTEGERS,'#{name}']
-    end
-  end
-      CODE
-      eval code
+      Options.instance_eval do
+        define_method("#{name}?") do
+          @hash[name.to_s]&.map(&:to_i)
+        rescue
+          raise UsageError, MSG[NOT_INTEGERS,name]
+        end
+      end
     end
   end
 end

data/lib/help_parser/options.rb

@@ -2,35 +2,35 @@ module HelpParser
   class Options
     def initialize(version, help, argv)
       @hash = HelpParser.parsea(argv)
-      if version && (@hash.has_key?(V) || @hash.has_key?(VSN))
+      if version && VSN.any?{@hash.key? _1}
         # -v or --version
-        raise VersionException, version
+        raise VersionException, String(version)
       end
       if help
-        h = [H, HLP]
-        if h.any?{@hash.key? _1}
-          HelpParser.parseh(help, validate: true)  if h.all?{@hash.key? _1}
+        help = String(help)
+        if HLP.any?{@hash.key? _1}
+          HelpParser.parseh(help, validate: true) if HLP.all?{@hash.key? _1}
           raise HelpException, help
         end
         specs = HelpParser.parseh(help)
         Completion.new(@hash, specs)
-        if exclusive=specs[EXCLUSIVE]
+        if (exclusive=specs[EXCLUSIVE])
           exclusive.each do |x|
             count = x.count{@hash.key? _1}
             raise HelpParser::UsageError, MSG[EXCLUSIVE_KEYS,*x] if count > 1
           end
         end
-        if inclusive=specs[INCLUSIVE]
+        if (inclusive=specs[INCLUSIVE])
           inclusive.each do |i|
             count = i.count{@hash.key? _1}
-            unless count==0 or count==i.length
+            unless count.zero? || count==i.length
               raise HelpParser::UsageError, MSG[INCLUSIVE_KEYS,*i]
             end
           end
         end
-        if conditional=specs[CONDITIONAL]
+        if (conditional=specs[CONDITIONAL])
           conditional.each do |c|
-            if @hash.key? c[0] and not c.all?{@hash.key? _1}
+            if @hash.key?(c[0]) && !c.all?{@hash.key? _1}
               raise HelpParser::UsageError, MSG[CONDITIONAL_KEYS,*c]
             end
           end
@@ -48,17 +48,16 @@ module HelpParser
       @hash[k]
     end
 
-    def method_missing(mthd, *args, &block)
-      super if block or args.length > 0
-      m = mthd.to_s
-      case m[-1]
-      when '?'
-        @hash.key? m[0..-2]
-      when '!'
-        super
-      else
-        @hash[m]
+    def respond_to_missing?(m, include_all=false)
+      m[-1]=='!' ? super : true
+    end
+
+    def method_missing(m, *args, &block)
+      super unless respond_to_missing?(m)
+      unless args.empty? && block.nil?
+        raise ArgumentError, 'expected neither args nor block'
       end
+      m[-1]=='?' ? @hash.key?(m[0..-2].to_s) : @hash[m.to_s]
     end
   end
 end

data/lib/help_parser/parsea.rb

@@ -7,7 +7,7 @@ module HelpParser
         break if a.size==1 # '-' quits argv processing
         if a[1]=='-'
           break if a.size==2 # '--' also quits argv processing
-          s = a[2..-1]
+          s = a[2..]
           if s.include?('=')
             k,v = s.split('=',2)
             hsh[k] = v
@@ -15,7 +15,7 @@ module HelpParser
             hsh[s] = true
           end
         else
-          a.chars[1..-1].each do |c|
+          a.chars[1..].each do |c|
             hsh[c] = true
           end
         end
@@ -24,6 +24,6 @@ module HelpParser
         n += 1
       end
     end
-    return hsh
+    hsh
   end
 end

data/lib/help_parser/parseh.rb

@@ -4,45 +4,47 @@ module HelpParser
     help.each_line do |line|
       line.chomp!
       next if line==''
-      if line=~SECTION_NAME
-        name = line[0..-2].downcase
+      if (md=SECTION_NAME.match(line))
+        name = md[:name].downcase
         specs[name] = []
       else
         next if name==''
         break if line[0]=='#'
-        next if !(line[0]==' ')
+        next unless line[0]==' '
         spec = (index=line.rindex("\t"))? line[0,index].strip : line.strip
-        raise HelpError, EXTRANEOUS_SPACES if validate and spec==''
+        raise HelpError, EXTRANEOUS_SPACES if validate && spec.empty?
         case name
         when USAGE
-          Validate.line_chars(spec.chars) if validate
+          Validate.balanced_brackets(spec.chars) if validate
           tokens = HelpParser.parseu(spec.chars)
           Validate.usage_tokens(tokens) if validate
           specs[USAGE].push tokens
         when TYPES
-          if validate and not spec=~TYPE_DEF
+          if validate && !TYPE_DEF.match?(spec)
             raise HelpError, MSG[UNRECOGNIZED_TYPE,spec]
           end
           specs[TYPES].push spec.split(CSV)
         when *FLAG_CLUMPS # EXCLUSIVE,INCLUSIVE,CONDITIONAL,...
-          if validate and not spec=~X_DEF
+          if validate && !X_DEF.match?(spec)
             raise HelpError, MSG[UNRECOGNIZED_X,spec]
           end
           specs[name].push spec.split(CSV)
         else
-          raise HelpError, MSG[UNRECOGNIZED_OPTION,spec] if validate and
-              not [SHORT, LONG, SHORT_LONG, SHORT_LONG_DEFAULT].any?{_1=~spec}
+          if validate &&
+             [SHORT, LONG, SHORT_LONG, SHORT_LONG_DEFAULT].none?{_1=~spec}
+            raise HelpError, MSG[UNRECOGNIZED_OPTION,spec]
+          end
           specs[name].push spec.split(CSV)
         end
       end
     end
     if validate
       Validate.usage_specs(specs)
-      if t2r = HelpParser.t2r(specs)
+      if (t2r=HelpParser.t2r(specs))
         k2t = HelpParser.k2t(specs)
         Validate.k2t2r(specs, k2t, t2r)
       end
     end
-    return specs
+    specs
   end
 end

data/lib/help_parser/parseu.rb

@@ -1,7 +1,11 @@
 module HelpParser
+  # Chars := String.split(/\t/,2).first.strip.chars
+  # Token := String=~/^[^ \[\]]$/
+  # Note that emergent Token is String=~/^[^\s\[\]]$/
+  # Tokens := Array(Token|Tokens)
   def self.parseu(chars)
     tokens,token = [],''
-    while c = chars.shift
+    while (c=chars.shift)
       case c
       when ' ','[',']'
         unless token==''
@@ -15,6 +19,6 @@ module HelpParser
       end
     end
     tokens.push(token) unless token==''
-    return tokens
+    tokens
   end
 end

data/lib/help_parser/validate.rb

@@ -1,27 +1,20 @@
 module HelpParser
 module Validate
-  def self.line_chars(chars)
+  def self.balanced_brackets(chars)
     count = 0
     chars.each do |c|
-      if c=='['
-        count += 1
-      elsif c==']'
-        count -= 1
-      end
-      break if count<0
+      c=='[' && (count+=1) or c==']' && (count-=1)
+      break if count.negative?
     end
-    raise HelpError, MSG[UNBALANCED,chars.join] unless count==0
+    raise HelpError, MSG[UNBALANCED,chars.join] unless count.zero?
   end
 
   def self.usage_tokens(tokens)
     words = []
     tokens.flatten.each do |token|
-      match = token.match(FLAG)     ||
-              token.match(LITERAL)  ||
-              token.match(VARIABLE) ||
-              token.match(FLAG_GROUP)
-      raise HelpError, MSG[UNRECOGNIZED_TOKEN,token] unless match
-      words.push match[:k] # key
+      raise HelpError, MSG[UNRECOGNIZED_TOKEN,token] unless
+      [FLAG,LITERAL,VARIABLE,FLAG_GROUP]
+      .detect{(_=token.match _1) && words.push(_[:k])}
     end
     words.each_with_index do |word,i|
       raise HelpError, MSG[DUP_WORD,word] unless i==words.rindex(word)
@@ -29,40 +22,37 @@ module Validate
   end
 
   def self.usage_specs(specs)
-    option_specs = specs.select{|a,b| not RESERVED.include? a}
-    flags = option_specs.values.flatten.select{|f|f[0]=='-'}.map{|f| F2K[f]}
+    flags = specs.except(*RESERVED).values.flatten
+            .select{_1[0]=='-'}.map{F2K[_1]}
     FLAG_CLUMPS.each do |k|
-      if a=specs[k]
-        seen = {}
-        a.each do |xs|
-          k = xs.sort.join(' ').to_sym
-          if seen[k] or not xs.length==xs.uniq.length
-            raise HelpError, MSG[DUP_X,k]
-          end
-          seen[k] = true
-          xs.each do |x|
-            raise HelpError, MSG[UNSEEN_FLAG, x] unless flags.include?(x)
-          end
+      next unless (a=specs[k])
+      seen = {}
+      a.each do |xs|
+        k = xs.sort.join(' ').to_sym
+        if seen[k] || xs.length!=xs.uniq.length
+          raise HelpError, MSG[DUP_X,k]
+        end
+        seen[k] = true
+        xs.each do |x|
+          raise HelpError, MSG[UNSEEN_FLAG, x] unless flags.include?(x)
         end
       end
     end
     flags.each_with_index do |flag,i|
       raise HelpError, MSG[DUP_FLAG,flag] unless i==flags.rindex(flag)
-    end   
+    end
     group = []
     specs_usage = specs[USAGE]
-    unless specs_usage.nil?
-      specs_usage.flatten.each do |token|
-        if match = token.match(FLAG_GROUP)
-          key = match[:k]
-          raise HelpError, MSG[UNDEFINED_SECTION,key] unless specs[key]
-          group.push(key)
-        end
+    specs_usage&.flatten&.each do |token|
+      if (match=token.match FLAG_GROUP)
+        key = match[:k]
+        raise HelpError, MSG[UNDEFINED_SECTION,key] unless specs[key]
+        group.push(key)
       end
     end
     specs.each do |key,tokens|
-      raise HelpError, MSG[MISSING_CASES,key] unless tokens.size>0
-      next if specs_usage.nil? or RESERVED.include? key
+      raise HelpError, MSG[MISSING_CASES,key] if tokens.empty?
+      next if specs_usage.nil? || RESERVED.include?(key)
       raise HelpError, MSG[MISSING_USAGE,key] unless group.include?(key)
     end
   end
@@ -70,11 +60,11 @@ module Validate
   def self.k2t2r(specs, k2t, t2r)
     a,b = k2t.values.uniq.sort,t2r.keys.sort
     unless a==b
-      c = (a+b).uniq.select{|x|!(a.include?(x) && b.include?(x))}
+      c = (a+b).uniq.reject{|x|a.include?(x) && b.include?(x)}
       raise HelpError, MSG[UNCOMPLETED_TYPES,c.join(',')]
     end
     specs.each do |section,tokens|
-      next if section==USAGE || section==TYPES
+      next if RESERVED.include? section
       tokens.each do |words|
         next if words.size<2
         default = words[-1]
@@ -83,7 +73,7 @@ module Validate
         i = long_type.index('=')
         next if i.nil?
         long = long_type[2..(i-1)]
-        type = long_type[(i+1)..-1]
+        type = long_type[(i+1)..]
         regex = t2r[type]
         unless regex=~default
           raise HelpError, MSG[BAD_DEFAULT,long,default,type,regex.inspect]

data/lib/help_parser.rb

@@ -10,7 +10,7 @@ require_relative 'help_parser/options'
 require_relative 'help_parser/macros'
 
 module HelpParser
-  VERSION = '8.0.210917'
+  VERSION = '8.2.230210'
   autoload :Validate, 'help_parser/validate'
 
   def self.[](
@@ -18,10 +18,10 @@ module HelpParser
     help    = nil,
     argv    = [File.basename($0)]+ARGV)
     Options.new(version, help, argv)
-  rescue HelpParserException => exception
-    exception.exit
+  rescue HelpParserException => e
+    e.exit
   end
 end
 
 # Requires:
-#`ruby`
+# `ruby`

metadata

@@ -1,22 +1,81 @@
 --- !ruby/object:Gem::Specification
 name: help_parser
 version: !ruby/object:Gem::Version
-  version: 8.0.210917
+  version: 8.2.230210
 platform: ruby
 authors:
 - CarlosJHR64
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-17 00:00:00.000000000 Z
-dependencies: []
+date: 2023-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.7
 description: "Welcome to Help Parser!  \nDo you have your help text?  \nLet's parse!\n"
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - README.md
 - lib/help_parser.rb
 - lib/help_parser/aliases.rb
@@ -34,7 +93,7 @@ homepage: https://github.com/carlosjhr64/help_parser
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -49,9 +108,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux]'
-rubygems_version: 3.2.22
-signing_key:
+- 'git: 2.30'
+rubygems_version: 3.4.6
+signing_key: 
 specification_version: 4
 summary: Welcome to Help Parser!   Do you have your help text?   Let's parse!
 test_files: []

data/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 carlosjhr64
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.