config_parser 0.1.0

data/History

@@ -0,0 +1,5 @@
+== 0.1.0 / 2010-07-25
+
+Initial release after extraction and cleanup from Configurable. Intended as a
+placeholder until final cleanup. Note that the documentation is largely
+inaccurate at this stage.

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010, Simon Chiang
+
+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.

data/README

@@ -0,0 +1,84 @@
+= ConfigParser
+
+Parse command-line options into a configuration hash.
+
+== Description
+
+ConfigParser is an analogue of
+{OptionParser}[http://www.ruby-doc.org/core/classes/OptionParser.html] that
+formalizes the pattern of setting parsed options into a hash. ConfigParser
+uses a similar, simplified declaration syntax that places less emphasis on the
+conversion of inputs to objects, preferring instead to delegate that
+responsibility to whatever consumes the hash.
+
+== Usage
+
+ConfigParser can be used much like OptionParser, where the parser itself can
+be used as a delegate to a config hash.
+
+  parser = ConfigParser.new
+  parser.on '-s', '--long LONG', 'a standard option' do |value|
+    parser[:long] = value
+  end
+ 
+  parser.on '--[no-]switch', 'a switch' do |value|
+    parser[:switch] = value
+  end
+
+  parser.on '--flag', 'a flag' do
+    parser[:flag] = true
+  end
+  
+  parser.parse('a b --long arg --switch --flag c')
+  # => ['a', 'b', 'c']
+  
+  parser.config     
+  # => {:long => 'arg', :switch => true, :flag => true}
+  
+  parser.to_s
+  # => %q{
+  #     -s, --long LONG             a standard option
+  #     --[no-]switch               a switch
+  #     --flag                      a flag
+  # }
+
+ConfigParser formalizes this pattern of setting values into a config hash as
+they occur, and adds the ability to specify default values.
+
+  parser = ConfigParser.new
+  parser.add(:key, 'default')
+
+  parser.parse('a b --key option c')             # => ['a', 'b', 'c']
+  parser.config                                  # => {:key => 'option'}
+                                                 
+  parser.parse('a b c')                          # => ['a', 'b', 'c']
+  parser.config                                  # => {:key => 'default'}
+
+Config keys may be mapped to options using arguments like those given to 'on',
+or using an options hash. A block can be given to processes values before they
+are set as configs.
+
+  parser = ConfigParser.new
+  parser.add(:x, nil, '-o', '--one', 'by args') {|value| value.upcase }
+  parser.add(:y, nil, :long => 'two', :desc => 'by hash')
+  
+  parser.parse('a b --one value --two c')
+  # => ['a', 'b', 'c']
+  
+  parser.config
+  # => {:x => 'VALUE', :y => true}
+
+ConfigParser integrates well with libraries like
+{Configurable}[http://tap.rubyforge.org/configurable] that are designed to set
+configurations via a config hash.
+
+== Installation
+
+ConfigParser is available as a gem via {Gemcutter}[http://rubygems.org/gems/config_parser].
+
+  % gem install config_parser
+
+== Info
+
+Copyright (c) 2010, Simon Chiang
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/lib/config_parser.rb

@@ -0,0 +1,393 @@
+require 'config_parser/list'
+autoload(:Shellwords, 'shellwords')
+
+# ConfigParser is the Configurable equivalent of 
+# {OptionParser}[http://www.ruby-doc.org/core/classes/OptionParser.html]
+# and uses a similar, simplified (see below) syntax to declare options.
+#
+#   opts = {}
+#   parser = ConfigParser.new do |psr|
+#     psr.on "-s", "--long LONG", "a standard option" do |value|
+#       opts[:long] = value
+#     end
+#   
+#     psr.on "--[no-]switch", "a switch" do |value|
+#       opts[:switch] = value
+#     end
+#
+#     psr.on "--flag", "a flag" do
+#       # note: no value is parsed; the block 
+#       # only executes if the flag is found
+#       opts[:flag] = true
+#     end
+#   end
+#
+#   parser.parse("a b --long arg --switch --flag c")   # => ['a', 'b', 'c']
+#   opts             # => {:long => 'arg', :switch => true, :flag => true}
+#
+# ConfigParser formalizes this pattern of setting values in a hash as they
+# occur, and adds the ability to specify default values.  The syntax is
+# not quite as friendly as for ordinary options, but meshes well with
+# Configurable classes:
+#
+#   psr = ConfigParser.new
+#   psr.define(:key, 'default', :desc => 'a standard option')
+#
+#   psr.parse('a b --key option c')                 # => ['a', 'b', 'c']
+#   psr.config                                      # => {:key => 'option'}
+#
+#   psr.parse('a b c')                              # => ['a', 'b', 'c']
+#   psr.config                                      # => {:key => 'default'}
+#
+# And now directly from a Configurable class, the equivalent of the
+# original example:
+#
+#   class ConfigClass
+#     include Configurable
+#
+#     config :long, 'default', :short => 's'  # a standard option
+#     config :switch, false, &c.switch        # a switch
+#     config :flag, false, &c.flag            # a flag
+#   end
+#
+#   psr = ConfigParser.new
+#   psr.add(ConfigClass.configurations)
+#
+#   psr.parse("a b --long arg --switch --flag c")   # => ['a', 'b', 'c']
+#   psr.config    # => {:long => 'arg', :switch => true, :flag => true}
+#
+#   psr.parse("a b --long=arg --no-switch c")       # => ['a', 'b', 'c']
+#   psr.config    # => {:long => 'arg', :switch => false, :flag => false}
+#
+#   psr.parse("a b -sarg c")                        # => ['a', 'b', 'c']
+#   psr.config    # => {:long => 'arg', :switch => false, :flag => false}
+#
+# As you might expect, config attributes are used by ConfigParser to 
+# correctly build a corresponding option.  In configurations like :switch, 
+# the block implies the {:type => :switch} attribute and so the
+# config is made into a switch-style option by ConfigParser.
+#
+# Use the to_s method to convert a ConfigParser into command line
+# documentation:
+#
+#   "\nconfigurations:\n#{psr.to_s}"
+#   # => %q{
+#   # configurations:
+#   #     -s, --long LONG                  a standard option
+#   #         --[no-]switch                a switch
+#   #         --flag                       a flag
+#   # }
+#
+# ==== Simplifications
+#
+# ConfigParser simplifies the OptionParser syntax for 'on'.  ConfigParser does
+# not support automatic conversion of values, gets rid of 'optional' arguments
+# for options, and only supports a single description string.  Hence:
+#
+#   psr = ConfigParser.new
+#  
+#   # incorrect, raises error as this will look
+#   # like multiple descriptions are specified
+#   psr.on("--delay N", 
+#          Float,
+#          "Delay N seconds before executing")        # !> ArgumentError
+#
+#   # correct
+#   psr.on("--delay N", "Delay N seconds before executing") do |value|
+#     value.to_f
+#   end
+#
+#   # this ALWAYS requires the argument and raises
+#   # an error because multiple descriptions are
+#   # specified
+#   psr.on("-i", "--inplace [EXTENSION]",
+#          "Edit ARGV files in place",
+#          "  (make backup if EXTENSION supplied)")   # !> ArgumentError
+#
+#   # correct
+#   psr.on("-i", "--inplace EXTENSION", 
+#          "Edit ARGV files in place\n  (make backup if EXTENSION supplied)")
+#
+#
+class ConfigParser
+  include Utils
+  
+  # Returns an array of the options registered with self, in the order in
+  # which they were added.  Separators are also stored in the registry.
+  attr_reader :registry
+  
+  # A hash of (flag, Option) pairs mapping command line flags like '-s' or
+  # '--long' to the Option that handles them.
+  attr_reader :options
+  
+  # The hash receiving configurations produced by parse.
+  attr_accessor :config
+  
+  # The argument to stop processing options
+  attr_accessor :option_break
+  
+  # Set to true to preserve the break argument
+  attr_accessor :preserve_option_break
+  
+  # Initializes a new ConfigParser and passes it to the block, if given.
+  def initialize(config={}, opts={})
+    opts = {
+      :option_break => OPTION_BREAK,
+      :preserve_option_break => false
+    }.merge(opts)
+    
+    @registry = []
+    @options = {}
+    @config = config
+    @option_break = opts[:option_break]
+    @preserve_option_break = opts[:preserve_option_break]
+    
+    yield(self) if block_given?
+  end
+  
+  # Returns the config value for key.
+  def [](key)
+    config[key]
+  end
+  
+  # Sets the config value for key.
+  def []=(key, value)
+    config[key] = value
+  end
+  
+  # Adds a separator string to self, used in to_s.
+  def separator(str)
+    @registry << str
+  end
+
+  # Registers the option with self by adding opt to options and mapping the
+  # opt flags. Raises an error for conflicting flags.
+  #
+  # If override is specified, options with conflicting flags are removed and
+  # no error is raised.  Note that this may remove multiple options.
+  def register(option, override=false)
+    return if option.nil?
+    
+    if override
+      existing = option.flags.collect {|flag| @options.delete(flag) }
+      @registry -= existing
+    end
+    
+    unless @registry.include?(option)
+      @registry << option
+    end
+    
+    option.flags.each do |flag|
+      current = @options[flag]
+      
+      if current && current != option
+        raise ArgumentError, "already mapped to a different option: #{flag}"
+      end
+      
+      @options[flag] = option
+    end
+    
+    option
+  end
+  
+  # Constructs an Option using args and registers it with self.  Args may
+  # contain (in any order) a short switch, a long switch, and a description
+  # string.  Either the short or long switch may signal that the option
+  # should take an argument by providing an argument name.
+  #
+  #   psr = ConfigParser.new
+  #
+  #   # this option takes an argument
+  #   psr.on('-s', '--long ARG_NAME', 'description') do |value|
+  #     # ...
+  #   end
+  #
+  #   # so does this one
+  #   psr.on('-o ARG_NAME', 'description') do |value|
+  #     # ...
+  #   end
+  #   
+  #   # this option does not
+  #   psr.on('-f', '--flag') do
+  #     # ...
+  #   end
+  #
+  # A switch-style option can be specified by prefixing the long switch with
+  # '--[no-]'.  Switch options will pass true to the block for the positive
+  # form and false for the negative form.
+  #
+  #   psr.on('--[no-]switch') do |value|
+  #     # ...
+  #   end
+  #
+  # Args may also contain a trailing hash defining all or part of the option:
+  #
+  #   psr.on('-k', :long => '--key', :desc => 'description')
+  #     # ...
+  #   end
+  #
+  def on(*args, &block)
+    register new_option(args, &block)
+  end
+  
+  # Same as on, but overrides options with overlapping switches.
+  def on!(*args, &block)
+    register new_option(args, &block), true
+  end
+  
+  # Defines and registers a config-style option with self.  Define does not
+  # take a block; the default value will be added to config, and any parsed
+  # value will override the default.  Normally the key will be turned into
+  # the long switch; specify an alternate long, a short, description, etc
+  # using attributes.
+  #
+  #   psr = ConfigParser.new
+  #   psr.define(:one, 'default')
+  #   psr.define(:two, 'default', :long => '--long', :short => '-s')
+  #
+  #   psr.parse("--one one --long two")
+  #   psr.config             # => {:one => 'one', :two => 'two'}
+  #
+  # Define support several types of configurations that define a special 
+  # block to handle the values parsed from the command line.  See the 
+  # 'setup_<type>' methods in Utils.  Any type with a corresponding setup
+  # method is valid:
+  #   
+  #   psr = ConfigParser.new
+  #   psr.define(:flag, false, :type => :flag)
+  #   psr.define(:switch, false, :type => :switch)
+  #   psr.define(:list, [], :type => :list)
+  #
+  #   psr.parse("--flag --switch --list one --list two --list three")
+  #   psr.config             # => {:flag => true, :switch => true, :list => ['one', 'two', 'three']}
+  #
+  # New, valid types may be added by implementing new setup_<type> methods
+  # following this pattern:
+  #
+  #   module SpecialType
+  #     def setup_special(key, default_value, attributes)
+  #       # modify attributes if necessary
+  #       attributes[:long] = "--#{key}"
+  #       attributes[:arg_name] = 'ARG_NAME'
+  # 
+  #       # return a block handling the input
+  #       lambda {|input| config[key] = input.reverse }
+  #     end
+  #   end
+  #
+  #   psr = ConfigParser.new.extend SpecialType
+  #   psr.define(:opt, false, :type => :special)
+  #
+  #   psr.parse("--opt value")
+  #   psr.config             # => {:opt => 'eulav'}
+  #
+  # The :hidden type causes no configuration to be defined.  Raises an error if
+  # key is already set by a different option.
+  def add(key, default=nil, *args, &block)
+    attrs = args.last.kind_of?(Hash) ? args.pop : {}
+    attrs = attrs.merge(:key => key, :default => default)
+    args << attrs
+    
+    on(*args, &block)
+  end
+  
+  # Parses options from argv in a non-destructive manner and returns an
+  # array of arguments remaining after options have been removed. If a 
+  # string argv is provided, it will be splits into an array using 
+  # Shellwords.
+  #
+  # ==== Options
+  #
+  # clear_config:: clears the currently parsed configs (true)
+  # add_defaults:: adds the default values to config (true)
+  # ignore_unknown_options:: causes unknown options to be ignored (false)
+  #
+  def parse(argv=ARGV)
+    argv = argv.dup unless argv.kind_of?(String)
+    parse!(argv)
+  end
+  
+  # Same as parse, but removes parsed args from argv.
+  def parse!(argv=ARGV)
+    argv = Shellwords.shellwords(argv) if argv.kind_of?(String)
+    
+    args = []
+    remainder = scan(argv) {|arg| args << arg }
+    args.concat(remainder)
+    argv.replace(args)
+    
+    argv
+  end
+  
+  def scan(argv=ARGV)
+    while !argv.empty?
+      arg = argv.shift
+  
+      # determine if the arg is an option
+      unless arg.kind_of?(String) && arg[0] == ?-
+        yield(arg)
+        next
+      end
+      
+      # add the remaining args and break
+      # for the option break
+      if option_break === arg
+        argv.unshift(arg) if preserve_option_break
+        break
+      end
+      
+      flag, value = arg, nil
+      
+      # try the flag directly
+      unless option = @options[flag]
+        
+        # then try --opt=value syntax
+        flag, value = flag.split('=', 2)
+        
+        # then try -ovalue syntax
+        if value.nil? && flag[1] != ?-
+          flag, value = flag[0, 2], flag[2, flag.length - 2]
+        end
+        
+        unless option = @options[flag]
+          raise "unknown option: #{flag}"
+        end
+      end
+      
+      option.parse(flag, value, argv, config)
+    end
+    
+    argv
+  end
+  
+  # Converts the options and separators in self into a help string suitable for
+  # display on the command line.
+  def to_s
+    @registry.collect do |option|
+      option.to_s.rstrip
+    end.join("\n") + "\n"
+  end
+  
+  protected
+  
+  def option_class(attrs) # :nodoc:
+    type = attrs[:type] || guess_type(attrs)
+    
+    case type
+    when :option then Option
+    when :flag   then Flag
+    when :switch then Switch
+    when :list   then List
+    when Class   then type
+    else raise "unknown option type: #{type}"
+    end
+  end
+  
+  # helper to parse an option from an argv.  new_option is used
+  # by on and on! to generate options
+  def new_option(argv, &block) # :nodoc:
+    attrs = argv.last.kind_of?(Hash) ? argv.pop : {}
+    attrs = attrs.merge parse_attrs(argv)
+    option_class(attrs).new(attrs, &block)
+  end
+end

data/lib/config_parser/flag.rb

@@ -0,0 +1,121 @@
+require 'config_parser/utils'
+
+class ConfigParser
+  class Flag
+    include Utils
+    
+    # The config key
+    attr_reader :key
+    
+    # The default value
+    attr_reader :default
+    
+    # The short flag mapping to self
+    attr_reader :short 
+    
+    # The long flag mapping to self
+    attr_reader :long
+    
+    # The description printed by to_s
+    attr_reader :desc
+    
+    # A callback for processing values
+    attr_reader :callback
+    
+    def initialize(attrs={}, &callback)
+      @key   = attrs[:key]
+      @default = attrs[:default]
+      @short = shortify(attrs[:short])
+      @long  = longify(attrs.has_key?(:long) ? attrs[:long] : key)
+      @desc  = attrs[:desc]
+      @callback = callback
+    end
+    
+    # Returns an array of non-nil flags mapping to self (ie [long, short]).
+    def flags
+      [long, short].compact
+    end
+    
+    # Assigns true into config and raises an error if a value is provided
+    # (flags take none).  The callback will be called if specified to provide
+    # the assigned value.
+    #
+    # Note this is the entry point for handling different types of
+    # configuration flags.
+    #
+    #--
+    # Implementation Note
+    #
+    # The compact syntax for short flags is handled through parse by
+    # unshifting remaining shorts (ie value) back onto argv.  This allows
+    # shorts that consume a value to take the remainder as needed.  As an
+    # example to clarify, assume -x -y are flags where -x takes a value and -y
+    # does not.  These are equivalent:
+    #
+    #   -x value -y
+    #   -xvalue -y
+    #   -y -xvalue
+    #   -yxvalue
+    #      
+    # Whereas this is not:
+    #
+    #   -xyvalue                   # x receives 'yvalue' not 'value'
+    #
+    # Parse handles the compact short syntax splitting '-yxvalue' into '-y',
+    # 'xvalue'. Then '-y' determines whether or not it needs a values; if not
+    # '-xvalue' gets unshifted to argv and parsing continues as if '-y
+    # -xvalue' were the original arguments.
+    def parse(flag, value, argv=[], config={})
+      unless value.nil?
+        if flag == short
+          argv.unshift "-#{value}"
+        else
+          raise "value specified for flag: #{flag}"
+        end
+      end
+      
+      assign(config, callback ? callback.call : default.nil? ? false : default)
+    end
+    
+    # Assign the value to the config hash, if key is set.  Returns value.
+    def assign(config, value)
+      config[key] = value if key
+      value
+    end
+    
+    # Formats self as a help string for use on the command line.
+    def to_s
+      lines = wrap(desc.to_s, 43)
+      
+      header =  header_str
+      header = header.length > 36 ? header.ljust(80) : (LINE_FORMAT % [header, lines.shift])
+      
+      if lines.empty?
+        header
+      else
+        lines.collect! {|line| LINE_FORMAT % [nil, line] }
+        "#{header}\n#{lines.join("\n")}"
+      end
+    end
+    
+    private
+    
+    def header_str # :nodoc:
+      "    #{short_str}#{long_str}"
+    end
+    
+    # helper returning short formatted for to_s
+    def short_str # :nodoc:
+      case
+      when short && long then "#{short}, "
+      when short then "#{short}"
+      else '    '
+      end
+    end
+    
+    # helper returning long formatted for to_s
+    def long_str # :nodoc:
+      long
+    end
+  end
+end

data/lib/config_parser/list.rb

@@ -0,0 +1,38 @@
+require 'config_parser/option'
+
+class ConfigParser
+  class List < Option
+    
+    # The default split character for multiple values
+    DEFAULT_SPLIT = ','
+    
+    # The maximum number of values that may be specified.
+    attr_reader :limit
+    
+    # The sequence on which to split single values into multiple values. Set
+    # to nil to prevent split.
+    attr_reader :split
+    
+    def initialize(attrs={})
+      super
+      @limit = attrs[:n]
+      @split = attrs.has_key?(:split) ? attrs[:split] : DEFAULT_SPLIT
+    end
+    
+    # List assigns configs by pushing the value onto an array, rather than
+    # directly setting it onto config.  As usual, no value is assigned if key
+    # is not set.  Returns value (the input, not the array).
+    def assign(config, value)
+      if key
+        array = (config[key] ||= [])
+        array.concat(split ? value.split(split) : [value])
+      
+        if limit && array.length > limit
+          raise "too many assignments: #{key.inspect}"
+        end
+      end
+      
+      value
+    end
+  end
+end

data/lib/config_parser/option.rb

@@ -0,0 +1,40 @@
+require 'config_parser/switch'
+
+class ConfigParser
+  
+  # Represents an option registered with ConfigParser.
+  class Option < Flag
+    DEFAULT_ARGNAME = 'VALUE'
+    
+    # The argument name printed by to_s.
+    attr_reader :arg_name
+    
+    def initialize(attrs={})
+      super
+      @arg_name = attrs[:arg_name] || (key ? key.to_s.upcase : DEFAULT_ARGNAME)
+    end
+    
+    # Parse the flag and value.  If no value is provided and a value is
+    # required, then a value is shifted off of argv.  Calls the callback
+    # with the value, if specified, and assigns the result.
+    def parse(flag, value, argv=[], config={})
+      if value.nil?
+        unless value = next_arg(argv)
+          raise "no value provided for: #{flag}"
+        end
+      end
+      assign(config, callback ? callback.call(value) : value)
+    end
+    
+    private
+    
+    def next_arg(argv) # :nodoc:
+      arg = argv[0]
+      (arg.kind_of?(String) && arg[0] == ?-) ? default : argv.shift
+    end
+    
+    def header_str # :nodoc:
+      "    #{short_str}#{long_str} #{arg_name}"
+    end
+  end
+end

data/lib/config_parser/switch.rb

@@ -0,0 +1,43 @@
+require 'config_parser/flag'
+
+class ConfigParser
+  
+  # Switch represents a special type of Option where both positive (--flag)
+  # and negative (--no-flag) flags map to self.
+  class Switch < Flag
+    
+    # The negative long flag, determined from long if not set otherwise.
+    attr_reader :negative_long
+    
+    def initialize(attrs={})
+      attrs[:default] = true unless attrs.has_key?(:default)
+      super
+      
+      raise ArgumentError, "no long specified" unless long
+      @negative_long = attrs[:negative_long] || prefix_long(long, 'no-')
+    end
+    
+    # Returns an array of non-nil flags mapping to self (ie [long,
+    # negative_long, short]).
+    def flags
+      [long, negative_long, short].compact
+    end
+    
+    # Assigns true into config for positive flags and false for negative
+    # flags.  If specified, the callback is called with the boolean to
+    # determine the assigned value.  Raises an error if a value is provided
+    # (switches take none).
+    def parse(flag, value, argv=[], config={})
+      raise "value specified for switch: #{flag}" if value
+      value = (flag == negative_long ? !default : default)
+      assign(config, callback ? callback.call(value) : value)
+    end
+
+    private
+    
+    # helper returning long formatted for to_s
+    def long_str # :nodoc:
+      long ? prefix_long(long, '[no-]') : ''
+    end
+  end
+end

data/lib/config_parser/utils.rb

@@ -0,0 +1,135 @@
+class ConfigParser
+  
+  # A medly of methods used throughout the ConfigParser classes.
+  module Utils
+    module_function
+    
+    # A format string used by to_s
+    LINE_FORMAT = "%-36s %-43s"
+    
+    # The default option break
+    OPTION_BREAK = "--"
+    
+    # Matches a long flag
+    LONG_FLAG = /\A--.+\z/
+
+    # Matches a short flag
+    SHORT_FLAG = /\A-.\z/
+    
+    # Matches a switch declaration (ex: '--[no-]opt', '--nest:[no-]opt').
+    # After the match:
+    #  
+    #   $1:: the nesting prefix ('nest')
+    #   $2:: the long flag name ('opt')
+    #
+    SWITCH = /\A--(.*?)\[no-\](.+)\z/
+    
+    # Turns the input into a short flag by prefixing '-' (as needed). Raises
+    # an error if the input doesn't result in a short flag.   Nils are
+    # returned directly.
+    #
+    #   shortify('-o')         # => '-o'
+    #   shortify(:o)           # => '-o'
+    #
+    def shortify(str)
+      return nil if str.nil?
+  
+      str = str.to_s
+      str = "-#{str}" unless str[0] == ?-
+      
+      unless str =~ SHORT_FLAG
+        raise ArgumentError, "invalid short flag: #{str}"
+      end
+      
+      str
+    end
+
+    # Turns the input into a long flag by prefixing '--' (as needed).  Raises
+    # an error if the input doesn't result in a long flag.   Nils are
+    # returned directly.
+    #
+    #   longify('--opt')       # => '--opt'
+    #   longify(:opt)          # => '--opt'
+    #
+    def longify(str)
+      return nil if str.nil?
+  
+      str = str.to_s
+      str = "--#{str}" unless str[0] == ?-
+      
+      unless str =~ LONG_FLAG
+        raise ArgumentError, "invalid long flag: #{str}"
+      end
+      
+      str
+    end
+    
+    # Adds a prefix onto the last nested segment of a long option.
+    #
+    #   prefix_long('--opt', 'no-')         # => '--no-opt'
+    #   prefix_long('--nested:opt', 'no-')  # => '--nested:no-opt'
+    #
+    def prefix_long(switch, prefix, split_char=':')
+      switch = switch[2, switch.length-2] if switch =~ /^--/
+      switch = switch.split(split_char)
+      switch[-1] = "#{prefix}#{switch[-1]}"
+      "--#{switch.join(':')}"
+    end
+    
+    # A wrapping algorithm slightly modified from:
+    # http://blog.macromates.com/2006/wrapping-text-with-regular-expressions/
+    def wrap(line, cols=80, tabsize=2)
+      line = line.gsub(/\t/, " " * tabsize) unless tabsize == nil
+      line.gsub(/(.{1,#{cols}})( +|$\r?\n?)|(.{1,#{cols}})/, "\\1\\3\n").split(/\s*?\n/)
+    end
+    
+    def parse_attrs(argv)
+      attrs={}
+      
+      argv.each do |arg|
+        if arg[0] != ?-
+          attrs[:desc] = arg
+          next
+        end
+
+        flag, arg_name = arg.split(/\s+/, 2)
+
+        if arg_name
+          attrs[:arg_name] = arg_name
+        end
+
+        case flag
+        when SWITCH
+          attrs[:long] = "--#{$1}#{$2}"
+          attrs[:negative_long] = "--#{$1}no-#{$2}"
+
+          if arg_name
+            raise ArgumentError, "arg_name specified for switch: #{arg_name}"
+          end
+
+        when LONG_FLAG
+          attrs[:long] = flag
+
+        when SHORT_FLAG
+          attrs[:short] = flag
+
+        else
+          raise ArgumentError.new("invalid flag: #{arg.inspect}")
+        end
+      end
+
+      attrs
+    end
+    
+    def guess_type(attrs) # :nodoc:
+      case
+      when attrs[:negative_long]
+        :switch
+      when attrs[:arg_name] || attrs[:default]
+        :option
+      else
+        :flag
+      end
+    end
+  end
+end

data/lib/config_parser/version.rb

@@ -0,0 +1,7 @@
+class ConfigParser
+  MAJOR = 0
+  MINOR = 1
+  TINY = 0
+
+  VERSION="#{MAJOR}.#{MINOR}.#{TINY}"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: config_parser
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-25 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: lazydoc
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History
+- README
+- MIT-LICENSE
+files: 
+- lib/config_parser.rb
+- lib/config_parser/flag.rb
+- lib/config_parser/list.rb
+- lib/config_parser/option.rb
+- lib/config_parser/switch.rb
+- lib/config_parser/utils.rb
+- lib/config_parser/version.rb
+- History
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- -S
+- -N
+- --title
+- ConfigParser
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ""
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Parse command-line options into a configuration hash
+test_files: []
+