clio 0.0.1 → 0.2.0

data/lib/clio/usage/main.rb

@@ -0,0 +1,165 @@
+require 'clio/usage/command'
+
+module Clio
+
+  module Usage #:nodoc:
+
+    # = Main
+    #
+    # Main specifies the toplevel "Command".
+    #
+    class Main < Command
+
+      # New Usage.
+      #
+      def initialize(name=nil, &block)
+        name ||= File.basename($0)
+        super(name, &block)
+      end
+
+      # Define a command.
+      #
+      #   command('remote')
+      #   command('remote','add')
+      #
+      #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
+      #    cmd = Command.new(key, self)
+      #    @commands << cmd
+      #  end
+      #  cmd.instance_eval(&block) if block
+      #  cmd
+      #end
+
+=begin
+      #alias_method :[], :command
+
+
+      # ARRAY NOTATION
+      #-------------------------------------------------------------
+
+      #
+      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
+
+          res = opt(*opts)
+        else
+          args.each do |name|
+            res = command(name)
+          end
+        end
+        return res
+      end
+=end
+
+=begin
+      # Usage text.
+      #
+      def to_s
+        #s = [full_name]
+        s = [name]
+
+        case options.size
+        when 0
+        when 1, 2, 3
+          s.concat(options.collect{ |o| "[#{o.to_s.strip}]" })
+        else
+          s << "[switches]"
+        end
+# switches? vs. options
+        s << arguments.join(' ') unless arguments.empty?
+
+        case commands.size
+        when 0
+        when 1
+          s << commands.join('')
+        when 2, 3
+          s << '[' + commands.join(' | ') + ']'
+        else
+          s << 'command'
+        end
+
+        s.flatten.join(' ')
+      end
+
+      # Help text.
+      #
+      def to_s_help
+        s = []
+        unless help.empty?
+          s << help
+          s << ''
+        end
+        s << "Usage:"
+        s << "  " + to_s
+        unless commands.empty?
+          s << ''
+          s << 'Commands:'
+          s.concat(commands.collect{ |x| "  %-20s %s" % [x.key, x.help] }.sort)
+        end
+        unless arguments.empty?
+          s << ''
+          s << "Arguments:"
+          s.concat(arguments.collect{ |x| "  %-20s %s" % [x, x.help] })
+        end
+        unless options.empty?
+          s << ''
+          s << 'Switches:'
+          s.concat(options.collect{ |x| "  %-20s %s" % [x, x.help] })
+        end
+        s.flatten.join("\n")
+      end
+=end
+
+      def parse(argv)
+        Parser.new(self, argv).parse #(argv)
+      end
+
+      # 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
+
+      # TODO: Use XDG
+
+      def cache_file
+        File.join(File.expand_path('~'), '.cache', 'clio', "#{name}.yaml")
+      end
+
+      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 Main
+
+  end#module Usage
+
+end#module Clio
+

data/lib/clio/usage/option.rb

@@ -0,0 +1,251 @@
+module Clio
+
+  module Usage #:nodoc:
+
+    # = Commandline Option
+    #
+    class Option
+
+      # Parent command.
+      #attr :parent
+
+      # Option name.
+      attr :name
+
+      # Alternate names for this option.
+      attr :aliases
+
+      # Option arguments.
+      attr :arguments
+
+      # Option can be used more that once.
+      attr :multiple
+
+      # Option (names) that are mutually exlusive
+      # to this option.
+      attr :excludes
+
+      # Is the option greedy (true/false)? A greedy
+      # option is one that is parsed from the
+      # commandline no matter where it appears.
+      #attr_accessor :greedy
+
+      # Help text for this option.
+      attr :help
+
+      # New Option.
+      #def initialize(name, parent=nil, &block)
+      def initialize(name, &block)
+        @name      = clean_name(name)
+        #@parent    = parent
+        @aliases   = []
+        @arguments = []
+        @multiple  = false
+        #@greedy    = false
+        @exclude   = []
+        @help      = ''
+        instance_eval(&block) if block
+      end
+
+      #
+      def initialize_copy(o)
+        @name    = o.name.dup
+        @aliases = o.aliases.dup
+        #@multiple = o.multiple
+        @exclude = o.exclude.dup
+        @help    = o.help.dup
+      end
+
+      # Same as +name+ but given as a symbol.
+      def key
+        name.to_sym
+      end
+
+      # Can this option occur multiple times in the
+      # command line?
+      def multiple? ; @multiple ; end
+
+      # Is this option greedy?
+      #def greedy?   ; @greedy   ; end
+
+      #
+      def inspect
+        to_s
+        #s  = "[--#{key}"
+        #s << "*" if multiple
+        #s << "=" + arguments.join(',') unless arguments.empty?
+        #s << " " + aliases.collect{ |a| "-#{a}" } unless aliases.empty?
+        ##s << " @excludes=#{@excludes.inspect}" unless @excludes.empty?
+        #s << "]"
+        #s
+      end
+
+      # Is this option a boolean flag?
+      def flag?; @arguments.empty?; end
+
+      # Assign an argument to the option.
+      def argument(name, &block)
+        arg = Argument.new(name) #, self)
+        arg.instance_eval(&block) if block
+        @arguments << arg
+        arg
+      end
+
+      # Specify aliases for the option.
+      def aliases(*names)
+        return @aliases if names.empty?
+        names.each do |name|
+          @aliases << clean_key(name)
+        end
+      end
+
+      # Specify if the option be used multiple times.
+      def multiple(bool=nil)
+        return @multiple if bool.nil?
+        @multiple = bool
+        self
+      end
+
+      # Specify mutually exclusive options.
+      def xor(*opts)
+        @exclusive.concat(opts)
+      end
+
+      #
+      #def |(other)
+      #  xor(other)
+      #end
+
+      #
+      def help(string=nil)
+        @help.replace(string.to_s) if string
+        @help
+      end
+
+      # Tab completion.
+      def completion
+        arguments.collect{|c| c.key}
+      end
+
+      # SHORTHAND NOTATION
+      #-------------------------------------------------------------
+
+      # Argument shorthand.
+      #
+      #   arg('PIN', 'pin number')
+      #
+      def arg(slot, help=nil)
+        argument(slot).help(help)
+      end
+
+      #
+      def to_s
+        tiny = aliases.select do |a|
+          a.to_s.size == 1
+        end
+        tiny.unshift(name) if name.size == 1
+
+        long = aliases.select do |a|
+          a.to_s.size > 1
+        end
+        long.unshift(name) if name.size > 1
+
+        tiny = tiny.collect{ |l| "-#{l}" }
+        long = long.collect{ |w| "--#{w}" }
+
+        if tiny.empty?
+          opts = [ '  ', *long ]
+        else
+          opts = tiny + long
+        end
+
+        unless arguments.empty?
+          args = arguments.collect{ |a| a.to_s.sub(/^[<]/,'').sub(/[>]$/,'') }
+          opts.last << "=" + args.join(',')
+        end
+
+        opts.join(' ')
+      end
+
+      #
+      def ===(other)
+        other = clean_key(other)
+        return true if clean_key(key) == other
+        return true if aliases.include?(other)
+        return false
+      end
+
+      # Breaks down an option at index of argv.
+      #def parse(argv, index)
+      #end
+
+    private
+
+      #
+      def clean_key(key)
+        clean_name(key).to_sym
+      end
+
+      #
+      def clean_name(name)
+        name = name.to_s
+        name = name.gsub(/^[-]+/, '')
+        name.chomp('?')
+      end
+
+      #
+      def flag_key?(key)
+        name = key.to_s
+        return key[-1,1] == '?'
+      end
+
+      #
+      def option_key(key)
+        k = clean_key(key).to_s
+        if k.size == 1
+          "-#{k}".to_sym
+        else
+          "--#{k}".to_sym
+        end
+      end
+
+    end
+
+  end # class Commandline
+
+end # module Clio
+
+=begin
+    # Option class. This is used by some command
+    # of the command line parser class to store
+    # option information.
+    class Option
+      attr_reader :name
+      attr_accessor :type
+      attr_accessor :init
+      attr_accessor :desc
+
+      alias_method :default, :init
+      alias_method :description, :desc
+
+      def initialize(name, desc, opts)
+        @name = name
+        @desc = desc
+        @type = opts[:type] || 'value'
+        @init = opts[:default] || opts[:init]
+      end
+      def usage
+        "--#{name}=#{type.to_s.upcase}"
+      end
+      def assert_valid(value)
+        raise "invalid" unless valid?(value)
+      end
+      def valid?(value)
+        validation ? validation.call(value) : true
+      end
+      def validation(&block)
+        @validation = block if block
+        @validation
+      end
+    end
+=end

data/lib/clio/usage/parser.rb

@@ -0,0 +1,191 @@
+require 'shellwords'
+require 'clio/usage/signature'
+require 'clio/usage/interface'
+
+module Clio
+
+  module Usage #:nodoc:
+
+    # = Parser
+    #
+    # Parse commandline arguments according to given Usage.
+    #
+    class Parser
+      attr :usage
+      attr :argv
+
+      attr :signatures
+
+      #
+      def initialize(usage, argv) #, index=0)
+        # convert to array if argv string
+        if ::String===argv
+          argv = Shellwords.shellwords(argv)
+        else
+          argv = argv.dup
+        end
+
+        @usage  = usage
+        @argv   = argv
+
+        @parsed     = false
+        @signatures = []
+        @errors     = []
+      end
+
+      #
+      def name ; usage.name ; end
+      def key  ; usage.key  ; end
+
+      #
+      def inspect
+        s = "<" + signatures.inspect + ">"
+        s
+        #s  = "#<#{self.class}"
+        #s << " @options=#{@options.inspect}" unless @options.empty?
+        #s << " @arguments=#{@arguments.inspect}" unless @arguments.empty?
+        #s << " @subcommand=#{@subcommand}>" if @subcommand
+        #s << ">"
+        #s
+      end
+
+      #
+      def parse
+        @parsed     = false
+        @signatures = []
+        @errors     = []
+
+        parse_command(usage, argv.dup)
+
+        @parsed     = true
+
+        return Interface.new(@signatures, @errors)
+      end
+
+      # Has the commandline been parsed?
+      def parsed? ; @parsed ; end
+
+    private
+
+      # TODO: clean-up parsing
+      def parse_command(usage, argv)
+        options    = {}
+        arguments  = []
+        command    = nil
+
+        #greedy = parse_greedy(usage, argv)
+
+        #options.update(greedy)
+
+        until argv.empty?
+          use, val = parse_option(usage, argv)
+          if use
+#p "use: #{use.key}, #{val}"
+            if val == "\t"
+              parse_errors << [val, use]
+            elsif use.multiple?
+              options[use.key] ||= []
+              options[use.key] << val
+            else
+              options[use.key] = val
+            end
+          elsif !usage.arguments.empty?
+            usage.arguments.each do |a|
+              if a.splat
+                while argv.first && argv.first !~ /^[-]/
+                  arguments << argv.shift
+                end
+                break if argv.empty?
+              else
+                arguments << argv.shift
+              end
+            end
+          else
+            break if argv.empty?
+            arg = argv.shift
+            use = usage.commands.find{|c| c === arg}
+            if use
+              parse_command(use, argv)
+              break
+            else
+              parse_errors << [arg, usage]
+              #raise ParseError, "unknown command or argument #{a} for #{usage.key} command"
+              break
+            end
+          end
+        end
+        @signatures.unshift(Signature.new(usage.name, arguments, options))
+      end
+
+=begin
+      # Parse greedy options. This function loops thru ARGV and
+      # removes any matching greedy options.
+      def parse_greedy(usage, argv)
+        options = {}
+        d, i = [], 0
+        while i < argv.size
+          case a = argv[i]
+          when /^[-].+/
+            #res = parse_option(a, i)
+            name, val = *a.split('=')
+            use = usage.greedy_option?(name)
+            if use && use.greedy?
+              d << i
+              if use.flag?
+                val = val || true
+              else
+                val = argv[i+1] unless val
+                i += 1
+                d << i
+              end
+              options[use.key] = val
+            end
+            res = val
+          end
+          i += 1
+        end
+        d.each{ |i| argv[i] = nil }
+        argv.compact!
+        return options
+      end
+=end
+
+      #
+      def parse_option(usage, argv)
+        return if argv.first =~ /^[-]+$/
+        return if argv.first !~ /(^-.+|=)/
+        arg = argv.shift
+        name, val = *arg.split('=')
+        if use = usage.option?(name)
+          if use.flag?
+            val = true unless val
+          else
+            val = argv.shift unless val
+          end
+          #options[use.name] = val
+        else
+          parse_errors << [arg, usage.key]
+        end
+        return use, val
+      end
+
+    public
+
+      #
+      def errors
+        @errors
+      end
+
+      alias_method :parse_errors, :errors
+
+    end #class Parser
+
+    #
+    class ParseError < StandardError
+    end
+
+  end #class Usage
+
+end #module Clio
+
+