clive 0.2.3 → 0.3.0

data/lib/clive/exceptions.rb

@@ -0,0 +1,48 @@
+class Clive
+  
+  # general problem
+  class CliveError < StandardError
+    attr_accessor :args
+    
+    def initialize(*args)
+      @args = args
+    end
+    
+    def self.filter_backtrace(array)
+      unless $DEBUG
+        array = [$0]
+      end
+      array
+    end
+    
+    def set_backtrace(array)
+      super(self.class.filter_backtrace(array))
+    end
+    
+    def message
+      self.reason + ': ' + args.join(' ')
+    end
+    alias_method :to_s, :message
+  
+  end
+  
+  # general problem with input
+  class ParseError < CliveError
+    def reason; "parse error"; end
+  end
+  
+  # a flag has a missing argument
+  class MissingArgument < ParseError
+    def reason; "missing argument"; end
+  end
+  
+  # a option that wasn't defined has been found
+  class InvalidOption < ParseError
+    def reason; "invalid option"; end
+  end
+  
+  class MissingLongName < CliveError
+    def reason; "missing long name"; end
+  end
+  
+end

data/lib/clive/ext.rb

@@ -2,24 +2,15 @@ class Clive
 
   class Array < ::Array
     
-    # If passed a Symbol or String will get the item with that name,
-    # checks #long and #short if available or #name. Otherwise does 
-    # what you expect of an Array (see Array#[])
+    # If passed a Symbol or String will get the item with that name.
+    # Otherwise does what you expect of an Array (see ::Array#[])
     #
     # @param [Symbol, String, Integer, Range] val name or index of item to return
     # @return the item that has been found
     def [](val)
       val = val.to_s if val.is_a? Symbol
       if val.is_a? String
-        if self[0].respond_to?(:name)
-          self.find_all {|i| i.name == val}[0]
-        elsif self[0].respond_to?(:long) 
-          if val.length == 1
-            self.find_all {|i| i.short == val}[0]
-          else
-            self.find_all {|i| i.long == val}[0]
-          end
-        end
+        self.find_all {|i| i.names.include?(val)}[0]
       else
         super
       end

data/lib/clive/flag.rb

@@ -0,0 +1,71 @@
+class Clive
+  
+  # A switch that takes an argument, with or without an equals
+  #   eg. wget --tries=10
+  #       wget -t 10
+  #
+  class Flag < Option
+    attr_accessor :arg_name, :optional
+        
+    # Creates a new Flag instance.
+    #
+    # +short+ _or_ +long+ can be omitted but not both.
+    #
+    # @overload flag(short, long, desc, &block)
+    #   Creates a new flag
+    #   @param [Symbol] short single character for short flag, eg. +:t+ => +-t 10+
+    #   @param [Symbol] long longer switch to be used, eg. +:tries+ => +--tries=10+
+    #   @param [String] desc the description for the flag
+    #
+    # @yield [String] A block to be run if switch is triggered
+    #
+    def initialize(*args, &block)
+      @names    = []
+      @optional = false
+      @arg_name = "ARG"
+      
+      args.each do |i|
+        if i.is_a? String
+          if i =~ /^[\[\]A-Z0-9]+$/
+            @arg_name = i
+          else
+            @desc = i
+          end
+        else
+          @names << i.to_s
+        end
+      end
+      
+      if @arg_name[0] == "["
+        @arg_name = @arg_name[1..@arg_name.length-2]
+        @optional = true
+      end
+
+      @block = block
+    end
+    
+    # Runs the block that was given with an argument
+    #
+    # @param [String] arg argument to pass to the block
+    def run(arg)
+      @block.call(arg)
+    end
+    
+    # @return [String] summary for help
+    def summary(width=30, prepend=5)
+      n = names_to_strings.join(', ')
+      if @optional
+        n << " [#{@arg_name}]"
+      else
+        n << " #{@arg_name}"
+      end
+      
+      spaces = width-n.length
+      spaces = 1 if spaces < 1
+      s = spaces(spaces)
+      p = spaces(prepend)
+      "#{p}#{n}#{s}#{@desc}"
+    end
+    
+  end
+end

data/lib/clive/option.rb

@@ -0,0 +1,77 @@
+class Clive
+  
+  class Option
+    attr_accessor :names, :desc, :block
+    
+    def initialize(desc, *names, &block)
+      @names = names
+      @desc = desc
+      @block = block
+    end
+    
+    def run
+      @block.call
+    end
+    
+    def summary(width=30, prepend=5)
+      n = names_to_strings.join(', ')
+      spaces = width-n.length
+      spaces = 1 if spaces < 1
+      s = spaces(spaces)
+      p = spaces(prepend)
+      "#{p}#{n}#{s}#{@desc}"
+    end
+    
+    # Convert the names to strings, depending on length
+    #
+    # @param [Boolean] bool whether to add [no-] to long
+    #
+    # @example
+    #
+    #   @names = ['v', 'verbose']
+    #   names_to_strings
+    #   #=> ['-v', '--verbose']
+    #
+    def names_to_strings(bool=false)
+      r = []
+      @names.each do |i|
+        next if i.nil?
+        if i.length == 1 # short
+          r << "-#{i}"
+        else # long
+          if bool
+            r << "--[no-]#{i}"
+          else
+            r << "--#{i}"
+          end
+        end
+      end
+      r
+    end
+    
+    # Create a string of +n+ spaces
+    def spaces(n)
+      s = ''
+      (0...n).each {s << ' '}
+      s
+    end
+    
+    # Tries to get the short name, if not choose lowest alphabetically
+    #
+    # @return [String] name to sort by
+    def sort_name
+      r = @names.sort[0]
+      @names.each do |i|
+        if i.length == 1
+          r = i
+        end
+      end
+      r
+    end
+    
+    def <=>(other)
+      self.sort_name <=> other.sort_name
+    end
+  
+  end
+end

data/lib/clive/switch.rb

@@ -0,0 +1,40 @@
+class Clive
+  
+  # A string that takes no argument, beginning with one or two dashes
+  #   eg. ruby --version
+  #       ruby -v
+  #
+  class Switch < Option
+      
+    # Create a new Switch instance.
+    #
+    # +short+ _or_ +long+ may be omitted but not both.
+    #
+    # @overload switch(short, long, desc, &block)
+    #   Creates a new switch
+    #   @param [Symbol] short single character for short switch, eg. +:v+ => +-v+
+    #   @param [Symbol] long longer switch to be used, eg. +:verbose+ => +--verbose+
+    #   @param [String] desc the description for the switch
+    #
+    # @yield A block to run if the switch is triggered
+    #
+    def initialize(*args, &block)
+      @names = []
+      args.each do |i|
+        case i
+        when Symbol
+          @names << i.to_s
+        when String
+          @desc = i
+        end
+      end
+      @block = block
+    end
+    
+    # Runs the block that was given
+    def run
+      @block.call
+    end
+    
+  end
+end

data/lib/clive/tokens.rb

@@ -17,7 +17,7 @@ class Clive
     # Create a new Tokens instance. Pass either an array of tokens
     # or a plain array, they will be converted correctly.
     #
-    # @param [Array]
+    # @param [::Array]
     # @return [Tokens]
     #
     def initialize(args=[])
@@ -32,7 +32,7 @@ class Clive
     # Turn +@tokens+ into an array, this ensures that shorts are split
     # as is expected
     #
-    # @return [Array] array representation of tokens held
+    # @return [::Array] array representation of tokens held
     def array
       return [] unless self.tokens
       arr = []
@@ -53,7 +53,7 @@ class Clive
     
     # Creates an array of tokens based on +self+
     #
-    # @return [Array] the tokens that are held
+    # @return [::Array] the tokens that are held
     def tokens
       t = []
       self.each do |i|
@@ -97,7 +97,7 @@ class Clive
     
     # Test whether an array is a token
     #
-    # @param [Array]
+    # @param [::Array]
     # @return [Boolean]
     #
     # @example

data/test/bin_test

@@ -9,15 +9,23 @@ c = Clive.new do
     options[:verbose] = true
   }
   
-  flag(:t, :type, "Type to choose") {
-    p "hi"
-  }
+  flag(:t, :type, "TYPE", "Change type to TYPE") do |i|
+    options[:type] = i
+  end
   
   flag(:long_only, "A flag with only a long") {}
   
+  flag(:p, :print, "[TEXT]", "Print TEXT, defaults to 'hey'") do |i|
+    i ||= 'hey'
+    p i
+  end
+  
+  flag(:z, :apple, "More applez") {}
+  
   command(:add, "Add something") {
     
-    p "adding stuff"
+    header "Usage: bin_test add [options]\n" +
+           "Use add to add things to add, which in turn can be added."
     
     switch(:f, :full, "Use full") {
       options[:full] = true
@@ -27,7 +35,15 @@ c = Clive.new do
     switch(:e, :empty, "Use empty") {
       options[:full] = false
     }
+    
+    footer "If the header was a little confusing, don't worry the footer thought so too."
+  
+  }
   
+  command(:remove, :delete, "Get rid of something") {
+    switch(:f, :force, "Force") {
+      p "deleting! now"
+    }   
   }
 
 end

data/test/test_boolean.rb

@@ -6,17 +6,23 @@ class TestBoolean < Test::Unit::TestCase
   
     setup do
       @c = Clive.new do
-        boolean(:v, :verbose, "Run verbosely") {|i| $stdout.puts(i)}
+        bool(:v, :verbose, "Run verbosely") {|i| puts(i)}
       end
     end
   
     should "create two switches" do
-      assert_equal 2, @c.booleans.length
+      assert_equal 2, @c.bools.length
+    end
+    
+    should "raise error when no long name given" do
+      assert_raise Clive::MissingLongName do
+        Clive::Bool.new(:v, "Run verbosely") {}
+      end
     end
     
     context "the true switch" do
       should "have a short name" do
-        assert_equal "v", @c.switches["verbose"].short
+        assert_contains @c.bools["verbose"].names, "v"
       end
       
       should "pass true to the block" do
@@ -25,13 +31,13 @@ class TestBoolean < Test::Unit::TestCase
       end
       
       should "create summary" do
-        assert_equal "-v, --[no-]verbose Run verbosely", @c.switches["verbose"].summary(0, 0)
+        assert_equal "-v, --[no-]verbose Run verbosely", @c.bools["verbose"].summary(0, 0)
       end
     end
     
     context "the false switch" do
       should "not have short name" do
-        assert_equal nil, @c.switches["no-verbose"].short
+        assert_does_not_contain @c.bools["no-verbose"].names, "v"
       end
       
       should "pass false to the block" do
@@ -40,9 +46,10 @@ class TestBoolean < Test::Unit::TestCase
       end
       
       should "not create summary" do
-        assert_equal nil, @c.switches["no-verbose"].summary
+        assert_equal nil, @c.bools["no-verbose"].summary
       end
     end
   
   end
+  
 end

data/test/test_clive.rb

@@ -30,8 +30,8 @@ class TestClive < Test::Unit::TestCase
     c = Clive.new do
       boolean(:verbose) {}
     end
-    assert_equal 3, c.switches.length # plus help
-    assert_instance_of Clive::Boolean, c.switches[0]
+    assert_equal 2, c.bools.length
+    assert_instance_of Clive::Bool, c.bools[0]
   end
   
   context "When parsing input" do
@@ -216,7 +216,40 @@ class TestClive < Test::Unit::TestCase
       r = {:v => true, :add => {:full => true, :init => {:base => true, :name => 'Works'}} }
       assert_equal r, opts
     end
+    
+    should "parse the one in the readme" do
+      opts = {}
+      c = Clive.new do
+        bool(:v, :verbose, "Run verbosely") {|i| opts[:verbose] = i}
+        
+        command(:add, "Add a new project") do
+          opts[:add] = {}
+          
+          switch(:force, "Force overwrite") {opts[:add][:force] = true}
+          flag(:framework, "Add framework") do |i| 
+            opts[:add][:framework] ||= []
+            opts[:add][:framework] << i
+          end
+          
+          command(:init, "Initialize the project after creating") do
+            switch(:m, :minimum, "Use minimum settings") {opts[:add][:min] = true}
+            flag(:w, :width) {|i| opts[:add][:width] = i.to_i}
+          end
+        
+        end
+        
+        switch(:version, "Show version") do
+          puts "1.0.0"
+          exit
+        end
+      end
+      argv = %w(-v add --framework=blueprint init -m -w 200 ~/Desktop/new_thing ~/Desktop/another_thing)
+      args = c.parse(argv)
+      
+      opts_r = {:add => {:min => true, :width => 200, :framework => ["blueprint"]}, :verbose => true}
+      assert_equal opts_r, opts
+      assert_equal ["~/Desktop/new_thing", "~/Desktop/another_thing"], args
+    end
   
   end
-  
 end