applix 0.3.0 → 0.3.4

data/README.mkd

@@ -1,6 +1,34 @@
 # applix
 
-`Hash#from_argv` builds a hash from ARGV like argument vector according to
+Building command line apps like:
+
+    Defaults = { :verbose => false }
+
+    Applix.main(ARGV, Defaults) do 
+        handle(:one) do |*args, opts|
+            if opts[:verbose]
+                puts "arguments: #{args.inspect}"
+                puts "options: #{opts.inspect}"
+            end
+        end
+
+        handle(:two) do |*args, opts|
+            if opts[:verbose]
+                puts "arguments: #{args.inspect}"
+                puts "options: #{opts.inspect}"
+            end
+        end
+    end
+
+can be called like:
+
+    $ app --verbose one 1234 x y z
+    arguments: ["1234", "x", "y", "z"]
+    options: {:verbose => true}
+    $
+
+Command line options will be processed with Hash#from_argv. `Hash#from_argv`
+builds a hash from ARGV like argument vector according to
 following examples: 
 
     '-f'                  --> { :f      => true }

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.4

data/lib/applix.rb

@@ -5,12 +5,13 @@ class Applix
     app = Applix.new
     app.instance_eval(&blk)
     app.run(argv, defaults)
+
   rescue => e
     puts <<-EOT
 
 ## #{e}
 
-usage: #{__FILE__} <args...>
+usage: #{$0} <args...>
 
 --- #{e.backtrace.join "\n    "}
     EOT
@@ -21,14 +22,40 @@ usage: #{__FILE__} <args...>
     options = (defaults.merge options)
     args = (options.delete :args)
 
-    # which task to run depends on first line argument..
-    (name = args.shift) or (raise "no task")
-    (task = tasks[name.to_sym]) or (raise "no such task: '#{name}'")
-    task[:code].call(*args, options)
+    # pre handle
+    @prolog_cb.call(*args, options) unless @prolog_cb.nil?
+
+    # it's either :any
+    if task = tasks[:any] 
+      rc = task[:code].call(*args, options)
+    else # or the task defined by the first argument
+      (name = args.shift) or (raise "no task")
+      (task = tasks[name.to_sym]) or (raise "no such task: '#{name}'")
+      rc = task[:code].call(*args, options)
+    end
+
+    # post handle
+    unless @epilog_cb.nil?
+      rc = @epilog_cb.call(rc, *args, options)
+    end
+
+    rc # return result code from handle callbacks, not the epilog_cb
   end
 
   private 
 
+  def prolog &blk
+    @prolog_cb = blk
+  end
+
+  def epilog &blk
+    @epilog_cb = blk
+  end
+
+  def any &blk
+    tasks[:any] = { :code => blk }
+  end
+
   def handle name, &blk
     tasks[name.to_sym] = { :code => blk }
   end

data/spec/applix_spec.rb

@@ -2,6 +2,79 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Applix" do
 
+  it 'prolog has read/write access to args and options' do
+    Applix.main(['func']) do
+      prolog { |*args, options|
+        args.should == ['func']
+        options[:prolog] = Time.now
+      }
+
+      handle(:func) { |*_, options| 
+        options[:prolog]
+      }
+    end.should_not == nil
+  end
+
+  it 'epilog has access to task handler results' do
+    Applix.main(['func']) do
+      # @epilog will NOT make it into the handle invocation
+      epilog { |rc, *_| 
+        rc.should == [1, 2, 3]
+        rc.reverse
+      }
+      handle(:func) { [1, 2, 3] }
+
+    end.should == [3, 2, 1]
+  end
+
+  it 'runs before callback before handle calls' do
+    Applix.main(['func']) do
+
+      # @prolog will be available in handle invocations
+      prolog { 
+        @prolog = :prolog 
+      }
+
+      # @epilog will NOT make it into the handle invocation
+      epilog { |rc, *_|
+        @epilog = :epilog 
+        rc 
+      }
+
+      handle(:func) { 
+        [@prolog, @epilog] 
+      }
+    end.should == [:prolog, nil]
+  end
+
+  it 'runs epilog callback after handle' do
+    t_handle = Applix.main([:func]) do
+      epilog { |rc, *_| 
+        $t_post_handle = Time.now 
+        rc
+      }
+      handle(:func) { 
+        # epilog block should not have been executed yet
+        $t_post_handle.should == nil
+        Time.now 
+      }
+    end
+    t_handle.should_not == nil
+    $t_post_handle.should_not == nil
+    (t_handle < $t_post_handle).should == true
+  end
+
+  it 'supports :any when task does not depend on first arguments' do
+    %w(bla fasel laber red).each do |name|
+      Applix.main(['--opt1', name, "param1", "param2"], {:opt2 => false}) do
+        any do |*args, options| 
+          args.should == [name, "param1", "param2"]
+          options.should == {:opt1 => true, :opt2 => false}
+        end
+      end
+    end
+  end
+
   it 'should call actions by first argument names' do
     argv = ['func']
     Applix.main(argv) do

metadata

@@ -2,7 +2,7 @@
 name: applix
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.3.4
 platform: ruby
 authors: 
 - dirk luesebrink
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-14 00:00:00 +02:00
+date: 2011-08-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -139,7 +139,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2866843717498845092
+      hash: 2582567187063183630
       segments: 
       - 0
       version: "0"