clive 0.7.2 → 0.8.0

data/lib/clive.rb

@@ -1,9 +1,9 @@
 require 'ast_ast'
+require 'attr_plus'
 
 require 'clive/parser'
 require 'clive/exceptions'
 require 'clive/tokens'
-require 'clive/ext'
 
 require 'clive/option'
 require 'clive/command'
@@ -18,6 +18,8 @@ require 'clive/formatter'
 #
 # @example Simple Example
 #
+#   require 'clive'
+#
 #   class CLI
 #     include Clive::Parser
 #     

data/lib/clive/command.rb

@@ -9,6 +9,14 @@ module Clive
     attr_accessor :options, :commands
     attr_accessor :argv, :base
     attr_reader   :names, :current_desc
+    attr_reader   :top_klass
+    
+    # Create the base Command instance. Replacement for the #initialize
+    # overloading.
+    #
+    def self.setup(klass, &block)
+      new([], "", klass, &block)
+    end
     
     # Create a new Command instance
     #
@@ -23,30 +31,23 @@ module Clive
     #
     # @yield A block to run, containing switches, flags and commands
     #
-    def initialize(*args, &block)
-      @argv     = []
-      @names    = []
-      @base     = false
-      @commands = Clive::Array.new
-      @options  = Clive::Array.new
+    def initialize(names, desc, top_klass, &block)
+      @argv      = []
+      @names     = names.map {|i| i.to_s }
+      @top_klass = top_klass
+      @desc      = desc
+      @commands  = []
+      @options   = []
+      @block     = block
+      @base      = false
       
-      @option_missing = Proc.new {|e| raise NoOptionError.new(e)}
-    
-      if args.length == 1 && args[0] == true
+      if @names == [] && @desc == ""
         @base = true
         self.instance_eval(&block) if block_given?
-      else
-        args.each do |i|
-          case i
-          when ::Array
-            @names = i.map {|i| i.to_s }
-          when String
-            @desc = i
-          end
-        end
-        @block = block
       end
       
+      @option_missing = Proc.new {|e| raise NoOptionError.new(e)}
+      
       # Create basic header "Usage: filename [command] [options]
       #                  or "Usage: filename commandname(s) [options]
       @header = "Usage: #{File.basename($0, '.*')} " << 
@@ -60,19 +61,19 @@ module Clive
       self.build_help
     end
     
-    # @return [Clive::Array] all bools in this command
+    # @return [Array] all bools in this command
     def bools
-      Clive::Array.new(@options.find_all {|i| i.class == Bool})
+      @options.find_all {|i| i.class == Bool}
     end
     
-    # @return [Clive::Array] all switches in this command
+    # @return [Array] all switches in this command
     def switches
-      Clive::Array.new(@options.find_all {|i| i.class == Switch})
+      @options.find_all {|i| i.class == Switch}
     end
     
-    # @return [Clive::Array] all flags in this command
+    # @return [Array] all flags in this command
     def flags
-      Clive::Array.new(@options.find_all {|i| i.class == Flag})
+      @options.find_all {|i| i.class == Flag}
     end
     
     # Run the block that was passed to find switches, flags, etc.
@@ -87,122 +88,217 @@ module Clive
       @block = nil
     end
     
-    # Parse the ARGV passed from the command line, and run
+    # Gets the type of the option which corresponds with the name given
     #
-    # @param [::Array] argv the command line input, usually just +ARGV+
-    # @return [::Array] any arguments that were present in the input but not used
+    # @param name [String]
+    # @return [Constant]
     #
-    def run(argv=[])
-      tokens = argv
-      tokens = tokenize(argv) if @base
-      
-      r = []
-      tokens.each do |i|
-        k, v = i[0], i[1]
-        case k
-        when :command
-          r << v.run(i[2])
-        when :switch
-          v.run
-        when :flag
-          args = i[2..-1]
-          opt_args = v.arg_size(:optional)
-          nec_args = v.arg_size(:mandatory)
-          # check for missing args
-          if args.size < nec_args
-            raise MissingArgument.new(v.sort_name)
-          end
-          
-          v.run(args)
-        when :argument
-          r << v
-        end
+    def type_is?(name)
+      find_opt(name).class.name || Clive::Command
+    end
+    
+    def opt_type(name)
+      case find_opt(name).class.name
+      when "Clive::Switch"
+        :switch
+      when "Clive::Bool"
+        :switch
+      when "Clive::Flag"
+        :flag
+      when "Clive::Command"
+        :command
+      else
+        nil
       end
-      r.flatten
     end
     
-    # Turns the command line input into a series of tokens.
-    # It will only raise errors if this is the base command instance.
+    # Finds the option which has the name given
     #
-    # @param [::Array] argv the command line input
-    # @return [::Array] a series of tokens
+    # @param name [String]
+    # @return [Clive::Option]
+    #
+    def find_opt(name)
+      options.find {|i| i.names.include?(name)}
+    end
+    
+    # Checks whether the string given is the name of a Command or not
+    #
+    # @param str [String]
+    # @return [true, false]
+    #
+    def is_a_command?(str)
+      find_command(str).empty?
+    end
+    
+    # Finds the command which has the name given
+    #
+    # @param name [String]
+    # @return [Clive::Command]
+    #
+    def find_command(str)
+      commands.find {|i| i.names.include?(str)}
+    end
+    
+    # Converts the array of input from the command line into a string of tokens.
+    # It replaces instances of the names of flags, switches and bools with the 
+    # actual option, but does not affect commands. Instead these are left as +words+.
     #
     # @example
     #
-    #   c.tokenize(["add", "-al", "--verbose"])
-    #   #=> [[:command, #<Clive::Command>, ...args...], [:switch, "a", 
-    #        #<Clive::Switch>], [:switch, "l", #<Clive::Switch>], [:switch, 
-    #        "verbose", #<Clive::Switch>]]
+    #   array_to_tokens ['--switch', 'command', '-f', 'arg']
+    #   #=> [[:option, "switch"], [:word, "command"], [:option, "f"], [:word, "arg"]]
     #
-    def tokenize(argv)
-      self.find
-      r = []
-      tokens = Tokens.new(argv)
+    # @param arr [Array]
+    # @return [Array]
+    #
+    def array_to_tokens(arr)
+      result = []
       
-      pre_command = Tokens.new
-      command = nil
-      tokens.tokens.each do |i|
-        k, v = i[0], i[1]
-        # check if a command
-        if k == :word && commands[v]
-          command = v
-          break
+      arr.each do |a|
+        if a[0..1] == "--"
+          result << [:option, a[2..-1]]
+          
+        elsif a[0] == "-"
+          a[1..-1].split('').each do |i|
+            result << [:option, i]
+          end
+
         else
-          pre_command << i
+          result << [:word, a]
         end
       end
-      
-      post_command = Tokens.new(tokens.array - pre_command - [command])
-      pre_command_tokens = parse(pre_command)
-      r = pre_command_tokens
-      
-      if command
-        t = commands[command].tokenize(post_command)
-        r << [:command, commands[command], t]
-      end
-      
-      r
+
+      result 
     end
     
-    # This runs through the tokens from Tokens#to_tokens (or similar)
-    # and creates a new array with the type of object and the object
-    # itself, possibly with an argument in the case of Flag.
+    # Converts the set of tokens returned from #array_to_tokens into a tree.
+    # This is where we determine whether a +word+ is an argument or command. 
     #
-    # @param [Tokens] tokens the tokens to run through
-    # @return [::Array] of the form 
-    #   [[:flag, #<Clive::Flag...>, "word"], [:switch, #<Clive::Switch....
-    # @raise [InvalidOption] raised if option given can't be found
-    #
-    def parse(tokens)
-      r = []
-      tokens.tokens.each do |i|
-        k, v = i[0], i[1]
-        if switch = switches[v] || switch = bools[v]
-          r << [:switch, switch]
-        elsif flag = flags[v]
-          r << [:flag, flag]
-        else
-          if k == :word
-            # add to last flag?
-            if r.last && r.last[0] == :flag && r.last.size - 2 < r.last[1].arg_size(:all)
-              r.last.push(v)
+    # @example
+    #   tokens_to_tree([[:option, "switch"], [:word, "command"], 
+    #                   [:option, "f"], [:word, "arg"]])
+    #   #=> [
+    #   #     [:switch, #<Clive::Switch [switch]>],
+    #   #     [:command, #<Clive::Command [command]>, [
+    #   #       [:flag, #<Clive::Flag [f, flag]>, [
+    #   #         [:arg, 'arg']
+    #   #       ]]
+    #   #     ]]
+    #   #   ]
+    #
+    # @param arr [Array]
+    # @return [Array]
+    #
+    def tokens_to_tree(arr)
+      tree = []
+      self.find
+      
+      l = arr.size
+      i = 0
+      while i < l
+        a = arr[i]
+        
+        if a[0] == :word
+          
+          last = tree.last || []
+          
+          if last[0] == :flag
+            last[2] ||= []
+          end
+          
+          if command = find_command(a[1])
+            if last[0] == :flag              
+              if last[2].size < last[1].arg_size(:mandatory)
+                last[2] << [:arg, a[1]]
+              else
+                tree << [:command, command, command.tokens_to_tree(arr[i+1..-1])]
+                i = l
+              end
             else
-              r << [:argument, v]
+              tree << [:command, command, command.tokens_to_tree(arr[i+1..-1])]
+              i = l
             end
           else
-            @option_missing.call(v)
+            if last[0] == :flag && last[2].size < last[1].arg_size(:all)
+              last[2] << [:arg, a[1]]
+            else
+              tree << [:arg, a[1]]
+            end  
+          end
+        else
+          tree << [opt_type(a[1]), find_opt(a[1])]
+        end
+
+        i += 1
+      end
+
+      tree
+    end
+    
+    # Traverses the tree created by #tokens_to_tree and runs the correct options.
+    # 
+    # @param tree [Array]
+    # @return [Array]
+    #   Any unused arguments.
+    #
+    def run_tree(tree)
+      i = 0
+      l = tree.size
+      r = []
+      
+      while i < l
+        curr = tree[i]
+        
+        case curr[0]
+        when :command
+          r << curr[1].run(curr[2])
+          
+        when :switch
+          curr[1].run
+          
+        when :flag
+          args = curr[2].map {|i| i[1] }
+          if args.size < curr[1].arg_size(:mandatory)
+            raise MissingArgument.new(curr[1].sort_name)
           end
+          curr[1].run(args)
+          
+        when :arg
+          r << curr[1]
         end
+        
+        i += 1
+      end
+      r.flatten
+    end
+    
+    
+    # Parse the ARGV passed from the command line, and run
+    #
+    # @param [Array] argv the command line input, usually just +ARGV+
+    # @return [Array] any arguments that were present in the input but not used
+    #
+    def run(argv=[])
+      to_run = argv
+      if @base # if not base we will have been passed the parsed tree already
+        to_run = tokens_to_tree( array_to_tokens(argv) )
       end
-      r
+      run_tree(to_run)
     end
     
+    
     def to_h
       {
         'names' => @names,
         'desc'  => @desc
       }
     end
+    
+    def method_missing(sym, *args, &block)
+      if @top_klass.respond_to?(sym)
+        @top_klass.send(sym, *args)
+      end
+    end
   
     
       
@@ -219,7 +315,7 @@ module Clive
     #   and flags
     #
     def command(*args, &block)
-      @commands << Command.new(args, @current_desc, &block)
+      @commands << Command.new(args, @current_desc, @top_klass, &block)
       @current_desc = ""
     end
     
@@ -234,15 +330,15 @@ module Clive
     # @see Flag#initialize
     def flag(*args, &block)
       names = []
-      arg = []
+      arg = nil
       args.each do |i|
         if i.is_a? Symbol
           names << i
         else
           if i[:arg]
-            arg << i[:arg]
+            arg = i[:arg]
           else
-            arg << i[:args]
+            arg = i[:args]
           end
         end
       end
@@ -369,7 +465,7 @@ module Clive
     def help_formatter(*args, &block)    
       if block_given?
         width   = 30
-        prepend = 5
+        prepend = 4
       
         unless args.empty?
           args[0].each do |k,v|
@@ -388,26 +484,27 @@ module Clive
       else
         case args[0]
         when :default
-           help_formatter do |h|
-            h.switch  "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
-            h.bool    "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
-            h.flag    "{prepend}{names.join(', ')} {args.join(' ')}  {spaces}" << 
-                        "{desc.grey} {options.join('(', ', ', ')').blue.bold}"
-            h.command "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
-          end
-        
+          help_formatter(&HELP_FORMATTERS[:default])
         when :white
-          help_formatter do |h|
-            h.switch  "{prepend}{names.join(', ')}  {spaces}{desc}"
-            h.bool    "{prepend}{names.join(', ')}  {spaces}{desc}"
-            h.flag    "{prepend}{names.join(', ')} {args.join(' ')}  {spaces}" << 
-                        "{desc} {options.join('(', ', ', ')').bold}"
-            h.command "{prepend}{names.join(', ')}  {spaces}{desc}"
-          end
-        
+          help_formatter(&HELP_FORMATTERS[:white])
         end
       end
     end
     
+    HELP_FORMATTERS = {
+      :default => lambda do |h|
+        h.switch  "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
+        h.bool    "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
+        h.flag    "{prepend}{names.join(', ')} {args}  {spaces}{desc.grey} {options.blue.bold}"
+        h.command "{prepend}{names.join(', ')}  {spaces}{desc.grey}"
+      end,
+      :white => lambda do |h|
+        h.switch  "{prepend}{names.join(', ')}  {spaces}{desc}"
+        h.bool    "{prepend}{names.join(', ')}  {spaces}{desc}"
+        h.flag    "{prepend}{names.join(', ')} {args}  {spaces}{desc} {options.bold}"
+        h.command "{prepend}{names.join(', ')}  {spaces}{desc}"
+      end
+    }
+    
   end
 end

data/lib/clive/flag.rb

@@ -5,7 +5,7 @@ module Clive
   #       wget -t 10
   #
   class Flag < Option
-    attr_accessor :args
+    attr_reader :args
         
     # Creates a new Flag instance. A flag is a switch that can take one or more
     # arguments.
@@ -17,7 +17,7 @@ module Clive
     # @param desc [String]
     #   A description of the flag.
     #
-    # @param args [String, Array, Range]
+    # @param arguments [String, Array, Range]
     #   Either, a string showing the arguments to be given, eg.
     #     
     #     "FROM"          # single argument required, or
@@ -35,34 +35,37 @@ module Clive
     # @yield [String] 
     #   A block to be run if switch is triggered, will always be passed a string
     #
-    def initialize(names, desc, args, &block)
-      @names = Clive::Array.new(names.map(&:to_s))
-      @args  = Clive::Array.new
+    def initialize(names, desc, arguments, &block)
+      @names = names.map(&:to_s)
+      self.args = (arguments || "ARG")
       
-      # Need to be able to make each arg_name optional or not
-      # and allow for type in future
-      args.each do |i|
-        case i
-        when String
-          i.split(' ').each do |arg|
+      @desc  = desc
+      @block = block
+    end
+    
+    def args=(val)
+      case val
+      when String
+        if val[-3..-1] == "..."
+          @args = {:type => :splat, :base_name => val[0..-4]}
+        
+        else
+          @args = {:type => :list, :arguments => []}
+          val.split(' ').each do |arg|
             optional = false
             if arg[0] == "["
               optional = true
               arg = arg[1..-2]
             end
-            @args << {:name => arg, :optional => optional}
+
+            @args[:arguments] << {:name => arg, :optional => optional}
           end
-        else
-          @args = i
         end
+      when Range
+        @args = {:type => :range, :range => val}
+      when Array
+        @args = {:type => :choice, :items => val}
       end
-
-      if @args.empty?
-        @args = [{:name => "ARG", :optional => false}]
-      end
-      
-      @desc  = desc
-      @block = block
     end
     
     # Runs the block that was given with an argument
@@ -71,12 +74,19 @@ module Clive
     # @raise [InvalidArgument] only if +args+ is an array of acceptable inputs
     #   and a match is not found.
     def run(args)
-      if @args.is_a?(Array) && @args[0].is_a?(Hash)
-        args = Clive::Array.new(@args.collect {|i| !i[:optional]}).optimise_fill(args)
-      else # list
-        unless @args.to_a.map(&:to_s).include? args[0]
+      case @args[:type]
+      when :list
+        args = optimise_fill(args, @args[:arguments].map {|i| !i[:optional] })
+      when :choice
+        unless @args[:items].map{|i| i.to_s}.include?(args[0])
+          raise InvalidArgument.new(args)
+        end
+      when :range
+        unless @args[:range].to_a.map {|i| i.to_s}.include?(args[0])
           raise InvalidArgument.new(args)
         end
+      when :splat
+        args = [args]
       end
       @block.call(*args)
     end
@@ -86,64 +96,104 @@ module Clive
     #   Can be passed three things; :all, returns size of all arguments; :optional
     #   returns all optional arguments; :mandatory, returns size of mandatory arguments.
     def arg_size(type=:all)
-      case type
-      when :all
-        if @args.is_a?(Array) && @args[0].is_a?(Hash)
-          @args.size
-        else
-          1
-        end
-      when :optional
-        if @args.is_a?(Array) && @args[0].is_a?(Hash)
-          @args.find_all {|i| i[:optional] == true }.size
-        else
-          0
+      case @args[:type]
+      when :list
+        case type
+        when :all
+          @args[:arguments].size
+        when :optional
+          @args[:arguments].find_all {|i| i[:optional] == true }.size
+        when :mandatory
+          @args[:arguments].find_all {|i| i[:optional] == false }.size
         end
-      when :mandatory
-        if @args.is_a?(Array) && @args[0].is_a?(Hash)
-          @args.find_all {|i| i[:optional] == false }.size
-        else
+      
+      when :choice, :range
+        (type == :optional) ? 0 : 1
+      
+      when :splat
+        case type
+        when :all
+          1.0/0 # Infinity!
+        when :optional
+          1.0/0 # Infinity!
+        when :mandatory
           1
         end
       end
     end
     
-    def args_to_strings
-      if @args.is_a? Range
-        [""]
-      elsif @args[0].is_a? Hash
+    def args_to_string
+      case @args[:type]
+      when :list
         r = []
-        @args.each do |arg|
+        @args[:arguments].each do |arg|
           if arg[:optional]
             r << "[" + arg[:name] + "]"
           else
-            r << arg[:name]
+            r << "<" + arg[:name] + ">"
           end
         end
-        r
-      else
-        [""]
+        r.join(' ')
+      when :choice, :range
+        ""
+      when :splat
+        "<#{@args[:base_name]}1> ..."
       end
     end
     
-    def options_to_strings
-      if @args.is_a? Range
-        [@args.to_s]
-      elsif @args[0].is_a? Hash
-        ['']
-      else
-        @args
+    def options_to_string
+      case @args[:type]
+      when :list, :splat
+        ''
+      when :choice
+        '(' + @args[:items].join(', ') + ')'
+      when :range
+        '(' + @args[:range].to_s + ')'
       end
     end
     
     def to_h
       {
-        'names'   => Clive::Array.new(names_to_strings),
+        'names'   => names_to_strings,
         'desc'    => @desc,
-        'args'    => Clive::Array.new(args_to_strings),
-        'options' => Clive::Array.new(options_to_strings)
+        'args'    => args_to_string,
+        'options' => options_to_string
       }
     end
     
+    
+    # Attempts to fill +self+ with values from +input+, giving priority to 
+    # true, then false. If insufficient input to fill all false will use nil.
+    #
+    # @param [Array] input array of values to fill +self+ with
+    # @return [Array] filled array
+    #
+    # @example
+    #
+    #   [true, false, false, true].optimise_fill(["a", "b", "c"])
+    #   #=> ["a", "b", nil, "c"]
+    #
+    #
+    def optimise_fill(input, match)
+      diff = input.size - match.reject{|i| i == false}.size
+      
+      result = []
+      match.each_index do |i|
+        curr_item = match[i]
+        if curr_item == true
+          result << input.shift
+        else
+          if diff > 0
+            result << input.shift
+            diff -= 1
+          else
+            result << nil
+          end
+        end
+      end
+      result
+    end
+    
+    
   end
 end

data/lib/clive/option.rb

@@ -91,6 +91,10 @@ module Clive
         "desc"  => @desc
       }
     end
+    
+    def inspect
+      "#<#{self.class.name} [#{@names.join(', ')}]>"
+    end
   
   end
 end

data/lib/clive/parser.rb

@@ -5,7 +5,7 @@ module Clive
   #
   # @example
   #
-  #   require 'clive/parser'
+  #   require 'clive'
   # 
   #   class CLI
   #     include Clive::Parser
@@ -29,7 +29,7 @@ module Clive
     def self.included(klass)
       klass.instance_variable_set("@klass", klass)
       klass.extend(self)
-      klass.instance_variable_set "@base", Clive::Command.new(true)
+      klass.instance_variable_set "@base", Clive::Command.setup(klass)
     end
     
     # @return [Clive::Command]
@@ -72,23 +72,13 @@ module Clive
       base.help_formatter(*args, &block)
     end
     
-    
-    # @see http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-    # or because that doesn't exist anymore from this mirror
-    # http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html
-    #
-    def meta_def(name, &blk)
-      (class << self; self; end).instance_eval { define_method(name, &blk) }
-    end
-    
+    # This is a bit nicer, I think, for defining CLIs.
     def option_var(name, value=nil)
-      @klass.meta_def(name) do
-        instance_variable_get("@#{name}")
-      end
-      @klass.meta_def("#{name}=") do |val|
-        instance_variable_set("@#{name}", val)
+      if value
+        @klass.class_attr_accessor name => value
+      else
+        @klass.class_attr_accessor name
       end
-      instance_variable_set("@#{name}", value)
     end
     
     # Create a new hash which is accessible to the options in the new class

data/lib/clive/tokens.rb

@@ -36,7 +36,7 @@ module 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 = []
@@ -60,7 +60,7 @@ module Clive
     # Strings beginning with --, eg. --verbose become [:long, "verbose"].
     # Strings which begin with neither become [:word, "value"].
     #
-    # @return [::Array] the tokens that are held
+    # @return [Array] the tokens that are held
     def tokens
       t = []
       self.each do |i|
@@ -105,7 +105,7 @@ module Clive
     
     # Test whether an array is a token
     #
-    # @param [::Array]
+    # @param [Array]
     # @return [Boolean]
     #
     # @example

data/lib/clive/version.rb

@@ -1,3 +1,3 @@
 module Clive
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

data/spec/clive/command_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Clive::Command do
 
   context "when creating a base command" do
-    subject { Clive::Command.new(true) {} }
+    subject { Clive::Command.setup(Class.new) {} }
   end
   
   subject { 
-    Clive::Command.new([:co, :comm], "A command") do
+    Clive::Command.new([:co, :comm], "A command", Class.new) do
       bool(:boo) {}
       switch(:swi) {}
       flag(:fla) {}
@@ -19,7 +19,7 @@ describe Clive::Command do
   
   describe "#initialize" do
     subject { 
-      Clive::Command.new([:com], "A command") do
+      Clive::Command.new([:com], "A command", Class.new) do
         flag(:test)
       end
     }
@@ -36,11 +36,6 @@ describe Clive::Command do
       }.should raise_error Clive::NoOptionError
     end
     
-    it "sets the help formatter to :default" do
-      formatter = subject.instance_variable_get("@help_formatter")
-      formatter.should == subject.help_formatter(:default)
-    end
-    
     it "doesn't run the block given" do
       subject.flags.size.should == 0
     end
@@ -97,21 +92,6 @@ describe Clive::Command do
     end
   end
   
-  describe "#tokenize" do
-    it "returns an array of tokens" do
-      subject.find
-      res = [
-        [:switch, subject.bools.find {|i| i.names == ["boo"] }],
-        [:argument, "what"]
-      ]
-      subject.tokenize(%w(--boo what)).should == res
-    end
-  end
-  
-  describe "#parse" do
-    it "returns an array of tokens"
-  end
-  
   describe "#to_h" do
     it "returns a hash of data for help formatting" do
       hsh = {'names' => subject.names, 'desc' => subject.desc}
@@ -214,7 +194,7 @@ describe Clive::Command do
   
   describe "#build_help" do
     it "adds a switch for help" do
-      subject.options = Clive::Array.new
+      subject.options = []
       subject.options.should be_empty
       subject.build_help
       subject.options.map(&:names).should include ['h', 'help']
@@ -227,7 +207,7 @@ describe Clive::Command do
 Usage: rspec co, comm [options]
 
   Options: 
-     -h, --help               \e[90mDisplay help\e[0m
+    -h, --help                \e[90mDisplay help\e[0m
 EOS
     
       subject.help.should == help

data/spec/clive/flag_spec.rb

@@ -2,15 +2,9 @@ require 'spec_helper'
 
 describe Clive::Flag do
 
-  subject { Clive::Flag.new([:S, :say], "Say something", ["WORD(S)"]) {|i| $stdout.puts i } }
+  subject { Clive::Flag.new([:S, :say], "Say something", "WORD(S)") {|i| $stdout.puts i } }
 
   it_behaves_like "an option"
-  
-  describe "#args" do
-    it "returns a hash with argument(s)" do
-      subject.args.should == [{:name => "WORD(S)", :optional => false}]
-    end
-  end
 
   describe "#run" do
     it "calls the block with the argument" do
@@ -19,12 +13,6 @@ describe Clive::Flag do
     end
   end
   
-  describe "#args_to_strings" do
-    it "converts the arguments to strings" do
-      subject.args_to_strings.should == ["WORD(S)"]
-    end
-  end
-  
   describe "#arg_size" do
     context "when choice is available" do
       it "returns 1" do
@@ -34,7 +22,7 @@ describe Clive::Flag do
     end
     
     context "when arguments are required" do
-      subject { Clive::Flag.new([:n], "Description", ["REQ [OPT] REQ2 [OPT2] [OPT3]"]) }
+      subject { Clive::Flag.new([:n], "Description", "REQ [OPT] REQ2 [OPT2] [OPT3]") }
     
       it "returns the number of all arguments" do
         subject.arg_size(:all).should == 5
@@ -50,35 +38,77 @@ describe Clive::Flag do
     end
   end
   
-  describe "#options_to_strings" do
-    context "when @args is a range" do
-      it "returns array with range as string" do
-        subject.args = 1..4
-        subject.options_to_strings.should == ["1..4"]
+  describe "#args_to_string" do
+  
+    context "when a list of options" do
+      it "returns the arguments as a string" do
+        subject.args = "first [second]"
+        subject.args_to_string.should == "<first> [second]"
+      end
+    end
+    
+    context "when a splat as option" do
+      it "returns the argument and ellipsis" do
+        subject.args = "arg..."
+        subject.args_to_string.should == "<arg1> ..."
+      end
+    end
+    
+    context "when a choice of options" do
+      it "returns an empty string" do
+        subject.args = %w(a b c)
+        subject.args_to_string.should == ""
+      end
+    end
+    
+    context "when a range of options" do
+      it "returns an empty string" do
+        subject.args = 1..5
+        subject.args_to_string.should == ""
+      end
+    end
+    
+  end
+  
+  describe "#options_to_string" do
+  
+    context "when a list of options" do
+      it "returns an empty string" do
+        subject.args = "first [second]"
+        subject.options_to_string.should == ""
       end
     end
     
-    context "when @args is a hash" do
-      it "converts the options to strings" do
-        subject.options_to_strings.should == [""]
+    context "when a splat as option" do
+      it "returns an empty string" do
+        subject.args = "arg..."
+        subject.options_to_string.should == ""
       end
     end
     
-    context "when @args is an array" do
-      it "returns the array" do
-        subject.args = %w(1 2 3 4)
-        subject.options_to_strings.should == %w(1 2 3 4)
+    context "when a choice of options" do
+      it "returns the choices joined" do
+        subject.args = %w(a b c)
+        subject.options_to_string.should == "(a, b, c)"
       end
     end
+    
+    context "when a range of options" do
+      it "returns a string representation of the range" do
+        subject.args = 1..5
+        subject.options_to_string.should == "(1..5)"
+      end
+    end
+    
   end
   
   describe "#to_h" do
     it "returns a hash" do
       hsh = {
-        "names" => Clive::Array.new(%w(-S --say)),
+        "names" => %w(-S --say),
         "desc"  => "Say something",
-        "args"  => Clive::Array.new(["WORD(S)"]),
-        "options" => Clive::Array.new([""])
+        "args"  => "<WORD(S)>",
+        "options" => ""
       }
       subject.to_h.should == hsh
     end

data/spec/clive/formatter_spec.rb

@@ -54,26 +54,26 @@ describe Clive::Formatter do
   
   describe "#format" do
     it "generates the help" do
-      formatter = Clive::Command.new(true).help_formatter(:white)
+      formatter = Clive::Command.setup(Class.new).help_formatter(:white)
       options = [
         Clive::Switch.new([:t, :test], "A test switch"),
         Clive::Bool.new([:boolean], "A bool", true),
         Clive::Bool.new([:boolean], "A bool", false),
-        Clive::Flag.new([:args], "With args", ["ARG [OPT]"]),
-        Clive::Flag.new([:choose], "With options", [["a", "b", "c"]])
+        Clive::Flag.new([:args], "With args", "ARG [OPT]"),
+        Clive::Flag.new([:choose], "With options", ["a", "b", "c"])
       ]
-      command = Clive::Command.new([:command], "A command")
+      command = Clive::Command.new([:command], "A command", Class.new)
       result = <<EOS
 head
 
   Commands: 
-     command                  A command
+    command                   A command
 
   Options: 
-     -t, --test               A test switch
-     --[no-]boolean           A bool
-     --args ARG [OPT]         With args \e[1m\e[0m
-     --choose                 With options \e[1m(a, b, c)\e[0m
+    -t, --test                A test switch
+    --[no-]boolean            A bool
+    --args <ARG> [OPT]        With args \e[1m\e[0m
+    --choose                  With options \e[1m(a, b, c)\e[0m
 
 foot
 EOS

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 7
-  - 2
-  version: 0.7.2
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Joshua Hawxwell
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-07 00:00:00 +00:00
+date: 2011-02-24 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,21 @@ dependencies:
         version: 0.2.1
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: attr_plus
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 2
+        version: 0.2.2
+  type: :runtime
+  version_requirements: *id002
 description: "    Clive provides a DSL for building command line interfaces. It allows \n    you to define commands, switches, flags (switches with options) and \n    boolean switches, it then parses the input and runs the correct blocks.\n"
 email: m@hawx.me
 executables: []
@@ -42,12 +57,10 @@ extra_rdoc_files: []
 
 files: 
 - README.md
-- Rakefile
 - LICENSE
 - lib/clive/bool.rb
 - lib/clive/command.rb
 - lib/clive/exceptions.rb
-- lib/clive/ext.rb
 - lib/clive/flag.rb
 - lib/clive/formatter.rb
 - lib/clive/option.rb
@@ -59,8 +72,6 @@ files:
 - lib/clive.rb
 - spec/clive/bool_spec.rb
 - spec/clive/command_spec.rb
-- spec/clive/exceptions_spec.rb
-- spec/clive/ext_spec.rb
 - spec/clive/flag_spec.rb
 - spec/clive/formatter_spec.rb
 - spec/clive/option_spec.rb
@@ -105,8 +116,6 @@ summary: A DSL for building command line interfaces.
 test_files: 
 - spec/clive/bool_spec.rb
 - spec/clive/command_spec.rb
-- spec/clive/exceptions_spec.rb
-- spec/clive/ext_spec.rb
 - spec/clive/flag_spec.rb
 - spec/clive/formatter_spec.rb
 - spec/clive/option_spec.rb

data/Rakefile

@@ -1,9 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end

data/lib/clive/ext.rb

@@ -1,71 +0,0 @@
-module Clive
-  class Array < ::Array
-    
-    # If passed a Symbol or String will get the option or command 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
-        self.find_all {|i| i.names.include?(val)}[0]
-      else
-        super
-      end
-    end
-    
-    # Attempts to fill +self+ with values from +input+, giving priority to 
-    # true, then false. If insufficient input to fill all false will use nil.
-    #
-    # @param [Array] input array of values to fill +self+ with
-    # @return [Array] filled array
-    #
-    # @example
-    #
-    #   [true, false, false, true].optimise_fill(["a", "b", "c"])
-    #   #=> ["a", "b", nil, "c"]
-    #
-    #
-    def optimise_fill(input)
-      match = self
-      diff = input.size - match.reject{|i| i == false}.size
-      
-      result = []
-      match.each_index do |i|
-        curr_item = match[i]
-        if curr_item == true
-          result << input.shift
-        else
-          if diff > 0
-            result << input.shift
-            diff -= 1
-          else
-            result << nil
-          end
-        end
-      end
-      result
-    end
-    
-    alias_method :_join, :join
-    
-    def join(*args)
-      case args.size
-      when 1
-        self._join(args[0])
-        
-      when 2 # use second for last eg. 1, 2 and 3
-        self[0..-2]._join(args[0]) << args[1] << self[-1]
-        
-      when 3 # prepend and append 1st and 3rd eg. (1, 2, 3)
-        if self[0] != ""
-          args[0] << self._join(args[1]) << args[2]
-        else
-          ""
-        end
-      end
-    end
-    
-  end
-end

data/spec/clive/exceptions_spec.rb

@@ -1 +0,0 @@
-require 'spec_helper'

data/spec/clive/ext_spec.rb

@@ -1 +0,0 @@
-require 'spec_helper'