facets 1.8.49 → 1.8.51

data/work/yore/commandutils.rb

@@ -1,379 +0,0 @@
-# = 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

data/work/yore/openobject.rb

@@ -1,298 +0,0 @@
-# = openobject.rb
-#
-# == Copyright (c) 2005 Thomas Sawyer, George Moschovitis
-#
-#   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.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-# * George Moschovitis
-
-# Author::    Thomas Sawyer, George Moschovitis
-# Copyright:: Copyright (c) 2005 Thomas Sawyer, George Moschovitis
-# License::   Ruby License
-
-require 'facets/core/kernel/as'
-require 'facets/core/kernel/object_class'
-require 'facets/core/hash/keys_to_sym'
-require 'facets/core/hash/to_proc'
-#require 'facets/more/nullclass'
-
-# = OpenObject
-#
-# OpenObject is similar to OpenStruct, but differs in a couple ways.
-#
-# OpenObject privatizes a few Kernel methods so there are fewer
-# reserved Kernel methods in the object's namespace, reducing
-# potential for name clashes.
-#
-# Also it does not create any methods for the added entries and instead
-# uses a hash ONLY. OpenStruct OTOH creates methods, but is actaully
-# inconsitant in their use --try #dup on an OpenStruct and
-# all the methods disappear. Morevoer, I beleive this feature was
-# added to OpenStruct for speed, but I have not been able to find
-# this advantage in benchmark tests.
-#
-#--
-# Third, when an entry is not found 'null' is returned rather then 'nil'.
-# This allows for run-on entries withuot error. Eg.
-#
-#   OpenObject.new.a.b.c  #=> null
-#++
-
-class OpenObject
-
-  # Privatize a few Kernel methods that are most likely to clash,
-  # but arn't essential here.
-
-  private :class, :clone, :display, :type, :method, :to_a, :to_s
-
-  def initialize( init=nil )
-    case init
-    when Array
-      @table = Hash[*init].keys_to_sym
-    when Hash
-      @table = init.keys_to_sym
-    when NilClass
-      @table = {}
-    when OpenObject
-      @table = init.send(:table).dup
-    else
-      @table = init.to_h.keys_to_sym
-    end
-  end
-
-  def to_openobject ; self    ; end
-
-  def to_a    ; @table.values ; end
-  def to_h    ; @table.dup    ; end
-  def to_hash ; @table.dup    ; end
-
-  # OpenObejct can be converted to an assignment Proc.
-  #
-  #   o = OpenObject.new( :a=>1 )
-  #   p = o.to_proc
-  #   x = OpenObject.new
-  #   p[x]
-  #   x.a #=> 1
-  #
-
-  def to_proc
-    @table.to_proc
-  end
-
-  # How to duplicate.
-
-  def initialize_copy( orig )
-    super
-    @table = @table.dup
-  end
-
-  def inspect
-    s = "<#{object_class}"
-    s << " " << @table.collect{|k,v| "#{k}=#{v.inspect}"}.join(' ') unless @table.empty?
-    s << ">"
-  end
-
-  def marshal_dump
-    @table
-  end
-
-  def marshal_load( tbl )
-    @table = tbl
-  end
-
-  # Compare this object and +other+ for equality.
-
-  def ==(other)
-    return false unless other.kind_of?( object_class )
-    return @table == other.send(:table)  # TODO funcall in future?
-  end
-
-  def method_missing( sym, *args )
-    type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
-
-    if type == '='
-      self[name] = args[0]
-    elsif type == '!' and args.size > 0
-      self[name] = args[0]
-      self
-    else
-      if @table.key?(name)
-        self[name]
-      #elsif @parent
-      #  @parent.__send__(name)
-      else
-        nil
-      end
-    end
-  end
-
-  def [](name)
-    name = name.to_sym
-    #if @table.key?(name)
-      @table[name]
-    #else
-    #  Kernel.null
-    #end
-  end
-
-  def []=(name,val)
-    @table[name.to_sym] = val
-  end
-
-  # For compatibility with other types of hash-like objects.
-  # Also make OpenObject usable via Enumerator.
-
-  def each(&yld)
-    @table.each( &yld )
-  end
-
-private
-
-  # Access to internal table.
-
-  def table ; @table ; end
-
-  #--
-  # TODO Parent feature? Or better only for OpenCascade?
-  #++
-  #def __parent__ ; @parent ; end
-  #def __parent__=(x) ; @parent = x ; end
-
-  def fetch(k)  ; @table[k.to_sym] ; end
-  #def __fetch__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
-
-  def store(k)  ; @table[k.to_sym]=v ; end
-
-  def key?(k) ; @table.key?(k.to_sym) ; end
-
-  def keys    ; @table.keys ; end
-
-  def update( other )
-    other = Hash[*other] if other.is_a?(Array)
-    other.each{ |k, v| @table[k.to_sym] = v }
-  end
-
-  def merge( other )
-    o = dup
-    o.send(:update, other)
-    o
-  end
-
-  # Core Extensions
-
-  class ::Hash
-    # Convert a Hash into an OpenObject.
-
-    def to_openobject
-      OpenObject.new( self )
-    end
-  end
-
-  class ::Proc
-    # Translates a Proc into an OpenObject. By droping an OpenObject into
-    # the Proc, the resulting assignments incured as the procedure is
-    # evaluated produce the OpenObject. This technique is simlar to that
-    # of MethodProbe.
-    #
-    #   p = lambda { |x|
-    #     x.word = "Hello"
-    #   }
-    #   o = p.to_openobject
-    #   o.word #=> "Hello"
-    #
-    # NOTE The Proc must have an arity of one --no more and no less.
-
-    def to_openobject
-      raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
-      o = OpenObject.new
-      self.call( o )
-      o
-    end
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    def test_01_001
-      f0 = OpenObject.new
-      f0[:a] = 1
-      assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_01_002
-      f0 = OpenObject.new( {:a=>1} )
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-  end
-
-  class TC02 < Test::Unit::TestCase
-
-    def test_02_001
-      f0 = OpenObject.new( :f0=>"f0" )
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenObject.new( :f0=>"f0", :h0=>"h0" ), f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_02_002
-      f1 = OpenObject.new( :f1=>"f1" )
-      h1 = { :h1=>"h1" }
-      f1.send(:update,h1)
-      h1.update( f1 )
-      assert_equal( OpenObject.new( :f1=>"f1", :h1=>"h1" ), f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-
-  end
-
-  class TC03 < Test::Unit::TestCase
-
-    def test_03_001
-      fo = OpenObject.new
-      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
-      99.times{ |i|
-        assert_equal( 1, fo.__send__( "n#{i}" ) )
-      }
-    end
-
-  end
-
-  class TC04 < Test::Unit::TestCase
-
-    def test_04_001
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = p.to_openobject
-      assert_equal( "Hello", o.word )
-    end
-
-  end
-
-=end