facets 1.7.46 → 1.8.0

data/work/more/aobject.rb

@@ -0,0 +1,132 @@
+# = aobject.rb
+#
+# == Developer Notes
+#
+# NOTE Add validity tests?
+
+require 'facets/core/kernel/meta_eval'
+require 'facets/core/hash/rekey'
+
+#
+
+class AObject
+
+  def self.instance_attributes
+    @@attributes ||= []
+  end
+
+  # Define an attribute.
+
+  def self.attr(name)
+    name = name.to_s.downcase
+    instance_attributes << name
+    define_method(name) do
+      @attributes[name]
+    end
+    define_method("#{name}=") do |v|
+      @attributes[name] = v
+    end
+  end
+
+  # Subclasses have to call super in initialize.
+
+  def initialize( keys=nil, &yld )
+    init = @@attributes.collect{|a|[a,nil]}.flatten
+    @attributes = Hash[*init]
+    return unless keys or yld
+    keys = (keys||yld).to_h
+    keys.rekey!{ |k| k.to_s.downcase }
+    @attributes.update(keys)
+  end
+
+  #
+
+  def attribute(name)
+    @attributes[name.to_s.downcase]
+  end
+  alias :at :attribute
+
+  #
+
+  def attributes
+    @@attributes.keys
+  end
+
+  # Bracket accessors.
+
+  def key?(name)
+    @attribuites.key?(name.to_s.downcase)
+  end
+
+  def [](name)
+    @attributes[name.to_s.downcase]
+  end
+
+  def []=(name, value)
+    @attributes[name.to_s.downcase] = value
+  end
+
+  # Hash conversion.
+
+  def to_hash(all=false)
+    @attributes
+  end
+  alias :to_h :to_hash
+
+  # YAML conversion.
+
+  def to_yaml
+    @attributes.to_yaml
+  end
+
+  # Arbitrary information.
+
+  def method_missing( s, *a, &b )
+    s = s.to_s
+    if s[-1,1] == '='
+      meta_eval { attr s.chomp('=') }
+      send(s,*a,&b)
+    else
+      super
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  class TestAObject < Test::Unit::TestCase
+
+    class X < AObject
+      attr :a
+      attr :b
+      attr :c
+
+      def a
+        self[:a] || 1
+      end
+
+      def c
+        self[:c] + 1
+      end
+    end
+
+    def test_001
+      x = X.new
+      assert_equal( 1, x.a )
+      x.b = 2
+      assert_equal( 2, x.b )
+      x.c = 3
+      assert_equal( 4, x.c )
+    end
+
+  end
+
+=end

data/work/more/autohash.rb

@@ -0,0 +1,67 @@
+######################################
+# WARNING! Highly expiremental code! #
+######################################
+
+# = autohash.rb
+#
+# == Copyright (c) 2005 Jan Molic
+#
+#   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 and Contributors
+#
+# * Jan Molic
+
+# Author::    Jan Molic
+# Copyright:: Copyright (c) 2005 Jan Molic
+# License::   Ruby License
+
+require 'facets/core/hash/self/auto'
+
+# = AutoHash
+#
+# Like Hash but automatically generates continous subsections.
+
+class AutoHash < Hash
+
+  # Alternate to #new which auto-creates subhash as needed.
+  #
+  #   d = AutoHash.new
+  #   d.a.b.c = "abc"  #=> { :a=>{:b=>{:c=>"abc"}}}
+  #
+  def self.new(*args) auto(*args) end
+
+end
+
+
+# # = AutoDictionary
+# #
+# # Like Dictionary but automatically generates continues subsections.
+#
+# class AutoDictionary < Dictionary
+#
+#   class << self
+#
+#     undef_method :auto
+#     undef_method :auto_alpha
+#
+#     # Alternate to #new which auto-creates sub-dictionaries as needed.
+#     #
+#     #   d = Dictionary.auto
+#     #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+#     #
+#     def new( *args )
+#       leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+#       super(*args, &leet)
+#     end
+#
+#   end
+#
+# end

data/work/more/cache.rb

@@ -0,0 +1,189 @@
+unless Enumerable.instance_methods.include?("min_by")
+  # for Ruby 1.8
+  module Enumerable
+    def min_by(&block)
+      min {|i,j| block.call(i) <=> block.call(j) }
+    end
+  end
+end
+
+module Glue
+
+# Abstract super class of all cache implementations.
+class Cache; end
+
+# Abstract super class of all caching strategies.
+class Cache::Strategy; end
+
+# Implements an unbounded cache strategy. The cache size can 
+# grow to infinity.
+
+class Cache::Strategy::Unbounded < Cache::Strategy
+  class Item < Struct.new(:value); end
+  def item_class() Item end
+
+  def access(item) end
+  def delete(item) end
+  def insert_or_extrude(item, enum) end
+end
+
+# Abstract class for a capacity bounded strategy. Only up to 
+# _capacity_ items are allowed to be stored in the cache 
+# at any time.
+
+class Cache::Strategy::CapacityBounded < Cache::Strategy
+  attr_accessor :capacity
+
+  def initialize(capacity)
+    @capacity = capacity
+    @n_items = 0  # number of items in cache
+  end
+
+  def inc(item)
+    raise if full?
+    @n_items += 1
+  end
+
+  def dec(item)
+    raise if empty?
+    @n_items -= 1
+  end
+
+  def full?
+    @n_items >= @capacity 
+  end
+
+  def empty?
+    @n_items == 0
+  end
+end
+
+# Implements the least frequently used (LFU) strategy.
+
+class Cache::Strategy::LFU < Cache::Strategy::CapacityBounded
+  class Item < Struct.new(:value, :freq); end 
+  def item_class() Item end
+
+  def access(item)
+    item.freq += 1
+  end
+
+  def delete(item)
+    dec(item)
+  end
+
+  # enum::
+  #    a [key, item] enumerable
+
+  def insert_or_extrude(item, enum)
+    # find least recently used key/item and yield
+    yield enum.min_by {|key, it| it.freq} while full?
+    item.freq = 0 
+    inc(item)
+  end
+end
+
+# Implements the least recently used (LRU) strategy.
+
+class Cache::Strategy::LRU < Cache::Strategy::CapacityBounded
+  class Item < Struct.new(:value, :time); end 
+  def item_class() Item end
+
+  def access(item)
+    item.time = Time.now
+  end
+
+  def delete(item)
+    dec(item)
+  end
+
+  # enum::
+  #    a [key, item] enumerable
+  #
+  def insert_or_extrude(item, enum)
+    # find least recently used key/item and yield
+    yield enum.min_by {|key, it| it.time} while full?
+    item.time = Time.now
+    inc(item)
+  end
+end
+
+# Implements a cache using a parameterizable strategy and a storage. 
+# The protocol that the _store_ must understand is: 
+#
+#   fetch(key) -> val
+#   has_key?(key)
+#   delete(key) -> val
+#   each {|key, val| }
+
+class Cache::StorageCache < Cache
+
+  def initialize(strategy, store=Hash.new, store_on_update=false)
+    @strategy = strategy
+    @store = store
+    @store_on_update = store_on_update
+  end
+
+  def has_key?(key)
+    @store.has_key?(key)
+  end
+
+  def delete(key)
+    if @store.has_key?(key)
+      item = @store.delete(key)
+      @strategy.delete(item)
+      item.value
+    else
+      nil
+    end
+  end
+
+  def fetch(key, default_value=nil)
+    if @store.has_key?(key)
+      item = @store.fetch(key)
+      @strategy.access(item)
+      @store.store(key, item) if @store_on_update
+      item.value
+    else
+      default_value
+    end
+  end
+
+  def store(key, value)
+    if @store.has_key?(key)
+      # update only 
+      item = @store.fetch(key)
+      item.value = value 
+      @strategy.access(item)
+      @store.store(key, item) if @store_on_update
+    else 
+      # insert new item
+      item = @strategy.item_class.new 
+      item.value = value  
+      @strategy.insert_or_extrude(item, @store) do |k, i|
+        @strategy.delete(i)
+        @store.delete(k)
+      end
+      @store.store(key, item) # correct!
+    end
+    value
+  end
+
+  alias [] fetch
+  alias []= store
+end
+
+# Implements an in-memory cache (uses a Hash as store) with a LRU replacement
+# stragegy.
+
+class Cache::MemoryLRUCache < Cache::StorageCache
+  DEFAULT_CAPACITY = 20
+
+  def initialize(capacity=DEFAULT_CAPACITY)
+    super(Cache::Strategy::LRU.new(capacity))
+  end
+end
+
+end # module Glue
+
+# * Michael Neumann <mneumann@ntecs.de>

data/work/more/class_inheritable_attributes.rb

@@ -0,0 +1,120 @@
+# THIS IS FROM RAILS
+# How does it compare to Facets' own Inheritor?
+
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
+
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= {}
+  end
+
+  def write_inheritable_attribute(key, value)
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    inheritable_attributes.clear
+  end
+
+  private 
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
+    end
+
+    if respond_to?(:inherited)
+      alias_method :inherited_without_inheritable_attributes, :inherited
+    end
+    alias_method :inherited, :inherited_with_inheritable_attributes
+end