help_parser 3.0.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33ad117bb5e036d38e871d90ea4a6434c1c004f1
-  data.tar.gz: 2e94e3e19e4c763bbf67ae4dc958b4d6dcfecf8c
+  metadata.gz: 2b2c0821ccb920314039d7e8f92851e7be14382a
+  data.tar.gz: f5184113ef5d80ae592c2f923d895527d078d954
 SHA512:
-  metadata.gz: 05bda5c57650c34545975a91bce8b87218dde3a7d52c23ccaf539bb037f8de7560071daedb8bf564bb1e30d68121438bec43aa7ea853c161da0f1837c1c5cc13
-  data.tar.gz: c4e7bc126d53c3df6bb3f9c9c83b1882da560536f442dca83c040c87ee7088a33b4983ab095873bf1ac77d9ea711be33a6808fae93649dcbddf6c19a11fe14e0
+  metadata.gz: 1afa018ea4504b0dfc00a443e26dda59338f4d7aa0f68f64b72b4c61c1d05d5558a3be3da9427bb07e57152da2fd6c2c77caf2e37d62729a5e3f905df18ec711
+  data.tar.gz: 70bb2be1242c6c094bba0b61e209f7028a8cb47c63f30ed9a9c5e3088d19f23107aa55d872c89bd153dfe73201a32936c967809de63dc16c0ba4ec8e10c4f2ea

data/README.md

@@ -0,0 +1,151 @@
+# HelpParser
+## Version 4!!!
+
+* [github](https://www.github.com/carlosjhr64/help_parser)
+* [rubygems](https://rubygems.org/gems/help_parser)
+
+## DESCRIPTION:
+HelpParser - Parses your help text to define your command line options.
+
+## INSTALL:
+
+    $ sudo gem install help_parser
+
+## LICENSE:
+[MIT](https://en.wikipedia.org/wiki/MIT_License) Copyright (c) 2017 CarlosJHR64
+
+## MINIMAL
+
+    #!/usr/bin/env ruby
+    require 'help_parser'
+    
+    OPTIONS = HelpParser.new
+    p OPTIONS._hash
+
+## SYNOPSIS:
+
+    #!/usr/bin/env ruby
+    require 'help_parser'
+
+    OPTIONS = HelpParser.new('1.2.3', <<-HELP)
+    Usage:
+      synopsis [:options] <x> <y>
+    Options:
+      --verbose
+    HELP
+
+    # Existentials via missing "?" methods
+    puts 'Whats x * y?' if OPTIONS.verbose?
+
+    # Values via missing methods.
+    puts OPTIONS.x.to_f * OPTIONS.y.to_f
+
+## MORE:
+
+    #!/usr/bin/env ruby
+    require 'help_parser'
+
+    # Any version string, does not have to be semantic versioning.
+    VERSION = '1.2.3'
+
+    HELP = <<-HELP
+    ### more ###########################################
+    # Lines starting with the pound sign are comments.
+    # HelpPaser parses the help text by sections
+    # with a heading of the form `<Section Name>:`.
+    # The Usage section gives the allowed forms of the
+    # command.  Keys, arguments, and selectors in
+    # square bracket are optional and can be nested.
+    # A plus sign, `+`, marks the associated token as
+    # taking multiple values. Note that variable
+    # arguments have the form `<name>`.
+    ####################################################
+    Usage:
+      more --wut <price> <count> [<name>]
+      more [:options] <args>+
+    ####################################################
+    # Tipically you'll have an `Options:` section, but
+    # you can give the section any name.
+    # An `Options:` section should match an `:options`
+    # selector in at least one of your usages.
+    # Assigning values to keys via the command line
+    # is done in the form `--key=value`.
+    ####################################################
+    Options:
+      -h --help    \tTab marks comment
+      -v --version \tShort and long synonyms
+      --val 5.0    \tProvided default to long
+      --number     \tLike --number=3
+      --usage
+    ####################################################
+    # The `Defaults:` section can give default values
+    # to arguments and options. 
+    # So for options you have a choice of where to set
+    # your defaults, but for arguments, it's done here.
+    ####################################################
+    Defaults:
+      name Carlos  \tDefault for name
+    ####################################################
+    # HelpPaser has two automatic types, `Float` and
+    # `Int`, which will convert values from String to
+    # Floats and Integers repectively.
+    # You can also provide you own custom validation
+    # with regular expressions.
+    ####################################################
+    Types:
+      Float --val price    \tPredefined Float and Int
+      Int   --number count
+      ^[A-Z][a-z]+$ name   \tUser defined type
+    ####################################################
+    # The start of a `Notes:` section tells HelpParser
+    # to break out of it's parsing.
+    # Anything else written after this heading is of
+    # no consequence to HelpParser.
+    ####################################################
+    Notes:
+      Stuff the help parser will ignore.
+    HELP
+
+    OPTIONS = HelpParser.new(VERSION, HELP)
+
+    # Short and long values via missing methods.
+    # Short and long existentials(booleans) via missing `?` methods.
+    # To avoid name collisions with command line argument and options,
+    # the HelpParser object was subclassed from BasicObject.
+    if OPTIONS.wut?
+      puts "Count:  #{_=OPTIONS.count}\t#{_.class}"
+      puts "Price:  #{_=OPTIONS.price}\t#{_.class}"
+      puts "Name:   #{_=OPTIONS.name}\t#{_.class}"
+    else
+      puts "Args: #{OPTIONS.args.join(', ')}"
+    end
+    puts "Name:   #{_=OPTIONS.name}\t#{_.class}"
+    puts "Val:    #{_=OPTIONS.val}\t#{_.class}"
+    puts "Number: #{_=OPTIONS.number}\t#{_.class}"
+
+    # The objects's hash data method is `_hash`.
+    # You can also get the help text parsed data from `_usage._hash`
+    puts '###'
+    if OPTIONS.usage?
+      p OPTIONS._usage._hash
+    else
+      p OPTIONS._hash
+    end
+
+## WHY?
+Even with the really nice options parsers available,
+for quick little scripts
+I kept writing stuff like `ARGV.include?(key)`
+or `options=ARGV.select{|a|a[0]=='-'}`.
+Just to have to go back and reimplement with a proper options parser
+when the little script ends up being useful and grows into something bigger.
+And I was doing this after I had written my own previous versions of HelpParser.
+So now I should have no excuse to just use HelpParser.  Always:
+
+    require 'HelpParser'
+    OPTIONS = HelpParser.new # DONE!
+
+Can't be any simpler.
+
+As the script evolves... add version.. add help text..
+no need to rework the code for not having started out with a proper options parser.

data/lib/help_parser.rb

@@ -1,9 +1,9 @@
-require 'help_parser/version'
 require 'help_parser/constants'
 require 'help_parser/pattern'
 require 'help_parser/usage'
 require 'help_parser/help_parser'
 HelpParser = HELP_PARSER::HelpParser
+HELP_PARSER::VERSION = '4.0.0'
 
 # Requires:
 #`ruby`

data/lib/help_parser/constants.rb

@@ -1,30 +1,75 @@
 module HELP_PARSER # Constants
 
-  NOTES,USAGE,TYPES = 'notes','usage','types'
-  Z,M,E,P,Q,I = '','-','=','[',']',''
-  H,LH,V,LV = '-h','--help','-v','--version'
+  ### OPTIONS LANGUAGE ###
 
-  S,SNS = /\s/,/\s*\n\s*/
+  H,LH = :h,:help
+  V,LV = :v,:version
+
+  C,Z,M,E,P,Q,I = '#','-','-','=','[',']',''
+  MM = '--'
+
+  ### HELP TEXT KEYS ###
+
+  NOTES,USAGE,TYPES,DEFAULTS = 'notes','usage','types','defaults'
+
+  ### ERROR COLOR CODES ###
 
   COLOR = [
     "\e[0m",    # no color
     "\e[1;31m", # red
   ]
 
-  FLOAT,INT = 'Float', 'Int'
+  ### TYPE MAPPINGS ###
+
+  FLOAT,INT = :Float, :Int
   Types = {
     INT   => /^[+-]?\d+$/,
     FLOAT => /^[+-]?\d+\.\d+$/,
   }
 
-  # Errors
-  class UsageError < StandardError
+  ### PATTERNS ###
+  
+  S          = /\s/             # space
+  SNS        = /\s*\n\s*/
+  KEY        = /^[-][-]?(.*)$/  #
+  SPS        = /\s+/            # spaces
+  MNS        = /^--?/
+  ERROR_KEY  = /:\s+(\S+)/
+  COMMENTARY = /\s*\t.*$/       # tab marks start of field comment
+
+  SELECTION   = /^(\w+):$/
+  SELECTION_P = /^:(.*?)([+]?)$/
+
+  VARIABLE    = /^<(.*)>$/
+  VARIABLE_P  = /^<(.*)>([+])?$/
+
+  ### Error Messages ###
+
+  MATCH_USAGE          = 'Please match usage!'
+  DUP_KEY              = 'Duplicate Key: '
+  ILLEGAL_KEY          = 'Illegal Key: '
+  SECTION_REDEFINITION = 'Section Redefinition: '
+  UNBALANCE_BRACKETS   = 'Unbalanced Brackets in Usage: '
+  MISSING_MINUS        = 'Missing Minus For Flag: '
+  NOT_A_FLAG           = 'No Minus For Types Or Defaults: '
+
+  ### Errors ###
+
+  class UsageError < RuntimeError
   end
-  class HelpFormatError < StandardError
+  class HelpError < RuntimeError
   end
-  class NoMatch < StandardError
+  class NoMatch < RuntimeError
   end
-  class SoftwareError < StandardError
+
+  ### REFINEMENTS ###
+
+  module Refinements
+    refine Array do
+      def detect_duplicate
+        self.detect{|_|self.rindex(_) != self.index(_)}
+      end
+    end
   end
-  SOFTWARE_ERROR_MSG = 'please submit a bug report'
+
 end

data/lib/help_parser/help_parser.rb

@@ -1,71 +1,99 @@
 module HELP_PARSER
-  # HelpParser Hash will act as if a GoLang map[string]string.
-  class HelpParser < Hash
-    def consume(argv)
-      n = 0
-      while a = argv.shift
+
+  # HelpParser should not alter argv
+  class HelpParser < BasicObject
+    USAGE_ERROR = lambda do |msg|
+      ::Kernel::raise ::HELP_PARSER::UsageError,msg
+    end
+
+    Ms,Es = ::HELP_PARSER::M.to_sym, ::HELP_PARSER::E.to_sym
+    VALIDATE_KEY = lambda do |hsh,k|
+      USAGE_ERROR[DUP_KEY+k.to_s] if hsh.key?(k)
+      USAGE_ERROR[ILLEGAL_KEY+k.to_s] if Ms==k or Es==k
+    end
+
+    PARSE_ARGV = lambda do |argv|
+      hsh,n,i = {},0,0
+      argv.each do |a|
         if a[0]==M # '-'
-          if a==M
-            self[M] = argv
-            break # end of parse
+          break if a==M
+          if a[1]==M
+            s,v = a.split(E,2) # split by '='
+            k = s[2..-1].to_sym
+            VALIDATE_KEY[hsh,k]
+            hsh[k] = (v)? v : true
           else
-            if a[1]==M
-              k,v = a.split(E,2) # split by '='
-              self[k] = (v)? v : Z # ''
-            else
-              # set each flag
-              a[1..-1].chars.each{|c|self[M+c]=Z}
+            # set each flag
+            a[1..-1].chars.each do |c|
+              k = c.to_sym
+              VALIDATE_KEY[hsh,k]
+              hsh[k]=true
             end
           end
         else
           # the nth argument
-          self[n.to_s] = a
+          hsh[n] = a
           n+=1
         end
+        i+=1
       end
+      return hsh
     end
 
     def initialize(version=nil, help=nil, argv=nil)
-      consume (argv.nil?)? [File.basename($0)]+ARGV : argv
-      if version and (self[V] or self[LV]) # -v or --version
-        puts version
-        exit(0)
-      end
-      if help
-        if self[H] or self[LH] # -h or --help
-          puts help
-          exit(0)
+      begin
+        hsh = PARSE_ARGV[(argv.nil?)? [::File.basename($0)]+::ARGV : argv]
+        if version and (hsh.key?(V) or hsh.key?(LV)) # -v or --version
+          $stdout.puts version
+          ::Kernel::exit(0)
+        end
+        if help
+          if hsh.key?(H) or hsh.key?(LH) # -h or --help
+            $stdout.puts help
+            ::Kernel::exit(0)
+          end
+          @usage = ::HELP_PARSER::Usage.new(help).validate(hsh)
         end
-        begin
-          Usage.new(help).validate(self)
-        rescue UsageError
-          $stderr.puts COLOR[1]+$!.message+COLOR[0]
+      rescue ::HELP_PARSER::UsageError => e
+        $stderr.puts COLOR[1]+e.message+COLOR[0]
+        $stderr.puts help if help
+        ::Kernel::exit(64) # Usage
+      rescue ::HELP_PARSER::HelpError => e
+        msg = e.message
+        $stderr.puts COLOR[1]+msg+COLOR[0]
+        if ERROR_KEY =~ msg
+          $stderr.puts help.gsub($1,COLOR[1]+$1+COLOR[0])
+        else
           $stderr.puts help
-          exit(64) # Usage
         end
+        ::Kernel::exit(78) # Config
       end
+      @hash = hsh.freeze
+    end
+
+    def [](k)
+      @hash[k]
+    end
+
+    def _hash
+      @hash
+    end
+
+    def _usage
+      @usage
     end
 
-    # obj.m?      ::  !obj['--m'].nil?
-    # obj.method! ::  obj['--method']
-    # obj.method  ::  obj['method']
     def method_missing(mthd, *args, &block)
-      if args.length==0
-        m=mthd.to_s
-        case m[-1]
-        when '?'
-          if m.length > 2
-            return !self[M+M+m[0..-2]].nil?
-          else
-            return !self[M+m[0]].nil?
-          end
-        when '!'
-          return self[M+M+m[0..-2]]
-        else
-          return self[m]
-        end
+      super if block or args.length > 0
+      m = mthd.to_s
+      case m[-1]
+      when '?'
+        @hash.key? m[0..-2].to_sym
+      when '!'
+        super
+      else
+        @hash[mthd]
       end
-      super
     end
   end
 end

data/lib/help_parser/pattern.rb

@@ -1,46 +1,121 @@
 module HELP_PARSER
   class Pattern
+
+    TYPE_MAP = lambda do |type,values,&block|
+      case type
+      when INT
+        case values
+        when Array
+          block.call values.map{|v|v.to_i}
+        when String
+          block.call values.to_i
+        end
+      when FLOAT
+        case values
+        when Array
+          block.call values.map{|v|v.to_f}
+        when String
+          block.call values.to_f
+        end
+      end
+    end
+
+    TYPE_VALIDATE = lambda do |values,tx,msg|
+      [*values].each do |value|
+        unless tx.match(value)
+          raise UsageError, sprintf(msg,value)
+        end
+      end
+    end
+
     def initialize(options,usage)
       @options,@usage = options,usage
       @keys = options.keys
       @cache = {}
     end
 
+    def types
+      @usage[TYPES].each do |type,*words|
+        tx = Types[type] || Regexp.new(type.to_s)
+        words.each do |word|
+          values = @options[word]
+          next if values.nil?
+          TYPE_VALIDATE[values,tx,"#{word}: %s !~ /#{type}/"]
+          TYPE_MAP.call(type,values){|m| @options[word]=m}
+        end
+      end
+    end
+
+    def pad
+      @cache.each{|k,v|@options[k]=v}
+      @usage.each do |name,words|
+        next if [USAGE,TYPES,DEFAULTS].include?(name)
+        words.each do |word|
+          next unless word.length==2
+          k,v = word
+          if v.class==Symbol
+            # Synonyms
+            if @options[k].nil?
+              @options[k]=@options[v] if @options.key?(v)
+            else
+              @options[v]=@options[k] unless @options.key?(v)
+            end
+          else
+            # Default
+            @options[k]=v unless @options.key?(k)
+          end
+        end
+      end
+      if @usage.key?(DEFAULTS)
+        @usage[DEFAULTS].each do |words|
+          *ks,v = words
+          ks.each do |k|
+            @options[k]=v.to_s unless @options.key?(k)
+          end
+        end
+      end
+    end
+
     def _matches(pattern, i)
       pattern.each do |token|
+        key = @keys[i] # Might be nil, but need to proceed...
         case token
-        when Array # it's optional
+        when Array # it's optional, so a key.nil? might be ok
           begin
             i = _matches(token,i)
           rescue NoMatch
             # Ok, no problem!
           end
           next
-        when /^:(.*?)([+]?)$/ # it's a selection
-          list,plus = @usage[$1].flatten.select{|_|_[0]==M},$2
-          raise NoMatch unless list.include?(@keys[i])
-          if plus=='+'
+        when SELECTION_P # it's a selection
+          raise NoMatch if key.nil?
+          section,plus = $1,$2
+          list = @usage[section]
+          list = list.flatten
+          raise NoMatch unless list.include?(key)
+          unless plus.nil?
             while list.include?(@keys[i+1])
               i+=1
             end
           end
-        when /^<(.*)>([+]?)$/ # it's a variable
-          word,plus = $1,$2
-          raise NoMatch if @keys[i].to_i==0
-          if plus=='+'
-            @cache[word] = [@options[@keys[i]]]
-            while @keys[i+1].to_i > 0
+        when VARIABLE_P # it's a variable
+          raise NoMatch if key.to_s.to_i==0 # nil.to_s.to_i==0 also works
+          word,plus = $1.to_sym,$2
+          unless plus.nil?
+            @cache[word] = [@options[key]]
+            while (key=@keys[i+1]).to_s.to_i > 0
               i+=1
-              @cache[word].push(@options[@keys[i]])
+              @cache[word].push(@options[key])
             end
           else
-            @cache[word] = @options[@keys[i]]
+            @cache[word] = @options[key]
           end
         else # it's a literal
+          raise NoMatch if key.nil?
           if token[0]==M
-            raise NoMatch unless @keys[i]==token
+            raise NoMatch unless token == ((key.length>1)? MM : M)+key.to_s
           else
-            raise NoMatch unless @options[@keys[i]]==token
+            raise NoMatch unless @options[key]==token
           end
         end
         i+=1
@@ -48,74 +123,18 @@ module HELP_PARSER
       return i
     end
 
-    def pad
-      @cache.each{|k,v|@options[k]=v}
-      @usage.each do |name,words|
-        next if [M,USAGE,TYPES].include?(name)
-        words.each do |word|
-          next unless word.length==2
-          k,v = word
-          next unless @options[k].nil?
-          if k[0]==M
-            if k[1]==M
-              # long option default
-              @options[k] = v
-            elsif v[0]==M and !@options[v].nil?
-              # long option synonym
-              @options[k] = @options[v]
-            end
-          else
-            # argument default
-            @options[k] = v
-          end
-        end
-      end
-    end
-
-    def types
-      @usage[TYPES].each do |type,*words|
-        tx = Types[type] || Regexp.new(type)
-        words.each do |word|
-          values = @options[word]
-          next if values.nil?
-          [*values].each do |value|
-            unless tx.match(value)
-              raise UsageError, "ERROR: #{word}=#{value} is not /#{type}/"
-            end
-          end
-          case type
-          when INT
-            case values
-            when Array
-              @options[word]=values.map{|v|v.to_i}
-            when String
-              @options[word]=values.to_i
-            end
-          when FLOAT
-            case values
-            when Array
-              @options[word]=values.map{|v|v.to_f}
-            when String
-              @options[word]=values.to_f
-            end
-          end
-        end
-      end
-    end
-
     def matches(pattern)
       begin
         i = _matches(pattern, 0)
         raise NoMatch if i != @options.length
         pad
         types if @usage[TYPES]
-        return true
       rescue NoMatch
         return false
       ensure
         @cache.clear
       end
-      raise SoftwareError, SOFTWARE_ERROR_MSG
+      return true
     end
   end
 end

data/lib/help_parser/usage.rb

@@ -1,6 +1,31 @@
 module HELP_PARSER
-  class Usage < Hash
-    def parse(chars)
+  class Usage
+    using HELP_PARSER::Refinements
+
+    DUPLICATES = lambda do |hsh|
+      a = hsh.select{|k| k!=TYPES and k!=DEFAULTS}.values.flatten.select{|e|e.class==Symbol}
+      if d = a.detect_duplicate
+        raise HelpError, DUP_KEY+d.to_s
+      end
+    end
+
+    VALIDATE_USAGE = lambda do |tokens|
+      seen = {}
+      tokens.flatten.each do |token|
+        t = token
+        if VARIABLE=~token
+          t = $1
+        elsif KEY=~token
+          t = $1
+        end
+        #raise HelpError, 'Duplicate Token: '+t if seen[t]
+        raise HelpError, DUP_KEY+t if seen[t]
+        seen[t]=true
+      end
+      return tokens
+    end
+
+    PARSE_USAGE = lambda do |chars|
       tokens, token = [], I
       while c = chars.shift
         case c
@@ -9,7 +34,7 @@ module HELP_PARSER
             tokens.push(token)
             token = I
           end
-          tokens.push parse(chars) if c==P
+          tokens.push PARSE_USAGE[chars] if c==P
           return tokens if c==Q
         else
           token += c
@@ -19,35 +44,57 @@ module HELP_PARSER
       return tokens
     end
 
+    BALANCED = lambda do |chars|
+      count = 0
+      chars.each do |c|
+        if c==P then count+=1 elsif c==Q then count-=1 end
+        break if count<0
+      end
+      return count==0
+    end
+
     def initialize(help)
-      name = M # '-'
-      self[name] = []
+      hsh,name = {},Z
       help.strip.split(SNS).each do |line|
-        line.sub!(/\s*\t.*$/,'') # tabs marks comment
+        next if line[0]==C # skip comment lines
+        line.sub!(COMMENTARY,'') # strip out commentary
         case line
-        when /^(\w+):$/
+        when SELECTION
           name = $1.downcase
           break if name==NOTES
-          raise HelpFormatError, "#{name} section redefinition"  if self[name]
-          self[name] = []
-        when /^\s*#/
-          next
+          raise HelpError, SECTION_REDEFINITION+name  if hsh[name]
+          hsh[name] = []
         else
-          if name==USAGE
-            self[USAGE].push(parse(line.chars))
+          case name
+          when Z
+            # Nothing to do
+          when USAGE
+            chars = line.chars
+            raise HelpError, UNBALANCE_BRACKETS+line  unless BALANCED[chars]
+            hsh[USAGE].push(VALIDATE_USAGE[PARSE_USAGE[chars]])
+          when TYPES,DEFAULTS
+            raise HelpError, NOT_A_FLAG+line if line[0]==M
+            hsh[name].push line.split(SPS).map{|_|_.to_sym}
           else
-            self[name].push line.split(/\s+/)
+            raise HelpError, MISSING_MINUS+line unless line[0]==M
+            hsh[name].push line.split(SPS).map{|_|(_[0]==M)? _.sub(MNS,'').to_sym : _}
           end
         end
       end
+      DUPLICATES[hsh]
+      @hash = hsh.freeze
+    end
+
+    def _hash
+      @hash
     end
 
     def validate(options)
-      pattern = Pattern.new(options,self)
-      self[USAGE].each do |cmd|
-        return if pattern.matches(cmd)
+      pattern = Pattern.new(options,@hash)
+      @hash[USAGE].each do |cmd|
+        return self if pattern.matches(cmd)
       end
-      raise UsageError, 'Please match usage!'
+      raise UsageError, MATCH_USAGE
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: help_parser
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.0
 platform: ruby
 authors:
 - carlosjhr64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-08 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies: []
 description: 'HelpParser - Parses your help text to define your command line options.
 
@@ -16,24 +16,20 @@ description: 'HelpParser - Parses your help text to define your command line opt
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
-- README.rdoc
+- README.md
 - lib/help_parser.rb
 - lib/help_parser/constants.rb
 - lib/help_parser/help_parser.rb
 - lib/help_parser/pattern.rb
 - lib/help_parser/usage.rb
-- lib/help_parser/version.rb
 homepage: https://github.com/carlosjhr64/help_parser
 licenses:
 - MIT
 metadata: {}
 post_install_message: 
-rdoc_options:
-- "--main"
-- README.rdoc
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -47,9 +43,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-linux]'
+- 'ruby: ruby 2.4.0p0 (2016-12-24 revision 57164) [x86_64-linux]'
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: HelpParser - Parses your help text to define your command line options.

data/README.rdoc

@@ -1,63 +0,0 @@
-= HelpParser
-
-This is version 3!
-
-github :: https://www.github.com/carlosjhr64/help_parser
-rubygems :: https://rubygems.org/gems/help_parser
-
-== DESCRIPTION:
-
-HelpParser - Parses your help text to define your command line options.
-
-== FEATURES/PROBLEMS:
-
-* long to short option mapping
-
-== SYNOPSIS:
-
-    #!/usr/bin/env ruby
-    require 'help_parser'
-    VERSION = '1.2.3'
-    HELP = <<HELP
-    ### cmd ###
-    Usage:
-      cmd --wut <price> <count> <name>
-      cmd [:options] <args>+
-    Options:
-      -h --help   \tTab marks comment
-      -v --version\tShort and long synonyms
-      -q --quiet
-      -V --verbose
-      --val 5.0   \tProvided default to long
-      --number    \tLike --number=3
-    Types:
-      Float --val price   \tPredefined Float and Int
-      Int   --number count
-      ^[A-Z][a-z]+$ name  \tUser defined type
-    Notes:
-      Stuff the help parser will ignore.
-    HELP
-    OPTIONS = HelpParser.new(VERSION, HELP)
-    # Shorts and longs as booleans via missing ? methods
-    "Got Options!" unless OPTIONS.q?
-    puts OPTIONS if OPTIONS.V?
-    # Long values via missing ! methods
-    puts "val = #{OPTIONS.val!}"
-    # Arguments via plain missing methods
-    if OPTIONS.wut?
-      puts "price = '#{OPTIONS.price}'"
-      puts "count = '#{OPTIONS.count}'"
-      puts "name = '#{OPTIONS.name}'"
-    else
-      puts "args = '#{OPTIONS.args.join(',')}'"
-    end
-
-== INSTALL:
-
-  $ sudo gem install help_parser
-
-== LICENSE:
-
-(The "Can't touch this, b/c it's all mine!" License)
-
-Copyright (c) 2016 CarlosJHR64

data/lib/help_parser/version.rb

@@ -1,3 +0,0 @@
-module HELP_PARSER
-  VERSION = '3.0.1'
-end