mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,193 @@
+# = Infinity
+#
+# A full featured Infinity class, supporting signed direction.
+# Inifinty is a multiton based on direction The constant INFINITY
+# is provided as the common case with direction=+1 (positive).
+#
+# Besides being an class, these four constants are preset:
+#
+#   NaN
+#   Inf
+#   PosInf
+#   NegInf
+#
+# These four constants a built from two other basic constants:
+#
+#   UNDEFINED
+#   INFINITY
+#
+# In physical memory there are actually only three objects, namely
+# three instances of InfinityClass, one for NaN, PosInf and NegInf,
+# respectively.
+#
+# == Copying
+#
+# Copyright (c) 2004 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.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Todo
+#
+# * Could @direction values greater than 1 support Aleph?
+
+require 'facets/multiton'
+
+# = Infinity
+#
+# A full featured Infinity class, supporting signed direction.
+# Inifinty is a multiton based on direction The constant INFINITY
+# is provided as the common case with direction=+1 (positive).
+#
+# Besides being an class, these four constants are preset:
+#
+#   NaN
+#   Inf
+#   PosInf
+#   NegInf
+#
+# These four constants a built from two other basic constants:
+#
+#   UNDEFINED
+#   INFINITY
+#
+# In physical memory there are actually only three objects, namely
+# three instances of InfinityClass, one for NaN, PosInf and NegInf,
+# respectively.
+#
+class InfinityClass < Numeric
+  include Multiton
+
+  attr_reader :direction
+
+  def initialize(direction=1)
+    @direction = (direction <=> 0)
+    super()
+  end
+
+  # Change direction of infinity.
+
+  def -@
+    case @direction
+    when  0 : self.class.instance(0)
+    when  1 : self.class.instance(-1)
+    when -1 : self.class.instance(1)
+    end
+  end
+
+  # Noop.
+
+  def +@
+    self
+  end
+
+  # Convert to the float version of infinity.
+
+  def to_f
+    (1.0/0) * @direction
+  end
+
+  # Gee, a real infinite loop!
+
+  def times
+    loop do yield end
+  end
+
+  # Coerce allows other numbers to be
+  # compared to infinity.
+
+  def coerce(other)
+    case other
+    when InfinityClass
+      super
+    else
+      return -self, other
+    end
+  end
+
+  # Equality. Note that NaN != NaN.
+
+  def ==(other)
+    case other
+    when InfinityClass
+      if @direction == 0 and other.direction == 0
+        false
+      else
+        super
+      end
+    else
+      false
+    end
+  end
+
+  # Comparision where infinity is alway greatest
+  # and negative infinityalways least.
+
+  def <=>(other)
+    case other
+    when InfinityClass
+      @direction <=> other.direction
+    else
+      @direction
+    end
+  end
+
+  #
+
+  def to_s
+    case @direction
+    when  0  : "NaN"
+    when  1  : "PosInf"
+    when -1  : "NegInf"
+    end
+  end
+
+end
+
+#
+
+class Numeric
+
+  def finite?
+    not InfinityClass === self
+  end
+
+  def infinite?
+    return false if NaN == self
+    InfinityClass === self
+  end
+  alias :inf? :infinite?
+
+  def nan?
+    NaN == self
+  end
+
+  def posinf?
+    PosInf == self
+  end
+
+  def neginf?
+    NegInf == self
+  end
+
+end
+
+# Set constant to positive infinity.
+UNDEFINED = InfinityClass.new(0)
+INFINITY  = InfinityClass.new(1)
+
+NaN = UNDEFINED
+Inf = INFINITY
+PosInf = +INFINITY
+NegInf = -INFINITY
+

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

@@ -0,0 +1,130 @@
+# = Inheritor
+#
+# Inheritor providse a means to store and inherit data via
+# the class heirarchy. An inheritor creates two methods
+# one named after the key that provides a reader. And one
+# named after key! which provides the writer. (Because of
+# the unique nature of inheritor the reader and writer
+# can't be the same method.)
+#
+#   class X
+#     inheritor :foo, [], :+
+#   end
+#
+#   class Y < X
+#   end
+#
+#   X.x! << :a
+#   X.x => [:a]
+#   Y.x => [:a]
+#
+#   Y.x! << :b
+#   X.x => [:a]
+#   Y.x => [:a, :b]
+#
+# It is interesting to note that the only reason inheritor is needed at all
+# is becuase Ruby does not allow modules to be inherited at the class-level, or
+# conversely that the "class-levels" of classes are not modules instead.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# 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.
+
+#require 'facets/module/class_extension'
+require 'facets/class_extension'
+
+# = Inheritor
+#
+# Inheritor providse a means to store and inherit data via
+# the class heirarchy. An inheritor creates two methods
+# one named after the key that provides a reader. And one
+# named after key! which provides the writer. (Because of
+# the unique nature of inheritor the reader and writer
+# can't be the same method.)
+#
+#   class X
+#     inheritor :foo, [], :+
+#   end
+#
+#   class Y < X
+#   end
+#
+#   X.x! << :a
+#   X.x => [:a]
+#   Y.x => [:a]
+#
+#   Y.x! << :b
+#   X.x => [:a]
+#   Y.x => [:a, :b]
+#
+# It is interesting to note that the only reason inheritor is needed at all
+# is becuase Ruby does not allow modules to be inherited at the class-level, or
+# conversely that the "class-levels" of classes are not modules instead.
+
+class Object
+
+  # Create an inheritor "class attribute".
+  def inheritor( key, obj, op=nil )
+
+    # inhertiance operator
+    op = op ? op.to_sym : :add
+
+    # inheritor store a this level
+    instance_variable_set("@#{key}", obj)
+
+    #base = self
+    deflambda = lambda do
+
+      define_method( key ) do
+        defined?(super) ? super.__send__(op,obj) : obj.dup
+      end
+
+      define_method( "#{key}!" ) do
+        if instance_variable_defined?("@#{key}")
+          instance_variable_get("@#{key}")
+        else
+          inheritor(key, obj.class.new, op)
+        end
+        #if instance_variables.include?("@#{key}")
+        #  instance_variable_get("@#{key}")
+        #else
+        #  if self != base
+        #    inheritor( key, obj.class.new, op )
+        #  end
+        #end
+      end
+    end
+
+    # TODO This is an issue if you try to include a module
+    # into Module or Class itself. How to fix?
+
+    # if the object is a module (not a class or other object)
+    if self == Class or self == Module
+      class_eval(&deflambda)
+    elsif is_a?(Class)
+      (class << self; self; end).class_eval(&deflambda)
+    elsif is_a?(Module)
+      #class_inherit &deflambda
+      extend class_extension(&deflambda)
+    else # other Object
+      (class << self; self; end).class_eval(&deflambda)
+    end
+
+    obj
+  end
+
+end
+

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

@@ -0,0 +1,264 @@
+#
+# ini.rb - read and write ini files
+#
+# Copyright (C) 2007 Jeena Paradies
+# License: GPL
+# Author: Jeena Paradies (info@jeenaparadies.net)
+#
+# == Overview
+#
+# This file provides a read-wite handling for ini files.
+# The data of a ini file is represented by a object which
+# is populated with strings.
+
+class Ini
+  
+  # Class with methods to read from and write into ini files.
+  #
+  # A ini file is a text file in a specific format,
+  # it may include several fields which are sparated by
+  # field headlines which are enclosured by "[]".
+  # Each field may include several key-value pairs.
+  #
+  # Each key-value pair is represented by one line and
+  # the value is sparated from the key by a "=".
+  #
+  # == Examples
+  #
+  # === Example ini file
+  #
+  #   # this is the first comment which will be saved in the comment attribute
+  #   mail=info@example.com
+  #   domain=example.com # this is a comment which will not be saved
+  #   [database]
+  #   db=example
+  #   user=john
+  #   passwd=very-secure
+  #   host=localhost
+  #   # this is another comment
+  #   [filepaths]
+  #   tmp=/tmp/example
+  #   lib=/home/john/projects/example/lib
+  #   htdocs=/home/john/projects/example/htdocs
+  #   [ texts ]
+  #   wellcome=Wellcome on my new website!
+  #   Website description = This is only a example. # and another comment
+  #
+  # === Example object
+  #
+  #   A Ini#comment stores:
+  #   "this is the first comment which will be saved in the comment attribute"
+  #
+  #   A Ini object stores:
+  #
+  #   {
+  #    "mail" => "info@example.com",
+  #    "domain" => "example.com",
+  #    "database" => {
+  #     "db" => "example",
+  #     "user" => "john",
+  #     "passwd" => "very-secure",
+  #     "host" => "localhost"
+  #    },
+  #    "filepaths" => {
+  #     "tmp" => "/tmp/example",
+  #     "lib" => "/home/john/projects/example/lib",
+  #     "htdocs" => "/home/john/projects/example/htdocs"
+  #    }
+  #    "texts" => {
+  #     "wellcome" => "Wellcome on my new website!",
+  #     "Website description" => "This is only a example."
+  #    }
+  #   }
+  #
+  # As you can see this module gets rid of all comments, linebreaks
+  # and unnecessary spaces at the beginning and the end of each
+  # field headline, key or value.
+  #
+  # === Using the object
+  #
+  # Using the object is stright forward:
+  #
+  #   ini = Ini.new("path/settings.ini")
+  #   ini["mail"] = "info@example.com"
+  #   ini["filepaths"] = { "tmp" => "/tmp/example" }
+  #   ini.comment = "This is\na comment"
+  #   puts ini["filepaths"]["tmp"]
+  #   # => /tmp/example
+  #   ini.write()
+  # 
+  
+  #
+  # :inihash is a hash which holds all ini data
+  # :comment is a string which holds the comments on the top of the file
+  #
+  attr_accessor :inihash, :comment
+
+  #
+  # Creating a new Ini object
+  #
+  # +path+ is a path to the ini file
+  # +load+ if nil restores the data if possible
+  #        if true restores the data, if not possible raises an error
+  #        if false does not resotre the data
+  #
+  def initialize(path, load=nil)
+    @path = path
+    @inihash = {}
+    
+    if load or ( load.nil? and FileTest.readable_real? @path )
+      restore()
+    end
+  end
+  
+  #
+  # Retrive the ini data for the key +key+
+  #
+  def [](key)
+    @inihash[key]
+  end
+  
+  #
+  # Set the ini data for the key +key+
+  #
+  def []=(key, value)
+    raise TypeError, "String expected" unless key.is_a? String
+    raise TypeError, "String or Hash expected" unless value.is_a? String or value.is_a? Hash
+    
+    @inihash[key] = value
+  end
+  
+  #
+  # Restores the data from file into the object
+  #
+  def restore()
+    @inihash = Ini.read_from_file(@path)
+    @comment = Ini.read_comment_from_file(@path)
+  end
+  
+  #
+  # Store data from the object in the file
+  #
+  def update()
+    Ini.write_to_file(@path, @inihash, @comment)
+  end
+
+  #
+  # Reading data from file
+  #
+  # +path+ is a path to the ini file
+  #
+  # returns a hash which represents the data from the file
+  #
+  def Ini.read_from_file(path)
+        
+    inihash = {}
+    headline = nil
+    
+    IO.foreach(path) do |line|
+
+      line = line.strip.split(/#/)[0]
+      
+      # read it only if the line doesn't begin with a "=" and is long enough
+      unless line.length < 2 and line[0,1] == "="
+        
+        # it's a headline if the line begins with a "[" and ends with a "]"
+        if line[0,1] == "[" and line[line.length - 1, line.length] == "]"
+          
+          # get rid of the [] and unnecessary spaces
+          headline = line[1, line.length - 2 ].strip
+          inihash[headline] = {}
+        else
+        
+          key, value = line.split(/=/, 2)
+          
+          key = key.strip unless key.nil?
+          value = value.strip unless value.nil?
+          
+          unless headline.nil?
+            inihash[headline][key] = value
+          else
+            inihash[key] = value unless key.nil?
+          end
+        end        
+      end
+    end
+    
+    inihash
+  end
+  
+  #
+  # Reading comments from file
+  #
+  # +path+ is a path to the ini file
+  #
+  # Returns a string with comments from the beginning of the
+  # ini file.
+  #
+  def Ini.read_comment_from_file(path)
+    comment = ""
+    
+    IO.foreach(path) do |line|
+      line.strip!
+      break unless line[0,1] == "#" or line == ""
+      
+      comment << "#{line[1, line.length ].strip}\n"
+    end
+    
+    comment
+  end
+  
+  #
+  # Writing a ini hash into a file
+  #
+  # +path+ is a path to the ini file
+  # +inihash+ is a hash representing the ini File. Default is a empty hash.
+  # +comment+ is a string with comments which appear on the
+  #           top of the file. Each line will get a "#" before.
+  #           Default is no comment.
+  #
+  def Ini.write_to_file(path, inihash={}, comment=nil)
+    raise TypeError, "String expected" unless comment.is_a? String or comment.nil?
+    
+    raise TypeError, "Hash expected" unless inihash.is_a? Hash
+    File.open(path, "w") { |file|
+      
+      unless comment.nil?
+        comment.each do |line|
+          file << "# #{line}"
+        end
+      end
+      
+      file << Ini.to_s(inihash)
+    }
+  end
+  
+  #
+  # Turn a hash (up to 2 levels deepness) into a ini string
+  #
+  # +inihash+ is a hash representing the ini File. Default is a empty hash.
+  #
+  # Returns a string in the ini file format.
+  #
+  def Ini.to_s(inihash={})
+    str = ""
+    
+    inihash.each do |key, value|
+
+      if value.is_a? Hash
+        str << "[#{key.to_s}]\n"
+        
+        value.each do |under_key, under_value|
+          str << "#{under_key.to_s}=#{under_value.to_s unless under_value.nil?}\n"
+        end
+
+      else
+        str << "#{key.to_s}=#{value.to_s unless value2.nil?}\n"
+      end
+    end
+    
+    str
+  end
+  
+end
+