facets-glimmer 3.2.0

data/lib/core/facets.rb

@@ -0,0 +1,40 @@
+require 'facets/version.rb'
+
+require 'facets/array.rb'
+require 'facets/binding.rb'
+require 'facets/boolean.rb'
+require 'facets/class.rb'
+require 'facets/comparable.rb'
+require 'facets/denumerable.rb'
+require 'facets/dir.rb'
+require 'facets/enumerable.rb'
+require 'facets/enumerator.rb'
+require 'facets/exception.rb'
+require 'facets/file.rb'
+require 'facets/filetest.rb'
+require 'facets/float.rb'
+require 'facets/functor.rb'
+require 'facets/hash.rb'
+require 'facets/indexable.rb'
+require 'facets/integer.rb'
+require 'facets/kernel.rb'
+require 'facets/lazy.rb'
+require 'facets/matchdata.rb'
+require 'facets/method.rb'
+require 'facets/module.rb'
+require 'facets/na.rb'
+require 'facets/nilclass.rb'
+require 'facets/numeric.rb'
+require 'facets/object.rb'
+require 'facets/objectspace.rb'
+require 'facets/proc.rb'
+require 'facets/process.rb'
+require 'facets/range.rb'
+require 'facets/regexp.rb'
+require 'facets/string.rb'
+require 'facets/struct.rb'
+require 'facets/symbol.rb'
+require 'facets/time.rb'
+#require 'facets/to_hash.rb'
+require 'facets/unboundmethod.rb'
+

data/lib/core/facets.yml

@@ -0,0 +1,80 @@
+---
+revision: 2013
+type: ruby
+sources:
+- Indexfile
+- Gemfile
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+organizations:
+- name: Rubyworks
+requirements:
+- groups:
+  - test
+  version: ">= 0"
+  name: lemon
+- groups:
+  - test
+  version: ">= 0"
+  name: qed
+- groups:
+  - test
+  version: ">= 0"
+  name: rubytest-cli
+- groups:
+  - test
+  version: ">= 0"
+  name: rake
+- groups:
+  - test
+  version: ">= 0"
+  name: simplecov
+- groups:
+  - guard
+  version: ">= 0"
+  name: guard
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: https://github.com/AndyObtiva/facets-glimmer
+  label: Homepage
+- type: code
+  uri: https://github.com/AndyObtiva/facets-glimmer
+  label: Source Code
+- type: docs
+  uri: http://rubyworks.github.com/facets/learn.html
+  label: Documentation
+- type: wiki
+  uri: http://wiki.github.com/rubyworks/facets
+  label: User Guide
+- type: talk
+  uri: http://groups.google.com/group/facets-universal
+repositories:
+- name: upstream
+  scm: git
+  uri: git@github.com:rubyworks/facets.git
+categories: []
+copyrights:
+- holder: Rubyworks
+  year: '2004'
+  license: BSD-2-Clause
+customs: []
+paths:
+  load:
+  - lib/core
+  - lib/standard
+name: facets-glimmer
+title: Ruby Facets - Glimmer Edition
+version: 3.2.0
+summary: The orginal well curated collection of extension methods for Ruby.
+slogan: ALL YOUR BASE ARE BELONG TO RUBY!
+description: Facets is the premier collection of extension methods for the Ruby programming
+  language. Facets extensions are unique by virtue of thier atomicity. They are stored
+  in individual files allowing for highly granular control of requirements. In addition,
+  Facets includes a few additional classes and mixins suitable to wide variety of
+  applications.
+scm_uri: https://github.com/AndyObtiva/facets-glimmer/tree/master
+created: '2004-12-16'
+date: '2022-06-17'

data/lib/facets-glimmer/ext/kernel.rb

@@ -0,0 +1,8 @@
+if RUBY_ENGINE == 'rubymotion'
+  def require(*args, &block)
+    # No Op (just a shim for RubyMotion)
+  end
+  def require_relative(*args, &block)
+    # No Op (just a shim for RubyMotion)
+  end
+end

data/lib/facets-glimmer.rb

@@ -0,0 +1,33 @@
+if Object.constants.include?(:Motion)
+  Motion::Project::App.setup do |app|
+    excluded_core_files = [
+      'core/facets/range/nudge.rb',
+      'core/facets/applique/file_helpers.rb',
+      'core/facets/enumerable/recursively.rb',
+      'core/facets/hash/recursively.rb',
+      'core/facets/functor.rb',
+      'core/facets/lazy.rb',
+      'core/facets/enumerable/associate.rb',
+      'core/facets/kernel/as.rb',
+      'core/facets/kernel/ergo.rb',
+    ]
+    excluded_standard_files = [
+      'standard/facets/uri/query.rb',
+      'standard/facets/date.rb',
+      'standard/facets/memoizer.rb',
+      'standard/facets/enumargs.rb',
+      'standard/facets/erb.rb',
+      'standard/facets/fileutils/outofdate.rb',
+      'standard/facets/interval.rb',
+      'standard/facets/pathname/op_div.rb',
+      'standard/facets/pathname/exists.rb',
+    ]
+    app.files += Dir[File.join(__dir__, 'facets-glimmer', 'ext', 'kernel.rb')]
+    app.files += Dir[File.join(__dir__, 'core', '**' , '*.rb')].reject do |f|
+      excluded_core_files.any? { |excluded_file| f.include?(excluded_file) }
+    end
+    app.files += Dir[File.join(__dir__, 'standard', '**' , '*.rb')].reject do |f|
+      excluded_standard_files.any? { |excluded_file| f.include?(excluded_file) }
+    end
+  end
+end

data/lib/standard/facets/against.rb

@@ -0,0 +1,53 @@
+require 'facets/functor'
+
+class Object
+
+  # Objectified message or block application. Only a message
+  # or a block can be given, not both.
+  #
+  # msg - method and arguments [Array]
+  # blk - procedure block [Proc]
+  #
+  # Examples
+  #
+  #   a = [1,2,3,4,5]
+  #   c = a.against(:>, 2)
+  #   c.select  #=> [3,4,5]
+  #
+  #   a = [1,2,3,4,5]
+  #   c = a.against(:>)
+  #   c.select(2)  #=> [3,4,5]
+  #
+  # Returns [Functor]
+  #
+  # TODO: Better name for this method?
+
+  def against(*msg, &blk)
+    raise ArgumentError, "too many arguments" if blk && !msg.empty?
+
+	  this = self
+
+    blk = ::Proc.new{ |x,*a| x.__send__(*msg, *a) } unless blk
+
+    #if blk
+		  Functor.new do |m, *a, &b|
+			  if b
+			    b2 = ::Proc.new{ |*x| blk.call(*b.call(*x), *a) }
+        else
+          b2 = blk
+			  end
+			  this.__send__(m, &b2)
+		  end
+    #else
+	  #	Functor.new do |m, *a, &b|
+	  #		if b
+	  #		  b2 = ::Proc.new{ |*x| b.call(*x).__send__(*msg, *a) }
+	  #		else
+	  #		  b2 = ::Proc.new{ |x| x.__send__(*msg, *a) }
+	  #		end
+	  #		this.__send__(m, &b2)
+	  #	end
+    #end
+  end
+
+end

data/lib/standard/facets/argvector.rb

@@ -0,0 +1,343 @@
+# = 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 / BSD-2 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.
+
+require 'shellwords'
+
+# = Argvector
+#
+# 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'}]
+#
+class Argvector
+
+  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 = Argvector.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"
+  #   argv = Argvector.new(line)
+  #
+  #   args, keys = *argv.parse
+  #
+  #   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"
+  #   argv = Argvector.new(line)
+  #
+  #   args = line.split(/\s/)
+  #   argv.assoc_options(args)  #=> [ ["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
+
+ArgVector = Argvector

data/lib/standard/facets/binding/block_exec.rb

@@ -0,0 +1,44 @@
+class Binding
+
+  # Allows the evaluation of blocks by a Binding in the same way that strings
+  # can be evaluated.
+  #
+  #   x = 5
+  #   $my_binding = binding
+  #
+  #   class Test  # just here to provide a scope gate
+  #     $my_binding.block_exec { x }
+  #   end
+  #
+  #   # => 5
+  #
+  # NOTE: The implementation of this method uses a method_missing trick.
+  #       Consequently it is a bit of a hack.
+  #
+  def block_exec(*args, &block)
+    BlockEnvironment.new(self, *args, &block).call
+  end
+
+  # This class is used for evaluating blocks in a particular context. 
+  # It is not really meant to be used independently; instead it is used
+  # with Binding#block_exec method.
+
+  class BlockEnvironment < BasicObject
+
+    def initialize(context, *args, &block)
+      @context = context
+      @args = args
+      @block = block
+    end
+
+    def call
+      instance_exec(*@args, &@block)
+    end
+
+    def method_missing(name)
+      eval(name.to_s, @context) rescue super
+    end
+
+  end
+
+end

data/lib/standard/facets/cgi/esc.rb

@@ -0,0 +1,11 @@
+require 'facets/cgi/escape_html'
+
+class CGI
+
+  # Instance level method for {CGI::escape_html}.
+
+  def esc(string, *modes)
+    self.class.escape_html(string, *modes)
+  end
+
+end

data/lib/standard/facets/cgi/escape_html.rb

@@ -0,0 +1,63 @@
+require 'cgi'
+
+class CGI
+
+  # Extends `#escape_html` to support escape modes. By default all strings
+  # are escaped on `&`, `>` and `<`. Add the `:nonstandard` mode to omit
+  # this conversion.
+  #
+  # If no mode is given then the `:default` mode is used.
+  #
+  # Available modes include:
+  # * `:quote`     - escapes single and double quotes
+  # * `:newlines`  - escapes newline characters (\r and \n)
+  # * `:ampersand` - escapes the ampersand sign
+  # * `:brackets`  - escapes less-than and greater-than signs
+  # * `:default`   - escapes double quotes
+  #
+  # @example
+  #   escape_html("<tag>")  #=> "&lt;tag&gt;"
+  #   escape_html("Example\nString", :newlines)  #=> "Example&#13;&#10;String"
+  #   escape_html("\"QUOTE\"", false)  #=> "\"QUOTE\""
+  #
+  def self.escape_html(string, *modes)
+    modes << :defualt if modes.empty?
+
+    unless modes.include?(:nonstandard)
+      string = string.gsub(/&/, '&amp;').gsub(/>/, '&gt;').gsub(/</, '&lt;')
+    end
+
+    modes.each do |mode|
+      string = \
+        case mode
+        when :quote, :quotes
+          string.gsub(%r|"|,'&quot;').gsub(%r|'|,'&#39;')
+        when :newlines, :newlines
+          string.gsub(/[\r\n]+/,'&#13;&#10;')
+        when :ampersand
+          string.gsub(/&/, '&amp;')
+        when :bracket, :brackets
+          string.gsub(/>/, '&gt;').gsub(/</, '&lt;')
+        when :default, true
+          string.gsub(/\"/, '&quot;')
+        when false
+        else
+          raise ArgumentError, "unrecognized HTML escape mode -- #{node}"
+        end
+    end
+  end
+
+  class << self
+    # @deprecated
+    alias :escapeHTML :escape_html
+  end
+
+  if RUBY_VERSION < '1.9'
+    class << self
+      alias :unescape_html :unescapeHTML
+      alias :escape_element :escapeElement
+      alias :unescape_element :unescapeElement
+    end
+  end
+
+end

data/lib/standard/facets/cgi/marshal.rb

@@ -0,0 +1,20 @@
+require 'cgi'
+
+class CGI
+
+  # Create an hidden input field through which an object can can be marshalled.
+  # This makes it very easy to pass form data betwenn requests.
+  def marshal_to_cgi(name, iobj)
+    data = CGI.escape(Marshal.dump(iobj))
+    return %Q{<input type="hidden" name="__#{name}__" value="#{data}"/>\n}
+  end
+
+  # Create an hidden input field through which an object can can be marshalled.
+  # This makes it very easy to pass form data between requests.
+  def marshal_from_cgi(name)
+    if self.params.has_key?("__#{name}__")
+      return Marshal.load(CGI.unescape(self["__#{name}__"][0]))
+    end
+  end
+
+end

data/lib/standard/facets/cgi.rb

@@ -0,0 +1,6 @@
+require 'cgi'
+
+require 'facets/cgi/marshal'
+require 'facets/cgi/escape_html'
+
+