optix 1.1.1 → 1.2.0

data/.gitignore

@@ -1,3 +1,4 @@
+*.swp
 *.gem
 *.rbc
 .bundle

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+

data/README.md

@@ -1,26 +1,27 @@
+[![Build Status](https://travis-ci.org/busyloop/optix.png?branch=master)](https://travis-ci.org/busyloop/optix)
+
 # Optix
 
 Optix is an unobtrusive, composable command line parser based on Trollop.
+It is intended to be a lighter weight alternative to [Thor](https://github.com/wycats/thor).
 
 
 ## Features
 
-* Lightweight, unobtrusive syntax.
-  No subclassing or introduction of dependencies.
+* Convenient, declarative syntax (similar to [Thor](https://github.com/wycats/thor))
 
 * Nested subcommands such as `git remote show origin` may be composed at runtime in arbitrary order.
 
 * Subcommands inherit from their parent. Common options (such as '--debug' or '--loglevel')
   need to be declared only once to make them available to an entire branch.
 
-* Stands on the shoulders of [Trollop](http://trollop.rubyforge.org) (by William Morgan), one of the most complete and robust
-  option-parser implementations ever created.
+* Stands on the shoulders of [Trollop](http://trollop.rubyforge.org) (by William Morgan), one of the
+  most advanced option-parser implementations available.
 
 * Automatic validation and help-screens.
 
 * Should work on all major Ruby versions (tested on 1.9.3, 1.9.2 and 1.8.7).
 
-* Strong test-suite.
 
 ## Installation
 
@@ -30,37 +31,35 @@ Optix is an unobtrusive, composable command line parser based on Trollop.
 
 ```ruby
 #!/usr/bin/env ruby
+
 require 'optix'
 
 module Example
-  module Printer
-    # Declare the "root"-command 
-    Optix::command do
+  class Printer < Optix::CLI
+
+    # Declare global cli-options
+    cli_root do
+      # A label to be printed on the root help-screen
       text "I am printer. I print strings to the screen."
       text "Please invoke one of my not so many sub-commands."
-  
-      # Declare a global option (all subcommands inherit this)
+      
+      # An option that is inherited by all commands
       opt :debug, "Enable debugging", :default => false
     end
-  
-    # Declare sub-command 
-    Optix::command 'print' do
-      desc "Print a string"
-      text "Print a string to the screen"
-      params "<string>"
-  
-      opt :count, "Print how many times?", :default => 1
-  
-      # This block is invoked when validations pass.
-      exec do |cmd, opts, argv|
-        if argv.length < 1
-          raise Optix::HelpNeeded
-        end
-
-        puts "DEBUGGING IS ENABLED!" if opts[:debug]
-        (1..opts[:count]).each do
-          puts argv.join(' ') 
-        end
+    
+    # Declare a command called "print"
+    desc "Print a string"
+    text "Print a string to the screen"
+    opt :count, "Print how many times?", :default => 1
+    params "<string>"
+    def print(cmd, opts, argv)
+      if argv.length < 1
+        raise Optix::HelpNeeded
+      end
+
+      puts "DEBUGGING IS ENABLED!" if opts[:debug]
+      (1..opts[:count]).each do
+        puts argv.join(' ')
       end
     end
   end
@@ -95,56 +94,106 @@ See the `examples/`-folder for more elaborate examples.
 
 ## Documentation
 
+A cli is composed by sub-classing `Optix::CLI` and using the DSL
+to describe the desired commands, labels and options.
+
+At runtime you call `Optix.invoke!(ARGV)` to invoke the parser. It will parse
+and validate the input (in this case: ARGV), create an instance of the class
+containing the requested method (if any) and call the latter.
+
+In case of a validation error Optix displays an adequate
+error-message and auto-generated help-screen.
+
+If your program contains multiple classes inheriting from `Optix::CLI`
+then the resulting cli will be the sum of their parts. You don't have
+to pay attention to load-order, an Optix CLI assembles correctly in 
+any order.
+
 ### Commands and Sub-Commands
 
-Commands may be declared anywhere, at any time, in any order.
-Declaring the "root"-command looks like this:
+In Optix all commands are created equal. In order to nest
+commands you simply declare them with a `parent`. The minimum
+code to create a program that can be invoked as `program.rb hello world`
+would look like this:
 
 ```ruby
+#!/usr/bin/env ruby
+
 require 'optix'
 
-Optix::command do
-  # opts, triggers, etc
-end
-```
+module Example
+  class HelloWorld < Optix::CLI
 
-Now, let's add a sub-command:
+    # Declare a command called "world" as child of "hello"
+    parent 'hello'
+    def world(cmd, opts, argv)
+      puts "Hello world!"
+    end
+  end
+end
 
-```ruby
-Optix::command 'sub' do
-  # opts, triggers, etc
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
 end
 ```
 
-And finally, a sub-sub command:
+You'll notice that we didn't actually declare the parent-command itself (`hello`).
+In optix this isn't necessary, any gaps in the hierarchy are automatically filled in.
+
+Commands may be nested to any depth, e.g. try this parent in the above code: `parent 'shout at the'`.
+
+## Commands that have sub-commands can not be invoked
+
+When you have a command `foo bar` then the parent command `foo` can not be invoked.
+It will still appear in help-screens and behave as expected, though.
+This is a deliberate constraint enforced by Optix in order to protect the sanity of your users.
+
+## Helpers
+
+Optix ignores all methods that aren't preceded by a DSL-directive
+(e.g. `parent`, `desc` or `opt`). Thus you don't need to do anything
+special to mix command-methods with helper-methods.
+
+Example:
 
 ```ruby
-Optix::command 'sub sub' do
-  # opts, triggers, etc
+module Example
+  class HelperExample < Optix::CLI
+
+    # This method becomes a command because it is
+    # preceded by an optix-directive ('parent')
+    parent 'hello'
+    def world(cmd, opts, argv)
+      puts "Hello world!"
+    end
+
+    # This method is ignored by Optix
+    def iam_a_helper(yay)
+      # ...
+    end
+  end
 end
 ```
 
-Remember: Optix doesn't care about the order of declarations.
-The `sub sub` command may be declared prior to the `sub` command.
- 
-A common pattern is to insert your `Optix::command` blocks directly
-at the module level so they get invoked during class-loading.
-This way your CLI assembles itself automatically and the
-command-hierarchy mirrors the modules/classes that
-are actually loaded.
-
 
-### Optix::command DSL
+### Optix DSL
 
-Within `Optix::command` the following directives are available:
+The following directives are available:
 
 ### desc
 
 Short description, displayed in the subcommand-list on the help-screen of the *parent* command.
 
 ```ruby
-Optix::command "frobnitz" do
-  desc "Frobnicates the gizmo"
+module Example
+  class Frobnitz < Optix::CLI
+
+    desc 'Frobnicate a gizmo'
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
@@ -153,22 +202,113 @@ end
 Long description, displayed on the help-screen for this command.
 
 ```ruby
-Optix::command "frobnitz" do
-  text "Frobnicate the gizmo by subtle twiddling."
-  text "Please only apply this to 2-state devices or you might bork it."
+module Example
+  class Frobnitz < Optix::CLI
+
+    text "Frobnicate the gizmo by subtle twiddling."
+    text "Please only apply this to 2-state devices or you might bork it."
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
 * May be called multiple times for a multi-line description.
 
+### parent
+
+Specifies the parent for this command.
+
+```ruby
+module Example
+  class Frobnitz < Optix::CLI
+
+    parent 'foo bar', ['desc for foo', 'desc for bar']
+    def batz(cmd, opts, argv)
+      puts "foo bar batz was called!"
+    end
+  end
+end
+```
+
+* Commands may be nested to any depth (delimited by whitespace), missing
+  parts of the hierarchy are filled in automatically.
+
+* The second argument to `parent` is an optional array of descriptions (`desc`) for
+  the auto-generated parents.
+
+* Use the special `parent :none` to describe the root-command in programs that
+  should accept arguments directly (`foo.rb --debug=true`) without any
+  commands (`foo.rb command --debug=true`). See `examples/thor_style/bare.rb`
+  for an example of this.
+
+### cli_root
+
+Takes a block to specify the root-command.
+
+This is a useful shorthand in programs that have
+(sub-)commands where it hence doesn't make sense to use
+the `parent :none`-syntax.
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'optix'
+
+module Example
+  class Frobnitz < Optix::CLI
+
+    # Declare global cli-options (aka "the root-command")
+    cli_root do
+      # A label to be printed on the root help-screen
+      text "I am printer. I print strings to the screen."
+      text "Please invoke one of my not so many sub-commands."
+      
+      # An option that is inherited by all commands
+      opt :debug, "Enable debugging", :default => false
+    end
+    
+    # Declare a command called "print"
+    desc "Print a string"
+    text "Print a string to the screen"
+    opt :count, "Print how many times?", :default => 1
+    params "<string>"
+    def print(cmd, opts, argv)
+      if argv.length < 1
+        raise Optix::HelpNeeded
+      end
+
+      if opts[:debug]
+        # ...
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end
+```
+
+* All sub-commands inherit the `opt`s from their parents.
+  A `text` declared inside `cli_root` will display on the root help-screen.
+
 
 ### opt
 
 Declares an option.
 
 ```ruby
-Optix::command do
-  opt :some_name, "some description", :default => 'some_default'
+module Example
+  class Frobnitz < Optix::CLI
+
+    opt :some_name, "some description", :default => 'some_default'
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
@@ -231,13 +371,18 @@ Takes the following optional arguments:
 Describes positional parameters that this command accepts.
 
 ```ruby
-Optix::command do
-  params "<foo> [bar]"
+module Example
+  class Frobnitz < Optix::CLI
+    params "<foo> [bar]"
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
-* Note: Optix does **not** validate or inspect positional parameters at all (this is your job, inside exec{}).
-  The value of this command is only used to display a proper synopsis in the help-screen.
+* Note: Optix does **not** validate or inspect positional parameters. This is up to you inside your method.
+  The value of this command is only used by Optix to display a proper synopsis in the help-screen.
 
 ### depends
 
@@ -245,11 +390,17 @@ Marks two (or more!) options as requiring each other. Only handles
 undirected (i.e., mutual) dependencies.
 
 ```ruby
-Optix::command do
-  opt :we,     ""
-  opt :are,    ""
-  opt :family, ""
-  depends :we, :are, :family
+module Example
+  class Frobnitz < Optix::CLI
+
+    opt :we,     ""
+    opt :are,    ""
+    opt :family, ""
+    depends :we, :are, :family
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
@@ -258,23 +409,35 @@ end
 Marks two (or more!) options as conflicting.
 
 ```ruby
-Optix::command do
-  opt :force, "Force this operation"
-  opt :no_op, "Dry run, don't actually do anything"
-  conflict :force, :no_op
+module Example
+  class Frobnitz < Optix::CLI
+
+    opt :force, "Force this operation"
+    opt :no_op, "Dry run, don't actually do anything"
+    conflict :force, :no_op
+    def frob(cmd, opts, argv)
+      ...
+    end
+  end
 end
 ```
 
 ### trigger
 
-Triggers allow to short-circuit argument parsing for "action-options"
+Triggers short-circuit argument parsing for "action-options"
 (options that directly trigger an action) such as `--version`.
 
 ```ruby
-Optix::command do
-  opt :version, "Print version and exit"
-  trigger :version do
-    puts "Version 1.0"
+module Example
+  class Frobnitz < Optix::CLI
+
+    opt :version, "Print version and exit"
+    trigger :version do
+      puts "Version 1.0"
+    end
+    def frob(cmd, opts, argv)
+      ...
+    end
   end
 end
 ```
@@ -296,14 +459,20 @@ end
 
 ### filter
 
-Filters allow to group functionality that is common to a branch of subcommands.
+Filters group functionality that is common to a branch of sub-commands.
 
 ```ruby
-Optix::command do
-  opt :debug, "Enable debugging"
-  filter do |cmd, opts, argv|
-    if opts[:debug]
-      # .. enable debugging ..
+module Example
+  class Frobnitz < Optix::CLI
+
+    opt :debug, "Enable debugging"
+    filter do |cmd, opts, argv|
+      if opts[:debug]
+        # .. enable debugging ..
+      end
+    end
+    def frob(cmd, opts, argv)
+      ...
     end
   end
 end
@@ -322,28 +491,25 @@ end
   parsing and display the help-screen.
 
 
-### exec
-
-The exec-block is called when your command is invoked, after validation
-passed. It should contain (or invoke) your actual business logic.
+### Method signature
 
 ```ruby
-Optix::command do
-  exec do |cmd, opts, argv|
-    if opts[:debug]
-      # .. enable debugging ..
+module Example
+  class Frobnitz < Optix::CLI
+
+    def frob(cmd, opts, argv)
+      ...
     end
   end
 end
 ```
 
-* Your block receives three arguments:
+* Your command-method receives three arguments:
     * `cmd` (Array) The full command that was executed, e.g.: ['foo', 'bar', 'baz']
     * `opts` (Hash) The options-hash, e.g.: { :debug => true }
     * `argv` (Array) Positional parameters that your command may have received, e.g.: ['a','b','c']
 
-* You may raise `Optix::HelpNeeded` inside your exec-block to abort
-  parsing and display the help-screen.
+* You may raise `Optix::HelpNeeded` to abort parsing and display the help-screen.
 
 
 ## Chain of execution
@@ -359,40 +525,12 @@ This is the chain of execution when you pass ['foo', 'bar', 'batz'] to `Optix.in
   1. Filters for `batz` (if any)
   1. Exec{}-block for `batz`
 
+## Advanced usage
 
+Optix is very flexible and can be easily shaped into many forms.
 
-## Scopes
-
-In rare cases you may want to have multiple independent Optix command-trees in a single app.
-This can be achieved by passing a scope-name to your command-declarations, like so:
-
-```ruby
-# Declare root-command in the :default scope
-Optix::command '', :default do
-  # opts, triggers, etc
-end
-
-# Declare root-command in another, independent scope
-Optix::command '', :other_scope do
-end
-
-# Declare a sub-command in the other scope
-Optix::command 'sub', :other_scope do
-end
-
-# Then either invoke the :default scope
-Optix.invoke!(ARGV)
-# ...or...
-Optix.invoke!(ARGV, :other_scope)
-```
-
-## Re-initialization
-
-In even rarer cases you may need to reset Optix at runtime.
-To make Optix forget all scopes, configuration and commands, invoke:
-
-`Optix.reset!`
-
+Please see the specs, source-code and the examples in `examples/singleton_style`
+for advanced usage patterns (no sub-classing, lower level access).
 
 ## Contributing
 

data/examples/{filetool.rb → singleton_style/filetool.rb}

@@ -1,13 +1,8 @@
+#!/usr/bin/env ruby
 require 'optix'
 
 #
-# Example application to demonstrate Optix.
-#
-# The easiest way to get started is to download this file
-# and actually run it. Play around, try invoking '--help',
-# '-v', '--version' and the subcommands. 
-#
-# Then come back here to learn how it's done. :)
+# Example application to demonstrate Optix advanced usage.
 #
 module Example
   class FileTool
@@ -15,7 +10,7 @@ module Example
     # Also declaring the first-level sub-commands right here.
     # Just like the root-command these commands can not be invoked
     # directly (because they have sub-commands). Their declaration
-    # is not mandatory, but by declaring them explicitly we can add
+    # is not mandatory but by declaring them explicitly we can add
     # some useful help-texts to aid the user.
     Optix::command do
       # Let's have a nice description

data/examples/thor_style/bare.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'optix'
+
+module Example
+  class Bare < Optix::CLI
+
+    # Normally Optix would create a sub-command
+    # called "main" for the method below. 
+    #
+    # But in this example we don't want any sub-commands,
+    # thus we specify 'parent :none' and attach our options
+    # directly to the root.
+    parent :none
+    desc "Print a string"
+    text "Printer v1.0"
+    text "I print a string to the screen, possibly many times."
+    opt :count, "Print how many times?", :default => 1
+    params "<string>"
+    def main(cmd, opts, argv)
+      if argv.length < 1
+        raise Optix::HelpNeeded
+      end
+
+      puts "DEBUGGING IS ENABLED!" if opts[:debug]
+      (1..opts[:count]).each do
+        puts argv.join(' ') 
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end
+

data/examples/thor_style/hello_world.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+# Minimum hello-world example.
+#
+# Note: In a real program you'd want to at least
+#       provide some label and help-text using
+#       "desc" and "text".
+
+require 'optix'
+
+module Example
+  class HelloWorld < Optix::CLI
+
+    # Declare a command called "world" as child of "hello"
+    parent 'hello', "Try me!"
+    def world(cmd, opts, argv)
+      puts "Hello world!"
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end

data/examples/thor_style/kitchen_sink.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'optix'
+
+# A kitchen sink example, demonstrating most Optix functionality
+
+module KitchenSink
+  # We declare the root-command ("global options") right here
+  # NOTE: This is an alternative (equivalent) syntax to using 'cli_root'
+  #       inside a sub-class of Optix::CLI
+  Optix::command do
+    # Help-screen text
+    text "Kitchen-sink-multi-tool. I can print text, calculate, sing and dance!"
+    text "Please invoke one of my sub-commands."
+
+    # A global option that is inherited by all sub-commands
+    opt :debug, "Enable debugging", :default => false
+
+    # Declare a filter on the :debug-option. All sub-commands
+    # inherit this filter as well so you will see the text printed
+    # when you use the '-d' option on any command.
+    filter do |cmd, opts, argv|
+      puts "DEBUG: '#{cmd.join(' ')}' was called with opts=#{opts}, argv=#{argv}" if opts[:debug]
+    end
+
+  end
+
+  # This is our Printer again.
+  # You probably remember him from the first example. ;)
+  class Printer < Optix::CLI
+    desc "Print a string"
+    text "Print a string to the screen"
+    params "<string>"
+    opt :count, "Print how many times?", :default => 1
+    def print(cmd, opts, argv)
+      if argv.length < 1
+        raise Optix::HelpNeeded
+      end
+
+      (1..opts[:count]).each do
+        puts argv.join(' ') 
+      end
+    end
+  end
+
+  # A simple Calculator
+  class Calculator < Optix::CLI
+    # We want all commands in here to be subcommands of
+    # 'calc'. Since 'calc' itself is not declared anywhere
+    # it is implicitly created, and we also pass a description.
+    parent 'calc', 'Calculator'
+    desc "Multiply some numbers"
+    text "Multiplication is ohsom!"
+    params "<int> <int> [int] ..."
+    def multi(cmd, opts, argv)
+      if argv.length < 2
+        puts "Error: Need at least two parameters!"
+        raise Optix::HelpNeeded
+      end
+  
+      o = 1
+      argv.each do |i|
+        o *= i.to_i
+      end
+      puts o
+    end
+
+    # Hint: Don't forget to specify the parent again, 
+    #       otherwise the method would become a child
+    #       of root. We can leave out the description
+    #       here because we already provided one above
+    #       the 'multi'-method.
+    parent 'calc' #, 'Calculator'
+    desc "Add some numbers"
+    text "Addition is ohsom!"
+
+    # Demonstrate a trigger here (makes no sense, but heck)
+    opt :argh, "Just say 'ARGH!' and exit"
+    trigger :argh do |cmd, opts, argv|
+      puts "ARGH!"
+    end
+
+    params "<int> <int> [int] ..."
+    def add(cmd, opts, argv)
+      if argv.length < 2
+        puts "Error: Need at least two parameters!"
+        raise Optix::HelpNeeded
+      end
+  
+      o = 0
+      argv.each do |i|
+        o += i.to_i
+      end
+      puts o
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end
+

data/examples/thor_style/nested.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'optix'
+
+module Example
+  class Frobnitz < Optix::CLI
+
+    parent 'foo bar', ['desc for foo', 'desc for bar']
+
+    desc 'i am foobarbaz' # label for 'foo bar baz'
+    text 'hell yea, i am foobarbaz' # help-screen for 'foo bar baz'
+    def baz(cmd, opts, argv)
+      puts "foo bar baz was called!"
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end
+

data/examples/thor_style/printer.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'optix'
+
+module Example
+  class Printer < Optix::CLI
+
+    # Declare global options; the text-label that is printed
+    # for the root-command and one option that is inherited by
+    # all sub-commands.
+    cli_root do
+      text "I am printer. I print strings to the screen."
+      text "Please invoke one of my not so many sub-commands."
+      # Opts are inherited by all children
+      opt :debug, "Enable debugging", :default => false
+    end
+    
+    # Declare a sub-command called "print"
+    desc "Print a string"
+    text "Print a string to the screen"
+    opt :count, "Print how many times?", :default => 1
+    params "<string>"
+    # Your CLI-methods always 
+    def print(cmd, opts, argv)
+      if argv.length < 1
+        raise Optix::HelpNeeded
+      end
+
+      puts "DEBUGGING IS ENABLED!" if opts[:debug]
+      (1..opts[:count]).each do
+        puts argv.join(' ')
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Perform the actual parsing and execution.
+  Optix.invoke!(ARGV)
+end

data/lib/optix/version.rb

@@ -1,3 +1,3 @@
 class Optix
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/optix.rb

@@ -271,3 +271,71 @@ class Optix
   end
 end
 
+class Optix
+  class CLI
+    class << self
+      def add_context(key, value, &block)
+        @optix_context ||= []
+        @optix_context << [key, value, block]
+      end
+
+      [:desc, :text, :opt, :params, :filter,
+       :trigger, :depends, :conflicts, :parent].each do |meth|
+        define_method(meth) do |*value, &block|
+          add_context(meth, value, &block)
+        end
+      end
+
+      def parent(path, label=nil)
+        @optix_context ||= []
+        if label
+          label = [label] if label.is_a? String
+          p = path.split
+          (0..p.length-1).each do |i|
+            _path = p[0..i].join(' ')
+            Optix::command(_path) do
+              desc label[i]
+            end
+          end
+        end
+
+        @optix_parent = path
+      end
+
+      def cli_root(&block)
+        if block
+          add_context(:cli_root, '', &block)
+        else
+          @optix_parent = :none
+        end
+      end
+
+      def method_added(meth)
+        return if @optix_context.nil?
+        if @optix_parent == :none
+          cmd_path = nil
+        elsif @optix_parent
+          cmd_path = "#{@optix_parent} #{meth.to_s}"
+        else
+          cmd_path = meth.to_s
+        end
+        cmd = Optix::command(cmd_path) {}
+        @optix_context.each do |e|
+          if :cli_root == e[0]
+            Optix::command *e[1], &e[2]
+            next
+          end
+          cmd.send(e[0], *e[1], &e[2])
+        end
+        me = self
+
+        cmd.send(:exec) do |cmd, opts, argv|
+          self.new.send(meth, cmd, opts, argv)
+        end
+        @optix_parent = ''
+        @optix_context = nil
+      end
+    end
+  end
+end
+

data/spec/optix_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'tempfile'
 require 'optix'
 
 describe Optix do
@@ -124,7 +125,7 @@ describe Optix do
         opt :a, '', :default => true
         opt :b, '', :default => 1
         opt :c, '', :default => 1.0
-        opt :d, '', :default => File.new('/tmp')
+        opt :d, '', :default => File.new(Tempfile.new('optix_test').path)
         opt :e, '', :default => Date.new
         opt :f, '', :default => "foo"
       end
@@ -150,7 +151,7 @@ describe Optix do
       Optix::command('', @context) do
         opt :b, '', :default => [1]
         opt :c, '', :default => [1.0]
-        opt :d, '', :default => [File.new('/tmp')]
+        opt :d, '', :default => [File.new(Tempfile.new('optix_test').path)]
         opt :e, '', :default => [Date.new]
         opt :f, '', :default => ["foo"]
       end
@@ -940,7 +941,7 @@ describe Optix do
 
     describe "FileTool" do
       before :each do
-        load 'examples/filetool.rb'
+        load 'examples/singleton_style/filetool.rb'
       end
 
       it "prints version when invoked with -v" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: optix
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-13 00:00:00.000000000 Z
+date: 2012-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
-  requirement: &13737160 !ruby/object:Gem::Requirement
+  requirement: &7466120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13737160
+  version_requirements: *7466120
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &13735760 !ruby/object:Gem::Requirement
+  requirement: &7465200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13735760
+  version_requirements: *7465200
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &13734640 !ruby/object:Gem::Requirement
+  requirement: &7464000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13734640
+  version_requirements: *7464000
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &13733600 !ruby/object:Gem::Requirement
+  requirement: &7463020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13733600
+  version_requirements: *7463020
 description: Optix is an unobtrusive, composable command line parser.
 email:
 - moe@busyloop.net
@@ -63,12 +63,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- examples/filetool.rb
-- examples/printer.rb
+- examples/singleton_style/filetool.rb
+- examples/singleton_style/printer.rb
+- examples/thor_style/bare.rb
+- examples/thor_style/hello_world.rb
+- examples/thor_style/kitchen_sink.rb
+- examples/thor_style/nested.rb
+- examples/thor_style/printer.rb
 - lib/optix.rb
 - lib/optix/trollop.rb
 - lib/optix/version.rb
@@ -89,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3252014974996613428
+      hash: 540681097072146683
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -98,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3252014974996613428
+      hash: 540681097072146683
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10