facets 1.7.46 → 1.8.0

data/{test/lib/facets/more/test_annotation.rb → work/yore/annotation2.rb}

@@ -1,17 +1,175 @@
+require 'facets/core/hash/to_h'
+#require 'facets/more/openobject'
+require 'facets/more/nullclass'
+require 'facets/core/hash/op_div'
+
+#
+
+class Annotations
+
+  def initialize( base )
+    @base, @ann = base, {}
+  end
+
+  def [](name)
+    @ann[name] ||= Annotation.new(@base, name)
+  end
+
+  def []=(name, note)
+    raise ArgumentError unless Annotation === note
+    @ann[name] = note
+  end
+
+  def ==(other) @ann == other.to_h end
+
+  def to_h() @ann end
+
+  def key?(name) @ann.key?(name) end
+
+  def each(&yld)
+    @ann.each(&yld)
+  end
+
+  def update( other )
+    @ann.update( other.to_h )
+    self
+  end
+  private :update
+
+#   def inheritance
+#     anns = Annotations.new(@base)
+#     @base.ancestors.each do |anc|
+#       anc.annotations.each { |k,v|
+#         next if anns.key?(k)
+#         anns[k] = v #.dup
+#       }
+#     end
+#     #@ann.each_key do |name|
+#     #  anns[name] = self[name].heritage
+#     #end
+#     return anns
+#   end
+
+  def annotated_base() @base end
+
+  def method_missing( name, *args, &blk )
+    if key?(name)
+      self[name] #.heritage
+    else
+      if @base.ancestors.any?{|anc| anc.annotations.key?(name)}
+        return self[name].heritage
+        #ann[name].heritage
+      end
+      super
+    end
+  end
+
+end
+
+#
+
+class Annotation < Hash
+
+  def initialize( base, name, orig=nil )
+    @base = base
+    @name = name
+    @orig = orig || self
+    super()
+  end
+
+  def original
+    @orig
+  end
+
+  #def class
+  #  self[:class]
+  #end
+
+  def inspect
+    "#<#{object_class.name}(#{@base}##{@name}) #{super}>"
+  end
+
+  def annotation_name
+    @name
+  end
+
+  def heritage( orig=nil )
+    ah = {}
+    @base.ancestors.reverse_each do |anc|
+      if anc.annotations.key?(@name)
+        anc.annotations[@name].each { |k,v|
+          case v
+          when Module
+            ah[k] = v
+          else
+            ah[k] = v.dup rescue v
+          end
+        }
+      end
+    end
+    a = Annotation.new( @base, @name, orig || @orig )
+    a.send(:replace, ah)
+    a
+  end
+
+  def method_missing( sym, *args, &blk )
+    type = sym.to_s[-1,1]
+    key = sym.to_s.gsub(/[=!?]$/, '').to_sym
+
+    case type
+    when '='
+      @orig[key] = args[0] #, *args, &blk )
+    when '!'
+      #r = super( key, *args, &blk )
+      if self.key?(key)
+        self[key]
+      else
+        self[key] = heritage(self)[key]
+      end
+    else
+      heritage[sym]
+    end
+  end
+
+end
+
+#
+
+class Module
+
+  def annotations
+    @annotations ||= Annotations.new(self)
+  end
+
+  def ann( name=nil, *options )
+    return annotations unless name
+    return name.each{|k,v| ann k,*v} if Hash === name
+    return annotations[name] if options.empty?
+    opt = {}
+    opt.update options.pop if Hash === options.last
+    opt[:class] = options.pop if Class === options.last
+    names = [name].concat options
+    names.each do |name|
+      note = annotations[name]
+      #unless options.empty?
+      #  (hopt[:tags] ||= []) << options
+      #end
+      note.send(:update,opt)
+    end 
+    names
+  end
+
+end
+
+
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|
 #   | |  __/\__ \ |_
 #   |_|\___||___/\__|
 #
-# for lib/facets/more/annotation.rb
-#
-# Extracted Fri Sep 08 20:20:32 EDT 2006
-# Unit Tools Reap Test Extractor
-#
-
-require 'facets/more/annotation.rb'
 
+=begin test
 
   require 'test/unit'
 
@@ -235,15 +393,6 @@ require 'facets/more/annotation.rb'
     end
   end
 
-  class TestAnnotation10 < Test::Unit::TestCase
-    class C
-      ann :self, :mod => 'YES'
-    end
-    def test_10_01
-      assert_equal( 'YES', C.ann.self.mod )
-    end
-  end
-
 #   class TestAnnotation10 < Test::Unit::TestCase
 #     module M
 #       ann :this, :koko => []
@@ -314,5 +463,4 @@ require 'facets/more/annotation.rb'
 #     end
 #   end
 
-
-
+=end

data/work/yore/commandutils.rb

@@ -0,0 +1,379 @@
+# = command.rb
+#
+# == Copyright (c) 2005 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.
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+# == Developer Notes
+#
+#   TODO Add documentation features. (NOT SO SURE NOW!)
+#
+#   TODO Move to console/command.rb, but I'm not sure yet if
+#        adding subdirectories to more/ is a good idea.
+#
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/core/array/index'
+require 'shellwords'
+
+module Console
+
+# = Console CommandUtils
+
+module CommandUtils
+
+  module_function
+
+  # Basic command parser.
+  #
+  # Partitions the command line into flags and arguments.
+  # Flags are converted to a associative array and then the
+  # two parts are returned.
+  #
+  #   line = "--trace stamp --file=VERSION"
+  #
+  #   argv,keys = *parse_command(line)
+  #
+  #   argv #=> ["stamp"]
+  #   keys #=> [["trace",true], ["file","VERSION"]]
+  #
+
+  def parse_command( line=nil, arity={} )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    argv = parse_flags( argv, arity )
+
+    keys, args = argv.partition{ |a| Array === a }
+
+    keys = format_flags(keys)
+
+    return args, keys
+  end
+
+
+  # Subcommand.
+  #
+  # Subcommand parsing assumes that the first non-flag
+  # entry is a subcommand, followed by subcommand flags.
+  #
+
+  def parse_subcommand( line=nil, arity={} )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    argv, glbl = parse_front_flags( argv, arity )
+
+    cmd = argv.shift
+
+    args, keys = parse_command(argv, arity)
+
+    return cmd, args, keys, glbl
+  end
+
+
+  # Multi-command.
+  #
+  # Parses a chain of commands from a single command line.
+  # This assumes commands take no free standing arguments,
+  # and rather only utilize option flags.
+  #
+  #   line = "--trace rubyforge --groupid=2014 publish --copy='**/*'
+  #
+  # This method does not support flag arity since each command in
+  # the chain could have it's own arity settings. So '=' must be
+  # used to set a flag parameter.
+
+  def parse_multicommand( line=nil )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    cmds = []
+    argv.unshift(nil)
+    until argv.empty?
+      cmd = argv.shift
+      i = argv.index{ |e| e !~ /^-/ }
+      opts = argv[0...i]  # options
+      keys = format_flags(parse_flags(opts))
+      cmds << [cmd, keys]
+      argv = argv[i..-1]  # chain command
+    end
+
+    return cmds
+  end
+
+  # Parse flags takes the command line and
+  # transforms it such that flags (eg. -x and --x)
+  # are elemetnal associative arrays.
+  #
+  #   line = "--foo hello --try=this"
+  #
+  #   parse_flags(line) #=> [ [foo,true], hello, ["try","this"] ]
+  #
+
+  def parse_flags( line, arity={} )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    i = 0
+    while i < argv.size
+      arg = argv[i]
+      case arg
+      when /^-/
+        arg = arg.sub(/^-{1,2}/,'')
+        if arg.index('=')
+          key, val = arg.split('=')
+          argv[i] = [key, val||true]
+        elsif arity.key?(arg)
+          cnt = arity[arg]
+          key = arg
+          val = argv[i+1,cnt]
+          argv[i,cnt+1] = [[key, *val]]
+          i += cnt
+        else
+          key = arg
+          argv[i] = [key,true]
+        end
+      end
+      i += 1
+    end
+    return argv
+  end
+
+  # Parse off the front flags of a command line.
+  #
+  #   line = "--trace stamp --file VERSION"
+  #
+  #   argv,keys = *parse_front_flags(line)
+  #
+  #   argv #=> ["stamp", "--file", "VERSION"]
+  #   keys #=> [["trace", true]]
+  #
+  # Provided an arity hash if any flags take free standing
+  # parameters.
+  #
+  #   line = "--level 4 stamp --file VERSION"
+  #
+  #   argv,keys = *parse_front_flags(line, :trace => 1)
+  #
+  #   argv #=> ["stamp", "--file", "VERSION"]
+  #   keys #=> [["level", 4]]
+  #
+
+  def parse_front_flags( line=nil, arity={} )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    keys = []
+    while argv.first =~ /^-/
+      key = argv.shift
+      key.sub!(/^-{1,2}/,'')
+      if name.index('=')
+        key, val = key.split('=')
+      elsif a = arity[name]
+        val = argv.slice!(0,a)
+      else
+        val = true
+      end
+      keys << [key, val]
+    end
+
+    keys = format_flags(keys)
+
+    return argv, keys
+  end
+
+  # Parse out flags across the entire command line.
+  # Flags parsed are the front flags and any specified in the
+  # the +flags+ parameter. The +flags+ parameters can be either
+  # a list of flag names or a name => arity hash.
+  #
+  # Returns the remaining split line and the global flags.
+
+  def parse_global_flags( line=nil, flags={} )
+    argv = parse_line(line)
+    argv = multi_flag(argv)
+
+    keys = []
+    flags.each do |name, arity|
+      while i = argv.index{ |e| e =~ /^-{1,2}#{name}/ }
+        arg = argv[i]
+        if arg.index('=')
+          key, val = arg.split('=')
+          keys << [name,val]
+        elsif arity
+          val = argv.slice!(i+1,arity)
+          keys << [name,val]
+        else
+          keys << [name,true]
+        end
+        argv.delete(i)
+      end
+    end
+
+    i = argv.index{ |e| e !~ /^-/ }
+    glbl = argv[0...i]  # main options
+    argv = argv[i..-1]  # rest of line
+
+    glbl.each do |key|
+      name = key.sub(/^-{1,2}/,'')
+      keys.unshift [name, true]
+    end
+
+    keys = format_flags(keys)
+
+    return argv, keys
+  end
+
+  # First pass parser to split the command line into an
+  # array using Shellwords, if not already so divided.
+
+  def parse_line(line=nil)
+    return ARGV unless line
+    if String === line
+      Shellwords.shellwords(line)
+    else
+      line
+    end
+  end
+
+  # Split single letter option groupings into separate options.
+  # ie. -xyz => -x -y -z
+
+  def multi_flag(argv)
+    argv = argv.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 flags into
+  # hash. This prevents repate option flags. If you need repeat options flags
+  # you can deacitvate this formatting by using the submodule RepeatFlag.
+
+  def format_flags(assoc_array)
+    Hash[*assoc_array.flatten]
+  end
+
+  #
+
+  module NoMultiFlag
+    include CommandUtils
+    module_function *CommandUtils.private_instance_methods(false)
+
+    module_function
+    def multi_flag(argv)
+      argv.dup
+    end
+  end
+
+  #
+
+  module RepeatFlag
+    include CommandUtils
+    module_function *CommandUtils.private_instance_methods(false)
+
+    module_function
+    def format_flags(assoc_array)
+      assoc_array.dup
+    end
+  end
+
+  #
+
+  module RepeatAndNoMultiFlag
+    include CommandUtils
+    module_function *CommandUtils.private_instance_methods(false)
+    include NoMultiFlag
+    module_function :multi_flag
+    include RepeatFlag
+    module_function :format_flags
+  end
+
+end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TCCommand < Test::Unit::TestCase
+
+    include Console
+
+    def test_01
+      line = "-x baz --foo=9 bar"
+      args, keys = CommandUtils::RepeatFlag.parse_command(line)
+      assert_equal(['baz','bar'],args)
+      assert_equal([['x',true],['foo','9']],keys)
+    end
+
+    def test_02
+      line = "-x baz --foo=8 bar"
+      args, keys = CommandUtils.parse_command(line)
+      assert_equal(['baz','bar'],args)
+      assert_equal({'foo'=>'8','x'=>true},keys)
+    end
+
+    def test_03
+      line = "-x baz --foo=7 bar"
+      cmd, args, keys, glbl = CommandUtils.parse_subcommand(line)
+      assert_equal('baz',cmd)
+      assert_equal(['bar'],args)
+      assert_equal({'foo'=>'7'},keys)
+      assert_equal({'x'=>true},glbl)
+    end
+
+    def test_04
+      line = "-x baz --foo=6 bar --zoo='xx'"
+      cmds = CommandUtils.parse_multicommand(line)
+
+      cmd, keys = *cmds[0]
+      assert_equal(nil,cmd)
+      assert_equal({'x'=>true},keys)
+
+      cmd, keys = *cmds[1]
+      assert_equal('baz',cmd)
+      assert_equal({'foo'=>'6'},keys)
+
+      cmd, keys = *cmds[2]
+      assert_equal('bar',cmd)
+      assert_equal({'zoo'=>'xx'},keys)
+    end
+
+    def test_05
+      line = "-x baz --foo 5 bar"
+      args, keys = CommandUtils.parse_command(line, 'foo'=>1)
+      assert_equal(['baz','bar'],args)
+      assert_equal({'x'=>true,'foo'=>'5'},keys)
+    end
+
+  end
+
+=end