mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,175 @@
+warn "use rich_units for future version"
+
+# = Bytes
+#
+# WARNING: Use Rich Units package for future compatibilty!
+#
+# == Synopisis
+#
+# Additional methods for Numeric class to make working with
+# bits and bytes easier.
+#
+# Additional methods for Numeric class to make working with
+# bits and bytes easier. Bits are used as the base value and
+# these methods can be used to convert between different
+# magnitudes.
+#
+#   1.byte               #=> 8
+#   2.bytes              #=> 16
+#   1.kilobit            #=> 1024
+#   1.kilobyte           #=> 8192
+#
+# Use the in_* methods to perform the inverse operations.
+#
+#   8192.in_kilobytes    #=> 1
+#   1024.in_kilobits     #=> 1
+#
+# == History
+#
+# Special thanks to Richard Kilmer for the orignal work.
+# This library is based on the original library bytes.rb
+# Copyright (c) 2004 by Rich Kilmer.
+#
+# Also thanks to Alexander Kellett for suggesting it be
+# included in Facets.
+#
+# == Authors
+#
+# * Rich Kilmer
+# * Thomas Sawyer
+#
+# == NOTES
+#
+# This library is not compatible with STICK's units.rb (an spin-off
+# of Facets old units.rb library). Do not attempt to use both at the same time.
+#
+# == Todo
+#
+# * Currently kilo, mega, etc. are all powers of two and not ten,
+#   which technically isn't corrent even though it is common usage.
+# * The in_* notation is weak. If a better nomentclature is thought
+#   of then consider changing this.
+#
+# == Copying
+#
+# Copyright (c) 2005 Rich Kilmer
+#
+# 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.
+
+
+# = Bytes
+#
+# Additional methods for Numeric class to make working with
+# bits and bytes easier. Bits are used as the base value and
+# these methods can be used to convert between different
+# magnitudes.
+#
+#   1.byte               #=> 8
+#   2.bytes              #=> 16
+#   1.kilobit            #=> 1024
+#   1.kilobyte           #=> 8192
+#
+# Use the in_* methods to perform the inverse operations.
+#
+#   8192.in_kilobytes    #=> 1
+#   1024.in_kilobits     #=> 1
+#
+class Numeric
+
+  def bit   ; self ; end
+  def bits  ; self ; end
+  def byte  ; self * 8 ; end
+  def bytes ; self * 8 ; end
+
+  [ 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa' ].each_with_index do |m, i|
+    j = i + 1
+    class_eval %{
+      def #{m}bit  ; self * #{1024**j} ; end
+      def #{m}byte ; self * #{1024**j*8} ; end
+      def in_#{m}bits  ; self / #{1024**j} ; end
+      def in_#{m}bytes ; self / #{1024**j*8} ; end
+      alias_method :#{m}bits,  :#{m}bit
+      alias_method :#{m}bytes, :#{m}byte
+    }
+  end
+
+  [ 'kibi', 'mebi', 'gibi', 'tebi', 'pebi', 'exbi' ].each_with_index do |m, i|
+    j = i + 1
+    class_eval %{
+      def #{m}bit  ; self * #{1024**j} ; end
+      def #{m}byte ; self * #{1024**j*8} ; end
+      def in_#{m}bits  ; self / #{1024**j} ; end
+      def in_#{m}bytes ; self / #{1024**j*8} ; end
+      alias_method :#{m}bits,  :#{m}bit
+      alias_method :#{m}bytes, :#{m}byte
+    }
+  end
+
+  # Formated string of bits proportial to size.
+  #
+  #   1024.bits_to_s            #=> "1.00 kb"
+  #   1048576.bits_to_s         #=> "1.00 mb"
+  #   1073741824.bits_to_s      #=> "1.00 gb"
+  #   1099511627776.bits_to_s   #=> "1.00 tb"
+  #
+  # Takes a format string to adjust output.
+  #
+  #   1024.bits_to_s('%.0f')    #=> "1 kb"
+  #
+  def strfbits(fmt='%.2f')
+    case
+    when self < 1024
+      "#{self} bits"
+    when self < 1024**2
+      "#{fmt % (self.to_f / 1024)} kb"
+    when self < 1024**3
+      "#{fmt % (self.to_f / 1024**2)} mb"
+    when self < 1024**4
+      "#{fmt % (self.to_f / 1024**3)} gb"
+    when self < 1024**5
+      "#{fmt % (self.to_f / 1024**4)} tb"
+    else
+      "#{self} bits"
+    end
+  end
+
+  # Formated string of bytes proportial to size.
+  #
+  #   1024.bytes_to_s            #=> "1.00 KB"
+  #   1048576.bytes_to_s         #=> "1.00 MB"
+  #   1073741824.bytes_to_s      #=> "1.00 GB"
+  #   1099511627776.bytes_to_s   #=> "1.00 TB"
+  #
+  # Takes a format string to adjust output.
+  #
+  #   1024.bytes_to_s('%.0f')    #=> "1 KB"
+  #
+  def strfbytes(fmt='%.2f')
+    case
+    when self < 1024
+      "#{self} bytes"
+    when self < 1024**2
+      "#{fmt % (self.to_f / 1024)} KB"
+    when self < 1024**3
+      "#{fmt % (self.to_f / 1024**2)} MB"
+    when self < 1024**4
+      "#{fmt % (self.to_f / 1024**3)} GB"
+    when self < 1024**5
+      "#{fmt % (self.to_f / 1024**4)} TB"
+    else
+      "#{self} bytes"
+    end
+  end
+
+  # deprecated
+  alias_method :octet_units, :strfbytes
+
+end
+

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

@@ -0,0 +1,117 @@
+# = CacheDecorator
+#
+# == Synopsis
+#
+# CacheDecorator wrap objects to provide cached versions of method calls.
+#
+#   class X
+#     def initialize ; @tick = 0 ; end
+#     def tick; @tick + 1; end
+#     def cached; @cache ||= CacheDecorator.new(self) ; end
+#   end
+#
+#   x = X.new
+#   x.tick  #=> 1
+#   x.cached.tick  #=> 2
+#   x.tick  #=> 3
+#   x.cached.tick  #=> 2
+#   x.tick  #=> 4
+#   x.cached.tick  #=> 2
+#
+# You can also use to cache a collections of objects to gain code
+# speed ups.
+#
+#   points = points.collect{|point| Cache.cache(point)}
+#
+# After our algorithm has finished using points, we want to get rid of
+# these Cache objects. That's easy:
+#
+#    points = points.collect{|point| point.self }
+#
+# Or if you prefer (it is ever so slightly safer):
+#
+#    points = points.collect{|point| Cache.uncache(point)}
+#
+# == Authors
+#
+# * Erik Veenstra
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2006 Erik Veenstra
+#
+# 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.
+
+# = CacheDecorator
+#
+# CacheDecorator wrap objects to provide cached versions of method calls.
+#
+# == Usage
+#
+#   class X
+#     def initialize ; @tick = 0 ; end
+#     def tick; @tick + 1; end
+#     def cached; @cache ||= CacheDecorator.new(self) ; end
+#   end
+#
+#   x = X.new
+#   x.tick  #=> 1
+#   x.cached.tick  #=> 2
+#   x.tick  #=> 3
+#   x.cached.tick  #=> 2
+#   x.tick  #=> 4
+#   x.cached.tick  #=> 2
+#
+# You can also use to cache a collections of objects to gain code
+# speed ups.
+#
+#   points = points.collect{|point| Cache.cache(point)}
+#
+# After our algorithm has finished using points, we want to get rid of
+# these Cache objects. That's easy:
+#
+#    points = points.collect{|point| point.self }
+#
+# Or if you prefer (it is ever so slightly safer):
+#
+#    points = points.collect{|point| Cache.uncache(point)}
+#
+class CacheDecorator
+
+  #private :class, :clone, :display, :type, :method, :to_a, :to_s
+  private *instance_methods(true).select{ |m| m.to_s !~ /^__/ }
+
+  def initialize(object)
+    @self = object
+    @cache = {}
+  end
+
+  def method_missing(method_name, *args, &block)
+    # Not thread-safe! Speed is important in caches... ;]
+    @cache[[method_name, args, block]] ||= @self.__send__(method_name, *args, &block)
+  end
+
+  def self; @self; end
+
+  def self.cache(object)
+    Cache.new(object)
+  end
+
+  def self.uncache(cached_object)
+    cached_object.self
+  end
+
+end
+
+# These are for backward compatibility (to be DEPRECATED)
+Cache = CacheDecorator
+CacheDelegator = Cache
+

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

@@ -0,0 +1,258 @@
+# = Capsule
+#
+# A Capsule is subclass of Module. It encapsulates an extenal script
+# as a funcitons module.
+#
+# A module which is an instance of the Capsule class encapsulates in its scope
+# the top-level methods, top-level constants, and instance variables defined in
+# a ruby script file (and its subfiles) loaded by a ruby program. This allows
+# use of script files to define objects that can be loaded into a program in
+# much the same way that objects can be loaded from YAML or Marshal files.
+#
+# See intro.txt[link:files/intro_txt.html] for an overview.
+#
+# == Authors
+#
+# * Joel VanderWerf
+# * Thomas Sawyer
+#
+# == Todo
+#
+# * The name of this is rather weak. Think of a better one.
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer, Joel VanderWerf
+#
+# 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.
+
+#require 'rbconfig'
+
+# = Capsule
+#
+# A Capsule is subclass of Module. It encapsulates an extenal script
+# as a funcitons module.
+#
+# A module which is an instance of the Capsule class encapsulates in its scope
+# the top-level methods, top-level constants, and instance variables defined in
+# a ruby script file (and its subfiles) loaded by a ruby program. This allows
+# use of script files to define objects that can be loaded into a program in
+# much the same way that objects can be loaded from YAML or Marshal files.
+#
+# See intro.txt[link:files/intro_txt.html] for an overview.
+
+class Capsule < Module
+
+  #DLEXT = Config::CONFIG['DLEXT']
+
+  # The script file with which the Import was instantiated.
+  attr_reader :main_file
+
+  # The directory in which main_file is located, and relative to which
+  # #load searches for files before falling back to Kernel#load.
+  #attr_reader :dir
+
+  # An array of paths to search for scripts. This has the same
+  # semantics as <tt>$:</tt>, alias <tt>$LOAD_PATH</tt>, excpet
+  # that it is local to this script. The path of the current
+  # script is added automatically (equivalent to '.')
+  attr_reader :load_path
+
+  # A hash that maps <tt>filename=>true</tt> for each file that has been
+  # required locally by the script. This has the same semantics as <tt>$"</tt>,
+  # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+  attr_reader :loaded_features
+
+  class << self
+    # As with #new but will search Ruby's $LOAD_PATH first.
+    #--
+    # Will also try .rb, .so, .dll, et al extensions, like require does.
+    #++
+    def load(main_file, options=nil, &block)
+      file = nil
+      $LOAD_PATH.each do |path|
+        break if file = File.file?(File.join(path, main_file))
+        #break if file = Dir.glob(File.join(path, main_file)+'{,.rb,.'+DLEXT+'}')[0]
+      end
+      new(file || main_file, options=nil, &block)
+    end
+  end
+
+  # Creates new Capsule, and loads _main_file_ in the scope of the script. If a
+  # block is given, the script is passed to it before loading from the file, and
+  # constants can be defined as inputs to the script.
+
+  def initialize(main_file, options=nil, &block)
+    extend self
+
+    options ||= {}
+
+    @main_file       = File.expand_path(main_file)
+    @load_path       = options[:load_path] || []
+    #@load_path |= [File.dirname(@main_file)]  # before or after?
+    @loaded_features = options[:loaded_features] || {}
+
+    # TODO In order to load/require at the instance level.
+    # This needs to be in a separate namespace however
+    # b/c it can interfere with what is expected.
+    #[ :require, :load ].each{ |meth|
+    #  m = method(meth)
+    #  define_method(meth) do |*args| m.call(*args) end
+    #}
+
+    module_eval(&block) if block
+    extend self
+
+    load_in_module(main_file)
+  end
+
+  # Lookup feature in load path.
+
+  def load_path_lookup(feature)
+    paths = File.join('{' + @load_path.join(',') + '}', feature + '{,.rb,.rbs}')
+    files = Dir.glob(paths)
+    match = files.find{ |f| ! @loaded_features.include?(f) }
+    return match
+  end
+
+  # Loads _file_ into the capsule. Searches relative to the local dir, that is,
+  # the dir of the file given in the original call to
+  # <tt>Capsule.load(file)</tt>, loads the file, if found, into this Capsule's
+  # scope, and returns true. If the file is not found, falls back to
+  # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+  # if found, into global scope, and returns true. Otherwise, raises
+  # <tt>LoadError</tt>.
+  #
+  # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+  # when the file is not found locally.
+  #
+  # Typically called from within the main file to load additional sub files, or
+  # from those sub files.
+  #
+  #--
+  # TODO Need to add load_path lookup.
+  #++
+
+  def load(file, wrap = false)
+    load_in_module(File.join(@dir, file))
+    true
+  rescue MissingFile
+    super
+  end
+
+  # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+  # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+  #
+  # Note that extensions (*.so, *.dll) can be required in the global scope, as
+  # usual, but not in the local scope. (This is not much of a limitation in
+  # practice--you wouldn't want to load an extension more than once.) This
+  # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+  # extension or is not found locally.
+  #
+  #--
+  # This was using load_in_module rather than include_script. Maybe is still should
+  # and one should have to call include_script instead? Think about this.
+  #++
+
+  def require(feature)
+    file = load_path_lookup(feature)
+    return super unless file
+    begin
+      @loaded_features[file] = true
+      load_in_module(file)
+    rescue MissingFile
+      @loaded_features[file] = false
+      super
+    end
+  end
+
+  # Raised by #load_in_module, caught by #load and #require.
+  class MissingFile < LoadError; end
+
+  # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+  # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+  # Called by #load and #require; not normally called directly.
+
+  def load_in_module(file)
+    module_eval(IO.read(file), File.expand_path(file))
+  rescue Errno::ENOENT => e
+    if /#{file}$/ =~ e.message
+      raise MissingFile, e.message
+    else
+      raise
+    end
+  end
+
+  def include_script(file)
+    include self.class.new(file, :load_path=>load_path, :loaded_features=>loaded_features)
+  rescue Errno::ENOENT => e
+    if /#{file}$/ =~ e.message
+      raise MissingFile, e.message
+    else
+      raise
+    end
+  end
+
+  #
+  def include(*mods)
+    super
+    extend self
+  end
+
+  def to_s # :nodoc:
+    "#<#{self.class}:#{main_file}>"
+  end
+
+end
+
+# TODO Is autoimport bets name for this?
+
+class Module
+
+  const_missing_definition_for_autoimport = lambda do
+    #$autoimport_activated = true
+    alias const_missing_before_autoimport const_missing
+
+    def const_missing(sym) # :nodoc:
+      filename = @autoimport && @autoimport[sym]
+      if filename
+        mod = Import.load(filename)
+        const_set sym, mod
+      else
+        const_missing_before_autoimport(sym)
+      end
+    end
+  end
+
+  # When the constant named by symbol +mod+ is referenced, loads the script
+  # in filename using Capsule.load and defines the constant to be equal to the
+  # resulting Capsule module.
+  #
+  # Use like Module#autoload--however, the underlying opertation is #load rather
+  # than #require, because scripts, unlike libraries, can be loaded more than
+  # once. See examples/autoscript-example.rb
+
+  define_method(:autoimport) do |mod, file|
+    if @autoimport.empty? #unless $autoimport_activated
+      const_missing_definition_for_autoimport.call
+    end
+    (@autoimport ||= {})[mod] = file
+  end
+end
+
+
+module Kernel
+
+  # Calls Object.autoimport
+  def autoimport(mod, file)
+    Object.autoimport(mod, file)
+  end
+
+end