help_parser 4.0.0 → 5.0.0

metadata

@@ -1,29 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: help_parser
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - carlosjhr64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-07-27 00:00:00.000000000 Z
 dependencies: []
-description: 'HelpParser - Parses your help text to define your command line options.
+description: |
+  All help is about to get parsed...
+  Again!!!
 
-'
+  And this time,
+  the battle between complexity and simplicity
+  has as familiar text.
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - lib/help_parser.rb
+- lib/help_parser/aliases.rb
+- lib/help_parser/completion.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/exceptions.rb
+- lib/help_parser/k2t2r.rb
+- lib/help_parser/macros.rb
+- lib/help_parser/options.rb
+- lib/help_parser/parsea.rb
+- lib/help_parser/parseh.rb
+- lib/help_parser/parseu.rb
+- lib/help_parser/validations.rb
 homepage: https://github.com/carlosjhr64/help_parser
 licenses:
 - MIT
@@ -43,10 +55,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.4.0p0 (2016-12-24 revision 57164) [x86_64-linux]'
+- 'ruby: ruby 2.4.1p111 (2017-03-22 revision 58053) [x86_64-linux]'
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: HelpParser - Parses your help text to define your command line options.
+summary: All help is about to get parsed... Again!!!
 test_files: []

data/lib/help_parser/help_parser.rb

@@ -1,99 +0,0 @@
-module HELP_PARSER
-
-  # 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 # '-'
-          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
-            # 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
-          hsh[n] = a
-          n+=1
-        end
-        i+=1
-      end
-      return hsh
-    end
-
-    def initialize(version=nil, help=nil, argv=nil)
-      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
-      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
-        end
-        ::Kernel::exit(78) # Config
-      end
-      @hash = hsh.freeze
-    end
-
-    def [](k)
-      @hash[k]
-    end
-
-    def _hash
-      @hash
-    end
-
-    def _usage
-      @usage
-    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].to_sym
-      when '!'
-        super
-      else
-        @hash[mthd]
-      end
-    end
-  end
-end

data/lib/help_parser/pattern.rb

@@ -1,140 +0,0 @@
-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, so a key.nil? might be ok
-          begin
-            i = _matches(token,i)
-          rescue NoMatch
-            # Ok, no problem!
-          end
-          next
-        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 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[key])
-            end
-          else
-            @cache[word] = @options[key]
-          end
-        else # it's a literal
-          raise NoMatch if key.nil?
-          if token[0]==M
-            raise NoMatch unless token == ((key.length>1)? MM : M)+key.to_s
-          else
-            raise NoMatch unless @options[key]==token
-          end
-        end
-        i+=1
-      end
-      return i
-    end
-
-    def matches(pattern)
-      begin
-        i = _matches(pattern, 0)
-        raise NoMatch if i != @options.length
-        pad
-        types if @usage[TYPES]
-      rescue NoMatch
-        return false
-      ensure
-        @cache.clear
-      end
-      return true
-    end
-  end
-end

data/lib/help_parser/usage.rb

@@ -1,100 +0,0 @@
-module HELP_PARSER
-  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
-        when S,P,Q
-          unless token==I
-            tokens.push(token)
-            token = I
-          end
-          tokens.push PARSE_USAGE[chars] if c==P
-          return tokens if c==Q
-        else
-          token += c
-        end
-      end
-      tokens.push(token) unless token==I
-      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)
-      hsh,name = {},Z
-      help.strip.split(SNS).each do |line|
-        next if line[0]==C # skip comment lines
-        line.sub!(COMMENTARY,'') # strip out commentary
-        case line
-        when SELECTION
-          name = $1.downcase
-          break if name==NOTES
-          raise HelpError, SECTION_REDEFINITION+name  if hsh[name]
-          hsh[name] = []
-        else
-          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
-            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,@hash)
-      @hash[USAGE].each do |cmd|
-        return self if pattern.matches(cmd)
-      end
-      raise UsageError, MATCH_USAGE
-    end
-  end
-end