clio 0.0.1

data/lib/clio/commandline.rb

@@ -0,0 +1,275 @@
+require 'shellwords'
+require 'facets/kernel/object_class'
+require 'facets/array/indexable'
+
+module Clio
+  ### = Commandline
+  ###
+  ### What a strange thing is the Clio Commandline.
+  ### An entity unknown until put upon.
+  ###
+  ###   cmd = Clio::Commandline.new("--force copy --file try.rb")
+  ###   cmd.option_alias(:f?, :force?)
+  ###   cmd.option_alias(:o, :file)
+  ###
+  ###   cmd.file   #=> 'try.rb'
+  ###   cmd.force? #=> true
+  ###   cmd.o      #=> 'try.rb'
+  ###   cmd.f?     #=> true
+  ###
+  ### TODO: Allow option setter methods (?)
+  ### TODO: Allow a hash as argument to initialize (?)
+  class Commandline
+    instance_methods.each{ |m| private m if m !~ /^(__|instance_|object_|send$|inspect$)/ }
+
+    ### Splits a raw command line into two smaller
+    ### ones. The first including only options
+    ### upto the first non-option argument. This
+    ### makes quick work of separating a subcommand
+    ### from the options for a main command.
+    # TODO: Rename this method.
+    def self.gerrymander(argv=ARGV)
+      if String===argv
+        argv = Shellwords.shellwords(argv)
+      end
+      sub = argv.find{ |x| x !~ /^[-]/ }
+      idx = argv.index(sub)
+      opts = argv[0...idx]
+      scmd = argv[idx..-1]
+      return opts, scmd
+    end
+
+    ### Define an option attibute.
+    ### While commandline can be used without
+    ### pre-declartion of support options
+    ### doding so allows for creating option
+    ### aliases. Eg. --quiet and -q.
+    def self.attr(name, *aliases)
+      (@predefined_options ||= []) << [name, *aliases]
+
+      name = name.to_s
+      if name =~ /\?$/
+        key = name.chomp('?')
+        #attr_writer name
+        module_eval "def #{key}?; @#{key} ; end"
+        aliases.each do |alt|
+          alt = alt.to_s.chomp('?')
+          alias_method("#{alt}?", "#{key}?")
+          #alias_method("#{alt}=", "#{name}=")
+        end
+      else
+        attr_reader name
+        #module_eval "def #{name}; self[:#{name}] ; end"
+        aliases.each do |alt|
+          #alt = alt.to_s.chomp('?')  # TODO: raise error ?
+          alias_method("#{alt}" , "#{name}")
+          #alias_method("#{alt}=", "#{name}=")
+        end
+      end
+    end
+
+    ### Returns a list of all pre-defined options.
+    ### It does this by seaching class ancestry
+    ### for instance_methods until it reaches the
+    ### Commandline base class.
+    ### TODO: Rename #runmodes method.
+    ### TODO: Robust enough? Use an Inheritor instead?
+    def self.predefined_options
+      @predefined_options ||= []
+      ancestor = ancestors[1]
+      if ancestor > ::Clio::Commandline
+        @predefined_options
+      else
+        @predefined_options | ancestor.predefined_options
+      end
+    end
+
+  public
+
+    ### This method provides the centralized means 
+    ### of accessing the options and arguments on
+    ### the commandline.
+    def [](index)
+      case index
+      when Integer
+        @arguments[index] ||= (
+          args = @argv.select{ |e| e !~ /^-/ }
+          val = args[index]
+          @argv.delete(args[index])
+          val
+        )
+      else
+        return send(index) if respond_to?(index)
+        key = index.to_s.chomp('?')
+        val = option_parse(index)
+        instance_variable_set("@#{key}", val)
+        (class << self; self; end).class_eval %{
+           def #{index}; @#{key}; end
+        }
+        return val
+      end
+    end
+
+    def shift!
+      args = @argv.select{ |e| e !~ /^-/ }
+      val = args.first
+      @argv.delete(val)
+      val
+    end
+
+    ### Define an option alias. This adds en entry to 
+    ### the aliases hash, pointing new to a list of
+    ### all aliases and the first entry on th list
+    ### being the master key.
+    def option_alias(new, old)
+      self[old]
+      key = old.to_s.chomp('?')
+      val = option_parse(new)
+      instance_variable_set("@#{key}", val) if val
+      (class << self; self; end).class_eval do
+        alias_method new, old
+      end
+    end
+
+    ### Access to the underlying commandline "ARGV".
+    ### This will show what is yet to be processed.
+    def instance_delegate ; @argv ; end
+
+    ### Returns a hash of all options parsed.
+    def instance_options
+      h = {}
+      ivs = instance_variables - ['@arguments','@argv']
+      ivs.each do |iv|
+        val = instance_variable_get(iv)
+        h[iv.sub('@','').to_sym] = val if val
+      end
+      h
+    end
+
+    ### Returns a list of all arguments parsed.
+    def instance_arguments
+      @arguments
+    end
+
+  private
+
+    ### New Commandline. Takse a single argument
+    ### which can be a "shell" string, or an array
+    ### of shell arguments, like ARGV. If none
+    ### is given it defaults to ARGV.
+    def initialize(argv=ARGV)
+      case argv
+      when String
+        @argv = Shellwords.shellwords(argv)
+      #when Hash
+      #  argv.each{ |k,v| send("#{k}=", v) }
+      else
+        @argv = argv.dup
+      end
+      @arguments = []
+
+      # parse predefined options attributes.
+      object_class.predefined_options.each do |modes|
+        key = modes.first.to_s.chomp('?')
+        modes.reverse.each do |i|
+          val = option_parse(i)
+          instance_variable_set("@#{key}", val) if val
+        end
+      end
+    end
+
+    ### Routes to #[].
+    def method_missing(name, *args)
+      super unless args.empty?
+      case name.to_s
+      when /\=$/
+        super
+      else
+        self[name]
+      end
+    end
+
+    def option_parse(index)
+      index = index.to_s
+      name  = index.chomp('?')
+      key   = name.to_sym
+
+      kind = name.size == 1 ? 'letter' : 'word'
+      flag = index =~ /\?$/ ? 'flag'   : 'value'
+
+      send("option_#{kind}_#{flag}", key)
+    end
+
+    ### Parse a flag option.
+    def option_word_flag(name)
+      o = "--#{name}"
+      i = @argv.index_of{ |e| e =~ /^#{o}[=]?/ }
+      return false unless i
+      raise ArgumentError if @argv[i] =~ /=/
+      @argv.delete_at(i)
+      return true
+    end
+
+    ### Parse a value option.
+    def option_word_value(name)
+      o = "--#{name}"
+      i = @argv.index_of{ |e| e =~ /^#{o}[=]?/ }
+      return false unless i
+
+      if @argv[i] =~ /=/
+        key, val = *@argv[i].split('=')
+        argv[i] = nil
+      else
+        case @argv[i+1]
+        when nil, /^-/
+          raise ArgumentError
+        else
+          key = @argv[i]
+          val = @argv[i+1]
+          @argv.delete_at(i) # do it twice
+          @argv.delete_at(i)
+        end
+      end
+      return val
+    end
+
+    ### Parse a single letter flag option.
+    def option_letter_flag(letter)
+      o = letter
+      i = @argv.index_of{ |e| e =~ /[-][^-]\w*(#{o})\w*$/ }
+      if i
+        @argv[i] = @argv[i].gsub(o.to_s,'')
+        true
+      end
+      false
+    end
+
+    ### Parse a single letter value option.
+    def option_letter_value(letter)
+      o = letter
+      i = @argv.index_of{ |e| e =~ /[-]\w*#{o}(\=|$)/ }
+      return nil unless i
+      if @argv[i] =~ /=/
+        rest, val = argv[i].split('=')
+        @argv[i] = rest
+      else
+        case @argv[i+1]
+        when nil, /^-/
+          raise ArgumentError
+        else
+          val = @argv[i+1]
+          new = @argv[i].gsub(o.to_s,'')
+          if new == '-'
+            @argv.delete_at(i)
+          else
+            @argv[i] = new
+          end
+          @argv.delete_at(i+1)
+        end
+      end
+      return val    
+    end
+
+  end
+end
+

data/lib/clio/consoleutils.rb

@@ -0,0 +1,117 @@
+# = Console Utilities
+#
+# ConsoleUtils provides methods that are
+# generally useful in the context of
+# creating console output.
+#
+# = Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2006,2007 Thomas Sawyer
+# Ruby/GPL
+
+
+module Clio
+
+  # = Termninal
+  #
+  # ConsoleUtils provides methods that are
+  # generally useful in the context of
+  # creating console output.
+  #
+  module Terminal
+
+    module_function
+
+    # Convenient method to get simple console reply.
+
+    def ask(question, answers=nil)
+      print "#{question}"
+      print " [#{answers}] " if answers
+      until inp = $stdin.gets ; sleep 1 ; end
+      inp
+    end
+
+    # Convenience method for puts. Use this instead of
+    # puts when the output should be supressed if the
+    # global $QUIET option is set.
+
+    #def say(statement)
+    #  puts statement #unless quiet? $QUIET
+    #end
+
+    # Ask for a password. (FIXME: only for unix so far)
+
+    def password(msg=nil)
+      msg ||= "Enter Password: "
+      inp = ''
+
+      $stdout << msg
+
+      begin
+        system "stty -echo"
+        inp = gets.chomp
+      ensure
+        system "stty echo"
+      end
+
+      return inp
+    end
+
+    # Console screen width (taken from progress bar)
+    #
+    # TODO: Don't know how portable #screen_width is.
+
+    def screen_width(out=STDERR)
+      default_width = ENV['COLUMNS'] || 80
+      begin
+        tiocgwinsz = 0x5413
+        data = [0, 0, 0, 0].pack("SSSS")
+        if out.ioctl(tiocgwinsz, data) >= 0 then
+          rows, cols, xpixels, ypixels = data.unpack("SSSS")
+          if cols >= 0 then cols else default_width end
+        else
+          default_width
+        end
+      rescue Exception
+        default_width
+      end
+    end
+
+    # Print a justified line with left and right entries.
+    #
+    # A fill option can be given to fill in any empty space
+    # between the two. And a ratio option can be given which defaults
+    # to 0.8 (eg. 80/20)
+
+    def print_justified(left, right, options={})
+      fill  = options[:fill] || '.'
+      fill  = ' ' if fill == ''
+      fill  = fill[0,1]
+
+      ratio = options[:ratio] || 0.8
+      ratio = 1 + ratio if ratio < 0
+
+      width = (@screen_width ||= screen_width) - 1
+
+      #l = (width * ratio).to_i
+      r = (width * (1 - ratio)).to_i
+      l = width - r
+
+      left  = left[0,l]
+      right = right[0,r]
+
+      str = fill * width
+      str[0,left.size] = left
+      str[width-right.size,right.size] = right
+
+      print str
+    end
+
+  end
+
+end
+

data/lib/clio/errors.rb

@@ -0,0 +1,16 @@
+module Clio
+
+  class NoOptionError < ::NoMethodError # ArgumentError ?
+    def initialize(name, *arg)
+      super("unknown option -- #{name}", name, *args)
+    end
+  end
+
+  class NoCommandError < ::NoMethodError
+    def initialize(name, *arg)
+      super("unknown subcommand -- #{name}", name, *args)
+    end
+  end
+
+end
+

data/lib/clio/option.rb

@@ -0,0 +1,36 @@
+module Clio
+
+  # 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/progressbar.rb

@@ -0,0 +1,253 @@
+# = Progressbar
+#
+# ProgressBar is a text-based progressbar library.
+#
+# == Usage
+#
+#   pbar = ProgressBar.new( "Demo", 100 )
+#   100.times { pbar.inc }
+#   pbar.finish
+#
+# == Copying
+#
+# Copyright (C) 2001 Satoru Takabayashi
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == Author
+#
+# * Satoru Takabayashi
+
+# = ProgressBar
+#
+# ProgressBar is a text-based progressbar library.
+#
+#   pbar = ProgressBar.new( "Demo", 100 )
+#   100.times { pbar.inc }
+#   pbar.finish
+#
+class ProgressBar
+
+  def initialize(title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @bar_length = 80
+    @bar_mark = "o"
+    @total_overflow = true
+    @current = 0
+    @previous = 0
+    @is_finished = false
+    @start_time = Time.now
+    @format = "%-14s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    show_progress
+  end
+
+  private
+  def convert_bytes (bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time(t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+
+  def stat
+    if @is_finished then elapsed else eta end
+  end
+
+  def stat_for_file_transfer
+    if @is_finished then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def eol
+    if @is_finished then "\n" else "\r" end
+  end
+
+  def bar
+    len = percentage * @bar_length / 100
+    sprintf("|%s%s|", @bar_mark * len, " " *  (@bar_length - len))
+  end
+
+  def percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def title
+    @title[0,13] + ":"
+  end
+
+  def get_width
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map{|method| send(method)}
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if line.length == width - 1
+      @out.print(line + eol)
+    elsif line.length >= width
+      @bar_length = [@bar_length - (line.length - width + 1), 0].max
+      if @bar_length == 0 then @out.print(line + eol) else show end
+    else #line.length < width - 1
+      @bar_length += width - line.length + 1
+      show
+    end
+  end
+
+  def show_progress
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+
+    if cur_percentage > prev_percentage || @is_finished
+      show
+    end
+  end
+
+  public
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def title=(str)
+    @title = str
+  end
+
+  def bar_mark=(mark)
+    @bar_mark = String(mark)[0..0]
+  end
+
+  def total_overflow=(boolv)
+    @total_overflow = boolv ? true : false
+  end
+
+  def format=(format)
+    @format = format
+  end
+
+  def format_arguments=(arguments)
+    @format_arguments = arguments
+  end
+
+  def finish
+    @current = @total
+    @is_finished = true
+    show_progress
+  end
+
+  def flush
+    @out.flush
+  end
+
+  def halt
+    @is_finished = true
+    show_progress
+  end
+
+  def set(count)
+    if count < 0
+      raise "invalid count less than zero: #{count}"
+    elsif count > @total
+      if @total_overflow
+        @total = count + 1
+      else
+        raise "invalid count greater than total: #{count}"
+      end
+    end
+    @current = count
+    show_progress
+    @previous = @current
+  end
+
+  def inc(step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_progress
+    @previous = @current
+  end
+
+  def inspect
+    "(ProgressBar: #{@current}/#{@total})"
+  end
+
+end
+
+
+module Console #:nodoc:
+  # For backward compatibility
+  ProgressBar = ::ProgressBar
+end
+