dcache 0.0.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/.yardopts

@@ -0,0 +1,12 @@
+--protected
+--private
+--title
+DCache documentation
+--load
+yard/reader
+--main
+README.rdoc
+lib/**/*.rb
+ext/**/*.c
+-
+History.rdoc

data/History.rdoc

@@ -0,0 +1,3 @@
+=== 0.0.0 / 2009-12-29
+
+* First public release.

data/Manifest.txt

@@ -0,0 +1,13 @@
+.autotest
+.yardopts
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+ext/dcache_ary/dcache_ary.c
+ext/dcache_ary/extconf.rb
+ext/dcache_list/dcache_list.c
+ext/dcache_list/extconf.rb
+lib/dcache.rb
+spec/dcache_spec.rb
+yard/reader.rb

data/README.rdoc

@@ -0,0 +1,109 @@
+= DCache
+
+* http://github.com/DirtYiCE/DCache
+* Documentation (git): http://yardoc.org/docs/DirtYiCE-DCache/file:README.rdoc
+* Documentation (release): http://dirty-ice.web44.net/doc/dcache
+
+== DESCRIPTION:
+
+A simple caching gem.
+
+== FEATURES:
+
+* Two different backends
+* Cached entries can have a timeout
+* Cache structures are either allocated at once (+:ary+ backend) or grow/shrink
+  dynamically (+:list+ backend)
+* Backends are written in C for speed
+
+== PROBLEMS:
+
+* Should use #hash for faster comparisions.
+
+== SYNOPSIS:
+
+Initialize a cache using +:ary+ backend, and storing 1000 values
+  require "dcache"
+  c = DCache.new :ary, 1000
+Put some value into it:
+  c.add :key, "value"
+  c.add :key2, 34
+  c.add [1, 2, 3], [4, 5, 6]         # key/value can be any ruby type
+  c.add :timeout, "of course", 60    # will be purged after 1 minute
+Retrieve values:
+  c.get :key                         # => "value"
+  c.get :not_stored                  # => nil
+  c.get :not_stored, "default value" # => "default_value"
+  c.get(:not_stored) { puts "Ouch" } # will print "Ouch"
+  c.get_or_add :foo, 3               # => 3
+  c.get :foo                         # => 3
+  c.get_or_raise :not_stored         # will raise ArgumentError
+  c.get :timeout                     # => "of course"
+  sleep 60
+  c.get :timeout                     # => nil
+Remove an element:
+  c.delete :key
+  c.get :key                         # => nil
+  c.get :key2                        # => 34
+Clear cache:
+  c.clear
+  c.get :key2                        # => nil
+Get statistics:
+  [c.hits, c.misses]                 # => [4, 8]
+  # also [c.stored, c.removed] with :list backend
+
+
+== REQUIREMENTS:
+
+* Ruby 1.9 (may work with 1.8)
+* Development dependencies:
+  * Hoe-2.4
+  * hoe-git-1.3.0
+  * RSpec-1.2
+  * yard (git version) (to generate docs)
+
+== INSTALL:
+
+Intall the latest release:
+  $ sudo gem install dcache
+
+Or check out the git repository from Github, then run:
+  $ rake install_gem
+This will install it into the system, so you'll need the root
+password. Alternatively you can run
+  $ rake gem
+which will build a gem, and put it into pkg/.
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Kővágó, Zoltán
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,77 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+require 'rubygems'
+require 'hoe'
+
+SOEXT = Config::CONFIG['DLEXT']
+EXTS = [:ary, :list]
+EXT_FILES = EXTS.map do |i|
+  "lib/dcache_#{i}.#{SOEXT}"
+end
+
+Hoe.plugin :git
+Hoe.spec 'dcache' do
+  developer("Kővágó, Zoltán", "DirtY.iCE.hu@gmail.com")
+
+  self.readme_file = 'README.rdoc'
+  self.history_file = 'History.rdoc'
+  self.post_install_message = "** Please build documentation with `yard'"
+
+  spec_extras[:extensions] = EXTS.map do |i|
+    "ext/dcache_#{i}/extconf.rb"
+  end
+
+  extra_dev_deps << ['rspec', '>=1.2']
+  extra_dev_deps << ['hoe-git', '>=1.3.0']
+  extra_dev_deps << ['yard', '>=0.5'] # for documentation
+
+  clean_globs << '.yardoc'
+  # clean globs for native extensions
+  clean_globs << EXT_FILES
+  EXTS.each do |i|
+    clean_globs << "ext/dcache_#{i}/Makefile"
+    clean_globs << "ext/dcache_#{i}/dcache_#{i}.o"
+    clean_globs << "ext/dcache_#{i}/dcache_#{i}.#{SOEXT}"
+    clean_globs << "lib/dcache_#{i}.#{SOEXT}"
+  end
+  clean_globs.flatten!
+
+  self.rspec_options = [ '--color' ]
+end
+
+# Workaround !
+file 'History.txt' => 'History.rdoc'
+file 'README.txt' => 'README.rdoc'
+
+# Native extension
+task :spec => EXT_FILES
+desc "Builds native extensions"
+task :build => EXT_FILES
+
+EXTS.each do |e|
+  files = [ "ext/dcache_#{e}/extconf.rb", "ext/dcache_#{e}/dcache_#{e}.c" ]
+  tfile = "lib/dcache_#{e}.#{SOEXT}"
+
+  file tfile => files do
+    Dir.chdir "ext/dcache_#{e}" do
+      ruby 'extconf.rb'
+      sh 'make'
+    end
+    FileUtils.copy "ext/dcache_#{e}/dcache_#{e}.#{SOEXT}", tfile
+  end
+end
+
+# YARD documentation
+Rake.application.instance_variable_get('@tasks').delete("docs")
+begin
+  require 'yard'
+
+  task :docs => :yard
+  YARD::Rake::YardocTask.new do |t|
+    # options and files read from '.yardopts'
+  end
+rescue LoadError
+  puts "** Install `yard' to generate docs."
+end
+
+# vim: syntax=ruby

data/ext/dcache_ary/dcache_ary.c

@@ -0,0 +1,276 @@
+#include <ruby.h>
+#include <time.h>
+
+static ID CMP;
+
+typedef struct
+{
+	VALUE key;
+	VALUE value;
+	time_t time;
+} SubStruct;
+
+typedef struct
+{
+	unsigned int head;
+	unsigned int items;
+	unsigned long long int hits;
+	unsigned long long int misses;
+	SubStruct s[];
+} Struct;
+
+/**
+ * Mark elements in cache for Ruby's GC.
+ * @param[in] s struct associated with self.
+ */
+static void struct_mark(Struct * s)
+{
+	time_t tim = time(NULL);
+	int i;
+
+	for(i = 0; i < s->items; ++i)
+	{
+		SubStruct * it = &(s->s[i]);
+
+		if (it->time > tim || it->time == 0)
+		{
+			rb_gc_mark(it->key);
+			rb_gc_mark(it->value);
+		}
+	}
+}
+
+/**
+ * Gets the associated structure.
+ * @param[in] self self
+ * @param[out] var name of the variable that'll contain the pointer to the
+ *   structure.
+ */
+#define GET_STRUCT(self, var)					\
+	Struct * var;								\
+	Data_Get_Struct(self, Struct, var);
+
+/*
+ * @return [Number] maximum number of items cache can store.
+ */
+static VALUE method_get_max_items(VALUE self)
+{
+	GET_STRUCT(self, s);
+	return INT2NUM(s->items);
+}
+
+/*
+ * @return [Number] number of cache hits.
+ */
+static VALUE method_get_hits(VALUE self)
+{
+	GET_STRUCT(self, s);
+	return INT2NUM(s->hits);
+}
+
+/*
+ * @return [Number] number of cache misses.
+ */
+static VALUE method_get_misses(VALUE self)
+{
+	GET_STRUCT(self, s);
+	return INT2NUM(s->misses);
+}
+
+/*
+ * @return [Number] number of currently cached items.
+ */
+static VALUE method_get_stored_items(VALUE self)
+{
+	GET_STRUCT(self, s);
+	time_t tim = time(NULL);
+	int cnt = 0;
+
+	int i;
+	for (i = 0; i < s->items; ++i)
+		if(s->s[i].time > tim || s->s[i].time == 0)
+			++cnt;
+
+	return INT2NUM(cnt);
+}
+
+/* @overload add(key, value, timeout)
+ *  Add a new value to cache.
+ *  @param [#eql?] key an unique identifier (in the cache)
+ *  @param value the value
+ *  @param [Number, nil] timeout time in seconds after the value will be purged
+ *    from cache. +nil+ if there's no such limit.
+ *  @return *value*
+ */
+static VALUE method_add(VALUE self, VALUE key, VALUE val, VALUE timeout)
+{
+	GET_STRUCT(self, s);
+	if (++s->head >= s->items)
+		s->head = 0;
+
+	SubStruct * it = &(s->s[s->head]);
+	it->key = key;
+	it->value = val;
+	if (timeout == Qnil)
+		it->time = 0;
+	else
+		it->time = time(NULL) + NUM2INT(timeout);
+
+	return val;
+}
+
+/**
+ * Decreases the item pointer, wrapping around the start if needed.
+ * @param[in,out] n pointer to the current pointer, will be changed directly.
+ * @param[in] cnt size of the cache
+ */
+static void dec(int * n, int cnt)
+{
+	--(*n);
+	if (*n < 0) *n = cnt - 1;
+}
+
+/*
+ * Tries to get a value from the cache.
+ * @overload get(key, default = nil)
+ *   Tries to get a value from cache. If it fails, returns a default value.
+ *   @param [#eql?] key the key of the value to get
+ *   @param default default return value.
+ *   @return the value from cache if found, *default* otherwise
+ * @overload get(key)
+ *   Tries to get a value from cache. If it fails, executes the block.
+ *   @param [#eql?] key the key of the value to get
+ *   @yield if key is not found.
+ *   @return the value from cache if found, or yielded block's return value.
+ */
+static VALUE method_get(int argc, VALUE * argv, VALUE self)
+{
+	GET_STRUCT(self, s);
+	VALUE key, default_val;
+	rb_scan_args(argc, argv, "11", &key, &default_val);
+
+	time_t tim = time(NULL);
+	int end = s->head + 1;
+	if (end >= s->items) end = 0;
+
+	int i;
+	for (i = s->head; i != end; dec(&i, s->items))
+	{
+		SubStruct * it = &(s->s[i]);
+		if (it->time <= tim && it->time != 0) continue;
+		if (rb_funcall(it->key, CMP, 1, key) == Qtrue)
+		{
+			++s->hits;
+			return it->value;
+		}
+	}
+
+	++s->misses;
+	if (rb_block_given_p())
+	{
+		return rb_yield(Qnil);
+	}
+
+	return default_val;
+}
+
+/*
+ * Removes a given key or keys from the cache.
+ * @overload remove(key)
+ *   @param key remove this key from the cache
+ * @overload remove() { |key, value| ... }
+ *   @yield [key, value] for each item in the cache,
+ *   @yieldparam key key of the current item.
+ *   @yieldparam value value associated with the *key*.
+ *   @yieldreturn [Boolean] +true+ if you want to delete this item
+ * @return [nil]
+ */
+static VALUE mehod_remove(int argc, VALUE * argv, VALUE self)
+{
+	GET_STRUCT(self, s);
+	VALUE todel;
+	rb_scan_args(argc, argv, "01", &todel);
+	time_t tim = time(NULL);
+
+	int has_block = rb_block_given_p();
+
+	int i;
+	for (i = 0; i < s->items; ++i)
+	{
+		SubStruct * it = &(s->s[i]);
+		if (it->time > tim || it->time == 0)
+		{
+			VALUE to_del;
+			if (has_block)
+			{
+				VALUE ary = rb_ary_new3(2, it->key, it->value);
+				to_del = rb_yield(ary);
+			}
+			else
+				to_del = rb_funcall(it->key, CMP, 1, todel);
+
+			if (to_del != Qfalse && to_del != Qnil)
+				it->time = 1;
+		}
+	}
+
+	return Qnil;
+}
+
+/*
+ * Clears the cache.
+ * @return [nil]
+ */
+static VALUE method_clear(VALUE self)
+{
+	GET_STRUCT(self, s);
+
+	int i;
+	for (i = 0; i < s->items; ++i)
+		s->s[i].time = 1;
+
+	return Qnil;
+}
+
+/* @overload new(max_items)
+ *  Creates a new array-based DCache backend with fixed size.
+ *  @param [Number] max_items number of cache items this cache can store.
+ *  @return [DCacheAry] the new object.
+ */
+static VALUE method_new(VALUE class, VALUE max_items)
+{
+	Struct * s;
+	int items = NUM2INT(max_items);
+	if (items < 1)
+		rb_raise(rb_eArgError, "max_items is %d, it should >= 1", items);
+
+	s = ruby_xmalloc(sizeof(Struct) + items * sizeof(SubStruct));
+	s->head = 0;
+	s->items = items;
+	s->hits = s->misses = 0;
+
+	int i;
+	for (i = 0; i < items; ++i)
+		s->s[i].time = 1;
+
+	VALUE x = Data_Wrap_Struct(class, struct_mark, free, s);
+	rb_obj_call_init(x, 0, NULL);
+
+	return x;
+}
+
+void Init_dcache_ary()
+{
+	CMP = rb_intern("eql?");
+	VALUE dcache = rb_define_class("DCacheAry", rb_cObject);
+	rb_define_singleton_method(dcache, "new", method_new, 1);
+	rb_define_method(dcache, "add", method_add, 3);
+	rb_define_method(dcache, "get", method_get, -1);
+	rb_define_method(dcache, "remove", mehod_remove, -1);
+	rb_define_method(dcache, "clear", method_clear, 0);
+
+	rb_define_method(dcache, "hits", method_get_hits, 0);
+	rb_define_method(dcache, "misses", method_get_misses, 0);
+	rb_define_method(dcache, "max_items", method_get_max_items, 0);
+	rb_define_method(dcache, "length", method_get_stored_items, 0);
+}

data/ext/dcache_ary/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+
+dir_config "dcache_ary"
+create_makefile "dcache_ary"