facets 1.8.49 → 1.8.51

data/work/more/aobject.rb

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

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

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

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