glue 0.41.0 → 1.0.0

data/lib/glue/autoreload.rb

@@ -1,60 +0,0 @@
-require 'facet/dir/self/recurse'
-
-module Kernel
-
-  # A Customized version of the autoreload from Facets. Also
-  # checks template files, and keeps a dirty flag.
-  
-  def autoreload(check_interval=10, glob = '.')
-    Thread.new(Time.now) do |start_time|
-      check_dirty = lambda do |file,hash,file_mtime|
-        if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
-          hash[file] = mtime 
-        end
-      end
-      file_mtime = {}
-
-      files = []
-      Dir.recurse(glob) do |f|
-        if f !~ /\/_darcs\// and f =~ /(.?)\.x(.?)/
-          files << f 
-        end
-      end
-      
-      loop do
-        need_reload = Hash.new
-        sleep check_interval 
-        $LOADED_FEATURES.each do |feature|
-          check_dirty.call(feature,need_reload,file_mtime)
-          $LOAD_PATH.each {|lp| check_dirty.call(File.join(lp, feature),need_reload,file_mtime)}
-        end
-                
-        unless need_reload.empty?
-          $autoreload_dirty = true
-          need_reload.each_pair do |file,mtime|
-            file_mtime[file] = mtime
-            Logger.debug "File '#{ file }' reloaded" if $DBG
-            begin
-              load(file)
-            rescue Exception => e
-              Logger.info e.inspect
-            end
-          end
-        end
-        
-        # Check for template files.
-        
-        files.each do |file|
-          if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
-            $autoreload_dirty = true
-            file_mtime[file] = mtime
-            Logger.debug "File '#{ file }' changed" if $DBG
-          end
-        end
-      
-      end # loop
-    
-    end
-  end
-
-end

data/lib/glue/builder.rb

@@ -1,57 +0,0 @@
-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 any target responding to <<.
-  
-  def initialize(buffer = '', options = {})
-    @buffer = buffer    
-  end  
-  
-  # Emit a text string.
-
-  def text!(str)
-    @buffer << str
-
-    return self
-  end
-  alias_method :print, :text!
-  alias_method :<<, :text!
-  
-  def to_s
-    @buffer.to_s
-  end
-  
-end
-
-end

data/lib/glue/builder/xml.rb

@@ -1,103 +0,0 @@
-require 'glue/builder'
-
-module Glue
-
-# A Builder for programmatically building XML blocks. 
-#--
-# TODO: move to nitro or move mixins here.
-#++
-
-class XmlBuilder < Builder
-  require 'nitro/helper/xhtml'
-  require 'nitro/helper/form'
-  require 'nitro/helper/table'
-
-  include_builder Nitro::XhtmlHelper
-  include_builder Nitro::TableHelper
-  include_builder Nitro::FormHelper
-  
-  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.to_s 
-          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 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

data/lib/glue/cache.rb

@@ -1,22 +0,0 @@
-module Glue
-
-# A general cache key.
-
-class CacheKey
-end
-
-# A general cache mechanism.
-#
-# This cache system was originaly developed for Nitro. It is 
-# used to cache fragments, og objects (entities), sessions, 
-# application scoped variables and more.
-
-class Cache
-
-  def update(hash)
-    hash.each { |key, value| self[key] = value }
-  end
-  
-end
-
-end

data/lib/glue/cache/drb.rb

@@ -1,51 +0,0 @@
-require 'drb'
-
-require 'glue/cache/memory'
-
-module Glue
-
-# A cached backed in a DRb server.
-# 
-# === Example
-#
-# This cache needs a corresponding DRb server. Here is how you
-# can setup the standard Nitro Drb server to keep a DrbCache:
-#
-# require 'glue/cache/memory'
-#
-# class MyDrbServer < Nitro::DrbServer
-#   def setup_drb_objects
-#     ..
-#     @my_cache = SyncHash.new 
-#     DRb.start_service("druby://#{my_drb_address}:#{my_drb_port}", @my_cache)
-#     ..
-#   end
-# end    
-#
-# MyDrbServer.start
-
-class DrbCache < MemoryCache
-
-  # Initialize the cache.
-  #
-  # === Options
-  #
-  # :address = The address of the DRb cache object.
-  # :port = The port of the DRb cache object.
-  
-  # The address of the Session cache / store (if distibuted).
- 
-  setting :address, :default => '127.0.0.1', :doc => 'The address of the Session cache'
-  
-  # The port of the Session DRb cache / store (if distributed).
- 
-  setting :port, :default => 9069, :doc => 'The port of the Session cache'
-  
-  
-  def initialize(address = DrbCache.address, port = DrbCache.port)
-    @hash = DRbObject.new(nil, "druby://#{address}:#{port}") 
-  end
-  
-end
-
-end

data/lib/glue/cache/file.rb

@@ -1,78 +0,0 @@
-require 'uri'
-require 'fileutils'
-require 'tmpdir'
-
-module Glue
- 
-  class FileCache
-
-    setting :basedir, :default => "#{Dir.tmpdir}/nitro_file_cache", :doc => 'The directory to store files'
-
-    def initialize(name = "cache", keepalive = nil)
-      @path = File.join(FileCache.basedir, name)
-      @keepalive = keepalive
-
-      FileUtils.mkdir_p(@path, :mode => 0700)
-    end
-
-    def []=(k,v)
-      fn = File.join(@path, escape_filename(k.to_s) )
-      encode_file(fn, v)
-    end
-    alias :set :[]=
-
-    def [](k)
-      fn = File.join(@path, escape_filename(k.to_s) )
-      return nil unless File.exists?(fn)
-      decode_file(fn)
-    end
-    alias :get :[]
-
-    def delete(k)
-      f = File.join(@path, escape_filename(k.to_s))
-      File.delete(f) if File.exists?(f)
-    end
-    
-    def gc!
-      return unless @keepalive
-
-      now = Time.now
-      all.each do |fn|
-        expire_time = File.stat(fn).atime + @keepalive 
-        File.delete(fn) if now > expire_time
-      end
-    end
-
-    def all
-      Dir.glob( File.join(@path, '*' ) )
-    end
-
-    private
-
-    def decode_file(fn)
-      val = nil
-      File.open(fn,"rb") do |f|
-        f.flock(File::LOCK_EX)
-        val = Marshal.load( f.read )
-        f.flock(File::LOCK_UN)
-      end
-      return val
-    end
-
-    def encode_file(fn, value)
-      File.open(fn, "wb") do |f| 
-        f.flock(File::LOCK_EX)
-        f.chmod(0600)
-        f.write(Marshal.dump(value))
-        f.flock(File::LOCK_UN)
-      end
-    end
-
-    # need this for fat filesystems
-    def escape_filename(fn)
-      URI.escape(fn, /["\/:;|=,\[\]]/)
-    end
-
-  end
-end
-

data/lib/glue/cache/memcached.rb

@@ -1,68 +0,0 @@
-# specifications:
-# http://cvs.danga.com/browse.cgi/wcmtools/memcached/doc/protocol.txt?rev=HEAD&content-type=text/plain
-#
-# very simple (= very fast) client for memcached
-#
-# i found the Ruby-MemCache library a little bit buggy and complicated, so i made my own before
-# fixing it ;)
-# 
-# TODO socket disconnection handling
-# TODO error handling
-# TODO multiple servers connections
-
-require "socket"
-
-module Glue
-
-  class MemCached
-
-    setting :address, :default => 'localhost', :doc => 'Server address'
-    setting :port, :default => 11211, :doc => 'Server port'
-
-    def initialize(name = "cache", keepalive = nil)
-      @sock = TCPSocket.new(MemCached.address, MemCached.port)
-      @name = name
-      @keepalive = keepalive
-    end
-    
-    def []=(k,v)
-      if @keepalive
-        exptime = (Time.now + @keepalive).to_i
-      else
-        exptime = 0
-      end
-
-      data = Marshal.dump(v)
-      @sock.print("set #{@name}:#{k} 0 #{exptime} #{data.size}\r\n#{data}\r\n")
-      response = @sock.gets # "STORED\r\n"
-      v
-    end
-    alias :set :[]=
-
-    def [](k)
-      @sock.print("get #{@name}:#{k}\r\n")
-      resp = @sock.gets 
-      if resp == "END\r\n"
-        return nil
-      end
-
-      #dummy, key, flags, size 
-      size = resp.split(/ /).last.to_i
-      raw_data = @sock.read(size)
-      @sock.gets # \r\n
-      @sock.gets # END\r\n
-      Marshal.load( raw_data )
-    end
-    alias :get :[]
-
-    def delete(k)
-      @sock.print("delete #{@name}:#{k}\r\n")
-      @sock.gets # "DELETED\r\n"
-    end
-
-    def gc!
-      # garbage collection is handled by the memcache server
-    end
-
-  end
-end