voke 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Luke Curley
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Voke
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'voke'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install voke
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/arguments.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'voke'
+
+class Arguments
+  include Voke
+
+  default :greet, "world"
+  default :excited do |options|
+    options[:greet] == "world"
+  end
+
+  def list(*args, options)
+    puts "arguments: #{ args.inspect }"
+    puts "options: #{ options.inspect }"
+  end
+end
+
+Arguments.new.voke("list", *ARGV)

data/examples/hello_world.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+require 'voke'
+
+class HelloWorld
+  include Voke
+
+  def hello(name = "world", options)
+    puts "hello #{ name }"
+  end
+end
+
+test = HelloWorld.new
+test.voke("hello", *ARGV)

data/lib/voke.rb

@@ -0,0 +1,158 @@
+require "voke/version"
+
+module Voke
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  def self.extended(klass)
+    klass.extend(ClassMethods)
+  end
+
+  def help(command, *args)
+    command = command.to_sym rescue nil
+
+    if command and respond_to?(command)
+      methods = [ command ]
+    else
+      methods = self.class.public_instance_methods(false)
+    end
+
+    methods.each do |method_name|
+      method = self.method(method_name)
+      parameters = method.parameters
+
+      # remove the options parameter
+      parameters.pop
+
+      parts = parameters.collect do |type, name|
+        case type
+        when :req
+          name
+        when :opt
+          "[#{ name }]"
+        when :part
+          "#{ name }*"
+        end
+      end
+    end
+  end
+
+  def voke(*args)
+    args = ARGV if args.empty?
+
+    command, arguments, options = voke_parse(*args)
+    voke_call(command, arguments, options)
+  end
+
+  def voke_call(command, arguments, options)
+    begin
+      method = method(command.to_sym)
+    rescue
+      return help(command, *arguments, options)
+    end
+
+    method.call(*arguments, options)
+  end
+
+  def voke_parse(*args)
+    command = args.shift
+    arguments = Array.new
+    options = Hash.new
+
+    args.each do |arg|
+      if arg =~ /^--(\w+)(?:=(.*))?$/
+        key = $1.to_sym
+
+        value = true
+        value = voke_parse_value($2) if $2
+
+        options[key] = value
+      else
+        key = nil
+        value = voke_parse_value(arg)
+
+        arguments << value
+      end
+    end
+
+    [ command, arguments, options ]
+  end
+
+  def voke_parse_value(value)
+    case value
+    when "", "nil"
+      nil
+    when "true"
+      true
+    when "false"
+      false
+    when /^-?\d+$/
+      value.to_i
+    when /^-?\d*\.\d*$/
+      value.to_f
+    when /^['"](.+)['"]$/
+      $1
+    when /^(.*),(.*)$/
+      value = value.split(',')
+      value.collect { |v| voke_parse_value(v) }
+    else
+      value
+    end
+  end
+
+  module ClassMethods
+    def voke_config(name)
+      @voke_config ||= Hash.new
+      @voke_config[name] ||= { :defaults => Hash.new }
+    end
+
+    def description(method = :voke_next, string)
+      config = voke_config(method)
+      config[:description] = string
+    end
+
+    def default(*args, &block)
+      value = block || args.pop
+      argument = args.pop
+      method = args.pop || :voke_next
+
+      config = voke_config(method)
+      config[:defaults][argument] = value
+    end
+
+    def method_added(method)
+      config = voke_config(method)
+
+      return if config[:added]
+      return if not public_method_defined?(method)
+
+      config[:added] = true
+
+      if next_config = @voke_config.delete(:voke_next)
+        config[:description] ||= next_config[:description]
+        config[:defaults] = next_config[:defaults].merge(config[:defaults])
+      end
+
+      orig_method = instance_method(method)
+
+      define_method(method) do |*args, &block|
+        if args.last.is_a?(Hash)
+          options = args.pop
+
+          config = self.class.voke_config(method)
+          config[:defaults].each do |key, value|
+            unless options[key]
+              value = value.call(options) if value.is_a?(Proc) or value.is_a?(Method)
+              options[key] = value
+            end
+          end
+
+          args.push(options)
+        end
+
+        orig_method.bind(self).call(*args, &block)
+      end
+    end
+  end
+end

data/lib/voke/version.rb

@@ -0,0 +1,3 @@
+module Voke
+  VERSION = "0.0.1"
+end

data/test/voke_test.rb

@@ -0,0 +1,290 @@
+require "minitest/autorun"
+
+require "bundler/setup"
+require "voke"
+
+class TestVoke
+  include Voke
+end
+
+describe Voke do
+  describe ".voke_parse" do
+    def voke_parse(*args)
+      TestVoke.new.voke_parse(*args)
+    end
+
+    it "parses empty values on empty" do
+      result = voke_parse()
+      result.must_equal [ nil, [], {} ]
+    end
+
+    it "parses the command" do
+      result = voke_parse("foo")
+      result.must_equal [ "foo", [], {} ]
+    end
+
+    it "parses the command and arguments" do
+      result = voke_parse("foo", "bar", "world")
+      result.must_equal [ "foo", [ "bar", "world" ], {} ]
+    end
+
+    it "parses nils in arguments" do
+      result = voke_parse("foo", "nil")
+      result.must_equal [ "foo", [ nil ], {} ]
+    end
+
+    it "parses booleans in arguments" do
+      result = voke_parse("foo", "true", "false")
+      result.must_equal [ "foo", [ true, false ], {} ]
+    end
+
+    it "parses integers in arguments" do
+      result = voke_parse("foo", "4", "-3")
+      result.must_equal [ "foo", [ 4, -3 ], {} ]
+    end
+
+    it "parses floats in arguments" do
+      result = voke_parse("foo", "1.2", ".67", "-5.76", "-.5")
+      result.must_equal [ "foo", [ 1.2, 0.67, -5.76, -0.5 ], {} ]
+    end
+
+    it "parses quoted strings in arguments" do
+      result = voke_parse("foo", "'4'", "\"hamburger,fries\"")
+      result.must_equal [ "foo", [ "4", "hamburger,fries" ], {} ]
+    end
+
+    it "parses arrays in arguments" do
+      result = voke_parse("foo", "hamburger,fries", ",")
+      result.must_equal [ "foo", [ [ "hamburger", "fries" ], [] ], {} ]
+    end
+
+    it "parses values inside arrays in arguments" do
+      result = voke_parse("foo", "-4,false,\"nil\",0.76")
+      result.must_equal [ "foo", [ [ -4, false, "nil", 0.76 ] ], {} ]
+    end
+
+    it "parses the command and options" do
+      result = voke_parse("foo", "--hello=world")
+      result.must_equal [ "foo", [], { :hello => "world" } ]
+    end
+
+    it "parses the command, arguments, and options" do
+      result = voke_parse("foo", "--hello=world", "bar", "--apple=fruit")
+      result.must_equal [ "foo", [ "bar" ], { :hello => "world", :apple => "fruit" } ]
+    end
+
+    it "defaults to true in options" do
+      result = voke_parse("foo", "--hello")
+      result.must_equal [ "foo", [], { :hello => true } ]
+    end
+
+    it "parses nils in options" do
+      result = voke_parse("foo", "--hello=", "--world=nil")
+      result.must_equal [ "foo", [], { :hello => nil, :world => nil } ]
+    end
+
+    it "parses booleans in options" do
+      result = voke_parse("foo", "--hello=true", "--goodbye=false")
+      result.must_equal [ "foo", [], { :hello => true, :goodbye => false } ]
+    end
+
+    it "parses integers in options" do
+      result = voke_parse("foo", "--foo=4", "--bar=-3")
+      result.must_equal [ "foo", [], { :foo => 4, :bar => -3 } ]
+    end
+
+    it "parses floats in options" do
+      result = voke_parse("foo", "--foo=1.2", "--bar=.67", "--hello=-5.76", "--world=-.5")
+      result.must_equal [ "foo", [], { :foo => 1.2, :bar => 0.67, :hello => -5.76, :world => -0.5 } ]
+    end
+
+    it "parses quoted strings in options" do
+      result = voke_parse("foo", "--foo='4'", "--bar=\"hamburger,fries\"")
+      result.must_equal [ "foo", [], { :foo => "4", :bar => "hamburger,fries" } ]
+    end
+
+    it "parses arrays in options" do
+      result = voke_parse("foo", "--foo=hamburger,fries")
+      result.must_equal [ "foo", [], { :foo => [ "hamburger", "fries" ] } ]
+    end
+
+    it "parses values inside arrays in arguments" do
+      result = voke_parse("foo", "--foo=-4,false,\"nil\",0.76")
+      result.must_equal [ "foo", [], { :foo => [ -4, false, "nil", 0.76 ] } ]
+    end
+  end
+
+  describe ".voke_call" do
+    # some helpers to make results more obvious
+    ARG1 = :arg1
+    ARG2 = :arg2
+    ARG3 = :arg3
+    OPTIONS = { :option1 => 1, :option2 => 2 }
+
+    def voke_call(method, *args)
+      TestVoke.new.voke_call(method, args, OPTIONS)
+    end
+
+    describe "zero option definition" do
+      class TestVoke
+        def m0;[];end
+      end
+
+      it "calls with no arguments" do
+        lambda { voke_call(:m0) }.must_raise ArgumentError
+      end
+
+      it "calls with one argument" do
+        lambda { voke_call(:m0, ARG1) }.must_raise ArgumentError
+      end
+    end
+
+    describe "one option definition" do
+      class TestVoke
+        def m1(a);[a];end
+        def m2(a=nil);[a];end
+        def n1(*a);a;end
+      end
+
+      it "calls with no arguments" do
+        voke_call(:m1).must_equal [ OPTIONS ]
+        voke_call(:m2).must_equal [ OPTIONS ]
+        voke_call(:n1).must_equal [ OPTIONS ]
+      end
+
+      it "calls with one argument" do
+        lambda { voke_call(:m1, ARG1) }.must_raise ArgumentError
+        lambda { voke_call(:m2, ARG1) }.must_raise ArgumentError
+        voke_call(:n1, ARG1).must_equal [ ARG1, OPTIONS ]
+      end
+
+      it "calls with two arguments" do
+        lambda { voke_call(:m1, ARG1, ARG2) }.must_raise ArgumentError
+        lambda { voke_call(:m2, ARG1, ARG2) }.must_raise ArgumentError
+        voke_call(:n1, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+      end
+    end
+
+    describe "two option definition" do
+      class TestVoke
+        def m3(a,b);[a,b];end
+        def m4(a,b=nil);[a,b];end
+        def m5(a=nil,b);[a,b];end
+        def m6(a=nil,b=nil);[a,b];end
+
+        def n2(a,*b);[a]+b;end
+        def n3(a=nil,*b);[a]+b;end
+        def n4(*a,b);a+[b];end
+        #def n5(*a,b=nil);a+[b];end # does not exist
+      end
+
+      it "calls with no arguments" do
+        lambda { voke_call(:m3) }.must_raise ArgumentError
+        voke_call(:m4).must_equal [ OPTIONS, nil ]
+        voke_call(:m5).must_equal [ nil, OPTIONS ]
+        voke_call(:m6).must_equal [ OPTIONS, nil ]
+
+        voke_call(:n2).must_equal [ OPTIONS ]
+        voke_call(:n3).must_equal [ OPTIONS ]
+        voke_call(:n4).must_equal [ OPTIONS ]
+      end
+
+      it "calls with one argument" do
+        voke_call(:m3, ARG1).must_equal [ ARG1, OPTIONS ]
+        voke_call(:m4, ARG1).must_equal [ ARG1, OPTIONS ]
+        voke_call(:m5, ARG1).must_equal [ ARG1, OPTIONS ]
+        voke_call(:m6, ARG1).must_equal [ ARG1, OPTIONS ]
+
+        voke_call(:n2, ARG1).must_equal [ ARG1, OPTIONS ]
+        voke_call(:n3, ARG1).must_equal [ ARG1, OPTIONS ]
+        voke_call(:n4, ARG1).must_equal [ ARG1, OPTIONS ]
+      end
+
+      it "calls with two arguments" do
+        lambda { voke_call(:m3, ARG1, ARG2) }.must_raise ArgumentError
+        lambda { voke_call(:m4, ARG1, ARG2) }.must_raise ArgumentError
+        lambda { voke_call(:m5, ARG1, ARG2) }.must_raise ArgumentError
+        lambda { voke_call(:m6, ARG1, ARG2) }.must_raise ArgumentError
+
+        voke_call(:n2, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:n3, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:n4, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+      end
+    end
+
+    describe "three option definition" do
+      class TestVoke
+        def m7(a,b,c);[a,b,c];end
+        def m8(a,b,c=nil);[a,b,c];end
+        def m9(a,b=nil,c);[a,b,c];end
+        def m10(a,b=nil,c=nil);[a,b,c];end
+        def m11(a=nil,b,c);[a,b,c];end
+        #def m12(a=nil,b,c=nil);[a,b,c];end # does not exist
+        def m12(a=nil,b=nil,c);[a,b,c];end
+        def m13(a=nil,b=nil,c=nil);[a,b,c];end
+
+        def n5(a,b,*c);[a,b]+c;end
+        def n6(a,*b,c);[a]+b+[c];end
+        def n7(*a,b,c);a+[b,c];end
+      end
+
+      it "calls with no arguments" do
+        lambda { voke_call(:m7) }.must_raise ArgumentError
+        lambda { voke_call(:m8) }.must_raise ArgumentError
+        lambda { voke_call(:m9) }.must_raise ArgumentError
+        voke_call(:m10).must_equal [ OPTIONS, nil, nil ]
+        lambda { voke_call(:m11) }.must_raise ArgumentError
+        voke_call(:m12).must_equal [ nil, nil, OPTIONS ]
+        voke_call(:m13).must_equal [ OPTIONS, nil, nil ]
+
+        lambda { voke_call(:n5) }.must_raise ArgumentError
+        lambda { voke_call(:n6) }.must_raise ArgumentError
+        lambda { voke_call(:n7) }.must_raise ArgumentError
+      end
+
+      it "calls with one argument" do
+        lambda { voke_call(:m7, ARG1) }.must_raise ArgumentError
+        voke_call(:m8, ARG1).must_equal [ ARG1, OPTIONS, nil ]
+        voke_call(:m9, ARG1).must_equal [ ARG1, nil, OPTIONS ]
+        voke_call(:m10, ARG1).must_equal [ ARG1, OPTIONS, nil ] # not ideal
+        #voke_call(:m10, ARG1).must_equal [ ARG1, nil, OPTIONS ]
+        voke_call(:m11, ARG1).must_equal [ nil, ARG1, OPTIONS ]
+        voke_call(:m12, ARG1).must_equal [ ARG1, nil, OPTIONS ]
+        voke_call(:m13, ARG1).must_equal [ ARG1, OPTIONS, nil ] # not ideal
+        #voke_call(:m13, ARG1).must_equal [ ARG1, nil, OPTIONS ]
+
+        lambda { voke_call(:n5) }.must_raise ArgumentError
+        lambda { voke_call(:n6) }.must_raise ArgumentError
+        lambda { voke_call(:n7) }.must_raise ArgumentError
+      end
+
+      it "calls with two arguments" do
+        voke_call(:m7, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m8, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m9, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m10, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m11, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m12, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:m13, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+
+        voke_call(:n5, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:n6, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+        voke_call(:n7, ARG1, ARG2).must_equal [ ARG1, ARG2, OPTIONS ]
+      end
+
+      it "calls with three arguments" do
+        lambda { voke_call(:m7, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m8, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m9, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m10, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m11, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m12, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+        lambda { voke_call(:m13, ARG1, ARG2, ARG3) }.must_raise ArgumentError
+
+        voke_call(:n5, ARG1, ARG2, ARG3).must_equal [ ARG1, ARG2, ARG3, OPTIONS ]
+        voke_call(:n6, ARG1, ARG2, ARG3).must_equal [ ARG1, ARG2, ARG3, OPTIONS ]
+        voke_call(:n7, ARG1, ARG2, ARG3).must_equal [ ARG1, ARG2, ARG3, OPTIONS ]
+      end
+    end
+  end
+end

data/voke.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'voke/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "voke"
+  gem.version       = Voke::VERSION
+  gem.authors       = ["Luke Curley"]
+  gem.email         = ["qpingu@gmail.com"]
+  gem.description   = %q{Minimal CLI}
+  gem.summary       = %q{Minimal CLI}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: voke
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Luke Curley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Minimal CLI
+email:
+- qpingu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/arguments.rb
+- examples/hello_world.rb
+- lib/voke.rb
+- lib/voke/version.rb
+- test/voke_test.rb
+- voke.gemspec
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Minimal CLI
+test_files:
+- test/voke_test.rb