jruby-ehcache-rails3 1.2.0 → 1.3.0

data/lib/ehcache/yaml_config.rb

@@ -0,0 +1,251 @@
+require 'java'
+require 'ehcache'
+require 'yaml'
+require 'erb'
+
+module Ehcache::Config
+  # Support for using YAML for Ehcache configuration.
+  #
+  # <strong>DEPRECATED:</strong> Please use ehcache.xml instead.
+  #
+  # YAML configuration is similar to XML configuration, but there are some
+  # changes to the names of configuration elements to make them simpler or
+  # more idiomatic to Ruby and YAML conventions.  The changes are described
+  # below.  For full documentation on the Ehcache configuration elements,
+  # see the Ehcache Cache Configuration documentation:
+  # http://ehcache.org/documentation/configuration.html
+  #
+  # The top level YAML configuration attributes and the corresponding XML
+  # elements or attributes are shown in the following table.
+  #
+  # name:: name attribute on ehcache element
+  # update_check:: updateCheck attribute on ehcache element
+  # monitoring:: monitoring attribute on ehcache element
+  # dynamic_config:: dynamicConfig attribute on ehcache element
+  # disk_store:: diskStore element
+  # transaction_manager:: transactionManagerLookup element
+  # event_listener:: cacheManagerEventListenerFactory element
+  # peer_providers (Array):: cacheManagerPeerProviderFactory elements
+  # peer_listeners (Array):: cacheManagerPeerListenerFactory elements
+  # terracotta_config:: terracottaConfig element
+  # default_cache:: defaultCache element
+  # caches (Array):: cache elements
+  #
+  # Each top level configuration attribute contains a set of key/value pairs
+  # that are equivalent to the Ehcache XML attributes, except that the
+  # attribute names are converted to use underscore_names instead of
+  # camelCaseNames.  For instance, the Ehcache XML attribute
+  # diskSpoolBufferSizeMB becomes disk_spool_buffer_size_mb in YAML.
+  #
+  # Entries in the above table that are marked as (Array) should be YAML lists
+  # to allow for multiple values.  So, for example, to configure multiple
+  # caches in your YAML configuration, use the following syntax:
+  #
+  #   caches:
+  #     - name: my_cache
+  #       time_to_idle_seconds: 360
+  #       time_to_live_seconds: 1000
+  #     - name: my_other_cache
+  #       max_elements_in_memory: 1000
+  #       eternal: true
+  #       overflow_to_disk: false
+  #       disk_persistent: true
+  #
+  # Note the use of the '-' to separate list elements.
+  #
+  # One further difference between YAML configuration and XML configuration
+  # deals with cache configuration.  The XML configuration allows for a set
+  # of XML sub elements to configure various aspects of caches (or the default
+  # cache).  In YAML, these sub elements are translated to attributes within
+  # the cache configuration (or default_cache configuration) that
+  # refer to Hashes or Arrays.  The following table shows the mapping.
+  #
+  # event_listeners (Array):: cacheEventListenerFactory sub elements
+  # extensions (Array):: cacheExtensionFactory sub elements
+  # loaders (Array):: cacheLoaderFactory sub elements
+  # decorators (Array):: cacheDecoratorFactory sub elements
+  # bootstrap_loader (Hash):: bootstrapCacheLoaderFactory sub element
+  # exception_handler (Hash):: cacheExceptionHandlerFactory sub element
+  # terracotta (Hash):: terracotta sub element
+  # cache_writer (Hash):: cacheWriter sub element
+  # copy_strategy (Hash):: copyStrategy sub element
+  #
+  # Those marked as (Array) may take a list of values, while those marked as
+  # (Hash) may take a single Hash value (set of key/value pairs).  Here is an
+  # example of a cache configuration that uses one of each style:
+  #
+  #   caches:
+  #     - name: some_cache
+  #       time_to_live_seconds: 100
+  #       event_listeners:
+  #         - class: net.sf.ehcache.distribution.RMICacheReplicatorFactory
+  #           properties: "replicateAsynchronously=false"
+  #       copy_strategy:
+  #         class: net.sf.ehcache.store.compound.SerializationCopyStrategy
+  #
+  # Note again the use of the '-' character to separate list elements in the
+  # case of Array values, which is not present for Hash values.
+  module YamlConfig
+
+    InvalidYamlConfiguration = Class.new(StandardError)
+
+    # Not sure why, but "include Java::NetSfEhcacheConfig" does not work,
+    # so define local constants referring to the Ehcache classes
+    Configuration = Java::NetSfEhcacheConfig::Configuration
+    CacheConfiguration = Java::NetSfEhcacheConfig::CacheConfiguration
+    DiskStoreConfiguration = Java::NetSfEhcacheConfig::DiskStoreConfiguration
+    FactoryConfiguration = Java::NetSfEhcacheConfig::FactoryConfiguration
+
+    %w[name update_check monitoring dynamic_config
+       disk_store transaction_manager event_listener
+       peer_providers peer_listeners
+       terracotta_config default_cache caches
+       event_listeners extensions loaders decorators
+    ].each do |attribute|
+      const_set(attribute.upcase.to_sym, attribute)
+    end
+
+    # Parses the given yaml_config_file and returns a corresponding
+    # Ehcache::Config::Configuration object.
+    def self.parse_yaml_config(yaml_config_file)
+      Ehcache::LOG.warn("YAML configuration is deprecated.  Please use ehcache.xml instead.")
+      YamlConfigBuilder.new(yaml_config_file).build
+    end
+
+    private
+
+    class YamlConfigBuilder
+
+      def initialize(yaml_file)
+        @yaml_file = yaml_file
+        @data = YAML.load(ERB.new(File.read(yaml_file)).result(binding))
+        raise InvalidYamlConfiguration unless valid?(@data)
+      end
+
+      def build
+        @config = Configuration.new
+        for attribute in [NAME, UPDATE_CHECK, MONITORING, DYNAMIC_CONFIG]
+          set_if_present(attribute)
+        end
+        set_disk_store
+        set_transaction_manager
+        set_event_listener
+        add_peer_providers
+        add_peer_listeners
+        set_default_cache
+        add_caches
+        @config
+      end
+
+      private
+
+      def valid?(data)
+        data.is_a?(Hash)
+      end
+
+      def set_if_present(key)
+        if @data.has_key?(key)
+          setter = "#{key}=".to_sym
+          @config.send(setter, @data[key])
+        end
+      end
+
+      def set_attributes(object, attributes)
+        attributes ||= []
+        attributes.each do |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            create_cache_config_factories(object, key, value)
+          else
+            object.send("#{key}=", value)
+          end
+        end
+        object
+      end
+
+      def create_cache_config_factories(cache, key, value)
+        [value].flatten.each do |data|
+          create_cache_config_factory(cache, key, data)
+        end
+      end
+
+      def names_for_factory(key)
+        singular = key.singularize.sub(/s$/, '')
+        factory_name = if key == 'bootstrap_loader'
+          "BootstrapCacheLoaderFactory"
+        else
+          "Cache#{singular.camelize}Factory"
+        end
+        class_name = "#{factory_name}Configuration"
+        method_name = "add#{factory_name}"
+        return [class_name, method_name]
+      end
+
+      def create_cache_config_factory(cache, key, data)
+        class_name, method_name = names_for_factory(key)
+        factory_class = CacheConfiguration.const_get(class_name)
+        factory = factory_class.new
+
+        cache.send(method_name, factory)
+        set_attributes(factory, data)
+      end
+
+      def apply_config(key, config_class)
+        if @data[key]
+          [@data[key]].flatten.each do |data|
+            config = config_class.new
+            set_attributes(config, data)
+            yield config
+          end
+        end
+      end
+
+      def set_disk_store
+        apply_config(DISK_STORE, DiskStoreConfiguration) do |disk_store|
+          @config.add_disk_store(disk_store)
+        end
+      end
+
+      def set_transaction_manager
+        apply_config(TRANSACTION_MANAGER, FactoryConfiguration) do |tx_mgr|
+          @config.add_transaction_manager_lookup(tx_mgr)
+        end
+      end
+
+      def set_event_listener
+        apply_config(EVENT_LISTENER, FactoryConfiguration) do |event_listener|
+          @config.addCacheManagerEventListenerFactory(event_listener)
+        end
+      end
+
+      def add_peer_providers
+        apply_config(PEER_PROVIDERS, FactoryConfiguration) do |peer_provider|
+          @config.addCacheManagerPeerProviderFactory(peer_provider)
+        end
+      end
+
+      def add_peer_listeners
+        apply_config(PEER_LISTENERS, FactoryConfiguration) do |peer_listener|
+          @config.addCacheManagerPeerListenerFactory(peer_listener)
+        end
+      end
+
+      def set_default_cache
+        apply_config(DEFAULT_CACHE, CacheConfiguration) do |cache_config|
+          @config.default_cache_configuration = cache_config
+        end
+      end
+
+      def add_caches
+        apply_config(CACHES, CacheConfiguration) do |cache_config|
+          @config.add_cache(cache_config)
+        end
+      end
+
+      def create_factory_configuration(data)
+        result = FactoryConfiguration.new
+        set_attributes(result, data)
+        result
+      end
+    end
+  end
+end

data/lib/ehcache.rb

@@ -0,0 +1,22 @@
+unless $:.include?(File.dirname(__FILE__)) ||
+       $:.include?(File.expand_path(File.dirname(__FILE__)))
+  $:.unshift(File.dirname(__FILE__))
+end
+
+require 'java'
+
+module Ehcache
+  unless defined?(EHCACHE_HOME)
+    EHCACHE_HOME = File.expand_path(File.dirname(__FILE__) + '/..')
+  end
+
+  # wraps all native exceptions
+  class EhcacheError < RuntimeError; end
+end
+
+require 'ehcache/extensions'
+require 'ehcache/java'
+require 'ehcache/config'
+require 'ehcache/cache'
+require 'ehcache/cache_manager'
+require 'ehcache/element'

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/ehcache.rb'}"
+puts "Loading ehcache gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'ehcache' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'ehcache'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = Ehcache::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/spec/cache_manager_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe CacheManager do
+  before(:each) do
+    @manager = Ehcache::CacheManager.new
+  end
+
+  after(:each) do
+    @manager.shutdown
+  end
+  it "should return false if include? is called with a non-existant cache name" do
+    @manager.include?("zomg").should == false
+  end
+
+  it "should return false if exists? is called with a non-existant cache name" do
+    @manager.exists?("zomg").should == false
+  end
+
+  it "should return true if include? is called with an existant cache name" do
+    @manager.include?(Ehcache::Cache::PRIMARY).should == true
+  end
+
+  it "should return true if exists? is called with an existant cache name" do
+    @manager.exists?(Ehcache::Cache::PRIMARY).should == true
+  end
+
+  it "should return all the cache names when caches is called" do
+    @manager.caches.length.should == 1
+  end
+
+  it "should remove the cache when remove is called with a cache name" do
+    @manager.remove(Ehcache::Cache::PRIMARY)
+    @manager.caches.length.should == 0
+  end
+
+  it "should remove all the caches when remove_all is called" do
+    @manager.add_cache("mynewcache")
+    @manager.caches.length.should == 2
+    @manager.remove_all
+    @manager.caches.length.should == 0
+  end
+
+  it "should add a cache when cache is called with a cache name" do
+    @manager.add_cache("mynewcache")
+    @manager.caches.length.should == 2
+  end
+
+  it "should add a cache when cache is called with a cache name" do
+    cache = @manager.cache(Ehcache::Cache::PRIMARY)
+    cache.put("key", "value")
+    cache.get("key").should == "value"
+    @manager.flush_all
+    cache.get("key").should == nil
+  end
+end
+
+describe CacheManager, "customized" do
+  after(:each) do
+    @manager.shutdown
+  end
+
+  it "should create a primary cache with values based on default cache" do
+    @manager = Ehcache::CacheManager.new
+    @manager.cache.max_elements.should == 10000
+  end
+
+  it "should create a cache with cache named steve" do
+    @manager = Ehcache::CacheManager.new({"cache" => {"name" => "steve"}})
+    @manager.include?("steve").should == true
+  end
+
+  it "should create a custom default and primary cache" do
+    @manager = Ehcache::CacheManager.new({
+      "default" => {"max_elements_in_memory" => 200000},
+      "cache"   => {"name" => "cache", "time_to_live_seconds" => 180, "eternal" => true}
+    })
+    @manager.cache("cache").max_elements.should == 200000
+    @manager.cache("cache").ttl.should == 180
+    @manager.cache("cache").eternal?.should == true
+  end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Cache do
+  before(:each) do
+    @manager = Ehcache::CacheManager.new
+    @cache   = @manager.cache
+  end
+
+  after(:each) do
+    @manager.shutdown
+  end
+
+  it "should have an alive status on creation" do
+    @cache.status.should == Ehcache::Status::ALIVE
+  end
+
+  it "should have a shutdown status when its manager shutsdown" do
+    @manager.shutdown
+    @cache.status.should == Ehcache::Status::SHUTDOWN
+  end
+
+  it "should return an element value from get when given a valid key" do
+    @cache.put("lol", "123456")
+    @cache.get("lol").should == "123456"
+  end
+
+  it "should return true when removing an element from the cache given a valid key" do
+    @cache.put("lol", "123456")
+    @cache.remove("lol").should == true
+  end
+
+  it "should return false when removing an element from the cache given a valid key" do
+    @cache.put("lol", "123456")
+    @cache.remove("rofl").should == false
+  end
+
+  it "should remove all elements from the cache on a call to remove_all" do
+    @cache.put("lol", "123456")
+    @cache.put("rofl", "123456")
+    @cache.remove_all
+    @cache.size.should == 0
+  end
+
+  it "should return true when exist? is called when a valid key is in the cache" do
+    @cache.put("lol", "123456")
+    @cache.exist?("lol").should == true
+  end
+
+  it "should return false when exist? is called when a valid key is in the cache" do
+    @cache.put("lol", "123456")
+    @cache.exist?("rofl").should == false
+  end
+
+  it "should raise an EhcacheArgumentException when given an empty key" do
+    lambda { @cache.put("", "123456") }.should raise_error(EhcacheError)
+  end
+
+  it "should raise an EhcacheArgumentException when given nil key" do
+    lambda { @cache.put(nil, "123456") }.should raise_error(EhcacheError)
+  end
+
+  it "should allow adding an element to the cache with a time to live" do
+    @cache.put("lol", "123456", { :ttl => 60 })
+    @cache.element("lol").ttl.should == 60
+  end
+
+  it "should return an element from a call to element when given a valid key" do
+    @cache.put("lol", "123456")
+    @cache.element("lol").class.should == Ehcache::Element
+  end
+
+  it "should return the number of elements in the cache" do
+    @cache.size.should == 0
+    @cache.put("lol", "123456")
+    @cache.size.should == 1
+  end
+
+  it "should return all the keys in the cache" do
+    @cache.put("lol", "123456")
+    @cache.put("rofl", "123456")
+    @cache.keys.size.should == 2
+  end
+
+  it "should return the number of elements in the memory store"
+  it "should return the number of elements in the disk store"
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format=specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'spec'
+require 'spec/story'
+require 'java'
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib ehcache]))
+include Ehcache
+include Ehcache::Java
+
+Spec::Runner.configure do |config|
+  #config.mock_with :mocha
+end

data/src/net/sf/ehcache/MarshaledRubyObject.java

@@ -0,0 +1,15 @@
+package net.sf.ehcache;
+
+import java.io.Serializable;
+
+public class MarshaledRubyObject implements Serializable {
+  private byte[] bytes;
+
+  public MarshaledRubyObject(byte[] bytes) {
+    this.bytes = bytes;
+  }
+
+  public byte[] getBytes() {
+    return this.bytes;
+  }
+}

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/website.rake

@@ -0,0 +1,17 @@
+desc 'Generate website files'
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]