clio 0.2.0 → 0.3.0

data/CHANGES

@@ -1,10 +1,22 @@
+== 0.3.0 / 2008-11-19
+
+* 5 Other Enhancements
+
+    * improved usage specs (#2e805f40a05afcccdf59bad087b759d1fda60354)
+    * string.rb, fixed gsub (#f7449ced8d9757aefb8dedb04e65821fd174a31d)
+    * renamed Usage::Main to Usage::Command and Usage::Command to Usage::Subcommand (#42ccad02a7f5a68461e70c4ef775a8751facbddb)
+    * remove QED from end of specs (#0a820c7c44db3d1a6e7b1950152fabdaae006381)
+    * Merge: 0a820c7... f7449ce...
+      improved string spec (#b0579c898f02be2a3644e3f4bc233f9795f9a122)
+
+
 == 0.2.0 / 2008-11-15
 
 * 1 Major Enhancements
 
     * commandline now has a full parser  (#251ff8fb0d6e56dd6e90d6e859e840717af004e4)
 
-* 46 Other Enhancements
+* 52 Other Enhancements
 
     * capitialized main files (#1ac75f6de90bab8a696e657b4b33f936c969bbe2)
     * moved multicommand prototype to depot (#efe1d718e191394fa73064e4527a113374c55931)
@@ -52,6 +64,12 @@
     * clio/string.rb, fixed require (#4a519dd76be6e66454424edbe9eb790c786fc582)
     * all specs now pass (#4b90a0b08a6a97ab29453b647ef969a7384f2d5d)
     * avoid class with Clio::String and use ::String where needed (#471a0b1480207324ecf17ffe2943dac29fedba7e)
+    * updated reap configs (#361162622b25a25b5600a55f523ee80d2f719208)
+    * update README and VERSION (0.2.0) (#01d804e3789b5d58fd7e6243a11ea0ba65f96296)
+    * argument.rb, added splat option (#4d37a8906945c223100cc0d617a8ecbe9f25b863)
+    * support for argument added splat option (#8176e5cee31f2a8fa73e0f151f504a40f0a9a21a)
+    * added some website assets (#16e6b765fd606f5c09d43b52f6d0104aa55fc56f)
+    * added doc/spec to .gitignore (#1fc846f54b304da8956fecc84d9287641a5da052)
 
 
 == 0.0.1 / 2008-08-29

data/MANIFEST

@@ -14,6 +14,7 @@ spec/commandline/scenario.rd
 spec/string
 spec/string/unit.rd
 spec/commandable
+MANIFEST
 CHANGES
 RELEASE
 README
@@ -31,11 +32,11 @@ lib/clio/facets
 lib/clio/facets/kernel.rb
 lib/clio/facets/string.rb
 lib/clio/usage
-lib/clio/usage/main.rb
 lib/clio/usage/signature.rb
 lib/clio/usage/command.rb
 lib/clio/usage/parser.rb
 lib/clio/usage/argument.rb
+lib/clio/usage/subcommand.rb
 lib/clio/usage/interface.rb
 lib/clio/usage/option.rb
 lib/clio/commandline.rb

data/README

@@ -6,11 +6,10 @@
 == INTRODUCTION
 
 Clio is a great way to build commandline tools.
-It provides an advanced options parser with
-a variety of notations suited to almost any
-perfered style, and provides a very rich and
-and easy to use library for generating console
-output.
+It provides an advanced options parser with a variety
+of notations suited to almost any perfered style,
+and provides a very rich and and easy to use library
+for generating console output.
 
 
 == RELEASE NOTES
@@ -35,7 +34,7 @@ Clio .tgz package and type:
 
 == USAGE
 
-Please see the RDoc API.
+For now please see the RDoc API.
 
 
 == LICENSE

data/RELEASE

@@ -1,8 +1,13 @@
-This is the initial release of Clio. While useable,
-it is still very much APLHA code. The API is still
-in flux and needs a lot more testing before I'd
-put it to gereral use.
+Clio is much cloer to a stable status. This release
+has a fairly large set of passing specifications.
 
-### 0.0.1 // 2008-08-29
+### 0.3.0 // 2008-08-29
 
+1 Major Change
+
+  * Rename Usage Main to Command and Command to Subcommand.
+
+1 Minor Change
+
+  * Fixed many small bugs.
 

data/VERSION

@@ -1 +1 @@
-clio 0.2.0 beta (2008-11-15)
+clio 0.3.0 beta (2008-11-19)

data/lib/clio/commandline.rb

@@ -1,4 +1,3 @@
-require 'clio/facets/kernel' # for deep_copy
 require 'clio/usage'
 #require 'shellwords'
 
@@ -183,7 +182,7 @@ module Clio
       #def inherited(subclass)
 #p usage.to_s
 #p subclass.usage.to_s
-#        subclass.usage = self.usage.clone #deep_copy
+#        subclass.usage = self.usage.clone #deep copy?
 #p subclass.usage.to_s
 #      end
 
@@ -203,12 +202,6 @@ module Clio
         @usage = u
       end
 
-      #    if ancestors[1] < Command
-      #      @usage = ancestors[0].usage.deep_copy
-      #    else
-      #      @usage = Usage.new
-      #    end
-
       #
       def subcommand(name, help=nil, &block)
         usage.subcommand(name, help, &block)
@@ -256,7 +249,7 @@ module Clio
       if self.class == Commandline
         @usage = Usage.new
       else
-        @usage = self.class.usage #|| Usage.new #.deep_copy
+        @usage = self.class.usage #|| Usage.new
       end
       @usage.instance_eval(&block) if block
     end

data/lib/clio/string.rb

@@ -32,8 +32,8 @@ module Clio
       s = text.dup
       m = marks.sort{ |a,b| b[0] <=> a[0] }
       m.each do |index, codes|
-        codes.each do |code|
-          s.insert(index, ANSICode.send(code))
+        codes.reverse_each do |code|
+          s.insert(index, ANSICode.__send__(code))
         end
       end
       s
@@ -41,20 +41,6 @@ module Clio
 
     def size ; text.size ; end
 
-    ###
-    def color!(ansicolor)
-      marks[0] << ansicolor
-      marks[size] << :clear
-    end
-
-    ###
-    def color(ansicolor)
-      m = marks.dup
-      m[0] << ansicolor
-      m[size] << :clear
-      self.class.new(text, m)
-    end
-
     ###
     def upcase  ; self.class.new(text.upcase, marks) ; end
     def upcase! ; text.upcase! ; end
@@ -69,7 +55,8 @@ module Clio
       when String
         ntext  = text + other.text
         nmarks = marks.dup
-        other.marks.each{ |i, c| m[i] << c }
+        omarks = shift_marks(0, text.size, other.marks)
+        omarks.each{ |i, c| nmarks[i].concat(c) }
       else
         ntext  = text + other.to_s
         nmarks = marks.dup
@@ -117,38 +104,110 @@ module Clio
 
     alias_method :[], :slice
 
-    # TODO: block support and \1, \2 support.
+    # This is more limited than the normal String method.
+    # It does not yet support a block, and +replacement+
+    # won't substitue for \1, \2, etc. 
+    #
+    # TODO: block support.
+    def sub!(pattern,replacement)
+      mark_changes = []
+      text = @text.sub(pattern) do |s|
+        index  = $~.begin(0)
+        delta  = (replacement.size - s.size)
+        mark_changes << [index, delta]
+        replacement
+      end
+      marks = @marks
+      mark_changes.each do |index, delta|
+        marks = shift_marks(index, delta, marks)
+      end
+      @text  = text
+      @marks = marks
+      self
+    end
+
+    #
     def sub(pattern,replacement)
-      if md = pattern.match(@text)
-        delta  = replacement.size - md.size
-        marks2 = shift_marks(md.end, delta)
-        text2  = text.sub(pattern,replacement)
-        self.class.new(text2, marks2)
-      else
-        self.class.new(text, marks)
+      dup.sub!(pattern, replacement)
+    end
+
+    #
+    def gsub!(pattern,replacement)
+      mark_changes = []
+      text = @text.gsub(pattern) do |s|
+        index  = $~.begin(0)
+        delta  = (replacement.size - s.size)
+        mark_changes << [index, delta]
+        replacement
+      end
+      marks = @marks
+      mark_changes.each do |index, delta|
+        marks = shift_marks(index, delta, marks)
       end
+      @text  = text
+      @marks = marks
+      self
     end
 
     #
-    def gsub
+    def gsub(pattern_replacement)
+      dup.gsub(pattern, replacement)
+    end
+
+    ###
+    def ansi(code)
+      m = marks.dup
+      m[0] << code
+      m[size] << :clear
+      self.class.new(text, m)
     end
+    alias_method :color, :ansi
+
+    ###
+    def ansi!(code)
+      marks[0] << ansicolor
+      marks[size] << :clear
+    end
+    alias_method :color!, :ansi!
+
+    def red      ; color(:red)      ; end
+    def green    ; color(:green)    ; end
+    def blue     ; color(:blue)     ; end
+    def black    ; color(:black)    ; end
+    def magenta  ; color(:magenta)  ; end
+    def yellow   ; color(:yellow)   ; end
+    def cyan     ; color(:cyan)     ; end
+
+    def red!     ; color!(:red)     ; end
+    def green!   ; color!(:green)   ; end
+    def blue!    ; color!(:blue)    ; end
+    def black!   ; color!(:black)   ; end
+    def magenta! ; color!(:magenta) ; end
+    def yellow!  ; color!(:yellow)  ; end
+    def cyan!    ; color!(:cyan)    ; end
 
   private
 
-    def shift_marks(index, delta)
+    #
+    def shift_marks(index, delta, marks=nil)
       new_marks = {}
-      marks.each do |i, v|
+      (marks || @marks).each do |i, v|
         case i <=> index
-        when 0, -1
+        when -1
           new_marks[i] = v
-        when 1
+        when 0, 1
           new_marks[i+delta] = v
         end
       end
       new_marks
     end
 
-  end
+    #
+    def shift_marks!(index, delta)
+     @marks.replace(shift_marks(index, delta))
+    end
+
+  end # class String
 
-end
+end # module Clio
 

data/lib/clio/usage.rb

@@ -1,4 +1,4 @@
-require 'clio/usage/main'
+require 'clio/usage/command'
 require 'clio/usage/parser'
 
 module Clio
@@ -175,7 +175,7 @@ module Clio
   module Usage
 
     def self.new(name=nil, &block)
-      Main.new(name, &block)
+      Command.new(name, &block)
     end
 
   end#module Usage

data/lib/clio/usage/argument.rb

@@ -4,19 +4,18 @@ module Clio
 
     # = Usage Argument
     #
+    # TODO: Should argument have name in addition to type?
     class Argument
       #attr :parent
-      attr :name
+      #attr :name
       attr :type
       attr :help
       attr :splat
 
       # New Argument.
-      #def initialize(name, parent=nil, &block)
-      def initialize(name, &block)
-        @name      = name.to_s
-        @type      = name.upcase
-        #@parent    = parent
+      def initialize(type, &block)
+        @type      = type
+        #@name      = type.downcase if type.upcase != type
         @splat     = false
         @help      = ''
         instance_eval(&block) if block
@@ -24,15 +23,15 @@ module Clio
 
       #
       def initialize_copy(o)
-        @name = o.name.dup
+        #@name = o.name.dup
         @type = o.type.dup
         @help = o.help.dup
       end
 
       # Same as +name+ but given as a symbol.
-      def key
-        name.to_sym
-      end
+      #def key
+      #  name.to_sym
+      #end
 
       # Specify the type of the argument.
       # This is an arbitrary description of the type.
@@ -47,6 +46,12 @@ module Clio
         self
       end
 
+      #def name(string=nil)
+      #  return @name unless string
+      #  @name = string.to_s
+      #  self
+      #end
+
       #
       def splat(true_or_false=nil)
         return @splat if true_or_false.nil?
@@ -60,20 +65,17 @@ module Clio
       end
 
       def to_s
-        if name.upcase == type
-          s = "<#{name}"
-        else
-          s = "<#{name}:#{type}"
-        end
+        s = "<#{type}"
         s << (splat ? "...>" : ">")
         s
       end
 
       def inspect
-        s  = "<#{name}"
-        s << ":#{type.inspect}" if type
-        s << ">"
-        s
+        to_s
+        #s  = "<#{name}"
+        #s << ":#{type.inspect}" if type
+        #s << ">"
+        #s
       end
 
     end #class Argument

data/lib/clio/usage/command.rb

@@ -1,354 +1,75 @@
-require 'clio/usage/option'
-require 'clio/usage/argument'
+require 'clio/usage/subcommand'
 
 module Clio
 
   module Usage #:nodoc:
 
-    # = Commandline Usage Command
+    # = Command
     #
-    # This is the heart of usage; subclassed by Main and
-    # containing together Options and Arguments.
+    # This is the toplevel "main" command.
     #
-    #   usage = Usage.new
-    #
-    class Command
-
-      # Parent command. This is needed
-      # to support cascading options.
-      #--
-      # NOTE: If it were possible to have this it would be better.
-      #++
-      attr :parent
-
-      # Name of the command.
-      attr :name
-
-      # Array of subcommands.
-      attr :subcommands
-
-      # Array of arguments. Arguments and subcommands
-      # are mutually exclusive, ie. either @arguments
-      # or @subcommands will be empty.
-      #
-      # TODO: Could use single attribute for both subcommands
-      # and arguments and use a flag to designate which type.
-      attr :arguments
-
-      # Array of options.
-      attr :options
-
-      # Help text.
-      attr :help
-
-      # Widely accepted alternate term for options.
-      alias_method :switches, :options
-
-      #
-      def initialize(name, parent=nil, &block)
-        @name        = name.to_s
-        @parent      = parent
-        @subcommands = []
-        @options     = []
-        @arguments   = []
-        @help        = ''
-        instance_eval(&block) if block
-      end
-
-      #
-      def initialize_copy(c)
-        @parent      = c.parent
-        @name        = c.name.dup
-        @options     = c.options.dup
-        @arguments   = c.arguments.dup
-        @subcommands = c.subcommands.dup
-        @help        = c.help.dup
-      end
-
-      def key ; @name.to_sym ; end
-
-      # METHOD MISSING
-      #-------------------------------------------------------------
-
-      def method_missing(key, *args, &blk)
-        key = key.to_s
-        case key
-        when /\?$/
-          option(key.chomp('?'), *args, &blk)
-        else
-          #k = full_name ? "#{full_name} #{key}" : "#{key}"
-          c = command(key, &blk)
-          args.each{ |a| c[a] }
-          c
-        end
-      end
-
-      #
-      def help!(*args)
-        Hash[*args].each do |key, desc|
-          self[key, desc]
-        end
-      end
-
-      # Define or retrieve a command.
-      #
-      #   subcommand('remote')
-      #
-      # A shortcut to accessing subcommands of subcommands, the following
-      # statements are equivalent:
-      #
-      #   subcommand('remote').subcommand('add')
-      #
-      #   subcommand('remote add')
-      #
-      def subcommand(name, help=nil, &block)
-        name, names = *name.to_s.strip.split(/\s+/)
-        if names
-          names = [name, *names]
-          cmd = names.inject(self) do |c, n|
-            c.subcommand(n)
-          end
-        else
-          cmd = subcommands.find{ |c| c === name }
-          unless cmd
-            cmd = Command.new(name, self)
-            subcommands << cmd
-          end
-        end
-        cmd.help(help) if help
-        cmd.instance_eval(&block) if block
-        cmd
-      end
-
-      alias_method :cmd, :subcommand
-      alias_method :command, :subcommand
+    class Command < Subcommand
 
-      alias_method :commands, :subcommands
-
-      # Define an option.
-      #
-      #   option(:output, :o)
+      # New Usage.
       #
-      def option(name, *aliases, &block)
-        opt = options.find{|o| o === name}
-        if not opt
-          opt = Option.new(name) #, self)
-          #opt.aliases(*aliases)
-          @options << opt
-        end
-        opt.aliases(*aliases) unless aliases.empty?
-        opt.instance_eval(&block) if block
-        opt
+      def initialize(name=nil, &block)
+        name ||= File.basename($0)
+        super(name, &block)
       end
 
-      alias_method :switch, :option
-
-      # Option shorthand.
+      # Define a command.
       #
-      #   opt('--output=FILE -o', 'output directory')
+      #   command('remote')
+      #   command('remote','add')
       #
-      def opt(name, help=nil)
-        name, *aliases = name.split(/\s+/)
-        name, type = *name.split('=')
-        mult = false
-        if type && type[0,1] == '*'
-          mult = true
-          type = type[1..-1]
-        end
-        name = option_name(name).to_sym
-        o = option(name, *aliases)
-        o.help(help) if help
-        o.argument(type) if type
-        o.multiple(mult)
-        self
-      end
-
-      alias_method :swt, :opt
-
-      # A switch is like an option, but it is greedy.
-      # When parsed it will pick-up any match subsequent
-      # the switch's parent command. In other words,
-      # switches are consumed by a command even if they
-      # appear in a subcommand's arguments.
-      #
-      #def switch(name, *aliases, &block)
-      #  if opt = @switches.find{|o| o === name}
+      #def command(name, &block)
+      #  raise "Command cannot have both arguments and subcommands (eg. #{name})." unless arguments.empty?
+      #  key = name.to_s.strip
+      #  if cmd = @commands.find{|c| c === key}
       #  else
-      #    opt = Option.new(name, self)
-      #    opt.greedy = true
-      #    opt.aliases(*aliases)
-      #    @switches << opt
+      #    cmd = Command.new(key, self)
+      #    @commands << cmd
       #  end
-      #  opt.instance_eval(&block) if block
-      #  opt
+      #  cmd.instance_eval(&block) if block
+      #  cmd
       #end
 
-      # Switch shorthand.
-      #
-      #   swt('--output=FILE -o', 'output directory')
-      #
-      #def swt(name, help=nil)
-      #  name, *aliases = name.split(/\s+/)
-      #  name, type = *name.split('=')
-      #  mult = false
-      #  if type && type[0,1] == '*'
-      #    mult = true
-      #    type = type[1..-1]
-      #  end
-      #  name = clean_name(name)
-      #  o = switch(name, *aliases)
-      #  o.help(help) if help
-      #  o.argument(type) if type
-      #  o.multiple(mult)
-      #  self
-      #end
+=begin
+      #alias_method :[], :command
 
-      # Define an argument.
-      # Takes a name, optional index and block.
-      #
-      # Indexing of arguments starts at 1, not 0.
-      #
-      # Examples
-      #
-      #   argument(:path)
-      #   argument(1, :path)
-      #
-      def argument(*n_type, &block)
-        index = Integer===n_type[0] ? n_type.shift : @arguments.size + 1
-        type  = n_type.shift
-        help  = n_type.shift
 
-        index = index - 1
-        type = type.to_s.sub(/^\</,'').chomp('>')
-
-        if type[0,1] == '*'
-          type.sub!('*', '')
-          splat = true
-        elsif type[-1,1] == '*'
-          type.sub!(/[*]$/, '')
-          splat = true
-        else
-          splat = false
-        end
-
-        raise "Command cannot have both arguments (eg. #{type}) and subcommands." unless subcommands.empty?
-
-        if arg = @arguments[index]
-          arg.type(type) if type
-          arg.help(help) if help
-          arg.splat(splat) if splat
-          arg.instance_eval(&block) if block
-        else
-          if type || block
-            arg = Argument.new(type, &block) #self, &block)
-            arg.help(help) if help
-            arg.splat(splat) if splat
-            @arguments[index] = arg
-          end
-        end
-        return arg
-      end
-
-      alias_method :arg, :argument
-
-      # Argument shorthand.
-      #
-      #   arg('PIN', 'pin number')
-      #
-      #def arg(type=nil, help=nil)
-      #  type = type.to_s.sub(/^\</,'').chomp('>')
-      #  argument(type).help(help)
-      #  self
-      #end
-
-      #
-      def help(string=nil)
-        @help.replace(string.to_s) if string
-        @help
-      end
-
-      # SHORTHAND NOTATION
-      #-------------------------------------------------------------
-
-      # Super shorthand notation.
-      #
-      #   cli['document']['--output=FILE -o']['<files>']
-      #
-      def [](*x)
-        case x[0].to_s[0,1]
-        when '-'
-          opt(*x)
-        when '<'
-          arg(*x)
-        else
-          subcommand(*x)
-        end
-      end
-
-      # QUERY METHODS
+      # ARRAY NOTATION
       #-------------------------------------------------------------
 
       #
-      def completion
-        if subcommands.empty?
-          options.collect{|o| o.to_s.strip } +
-          arguments.collect{|c| c.name}
-        else
-          options.collect{|o| o.to_s.strip } +
-          subcommands.collect{|c| c.name}
-        end
-      end
-
-      # Option defined?
-      #
-      def option?(name)
-        opt = options.find{|o| o === name}
-        if parent && !opt
-          opt = parent.option?(name)
-        end
-        opt
-        #return opt if opt
-        #options.each do |o|
-        #  return o if o.aliases.include?(key)
-        #end
-        #nil
-      end
-
-      alias_method :switch?, :option
-
-      # Greedy Option defined?
-      #
-      #def greedy_option?(key)
-      #  switches.find{|o| o === key}
-      #end
-
-      #
-      def ===(other_name)
-        name == other_name.to_s
-      end
-
-      #
-      def inspect
-        s = ''
-        s << "#<#{self.class}:#{object_id} #{@name}"
-        s << " @arguments=#{@arguments.inspect} " unless @arguments.empty?
-        s << " @options=#{@options.inspect} "     unless @options.empty?
-        #s << "@switches=#{@switches.inspect} "   unless @switches.empty?
-        s << " @help=#{@help.inspect}"            unless @help.empty?
-        #s << "@commands=#{@commands.inspect} "  unless @commands.empty?
-        s << ">"
-        s
-      end
+      def [](*args)
+        res = nil
+        head, *tail = *args
+        case head.to_s
+        when /^-/
+          x = []
+          opts = args.map do |o|
+            o = o.to_s
+            if i = o.index('=')
+              x << o[i+1..-1]
+              o[0...i]
+            else
+              o
+            end
+          end
+          x = x.uniq
 
-      # Full callable command name.
-      def full_name
-        if parent && parent.full_name
-          "#{parent.full_name} #{name}"
+          res = opt(*opts)
         else
-          "#{name}"
+          args.each do |name|
+            res = command(name)
+          end
         end
+        return res
       end
+=end
 
+=begin
       # Usage text.
       #
       def to_s
@@ -360,17 +81,17 @@ module Clio
         when 1, 2, 3
           s.concat(options.collect{ |o| "[#{o.to_s.strip}]" })
         else
-          s << "[switches]"  # switches? vs. options
+          s << "[switches]"
         end
-
+# switches? vs. options
         s << arguments.join(' ') unless arguments.empty?
 
-        case subcommands.size
+        case commands.size
         when 0
         when 1
-          s << subcommands.join('')
+          s << commands.join('')
         when 2, 3
-          s << '[' + subcommands.join(' | ') + ']'
+          s << '[' + commands.join(' | ') + ']'
         else
           s << 'command'
         end
@@ -388,10 +109,10 @@ module Clio
         end
         s << "Usage:"
         s << "  " + to_s
-        unless subcommands.empty?
+        unless commands.empty?
           s << ''
           s << 'Commands:'
-          s.concat(subcommands.collect{ |x| "  %-20s %s" % [x.name, x.help] }.sort)
+          s.concat(commands.collect{ |x| "  %-20s %s" % [x.key, x.help] }.sort)
         end
         unless arguments.empty?
           s << ''
@@ -405,36 +126,40 @@ module Clio
         end
         s.flatten.join("\n")
       end
+=end
 
-      # PARSE
-      #-------------------------------------------------------------
+      def parse(argv)
+        Parser.new(self, argv).parse #(argv)
+      end
 
-      # Parse usage.
-      def parse(argv, index=0)
-        @parser ||= Parser.new(self, argv, index)
-        @parser.parse
+      # Cache usage into a per-user cache file for reuse.
+      # This can be used to greatly speed up tab completion.
+      #
+      def cache
+        File.open(cache_file, 'w'){ |f| f << to_yaml }
       end
 
     private
 
-      def option_key(key)
-        name = option_name(key) #.to_s
-        if name.size == 1
-          "-#{name}".to_sym
-        else
-          "--#{name}".to_sym
-        end
+      # TODO: Use XDG
+
+      def cache_file
+        File.join(File.expand_path('~'), '.cache', 'clio', "#{name}.yaml")
       end
 
-      def option_name(name)
-        name = name.to_s
-        name = name.gsub(/^[-]+/, '')
-        return name.chomp('?') #.to_sym
+      def self.cache_file
+        File.join(File.expand_path('~'), '.cache', 'clio', "#{name}.yaml")
+      end
+
+      def self.load_cache
+        if File.file?(cache_file)
+          YAML.load(File.new(cache_file))
+        end
       end
 
-    end #class Command
+    end#class Main
 
-  end #module Usage
+  end#module Usage
 
-end #module Clio
+end#module Clio