help_parser 4.0.0 → 5.0.0

data/lib/help_parser/exceptions.rb

@@ -0,0 +1,51 @@
+module HelpParser
+  class HelpParserException < Exception
+    def _init; @code = 1; end
+
+    # Must give message
+    def initialize(message)
+      _init
+      super
+    end
+
+    def exit
+      if @code > 0
+        STDERR.puts self.message
+      else
+        puts self.message
+      end
+      Kernel.exit @code
+    end
+  end
+
+  class VersionException < HelpParserException
+    def _init; @code = 0; end
+  end
+
+  class HelpException < HelpParserException
+    def _init; @code = 0; end
+  end
+
+  class UsageError < HelpParserException
+    def _init; @code = 64; end
+  end
+
+  class SoftwareError < HelpParserException
+    # Stuff that should not happen
+    def _init; @code = 70; end
+  end
+
+  class NoMatch < HelpParserException
+    # used to shortcircuit out
+    def _init; @code = 70; end
+
+    # Forces it's owm message
+    def initialize
+      super("Software Error: NoMatch was not caught by HelpParser.")
+    end
+  end
+
+  class HelpError < HelpParserException
+    def _init; @code = 78; end
+  end
+end

data/lib/help_parser/k2t2r.rb

@@ -0,0 +1,33 @@
+module HelpParser
+  def self.k2t(specs)
+    k2t = NoDupHash.new
+    tokens = specs.select{|k,v| !(k==TYPES)}.values.flatten.select{|v|v.include?('=')}
+    tokens.each do |token|
+      if match = VARIABLE.match(token) || LONG.match(token)
+        name, type = match["k"], match["t"]
+        k2t[name] = type if !k2t.has_key?(name)
+        raise HelpError, "Inconsistent use of variable: #{name}" unless type==k2t[name]
+      else
+        # Expected these to be caught earlier...
+        raise SoftwareError, "Unexpected string in help text: #{token}"
+      end
+    end
+    return k2t
+  end
+
+  def self.t2r(specs)
+    if types = specs[TYPES]
+      t2r = NoDupHash.new
+      types.each do |pair|
+        type, pattern = *pair
+        begin
+          t2r[type] = Regexp.new(pattern[1..-2])
+        rescue
+          raise HelpError, "Bad regex for #{type}: #{pattern}"
+        end
+      end
+      return t2r
+    end
+    return nil
+  end
+end

data/lib/help_parser/macros.rb

@@ -0,0 +1,199 @@
+module HelpParser
+  def self.string(*names)
+    names.each do |name|
+      code = <<-CODE
+  class Options
+    def #{name}
+      s = @hash["#{name}"]
+      raise UsageError, "#{name} not a String." unless s.is_a?(String)
+      return s
+    end
+  end
+      CODE
+      eval code
+    end
+  end
+
+  def self.string?(*names)
+    names.each do |name|
+      code = <<-CODE
+  class Options
+    def #{name}?
+      s = @hash["#{name}"]
+      raise UsageError, "#{name} not a String." unless s.nil? || s.is_a?(String)
+      return s
+    end
+  end
+      CODE
+      eval code
+    end
+  end
+
+  def self.strings(*names)
+    names.each do |name|
+      code = <<-CODE
+  class Options
+    def #{name}
+      a = @hash["#{name}"]
+      raise UsageError, "#{name} not Strings." unless a.is_a?(Array)
+      return a
+    end
+  end
+      CODE
+      eval code
+    end
+  end
+
+  def self.strings?(*names)
+    names.each do |name|
+      code = <<-CODE
+  class Options
+    def #{name}?
+      a = @hash["#{name}"]
+      raise UsageError, "#{name} not Strings." unless a.nil? || a.is_a?(Array)
+      return a
+    end
+  end
+      CODE
+      eval code
+    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, "#{name} not a Float."
+    end
+  end
+      CODE
+      eval code
+    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, "#{name} not a Float."
+    end
+  end
+      CODE
+      eval code
+    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{|_|_.to_f}
+    rescue
+      raise UsageError, "#{name} not Floats."
+    end
+  end
+      CODE
+      eval code
+    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{|_|_.to_f}
+    rescue
+      raise UsageError, "#{name} not Floats."
+    end
+  end
+      CODE
+      eval code
+    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, "#{name} not an Integer."
+    end
+  end
+      CODE
+      eval code
+    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, "#{name} not an Integer."
+    end
+  end
+      CODE
+      eval code
+    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{|_|_.to_i}
+    rescue
+      raise UsageError, "#{name} not Integers."
+    end
+  end
+      CODE
+      eval code
+    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{|_|_.to_i}
+    rescue
+      raise UsageError, "#{name} not Integers."
+    end
+  end
+      CODE
+      eval code
+    end
+  end
+end

data/lib/help_parser/options.rb

@@ -0,0 +1,40 @@
+module HelpParser
+  class Options
+    def initialize( version, help, argv)
+      @hash = HelpParser.parsea(argv)
+      if version && (@hash.has_key?('v') || @hash.has_key?("version"))
+        # -v or --version
+        raise VersionException, version
+      end
+      if help
+        if @hash.has_key?('h') || @hash.has_key?("help")
+          # -h or --help
+          raise HelpException, help
+        end
+        specs = HelpParser.parseh(help)
+        Completion.new(@hash, specs)
+      end
+    end
+
+    def _hash
+      @hash
+    end
+
+    def [](k)
+      @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]
+      end
+    end
+  end
+end

data/lib/help_parser/parsea.rb

@@ -0,0 +1,29 @@
+module HelpParser
+  def self.parsea(argv)
+    hsh = ArgvHash.new
+    n = 0
+    argv.each do |a|
+      if a[0]=='-'
+        break if a.size==1 # "-" quits argv processing
+        if a[1]=='-'
+          break if a.size==2 # "--" also quits argv processing
+          s = a[2..-1]
+          if s.include?('=')
+            k,v = s.split('=',2)
+            hsh[k] = v
+          else
+            hsh[s] = true
+          end
+        else
+          a.chars[1..-1].each do |c|
+            hsh[c] = true
+          end
+        end
+      else
+        hsh[n] = a
+        n += 1
+      end
+    end
+    return hsh
+  end
+end

data/lib/help_parser/parseh.rb

@@ -0,0 +1,29 @@
+module HelpParser
+  def self.parseh(help)
+    specs,name = NoDupHash.new,""
+    help.each_line do |line|
+      line.chomp!
+      next if line==""
+      if line=~/^[A-Z]\w+:$/
+        name = line[0..-2].downcase
+        specs[name] = []
+      else
+        next if name=="" || !(line[0]==' ')
+        spec = (index=line.rindex("\t"))? line[0,index].strip : line.strip
+        HelpParser.validate_no_extraneous_spaces(spec)
+        if name==USAGE
+          HelpParser.validate_usage_spec(spec)
+          specs[name].push HelpParser.parseu spec
+        elsif name==TYPES
+          HelpParser.validate_type_spec(spec)
+          specs[name].push spec.split(CSV)
+        else
+          HelpParser.validate_option_spec(spec)
+          specs[name].push spec.split(CSV)
+        end
+      end
+    end
+    HelpParser.validate_usage_specs(specs)
+    return specs
+  end
+end

data/lib/help_parser/parseu.rb

@@ -0,0 +1,28 @@
+module HelpParser
+  def self._parseu(chars)
+    tokens,token = [],""
+    while c = chars.shift
+      case c
+      when ' ','[',']'
+        unless token==""
+          tokens.push(token)
+          token = ""
+        end
+        tokens.push HelpParser._parseu(chars) if c=='['
+        return tokens if c==']'
+      else
+        token += c
+      end
+    end
+    tokens.push(token) unless token==""
+    return tokens
+  end
+
+  def self.parseu(line)
+    chars = line.chars
+    HelpParser.validate_line_chars(chars)
+    tokens = HelpParser._parseu(chars)
+    HelpParser.validate_usage_tokens(tokens)
+    return tokens
+  end
+end

data/lib/help_parser/validations.rb

@@ -0,0 +1,98 @@
+module HelpParser
+  def self.validate_line_chars(chars)
+    count = 0
+    chars.each do |c|
+      if c=='['
+        count += 1
+      elsif c==']'
+        count -= 1
+      end
+      break if count<0
+    end
+    raise HelpError, "Unbalance brackets: "+chars.join unless count==0
+  end
+
+  def self.validate_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, "Unrecognized usage token: #{token}" unless match
+      words.push match["k"] # key
+    end
+    words.each_with_index do |word,i|
+      raise HelpError, "Duplicate word: #{word}" unless i==words.rindex(word)
+    end
+  end
+
+  def self.validate_usage_spec(spec)
+    # TODO: Symmetry demands this,
+    # but I can't think of any help text errors I'm not already catching.
+  end
+
+  def self.validate_type_spec(spec)
+    raise HelpError, "Unrecognized type spec: "+spec unless spec=~TYPE_DEF
+  end
+
+  def self.validate_option_spec(spec)
+    case spec
+    when SHORT, LONG, SHORT_LONG, SHORT_LONG_DEFAULT
+      # OK
+    else
+      raise HelpError, "Unrecognized option spec: #{spec}"
+    end
+  end
+
+  def self.validate_usage_specs(specs)
+    option_specs = specs.select{|a,b| !(a==USAGE || a==TYPES)}
+    flags = option_specs.values.flatten.select{|f|f[0]=='-'}.map{|f| HelpParser.f2k(f)}
+    flags.each_with_index do |flag,i|
+      raise HelpError, "Duplicate flag: #{flag}" unless i==flags.rindex(flag)
+    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, "No #{key} section given." unless specs[key]
+          group.push(key)
+        end
+      end
+    end
+    specs.each do |key,tokens|
+      raise HelpError, "No #{key} cases given." unless tokens.size>0
+      next if specs_usage.nil? || key==USAGE || key==TYPES
+      raise HelpError, "No usage given for #{key}." unless group.include?(key)
+    end
+  end
+
+  def self.validate_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))}
+      raise HelpError, "Uncompleted types definition: #{c.join(",")}"
+    end
+    specs.each do |section,tokens|
+      next if section==USAGE || section==TYPES
+      tokens.each do |words|
+        next if words.size<2
+        default = words[-1]
+        next if default[0]=='-'
+        long_type = words[-2]
+        i = long_type.index('=')
+        next if i.nil?
+        long = long_type[2..(i-1)]
+        type = long_type[(i+1)..-1]
+        regex = t2r[type]
+        raise HelpError, "Default not #{type}: #{long}" unless regex=~default
+      end
+    end
+  end
+
+  def self.validate_no_extraneous_spaces(spec)
+    raise HelpError, "Extraneous spaces in help." if spec == ""
+  end
+end