mack-facets 0.8.2 → 0.8.3

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

@@ -1,315 +0,0 @@
-# = ANSICode
-#
-# Module which makes it very easy to use ANSI codes.
-# These are esspecially nice for beautifying shell output.
-#
-#   include ANSICode
-#
-#   p red, "Hello", blue, "World"
-#   => "\e[31mHello\e[34mWorld"
-#
-#   p red { "Hello" } + blue { "World" }
-#   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
-#
-# == Supported ANSI Comands
-#
-# The following is a list of supported codes.
-#
-#     save
-#     restore
-#     clear_screen
-#     cls             # synonym for :clear_screen
-#     clear_line
-#     clr             # synonym for :clear_line
-#     move
-#     up
-#     down
-#     left
-#     right
-#     display
-#
-#     clear
-#     reset           # synonym for :clear
-#     bold
-#     dark
-#     italic          # not widely implemented
-#     underline
-#     underscore      # synonym for :underline
-#     blink
-#     rapid_blink     # not widely implemented
-#     negative        # no reverse because of String#reverse
-#     concealed
-#     strikethrough   # not widely implemented
-#
-#     black
-#     red
-#     green
-#     yellow
-#     blue
-#     magenta
-#     cyan
-#     white
-#
-#     on_black
-#     on_red
-#     on_green
-#     on_yellow
-#     on_blue
-#     on_magenta
-#     on_cyan
-#     on_white
-#
-# == Authors
-#
-# * Florian Frank
-# * Thomas Sawyer
-#
-# == Speical Thanks
-#
-# Special thanks to Florian Frank. ANSICode is a partial adaptation
-# of ANSIColor, Copyright (c) 2002 Florian Frank, LGPL.
-#
-# == Todo
-#
-# * Need to add rest of ANSI codes. Include modes?
-# * Re-evaluate how color/yielding methods are defined.
-# * Maybe up, down, right, left should have yielding methods too?
-#
-# == Copying
-#
-# Copyright (c) 2004 Florian Frank, 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.
-
-
-# = ANSICode
-#
-# Module which makes it very easy to use ANSI codes.
-# These are esspecially nice for beautifying shell output.
-#
-#   include ANSICode
-#
-#   p red, "Hello", blue, "World"
-#   => "\e[31mHello\e[34mWorld"
-#
-#   p red { "Hello" } + blue { "World" }
-#   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
-#
-# == Supported ANSI Comands
-#
-# The following is a list of supported codes.
-#
-#     save
-#     restore
-#     clear_screen
-#     cls             # synonym for :clear_screen
-#     clear_line
-#     clr             # synonym for :clear_line
-#     move
-#     up
-#     down
-#     left
-#     right
-#     display
-#
-#     clear
-#     reset           # synonym for :clear
-#     bold
-#     dark
-#     italic          # not widely implemented
-#     underline
-#     underscore      # synonym for :underline
-#     blink
-#     rapid_blink     # not widely implemented
-#     negative        # no reverse because of String#reverse
-#     concealed
-#     strikethrough   # not widely implemented
-#
-#     black
-#     red
-#     green
-#     yellow
-#     blue
-#     magenta
-#     cyan
-#     white
-#
-#     on_black
-#     on_red
-#     on_green
-#     on_yellow
-#     on_blue
-#     on_magenta
-#     on_cyan
-#     on_white
-#
-module ANSICode
-
-  extend self
-
-  # Save current cursor positon.
-
-  def save
-    "\e[s"
-  end
-
-  # Restore saved cursor positon.
-
-  def restore
-    "\e[u"
-  end
-
-  # Clear the screen and move cursor to home.
-
-  def clear_screen
-    "\e[2J"
-  end
-  alias_method :cls, :clear_screen
-
-  # Clear to the end of the current line.
-
-  def clear_line
-    "\e[K"
-  end
-  alias_method :clr, :clear_line
-
-  #--
-  #def position
-  #  "\e[#;#R"
-  #end
-  #++
-
-  # Move curose to line and column.
-
-  def move( line, column=0 )
-    "\e[#{line.to_i};#{column.to_i}H"
-  end
-
-  # Move cursor up a specificed number of spaces.
-
-  def up( spaces=1 )
-    "\e[#{spaces.to_i}A"
-  end
-
-  # Move cursor down a specificed number of spaces.
-
-  def down( spaces=1 )
-    "\e[#{spaces.to_i}B"
-  end
-
-  # Move cursor left a specificed number of spaces.
-
-  def left( spaces=1 )
-    "\e[#{spaces.to_i}D"
-  end
-
-  # Move cursor right a specificed number of spaces.
-
-  def right( spaces=1 )
-    "\e[#{spaces.to_i}C"
-  end
-
-  # Like +move+ but returns to original positon
-  # after yielding block or adding string argument.
-
-  def display( line, column=0, string=nil ) #:yield:
-    result = "\e[s"
-    result << "\e[#{line.to_i};#{column.to_i}H"
-    if block_given?
-      result << yield
-      result << "\e[u"
-    elsif string
-      result << string
-      result << "\e[u"
-    elsif respond_to?(:to_str)
-      result << self
-      result << "\e[u"
-    end
-    return result
-  end
-
-  # Define color codes.
-
-  def self.define_ansicolor_method(name,code)
-    class_eval <<-HERE
-      def #{name.to_s}(string = nil)
-          result = "\e[#{code}m"
-          if block_given?
-              result << yield
-              result << "\e[0m"
-          elsif string
-              result << string
-              result << "\e[0m"
-          elsif respond_to?(:to_str)
-              result << self
-              result << "\e[0m"
-          end
-          return result
-      end
-    HERE
-  end
-
-  @@colors = [
-    [ :clear        ,   0 ],
-    [ :reset        ,   0 ],     # synonym for :clear
-    [ :bold         ,   1 ],
-    [ :dark         ,   2 ],
-    [ :italic       ,   3 ],     # not widely implemented
-    [ :underline    ,   4 ],
-    [ :underscore   ,   4 ],     # synonym for :underline
-    [ :blink        ,   5 ],
-    [ :rapid_blink  ,   6 ],     # not widely implemented
-    [ :negative     ,   7 ],     # no reverse because of String#reverse
-    [ :concealed    ,   8 ],
-    [ :strikethrough,   9 ],     # not widely implemented
-    [ :black        ,  30 ],
-    [ :red          ,  31 ],
-    [ :green        ,  32 ],
-    [ :yellow       ,  33 ],
-    [ :blue         ,  34 ],
-    [ :magenta      ,  35 ],
-    [ :cyan         ,  36 ],
-    [ :white        ,  37 ],
-    [ :on_black     ,  40 ],
-    [ :on_red       ,  41 ],
-    [ :on_green     ,  42 ],
-    [ :on_yellow    ,  43 ],
-    [ :on_blue      ,  44 ],
-    [ :on_magenta   ,  45 ],
-    [ :on_cyan      ,  46 ],
-    [ :on_white     ,  47 ],
-  ]
-
-  @@colors.each do |c, v|
-    define_ansicolor_method(c, v)
-  end
-
-  ColoredRegexp = /\e\[([34][0-7]|[0-9])m/
-
-  def uncolored(string = nil)
-    if block_given?
-      yield.gsub(ColoredRegexp, '')
-    elsif string
-      string.gsub(ColoredRegexp, '')
-    elsif respond_to?(:to_str)
-      gsub(ColoredRegexp, '')
-    else
-      ''
-    end
-  end
-
-  module_function
-
-  def colors
-    @@colors.map { |c| c[0] }
-  end
-
-end
-

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

@@ -1,365 +0,0 @@
-# = ArgVector
-#
-# == Synopsis
-#
-# ArgVector provides a very simple means of parsing
-# command line arguments.
-#
-# Unlike other more complex libs this provides only
-# the most basic and standard parsing functionality.
-# In many cases that's all one really needs.
-#
-# Usage is straight foward. Simply instantiate the
-# class and query it for the particular "views" of
-# the command line you want.
-#
-#   cargs = ArgVector.new("-a foo -b=2")
-#
-#   cargs.parameters    #=> [['foo'],{'a'=>true,'b'=>'2'}]
-#   cargs.flags         #=> ['a']
-#   cargs.preoptions    #=> {'a'=>true}
-#   cargs.preflags      #=> ['a']
-#   cargs.subcommand    #=> ['foo',{'b'=>'2'}]
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2006 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 'please use argvector.rb for future versions'
-
-require 'shellwords'
-
-module CLI
-
-  # = CLI::Arguments
-  #
-  # CLI::Arguments provides a very simple means of parsing
-  # command line arguments.
-  #
-  # Unlike other more complex libs this provides only
-  # the most basic and standard parsing functionality.
-  # In many cases that's all one really needs.
-  #
-  # Usage is straight foward. Simply instantiate the
-  # class and query it for the particular "views" of
-  # the command line you want.
-  #
-  #   cargs = CLI::Arguments.new("-a foo -b=2")
-  #
-  #   cargs.parameters    #=> [['foo'],{'a'=>true,'b'=>'2'}]
-  #   cargs.flags         #=> ['a']
-  #   cargs.preoptions    #=> {'a'=>true}
-  #   cargs.preflags      #=> ['a']
-  #   cargs.subcommand    #=> ['foo',{'b'=>'2'}]
-  #
-  class Arguments
-
-    def self.parameters(*args)
-      new.parameters(*args)
-    end
-
-    attr :line
-    attr :argv
-    attr :arity
-    #attr :opts
-
-    #alias :flags :options
-
-    # Takes the command line string (or array) and options.
-    # Options have flags and end with a hash of option arity.
-    #
-    def initialize(line=nil, arity=nil)
-      @line, @argv  = parse_line(line)
-      @arity = parse_arity(arity||{})
-      parse
-    end
-
-    public
-
-    # Returns operand array.
-
-    def operands
-      @operands
-    end
-    
-    # deprecate alias ?
-    alias arguments operands
-
-    # Returns options hash.
-
-    def options
-      @options
-    end
-
-    # Returns [operands, options], which is good for plugging
-    # directly into a method.
-
-    def parameters
-      return @operands, @options
-    end
-
-    # Return flags, which are true options.
-
-    def flags
-      f = []
-      @options.each do |k, v|
-        if TrueClass===v or FalseClass===v  # not that it's ever false
-          f << k
-        end
-      end
-      return f
-    end
-
-    # Assumes the first operand is a "subcommand" and
-    # returns it and the argments following it as
-    # parameters.
-
-    def subcommand_with_parameters
-      opts, args = *parse_preoptions(argv)
-      cmd = args.shift
-      subargs = self.class.new(args, @arity)
-      return [cmd, *subargs.parameters]
-    end
-
-    alias subcommand subcommand_with_parameters
-
-    #
-    def subcommand_with_preoptions
-      pre, args = *parse_preoptions(argv)
-      cmd = args.shift
-      subargs = self.class.new(args, @arity)
-      args, opts = *subargs.parameters
-      return [cmd, args, pre.merge(opts)]
-    end
-
-    # Assumes the first operand is a "subcommand" and
-    # returns it and the argments following it as
-    # another Arguments object.
-    #
-    # TODO: This probably should be called 'subcommand'.
-    #
-    def subcommand_with_arguments
-      opts, args = *parse_preoptions(argv)
-      cmd = args.shift
-      subargs = self.class.new(args, @arity)
-      return cmd, subargs
-    end
-
-    # Returns a hash of options that occur before
-    # the first operand. This works well with
-    # subcommand to get the main command's options.
-    #
-    #   line = "--trace stamp --file VERSION"
-    #   cargs = CLI::Arguments.new(line)
-    #   opts = cargs.preoptions
-    #   opts #=> {"trace"=>true}
-
-    def preoptions
-      preopts, remainder = *parse_preoptions(argv)
-      return preopts
-    end
-
-    # Same as +flags+ but only returns flags in the
-    # preoptions.
-
-    def preflags
-      preopts, remainder = *parse_preoptions(argv)
-      f = []
-      preopts.each do |k, v|
-        if TrueClass===v or FalseClass===v  # not that it's ever false
-          f << k
-        end
-      end
-      return f
-    end
-
-    # Like parameters but without allowing for duplicate options.
-
-    def parameters_without_duplicates
-      opts = {}
-      @options.each do |k,v|
-        if Array===v
-          opts[k] = v[0]
-        else
-          opts[k] =  v
-        end
-      end
-      return @operands, opts
-    end
-
-    private # ------------------
-
-    # Basic parser partitions the command line into options and
-    # operands. Options are converted to a hash and the two 
-    # parts are returned.
-    #
-    #   line = "--trace stamp --file=VERSION"
-    #
-    #   args, keys = *parse_command(line)
-    #
-    #   args #=> ["stamp"]
-    #   keys #=> {"trace"=>true, "file"=>"VERSION"}
-    #
-    def parse
-      args = assoc_options(argv) #, *opts_arity)
-
-      opts, opds = args.partition{ |a| Array === a }
-
-      @operands = opds
-      @options  = format_options(opts)
-
-      return @operands, @options
-    end
-
-    # First pass parser to split the command line into an
-    # array using Shellwords, if not already so divided.
-
-    def parse_line(line=nil)
-      if line
-        case line
-        when String
-          argv = Shellwords.shellwords(line)
-        else
-          argv = line.to_ary.dup
-          line = argv.join(' ')
-        end
-      else
-        argv = ARGV.dup
-        line = argv.join(' ')
-      end
-      return line, argv
-    end
-
-    # Ensure opts are a uniform.
-    #
-    #def clean_opts( opts )
-    #  opts2 = opts.collect{ |o| o.to_sym }
-    #  opts2 = opts2 & [:simple, :repeat]  # valid options only
-    #  return opts2
-    #end
-
-    # Ensure arity is uniform.
-
-    def parse_arity(arity)
-      arity2 = {}
-      arity.each{ |k,v| arity2[k.to_s] = v.to_i }
-      return arity2
-    end
-
-    # Parse preoptions. A "preoption" is one that
-    # occurs before the first operans (if any).
-
-    def parse_preoptions(args)
-      #args = args.dup
-      args = multi_flag(args) #unless opts.include?(:simple)
-
-      flags = []
-      while args.first =~ /^-/
-        key = args.shift
-        key.sub!(/^-{1,2}/,'')
-        if key.index('=')
-          key, val = key.split('=')
-        elsif a = arity[key]
-          val = args.slice!(0,a)
-          val = val.first if a == 1
-        else
-          val = true
-        end
-        flags << [key, val]
-      end
-
-      flags = format_options(flags)
-
-      return flags, args
-    end
-
-    # Parse flags takes the command line and
-    # transforms it such that flags (eg. -x and --x)
-    # are elemental associative arrays.
-    #
-    #   line = "--foo hello --try=this"
-    #
-    #   parse_flags(line) #=> [ [foo,true], hello, ["try","this"] ]
-    #
-    def assoc_options(args)
-      #args = args.dup
-      args = multi_flag(args) #unless opts.include?(:simple)
-
-      i = 0
-      while i < args.size
-        arg = args[i]
-        case arg
-        when /^-/
-          arg = arg.sub(/^-{1,2}/,'')
-          if arg.index('=')
-            key, val = arg.split('=')
-            args[i] = [key, val||true]
-          elsif arity.key?(arg)
-            cnt = arity[arg]
-            key = arg
-            val = args[i+1,cnt]
-            args[i,cnt+1] = [[key, *val]]
-            i += (cnt - 1)
-          else
-            key = arg
-            args[i] = [key,true]
-          end
-        end
-        i += 1
-      end
-      return args
-    end
-
-    # Split single letter option groupings into separate options.
-    # ie. -xyz => -x -y -z
-
-    def multi_flag(args=nil)
-      args ||= argv
-      args.collect { |arg|
-        if md = /^-(\w{2,})/.match( arg )
-          md[1].split(//).collect { |c| "-#{c}" }
-        else
-          arg.dup
-        end
-      }.flatten
-    end
-
-    # Format flag options. This converts the associative array of
-    # options/flags into a hash. Repeat options will be placed in arrays.
-
-    def format_options(assoc_options)
-      opts = {}
-      assoc_options.each do |k,v|
-        if opts.key?(k)
-          opts[k] = [opts[k]].flatten << v
-        else
-          opts[k] = v
-        end
-      end
-      return opts
-    end
-
-  end
-
-end
-
-# For backward compatibiltiy
-module Console #:nodoc:
-  Arguments = CLI::Arguments
-end
-
-