applix 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3e0cc3a63efd54a150fc9261fedad236cf2e5d1
-  data.tar.gz: 1703a149b57fcfd93b5cdee98c66a4f53a0f9809
+  metadata.gz: 54a476e8df75c875f08de5e5ac9a0a952d20fb50
+  data.tar.gz: 22f80002098e75c8a0ed9e492aecf5e12b31a2a5
 SHA512:
-  metadata.gz: fda903579759622f6e4854c0bd61581d030908fd798202c1c7b5d81fbeeaf94e565b1e963765c12fd72457b3ecafe5131a2e2a5929aca8d0e059b232ff69e236
-  data.tar.gz: 5080cd1efba36a17b0386afe2d8b350c54d9815fddf822f5514b32d78350292275c4eb86175cdd58d9fd99b71159b798842efd1df83c9a276a15f4b4e7fcbea8
+  metadata.gz: 9657b4faae0275463346437eabd2fcb8d7058fdce52ba2330b9c1f53257080e2442c9429a94b67b39ebef7cca559e69170633b4cd96458dd2f9e21c0e9ee2059
+  data.tar.gz: 221e610a1609fb16d73591cce387b1e73655accdff8928f0a56d638ea6b6d599c591c58f3042975ef66527e4d7a5e17c2fc293738931acd42990679a6630f75d

data/.rspec

@@ -1 +1 @@
---color --backtrace --format documentation --debug
+--color --backtrace

data/Guardfile

@@ -1,7 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard :rspec, all_on_start: true, cli: '--format nested --debug --color' do
+guard(:rspec, all_on_start: true) do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }

data/README.mkd

@@ -52,6 +52,58 @@ becomes:
 
     { :foo => true, :bar => 'loo', :args => ["123", "now"] }
 
+## Command line micro DSLs with @argsloop@
+
+Imagine you have an app which could perform multiple operations on a excel
+sheet. Like reading, validating and reporting. You could put all variations in
+a single command which to call directly from a command line. A better is to
+break down such a procedure into single steps which can be performed
+independently and combined freely on the command line. Example procedure:
+
+  load <filename>
+  select <sheetname>
+  validate
+  print 
+
+Now you can make this an applix command line DSL like this:
+
+  Applix.main(ARGV) do
+    any(argsloop: MyExcelApp.new)
+  end
+
+and calling it like:
+
+  $ my_app load <filename> select <sheetname> validate print 
+
+Now to make applix call your app with the right commands and parameters the
+commands just have to take its parameters off the arg vector like this:
+
+  app.load(args)
+    filename = args.shift
+    ...
+    args
+  end
+
+  app.select(args)
+    sheetname = args.shift
+    ...
+    args
+  end
+
+  app.validate(args)
+    ...
+    args
+  end
+
+  app.print(args)
+    ...
+    args
+  end
+
+Adding new steps now is easy, like instead of print you could make an upload
+to another database for example without the need touch existing code.
+
+
 ## Note on Patches/Pull Requests
  
 * Fork the project.

data/applix.gemspec

@@ -42,10 +42,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec-mocks'
   s.add_development_dependency 'guard-rspec'
 
-  if RUBY_PLATFORM.match /java/i
-    s.add_development_dependency 'ruby-debug'
-  else
-    s.add_development_dependency 'debugger'
+  unless RUBY_PLATFORM.match /java/i
+    s.add_development_dependency 'byebug'
   end
 
   # version class is read from

data/lib/applix.rb

@@ -105,17 +105,29 @@ usage: #{$0} <args...>
     @epilog_cb = blk
   end
 
+  # opts[:argsloop], the target for any, may be be class or an object. In case
+  # of class we instantiate an object from it, other we use the object itself
   def any(opts = {}, &blk)
     if(app = opts[:argsloop]) 
+
       blk = lambda do |*args, opts|
+        # instantiate or assign target object before first usage
+        target = (app.is_a? Class) ? app.new(opts) : app
+
         while(args && 0 < args.size) do
           args = begin
                    if(op = args.shift)
                      puts " --(#{op})-- (#{args.join ', '})"
-                     app.send(op, args, opts)
+                     if(target == app)
+                       # object target
+                       target.send(op, args, opts)
+                     else
+                       # object instance created from class target 
+                       target.send(op, *args)
+                     end
                    end
                  rescue ArgumentError => e
-                   app.send(op, opts)
+                   target.send(op, opts)
                  end
         end
       end

data/lib/applix/version.rb

@@ -1,5 +1,5 @@
 # gem version is extracted automatically from this class during the build
 # process
 class Applix
-  VERSION = '0.4.11'
+  VERSION = '0.4.12'
 end

data/spec/applix_hash_spec.rb

@@ -2,19 +2,21 @@ require 'spec_helper'
 
 describe ApplixHash do
   it 'parses dashed string options' do
-    (ApplixHash.parse '--foo-bar').should == ["foo-bar".to_sym, true]
-    (ApplixHash.parse '--foo-bar=321').should == ["foo-bar".to_sym, '321']
+    #(ApplixHash.parse '--foo-bar').should == ["foo-bar".to_sym, true]
+    expect(ApplixHash.parse '--foo-bar').to eq(["foo-bar".to_sym, true])
+    #(ApplixHash.parse '--foo-bar=321').should == ["foo-bar".to_sym, '321']
+    expect(ApplixHash.parse '--foo-bar=321').to eq(["foo-bar".to_sym, '321'])
   end
 
   it "parses the old unit test..." do
     #   -f                becomes { :f      => true }
     #   --flag            becomes { :flag   => true }
-    (ApplixHash.parse '-f').should == [:f, true]
-    (ApplixHash.parse '--flag').should == [:flag, true]
+    expect(ApplixHash.parse '-f').to eq([:f, true])
+    expect(ApplixHash.parse '--flag').to eq([:flag, true])
     #   --flag:false      becomes { :flag   => false }
-    (ApplixHash.parse '--flag:false').should == [:flag, false]
+    expect(ApplixHash.parse '--flag:false').to eq([:flag, false])
 
     #   --option=value    becomes { :option => "value" }
-    (ApplixHash.parse '--opt=val').should == [:opt, 'val']
+    expect(ApplixHash.parse '--opt=val').to eq([:opt, 'val'])
   end
 end

data/spec/applix_spec.rb

@@ -4,28 +4,28 @@ describe Applix do
 
   context 'main' do
     it 'catches unknown task errors' do 
-      expect { Applix.main(%w(no-such-task)) {} }.not_to raise_error
+      expect { Applix.main(%w(0no-such-task)) {} }.not_to raise_error
     end
 
     context 'with captured I/O streams' do
       it 'prints a minimal (better than nothing?) usage line on errors' do 
-        output = capture(:stdout) { Applix.main(%w(no-such-task)) {} }
-        output.should =~ /usage: /
+        output = capture(:stdout) { Applix.main(%w(1no-such-task)) {} }
+        expect(output).to match(/usage: /)
       end
 
       it 'suppresses the callstack on errors' do 
-        output = capture(:stdout) { Applix.main(%w(no-such-task)) {} }
-        output.should     =~ / ## no such task:/
-        output.should_not =~ / !! no such task:/
+        output = capture(:stdout) { Applix.main(%w(expected-task-error-output)) {} }
+        expect(output).to match(/ ## no such task:/)
+        expect(output).not_to match(/ !! no such task:/)
       end
 
       it 'shows callstack on --debug option' do 
-        output = capture(:stdout) { Applix.main(%w(--debug no-such-task)) {} }
-        output.should =~ / !! no such task:/
+        output = capture(:stdout) { Applix.main(%w(--debug 2no-such-task)) {} }
+        expect(output).to match(/ !! no such task:/)
       end
 
       it 'dumps a stacktrace on main with a !' do 
-        expect { Applix.main!(%w(no-such-task)) {} }.
+        expect { Applix.main!(%w(3no-such-task)) {} }.
           to raise_error /no such task:/
       end
     end
@@ -46,7 +46,7 @@ describe Applix do
     end
 
     it 'calls cluster prolog' do
-      Applix.main(%w(foo a b)) do
+      expect(Applix.main(%w(foo a b)) do
         cluster(:foo) do
           prolog { |args, options|
             args.should == %w(a b)
@@ -55,12 +55,12 @@ describe Applix do
           handle(:a) { raise 'should not be called!' }
           handle(:b) { :b_was_called }
         end
-      end.should == :b_was_called
+      end).to be(:b_was_called)
     end
 
     it 'support :cluster for nesting' do
       args = %w(-a -b:2 foo bar p1 p2)
-      Applix.main(args) do
+      expect(Applix.main(args) do
         handle(:foo) do
           raise 'should not be called!'
         end
@@ -71,12 +71,12 @@ describe Applix do
             args
           end
         end
-      end.should == %w{p1 p2}
+      end).to eq(%w{p1 p2})
     end
 
     it 'can even cluster clusters' do
       args = %w(foo bar f p1 p2)
-      Applix.main(args) do
+      expect(Applix.main(args) do
         cluster(:foo) do
           cluster(:bar) do
             handle(:f) do |*args, options|
@@ -86,36 +86,58 @@ describe Applix do
             end
           end
         end
-      end.should == %w{p1 p2}
+      end).to eq(%w{p1 p2})
     end
   end #.cluster
 
-  it 'prolog can even temper with arguments to modify the handle sequence' do
-    Applix.main(['a', 'b']) do
-      prolog { |args, options|
-        args.should == ['a', 'b']
-        args.reverse!
-      }
-      handle(:a) { raise 'should not be called!' }
-      handle(:b) { :b_was_called }
-    end.should == :b_was_called
-  end
+  context 'prolog invokations' do
+    it 'prolog can even temper with arguments to modify the handle sequence' do
+      expect(Applix.main(['a', 'b']) do
+        prolog { |args, options|
+          args.should == ['a', 'b']
+          args.reverse!
+        }
+        handle(:a) { raise 'should not be called!' }
+        handle(:b) { :b_was_called }
+      end).to eq(:b_was_called)
+    end
 
-  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
-      }
+    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 be_nil
+    end
 
-      handle(:func) { |*_, options|
-        options[:prolog]
-      }
-    end.should_not == nil
+    it 'runs before callback before handle calls' do
+      expect(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).to eq([:prolog, nil])
+    end
   end
 
   it 'epilog has access to task handler results' do
-    Applix.main(['func']) do
+    expect(Applix.main(['func']) do
       # @epilog will NOT make it into the handle invocation
       epilog { |rc, *_|
         rc.should == [1, 2, 3]
@@ -123,27 +145,7 @@ describe Applix do
       }
       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).to eq([3, 2, 1])
   end
 
   it 'runs epilog callback after handle' do
@@ -160,7 +162,7 @@ describe Applix do
         last_action = :handle
       }
     end
-    last_action.should == :epilog
+    expect(last_action).to be(:epilog)
   end
 
   it 'supports :any as fallback on command lines without matching task' do
@@ -194,46 +196,63 @@ describe Applix do
     end
   end
 
-  it 'loops over args with argsloop app option to any' do
-    # stubbed app simulates consuming the args while looping over app calls
-    app = double(:app)
-    app.should_receive(:a).with(%w(1 b 2 3 c 4 5 6), {}).and_return(%w(b 2 3))
-    app.should_receive(:b).with(%w(2 3), {}).and_return(%w(c 4 5 6))
-    app.should_receive(:c).with(%w(4 5 6), {}).and_return([])
-    Applix.main(%w(a 1 b 2 3 c 4 5 6)) do
-      handle(:not_called) { raise "can't possible happen" }
-      any(argsloop: app)
+  describe 'any with argsloop' do
+    it 'loops over args' do
+      # stubbed app simulates consuming the args while looping over app calls
+      app = double(:app)
+      #app.should_receive(:op1).with(%w(p1 op2 2 3 op3 4 5 6), {}).and_return(%w(op2 2 3))
+      expect(app).to receive(:op1).with(%w(p1 op2 2 3 op3 4 5 6), {}).and_return(%w(op2 2 3))
+      #app.should_receive(:op2).with(%w(2 3), {}).and_return(%w(op3 4 5 6))
+      expect(app).to receive(:op2).with(%w(2 3), {}).and_return(%w(op3 4 5 6))
+      #app.should_receive(:op3).with(%w(4 5 6), {}).and_return([])
+      expect(app).to receive(:op3).with(%w(4 5 6), {}).and_return([])
+      Applix.main(%w(op1 p1 op2 2 3 op3 4 5 6)) do
+        handle(:not_called) { raise "can't possible happen" }
+        any(argsloop: app)
+      end
+    end
+
+    it 'instantiates a class instance' do
+      obj = double(:obj)
+      clazz = Class.new
+      expect(clazz).to receive(:new).with({o: true}).and_return(obj)
+      expect(obj).to receive(:p).with('a1', 'a2').and_return([])
+      Applix.main(%w(-o p a1 a2)) do
+        handle(:not_called) { raise "can't possible happen" }
+        any(argsloop: clazz)
+      end
     end
   end
 
   it 'should call actions by first argument names' do
     argv = ['func']
-    Applix.main(argv) do
+    expect(Applix.main(argv) do
       handle(:func) { :func_return }
-    end.should == :func_return
+    end).to be(:func_return)
   end
 
   it 'passes arguments to function' do
     argv = ['func', 'p1', 'p2']
     subject = Applix.main(argv) { handle(:func) {|*args, options| args} }
-    subject.should eq(%w(p1 p2))
+    expect(subject).to eq(%w(p1 p2))
   end
 
   it 'passes a default options hash to function' do
     argv = %w(func)
-    Applix.main(argv) do
+    expect(Applix.main(argv) do
       handle(:func) { |*_, options| options }
-    end.should eq({})
+    end).to eq({})
   end
 
   it 'should pass a processed options hash' do
     argv = %w(-a --bar func)
-    Applix.main(argv) do
+    expect(Applix.main(argv) do
       handle(:func) { |*_, options| options }
-    end.should include(:a => true, :bar => true)
+    end).to include(:a => true, :bar => true)
   end
 
   pending 'parses dashes in string options' do
+    fail '?'
   end
   
   it "should parse the old unit test..." do
@@ -244,22 +263,22 @@ describe Applix do
     #   --float=2.3       becomes { :float  => "2.3" }
     #   --float:2.3       becomes { :float  => 2.3 }
     #   -f:1.234          becomes { :f      => 1.234 }
-    (Hash.from_argv ["--int=1"])[:int].should == "1"
-    (Hash.from_argv ["--int:1"])[:int].should == 1
-    (Hash.from_argv ["--float=2.3"])[:float].should == "2.3"
-    (Hash.from_argv ["--float:2.3"])[:float].should == 2.3
-    (Hash.from_argv ["-f:2.345"])[:f].should == 2.345
+    expect((Hash.from_argv ["--int=1"])[:int]).to eq("1")
+    expect((Hash.from_argv ["--int:1"])[:int]).to eq(1)
+    expect((Hash.from_argv ["--float=2.3"])[:float]).to eq("2.3")
+    expect((Hash.from_argv ["--float:2.3"])[:float]).to eq(2.3)
+    expect((Hash.from_argv ["-f:2.345"])[:f]).to eq(2.345)
 
     #   --txt="foo bar"   becomes { :txt    => "foo bar" }
     #   --txt:'"foo bar"' becomes { :txt    => "foo bar" }
     #   --txt:%w{foo bar} becomes { :txt    => ["foo", "bar"] }
-    (Hash.from_argv ['--txt="foo bar"'])[:txt].should == "foo bar"
-    (Hash.from_argv [%q|--txt:'"foo bar"'|])[:txt].should == "foo bar"
-    (Hash.from_argv [%q|--txt:'%w{foo bar}'|])[:txt].should == ["foo", "bar"]
+    expect((Hash.from_argv ['--txt="foo bar"'])[:txt]).to eq("foo bar")
+    expect((Hash.from_argv [%q|--txt:'"foo bar"'|])[:txt]).to eq("foo bar")
+    expect((Hash.from_argv [%q|--txt:'%w{foo bar}'|])[:txt]).to eq(["foo", "bar"])
 
     #   --now:Time.now    becomes { :now    => Mon Jul 09 01:30:21 0200 2007 }
     #dt = Time.now - H.parse("--now:Time.now")[1]
-    (t = (Hash.from_argv ["--now:Time.now"])[:now]).should_not == nil
+    expect((t = (Hash.from_argv ["--now:Time.now"])[:now])).to be
   end
 end
 

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 #require 'rspec/mocks'
 require 'applix'
 require 'applix/oattr'
+require 'byebug'
 
 RSpec.configure do |config|
   config.before :each do
@@ -11,6 +12,13 @@ RSpec.configure do |config|
 
   config.after :each do
   end
+
+  # disable $crux debug flag after each test
+  config.after(:each) { $crux = false }
+
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
 end
 
 # captures standard output streams to help testing console I/O

metadata

@@ -1,111 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: applix
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - art+com/dirk luesebrink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-23 00:00:00.000000000 Z
+date: 2015-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-mocks
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: debugger
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: "\n    ApplixHash#from_argv builds hashes from ARGV like argument vectors\n
@@ -127,11 +127,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .autotest
-- .document
-- .gitignore
-- .rspec
-- .travis.yml
+- ".autotest"
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -155,17 +155,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: extracting typed option hashes from command line arguments