pezra-options 2.2.0

data/CHANGELOG

@@ -0,0 +1,7 @@
+v2.1.0
+======
+
+ * 1.9 compatibility
+ * Validation of passed options
+ 
+

data/README

@@ -0,0 +1,218 @@
+NAME
+  options.rb
+
+DESCRIPTION
+  options.rb simplifies the common idiom of dealing with keyword options in
+  ruby functions.  it also deals correctly with symbol vs string keywords and
+  prevents many subtle programming errors that can arise from doing so
+  incorrectly.  options.rb doesn't hack ruby's core with one exception: the
+  method Array#options.
+
+SYNOPSIS
+  require 'options'
+
+  def method(*args, &block)
+    args, options = Options.parse(args)
+
+    a = args.shift
+    b = args.shift
+
+    force = options.getopt(:force, default = false)
+    verbose = options.getopt([:verbose, :VERBOSE])
+    foo, bar = options.getopt(:foo, :bar)
+  end
+
+INSTALL
+  gem install options
+
+HISTORY
+  2.2.0:
+    - Calculated default values
+    - #getopt second arg can be an options hash
+  2.1.1:
+    - Improved samples
+    - Improved 1.9 compatibility
+  2.1.0:
+    - 1.9 compatibility
+    - Validation of passed options
+
+SAMPLES
+
+  
+  <========< samples/a.rb >========>
+
+  ~ > cat samples/a.rb
+
+    require 'options'
+    
+    # options.rb makes it super easy to deal with keyword options in a safe and
+    # easy way.
+    #
+    
+      def method(*args)
+        args, options = Options.parse(args)
+    
+        force = options.getopt(:force, :default => false)
+        p force
+      end
+    
+      method(:foo, :bar, :force => true)
+      method('force' => true)
+
+  ~ > ruby samples/a.rb
+
+    true
+    true
+
+
+  <========< samples/b.rb >========>
+
+  ~ > cat samples/b.rb
+
+    require 'options'
+    
+    # options.rb avoids common mistakes made handling keyword arguments
+    #
+    
+      def broken(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        if options[:force]
+          puts 'forcing'
+        else
+          puts 'broken'
+        end
+      end
+    
+      def nonbroken(*args)
+        args, options = Options.parse(args)
+        if options.getopt(:force)
+          puts 'nonbroken'
+        end
+      end
+    
+      broken('force' => true)
+      nonbroken('force' => true)
+    
+    
+    
+      def fubar(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        verbose = options[:verbose] || true
+        if verbose 
+          if options[:verbose]
+            puts 'verbosely'
+          else
+            puts 'fubar'
+          end
+        end
+      end
+    
+      def nonfubar(*args)
+        args, options = Options.parse(args)
+        verbose = options.getopt(:verbose)
+        if verbose 
+          puts 'verbosely'
+        else
+          puts 'nonfubar'
+        end
+      end
+    
+      fubar(:verbose => false)
+      nonfubar(:verbose => false)
+
+  ~ > ruby samples/b.rb
+
+    broken
+    nonbroken
+    fubar
+    nonfubar
+
+
+  <========< samples/c.rb >========>
+
+  ~ > cat samples/c.rb
+
+    require 'options'
+    
+    # options.rb hacks ruby core in exactly one way - the method Array#options
+    #
+    
+      def method(*args)
+        options = args.options
+        p :args => args
+        p :options => options
+      end
+    
+      method(:a, :b, :k => :v)
+    
+      def method2(*args)
+        options = args.options.pop
+        p :args => args
+        p :options => options
+      end
+    
+      method2(:a, :b, :k => :v)
+
+  ~ > ruby samples/c.rb
+
+    {:args=>[:a, :b, {:k=>:v}]}
+    {:options=>{:k=>:v}}
+    {:args=>[:a, :b]}
+    {:options=>{:k=>:v}}
+
+
+  <========< samples/d.rb >========>
+
+  ~ > cat samples/d.rb
+
+    require 'options'
+    
+    # options.rb makes it easy to provide good error messages when people
+    # misuse a method.
+    #
+    
+      def method(*args)
+        args, options = Options.parse(args)
+        options.validate(:force)
+    
+        force = options.getopt(:force, default=false)
+        p force
+      end
+    
+      method(:foo, :bar, :misspelled_option => true)
+
+  ~ > ruby samples/d.rb
+
+    /Users/pezra/Development/options/lib/options.rb:188:in `validate': Unrecognized options: misspelled_option (ArgumentError)
+    	from samples/d.rb:9:in `method'
+    	from samples/d.rb:15:in `<main>'
+
+
+  <========< samples/e.rb >========>
+
+  ~ > cat samples/e.rb
+
+    require 'options'
+    require 'date'
+    
+    # You can also provide a lambda (or anything that responds to `#call`)
+    # as the default value.  If default responds to `#call` the return
+    # value of `#call` be used as the default value.  Default value
+    # calculation procs will not be called when the option is
+    # present. This allows for runtime calculation of default values, or
+    # for defaults that are expensive to create.
+    
+      def method(*args)
+        args, options = Options.parse(args)
+    
+        force = options.getopt(:force, :default => lambda{Date.today.day.even?})
+        p force
+      end
+    
+      method(:foo)  # force will be true on even days and false on odd days
+
+  ~ > ruby samples/e.rb
+
+    true
+
+

data/README.erb

@@ -0,0 +1,41 @@
+NAME
+  options.rb
+
+DESCRIPTION
+  options.rb simplifies the common idiom of dealing with keyword options in
+  ruby functions.  it also deals correctly with symbol vs string keywords and
+  prevents many subtle programming errors that can arise from doing so
+  incorrectly.  options.rb doesn't hack ruby's core with one exception: the
+  method Array#options.
+
+SYNOPSIS
+  require 'options'
+
+  def method(*args, &block)
+    args, options = Options.parse(args)
+
+    a = args.shift
+    b = args.shift
+
+    force = options.getopt(:force, default = false)
+    verbose = options.getopt([:verbose, :VERBOSE])
+    foo, bar = options.getopt(:foo, :bar)
+  end
+
+INSTALL
+  gem install options
+
+HISTORY
+  2.2.0:
+    - Runtime calculation of default values
+    - #getopt second arg may be an options hash
+  2.1.1:
+    - Improved samples
+    - Improved 1.9 compatibility
+  2.1.0:
+    - 1.9 compatibility
+    - Validation of passed options
+
+SAMPLES
+
+  <%= samples %>

data/Rakefile

@@ -0,0 +1,216 @@
+This.rubyforge_project = 'codeforpeople'
+This.author = "Ara T. Howard"
+This.email = "ara.t.howard@gmail.com"
+This.homepage = "http://github.com/ahoward/#{ This.lib }/tree/master"
+
+
+task :default do
+  puts(Rake::Task.tasks.map{|task| task.name} - ['default'])
+end
+
+task :spec do
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/*_spec.rb']
+  end
+end
+
+require 'pp'
+task :gemspec do
+  shiteless = lambda do |list|
+    ignore_patterns = '*.git', '*.tmp', '*.sw?', '*.gem', 'pkg/**/*', 'test/log'
+    Rake::FileList.new(*list).exclude(*ignore_patterns) {|f| File.directory?(f)}
+  end
+
+  lib         = This.lib
+  version     = This.version
+  test_files  = shiteless[FileList.new('test/**/*', 'spec/**/*')]
+  files       = shiteless[Dir::glob("**/**")] - test_files
+  executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
+  has_rdoc    = true #File.exist?('doc')
+
+  extensions = This.extensions
+  if extensions.nil?
+    %w( Makefile configure extconf.rb ).each do |ext|
+      extensions << ext if File.exists?(ext)
+    end
+  end
+  extensions = [extensions].flatten.compact
+
+  template = 
+    if test(?e, 'gemspec.erb')
+      Template{ IO.read('gemspec.erb') }
+    else
+      Template {
+        <<-__
+          ## #{ lib }.gemspec
+          #
+
+          Gem::Specification::new do |spec|
+            spec.name = #{ lib.inspect }
+            spec.version = #{ version.inspect }
+            spec.platform = Gem::Platform::RUBY
+            spec.summary = #{ lib.inspect }
+
+            spec.files = #{ files.inspect }
+            spec.executables = #{ executables.inspect }
+            
+            spec.require_path = "lib"
+
+            spec.has_rdoc = #{ has_rdoc.inspect }
+            spec.test_files = #{ test_files.inspect }
+            #spec.add_dependency 'lib', '>= version'
+            #spec.add_dependency 'fattr'
+
+            spec.extensions.push(*#{ extensions.inspect })
+
+            spec.rubyforge_project = #{ This.rubyforge_project.inspect }
+            spec.author = #{ This.author.inspect }
+            spec.email = #{ This.email.inspect }
+            spec.homepage = #{ This.homepage.inspect }
+          end
+        __
+      }
+    end
+
+  open("#{ lib }.gemspec", "w"){|fd| fd.puts template}
+  This.gemspec = "#{ lib }.gemspec"
+end
+
+task :gem => [:clean, :gemspec] do
+  Fu.mkdir_p This.pkgdir
+  before = Dir['*.gem']
+  cmd = "gem build #{ This.gemspec }"
+  `#{ cmd }`
+  after = Dir['*.gem']
+  gem = ((after - before).first || after.first) or abort('no gem!')
+  Fu.mv gem, This.pkgdir
+  This.gem = File.basename(gem)
+end
+
+task :readme do
+  samples = ''
+  prompt = '~ > '
+  lib = This.lib
+  version = This.version
+
+  Dir['sample*/*.rb'].sort.each do |sample|
+    samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+    cmd = "cat #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+    samples << Util.indent(`#{ cmd }`, 4) << "\n"
+
+    cmd = "ruby #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+
+    cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -Ilib #{ sample })'"
+    samples << Util.indent(`#{ cmd } 2>&1`, 4) << "\n"
+  end
+
+  template = 
+    if test(?e, 'readme.erb')
+      Template{ IO.read('readme.erb') }
+    else
+      Template {
+        <<-__
+          NAME
+            #{ lib }
+
+          DESCRIPTION
+
+          INSTALL
+            gem install #{ lib }
+
+          SAMPLES
+            #{ samples }
+        __
+      }
+    end
+
+  open("README", "w"){|fd| fd.puts template}
+end
+
+
+task :clean do
+  Dir[File.join(This.pkgdir, '**/**')].each{|entry| Fu.rm_rf(entry)}
+end
+
+
+task :release => [:clean, :gemspec, :gem] do
+  gems = Dir[File.join(This.pkgdir, '*.gem')].flatten
+  raise "which one? : #{ gems.inspect }" if gems.size > 1
+  raise "no gems?" if gems.size < 1
+  cmd = "rubyforge login && rubyforge add_release #{ This.rubyforge_project } #{ This.lib } #{ This.version } #{ This.pkgdir }/#{ This.gem }"
+  puts cmd
+  system cmd
+end
+
+
+
+
+
+BEGIN {
+  $VERBOSE = nil
+
+  require 'ostruct'
+  require 'erb'
+  require 'fileutils'
+
+  Fu = FileUtils
+
+  This = OpenStruct.new
+
+  This.file = File.expand_path(__FILE__)
+  This.dir = File.dirname(This.file)
+  This.pkgdir = File.join(This.dir, 'pkg')
+
+  lib = ENV['LIB']
+  unless lib
+    lib = File.basename(Dir.pwd)
+  end
+  This.lib = lib
+
+  version = ENV['VERSION']
+  unless version
+    name = lib.capitalize
+    require "./lib/#{ lib }"
+    version = eval(name).send(:version)
+  end
+  This.version = version
+
+  abort('no lib') unless This.lib
+  abort('no version') unless This.version
+
+  module Util
+    def indent(s, n = 2)
+      s = unindent(s)
+      ws = ' ' * n
+      s.gsub(%r/^/, ws)
+    end
+
+    def unindent(s)
+      indent = nil
+      s.lines do |line|
+      next if line =~ %r/^\s*$/
+      indent = line[%r/^\s*/] and break
+    end
+    indent ? s.gsub(%r/^#{ indent }/, "") : s
+  end
+    extend self
+  end
+
+  class Template
+    def initialize(&block)
+      @block = block
+      @template = block.call.to_s
+    end
+    def expand(b=nil)
+      ERB.new(Util.unindent(@template)).result(b||@block.binding)
+    end
+    alias_method 'to_s', 'expand'
+  end
+  def Template(*args, &block) Template.new(*args, &block) end
+
+  Dir.chdir(This.dir)
+}

data/lib/options.rb

@@ -0,0 +1,224 @@
+module Options
+  VERSION = '2.2.0'
+
+  class << Options
+    def version
+      Options::VERSION
+    end
+
+    def normalize!(hash)
+      hash.keys.each{|key| hash[key.to_s.to_sym] = hash.delete(key) unless Symbol===key}
+      hash
+    end
+    alias_method 'to_options!', 'normalize!'
+
+    def normalize(hash)
+      normalize!(hash.dup)
+    end
+    alias_method 'to_options', 'normalize'
+
+    def stringify!(hash)
+      hash.keys.each{|key| hash[key.to_s] = hash.delete(key) unless String===key}
+      hash
+    end
+    alias_method 'stringified!', 'stringify!'
+
+    def stringify(hash)
+      stringify!(hash)
+    end
+    alias_method 'stringified', 'stringify'
+
+    def for(hash)
+      hash =
+        case hash
+          when Hash
+            hash
+          when Array
+            Hash[*hash.flatten]
+          when String, Symbol
+            {hash => true}
+          else
+            hash.to_hash
+        end
+      normalize!(hash)
+    ensure
+      hash.extend(Options) unless hash.is_a?(Options)
+    end
+
+    def parse(args)
+      case args
+      when Array
+        args.extend(Arguments) unless args.is_a?(Arguments)
+        [args, args.options.pop]
+      when Hash
+        Options.for(args)
+      else
+        raise ArgumentError, "`args` should be and Array or Hash"
+      end
+    end
+  end
+
+  def to_options!
+    replace to_options
+  end
+
+  def to_options
+    keys.inject(Hash.new){|h,k| h.update k.to_s.to_sym => fetch(k)}
+  end
+        
+  def getopt key, default = nil
+    [ key ].flatten.each do |key|
+      return fetch(key) if has_key?(key)
+      key = key.to_s
+      return fetch(key) if has_key?(key)
+      key = key.to_sym
+      return fetch(key) if has_key?(key)
+    end
+    # did not find the option; fall back on default
+    
+    default = Options.for(default).getopt(:default) if Hash === default
+
+    if default.respond_to?(:call)
+      default.call
+    else
+      default
+    end
+  end
+
+  def getopts *args
+    args.flatten.map{|arg| getopt arg}
+  end
+
+  def hasopt key, default = nil
+    [ key ].flatten.each do |key|
+      return true if has_key?(key)
+      key = key.to_s
+      return true if has_key?(key)
+      key = key.to_sym
+      return true if has_key?(key)
+    end
+    default
+  end
+  alias_method 'hasopt?', 'hasopt'
+
+  def hasopts *args
+    args.flatten.map{|arg| hasopt arg}
+  end
+  alias_method 'hasopts?', 'hasopts'
+
+  def delopt key, default = nil
+    [ key ].flatten.each do |key|
+      return delete(key) if has_key?(key)
+      key = key.to_s
+      return delete(key) if has_key?(key)
+      key = key.to_sym
+      return delete(key) if has_key?(key)
+    end
+    default
+  end
+
+  def delopts *args
+    args.flatten.map{|arg| delopt arg}
+  end
+
+  def setopt key, value = nil
+    [ key ].flatten.each do |key|
+      return self[key]=value if has_key?(key)
+      key = key.to_s
+      return self[key]=value if has_key?(key)
+      key = key.to_sym
+      return self[key]=value if has_key?(key)
+    end
+    return self[key]=value
+  end
+  alias_method 'setopt!', 'setopt'
+
+  def setopts opts 
+    opts.each{|key, value| setopt key, value}
+    opts
+  end
+  alias_method 'setopts!', 'setopts'
+
+  def select! *a, &b
+    replace select(*a, &b).to_hash
+  end
+
+  def normalize!
+    Options.normalize!(self)
+  end
+  alias_method 'normalized!', 'normalize!'
+  alias_method 'to_options!', 'normalize!'
+
+  def normalize
+    Options.normalize(self)
+  end
+  alias_method 'normalized', 'normalize'
+  alias_method 'to_options', 'normalize'
+
+  def stringify!
+    Options.stringify!(self)
+  end
+  alias_method 'stringified!', 'stringify!'
+
+  def stringify
+    Options.stringify(self)
+  end
+  alias_method 'stringified', 'stringify'
+
+  attr_accessor :arguments
+  def pop
+    pop! unless popped?
+    self
+  end
+
+  def popped?
+    defined?(@popped) and @popped
+  end
+
+  def pop!
+    @popped = arguments.pop
+  end
+
+  # Validates that the options provided are acceptable.
+  #
+  # @param [Symbol] *acceptable_options List of options that are
+  #   allowed
+  def validate(*acceptable_options)
+    remaining = (provided_options - acceptable_options).map{|opt| opt.to_s}.sort
+    raise ArgumentError, "Unrecognized options: #{remaining.join(', ')}" unless remaining.empty?
+    
+    self
+  end
+
+  protected
+
+  def provided_options
+    normalize!.keys
+  end
+end
+
+module Arguments
+  def options
+    @options ||= Options.for(last.is_a?(Hash) ? last : {})
+  ensure
+    @options.arguments = self
+  end
+
+  class << Arguments
+    def for(args)
+      args.extend(Arguments) unless args.is_a?(Arguments)
+      args
+    end
+
+    def parse(args)
+      [args, Options.parse(args)]
+    end
+  end
+end
+
+class Array
+  def options
+    extend(Arguments) unless is_a?(Arguments)
+    options
+  end
+end

data/options.gemspec

@@ -0,0 +1,26 @@
+## options.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "options"
+  spec.version = "2.2.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "options"
+
+  spec.files = ["CHANGELOG", "lib/options.rb", "options.gemspec", "Rakefile", "README", "README.erb", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb"]
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.has_rdoc = true
+  spec.test_files = ["spec/options_spec.rb", "spec/spec_helper.rb"]
+  #spec.add_dependency 'lib', '>= version'
+  #spec.add_dependency 'fattr'
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://github.com/ahoward/options/tree/master"
+end

data/samples/a.rb

@@ -0,0 +1,15 @@
+require 'options'
+
+# options.rb makes it super easy to deal with keyword options in a safe and
+# easy way.
+#
+
+  def method(*args)
+    args, options = Options.parse(args)
+
+    force = options.getopt(:force, :default => false)
+    p force
+  end
+
+  method(:foo, :bar, :force => true)
+  method('force' => true)

data/samples/b.rb

@@ -0,0 +1,50 @@
+require 'options'
+
+# options.rb avoids common mistakes made handling keyword arguments
+#
+
+  def broken(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    if options[:force]
+      puts 'forcing'
+    else
+      puts 'broken'
+    end
+  end
+
+  def nonbroken(*args)
+    args, options = Options.parse(args)
+    if options.getopt(:force)
+      puts 'nonbroken'
+    end
+  end
+
+  broken('force' => true)
+  nonbroken('force' => true)
+
+
+
+  def fubar(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    verbose = options[:verbose] || true
+    if verbose 
+      if options[:verbose]
+        puts 'verbosely'
+      else
+        puts 'fubar'
+      end
+    end
+  end
+
+  def nonfubar(*args)
+    args, options = Options.parse(args)
+    verbose = options.getopt(:verbose)
+    if verbose 
+      puts 'verbosely'
+    else
+      puts 'nonfubar'
+    end
+  end
+
+  fubar(:verbose => false)
+  nonfubar(:verbose => false)

data/samples/c.rb

@@ -0,0 +1,20 @@
+require 'options'
+
+# options.rb hacks ruby core in exactly one way - the method Array#options
+#
+
+  def method(*args)
+    options = args.options
+    p :args => args
+    p :options => options
+  end
+
+  method(:a, :b, :k => :v)
+
+  def method2(*args)
+    options = args.options.pop
+    p :args => args
+    p :options => options
+  end
+
+  method2(:a, :b, :k => :v)

data/samples/d.rb

@@ -0,0 +1,15 @@
+require 'options'
+
+# options.rb makes it easy to provide good error messages when people
+# misuse a method.
+#
+
+  def method(*args)
+    args, options = Options.parse(args)
+    options.validate(:force)
+
+    force = options.getopt(:force, default=false)
+    p force
+  end
+
+  method(:foo, :bar, :misspelled_option => true)

data/samples/e.rb

@@ -0,0 +1,18 @@
+require 'options'
+require 'date'
+
+# You can also provide a lambda (or anything that responds to `#call`)
+# as the default value.  If default responds to `#call` the return
+# value of `#call` be used as the default value.  Default value
+# calculation procs will not be called when the option is
+# present. This allows for runtime calculation of default values, or
+# for defaults that are expensive to create.
+
+  def method(*args)
+    args, options = Options.parse(args)
+
+    force = options.getopt(:force, :default => lambda{Date.today.day.even?})
+    p force
+  end
+
+  method(:foo)  # force will be true on even days and false on odd days

data/spec/options_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'options'
+
+describe Options do 
+  describe "parsing" do 
+    it "should be able to handle an options hash" do 
+      opts = Options.parse({:this => 'that'})
+      opts.getopt(:this).should eql('that')
+    end
+
+    it "should be able to handle args list w/ options hash" do 
+      args, opts = Options.parse([:foo, {:this => 'that'}])
+      opts.getopt(:this).should eql('that')
+      args.should eql([:foo])
+    end
+  end
+
+  describe "validation" do 
+    it "should be able to detect extraneous options" do 
+      lambda{
+        Options.parse({:this => 'test'}).validate(:foo, :bar)
+      }.should raise_error(ArgumentError, "Unrecognized options: this")
+    end
+
+    it "should list all extraneous options in message" do 
+      lambda{
+        Options.parse({:this => 'test', :that => 'test'}).validate(:foo)
+      }.should raise_error(ArgumentError, "Unrecognized options: that, this")
+    end
+
+    it "should accept options from simple list" do 
+      lambda{
+        Options.parse({:foo => 'this', :bar => 'that'}).validate(:foo, :bar)
+      }.should_not raise_error
+    end
+  end
+
+  describe "#getopt" do 
+    it "should handle simple lookup" do 
+      Options.for({}).getopt(:this).should be_nil
+    end
+
+    it "should handle lookup w/ default" do 
+      Options.for({}).getopt(:this, "some default").should eql('some default')
+    end
+
+    it "should handle lookup w/ default in options hash" do 
+      Options.for({}).getopt(:this, :default => "some default").should eql('some default')
+    end
+
+    it "should handle lookup w/ lambda default" do 
+      ext = 2
+      Options.for({}).getopt(:this, lambda{ext + 1}).should eql(3)
+    end
+
+    it "should handle lookup w/ lambda default in options hash" do 
+      ext = 2
+      Options.for({}).getopt(:this, :default => lambda{ext + 1}).should eql(3)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require 'pathname'
+require 'pp'
+
+$LOAD_PATH.unshift Pathname(__FILE__).dirname + "../lib"
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: pezra-options
+version: !ruby/object:Gem::Version 
+  version: 2.2.0
+platform: ruby
+authors: 
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ara.t.howard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- lib/options.rb
+- options.gemspec
+- Rakefile
+- README
+- README.erb
+- samples/a.rb
+- samples/b.rb
+- samples/c.rb
+- samples/d.rb
+- samples/e.rb
+has_rdoc: true
+homepage: http://github.com/ahoward/options/tree/master
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: codeforpeople
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: options
+test_files: 
+- spec/options_spec.rb
+- spec/spec_helper.rb