mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/command.rb

@@ -0,0 +1,439 @@
+# == CLI::Command
+#
+# Here is an example of usage:
+#
+#   # General Options
+#
+#   module GeneralOptions
+#     attr_accessor :dryrun ; alias_accessor :n, :noharm, :dryrun
+#     attr_accessor :quiet  ; alias_accessor :q, :quiet
+#     attr_accessor :force
+#     attr_accessor :trace
+#   end
+#
+#   # Build Subcommand
+#
+#   class BuildCommand < CLI::Command
+#     include GeneralOptions
+#
+#     # metadata files
+#     attr_accessor  :file     ; alias_accessor :f, :file
+#     attr_accessor  :manifest ; alias_accessor :m, :manifest
+#
+#     def call
+#       # do stuf here
+#     end
+#   end
+#
+#   # Box Master Command
+#
+#   class BoxCommand < CLI::Command
+#     subcommand :build,     BuildCommand
+#   end
+#
+#   BoxCommand.start
+#
+# == Authors
+#
+# * Trans
+#
+# == Todo
+#
+# * Move helpers into core.
+# * Add global options to master command, or "all are master options" flag (?)
+# * Add usage/help/documentation/man features (?)
+#
+# == Copying
+#
+# Copyright (c) 2005,2008 Thomas Sawyer
+#
+# 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.
+
+warn "command.rb will be deprecated, use clio instead (clio.rubyforge.org)"
+
+require 'facets/arguments'
+require 'facets/consoleutils'
+require 'facets/array/not_empty'
+
+module CLI
+
+  # For CommandOptions, but defined external to it, so
+  # that it is easy to access from user defined commands.
+  # (This lookup issue should be fixed in Ruby 1.9+, and then
+  # the class can be moved back into Command namespace.)
+
+  class NoOptionError < NoMethodError
+    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
+
+  # Here is an example of usage:
+  #
+  #   # General Options
+  #
+  #   module GeneralOptions
+  #     attr_writer :dryrun ; alias_writer :n, :noharm, :dryrun
+  #     attr_writer :quiet  ; alias_writer :q, :quiet
+  #     attr_writer :force
+  #     attr_writer :trace
+  #   end
+  #
+  #   # Build Subcommand
+  #
+  #   class BuildCommand < Command
+  #     include GeneralOptions
+  #
+  #     # metadata files
+  #     attr_writer  :file     ; alias_writer :f, :file
+  #     attr_writer  :manifest ; alias_writer :m, :manifest
+  #
+  #     def call
+  #       # do stuf here
+  #     end
+  #   end
+  #
+  #   # Box Master Command
+  #
+  #   class BoxCommand < CLI::Command
+  #     subcommand :build,     BuildCommand
+  #   end
+  #
+  #   BoxCommand.start
+
+  class Command
+
+    # Include this in your dispatch command if you want
+    # all options to be traeted the same.
+
+    module UniversalOptions
+    end
+
+    #
+
+    def self.option_arity(arity_hash=nil)
+      @option_arity ||= {}
+      if arity_hash
+        @option_arity.merge!(arity_hash)
+      end
+      @option_arity
+    end
+
+    #
+
+    def self.start(line=nil)
+      cargs = Arguments.new(line || ARGV, option_arity)
+      pre = cargs.preoptions
+
+      if instance_method(:call).arity == 0 #is_a?(SingleCommand)
+        args, opts = *cargs.parameters
+        new(args, opts).call
+      else
+        subc, args, opts = *cargs.subcommand
+        if self < UniversalOptions
+          new(pre, opts).call(subc, args, opts)
+        else
+          new(pre).call(subc, args, opts)
+        end
+      end
+    end
+  
+    # Command Arguments (for single commands).
+
+    attr :arguments
+
+    # Command options. For dispatch commands these are the pre-options.
+
+    attr :options
+
+    # For dispatchers, this is a convenience method for creating subcommands.
+
+    def self.subcommand(name, command_class, options=nil)
+      options ||= {}
+      if options[:no_merge]
+        file, line = __FILE__, __LINE__+1
+        code = %{
+          def #{name}(args, opts)
+            #{command_class}.new(args, opts).call
+          end
+        }
+      else
+        file, line = __FILE__, __LINE__+1
+        code = %{
+          def #{name}(args, opts)
+            opts.merge(options)
+            #{command_class}.new(args, opts).call
+          end
+        }
+      end
+      class_eval(code, file, line)
+    end
+
+    private
+
+    #
+
+    def initialize(*args)
+      @arguments = []
+      @options   = {}
+
+      opts, args = *args.partition{ |e| Hash===e }
+      #TEST("options should all be hashes"){ ! opts.all?{ |e| Hash===e }
+      initialize_arguments(*args)
+      initialize_options(*opts)
+    end
+
+    #
+
+    def initialize_arguments(*arguments)
+      @arguments.concat(arguments)
+    end
+
+    #
+
+    def initialize_options(*options)
+      options = options.inject{ |h,o| h.merge(o) }
+      begin
+        opt, val = nil, nil
+        options.each do |opt, val|
+          opt = opt.gsub('-','_')
+          send("#{opt}=", val)
+        end
+      rescue NoMethodError
+        option_missing(opt, val)
+      end
+      @options.update(options)
+    end
+
+    public
+
+    # For a single command (ie. a subcommand) override #call with arity=0.
+
+    def call(cmd=nil, *args)
+      opts = Hash==args.last ? args.pop : {}
+      #TEST("options should all be hashes"){ ! opts.all?{ |e| Hash===e }
+      #cmd = :default if cmd.nil?
+      if cmd.nil?
+        default
+      else
+        begin
+          # FIXME: rename call to [] ?
+          raise NameError if cmd == 'call'
+          raise NameError unless commands.include?(cmd.to_sym)
+          subcommand = method(cmd)
+          parameters = [args, opts]
+        rescue NameError
+          subcommand = method(:command_missing)
+          parameters = [cmd, args, opts]
+        end
+        if subcommand.arity < 0
+          subcommand.call(*parameters[0..subcommand.arity])
+        else
+          subcommand.call(*parameters[0,subcommand.arity])
+        end
+      end
+    end
+
+    # Display help message.
+    # The one provided is just a very limited dummy routine.
+
+#    def help
+#      puts "USAGE #{File.basename($0)} [options]"
+#      puts "\nOptions:"
+#      options = self.class.instance_methods(false)
+#      options = options - Command.instance_methods(true)
+#      options = options.select{ |m| m.to_s =~ /=$/ }
+#      options.each do |opt|
+#        puts "  --#{opt.to_s.chomp('=')}"
+#      end
+#    end
+
+    private
+
+    # Override default to provide non-subcommand functionality.
+
+    def default; end
+
+    #
+    def commands
+      @_commands ||= (
+        cmds = self.class.instance_methods(true) - Command.instance_methods(true)
+        cmds.select{ |c| c !~ /\W/ }
+        cmds.collect{ |c| c.to_sym }
+      )     
+    end
+
+    #
+
+    def command_missing(cmd, args, opt)
+      raise NoCommandError.new(cmd, args << opt)
+    end
+
+    #
+
+    def option_missing(opt, arg=nil)
+      raise NoOptionError.new(opt)
+    end
+
+  end
+
+  # Temporary backward compatability.
+  MasterCommand = Command
+
+end
+
+
+module Console #:nodoc:
+  # For backward compatibility.
+  Command = CLI::Command
+end
+
+
+# SCRAP CODE FOR REFERENCE TO POSSIBLE ADD FUTURE FEATURES
+
+=begin
+
+  # We include a module here so you can define your own help
+  # command and call #super to utilize this one.
+
+  module Help
+
+    def help
+      opts = help_options
+      s = ""
+      s << "#{File.basename($0)}\n\n"
+      unless opts.empty?
+        s << "OPTIONS\n"
+        s << help_options
+        s << "\n"
+      end
+      s << "COMMANDS\n"
+      s << help_commands
+      puts s
+    end
+
+    private
+
+    def help_commands
+      help = self.class.help
+      bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+      lines = []
+      help.each { |cmd, str|
+        cmd = cmd.to_s
+        if cmd !~ /^_/
+          lines << "  " + cmd + (" " * (bufs - cmd.size)) + str
+        end
+      }
+      lines.join("\n")
+    end
+
+    def help_options
+      help = self.class.help
+      bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+      lines = []
+      help.each { |cmd, str|
+        cmd = cmd.to_s
+        if cmd =~ /^_/
+          lines << "  " + cmd.gsub(/_/,'-') + (" " * (bufs - cmd.size)) + str
+        end
+      }
+      lines.join("\n")
+    end
+
+    module ClassMethods
+
+      def help( str=nil )
+        return (@help ||= {}) unless str
+        @current_help = str
+      end
+
+      def method_added( meth )
+        if @current_help
+          @help ||= {}
+          @help[meth] = @current_help
+          @current_help = nil
+        end
+      end
+
+    end
+
+  end
+
+  include Help
+  extend Help::ClassMethods
+
+=end
+
+=begin
+
+   # Provides a very basic usage help string.
+    #
+    # TODO Add support for __options.
+    def usage
+      str = []
+      public_methods(false).sort.each do |meth|
+        meth = meth.to_s
+        case meth
+        when /^_/
+          opt = meth.sub(/^_+/, '')
+          meth = method(meth)
+          if meth.arity == 0
+            str << (opt.size > 1 ? "[--#{opt}]" : "[-#{opt}]")
+          elsif meth.arity == 1
+            str << (opt.size > 1 ? "[--#{opt} value]" : "[-#{opt} value]")
+          elsif meth.arity > 0
+            v = []; meth.arity.times{ |i| v << 'value' + (i + 1).to_s }
+            str << (opt.size > 1 ? "[--#{opt} #{v.join(' ')}]" : "[-#{opt} #{v.join(' ')}]")
+          else
+            str << (opt.size > 1 ? "[--#{opt} *values]" : "[-#{opt} *values]")
+          end
+        when /=$/
+          opt = meth.chomp('=')
+          str << (opt.size > 1 ? "[--#{opt} value]" : "[-#{opt} value]")
+        when /!$/
+          opt = meth.chomp('!')
+          str << (opt.size > 1 ? "[--#{opt}]" : "[-#{opt}]")
+        end
+      end
+      return str.join(" ")
+    end
+
+    #
+
+    def self.usage_class(usage)
+      c = Class.new(self)
+      argv = Shellwords.shellwords(usage)
+      argv.each_with_index do |name, i|
+        if name =~ /^-/
+          if argv[i+1] =~ /^[(.*?)]/
+            c.class_eval %{
+              attr_accessor :#{name}
+            }
+          else
+            c.class_eval %{
+              attr_reader :#{name}
+              def #{name}! ; @#{name} = true ; end
+            }
+          end
+        end
+      end
+      return c
+    end
+
+  end
+
+=end

data/lib/gems/facets-2.4.5/lib/more/facets/consoleutils.rb

@@ -0,0 +1,113 @@
+# = 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
+
+
+# = ConsoleUtils
+#
+# ConsoleUtils provides methods that are
+# generally useful in the context of
+# creating console output.
+#
+module ConsoleUtils
+
+  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
+