active_store 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use jruby-1.6.5@active_store --create

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_store.gemspec
+gem 'activesupport', '3.0.11'
+
+platforms :jruby do
+  gem 'json-jruby', :require => 'json'
+end
+
+gemspec

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+# Get your spec rake tasks working in RSpec 2.0
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+
+RUBIES = %w[jruby-1.6.5 1.9.2-p290]
+desc "Run tests with ruby 1.8.7 and 1.9.2"
+task :default do
+  RUBIES.each do |ruby|
+    sh "rvm #{ruby}@active_store rake spec"
+  end
+end

data/active_store.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_store/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_store"
+  s.version     = ActiveStore::VERSION
+  s.authors     = ["Petter Remen", "Jean-Louis Giordano"]
+  s.email       = ["petter@icehouse.se", "jean-louis@icehouse.se"]
+  s.homepage    = ""
+  s.summary     = %q{A active record-like wrapper for memcached protocol}
+  s.description = %q{}
+
+  s.rubyforge_project = "active_store"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_runtime_dependency "dalli", '1.1.3'
+  s.add_runtime_dependency "activesupport"
+end

data/lib/active_store/base.rb

@@ -0,0 +1,188 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveStore
+  class Base
+
+    def initialize(params = {})
+      set_attributes(params)
+      @created_at ||= Time.now
+    end
+
+    def ==(another_object)
+      (self.class.attributes - [:created_at]).all? do |attribute|
+        self.send(attribute) == another_object.send(attribute)
+      end
+    end
+
+    def attributes
+      self.class.attributes.inject(HashWithIndifferentAccess.new) do |accu, attribute|
+        send(attribute).nil? ? accu : accu.merge({attribute => send(attribute)})
+      end
+    end
+
+    def set_attributes(params = {})
+      params = params.with_indifferent_access
+      self.class.attributes.each do |attribute|
+        write_attribute(attribute, params[attribute])
+      end
+    end
+
+    def update_attribute(attribute, value)
+      self.send "#{attribute}=", value
+      save
+    end
+
+    def update_attributes(params)
+      params.each do |key, value|
+        send("#{key}=", value)
+      end
+      save
+    end
+
+    def reload
+      raise NoIdError.new("Could not reload without id.") if (id.nil? || id.empty?)
+      set_attributes(connection.get(id))
+      self
+    end
+
+    def save(ttl = self.class.default_ttl)
+      return false if (id.nil? || id.empty?)
+      connection.set(id, self.attributes, ttl)
+      true
+    end
+
+    def save!(ttl = self.class.default_ttl)
+      save(ttl) or raise NoIdError.new("Could not save without id.")
+    end
+
+    def connection
+      self.class.connection
+    end
+
+    protected
+
+    def write_attribute (attribute, value)
+      instance_variable_set("@#{attribute}", value)
+    end
+
+    def read_attribute (attribute)
+      instance_variable_get("@#{attribute}")
+    end
+
+    class << self
+      attr_reader :attributes
+
+      def define_attributes(*args)
+        @attributes ||= []
+        @attributes += args
+        @attributes |= [:id, :created_at]
+        attr_accessor *@attributes
+      end
+
+      def create(params = {})
+        obj = new(params)
+        obj.save!
+        obj
+      end
+
+      # Allows you to update an ActiveStore object within a
+      # CAS "transaction"
+      #
+      # Example:
+      #   Model.cas_update(3) do |instance|
+      #     instance.value += 5
+      #   end
+      #
+      # Returns nil if the object could not be found.
+      # Returns false if the CAS operation failed due to
+      # the object being modified in the background.
+      def cas_update(id, ttl = default_ttl, &block)
+        block = attributes_block_wrapper(&block)
+        connection.cas(id, ttl, &block)
+      end
+
+      # Like cas_update, but also creates a new object if none could be
+      # found. The given block is guaranteed to be executed at most once.
+      #
+      # Example:
+      #   Model.cas_update_or_create(3) do |instance|
+      #     instance.value ||= 0
+      #     instance.value += 5
+      #   end
+      #
+      # Returns false if the CAS operation failed due to
+      # the object having been modified by another process, or if
+      # someone managed to create an object between the CAS and ADD
+      # operations
+      def cas_update_or_create(id, ttl = default_ttl, &block)
+        res = cas_update(id, ttl, &block)
+        res.nil? ? create_with_block(id, ttl, &block) : res
+      end
+
+      def stm_update_or_create (id, ttl = default_ttl, &block)
+        begin
+          success = cas_update_or_create(id, ttl = default_ttl, &block)
+        end until success
+        true
+      end
+
+      def create_with_block(id, ttl = default_ttl, &block)
+        block = attributes_block_wrapper(&block)
+        connection.add(id, block.call({:id => id}), ttl)
+      end
+
+      def find(id)
+        return nil if (id.nil? || id.empty?)
+        params = connection.get(id)
+        params ? new(params) : nil
+      end
+
+      def find_or_initialize_by_id(id)
+        find(id) || new(:id => id)
+      end
+
+      def connection
+        @connection ||= Connection.new(connection_string, namespace, default_ttl)
+      end
+
+      def connection_string= (connection_string)
+        @connection = nil
+        @connection_string = connection_string
+      end
+
+      def connection_string
+        @connection_string ||= (superclass.connection_string unless self == Base)
+      end
+
+      def namespace= (namespace)
+        @connection = nil
+        @namespace = namespace
+      end
+
+      def namespace
+        @namespace ||= self.name
+      end
+
+      def default_ttl= (default_ttl)
+        @connection = nil
+        @default_ttl = default_ttl
+      end
+
+      def default_ttl
+        @default_ttl ||= 30 * 24 * 3600
+      end
+
+      private
+      def attributes_block_wrapper(&block)
+        lambda do |attrs|
+          instance = new(attrs)
+          block.call(instance)
+          instance.attributes
+        end
+      end
+    end
+
+    class NoIdError < StandardError
+    end
+  end
+end

data/lib/active_store/connection.rb

@@ -0,0 +1,91 @@
+require 'dalli'
+require 'json'
+
+module ActiveStore
+  class Connection
+    attr_accessor :connection_string, :namespace, :default_ttl
+
+    def initialize(connection_string, namespace, default_ttl)
+      @connection_string = connection_string
+      @namespace = namespace
+      @default_ttl = default_ttl
+    end
+
+    class ::Dalli::Client
+      # Monkey patch to avoid having a separate branch
+      def validate_key (key)
+        raise ArgumentError, "key cannot be blank" if key.nil? || key.strip.size == 0
+        raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
+      end
+    end
+
+    attr_writer :store
+
+    def flush_all
+      store.flush_all
+    end
+
+    def incr(*args)
+      store.incr(*args)
+    end
+
+    def delete(*args)
+      store.delete(*args)
+    end
+
+    def get (key)
+      load(get_raw(key))
+    end
+
+    def set (key, value, ttl=default_ttl)
+      set_raw(key, dump(value), ttl)
+    end
+
+    def add (key, value, ttl=default_ttl)
+      add_raw(key, dump(value), ttl)
+    end
+
+    def cas (key, ttl=default_ttl)
+      store.cas(key, ttl, :raw => true) do |value|
+        raw_output = yield load(value)
+        dump(raw_output)
+      end
+    end
+
+    def get_raw(key)
+      store.get(key)
+    end
+
+    def set_raw(key, value, ttl=default_ttl)
+      store.set(key, value, ttl, :raw => true)
+    end
+
+    def add_raw(key, value, ttl=default_ttl)
+      store.add(key, value, ttl, :raw => true)
+    end
+
+    def store
+      unless @store
+        @store = Dalli::Client.new(connection_string, :namespace => namespace, :expires_in => default_ttl, :socket_timeout => 1)
+        begin
+          @store.get('test')
+        rescue Dalli::RingError => e
+          @store = nil
+          raise e
+        end
+      end
+      @store
+    end
+
+    private
+
+    # Ugly tricks to fool parsers that don't allow literals
+    def dump (value)
+      JSON.dump([value])[1...-1]
+    end
+
+    def load (value)
+      JSON.load("[#{value}]").first
+    end
+  end
+end

data/lib/active_store/version.rb

@@ -0,0 +1,3 @@
+module ActiveStore
+  VERSION = "0.0.1"
+end

data/lib/active_store.rb

@@ -0,0 +1,6 @@
+require "active_store/version"
+require "active_store/base"
+require "active_store/connection"
+
+module ActiveStore
+end

data/spec/lib/active_store/base_spec.rb

@@ -0,0 +1,378 @@
+require 'spec_helper'
+
+describe ActiveStore::Base do
+  before do
+    class ItemStore < ActiveStore::Base
+      define_attributes :a1, :a2
+      self.namespace = "item"
+      self.default_ttl = 0
+      self.connection_string = nil
+    end
+  end
+
+  describe ".connection_string" do
+    it "defaults to Base value if nil" do
+      ActiveStore::Base.connection_string = "some_string"
+      ItemStore.connection_string.should == "some_string"
+      ItemStore.connection_string = "some other string"
+      ActiveStore::Base.connection_string.should == "some_string"
+      ItemStore.connection_string.should == "some other string"
+    end
+  end
+  describe ".namespace" do
+    it "forces a new connection" do
+      connection = ItemStore.connection
+      ItemStore.namespace = "item"
+      ItemStore.connection.should_not be_eql connection
+    end
+    it "sends itself as a parameter to Connection.new" do
+      ItemStore.connection.namespace.should == "item"
+      ItemStore.namespace = "foo"
+      ItemStore.connection.namespace.should == "foo"
+    end
+    it "defaults to the name of the class" do
+      ItemStore.namespace = nil
+      ItemStore.namespace.should == 'ItemStore'
+    end
+  end
+
+  describe ".default_ttl" do
+    it "forces a new connection" do
+      connection = ItemStore.connection
+      ItemStore.default_ttl = 2
+      ItemStore.connection.should_not be_eql connection
+    end
+    it "sends itself as a parameter to Connection.new" do
+      ItemStore.connection.default_ttl.should == 0
+      ItemStore.default_ttl = 2
+      ItemStore.connection.default_ttl.should == 2
+    end
+    it "defaults to 30 days" do
+      ItemStore.default_ttl = nil
+      ItemStore.default_ttl.should == 30 * 24 * 3600
+    end
+  end
+
+  it "lists attibute names" do
+    ItemStore.attributes.should include :a1, :a2
+  end
+
+  it "provides accessors for its attributes" do
+    item = ItemStore.new
+    item.a1.should be_nil
+    (item.a1 = "new_value").should == "new_value"
+    item.a1.should == "new_value"
+  end
+
+  describe ".define_attributes" do
+    it "should add id and created_at in attributes" do
+      ItemStore.attributes.should include :id, :created_at
+    end
+    it "should add id and created_at in its instance accessors" do
+      ItemStore.new.methods.map(&:to_sym).should include :id, :id=, :created_at, :created_at=
+    end
+  end
+
+  describe "#initialize" do
+    it "initializes given attributes" do
+      params = { :a1 => "one", :a2 => "two" }
+      item = ItemStore.new params
+      item.attributes[:a1].should == params[:a1]
+      item.attributes[:a2].should == params[:a2]
+    end
+    it "initializes attributes even when the params keys are strings" do
+      params = { "a1" => "one", "a2" => "two" }
+      item = ItemStore.new params
+      item.attributes[:a1].should == params["a1"]
+      item.attributes[:a2].should == params["a2"]
+    end
+    it "doesn't require attributes" do
+      ItemStore.new.a1.should be_nil
+    end
+    it "sets created_at if not given in params" do
+      ItemStore.new.created_at.should be_within(1).of(Time.now)
+    end
+    it "sets created_at if given" do
+      ItemStore.new(:created_at => "some time").created_at.should == "some time"
+    end
+    it "can set attribute to false" do
+      item = ItemStore.new "a1" => false
+      item.attributes[:a1].should == false
+    end
+  end
+
+  describe "#==" do
+    it "returns true if all attributes are the same" do
+      params = { :a1 => "one", :a2 => "two" }
+      (ItemStore.new(params) == ItemStore.new(params)).should be_true
+    end
+    it "returns false any of the attributes are different" do
+      params1 = { :a1 => "one", :a2 => "two"}
+      params2 = { :a1 => "different", :a2 => "two" }
+      (ItemStore.new(params1) == ItemStore.new(params2)).should be_false
+    end
+  end
+
+  describe "#update_attribute" do
+    it "updates given attribute and saves" do
+      item = ItemStore.new :id => "myid"
+      item.update_attribute(:a1, "new_value").should be_true
+      item.reload.a1.should be_true
+    end
+    it "returns false if id is missing" do
+      item = ItemStore.new
+      item.update_attribute(:a1, "new_value").should be_false
+    end
+    it "raises if attribute is missing" do
+      item = ItemStore.new
+      expect { item.update_attribute :apa, true }.to raise_exception(NoMethodError)
+    end
+  end
+
+  describe "#update_attributes" do
+    it "updates all given attributes" do
+      item = ItemStore.new :id => "myid"
+      item.update_attributes(:a1 => "one", :a2 => "two").should == true
+      item.reload
+      item.a1.should == "one"
+      item.a2.should == "two"
+    end
+    it "returns false if id is missing" do
+      item = ItemStore.new
+      item.update_attributes(:a1 => "new_value").should be_false
+    end
+  end
+
+  describe ".cas_update" do
+    context "when the given id does not exist" do
+      it "returns nil" do
+        ItemStore.cas_update("nonexistent").should be_nil
+      end
+      it "should not run the block" do
+        ItemStore.cas_update("nonexistent") do
+          true.should be_false
+        end
+      end
+    end
+    context "when the record has been updated before CAS set operation" do
+      it "returns false" do
+        ItemStore.create :id => "existent", :a1 => "foo"
+        ItemStore.cas_update("existent") do |item|
+          same_item = ItemStore.find("existent")
+          same_item.a1 = "bar"
+          same_item.save
+          item.a1 = "baz"
+        end.should be_false
+      end
+      it "doesn't modify the record" do
+        ItemStore.create :id => "existent", :a1 => "foo"
+        ItemStore.cas_update("existent") do |item|
+          same_item = ItemStore.find("existent")
+          same_item.a1 = "bar"
+          same_item.save
+          item.a1 = "baz"
+        end
+        ItemStore.find("existent").a1.should == "bar"
+      end
+    end
+    context "otherwise" do
+      it "returns true" do
+        ItemStore.create :id => "existent"
+        ItemStore.cas_update("existent") do |item|
+          item.a1 = "baz"
+        end.should be_true
+      end
+      it "updates the record" do
+        ItemStore.create :id => "existent"
+        ItemStore.cas_update("existent") do |item|
+          item.a1 = "baz"
+        end
+        ItemStore.find("existent").a1.should == "baz"
+      end
+    end
+  end
+
+  describe "cas_update_or_create" do
+    it "tries to update the record using cas_update" do
+      proc_mock = Proc.new {}
+      ItemStore.should_receive(:cas_update).with("old", ItemStore.default_ttl, &proc_mock).and_return(true)
+      ItemStore.cas_update_or_create("old", &proc_mock)
+    end
+
+    it "creates the record create_with_block if the CAS operation fails due to missing record" do
+      proc_mock = Proc.new {}
+      ItemStore.stub!(:cas_update).and_return(nil)
+      ItemStore.should_receive(:create_with_block).with("old", ItemStore.default_ttl, &proc_mock)
+      ItemStore.cas_update_or_create("old", &proc_mock)
+    end
+
+    it "returns false if update_cas returns false" do
+      proc_mock = Proc.new {}
+      ItemStore.stub!(:cas_update).and_return(false)
+      ItemStore.cas_update_or_create("foo", &proc_mock).should be_false
+    end
+
+    it "returns false if create_with_block returns false" do
+      proc_mock = Proc.new {}
+      ItemStore.stub!(:cas_update).and_return(nil)
+      ItemStore.stub!(:create_with_block).and_return(false)
+      ItemStore.cas_update_or_create("foo", &proc_mock).should be_false
+    end
+
+    it "returns true if the record was successfully created" do
+      ItemStore.cas_update_or_create("foo") {}.should be_true
+    end
+
+    it "returns true if the record was successfully modified" do
+      ItemStore.create(:id => "foo")
+      ItemStore.cas_update_or_create("foo") {}.should be_true
+    end
+
+  end
+
+  describe "stm_update_or_create" do
+    it "performs a cas_update_or_create" do
+      to_run = Proc.new(){}
+      ItemStore.should_receive(:cas_update_or_create) do |id, &block|
+        id.should == :some_id
+        block.should == to_run
+        true
+      end
+      ItemStore.stm_update_or_create(:some_id, &to_run).should be_true
+    end
+    it "performs a cas_update_or_create until success" do
+      ItemStore.should_receive(:cas_update_or_create).exactly(3).times.and_return(false, false, true)
+      ItemStore.stm_update_or_create(:some_id){}.should be_true
+    end
+  end
+
+  describe "#create_with_block" do
+    it "creates a new record if it doesn't exist" do
+      ItemStore.create_with_block("foo") do |item|
+        item.a1 = "bar"
+      end
+      ItemStore.find("foo").a1.should == "bar"
+    end
+
+    context "if the record already exists" do
+      before do
+        ItemStore.create(:id => "foo", :a1 => "bar")
+      end
+
+      it "returns false" do
+        ItemStore.create_with_block("foo") {}.should be_false
+      end
+
+      it "doesn't update the record" do
+        ItemStore.create_with_block("foo") do |item|
+          item.a1 = "baz"
+        end
+        ItemStore.find("foo").a1.should == "bar"
+      end
+    end
+  end
+
+  describe "#reload" do
+    it "reloads attributes from db" do
+      item = ItemStore.new :id => "myid"
+      ItemStore.connection.set("myid", :a1 => "new value")
+      item.reload
+      item.a1.should == "new value"
+    end
+    it "raises if no id is set" do
+      expect { ItemStore.new.reload }.to raise_exception(ActiveStore::Base::NoIdError)
+    end
+    it "raises if no id is empty string" do
+      expect { ItemStore.new(:id => "").reload }.to raise_exception(ActiveStore::Base::NoIdError)
+    end
+  end
+
+  describe "#save" do
+    it "saves attribute do db" do
+      ItemStore.find("myid").should be_nil
+      item = ItemStore.new :id =>"myid", :a1 => "one", :a2 => "two"
+      item.save.should be_true
+      item.created_at.should_not be_nil
+      ItemStore.find("myid").should == item
+    end
+    it "returns false if id is nil" do
+      item = ItemStore.new :id => nil
+      item.save.should be_false
+    end
+    it "saves with a given ttl" do
+      item = ItemStore.new :id => "myid", :a1 => "one", :a2 => "two"
+      ItemStore.connection.should_receive(:set).with(anything, anything, 2 * 24 * 3600)
+      item.save(2 * 24 * 3600)
+    end
+    it "saves with default ttl if not specified otherwise" do
+      item = ItemStore.new :id => "myid", :a1 => "one", :a2 => "two"
+      ItemStore.connection.should_receive(:set).with(anything, anything, ItemStore.default_ttl)
+      item.save
+    end
+  end
+
+  describe "#save!" do
+    it "calls save" do
+      item = ItemStore.new :id => "myid"
+      item.should_receive(:save).and_return(true)
+      item.save!
+    end
+    it "it returns true on successfull save" do
+      item = ItemStore.new :id => "myid"
+      item.save!.should be_true
+    end
+    it "raises if id is nil" do
+      item = ItemStore.new :id => nil
+      expect { item.save! }.to raise_exception(ActiveStore::Base::NoIdError)
+    end
+    it "saves with a given ttl" do
+      item = ItemStore.new :id => "myid"
+      ItemStore.connection.should_receive(:set).with(anything, anything, 2 * 24 * 3600)
+      item.save!(2 * 24 * 3600)
+    end
+    it "saves with default ttl if not specified otherwise" do
+      item = ItemStore.new :id => "myid"
+      ItemStore.connection.should_receive(:set).with(anything, anything, ItemStore.default_ttl)
+      item.save!
+    end
+  end
+
+  describe ".create" do
+    it "creates an item and saves it" do
+      item = ItemStore.create :id => "myid", :a1 => "one", :a2 => "two"
+      ItemStore.find("myid").should == item
+    end
+    it "returns the created campaign" do
+      ItemStore.create(:id => "myid").should be_a(ItemStore)
+    end
+  end
+
+  describe ".find" do
+    it "returns nil for nil" do
+      ItemStore.find(nil).should == nil
+    end
+    it "returns nil for empty string" do
+      ItemStore.find("").should == nil
+    end
+    it "returns nil if no match" do
+      ItemStore.find("no_match").should == nil
+    end
+    it "returns item if match" do
+      item = ItemStore.create :id => "match"
+      ItemStore.find("match").should == item
+    end
+  end
+
+  describe ".find_or_initialize_by_id" do
+    it "returns found dossier if present" do
+      ItemStore.should_receive(:find).with("some_id").and_return("found_dossier")
+      ItemStore.find_or_initialize_by_id("some_id").should == "found_dossier"
+    end
+    it "initializes a new dossier if none is present" do
+      ItemStore.should_receive(:find).with("some_id").and_return(nil)
+      ItemStore.find_or_initialize_by_id("some_id").id.should == "some_id"
+    end
+  end
+
+end
+

data/spec/lib/active_store/connection_spec.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveStore::Connection do
+  before do
+    @connection = ActiveStore::Connection.new(nil, 'test', 30 * 24 * 3600)
+  end
+
+  it "it sets and gets values from db" do
+    @connection.set "test", "foo" => "boo", "sha" => "bada"
+    @connection.get("test").should == {"foo" => "boo", "sha" => "bada"}
+  end
+
+  it "sets data as JSON" do
+    @connection.set "test", :foo => "boo", :sha => "bada"
+    @connection.get_raw("test").should == '{"foo":"boo","sha":"bada"}'
+  end
+
+  it "adds data as JSON" do
+    @connection.add("test", :foo => "boo", :sha => "bada").should be_true
+    @connection.get_raw("test").should == '{"foo":"boo","sha":"bada"}'
+  end
+
+  it "get returns nil if the key doesn't exist" do
+    @connection.get("asdfgasda").should be_nil
+  end
+
+  it "get does not create Time-like objects from Time-like strings" do
+    time_str = Time.now.to_s
+    date_str = Date.today.to_s
+    @connection.set("test", "foo" => time_str, "bar" => date_str)
+    @connection.get("test").should == {
+      "foo" => time_str,
+      "bar" => date_str
+    }
+  end
+
+  it "cas data as JSON" do
+    @connection.set_raw("test", '{"foo":"boo","sha":"bada"}', 1)
+    @connection.cas "test" do |data|
+      data.should == {"foo" => "boo", "sha" => "bada"}
+      data["shi"] = "bidi"
+      data
+    end
+    @connection.get_raw("test").should == '{"foo":"boo","sha":"bada","shi":"bidi"}'
+  end
+
+  it "gets data as JSON" do
+    @connection.set_raw("test", '{"foo":"boo","sha":"bada"}', 1)
+    @connection.get("test").should == {"foo" => "boo", "sha" => "bada"}
+  end
+
+  it "Works with increment" do
+    @connection.set("test", 10)
+    @connection.incr("test").should == 11
+  end
+
+  it "Works with strings" do
+    @connection.set("test", "some value")
+    @connection.get("test").should == "some value"
+  end
+
+  it "supports non-ascii keys" do
+    @connection.set("testäöå", "3")
+    @connection.get("testäöå").should == "3"
+  end
+
+  it "supports spaces in keys" do
+    @connection.set(" foo\n", "2")
+    @connection.get(" foo\n").should == "2"
+  end
+
+  describe "#store" do
+    it "returns a Dalli::Client" do
+      @connection.store = nil
+      @connection.store.should be_instance_of(Dalli::Client)
+    end
+
+    it "raises an exception when it cannot connect" do
+      connection = ActiveStore::Connection.new("localhost:1234", "test", 0)
+      expect {connection.store}.to raise_error
+      # Tests that we clear the memoization to try again
+      expect {connection.store}.to raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'active_store'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    ActiveStore::Base.connection_string = nil
+    ActiveStore::Base.connection.flush_all
+  end
+end
+

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: active_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Petter Remen
+- Jean-Louis Giordano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70327179856160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70327179856160
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70327179855740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70327179855740
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: &70327179855240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70327179855240
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70327179854820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70327179854820
+description: ''
+email:
+- petter@icehouse.se
+- jean-louis@icehouse.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- active_store.gemspec
+- lib/active_store.rb
+- lib/active_store/base.rb
+- lib/active_store/connection.rb
+- lib/active_store/version.rb
+- spec/lib/active_store/base_spec.rb
+- spec/lib/active_store/connection_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: active_store
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A active record-like wrapper for memcached protocol
+test_files:
+- spec/lib/active_store/base_spec.rb
+- spec/lib/active_store/connection_spec.rb
+- spec/spec_helper.rb