facets-glimmer 3.2.0

data/lib/standard/facets/nullclass.rb

@@ -0,0 +1,38 @@
+# = Nullclass
+#
+# NullClass is essentially NilClass but it differs in one
+# important way. When a method is called against it that it
+# deoesn't have, it will simply return null value rather then
+# raise an error.
+#
+# TODO: Perhaps NullClass should be called NackClass?
+
+class NullClass #< NilClass
+  class << self
+    def new
+      @null ||= NullClass.allocate
+    end
+  end
+  def inspect ; 'null' ; end
+  def nil?  ; true ; end
+  def null? ; true ; end
+  def [](key); nil; end
+  def method_missing(sym, *args)
+    return nil if sym.to_s[-1,1] == '?'
+    self
+  end
+end
+
+module Kernel
+  def null
+    NullClass.new
+  end
+end
+
+class Object
+  def null?
+    false
+  end
+end
+
+# Copyright (c) 2005 Thomas Sawyer

data/lib/standard/facets/opesc.rb

@@ -0,0 +1,79 @@
+# = OpEsc
+#
+# NOTE: As of v3.0 of Facets these have been renamed:
+#
+#    op_plus_self   -> op_plus
+#    op_minus_self  -> op_minus
+#    op_plus        -> op_add
+#    op_minus       -> op_sub
+#    op_case_eq     -> op_case
+#
+# TODO: In the future we might also rename:
+#
+#    op_lshift      -> op_push
+#    op_rshift      -> op_pull
+#    op_store       -> op_index
+#    op_fetch       -> op_index  (b/c [] and []= in same file)
+
+module OpEsc
+
+  OPERATORS = %w{ +@ -@ + - ** * / % ~ <=> << >> < > === == =~ <= >= | & ^ []= [] }
+  OPERATORS_REGEXP = Regexp.new( '(' << OPERATORS.collect{ |k| Regexp.escape(k) }.join('|') << ')' )
+  OPERATORS_ESC_TABLE = {
+      "+@"   => "op_plus",
+      "-@"   => "op_minus",
+      "+"    => "op_add",
+      "-"    => "op_sub",
+      "**"   => "op_pow",
+      "*"    => "op_mul",
+      "/"    => "op_div",
+      "%"    => "op_mod",
+      "~"    => "op_tilde",
+      "<=>"  => "op_cmp",
+      "<<"   => "op_lshift",  #push?
+      ">>"   => "op_rshift",  #pull?
+      "<"    => "op_lt",
+      ">"    => "op_gt",
+      "==="  => "op_case",
+      "=="   => "op_equal",
+      "=~"   => "op_apply",
+      "<="   => "op_lt_eq",
+      ">="   => "op_gt_eq",
+      "|"    => "op_or",
+      "&"    => "op_and",
+      "^"    => "op_xor",
+      "[]="  => "op_store",
+      "[]"   => "op_fetch"
+  }
+
+  # Applies operator escape's according to OPERATORS_ESCAPE_TABLE.
+  #
+  #   OpEsc.escape('-') #=> "op_sub"
+  #
+  # CREDIT: Trans
+
+  def self.escape(str)
+    str.to_s.gsub(OPERATORS_REGEXP){ OPERATORS_ESC_TABLE[$1] }
+  end
+
+  #
+  def self.method_to_filename(name)
+    fname = escape(name)
+    fname = fname[0...-1] if fname =~ /[\!\=\?]$/
+    fname
+  end
+
+  ## Require a file with puncuation marks escaped.
+  ##
+  ##   require_esc '[].rb'
+  ##
+  ## in actuality requires the file 'op_fetch.rb'.
+  ##
+  ##   def require_esc( fpath )
+  ##     fdir, fname = File.split(fpath)
+  ##     fname = method_to_filename(fname)
+  ##     path = File.join(fdir, fname)
+  ##     require(path)
+  ##   end
+
+end

data/lib/standard/facets/ostruct/each.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Iterate over key-value pairs.
+  #
+  def each(&blk)
+    @table.each(&blk)
+  end
+
+end

data/lib/standard/facets/ostruct/initialize.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Allows the initialization of an OpenStruct with a setter block:
+  #
+  #   person = OpenStruct.new do |o|
+  #     o.name    = 'John Smith'
+  #     o.gender  = :M
+  #     o.age     = 71
+  #   end
+  #
+  # You can still provide a hash for initialization purposes, and even combine
+  # the two approaches if you wish.
+  #
+  #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
+  #     p.gender = :M
+  #   end
+  #
+  # Alternatively you can provide a default block:
+  #
+  #   stuff = OpenStruct.new{ |o,k| o[k] = [] }
+  #   stuff.place << :a
+  #   stuff.place << :b
+  #   stuff.place #=> [:a, :b]
+  #
+  # A setter block versus a defualt block is determined by the arity of
+  # the block. You cannot provide both at the same time.
+  #
+  # CREDIT: Noah Gibbs, Gavin Sinclair
+  def initialize(hash=nil, &block)
+    if block && block.arity==2
+      @table = Hash.new(&block)
+    else
+      @table = {}
+    end
+    if hash
+      for k,v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+    if block && block.arity==1
+      yield self
+    end
+  end
+
+end

data/lib/standard/facets/ostruct/merge.rb

@@ -0,0 +1,21 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.merge!(:a => 2)
+  #   o.a  #=> 2
+  #
+  def merge!(other)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    ##other = other.to_hash #to_h?
+    for k,v in other
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+end
+

data/lib/standard/facets/ostruct/op_fetch.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+class OpenStruct
+
+  # Access a value in the OpenStruct by key, like a Hash.
+  # This increases OpenStruct's "duckiness".
+  #
+  #   o = OpenStruct.new
+  #   o.t = 4
+  #   o['t']  #=> 4
+  #
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+
+  # Set a value in the OpenStruct by key, like a Hash.
+  #
+  #   o = OpenStruct.new
+  #   o['t'] = 4
+  #   o.t  #=> 4
+  #
+  def []=(key,val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]=val
+  end
+
+end

data/lib/standard/facets/ostruct/op_store.rb

@@ -0,0 +1 @@
+require 'facets/ostruct/op_fetch'

data/lib/standard/facets/ostruct/to_h.rb

@@ -0,0 +1,10 @@
+require 'ostruct'
+
+class OpenStruct
+
+  #
+  def to_h
+    @table.dup
+  end
+
+end

data/lib/standard/facets/ostruct/to_ostruct.rb

@@ -0,0 +1,65 @@
+require 'ostruct'
+
+class OpenStruct
+  #
+  def to_ostruct
+    self
+  end
+end
+
+class Hash
+  # Turns a hash into a generic object using an OpenStruct.
+  #
+  #     o = {'a' => 1}.to_ostruct
+  #     o.a  #=> 1
+  #
+  def to_ostruct
+    OpenStruct.new(self)
+  end
+
+  ## Recursively converts a Hash object to an OpenStruct object.
+  ##
+  ## Returns a copy of the hash as an OpenStruct.
+  #def to_ostruct()
+  #  struct = OpenStruct.new(self.clone())
+  #  each do |k, v|
+  #    struct.__send__("#{k}=", v.to_ostruct()) if v.is_a?(Hash)
+  #    struct.__send__(k).map! {|x| x.is_a?(Hash) ? x.to_ostruct() : x} if v.is_a?(Array)
+  #  end
+  #  return struct
+  #end
+
+  # Like `#to_ostruct` but recusively objectifies all hash elements as well.
+  #
+  #     o = {'a' => { 'b' => 1 }}.to_ostruct_recurse
+  #     o.a.b  #=> 1
+  #
+  # The `exclude` parameter is used internally to prevent infinite
+  # recursion and is not intended to be utilized by the end-user.
+  # But for more advance use, if there is a particular subhash you
+  # would like to prevent from being converted to an OpoenStruct
+  # then include it in the `exclude` hash referencing itself. e.g.
+  #
+  #     h = { 'a' => { 'b' => 1 } }
+  #     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+  #     o.a['b']  #=> 1
+  #
+  # CREDIT: Alison Rowland, Jamie Macey, Mat Schaffer
+  def to_ostruct_recurse(exclude={})
+    return exclude[self] if exclude.key?( self )
+    o = exclude[self] = OpenStruct.new
+    h = self.dup
+    each_pair do |k,v|
+      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
+    end
+    o.merge!(h)
+  end
+end
+
+class NilClass
+  # Create an empty OpenStruct object.
+  def to_ostruct
+    OpenStruct.new
+  end
+end
+

data/lib/standard/facets/ostruct.rb

@@ -0,0 +1,89 @@
+require 'ostruct'
+require 'facets/ostruct/initialize'
+require 'facets/ostruct/to_h'
+require 'facets/ostruct/merge'
+require 'facets/ostruct/each'
+require 'facets/ostruct/to_ostruct'
+require 'facets/ostruct/op_fetch'
+require 'facets/ostruct/op_store'
+
+class OpenStruct
+
+  #--
+  # TO BE DEPRECATED
+  # Must consider that accessing instance_delegate instead can be dangerous.
+  # Might we us a Functor to ensure the table keys are always symbols?
+  #++
+
+  # Provides access to an OpenStruct's inner table.
+  #
+  #   o = OpenStruct.new
+  #   o.a = 1
+  #   o.b = 2
+  #   o.instance_delegate.map { |k, v| "#{k} #{v}" }
+  #   #=> ["a 1", "b 2"]
+  #
+  # @deprecated Use `#marshal_dump` instead.
+  #
+  def instance_delegate
+    warn "OpenStruct#instance_delegate is deprecated, use #marshal_dump instead."
+    @table
+  end
+
+  # @deprecated Use `#marshal_dump` instead.
+  alias ostruct_delegate instance_delegate
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update(:a => 2)
+  #   o.a  #=> 2
+  #
+  # @deprecated Use #merge! instead.
+  #
+  def ostruct_update(other)
+    warn "OpenSrtuct#ostruct_update has been deprecated. Use #merge! instead."
+    merge!(other)
+  end
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update(:a => 2)
+  #   o.a  #=> 2
+  #
+  # @deprecated Use #merge! instead.
+  #
+  def __update__(other)
+    raise NameError, "OpenSrtuct#__update__ has been deprecated. Use #merge! instead."
+    #merge!(other)
+  end
+
+  # TODO: How to handle regular merge, since it lacks punctuation to make it safe.
+  #       Maybe `#update!`? Kind of odd but could work.
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   x = o.ostruct_merge(:a => 2)
+  #   x.a  #=> 2
+  #
+  def ostruct_merge(other)
+    o = dup
+    o.merge!(other)
+    o
+  end
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   x = o.__merge__(:a => 2)
+  #   x.a  #=> 2
+  #
+  def __merge__(other)
+    o = dup
+    o.merge!(other)
+    o
+  end
+
+end

data/lib/standard/facets/pathname/chdir.rb

@@ -0,0 +1,15 @@
+class Pathname
+
+  # Change current working directory of the process
+  # to the given path
+  #
+  # See Dir.chdir
+  #
+  # CREDIT: Ryan Duryea
+
+  def chdir(&block)
+    Dir.chdir(self, &block)
+  end
+
+end
+

data/lib/standard/facets/pathname/empty.rb

@@ -0,0 +1,10 @@
+class Pathname
+
+  # Is a directory path empty?
+  #
+  # Returns [Boolean]
+  def empty?
+    Dir.glob(::File.join(to_s, '*')).empty?
+  end
+
+end

data/lib/standard/facets/pathname/exists.rb

@@ -0,0 +1,6 @@
+class Pathname
+
+  # Pluralized alias for `#exist?` method.
+  alias :exists? :exist?
+
+end

data/lib/standard/facets/pathname/glob.rb

@@ -0,0 +1,57 @@
+class Pathname
+
+  # Glob pathnames.
+  def glob(match, *opts)
+    flags = glob_flags(opts)
+    Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
+  end
+
+  # Return the first glob match.
+  #
+  # DEPRECATE: While slightly faster then glob().first, not really worth it
+  # unless this can be rewritten to shortcut on first match (using fnmatch?).
+  # In wich case, is there a better name for this method?
+  def glob_first(match, *opts)
+    flags = glob_flags(opts)
+    file = ::Dir.glob(::File.join(self.to_s, match), flags).first
+    file ? self.class.new(file) : nil
+  end
+
+  # Return globbed matches with pathnames relative to the current pathname.
+  def glob_relative(match, *opts)
+    flags = glob_flags(opts)
+    files = Dir.glob(::File.join(self.to_s, match), flags)
+    files = files.map{ |f| f.sub(self.to_s.chomp('/') + '/', '') }
+    files.collect{ |m| self.class.new(m) }
+  end
+
+  # Does a directory contain a matching entry?
+  # Or if the pathname is a file, same as #fnmatch.
+  #
+  # TODO: Move to own file? Better name?
+  #
+  # Returns [Pathname]
+
+  def include?(pattern,*opts)
+    if directory?
+      glob_first(pattern,*opts)
+    else
+      fnmatch(pattern,*opts)
+    end
+  end
+
+private
+
+  def glob_flags(opts)
+    flags = 0
+    opts.each do |opt|
+      case opt when Symbol, String
+        flags += ::File.const_get("FNM_#{opt}".upcase)
+      else
+        flags += opt
+      end
+    end
+    flags
+  end
+
+end

data/lib/standard/facets/pathname/home.rb

@@ -0,0 +1,12 @@
+class Pathname
+
+  # Home constant for building paths from root directory onward.
+  #
+  # TODO: Pathname#home needs to be more robust.
+  #
+  # Returns [Pathname]
+  def self.home
+    Pathname.new('~')
+  end
+
+end

data/lib/standard/facets/pathname/null.rb

@@ -0,0 +1,20 @@
+class Pathname
+
+  # Platform dependent null device.
+  #
+  # CREDIT: Daniel Burger
+
+  def self.null
+    case RUBY_PLATFORM
+    when /mswin/i
+      'NUL'
+    when /amiga/i
+      'NIL:'
+    when /openvms/i
+      'NL:'
+    else
+      '/dev/null'
+    end
+  end
+
+end

data/lib/standard/facets/pathname/op_div.rb

@@ -0,0 +1,15 @@
+class Pathname
+
+  # Start a path. Another alias for #new.
+  #
+  #   Pathname / 'usr'
+  #
+  def self./(path)
+    new(path)
+  end
+
+  # Try to get this into standard Pathname class.
+  alias_method :/, :+
+
+end
+

data/lib/standard/facets/pathname/op_fetch.rb

@@ -0,0 +1,13 @@
+class Pathname
+
+  # Alternate to Pathname#new.
+  #
+  #   Pathname['/usr/share']
+  #
+  # Returns [Pathname]
+
+  def self.[](path)
+    new(path)
+  end
+
+end

data/lib/standard/facets/pathname/outofdate.rb

@@ -0,0 +1,13 @@
+require 'facets/fileutils/outofdate'
+
+class Pathname
+
+  # Is a path out of date relative a set of source files.
+  #
+  # Returns [Boolean]
+
+  def outofdate?(*sources)
+    ::FileUtils.outofdate?(to_s, sources.flatten)
+  end
+
+end

data/lib/standard/facets/pathname/readline.rb

@@ -0,0 +1,13 @@
+class Pathname
+  # Reads the first line of the file
+  #
+  # Captures the best practice from this post at stack overflow:
+  # https://stackoverflow.com/questions/1490138/reading-the-first-line-of-a-file-in-ruby
+  #
+  # Credit: Ryan Duryea
+  def readline(*args)
+    open { |f| f.readline(*args) }
+  end
+end
+
+

data/lib/standard/facets/pathname/root.rb

@@ -0,0 +1,10 @@
+class Pathname
+
+  # Root constant for building paths from root directory onward.
+  #
+  # Returns [Pathname]
+  def self.root
+    Pathname.new('/')
+  end
+
+end

data/lib/standard/facets/pathname/rootname.rb

@@ -0,0 +1,10 @@
+require 'facets/file/rootname'
+
+class Pathname
+
+  #
+  def rootname
+    self.class.new(File.rootname(to_s))
+  end
+
+end

data/lib/standard/facets/pathname/safe.rb

@@ -0,0 +1,15 @@
+require 'facets/filetest/safe'
+
+class Pathname
+
+  # Is a path reasonably safe?
+  #
+  # Do not mistake this for a perfect solution!
+  #
+  # Returns [Boolean]
+
+  def safe?
+    FileTest.safe?(to_s)
+  end
+
+end

data/lib/standard/facets/pathname/split_root.rb

@@ -0,0 +1,9 @@
+class Pathname
+
+  #
+  def split_root
+    head, tail = *::File.split_root(to_s)
+    [self.class.new(head), self.class.new(tail)]
+  end
+
+end

data/lib/standard/facets/pathname/to_path.rb

@@ -0,0 +1,28 @@
+# Unfortunately NilClass#to_path causes FileUtils to bomb when testing
+# for symlinks. See issue #77. It would be better if Ruby could be changed
+# so this would work. But until then we have no choice but to deprecate
+# this method.
+
+#class NilClass
+#  # Provide platform dependent null path.
+#  #
+#  # @standard
+#  #   require 'facets/pathname'
+#  #
+#  # @author Daniel Burger
+#  def to_path
+#    Pathname.null
+#  end
+#end
+
+class Array
+  # Convert array to Pathname instance.
+  #
+  # @standard
+  #   require 'facets/pathname'
+  #
+  def to_path
+    Pathname.new(join('/'))
+  end
+end
+

data/lib/standard/facets/pathname/to_str.rb

@@ -0,0 +1,8 @@
+class Pathname
+
+  # Alias #to_s to #to_str when #to_str is not defined.
+  #
+  # Returns [String]
+  alias_method(:to_str, :to_s) unless method_defined?(:to_str)
+
+end

data/lib/standard/facets/pathname/uptodate.rb

@@ -0,0 +1,11 @@
+class Pathname
+
+  # Is a path up to date relative to a set of source files?
+  #
+  # Returns [Boolean]
+
+  def uptodate?(*sources)
+    ::FileUtils.uptodate?(to_s, sources.flatten)
+  end
+
+end