hashery 1.0.0

data/lib/hashery/lruhash.rb

@@ -0,0 +1,274 @@
+# LRU based Hash
+
+require 'enumerator'
+
+# Hash with LRU expiry policy.  There are at most max_size elements in a
+# LRUHash.  When adding more elements old elements are removed according
+# to LRU policy.
+#
+# by Robert Klemme
+
+class LRUHash
+
+  include Enumerable
+
+  attr_reader :max_size
+
+  attr_accessor :default
+  attr_accessor :default_proc
+  attr_accessor :release_proc
+
+  def initialize(max_size, default_value = nil, &block)
+    @max_size = normalize_max(max_size)
+    @default = default_value
+    @default_proc = block
+
+    @h = {}
+    @head = Node.new
+    @tail = front(Node.new)
+  end
+
+  def each_pair
+    if block_given?
+      each_node do |n|
+        yield [n.key, n.value]
+      end
+    else
+      enum_for :each_pair
+    end
+  end
+
+  alias each each_pair
+
+  def each_key
+    if block_given?
+      each_node do |n|
+        yield n.key
+      end
+    else
+      enum_for :each_key
+    end
+  end
+
+  def each_value
+    if block_given?
+      each_node do |n|
+        yield n.value
+      end
+    else
+      enum_for :each_value
+    end
+  end
+
+  def size
+    @h.size
+  end
+
+  def empty?
+    @head.succ.equal? @tail
+  end
+
+  def fetch(key, &b)
+    n = @h[key]
+
+    if n
+      front(n).value
+    else
+      (b || FETCH)[key]
+    end
+  end
+
+  def [](key)
+    fetch(key) do |k|
+      @default_proc ? @default_proc[self, k] : default
+    end
+  end
+
+  def keys
+    @h.keys
+  end
+
+  def values
+    @h.map {|k,n| n.value}
+  end
+
+  def has_key?(key)
+    @h.has_key? key
+  end
+
+  alias key? has_key?
+  alias member? has_key?
+  alias include? has_key?
+
+  def has_value?(value)
+    each_pair do |k, v|
+      return true if value.eql? v
+    end
+
+    false
+  end
+
+  alias value? has_value?
+
+  def values_at(*key_list)
+    key_list.map {|k| self[k]}
+  end
+
+  def assoc(key)
+    n = @h[key]
+
+    if n
+      front(n)
+      [n.key, n.value]
+    end
+  end
+
+  def rassoc(value)
+    each_node do |n|
+      if value.eql? n.value
+        front(n)
+        return [n.key, n.value]
+      end
+    end
+    nil
+  end
+
+  def key(value)
+    pair = rassoc(value) and pair.first
+  end
+
+  def store(key, value)
+    # same optimization as in Hash
+    key = key.dup.freeze if String === key && !key.frozen?
+
+    n = @h[key]
+
+    unless n
+      if size == max_size
+        # reuse node to optimize memory usage
+        n = delete_oldest
+        n.key = key
+        n.value = value
+      else
+        n = Node.new key, value
+      end
+
+      @h[key] = n
+    end
+
+    front(n).value = value
+  end
+
+  alias []= store
+
+  def delete(key)
+    n = @h[key] and remove_node(n).value
+  end
+
+  def delete_if
+    each_node do |n|
+      remove_node n if yield n.key, n.value
+    end
+  end
+
+  def max_size=(limit)
+    limit = normalize_max(limit)
+
+    while size > limit
+      delete_oldest
+    end
+
+    @max_size = limit
+  end
+
+  def clear
+    until empty?
+      delete_oldest
+    end
+
+    self
+  end
+
+  def to_s
+    s = nil
+    each_pair {|k, v| (s ? (s << ', ') : s = '{') << k.to_s << '=>' << v.to_s}
+    s ? (s << '}') : '{}'
+  end
+
+  alias inspect to_s
+
+  private
+
+  # iterate nodes
+  def each_node
+    n = @head.succ
+
+    until n.equal? @tail
+      succ = n.succ
+      yield n
+      n = succ
+    end
+
+    self
+  end
+
+  # move node to front
+  def front(node)
+    node.insert_after(@head)
+  end
+
+  # remove the node and invoke release_proc
+  # if set
+  def remove_node(node)
+    n = @h.delete(node.key)
+    n.unlink
+    release_proc and release_proc[n.key, n.value]
+    n
+  end
+
+  # remove the oldest node returning the node
+  def delete_oldest
+    n = @tail.pred
+    raise "Cannot delete from empty hash" if @head.equal? n
+    remove_node n
+  end
+
+  # Normalize the argument in order to be usable as max_size
+  # criterion is that n.to_i must be an Integer and it must
+  # be larger than zero.
+  def normalize_max(n)
+    n = n.to_i
+    raise ArgumentError, 'Invalid max_size: %p' % n unless Integer === n && n > 0
+    n
+  end
+
+  #
+  FETCH = Proc.new {|k| raise KeyError, 'key not found'}
+
+  # A single node in the doubly linked LRU list of nodes
+  Node = Struct.new :key, :value, :pred, :succ do
+    def unlink
+      pred.succ = succ if pred
+      succ.pred = pred if succ
+      self.succ = self.pred = nil
+      self
+    end
+
+    def insert_after(node)
+      raise 'Cannot insert after self' if equal? node
+      return self if node.succ.equal? self
+
+      unlink
+
+      self.succ = node.succ
+      self.pred = node
+
+      node.succ.pred = self if node.succ
+      node.succ = self
+
+      self
+    end
+  end
+
+end
+

data/lib/hashery/memoizer.rb

@@ -0,0 +1,64 @@
+# Memoizer
+#
+# Copyright (c) 2006 Erik Veenstra
+#
+# See http://javathink.blogspot.com/2008/09/what-is-memoizer-and-why-should-you.html
+
+# Memoizer wraps objects to provide cached method calls.
+#
+#   class X
+#     def initialize ; @tick = 0 ; end
+#     def tick; @tick + 1; end
+#     def memo; @memo ||= Memoizer.new(self) ; end
+#   end
+#
+#   x = X.new
+#   x.tick       #=> 1
+#   x.memo.tick  #=> 2
+#   x.tick       #=> 3
+#   x.memo.tick  #=> 2
+#   x.tick       #=> 4
+#   x.memo.tick  #=> 2
+#
+# You can also use to cache collections of objects to gain code speed ups.
+#
+#   points = points.collect{|point| Memoizer.cache(point)}
+#
+# After our algorithm has finished using points, we want to get rid of
+# these Memoizer objects. That's easy:
+#
+#    points = points.collect{|point| point.__self__ }
+#
+# Or if you prefer (it is ever so slightly safer):
+#
+#    points = points.collect{|point| Memoizer.uncache(point)}
+#
+class Memoizer
+
+  #private :class, :clone, :display, :type, :method, :to_a, :to_s
+  private *instance_methods(true).select{ |m| m.to_s !~ /^__/ }
+
+  def initialize(object)
+    @self  = object
+    @cache = {}
+  end
+
+  def __self__ ; @self ; end
+
+  # Not thread-safe! Speed is important in caches... ;]
+  def method_missing(method_name, *args, &block)
+    @cache[[method_name, args, block]] ||= @self.__send__(method_name, *args, &block)
+  end
+
+  #def self; @self; end
+
+  def self.cache(object)
+    new(object)
+  end
+
+  def self.uncache(cached_object)
+    cached_object.instance_variable_get('@self')
+  end
+
+end
+

data/lib/hashery/opencascade.rb

@@ -0,0 +1,82 @@
+#require 'facets/boolean' # bool
+#require 'facets/nullclass'
+require 'hashery/openobject'
+
+# = OpenCascade
+#
+# OpenCascade is subclass of OpenObject. It differs in a few
+# significant ways.
+#
+# The main reason this class is labeled "cascade", every internal
+# Hash is transformed into an OpenCascade dynamically upon access.
+# This makes it easy to create "cascading" references.
+#
+#   h = { :x => { :y => { :z => 1 } } }
+#   c = OpenCascade[h]
+#   c.x.y.z  #=> 1
+#
+# As soon as you access a node it automatically becomes an OpenCascade.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.r                   #=> #<OpenCascade:0x7fac368084c0 {}>
+#   c.a.b                 #=> #<OpenCascade:0x7fac3680a4f0 {}>
+#
+# But if you set a node, then that will be it's value.
+#
+#   c.a.b = 4             #=> 4
+#
+# To query a node without causing the auto-creation of an OpenCasade
+# object, use the ?-mark.
+#
+#   c.a.z?                #=> nil
+#
+# Finally, you can set a node and get the reciever back using
+# the !-mark.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.x!(4).y!(3)         #=> #<OpenCascade:0x7fac3680ccf0 {:x=>4, :y=>3}>
+#
+#--
+# Last, when an entry is not found, 'null' is returned rather then 'nil'.
+# This allows for run-on entries withuot error. Eg.
+#
+#   o = OpenCascade.new
+#   o.a.b.c  #=> null
+#
+# Unfortuately this requires an explict test for null? in 'if' conditions.
+#
+#   if o.a.b.c.null?  # true if null
+#   if o.a.b.c.nil?   # true if nil or null
+#   if o.a.b.c.not?   # true if nil or null or false
+#
+# So be sure to take that into account.
+#++
+
+class OpenCascade < OpenObject
+
+  def method_missing(sym, *args, &blk)
+    type = sym.to_s[-1,1]
+    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+    case type
+    when '='
+      self[name] = args.first
+    when '!'
+      @hash.__send__(key, *args, &blk)
+    when '?'
+      self[name]
+    else
+      if key?(name)
+        val = self[name]
+        if Hash === val
+          self[name] = OpenCascade.new(val) #self.class.new(val)
+        else
+          self[name]
+        end
+      else
+        self[name] = OpenCascade.new #self.class.new
+      end
+    end
+  end
+
+end
+

data/lib/hashery/openhash.rb

@@ -0,0 +1,65 @@
+# = OpenHash
+#
+# OpenHash is very similar to Ruby's own OpenStruct, but it offers some
+# useful advantages in that it is a true Hash object.
+#
+# Because OpenHash is a subclass of Hash, it can do everything a Hash
+# can *unless* a Hash method has been explicity exempted for use
+# an an open read/writer via the #omit! method.
+
+class OpenHash < Hash
+
+  # New OpenHash.
+  def initialize(data={})
+    super()
+    merge!(data)
+  end
+
+  #
+  def respond_to?(name)
+    key?(name.to_sym) || super(name)
+  end
+
+  #
+  def to_h
+    dup
+  end
+
+  #
+  def to_hash
+    dup
+  end
+
+  #
+  def inspect
+    super
+  end
+
+  # Omit specific Hash methods from slot protection.
+  def omit!(*methods)
+    methods.reject!{ |x| x.to_s =~ /^__/ }
+    (class << self; self; end).class_eval{ private *methods }
+  end
+
+  # Route get and set calls.
+  def method_missing(s,*a, &b)
+    type = s.to_s[-1,1]
+    name = s.to_s.sub(/[!?=]$/, '')
+    key  = name.to_sym
+    case type
+    when '='
+      self[key] = a[0]
+    #when '!'
+    #  self[s] = OpenHash.new
+    when '?'
+      key?(key)
+    else
+      if key?(key)
+        self[key]
+      else
+        super(s,*a,&b)
+      end
+    end
+  end
+
+end