ragol 0.0.3

data/lib/ragol/args.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/hash'
+
+module Ragol
+  class OptionArguments < Hash
+    VAR_TYPES = {
+      :boolean => :boolean,
+      :string => :string,
+      :float => :float,
+      :integer => :fixnum,
+      :fixnum => :fixnum,
+      :regexp => :regexp,
+    }
+
+    OLD_OPTIONS = {
+      :regexps => [ Regexp.new('--fo+'), Regexp.new('--ba*r') ],
+      :tags => [ '--foo', '-b' ],
+      :arg => [ [ :boolean, :string, :float, :integer, :fixnum, :regexp ], [ :optional, :required, :none ] ],
+      :set => Proc.new { },
+      :rcnames => [ "foo" ],
+      :rc => [ ]
+    }
+    
+    NEW_OPTIONS = {
+      :regexps => [ Regexp.new('--fo+'), Regexp.new('--ba*r') ],
+      :tags => [ '--foo', '-b' ],
+      :rcnames => [ 'foo', 'foobar' ],
+      :takesvalue => [ true, :optional, false ],
+      :valuetype => [ :boolean, :string, :float, :integer, :fixnum, :regexp ],
+      :valueregexp => Regexp.new('(one|two|three)'),
+      :default => nil,
+      :process => Proc.new { |val| },
+      :postproc => Proc.new { |optset, results, unprocessed| },
+      :description => "a description"
+    }
+    
+    def initialize origargs = Hash.new
+      super()
+
+      if origargs[:arg]
+        if re = origargs[:arg].find { |x| x.kind_of?(Regexp) }
+          self[:valueregexp] = re
+          self[:valuetype] = :regexp
+        else
+          self[:valuetype] = Ragol::HashUtil.hash_array_value VAR_TYPES, origargs[:arg]
+        end
+        
+        self[:takesvalue] = if self[:valuetype] == :boolean
+                              false
+                            else
+                              hasvaluetype = self[:valuetype] != nil
+                              takes = { :optional => :optional, :required => true, :none => hasvaluetype, nil => hasvaluetype }
+                              Ragol::HashUtil.hash_array_value takes, origargs[:arg]
+                            end
+      else
+        Ragol::HashUtil.copy_hash self, origargs, [ [ :takesvalue, :valuereq ], [ :valuetype ], [ :valueregexp ] ]
+        if self[:valuetype]
+          self[:takesvalue] ||= true
+        end
+      end
+
+      fields = [
+                [ :regexps, :regexp, :res, :re ],
+                [ :tags ],
+                [ :process, :set ],
+                [ :postproc ],
+                [ :rcnames, :rcname, :rc ],
+                [ :default ],
+                [ :unsets, :unset ],
+                [ :description ],
+               ]
+      Ragol::HashUtil.copy_hash self, origargs, fields
+    end
+  end
+end

data/lib/ragol/argslist.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Ragol
+  class ArgsList
+    attr_accessor :args
+    
+    def initialize args = Array.new
+      @args = args
+    end
+
+    def next_arg
+      curr = @args.shift
+      re = Regexp.new('^- (?:(\d+)(\D+) | ([a-zA-Z])(\w+) )', Regexp::EXTENDED)
+
+      if md = re.match(curr)
+        mi = md[1] ? 1 : 3
+        arg, newarg = ('-' + md[mi]), ('-' + md[mi + 1])
+        @args.unshift newarg
+        arg
+      else
+        curr
+      end
+    end
+
+    def shift_arg
+      @args.shift
+    end
+
+    def args_empty?
+      @args.empty?
+    end
+
+    def empty?
+      @args.empty?
+    end
+
+    def current_arg
+      curr = @args[0]
+      re = Regexp.new('^-(?:\d+|\w)')
+      if md = re.match(curr)
+        md[0]
+      else
+        curr
+      end
+    end
+
+    def eql? args
+      @args == args
+    end
+
+    def [] idx
+      @args[idx]
+    end
+
+    def end_of_options?
+      current_arg == '--'
+    end
+  end
+end

data/lib/ragol/boolean_option.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+
+module Ragol
+  # a boolean option maps to a single tag, not a tag and value. For example,
+  # "-v" (verbose) is a boolean option, but "-r 3444" (revision) is a option
+  # with a value.
+  class BooleanOption < Option
+    def takes_value?
+      false
+    end
+  end
+end

data/lib/ragol/doc.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+
+module Ragol
+  # documentation for an option.
+  class Doc
+    include Logue::Loggable
+
+    def initialize option
+      @option = option
+    end
+
+    def to_doc_tag
+      tags = @option.matchers.tags.elements
+      longopts, shortopts = tags.partition { |tag| tag[0 .. 1] == '--' }
+      tagline = [ shortopts, longopts ].flatten.join ', '
+      if @option.takes_value?
+        tagline << " ARG"
+      end
+      tagline
+    end
+
+    # returns an option regexp as a 'cleaner' string
+    def re_to_string re
+      re.source.gsub(%r{\\d\+?}, 'N').gsub(%r{[\^\?\$\\\(\)]}, '')
+    end
+
+    def to_doc_negate
+      doc = nil
+      @option.matchers.negatives.elements.each do |neg|
+        str = if neg.kind_of? Regexp
+                str = re_to_string neg
+              else
+                str = neg
+              end
+
+        if doc
+          doc << " [#{str}]"
+        else
+          doc = str
+        end
+      end
+      doc
+    end
+
+    #   -g [--use-merge-history] : use/display additional information from merge
+    # 01234567890123456789012345678901234567890123456789012345678901234567890123456789
+    # 0         1         2         3         4         5         6         
+
+    def to_doc_line lhs, rhs, sep = ""
+      fmt = "  %-24s %1s %s"
+      sprintf fmt, lhs, sep, rhs
+    end
+      
+    def to_doc io
+      # wrap optdesc?
+
+      [ @option.description ].flatten.each_with_index do |descline, idx|
+        lhs = idx == 0 ? to_doc_tag :  ""
+        io.puts to_doc_line lhs, descline, idx == 0 ? ":" : ""
+      end
+
+      if defval = @option.default
+        io.puts to_doc_line "", "  default: #{defval}"
+      end
+
+      if re = @option.matchers.regexps
+        io.puts to_doc_line re_to_string(re), "same as above", ":"
+      end
+
+      if @option.matchers.negatives
+        lhs = to_doc_negate
+        io.puts to_doc_line lhs, "", ""
+      end
+    end
+  end
+end

data/lib/ragol/exception.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Ragol
+  class OptionException < RuntimeError
+  end
+end

data/lib/ragol/fixnum_option.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+
+module Ragol
+  class FixnumOption < Option
+    REGEXP = Regexp.new '^ ([\-\+]?\d+) $ ', Regexp::EXTENDED
+    
+    def value_regexp
+      REGEXP
+    end
+    
+    def convert md
+      return unless val = md && md[-1]
+      val.to_i
+    end
+  end
+end

data/lib/ragol/float_option.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+
+module Ragol
+  class FloatOption < Option
+    REGEXP = Regexp.new '^ ([\-\+]?\d* (?:\.\d+)?) $ ', Regexp::EXTENDED
+    
+    def value_regexp
+      REGEXP
+    end
+    
+    def convert md
+      return unless val = md && md[-1]
+      val.to_f
+    end
+  end
+end

data/lib/ragol/hash.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Ragol
+  module HashUtil
+    def self.copy_hash to_hash, from_hash, fields = Array.new
+      fields.each do |fieldnames|
+        to_hash[fieldnames.first] = from_hash[fieldnames.find { |x| from_hash[x] }]
+      end
+    end
+
+    def self.hash_array_value hash, array
+      hash[(array & hash.keys)[0]]
+    end
+  end
+end

data/lib/ragol/matcher.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+
+module Ragol
+  class Matcher
+    include Logue::Loggable
+    
+    attr_reader :elements
+    
+    def initialize tags
+      @elements = [ tags ].flatten.compact
+    end
+
+    def find_match opt
+      tag = opt.split('=', 2)[0] || opt
+
+      @elements.each do |elmt|
+        if elmt.kind_of?(Regexp)
+          if md = elmt.match(tag)
+            return [ :regexp, md ]
+          end
+        elsif tag.length > elmt.length
+          next 
+        elsif elmt.index(tag) == 0
+          score = tag.length == elmt.length ? 1.0 : tag.length * 0.01
+          return [ :string, score ]
+        end
+      end
+      nil
+    end
+
+    def match? opt
+      type, val = find_match(opt)
+      type && val
+    end
+
+    def score opt
+      type, val = find_match(opt)
+      type && (type == :regexp ? 1.0 : val)
+    end
+
+    def to_s
+      @elements.join(', ')
+    end
+  end
+end

data/lib/ragol/matchers.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+require 'ragol/matcher'
+
+module Ragol
+  class Matchers
+    include Logue::Loggable
+
+    attr_reader :tags
+    attr_reader :negatives
+    attr_reader :regexps
+
+    def initialize tags, negate, regexp
+      @tags = tags
+      @negatives = negate
+      @regexps = regexp
+    end
+
+    def tag_match? arg
+      @tags and @tags.match? arg
+    end
+
+    def negative_match? arg
+      @negatives and @negatives.match? arg
+    end
+
+    def regexp_match? arg
+      @regexps and @regexps.match? arg
+    end
+
+    def match_type? arg
+      case 
+      when tm = tag_match?(arg)
+        [ :tag_match, tm ]
+      when nm = negative_match?(arg)
+        [ :negative_match, nm ]
+      when rm = regexp_match?(arg)
+        [ :regexp_match, rm ]
+      else
+        nil
+      end
+    end
+
+    def name
+      @name ||= begin
+                  if @tags
+                    if longtag = @tags.elements.find { |t| t[0, 2] == '--' }
+                      longtag.sub(%r{^--}, '')
+                    else
+                      @tags.elements[0][1 .. -1]
+                    end
+                  elsif @regexps
+                    @regexps.elements[0].to_s
+                  end
+                end
+    end
+
+    def to_s
+      [ @tags, @regexps ].compact.collect { |x| x.to_s }.join(' ')
+    end
+  end
+end

data/lib/ragol/option.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+require 'ragol/matcher'
+require 'ragol/matchers'
+require 'ragol/doc'
+
+module Ragol
+  class Option
+    include Logue::Loggable
+
+    attr_reader :matchers
+
+    attr_accessor :name
+    attr_accessor :default
+    attr_accessor :description
+    attr_accessor :tags
+    attr_accessor :negates
+    attr_accessor :regexps
+    
+    def initialize options = Hash.new, &blk
+      @tags = nil
+      @negates = nil
+      @regexps = nil
+      @name = nil
+      @default = nil
+      @unsets = nil
+      @process = nil
+      @takesvalue = nil
+      @rcnames = nil
+      @description = nil
+
+      if blk
+        blk.call self
+      end
+
+      tagsmatch = to_matcher(@tags || options[:tags])
+      negatesmatch = to_matcher(@negates || options[:negates])
+      regexpsmatch = to_matcher(@regexps || options[:regexps])
+
+      @matchers = Ragol::Matchers.new tagsmatch, negatesmatch, regexpsmatch
+
+      @name ||= options[:name] || @matchers.name
+
+      @default ||= options[:default]
+      @unsets ||= options[:unsets]
+      @process ||= options[:process]
+      @takesvalue ||= options[:takesvalue]
+      @rcnames ||= [ options[:rcnames] ].flatten
+      @description ||= options[:description]
+    end
+
+    def match_rc? field
+      @rcnames.include?(field)
+    end
+
+    def to_matcher elements
+      elements && Ragol::Matcher.new(elements)
+    end
+
+    def takes_value?
+      @takesvalue
+    end
+
+    def post_process option_set, results, unprocessed
+      resolve_value option_set, results, unprocessed
+
+      if @unsets
+        option_set.unset results, @unsets
+      end
+    end
+
+    def resolve_value option_set, results, unprocessed
+    end
+    
+    def to_s
+      @matchers.to_s
+    end
+
+    def value_regexp
+    end
+
+    def convert md
+      md.kind_of?(MatchData) ? md[-1] : md
+    end
+
+    def do_match val
+      if valuere = value_regexp
+        unless md = valuere.match(val)
+          raise "invalid argument '#{val}' for option: #{self}"
+        end
+        md
+      else
+        val
+      end
+    end
+
+    def take_eq_value opt
+      val = opt.split('=', 2)[1]
+      val && do_match(val)
+    end
+
+    def argument_missing
+      if takes_value? == true
+        raise "value expected for option: #{self}"
+      end
+    end
+
+    def match_next_value_required results
+      val = results.shift_arg
+      val && do_match(val)
+    end
+
+    def match_next_value_optional results
+      return unless val = results.current_arg
+      return true if val[0] == '-'
+      return results.shift_arg unless valuere = value_regexp
+      
+      if md = valuere.match(results.current_arg)
+        results.shift_arg
+        md
+      else
+        true
+      end
+    end
+
+    def match_next_value results
+      if takes_value? == true
+        match_next_value_required results
+      else
+        match_next_value_optional results
+      end
+    end
+
+    def set_value_for_tag results, arg
+      md = if takes_value?
+             take_eq_value(arg) || match_next_value(results) || argument_missing
+           else
+             true
+           end
+      set_option_value md, arg, results
+    end
+
+    def set_value_negative results, arg
+      set_option_value false, arg, results
+    end
+
+    def set_value_regexp results, arg
+      md = @matchers.regexp_match? arg
+      set_option_value md, arg, results
+    end
+
+    def set_option_value md, arg, results
+      value = md == true ? true : convert(md)
+      if @process
+        setargs = [ value, arg, results.unprocessed ][0 ... @process.arity]
+        @process.call(*setargs)
+      end
+      results.set_value name, value
+    end
+      
+    def to_doc io
+      doc = Ragol::Doc.new self
+      doc.to_doc io
+    end
+  end
+end

data/lib/ragol/optproc/optproc.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/optproc/optset'

data/lib/ragol/optproc/optset.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/optset'
+
+module OptProc
+  class OptionSet < Ragol::OptionSet
+    include Logue::Loggable
+    
+    def initialize data
+      super :data => data
+    end
+
+    # this is a legacy method; process should be used instead.
+    def process_option argslist
+      set_option argslist
+    end
+  end
+end

data/lib/ragol/optset.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+require 'ragol/results'
+require 'ragol/exception'
+require 'ragol/args'
+
+module Ragol
+  class OptionSet
+    include Logue::Loggable
+
+    # maps from an OptionSet class to the valid options for that class.
+    @@options_for_class = Hash.new { |h, k| h[k] = Array.new }
+
+    def self.has_option optcls, optargs = Hash.new
+      @@options_for_class[self] << { :class => optcls, :args => optargs }
+    end
+
+    def self.options_for_class cls
+      @@options_for_class[cls]
+    end
+
+    attr_reader :options
+    
+    def initialize(*options)
+      # puts "options: #{options.inspect}"
+      if options[0] && options[0].kind_of?(Hash)
+        data = options[0][:data]
+        options = data.collect do |optdata|
+          optargs = OptionArguments.new(optdata)
+
+          opttype = optargs[:valuetype]
+          clstype = OptionArguments::VAR_TYPES[opttype]
+
+          if clstype
+            clsstr = clstype.to_s
+            require 'ragol/' + clsstr + '_option'
+            clssym = (clsstr.capitalize + 'Option').to_sym
+            optcls = ::Ragol.const_get(clssym)
+            optcls.new(optargs)
+          else
+            Ragol::Option.new(optargs)
+          end
+        end
+      end
+      
+      @options = options
+
+      cls = self.class
+      while cls <= OptionSet
+        opts = self.class.options_for_class(cls)
+        
+        opts.each do |option|
+          args = option[:args]
+          opt = option[:class].new(*args)
+          
+          add opt
+        end
+        
+        cls = cls.superclass
+      end
+    end
+
+    def name
+      @name ||= self.class.to_s.sub(%r{.*?(\w+)OptionSet}, '\1').downcase
+    end
+
+    def inspect
+      @options.collect { |opt| opt.inspect }.join("\n")
+    end
+
+    def find_by_name name
+      @options.find { |opt| opt.name == name }
+    end
+
+    def << option
+      add option
+    end
+
+    def add option
+      @options << option
+      option
+    end
+    
+    def get_best_match results
+      tag_matches = Hash.new { |h, k| h[k] = Array.new }
+      negative_match = nil
+      regexp_match = nil
+
+      options.each do |opt|
+        if mt = opt.matchers.match_type?(results.current_arg)
+          case mt[0]
+          when :tag_match
+            tag_matches[mt[1]] << opt
+          when :negative_match
+            negative_match = opt
+          when :regexp_match
+            regexp_match = opt
+          end
+        end
+      end
+
+      if tag_matches.keys.any?
+        highest = tag_matches.keys.sort[-1]
+        opts = tag_matches[highest]
+        if opts.size > 1
+          optstr = opts.collect { |opt| '(' + opt.to_s + ')' }.join(', ')
+          raise "ambiguous match of '#{results.current_arg}'; matches options: #{optstr}"
+        end
+        [ :tag_match, opts.first ]
+      elsif negative_match
+        [ :negative_match, negative_match ]
+      elsif regexp_match
+        [ :regexp_match, regexp_match ]
+      else
+        nil
+      end
+    end
+
+    def find_matching_option results
+      type, opt = get_best_match(results)
+
+      unless type
+        raise OptionException.new "#{name}: invalid option '#{results.current_arg}'"
+      end
+
+      [ type, opt ]
+    end
+
+    def set_option results
+      type, opt = find_matching_option(results)
+
+      case type
+      when :tag_match
+        arg = results.next_arg
+        opt.set_value_for_tag results, arg
+      when :negative_match
+        arg = results.next_arg
+        opt.set_value_negative results, arg
+      when :regexp_match
+        arg = results.next_arg
+        opt.set_value_regexp results, arg
+      end
+
+      opt
+    end
+
+    def process args, results = Ragol::Results.new(options, args)
+      options_processed = Array.new
+      
+      while !results.args_empty?
+        if results.end_of_options?
+          results.shift_arg
+          break
+        elsif results.current_arg[0] != '-'
+          break
+        end
+
+        option = set_option(results)
+        if option
+          options_processed << option
+        else
+          break
+        end
+      end
+
+      options_processed.each do |opt|
+        opt.post_process self, results, results.args
+      end
+
+      results
+    end
+    
+    def unset results, key
+      if opt = find_by_name(key)
+        results.unset_value opt.name
+      end
+    end
+
+    def read_rclines lines, results = Ragol::Results.new(options, nil)
+      options_processed = Array.new
+      
+      lines.each do |line|
+        line.sub!(%r{\#.*}, '')
+        next if line.empty?
+        name, val = line.split(%r{\s*:\s*})
+        opt = @options.detect { |op| op.match_rc? name }
+        if opt
+          opt.set_option_value val, name, results
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/ragol/regexp_option.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+
+module Ragol
+  class RegexpOption < Option
+    def initialize args
+      @regexp = args[:valueregexp]
+      super
+    end
+    
+    def value_regexp
+      @regexp
+    end
+  end
+end

data/lib/ragol/results.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'logue/loggable'
+require 'ragol/option'
+require 'ragol/argslist'
+
+module Ragol
+  class Results
+    include Logue::Loggable
+
+    attr_reader :options
+    
+    def initialize options, args = Array.new
+      @argslist = Ragol::ArgsList.new(args)
+      @values = Hash.new
+
+      options.each do |option|
+        @values[option.name] = option.default
+        
+        define_singleton_method option.name do
+          instance_eval do
+            @values[option.name]
+          end
+        end
+      end
+    end
+
+    def value optname
+      @values[optname]
+    end
+
+    def set_value optname, value
+      @values[optname] = value
+    end
+
+    def unset_value optname
+      @values.delete optname
+    end
+
+    def unprocessed
+      @argslist
+    end
+
+    def end_of_options?
+      @argslist.end_of_options?
+    end
+
+    def args
+      @argslist.args
+    end
+
+    def next_arg
+      @argslist.next_arg
+    end
+
+    def shift_arg
+      @argslist.shift_arg
+    end
+
+    def args_empty?
+      @argslist.args_empty?
+    end
+
+    def current_arg
+      @argslist.current_arg
+    end
+  end
+end

data/lib/ragol/string_option.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+
+module Ragol
+  class StringOption < Option
+    REGEXP = Regexp.new '^ [\"\']? (.*?) [\"\']? $ ', Regexp::EXTENDED
+    
+    def value_regexp
+      REGEXP
+    end
+  end
+end

data/lib/ragol/synoption/args.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Synoption
+  class OptionArguments < Hash
+    def initialize name, tag, description, default, origargs
+      super()
+
+      merge! origargs.dup
+      
+      takesvalue = if origargs.has_key?(:takesvalue)
+                     origargs[:takesvalue]
+                   else
+                     true
+                   end
+
+      self[:takesvalue] = takesvalue
+      self[:regexps] ||= origargs[:regexp]
+      self[:negates] ||= origargs[:negate]
+      self[:tags] = [ tag, '--' + name.to_s.gsub('_', '-') ]
+      self[:description] = description
+      self[:name] = name
+      self[:default] = default
+    end
+  end
+end

data/lib/ragol/synoption/boolean_option.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/boolean_option'
+require 'ragol/synoption/option'
+
+module Synoption
+  # a boolean option maps to a single tag, not a tag and value. For example,
+  # "-v" (verbose) is a boolean option, but "-r 3444" (revision) is a option
+  # with a value.
+  class BooleanOption < Ragol::Option
+    include OptionInit
+    
+    def default_value
+      false
+    end
+
+    def takes_value?
+      false
+    end
+  end
+end

data/lib/ragol/synoption/fixnum_option.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/fixnum_option'
+require 'ragol/synoption/option'
+
+module Synoption
+  # An option that has a fixnum (integer) as its value.
+  class FixnumOption < Ragol::FixnumOption
+    include Synoption::OptionInit
+  end
+end

data/lib/ragol/synoption/float_option.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/float_option'
+require 'ragol/synoption/option'
+
+module Synoption
+  # An option that has a float as its value.
+  class FloatOption < Ragol::FloatOption
+    include OptionInit
+  end
+end

data/lib/ragol/synoption/option.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/option'
+require 'ragol/synoption/args'
+
+module Synoption
+  module OptionInit
+    def initialize(*args, &blk)
+      name, tag, description, deflt, options = *args
+      options ||= Hash.new
+      deflt ||= default_value
+      args = OptionArguments.new name, tag, description, deflt, options
+      super args, &blk
+    end
+
+    def default_value
+      nil
+    end
+  end
+end
+
+module Synoption
+  class Option < Ragol::Option
+    include OptionInit
+  end
+end

data/lib/ragol/synoption/optset.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'ragol/optset'
+
+module Synoption
+  class OptionSet < Ragol::OptionSet
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: ragol
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Pace
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logue
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: Another implementation of an option processor.
+email: jeugenepace@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ragol/args.rb
+- lib/ragol/argslist.rb
+- lib/ragol/boolean_option.rb
+- lib/ragol/doc.rb
+- lib/ragol/exception.rb
+- lib/ragol/fixnum_option.rb
+- lib/ragol/float_option.rb
+- lib/ragol/hash.rb
+- lib/ragol/matcher.rb
+- lib/ragol/matchers.rb
+- lib/ragol/option.rb
+- lib/ragol/optproc/optproc.rb
+- lib/ragol/optproc/optset.rb
+- lib/ragol/optset.rb
+- lib/ragol/regexp_option.rb
+- lib/ragol/results.rb
+- lib/ragol/string_option.rb
+- lib/ragol/synoption/args.rb
+- lib/ragol/synoption/boolean_option.rb
+- lib/ragol/synoption/fixnum_option.rb
+- lib/ragol/synoption/float_option.rb
+- lib/ragol/synoption/option.rb
+- lib/ragol/synoption/optset.rb
+homepage: http://github.com/jpace/ragol
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ! 'Ragol: Another GetOpt Library.'
+test_files: []