glue 0.20.0 → 0.21.0

data/lib/glue/autoreload.rb

@@ -24,7 +24,7 @@ def autoreload(check_interval=10)
         end
       end
     end
-	}
+  }
 end
 
 end

data/lib/glue/builder.rb

@@ -0,0 +1,48 @@
+module Glue
+
+# A Builder integrates a number of Modules containing text 
+# manipulation utilities and provides an alternative
+# 'accomulation' interface.
+
+class Builder
+
+  # The builder output is accomulated in the buffer.
+  
+  attr_accessor :buffer
+  
+  class << self 
+  
+    def include_builder(*modules)
+      for mod in modules
+        include mod      
+        for meth in mod.public_instance_methods
+          self.module_eval %{
+            alias_method :_mixin_#{meth}, :#{meth}
+            def #{meth}(*args)
+              @buffer << _mixin_#{meth}(*args)
+              return self
+            end
+          }
+        end      
+      end
+    end
+    alias_method :builder, :include_builder
+    
+  end
+
+  # Provide the target where the builder output will be
+  # accomulated. The builder utilizes duck typing to make it
+  # compatible with anly target responding to <<.
+  
+  def initialize(buffer = '', *modules)
+    @buffer = buffer
+    
+  end  
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>
+
+__END__

data/lib/glue/builder/xml.rb

@@ -0,0 +1,114 @@
+require 'glue/builder'
+
+require 'nitro/mixin/xhtml'
+require 'nitro/mixin/form'
+require 'nitro/mixin/table'
+
+module Glue
+
+# A Builder for programmatically building XML blocks. 
+#--
+# TODO: move to nitro or move mixins here.
+#++
+
+class XmlBuilder < Builder
+  include_builder Nitro::XhtmlMixin
+  include_builder Nitro::TableMixin
+  include_builder Nitro::FormMixin
+  
+  def method_missing(tag, *args, &block)
+    self.class.module_eval <<-"end_eval", __FILE__, __LINE__
+      def #{tag}(*args)
+        attrs = args.last.is_a?(Hash) ? args.pop : nil
+
+        if block_given?
+          start_tag!('#{tag}', attrs)
+          yield
+          end_tag!('#{tag}')
+        elsif (!args.empty?)
+          start_tag!('#{tag}', attrs)
+          @buffer << args.first 
+          end_tag!('#{tag}')
+        else
+          start_tag!('#{tag}', attrs, false)
+          @buffer << ' />'
+        end
+        
+        return self
+      end
+    end_eval
+
+    self.send(tag, *args, &block)
+  end
+
+  # Emit the start (opening) tag of an element.
+
+  def start_tag!(tag, attributes = nil, close = true)
+    unless attributes
+      if close
+        @buffer << "<#{tag}>"
+      else
+        @buffer << "<#{tag}"
+      end
+    else
+      @buffer << "<#{tag}"
+      for name, value in attributes
+        if value
+          @buffer << %| #{name}="#{value}"|
+        else
+          @buffer << %| #{name}="1"|
+        end
+      end
+      @buffer << ">" if close
+    end
+
+    return self
+  end
+
+  # Emit the end (closing) tag of an element.
+
+  def end_tag!(tag)
+    @buffer << "</#{tag}>" 
+
+    return self
+  end
+
+  # Emit a text string.
+
+  def text!(str)
+    @buffer << str
+
+    return self
+  end
+  alias_method :print, :text!
+
+  # Emit a comment.
+
+  def comment!(str)
+    @buffer << "<!-- #{str} -->" 
+
+    return self
+  end
+
+  # Emit a processing instruction.
+
+  def processing_instruction!(name, attributes = nil)
+    unless attributes
+      @buffer << "<?#{name} ?>"
+    else
+      @buffer << "<?#{name} "
+      attributes.each do |a, v|
+        @buffer << %[#{a}="#{v}" ]
+      end
+      @buffer << "?>"
+    end
+    
+    return self
+  end
+  alias_method :pi!, :processing_instruction!
+
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/glue/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/lib/glue/configuration.rb

@@ -14,87 +14,105 @@ require 'glue/flexob'
 
 class Configuration
 
-	# A hash of setting owners. Use double @'s to allow for
-	# the Settings alias.
-	#--
-	# TODO: find a better name.
-	#++
-		
-	@@owners = Glue::SafeHash.new	
+  # A hash of setting owners. Use double @'s to allow for
+  # the Settings alias.
+  #--
+  # TODO: find a better name.
+  #++
+    
+  @@owners = Glue::SafeHash.new  
 
-	# A datastructure to store Settings metadata.
-	
-	class Setting
-		attr_accessor :owner, :name, :type, :value, :options
-		
-		def initialize(owner, name, options)
-			raise ArgumentError.new('A default value is required') unless options.key?(:default)
-			@owner, @name = owner, name
-			@options = options
-			@value = options[:default]
-			@type = options[:type] = options[:type] || @value.class
-		end
+  # A datastructure to store Settings metadata.
+  
+  class Setting
+    attr_accessor :owner, :name, :type, :value, :options
+    
+    def initialize(owner, name, options)
+      raise ArgumentError.new('A default value is required') unless options.key?(:default)
+      @owner, @name = owner, name
+      @options = options
+      @value = options[:default]
+      @type = options[:type] = options[:type] || @value.class
+    end
 
-		def value=(value)
-			@value = value
-			constant(@owner).module_eval %{
-				@@#{@name} = #{value.inspect}
-			}
-		end
+    def value=(value)
+      @value = value
+      constant(@owner).module_eval %{
+        @@#{@name} = #{value.inspect}
+      }
+    end
 
-		def to_s
-			@value.to_s
-		end
-	end
-	
-	class << self
-	
-		def setup(options)
-			options.each do |owner, ss|
-				owner = constant(owner)
-				ss.each do |name, s|
-					@@owners[owner][name.to_sym].value = s
-					owner.module_eval %{
-						@@#{name} = #{s.inspect}
-					}
-				end 
-			end
-		end
+    def to_s
+      @value.to_s
+    end
+  end
+  
+  class << self
+  
+    # Inject the configuration parameters to configuration
+    # classes.
+    
+    def setup(options)
+      options.each do |owner, ss|
+        next unless ss
+        begin
+          owner = constant(owner)
+        rescue NameError
+          next
+        end
+        ss.each do |name, s|
+          @@owners[owner][name.to_sym].value = s
+          owner.module_eval %{
+            @@#{name} = #{s.inspect}
+          }
+        end 
+      end
+    end
 
-		def parse(options)
-			temp = YAML::load(options)
-			options = {}
-			temp.each { |k, v| options[constant(k.gsub(/\./, '::').to_sym)] = v }
-			setup(options)
-		end
-		
-		def load(filename)
-			parse(File.read(filename))
-		end
-		
-		def add_setting(owner, name, options)
-			s = @@owners[owner] || {}
-			s[name] = Setting.new(owner, name, options)
-			@@owners[owner] = s
-		end
-		
-		def settings(owner = nil)
-			if owner
-				@@owners[owner]
-			else
-				@@owners.values.inject([]) { |memo, obj| memo.concat(obj.values) }
-			end
-		end
-		alias_method :all, :settings
-		alias_method :[], :settings
+    # Parse configuration parameters in yaml format.
+    
+    def parse(options)
+      temp = YAML::load(options)
+      options = {}
+      temp.each do |k, v| 
+        begin
+          options[constant(k.gsub(/\./, '::').to_sym)] = v 
+        rescue Object
+          options[k] = v 
+        end
+      end
+      setup(options)
+    end
+    
+    # Load and parse an external yaml configuration file.
+    
+    def load(filename)
+      parse(File.read(filename))
+    end
+    
+    def add_setting(owner, name, options)
+      s = @@owners[owner] || {}
+      s[name] = Setting.new(owner, name, options)
+      @@owners[owner] = s
+    end
+    
+    def settings(owner = nil)
+      if owner
+        @@owners[owner]
+      else
+        @@owners.values.inject([]) { |memo, obj| memo.concat(obj.values) }
+      end
+    end
+    alias_method :all, :settings
+    alias_method :[], :settings
 
-		def method_missing(sym)
-			if sym.to_s =~ /[A-Z]/ # facet's capitalized? is buggy at the moment.
-				Flexob.new(self[constant(sym)])
-			end
-		end
-	end
-	
+    def method_missing(sym)
+      if sym.to_s =~ /[A-Z]/ # facet's capitalized? is buggy at the moment.
+        Flexob.new(self[constant(sym)])
+      end
+    end
+  end
+  
 end
 
 # Alias for the Configuration class (shorter).
@@ -104,23 +122,23 @@ end
 
 class Module
 
-	# Defines a configuration setting.
-	#--
-	# TODO: implement with annotations.
-	#++
-	
-	def setting(sym, options = {})
-		Configuration.add_setting(self, sym, options)
-		module_eval %{
-			mattr_accessor sym, options[:default]
-			
+  # Defines a configuration setting.
+  #--
+  # TODO: implement with annotations.
+  #++
+  
+  def setting(sym, options = {})
+    Configuration.add_setting(self, sym, options)
+    module_eval %{
+      mattr_accessor sym, options[:default]
+      
       def self.#{sym.id2name}=(obj)
         @@#{sym.id2name} = obj
         Configuration[#{self}][:#{sym}].value = obj
       end
-		}
-	end
-	
+    }
+  end
+  
 end
 
-# * George Moschovitis <gm@navel.gr> 	
+# * George Moschovitis <gm@navel.gr>