facets 2.7.0 → 2.8.0

data/lib/more/facets/ini.rb

@@ -0,0 +1,267 @@
+# ini.rb - read and write ini files
+#
+# Copyright (C) 2007 Jeena Paradies
+# License: GPL
+# Author: Jeena Paradies (info@jeenaparadies.net)
+#
+# 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 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()
+# 
+
+class Ini
+  
+  
+  #
+  # :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
+
+  #
+  def to_h
+    @inihash.dup
+  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/instance_eval.rb

@@ -31,16 +31,16 @@ class Object
   #
   # TODO: Will only support calls with blocks as of Ruby 1.9+.
   #
-  def instance_eval(&block)
-    return super if block
+  def instance_eval(*args, &block)
+    return super if block or !args.empty?
     @_instance_eval ||= Functor.new do |op, *a|
       instance_eval{ send(op, *a) }
     end
   end
 
   # TODO for Ruby 1.9
-  #def instance_eval(&block)
-  #  return super if block
+  #def instance_eval(*args, &block)
+  #  return super if block or !args.empty?
   #  @_instance_functor ||= Functor.new do |op, *a, &b|
   #    fcall(op, *a, &b)
   #  end

data/lib/more/facets/ioredirect.rb

@@ -1,22 +1,8 @@
+warn "IORedirect is being deprecated. It is not a robust solution. If you use this library, please consider contributing to Facets by rewritting the library so we can keep it in Facets."
+
 # = IORedirect
 #
-# A class to redirect $stdout, or other IO object, to a StringIO object,
-# or any other object with a write() method.
-#
-#   s = StringIO.new
-#   r = Redirector.redirect($stdout, s) do
-#     $stdout.puts "this is a test"
-#   end
-#
-# == History
-#
-# * IORedirect was ported from Paul Brannan's Ruby Treasures.
-#
-# == Authors
-#
-# * Paul Brannan <paul@atdesk.com>
-#
-# = Copying
+# IORedirect was ported from Paul Brannan's Ruby Treasures.
 #
 # Copyright (C) 2002 Paul Brannan <paul@atdesk.com>
 #
@@ -29,6 +15,7 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 
+require 'thread'
 
 # = IORedirect
 #
@@ -36,7 +23,7 @@
 # or any other object with a write() method.
 #
 #   s = StringIO.new
-#   r = Redirector.redirect($stdout, s) do
+#   r = IORedirect.redirect($stdout, s) do
 #     $stdout.puts "this is a test"
 #   end
 #
@@ -55,7 +42,7 @@ class IORedirect
   def start
     raise "Redirection already in progress" if @t
     tmp = @from.dup
-    r, w = IO.pipe
+    r, w = *IO.pipe
     @from.reopen(w)
     @t = Thread.new do
       begin
@@ -78,53 +65,13 @@ class IORedirect
 
   # An exception-safe class method for redirection
   def self.redirect(from, to)
-    s = self.new(from, to)
+    s = new(from, to)
     begin
       yield
     ensure
       s.stop
     end
   end
-end
-
-
-# --- test ---
-
-if __FILE__ == $0 then
-
-  class SimpleStringIO
-    attr_reader :str
-    def initialize; @str = ''; end
-    def write(str); @str << str; end
-  end
-
-  Thread.abort_on_exception = true
-  s = SimpleStringIO.new
-  r = Redirector.redirect($stdout, s) do
-    $stdout.puts "this is a test"
-    $stdout.puts "of the StringIO redirection system"
-  end
-  puts "Done redirecting."
-  puts "Result:\n#{s.str}"
 
 end
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin #testing
-
-  require 'test/unit'
-
-=end
-
-
-

data/lib/more/facets/linkedlist.rb

@@ -0,0 +1,195 @@
+# LinkedList
+#
+# Copyright (C) 2006 Kirk Haines <khaines@enigo.com>.
+#
+# General Public License (GPL)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'enumerator'
+
+# LinkedList implements a simple doubly linked list with efficient
+# hash-like element access.
+#
+# This is a simple linked list implementation with efficient random
+# access of data elements.  It was inspired by George Moscovitis'
+# LRUCache implementation found in Facets 1.7.30, but unlike the
+# linked list in that cache, this one does not require the use of a
+# mixin on any class to be stored.  The linked list provides the
+# push, pop, shift, unshift, first, last, delete and length methods
+# which work just like their namesakes in the Array class, but it
+# also supports setting and retrieving values by key, just like a
+# hash.
+#
+# LinkedList was ported from the original in Kirk Hanes IOWA web framework.
+#
+class LinkedList
+
+        include Enumerable
+
+        # Represents a single node of the linked list.
+
+        class Node
+                attr_accessor :key, :value, :prev_node, :next_node
+
+                def initialize(key=nil,value=nil,prev_node=nil,next_node=nil)
+                        @key = key
+                        @value = value
+                        @prev_node = prev_node
+                        @next_node = next_node
+                end
+        end
+
+        def initialize
+                @head = Node.new
+                @tail = Node.new
+                @lookup = Hash.new
+                node_join(@head,@tail)
+        end
+
+        def [](v)
+                @lookup[v].value
+        end
+
+        def []=(k,v)
+                if @lookup.has_key?(k)
+                        @lookup[k].value = v
+                else
+                        n = Node.new(k,v,@head,@head.next_node)
+                        node_join(n,@head.next_node)
+                        node_join(@head,n)
+                        @lookup[k] = n
+                end
+                v
+        end
+
+        def empty?
+                @lookup.empty?
+        end
+
+        def delete(k)
+                n = @lookup.delete(k)
+                v = n ? node_purge(n) : nil
+                v
+        end
+
+        def first
+                @head.next_node.value
+        end
+
+        def last
+                @tail.prev_node.value
+        end
+
+        def shift
+                k = @head.next_node.key
+                n = @lookup.delete(k)
+                node_delete(n) if n
+        end
+
+        def unshift(v)
+                if @lookup.has_key?(v)
+                        n = @lookup[v]
+                        node_delete(n)
+                        node_join(n,@head.next_node)
+                        node_join(@head,n)
+                else
+                        n = Node.new(v,v,@head,@head.next_node)
+                        node_join(n,@head.next_node)
+                        node_join(@head,n)
+                        @lookup[v] = n
+                end
+                v
+        end
+
+        def pop
+                k = @tail.prev_node.key
+                n = @lookup.delete(k)
+                node_delete(n) if n
+        end
+
+        def push(v)
+                if @lookup.has_key?(v)
+                        n = @lookup[v]
+                        node_delete(n)
+                        node_join(@tail.prev_node,n)
+                        node_join(n,@tail)
+                else
+                        n = Node.new(v,v,@tail.prev_node,@tail)
+                        node_join(@tail.prev_node,n)
+                        node_join(n,@tail)
+                        @lookup[v] = n
+                end
+                v
+        end
+
+        def queue
+                r = []
+                n = @head
+                while (n = n.next_node) and n != @tail
+                        r << n.key
+                end
+                r
+        end
+
+        def to_a
+                r = []
+                n = @head
+                while (n = n.next_node) and n != @tail
+                        r << n.value
+                end
+                r
+        end
+
+        def length
+                @lookup.length
+        end
+
+        def each
+                n = @head
+                while (n = n.next_node) and n != @tail
+                        yield(n.key,n.value)
+                end
+        end
+
+        private
+
+        def node_delete(n)
+                node_join(n.prev_node,n.next_node)
+                v = n.value
+        end
+
+        def node_purge(n)
+                node_join(n.prev_node,n.next_node)
+                v = n.value
+                n.value = nil
+                n.key = nil
+                n.next_node = nil
+                n.prev_node = nil
+                v
+        end
+
+        def node_join(a,b)
+                a.next_node = b
+                b.prev_node = a
+        end
+
+end
+