facets 2.6.0 → 2.7.0

data/lib/more/facets/ini.rb

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

data/lib/more/facets/instantise.rb

@@ -1 +0,0 @@
-require 'facets/instantize'

data/lib/more/facets/instantize.rb

@@ -1,95 +0,0 @@
-# = Instantize
-#
-# Instantize converts module methods into instance methods
-# such that the first parameter is passed self at the instance level.
-# This promotes DRY programming when wishing to offer both an inheritable
-# and a module callable procedure.
-#
-#   module MyModule
-#     extend Instantize
-#
-#     def self.jumble( obj, arg )
-#       obj + arg
-#     end
-#   end
-#
-#   class String
-#     include MyModule
-#   end
-#
-#   MyModule.jumble( "Try", "Me" )  #=> "TryMe"
-#
-#   "Try".jumble( "Me" )            #=> 'TryMe'
-#
-# == Notes
-#
-# This module used to be called PromoteSelf. Instantize is more descriptive, but 
-# a better name is probably still out there.
-#
-# == 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.
-
-
-# = Instantize
-#
-# Instantize converts module methods into instance methods
-# such that the first parameter is passed self at the instance level.
-# This promotes DRY programming when wishing to offer both an inheritable
-# and a module callable procedure.
-#
-#   module MyModule
-#     extend Instantize
-#
-#     def self.jumble( obj, arg )
-#       obj + arg
-#     end
-#   end
-#
-#   class String
-#     include MyModule
-#   end
-#
-#   MyModule.jumble( "Try", "Me" )  #=> "TryMe"
-#
-#   "Try".jumble( "Me" )            #=> 'TryMe'
-#
-# == Notes
-#
-# This module used to be called PromoteSelf. Instantize is more descriptive, but 
-# a better name is probably still out there.
-#
-module Instantize
-
-  def self.append_features(mod)
-    mod.extend self
-  end
-
-  def singleton_method_added( meth )
-    d = %{
-      def #{meth}(*args)
-        #{self.name}.#{meth}(self,*args)
-      end
-    }
-    self.class_eval d
-    super(meth)
-  end
-
-end
-
-# Constant Alias
-Instantise = Instantize
-

data/lib/more/facets/interval.rb

@@ -1,282 +0,0 @@
-# = Interval
-#
-# While Ruby support the Range class out of the box, is does not quite
-# fullfil the role od a real Interval class. For instance, it does
-# not support excluding the front sentinel. This is because Range
-# also tries to do triple duty as a simple Sequence and as a simple Tuple-Pair,
-# thus limiting its potential as an Interval. The Interval class remedies
-# the situation by commiting to interval behavior, and then extends the class'
-# capabilites beyond that of the standard Range in ways that naturally
-# fall out of that.
-#
-# Range depends on two methods: #succ and #<=>. If numeric
-# ranges were the only concern, those could just as well be #+ and #<=>,
-# but esoteric forms make that unfeasible --the obvious example being a String
-# range. But a proper Interval class requires mathematical continuation,
-# thus the Interval depends on #+ and #<=>, as well as #- as the inverse of #+.
-#
-#   i = Interval.new(1,5)
-#   i.to_a       #=> [1,2,3,4,5]
-#
-#   i = Interval[0,5]
-#   i.to_a(2)    #=> [0,2,4]
-#
-#   i = Interval[1,5]
-#   i.to_a(-1)   #=> [5,4,3,2,1]
-#
-#   i = Interval[1,3]
-#   i.to_a(1,2)  #=> [1.0,1.5,2.0,2.5,3.0]
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Todo
-#
-# * Still need to tie in Infinity.
-#
-# == 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.
-
-require 'facets/multiton'
-require 'facets/enumerablepass'
-#require 'facets/infinity'
-
-# = Interval
-#
-# While Ruby support the Range class out of the box, is does not quite
-# fullfil the role od a real Interval class. For instance, it does
-# not support excluding the front sentinel. This is because Range
-# also tries to do triple duty as a simple Sequence and as a simple Tuple-Pair,
-# thus limiting its potential as an Interval. The Interval class remedies
-# the situation by commiting to interval behavior, and then extends the class'
-# capabilites beyond that of the standard Range in ways that naturally
-# fall out of that.
-#
-# Range depends on two methods: #succ and #<=>. If numeric
-# ranges were the only concern, those could just as well be #+ and #<=>,
-# but esoteric forms make that unfeasible --the obvious example being a String
-# range. But a proper Interval class requires mathematical continuation,
-# thus the Interval depends on #+ and #<=>, as well as #- as the inverse of #+.
-#
-#   i = Interval.new(1,5)
-#   i.to_a       #=> [1,2,3,4,5]
-#
-#   i = Interval[0,5]
-#   i.to_a(2)    #=> [0,2,4]
-#
-#   i = Interval[1,5]
-#   i.to_a(-1)   #=> [5,4,3,2,1]
-#
-#   i = Interval[1,3]
-#   i.to_a(1,2)  #=> [1.0,1.5,2.0,2.5,3.0]
-
-class Interval
-
-  include Multiton
-  include EnumerablePass
-
-  def self.[]( *args )
-    self.new( *args )
-  end
-
-  def initialize(first, last, exclude_first=false, exclude_last=false )
-    raise ArgumentError, "bad value for interval" if first.class != last.class
-    @first = first
-    @last = last
-    @exclude_first = exclude_first
-    @exclude_last = exclude_last
-    @direction = (@last <=> @first)
-  end
-
-  # Returns a two element array of first and last sentinels.
-  #
-  #  (0..10).sentinels   #=> [0,10]
-  #
-  def sentinels
-    return [@first, @last]
-  end
-
-  # Returns the first or last sentinal of the interval.
-  def first ; @first ; end
-  def last ; @last ; end
-
-  #
-  def exclude_first? ; @exclude_first ; end
-  def exclude_last? ; @exclude_last ; end
-
-  # (IMHO) these should be deprectated
-  alias_method( :begin, :first )
-  alias_method( :end, :last )
-  alias_method( :exclude_begin?, :exclude_first? )
-  alias_method( :exclude_end?, :exclude_last? )
-
-  # Returns +true+ if the start and end sentinels are equal and the interval is closed; otherwise +false+.
-  def degenerate? ; @direction == 0 and ! (@exclusive_first or @exclusive_last) ;  end
-
-  # Returns +true+ if the start and end sentinels are equal and the interval is open; otherwise +false+.
-  def null? ; @direction == 0 and @exclusive_first and @exclusive_last ; end
-
-  # Returns the direction of the interval indicated by +1, 0 or -1.
-  #
-  #   (1..5).direction  #=> 1
-  #   (5..1).direction  #=> -1
-  #   (1..1).direction  #=> 0
-  #
-  def direction ; @direction ; end
-
-  # Returns a new interval inclusive of of both sentinels.
-  def closed; Interval.new(@first, @last, true, true) ; end
-
-  # Returns a new interval exclusive of both sentinels.
-  def opened; Interval.new(@first, @last, true, true) ; end
-
-  # Returns a new interval with either the first or the last sentinel exclusive.
-  # If the parameter is false, the deafult, then the first sentinel is excluded;
-  # if the parameter is true, the last sentinel is excluded.
-  def half_closed(e=false)
-    e ? Interval.new(@first, @last, true, false) : Interval.new(@first, @last, false, true)
-  end
-
-  # Returns a new interval with one of the two sentinels opened or closed
-  def first_closed ; Interval.new(@first, @last, false, true) ; end
-  def last_closed ; Interval.new(@first, @last, true, false) ; end
-  def first_opened ; Interval.new(@first, @last, true, false) ; end
-  def last_opened ; Interval.new(@first, @last, false, true) ; end
-
-  # Unary shorthands. These return a new interval exclusive of first,
-  # last or both sentinels, repectively.
-  def +@ ; Interval.new(first, last, true, false) ; end
-  def -@ ; Interval.new(first, last, false, true) ; end
-  def ~@ ; Interval.new(first, last, true, true) ; end
-
-  # Returns a new interval with the sentinels reversed.
-  #
-  #   (0..10).reversed  #=> 10..0
-  #
-  def reversed
-    Interval.new(@last, @first, true, true)
-  end
-
-  # Returns the length of the interval as the difference between
-  # the first and last elements. Returns +nil+ if the sentinal objects
-  # do not support distance comparison (#distance).
-  # TODO: Add +n+ parameter to count segmentations like those produced by #each.
-  def distance
-    @last - @first
-    #if @last.respond_to?( :distance )
-    #  @last.distance( @first )
-    #else
-    #  #self.to_a.length
-    #end
-  end
-  alias_method( :length, :distance )
-  alias_method( :size, :distance )
-
-  # Returns the lesser of the first and last sentinals.
-  def min
-    ((@first <=> @last) == -1) ? @first : @last
-  end
-
-  # Returns the greater of the first and last sentinals.
-  def max
-    ((@first <=> @last) == 1) ? @first : @last
-  end
-
-  # Returns true or false if the element is part of the interval.
-  def include?(x)
-    # todo: infinity?
-    tf = exclude_first? ? 1 : 0
-    tl = exclude_last? ? -1 : 0
-    (x <=> first) >= tf and (x <=> last) <= tl
-  end
-  alias_method( :===, :include? )
-  alias_method( :member?, :include? )
-
-=begin
-#     def include?(x)
-#       tf = exclude_first? ? 1 : 0
-#       tl = exclude_last? ? -1 : 0
-#       # if other classes handled Infinity in their <=> method
-#       # (which probably they should) this clause would not be required
-#       if first.kind_of?(InfinityClass)
-#         ft = ((first <=> x) <= tf)
-#       else
-#         ft = (x <=> first) >= tf
-#       end
-#       if last.kind_of?(InfinityClass)
-#         fl = ((last <=> x) >= tl)
-#       else
-#         fl = (x <=> last) <= tl
-#       end
-#       ft && fl
-#     end
-=end
-
-  # Iterates over the interval, passing each _n_th element to the block.
-  # If n is not given then n defaults to 1. Each _n_th step is determined
-  # by invoking +\++ or +\-+ n, depending on the direction of the interval.
-  # If n is negative the iteration is preformed in reverse form end sentinal
-  # to front sentinal. A second parameter, d, can be given in which case
-  # the applied step is calculated as a fraction of the interval's length
-  # times n / d. This allows iteration over the whole interval in equal sized
-  # segments.
-  #
-  #   1..5.each { |e| ... }        #=> 1 2 3 4 5
-  #   1..5.each(2) { |e| ... }     #=> 1 3 5
-  #   1..5.each(1,2) { |e| ... }   #=> 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
-  #
-  def each(n=1, d=nil)  # :yield:
-    return (n < 0 ? @last : @first) if degenerate?  # is this right for all values of n ?
-    s = d ? self.length.to_f * (n.to_f / d.to_f) : n.abs
-    raise "Cannot iterate over zero length steps." if s == 0
-    s = s * @direction
-    if n < 0
-      e = @exclude_last ? @last - s : @last
-      #e = @exclude_last ? @last.pred(s) : @last
-      t = @exclude_last ? 1 : 0
-      #while e.cmp(@first) >= t
-      while (e <=> @first) >= t
-        yield(e)
-        e -= s
-        #e = e.pred(s)
-      end
-    else
-      e = @exclude_first ? @first + s : @first
-      #e = @exclude_first ? @first.succ(s) : @first
-      t = @exclude_last ? -1 : 0
-      #while e.cmp(@last) <= t
-      while (e <=> @last) <= t
-        yield(e)
-        e += s
-        #e = e.succ(s)
-      end
-    end
-  end
-  alias_method( :step, :each )
-
-  # Should there be a #reverse_each ?
-  # Since #each can now take a negative argument, this isn't really needed.
-  # Should it exist anyway and routed to #each?
-  # Also, alias_method( :reverse_step, :reverse_each )
-
-  # Compares two intervals to see if they are equal
-  def eql?(other)
-    return false unless @first == other.first
-    return false unless @last == other.last
-    return false unless @exclude_first == other.exclude_first?
-    return false unless @exclude_last == other.exclude_last?
-    true
-  end
-
-end