root/lang/ruby/open-uri-cache/trunk/lib/open-uri/cache.rb @ 4640

require 'stringio'
require 'open-uri'
require 'singleton'

module OpenURI
  # interface for auto caching open-uri
  # 
  class Cache
    include Singleton

    class << self
      alias instance_original instance

      def instance
        unless @engine
        end
        
        instance_original
      end

      def method_missing meth, *args, &block
        instance.__send__(meth, *args, &block)
      end

    end

    attr_reader :engine
    attr_accessor :enabled

    def engine= val
      @engine = val.instance
    end

    def enable!
      @enabled = true
      # hook point for engine class
      if @engine.methods.include? :enable!
        @engine.enable!
      end
    end

    def enabled?
      @enabled
    end

    def disabled?
      !@enabled
    end

    def disable!
      @enabled = false
      # hook point for engine class
      if @engine.methods.include? :diable!
        @engine.disable!
      end
    end

    # if it isn't defined method in this class, call engine class method.
    def method_missing meth, *args, &block
      @engine.__send__(meth, *args, &block)
    end

    # if you write orignal engine, please include this module for checking.
    module Lint
      def self.instance
        raise NotImplementedError
      end

      def set key, val
        raise NotImplementedError
      end

      def get key
        raise NotImplementedError
      end
    end

    # you should raise this error or subclass in engine class.
    class Error < ::Exception; end
  end
  
  # override OpenURI.open with Cache.
  class << self
    alias open_without_cache open

    def open(uri, *rest, &block)
      if Cache.enabled
        begin
          res = Cache.get(uri.to_s)
        rescue
          res = nil
        end
      else
        return open_without_cache(uri, *rest, &block)
      end

      unless res
        res = open_without_cache(uri, *rest, &block).read
        Cache.set(uri.to_s, res)
      end

      return StringIO.new(res)
    end
  end
end