remix-stash 0.9.0 → 0.9.6

data/lib/remix/stash.rb

@@ -0,0 +1,256 @@
+module Remix; end
+
+class Remix::Stash
+  require 'remix/stash/extension'
+  require 'remix/stash/cluster'
+  require 'remix/stash/protocol'
+
+  attr_accessor :name
+
+  @@instances = {}
+  @@clusters = {:default => Cluster.new(%w[localhost:11211])}
+
+  def self.cluster(name)
+    @@clusters[name]
+  end
+
+  def self.cycle_action
+    @@instances.each {|name, stash|
+      stash.cycle if stash.default[:coherency] == :action}
+  end
+
+  def self.define_cluster(clusters)
+    clusters.each do |k,v|
+      @@clusters[k] = Cluster === v ? v : Cluster.new(v)
+    end
+  end
+
+  def self.new(name)
+    @@instances[name] ||= super
+  end
+
+  def initialize(name)
+    @name = name
+    @scope = nil
+    if name == :root
+      @local = @opts = {:coherency => :action, :ttl => 0, :cluster => :default}
+    else
+      @local = {}
+      @opts = stash.default.dup
+    end
+  end
+
+  def add(*keys)
+    opts = default_opts(keys)
+    value = keys.pop
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.add(io, key, value, opts[:ttl])}
+  end
+
+  def clear(*keys)
+    opts = default_opts(keys)
+    if keys.empty?
+      if @name == :root
+        cluster(opts).each {|io| Protocol.flush(io)}
+      else
+        vk = vector_key
+        cluster(opts).select(vk) {|io|
+          unless Protocol.incr(io, vk, 1)
+            Protocol.add(io, vk, '0')
+            Protocol.incr(io, vk, 1)
+          end
+        }
+      end
+      cycle
+    else
+      # remove a specific key
+      key = canonical_key(keys, opts)
+      cluster(opts).select(key) {|io| Protocol.delete(io, key)}
+    end
+  end
+
+  def clear_scope
+    @scope = nil
+  end
+
+  def cycle
+    @vector = nil
+  end
+
+  def decr(*keys)
+    opts = default_opts(keys)
+    step = keys.pop
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.decr(io, key, step)}
+  end
+
+  def default(opts = nil)
+    if opts
+      if opts.has_key? :coherency
+        [:dynamic, :action, :transaction].include?(opts[:coherency]) or raise ArgumentError,
+          "Invalid coherency setting used (#{opts[:coherency].inspect})"
+      end
+      @local.merge!(opts)
+      @opts.merge!(opts)
+      if @name == :root
+        @@instances.each do |name, stash|
+          stash.update_options unless name == :root
+        end
+      end
+    end
+    @opts
+  end
+
+  def delete(*keys)
+    opts = default_opts(keys)
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.delete(io, key)}
+  end
+
+  def eval(*keys)
+    opts = default_opts(keys)
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io|
+      value = Protocol.get(io, key)
+      if value
+        Marshal.load(value)
+      else
+        value = yield(*keys)
+        Protocol.set(io, key, dump_value(value), opts[:ttl])
+        value
+      end
+    }
+  end
+
+  def gate(*keys)
+    opts = default_opts(keys)
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io|
+      if Protocol.get(io, key)
+        yield(*keys)
+        true
+      else
+        false
+      end
+    }
+  end
+
+  def get(*keys)
+    opts = default_opts(keys)
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| load_value(Protocol.get(io, key))}
+  end
+  alias [] get
+
+  def incr(*keys)
+    opts = default_opts(keys)
+    step = keys.pop
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.incr(io, key, step)}
+  end
+
+  def read(*keys)
+    opts = default_opts(keys)
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.get(io, key)}
+  end
+
+  def release
+    @@instances.delete(@name)
+  end
+
+  def scope(&b)
+    @scope = b
+    self
+  end
+
+  def set(*keys)
+    opts = default_opts(keys)
+    value = keys.pop
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.set(io, key, dump_value(value), opts[:ttl])}
+  end
+  alias []= set
+
+  def transaction
+    yield self
+  ensure
+    cycle
+  end
+
+  def write(*keys)
+    opts = default_opts(keys)
+    value = keys.pop
+    key = canonical_key(keys, opts)
+    cluster(opts).select(key) {|io| Protocol.set(io, key, value, opts[:ttl])}
+  end
+
+protected
+
+  def update_options
+    @opts = stash.default.merge(@local)
+  end
+
+private
+
+  KEY_SEPARATOR = '/'
+  def canonical_key(keys, opts)
+    v = vector(opts)
+    if @scope
+      "#{implicit_scope}#{keys.join(KEY_SEPARATOR)}#{vector(opts)}"
+    elsif v
+      keys.join(KEY_SEPARATOR) << v
+    else
+      keys.join(KEY_SEPARATOR)
+    end
+  end
+
+  def cluster(opts = {})
+    @@clusters[opts[:cluster]]
+  end
+
+  def default_opts(params)
+    params.last.is_a?(Hash) ? default.merge(params.pop) : default
+  end
+
+  def dump_value(value)
+    Marshal.dump(value)
+  end
+
+  def implicit_scope
+    @scope.call(self) if @scope
+  end
+
+  def load_value(data)
+    Marshal.load(data) if data
+  rescue TypeError, ArgumentError
+    logger = default_opts[:logger]
+    logger && logger.error("[stash] Unable to load marshal stream: #{data.inspect}")
+    nil
+  end
+
+  def vector(opts)
+    return if @name == :root
+    return @vector if @vector && opts[:coherency] != :dynamic
+    vk = vector_key
+    cluster(opts).select(vk) do |io|
+      @vector = Protocol.get(io, vk)
+      unless @vector
+        Protocol.add(io, vk, '0')
+        @vector = Protocol.get(io, vk)
+      end
+      @vector = "@#@name:#@vector"
+    end
+  end
+
+  def vector_key
+    "#@name#{implicit_scope}_vector"
+  end
+
+  class ProtocolError < RuntimeError; end
+  class ClusterError < RuntimeError; end
+
+end
+
+class Object; include Remix::Stash::Extension end
+module Remix; extend Remix::Stash::Extension end

data/remix-stash.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remix-stash}
+  s.version = "0.9.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Mitchell"]
+  s.date = %q{2009-09-22}
+  s.email = %q{binary42@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "benchmarks/get_set.rb",
+     "benchmarks/payload.rb",
+     "examples/eval.rb",
+     "examples/gate.rb",
+     "examples/getset.rb",
+     "examples/scope.rb",
+     "examples/stash.rb",
+     "harness.rb",
+     "lib/remix/stash.rb",
+     "lib/remix/stash/cluster.rb",
+     "lib/remix/stash/extension.rb",
+     "lib/remix/stash/protocol.rb",
+     "remix-stash.gemspec",
+     "spec/extension_spec.rb",
+     "spec/spec.rb",
+     "spec/stash_spec.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/binary42/remix-stash}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Remix your memcache}
+  s.test_files = [
+    "spec/extension_spec.rb",
+     "spec/spec.rb",
+     "spec/stash_spec.rb",
+     "examples/eval.rb",
+     "examples/gate.rb",
+     "examples/getset.rb",
+     "examples/scope.rb",
+     "examples/stash.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/extension_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/spec'
+
+class ExtensionSpec < Spec
+
+  context '#stash' do
+
+    should 'return a stash object with the correct name' do
+      s = stash(:a)
+      assert_instance_of Stash, s
+      assert_equal :a, s.name
+    end
+
+    should 'return the same object when given the same name' do
+      assert_equal stash(:b), stash(:b)
+      assert_not_equal stash(:a), stash(:b)
+    end
+
+    should 'allow access to a default root stash' do
+      assert_equal stash, stash(:root)
+      assert_equal :root, stash.name
+    end
+
+  end
+
+  context 'modules' do
+
+    should 'be mixed into Object' do
+      assert Object.respond_to?(:stash)
+    end
+
+    should 'be mixed into Remix' do
+      assert Remix.respond_to?(:stash)
+    end
+
+  end
+
+end

data/spec/spec.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+require 'remix/stash'
+
+Spec = Test::Unit::TestCase
+
+include Remix