cp 0.0.1.pre1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cp.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/cp.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cp"
+  s.version     = CP::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Rick Fletcher"]
+  s.email       = ["fletch@pobox.com"]
+  s.homepage    = ""
+  s.summary     = %q{An alternative API for CmdParse}
+  s.description = %q{CP provides a less verbose API for the CmdParse gem.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency(%q<cmdparse>, [">= 2.0.2"])
+  s.add_runtime_dependency(%q<cmdparse>, [">= 2.0.2"])
+end

data/examples/net.rb

@@ -0,0 +1,81 @@
+##
+# A port of the CmdParse tutorial app, net.rb
+# original: http://cmdparse.rubyforge.org/tutorial.html
+#
+
+$: << File.join( ".", File.dirname( __FILE__ ), "..", "lib" )
+
+require "cp"
+
+include CP
+
+$ipaddrs = []
+$verbose = false
+
+app :name, "net"
+app :version, "0.1.1"
+
+# global options
+option( "--verbose", "Be verbose when outputting info" ) { |t| $verbose = true }
+
+# add the top-level "ipaddr" command
+command :ipaddr do |c|
+  # c.allow_partial! # partial commands aren't implemented
+  c.summary = "Manage IP addresses"
+
+  # add the "add" subcommand
+  c.command( :add ) do |s|
+    s.summary = "Add an IP address"
+
+    s.execute do |*args|
+      puts "Adding IP addresses: #{args.join(', ')}" if $verbose
+      $ipaddrs += args
+    end
+  end
+
+  # add the "del" subcommand
+  c.command :del do |s|
+    s.summary = "Delete IP addresses"
+
+    s.option( "-a", "--all", "Delete all IP addresses" ){ $deleteAll = true }
+
+    s.execute do |*args|
+      if $deleteAll
+        $ipaddrs = []
+      else
+        puts "Deleting IP addresses: #{args.join(', ')}" if $verbose
+        args.each { |ip| $ipaddrs.delete( ip ) }
+      end
+    end
+  end
+
+  # add the "list" subcommand
+  c.command :list do |s|
+#    s.default! # make :list the default subcommand
+    s.summary = "List all IP addresses"
+
+    s.execute do |*args|
+      puts "Listing IP addresses:" if $verbose
+      puts $ipaddrs.to_yaml
+    end
+  end
+
+  # add the "stat" subcommand
+  c.command :stat do |s|
+    s.summary = "Show network statistics"
+    s.description = "This command shows very useful network statistics - eye catching!!!"
+
+    s.execute do |*args|
+      puts "Showing network statistics" if $verbose
+      puts
+      puts "Yeah, I will do something now..."
+      puts
+      1.upto(10) do |row|
+        puts " "*(20-row) + "#"*(row*2 - 1)
+      end
+      puts
+    end
+  end
+end
+
+run

data/lib/cp.rb

@@ -0,0 +1,22 @@
+require "rubygems"
+require "cmdparse"
+
+require "cp/runners/cmd_parse"
+require "cp/commands"
+require "cp/options"
+require "cp/command"
+require "cp/version"
+require "cp/option"
+require "cp/app"
+
+module CP
+  def self.included( scope )
+    scope.extend( self )
+  end
+
+  [:app, :command, :option, :run].each do |method|
+    define_method( method ) { |*args, &block|
+      App.instance.send( method, *args, &block )
+    }
+  end
+end

data/lib/cp/app.rb

@@ -0,0 +1,28 @@
+require "singleton"
+
+module CP
+  class App
+    include ::Singleton
+
+    include CP::Commands
+    include CP::Options
+
+    attr_accessor :name, :version, :runner
+
+    def initialize
+      self.runner = CP::Runners::CmdParse
+    end
+
+    def app( attr, value )
+      begin
+        self.send( "#{attr}=", value )
+      rescue NoMethodError
+        raise ArgumentError.new( "no such property: #{attr}" )
+      end
+    end
+
+    def run
+      self.runner.new( self ).run
+    end
+  end
+end

data/lib/cp/command.rb

@@ -0,0 +1,23 @@
+module CP
+  class Command
+    include CP::Commands
+    include CP::Options
+
+    attr_reader :block, :name
+    attr_accessor :description, :summary
+
+    def initialize( name )
+      unless name.respond_to?( :to_sym )
+        raise ArgumentError.new( "parameter must be a Symbol (or respond to .to_sym)")
+      end
+
+      @name = name.to_sym
+
+      yield self if block_given?
+    end
+
+    def execute( &block )
+      @block = block
+    end
+  end
+end

data/lib/cp/commands.rb

@@ -0,0 +1,15 @@
+module CP
+  module Commands
+    def commands
+      @commands ||= []
+      @commands
+    end
+
+    def command( *args )
+      cmd = CP::Command.new( *args )
+      yield cmd if block_given?
+      commands << cmd
+      cmd
+    end
+  end
+end

data/lib/cp/option.rb

@@ -0,0 +1,86 @@
+require "optparse"
+
+module CP
+  class Option
+    attr_accessor :allowed, :type, :block, :description, :required
+    attr_reader :arg, :short, :long
+
+    # see: OptionsParser#make_switch
+    def initialize( *args )
+      parsed = parse_args( args )
+
+      yield self if block_given?
+
+      # pick up any args we dropped the first time
+      parse_args( self.to_option_parser_args + args ) unless parsed
+
+      unless self.short || self.long
+        raise ArgumentError.new( "no switch given" )
+      end
+    end
+
+    def long=( val )
+      set_switch( :long, val )
+    end
+
+    def name
+      if self.long
+        name = self.long.sub( /^-+(\[no-\])?/, '' )
+      else
+        name = self.short.sub( /^-/, '' ).sub( /\[(.-.)\]/, '\\1' )
+      end
+      name.gsub( "-", "_" ).to_sym
+    end
+
+    def short=( val )
+      set_switch( :short, val )
+    end
+
+    def switches
+      [self.short, self.long].inject( [] ) { |acc, s|
+        unless s.nil?
+          s += self.arg unless self.arg.nil?
+          acc << s
+        end
+        acc
+      }
+    end
+
+    def to_option_parser_args
+      args = self.switches + [self.type, self.allowed, self.description, self.block]
+      args.find_all { |a| !a.nil? }
+    end
+
+  private
+
+    def parse_args( args )
+      switch = OptionParser.new.make_switch( args ).first
+      if !switch.kind_of?( OptionParser::Switch )
+        false
+      else
+        self.allowed = args.find { |a| a.is_a?( Hash ) || a.is_a?( Array ) }
+        self.type = args.find { |a| a.is_a?( Class ) }
+        self.description = switch.desc.first rescue nil
+        self.block = switch.block
+        self.long = switch
+        self.short = switch
+      end
+    end
+
+    def set_switch( which, switch )
+      other = self.send( [:short, :long].find_all { |s| s != which }.first )
+      other = other ? other + ( self.arg || "" ) : nil
+
+      unless switch.kind_of?( OptionParser::Switch )
+        switch = OptionParser.new.make_switch( [ switch, other ] ).first
+      end
+
+      unless switch.kind_of?( OptionParser::Switch ) || switch.send( which ).empty?
+        raise ArgumentError.new( "invalid #{which} switch: #{switch.first}" )
+      end
+
+      @arg = switch.arg
+      instance_variable_set( :"@#{which}", switch.send( which ).first )
+    end
+  end
+end

data/lib/cp/options.rb

@@ -0,0 +1,15 @@
+module CP
+  module Options
+    def options
+      @options ||= []
+      @options
+    end
+
+    def option( *args )
+      opt = CP::Option.new( *args )
+      yield opt if block_given?
+      options << opt
+      opt
+    end
+  end
+end

data/lib/cp/runners/cmd_parse.rb

@@ -0,0 +1,56 @@
+require "rubygems"
+require "cmdparse"
+
+module CP
+  module Runners
+    class CmdParse
+      attr_reader :runner
+
+      def initialize( app )
+        @app = app
+      end
+
+      def run
+        @runner = ::CmdParse::CommandParser.new
+        @runner.program_name = @app.name
+        @runner.program_version = @app.version.split( "." )
+
+        add_options( @runner, @app.options )
+        add_commands( @runner, @app.commands )
+
+        @runner.parse
+      end
+
+    private
+
+      def add_options( target, options )
+        unless options.empty?
+          target.options = ::CmdParse::OptionParserWrapper.new do |o|
+            o.separator "Global Options:"
+            options.each { |opt| o.on( *opt.to_option_parser_args ) }
+          end
+        end
+      end
+
+      def add_commands( target, commands )
+        unless commands.empty?
+          commands.each do |c|
+            cmd = ::CmdParse::Command.new( c.name.to_s, !c.commands.empty? )
+            cmd.description = c.description
+            cmd.short_desc = c.summary
+
+            cmd.set_execution_block do |args|
+              c.block.call( args ) if c.block
+            end
+
+            add_options( cmd, c.options )
+            add_commands( cmd, c.commands )
+
+            target.add_command( cmd )
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cp/version.rb

@@ -0,0 +1,3 @@
+module CP
+  VERSION = "0.0.1.pre1"
+end

data/spec/app_spec.rb

@@ -0,0 +1,50 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::App do
+  before( :each ) do
+    @target = CP::App.instance
+  end
+
+  it_should_behave_like "it accepts commands"
+  it_should_behave_like "it accepts options"
+
+  describe "#instance" do
+    it "should always return the same object" do
+      @target.should == CP::App.instance
+    end
+  end
+
+  describe "#parser" do
+    it "should default to CmdParser" do
+      @target.parser.should == CP::Parsers::CmdParse
+    end
+  end
+
+  describe "#run" do
+    it "should exist" do
+      @target.methods.include?( :run ).should be_true
+    end
+
+    it "should not take any parameters" do
+      @target.method( :run ).arity.should === 0
+    end
+  end
+
+  describe "properties" do
+    [:name, :version].each do |prop_name|
+      it "should accept a #{prop_name} property" do
+        prop_val = "0.1.1"
+
+        lambda {
+          @target.app prop_name, prop_val
+        }.should change( @target, prop_name ).from( nil ).to( prop_val )
+      end
+    end
+
+    it "should raise a ArgumentError when setting other properties" do
+      lambda {
+        test_app.app :foo, "bar"
+      }.should raise_error( ArgumentError, /no such property/ )
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,48 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::Command do
+  before( :each ) do
+    @target = test_command
+  end
+
+  it_should_behave_like "it accepts commands"
+  it_should_behave_like "it accepts options"
+
+  describe "attributes" do
+    [
+      [:description, "description"],
+      [:summary,     "summary"],
+      [:execute,     lambda {}],
+    ].each { |(attr, val)|
+      it "defines a ##{attr} accessor" do
+        lambda {
+          @target.send( :"#{attr}=", val )
+        }.should change( @target, attr ).from( @target.send( attr ) ).to( val )
+      end
+    }
+  end
+
+  describe "#new" do
+    it "takes one parameter" do
+      CP::Command.instance_method( :initialize ).arity.should === 1
+    end
+
+    it "takes a symbol" do
+      lambda {
+        CP::Command.new( 1 )
+      }.should raise_error( ArgumentError, /Symbol/ )
+    end
+
+    it "saves the param as the name" do
+      CP::Command.new( :test ).name.should === :test
+    end
+
+    it "yields itself" do
+      yielded = nil
+      c = CP::Command.new( :test ) do |cmd|
+        yielded = cmd
+      end
+      c.should === yielded
+    end
+  end
+end

data/spec/cp_spec.rb

@@ -0,0 +1,26 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP do
+  describe "methods" do
+    def assert_method_added( method )
+      Object.new.methods.include?( method ).should be_false
+      App.new.methods.include?( method ).should be_true
+    end
+
+    it "should define a app method" do
+      assert_method_added :app
+    end
+
+    it "should define a command method" do
+      assert_method_added :command
+    end
+
+    it "should define an option method" do
+      assert_method_added :option
+    end
+
+    it "should not define class methods" do
+      Object.class.methods.include?( :command ).should be_false
+    end
+  end
+end

data/spec/option_spec.rb

@@ -0,0 +1,171 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::Option do
+  before( :each ) do
+    @target = CP::Option.new( "-x" )
+  end
+
+
+  describe "attributes" do
+    [
+      [:allowed,     ["foo", "bar"]],
+      [:block,       lambda{}],
+      [:description, "description"],
+      [:long,        "--short"],
+      [:required,    true],
+      [:short,       "-s"],
+      [:type,        String]
+    ].each { |(attr, val)|
+      it "defines a ##{attr} accessor" do
+        lambda {
+          @target.send( :"#{attr}=", val )
+        }.should change( @target, attr ).from( @target.send( attr ) ).to( val )
+      end
+    }
+  end
+
+  describe "incompatible switch types" do
+    it "disallows them from accessors" do
+      lambda {
+        @target.long = "--switch FOO" # mandatory arg
+        @target.short = "-s[=FOO]"    # optional arg
+      }.should raise_error( ArgumentError, /incompatible/i )
+    end
+
+    it "disallows them in the contructor" do
+      lambda {
+        CP::Option.new( "--switch FOO", "-s[=FOO]" )
+      }.should raise_error( ArgumentError, /incompatible/i )
+    end
+  end
+
+  describe "#name" do
+    it "returns a symbol" do
+      @target.name.is_a?( Symbol )
+    end
+
+    it "uses the long switch" do
+      @target.long = "--long"
+      @target.name.should === :long
+    end
+
+    it "uses the short switch" do
+      @target.short = "-s"
+      @target.name.should === :s
+    end
+
+    it "prefers the long switch" do
+      @target.short = "-s"
+      @target.long = "--long"
+      @target.name.should === :long
+    end
+
+    it "ignores the optional part of a boolean switch" do
+      @target.long = "--[no-]foo"
+      @target.name.should === :foo
+    end
+
+    it "ignores the brackets in a range switch" do
+      @target.short = "-[a-z]"
+      @target.name.should === :"a_z"
+    end
+
+    it "converts dashes to underscores" do
+      @target.long = "--multi-word"
+      @target.name.should === :multi_word
+    end
+  end
+
+  describe "#new" do
+    it "accepts args like OptionParser.make_switch" do
+      lambda {
+        CP::Option.new( "-s" )
+        CP::Option.new( "-s", "--switch" )
+        CP::Option.new( "-s", "--switch[=OPTIONAL]" )
+        CP::Option.new( "-s", "--switch[=OPTIONAL]", "Do something switchy" )
+        CP::Option.new( "-s", "--switch[=OPTIONAL]", String, "Do something switchy" )
+      }.should_not raise_error
+    end
+
+    it "requires a switch" do
+      lambda {
+        CP::Option.new( "Description of the option" )
+      }.should raise_error( ArgumentError )
+    end
+
+    it "sets the description from arguments" do
+      CP::Option.new( "-s", "description" ).description.should === "description"
+    end
+    it "sets the short switch from arguments" do
+      CP::Option.new( "-s" ).short.should === "-s"
+    end
+    it "sets the long switch from arguments" do
+      CP::Option.new( "--switch" ).long.should === "--switch"
+    end
+    it "sets the type from arguments" do
+      CP::Option.new( "-s", String ).type.should == String
+    end
+    it "sets the block from arguments" do
+      ran = false
+      CP::Option.new( "-s", lambda{ ran = true } ).block.call
+      ran.should be_true
+    end
+
+    it "yields itself" do
+      yielded = nil
+      o = CP::Option.new( "-s" ) do |opt|
+        yielded = opt
+      end
+      o.should === yielded
+    end
+
+    describe "combined arguments and attribute setting" do
+      it "doesn't raise an error if switches are set later" do
+        lambda {
+          CP::Option.new( "Description of the option" ) do |opt|
+            opt.short = "-v"
+          end
+        }.should_not raise_error( ArgumentError )
+      end
+
+      it "saves early args" do
+        o = CP::Option.new( String, "Do something switchy" ) { |o| o.short = "-s" }
+        o.type.should == String
+        o.description.should === "Do something switchy"
+      end
+    end
+  end
+
+  describe "#long=" do
+    it "parses the option, separating the option argument" do
+      o = CP::Option.new do |opt|
+        opt.long = "--switch VALUE"
+      end
+      o.arg.should == " VALUE"
+      o.long.should == "--switch"
+    end
+  end
+
+  describe "#short=" do
+    it "parses the option, separating the option argument" do
+      o = CP::Option.new do |opt|
+        opt.short = "-s VALUE"
+      end
+      o.arg.should == " VALUE"
+      o.short.should == "-s"
+    end
+  end
+
+  describe "#to_option_parser_args" do
+    it "includes switch with args" do
+      @target.short = "-s FOO"
+      @target.long = "--switch FOO"
+      @target.to_option_parser_args.include?( "-s FOO" ).should be_true
+      @target.to_option_parser_args.include?( "--switch FOO" ).should be_true
+    end
+
+    it "returns an array" do
+      @target.to_option_parser_args.should be_a( Array )
+    end
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,10 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::Options do
+  before( :each ) do
+    class Target; include CP::Options; end
+    @target = Target.new
+  end
+
+  it_should_behave_like "it accepts options"
+end

data/spec/runners/cmd_parse_spec.rb

@@ -0,0 +1,47 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::Runners::CmdParse do
+  before( :each ) do
+    @target = test_app.parser
+  end
+
+  describe "#instance" do
+    it "should always return the same object" do
+      @target.should == CP::App.instance
+    end
+  end
+
+  describe "#parser" do
+    it "should default to CmdParser" do
+      @target.parser.should == CP::Parsers::CmdParse
+    end
+  end
+
+  describe "#run" do
+    it "should exist" do
+      @target.methods.include?( :run ).should be_true
+    end
+
+    it "should not take any parameters" do
+      @target.method( :run ).arity.should === 0
+    end
+  end
+
+  describe "properties" do
+    [:name, :version].each do |prop_name|
+      it "should accept a #{prop_name} property" do
+        prop_val = "0.1.1"
+
+        lambda {
+          @target.app prop_name, prop_val
+        }.should change( @target, prop_name ).from( nil ).to( prop_val )
+      end
+    end
+
+    it "should raise a ArgumentError when setting other properties" do
+      lambda {
+        test_app.app :foo, "bar"
+      }.should raise_error( ArgumentError, /no such property/ )
+    end
+  end
+end

data/spec/support/shared_helper.rb

@@ -0,0 +1,47 @@
+shared_examples_for "it accepts commands" do
+  describe "#command" do
+    it "should return a Command" do
+      @target.command( :test ).should be_an_instance_of( CP::Command )
+    end
+  end
+
+  describe "#commands" do
+    it "should return an array" do
+      @target.commands.should be_an_instance_of( Array )
+    end
+
+    it "should increase with each defined command" do
+      lambda {
+        @target.command( :test )
+      }.should change(){ @target.commands.length}.by( 1 )
+    end
+
+    it "should include each defined command" do
+      @target.commands.include?( @target.command( :test ) ).should be_true
+    end
+  end
+end
+
+shared_examples_for "it accepts options" do
+  describe "#option" do
+    it "should return an Option" do
+      @target.option( "-s" ).should be_an_instance_of( CP::Option )
+    end
+  end
+
+  describe "#options" do
+    it "should return an array" do
+      @target.options.should be_an_instance_of( Array )
+    end
+
+    it "should increase with each defined option" do
+      lambda {
+        @target.option( "-s" )
+      }.should change(){ @target.options.length}.by( 1 )
+    end
+
+    it "should include each defined option" do
+      @target.options.include?( @target.option( "-s" ) ).should be_true
+    end
+  end
+end

data/spec/support/singleton_helper.rb

@@ -0,0 +1,17 @@
+# from http://blog.ardes.com/2006/12/11/testing-singletons-with-ruby
+
+require "singleton"
+
+class << Singleton
+  def included_with_reset( klass )
+    included_without_reset( klass )
+    class << klass
+      def reset_instance
+        Singleton.send :__init__, self
+        self
+      end
+    end
+  end
+  alias_method :included_without_reset, :included
+  alias_method :included, :included_with_reset
+end

data/spec/support/spec_helper.rb

@@ -0,0 +1,32 @@
+require File.join( File.dirname( __FILE__ ), "singleton_helper" )
+require File.join(File.dirname(__FILE__), "shared_helper")
+
+# ensure we're at the front of the load path
+$:.unshift( File.join( File.dirname( __FILE__ ), "..", "lib" ) )
+
+# include the gem
+require "cp"
+
+# reset the App singleton before each test
+RSpec.configure do |config|
+  config.before( :each ) {
+    CP::App.reset_instance
+  }
+end
+
+
+class App
+  include CP
+end
+
+def test_app
+  a = App.new
+  yield a if block_given?
+  a
+end
+
+def test_command
+  c = CP::Command.new( :test )
+  yield c if block_given?
+  c
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: cp
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 0.0.1.pre1
+platform: ruby
+authors: 
+- Rick Fletcher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cmdparse
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cmdparse
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+  type: :runtime
+  version_requirements: *id002
+description: CP provides a less verbose API for the CmdParse gem.
+email: 
+- fletch@pobox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- cp.gemspec
+- examples/net.rb
+- lib/cp.rb
+- lib/cp/app.rb
+- lib/cp/command.rb
+- lib/cp/commands.rb
+- lib/cp/option.rb
+- lib/cp/options.rb
+- lib/cp/runners/cmd_parse.rb
+- lib/cp/version.rb
+- spec/app_spec.rb
+- spec/command_spec.rb
+- spec/cp_spec.rb
+- spec/option_spec.rb
+- spec/options_spec.rb
+- spec/runners/cmd_parse_spec.rb
+- spec/support/shared_helper.rb
+- spec/support/singleton_helper.rb
+- spec/support/spec_helper.rb
+homepage: ""
+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: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.4
+signing_key: 
+specification_version: 3
+summary: An alternative API for CmdParse
+test_files: 
+- spec/app_spec.rb
+- spec/command_spec.rb
+- spec/cp_spec.rb
+- spec/option_spec.rb
+- spec/options_spec.rb
+- spec/runners/cmd_parse_spec.rb
+- spec/support/shared_helper.rb
+- spec/support/singleton_helper.rb
+- spec/support/spec_helper.rb