vault 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-* Nicolás Sanguinetti
+
+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/README.md

@@ -0,0 +1,73 @@
+Vault, a lightweight Object Document Mapper
+===========================================
+
+    class User
+      include Vault
+
+      key      :id
+      property :name
+      property :email
+    end
+
+    user = User.new(:id => 1, :name => "John", :email => "john@example.org")
+    user.save
+
+    User.find(1) #=> user
+    User.all     #=> [user]
+    User.size    #=> 1
+
+Storage
+-------
+
+By default Vault stores everything in an in-memory hash. Each model (class in
+which you included the `Vault` module) has its own, independent storage.
+
+Subclasses of a model share their storage with their parent.
+
+To change the storage you can call `store_objects_in(store)` in the class
+definition. A store is any object that implements this API:
+
+* `Store#size` returns an integer with the total amount of elements in the store
+* `Store#each(&block)` a store must implement `each` and include Enumerable
+* `Store#[](key)` receiving the key it should return a hash of all attributes
+**except for the key**.
+* `Store#[]=(key, attributes)` attributes will be a hash with the attributes
+**except** for the key.
+* `Store#delete(key)` shall delete the item without the given key.
+* `Store#filter(hash)` should return a new object of the same class as the
+  original store, but only with objects whose properties match those of the
+  argument.
+
+This library provides two storage mechanisms out of the box:
+
+* `Vault::Storage::InMemoryStore` is a simple hash storage (and the default)
+* `Vault::Storage::YamlStore` serializes the contents to disk as a YAML file
+
+TODO
+----
+
+* Relationships/Associations
+
+More docs?
+----------
+
+I will get to it eventually. For now, read the specs and the source—it is a
+small library. Or help and write some docs :)
+
+Note on Patches/Pull Requests
+-----------------------------
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don’t break it in a future version
+  unintentionally.
+* Commit, do not mess with Rakefile, version, or history. (if you want to have
+  your own version, that is fine but bump version in a commit by itself I can
+  ignore when I pull.)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+---------
+
+Copyright © 2010 [Nicolás Sanguinetti](http://github.com/foca), licensed under
+an MIT license. See MIT-LICENSE for details.

data/Rakefile

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "rake"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+
+require "vault/version"
+
+begin
+  require "spec/rake/spectask"
+
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.pattern = "spec/**/*_spec.rb"
+    spec.spec_opts << "--color" << "--format specdoc"
+  end
+
+  task :default => ["spec"]
+rescue LoadError
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = "vault"
+  s.version           = Vault::Version::STRING
+  s.summary           = "Provides a very lightweight ODM"
+  s.author            = "Nicolás Sanguinetti"
+  s.email             = "hi@nicolassanguinetti.info"
+  s.homepage          = "http://github.com/foca/vault"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.md MIT-LICENSE)
+
+  s.files             = Dir['Rakefile', '{bin,lib,man,test,spec}/**/*', 'README*', '*LICENSE*'] & `git ls-files -z`.split("\0")
+
+  s.require_paths     = ["lib"]
+
+  s.add_dependency("activemodel", "3.0.0.beta.3")
+  s.add_development_dependency("rspec", "~> 1.3")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/lib/vault/associations.rb

@@ -0,0 +1,39 @@
+module Vault
+  module Associations
+    def has_many(name, klass_name=name.to_s.classify, foreign_key="#{self.to_s.underscore.singularize}_key")
+      define_method name do
+        model = klass_name.is_a?(Class) ? klass_name : self.class.const_get(klass_name)
+        HasManyProxy.new(self, model, foreign_key, foreign_key => key)
+      end
+    end
+
+    def belongs_to(name, klass_name=name.to_s.classify)
+      foreign_key = "#{name}_key"
+
+      property(foreign_key)
+
+      define_method name do
+        model = klass_name.is_a?(Class) ? klass_name : self.class.const_get(klass_name)
+        model[send(foreign_key)]
+      end
+
+      define_method "#{name}=" do |object|
+        send("#{foreign_key}=", object.key)
+      end
+    end
+
+    class HasManyProxy < Scoping::Scope
+      def initialize(owner, model, foreign_key, conditions={})
+        super(model, conditions)
+        @owner = owner
+        @foreign_key = foreign_key
+      end
+
+      def <<(object)
+        object.send("#{@foreign_key}=", @owner.key)
+        object.save
+        self
+      end
+    end
+  end
+end

data/lib/vault/attribute_accessors.rb

@@ -0,0 +1,29 @@
+module Vault
+  module AttributeAccessors
+    def initialize(*)
+      @_attributes = attributes_from_model_properties
+      super
+    end
+
+    def write_attribute(name, value)
+      @_attributes[name] = value
+    end
+
+    def read_attribute(name)
+      @_attributes[name]
+    end
+
+    def attributes
+      @_attributes
+    end
+
+    private
+
+    def attributes_from_model_properties
+      self.class.properties.inject(HashWithIndifferentAccess.new) do |props, prop|
+        props[prop.name] = prop.default
+        props
+      end
+    end
+  end
+end

data/lib/vault/bulk_attributes.rb

@@ -0,0 +1,17 @@
+module Vault
+  module BulkAttributes
+    def initialize(attrs={})
+      update(attrs)
+      changed_attributes.clear
+    end
+
+    def update(attrs={})
+      attrs.each do |key, value|
+        method = "#{key}="
+        __send__(method, value)
+      end
+
+      self
+    end
+  end
+end

data/lib/vault/dirty.rb

@@ -0,0 +1,37 @@
+module Vault
+  module Dirty
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Dirty
+    end
+
+    def save(*)
+      super.tap do |saved|
+        if saved
+          if attribute_changed?(self.class.key)
+            self.class.store.delete(attribute_was(self.class.key))
+          end
+
+          @previously_changed = changes
+          changed_attributes.clear
+        end
+      end
+    end
+
+    def write_attribute(name, value)
+      name = name.to_s
+
+      if attribute_changed?(name)
+        old = changed_attributes[name]
+        changed_attributes.delete(name) if old == value
+      else
+        old = read_attribute(name)
+        old = old.dup if old.duplicable?
+        changed_attributes[name] = old if old != value
+      end
+
+      super(name, value)
+    end
+  end
+end

data/lib/vault/finders.rb

@@ -0,0 +1,24 @@
+module Vault
+  module Finders
+    delegate :size, :to => :store
+    alias_method :count, :size
+
+    def all(query={})
+      query.delete(key)
+      store.filter(query).map do |key_value, properties|
+        build(key_value, properties)
+      end
+    end
+
+    def [](key_value)
+      properties = store[key_value]
+      build(key_value, properties) if properties
+    end
+
+    private
+
+    def build(key_value, properties)
+      new(properties.update(key => key_value))
+    end
+  end
+end

data/lib/vault/persistance.rb

@@ -0,0 +1,47 @@
+module Vault
+  module Persistance
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :store
+      extend Storage
+
+      store_objects_in Vault::Storage::InMemoryStore.new
+    end
+
+    module Storage
+      def store_objects_in(store)
+        self.store = store
+      end
+    end
+
+    def initialize(*)
+      @_new = true
+      @_destroyed = false
+      super
+    end
+
+    def persisted?
+      !@_new && !@_destroyed
+    end
+
+    def save(run_validations=true)
+      return false if run_validations && !valid?
+      self.class.store[key] = attributes_except_key
+      @_new = false
+      true
+    end
+
+    def destroy
+      self.class.store.delete(key)
+      @_destroyed = true
+      freeze
+    end
+
+    private
+
+    def attributes_except_key
+      attributes.except(self.class.key)
+    end
+  end
+end

data/lib/vault/properties.rb

@@ -0,0 +1,68 @@
+module Vault
+  module Properties
+    def key(key=nil)
+      return @_key if key.nil?
+      @_key = property(key, true).name
+    end
+
+    def property(name, primary=false, &block)
+      Property.new(name, primary, &block).tap do |prop|
+        properties << prop
+        define_property_methods(prop.name)
+
+        # FIXME: Ugh, ActiveModel fails with this, I can't do incremental method
+        # definition, you have to define them all at once (so undefine/define
+        # each time if you don't know all the properties upfront, like here.)
+        undefine_attribute_methods
+        define_attribute_methods(property_names)
+      end
+    end
+
+    def properties
+      @_properties ||= Set.new
+    end
+
+    def property_names
+      properties.map(&:name)
+    end
+
+    def define_property_methods(name)
+      class_eval <<-ruby, __FILE__, __LINE__
+        def #{name}
+          read_attribute(:#{name})
+        end
+
+        def #{name}=(value)
+          write_attribute(:#{name}, value)
+        end
+      ruby
+    end
+
+    class Property
+      attr_reader :name
+
+      def initialize(name, primary=false, &default)
+        @name = name.to_s
+        @default = default || lambda {}
+        @primary = primary
+      end
+
+      def primary?
+        @primary
+      end
+
+      def default
+        @default.call
+      end
+
+      # Set requires both #hash and #eql? to check for inclusion
+      def hash # :nodoc:
+        name.hash
+      end
+
+      def eql?(other) # :nodoc:
+        name == other.name
+      end
+    end
+  end
+end

data/lib/vault/scoping.rb

@@ -0,0 +1,64 @@
+module Vault
+  module Scoping
+    extend ActiveSupport::Concern
+
+    def scopes
+      @_scopes ||= Hash.new
+    end
+
+    def scope(name, &conditions)
+      name = name.to_s
+      scopes[name] = Scope.new(self, conditions.call)
+      define_scope_method(name)
+    end
+
+    private
+
+    def define_scope_method(name)
+      singleton_class.instance_eval do
+        define_method name do
+          scopes[name]
+        end
+      end
+    end
+
+    class Scope
+      include Finders
+
+      delegate :new, :key, :model_name, :to => :model
+
+      attr_reader :conditions, :model
+
+      def initialize(model, conditions)
+        @model = model
+        @conditions = conditions.stringify_keys
+      end
+
+      def store
+        @store ||= @model.store.filter(conditions)
+      end
+
+      def method_missing(method, *)
+        if model_has_scope?(method)
+          merge(model.scopes[method.to_s])
+        else
+          super
+        end
+      end
+
+      def respond_to?(method, include_private=false)
+        model_has_scope?(method) || super
+      end
+
+      private
+
+      def model_has_scope?(name)
+        model.scopes.include?(name.to_s)
+      end
+
+      def merge(scope)
+        Scope.new(model, conditions.merge(scope.conditions))
+      end
+    end
+  end
+end

data/lib/vault/storage/in_memory_store.rb

@@ -0,0 +1,14 @@
+module Vault
+  module Storage
+    class InMemoryStore < Hash
+      def filter(query)
+        return self if query.blank?
+
+        inject(InMemoryStore.new) do |result, (key, properties)|
+          result[key] = properties if properties.merge(query) == properties
+          result
+        end
+      end
+    end
+  end
+end

data/lib/vault/storage/yaml_store.rb

@@ -0,0 +1,52 @@
+require "yaml"
+require "active_support/core_ext/module/delegation"
+
+module Vault
+  module Storage
+    class YamlStore
+      include Enumerable
+
+      delegate :[], :[]=, :size, :each, :delete, :to => :doc
+
+      def initialize(file=nil)
+        @file = file
+        at_exit { flush if @file.present? }
+      end
+
+      def initialize_copy(*)
+        @file = nil
+      end
+
+      def filter(query)
+        return filtered_copy(@doc) if query.blank?
+
+        results = doc.inject(ActiveSupport::OrderedHash.new) do |result, (key, properties)|
+          result[key] = properties if properties.merge(query) == properties
+          result
+        end
+
+        filtered_copy(results)
+      end
+
+      def flush
+        File.open(@file, "w+") {|f| YAML.dump(@doc, f) }
+      end
+
+      protected
+
+      def doc=(doc)
+        @doc = doc
+      end
+
+      private
+
+      def filtered_copy(doc)
+        dup.tap {|store| store.doc = doc }
+      end
+
+      def doc
+        @doc ||= ActiveSupport::OrderedHash.new(YAML.load_file(@file))
+      end
+    end
+  end
+end

data/lib/vault/storage.rb

@@ -0,0 +1,4 @@
+module Vault
+  module Storage
+  end
+end

data/lib/vault/validations.rb

@@ -0,0 +1,13 @@
+module Vault
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations
+    end
+
+    def errors
+      @_errors ||= ActiveModel::Errors.new
+    end
+  end
+end

data/lib/vault/version.rb

@@ -0,0 +1,8 @@
+module Vault
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY].join(".").freeze
+  end
+end

data/lib/vault.rb

@@ -0,0 +1,53 @@
+require "set"
+require "active_model"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/class/attribute_accessors"
+
+module Vault
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Associations
+  autoload :AttributeAccessors
+  autoload :BulkAttributes
+  autoload :Dirty
+  autoload :Finders
+  autoload :Persistance
+  autoload :Properties
+  autoload :Scoping
+  autoload :Storage
+  autoload :Validations
+
+  module Storage
+    extend ActiveSupport::Autoload
+    autoload :InMemoryStore
+    autoload :YamlStore
+  end
+
+  included do
+    extend ActiveModel::Naming
+    extend Properties
+    extend Finders
+    extend Scoping
+    extend Associations
+
+    include BulkAttributes
+    include AttributeAccessors
+    include Persistance
+    include Dirty
+    include Validations
+
+    # Convenience methods to provide ActiveModel's API
+    include ActiveModel::Conversion
+  end
+
+  def key
+    send(self.class.key)
+  end
+  alias_method :id, :key
+
+  def ==(other)
+    key == other.key
+  end
+end

data/spec/active_model_compliance_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "ActiveModel compliance" do
+  class Person
+    include Vault
+
+    key      :id
+    property :first_name
+    property :last_name
+  end
+
+  include ActiveModel::Lint::Tests
+
+  instance_methods.grep(/^test_/).each do |method|
+    it method.gsub("_", " ").gsub(/to (\w+)/, 'to_\1') do
+      send method
+    end
+  end
+
+  private
+
+  def model
+    Person.new
+  end
+
+  def assert(cond, msg=nil)
+    flunk msg unless cond
+  end
+
+  def assert_kind_of(kind, object, msg=nil)
+    flunk msg unless object.kind_of?(kind)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "spec"
+require "vault"
+
+Dir["spec/support/**/*.rb"].each {|f| require f }
+
+Spec::Runner.configure do |config|
+  config.include SpecHelpers
+end

data/spec/support/helpers.rb

@@ -0,0 +1,16 @@
+module SpecHelpers
+  def model(&block)
+    Class.new do
+      include Vault
+      class_eval(&block) if block
+    end
+  end
+
+  def named_model(name, &block)
+    model = model(&block)
+    self.class.class_eval do
+      remove_const(name) if const_defined?(name)
+      const_set(name, model)
+    end
+  end
+end

data/spec/support/storage_api.rb

@@ -0,0 +1,14 @@
+shared_examples_for "A storage adapter" do
+  it { should respond_to(:size) }
+  it { should respond_to(:delete) }
+  it { should respond_to(:[]) }
+  it { should respond_to(:[]=) }
+
+  it { should respond_to(:each) }
+  it { should be_an(Enumerable) }
+
+  it { should respond_to(:filter) }
+  it "is closed under #filter" do
+    subject.filter({}).should be_a(described_class)
+  end
+end

data/spec/vault/associations_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Vault, "model" do
+  class Book
+    include Vault
+    key      :title
+    has_many :authors
+  end
+
+  class Author
+    include Vault
+    key        :name
+    belongs_to :book
+  end
+
+  let(:pickaxe_book) { Book.new(:title => "Programming Ruby") }
+
+  let(:dave_thomas)  { Author.new(:name => "Dave Thomas") }
+  let(:chad_fowler)  { Author.new(:name => "Chad Fowler") }
+  let(:andy_hunt)    { Author.new(:name => "Andy Hunt")   }
+  let(:sam_ruby)     { Author.new(:name => "Sam Ruby")    }
+
+  describe ".belongs_to" do
+    before do
+      dave_thomas.save
+      pickaxe_book.save
+    end
+
+    it "can assign the associated object directly" do
+      dave_thomas.book = pickaxe_book
+      dave_thomas.book.should == pickaxe_book
+    end
+
+    it "can assign the key" do
+      dave_thomas.book_key = pickaxe_book.key
+      dave_thomas.book.should == pickaxe_book
+    end
+  end
+
+  describe ".has_many" do
+    before do
+      dave_thomas.book = pickaxe_book
+      chad_fowler.book = pickaxe_book
+
+      dave_thomas.save
+      chad_fowler.save
+
+      pickaxe_book.save
+    end
+
+    subject { pickaxe_book.authors.all }
+
+    it "can find all associated objects" do
+      should include(dave_thomas, chad_fowler)
+    end
+
+    it "doesn't find objects that haven't been associated to the model" do
+      should_not include(sam_ruby)
+    end
+
+    context "adding objects directly to the association" do
+      it "persists both the container and containee" do
+        pickaxe_book.authors << andy_hunt
+        should include(andy_hunt)
+      end
+
+      it "can chain additions" do
+        pickaxe_book.authors << andy_hunt << sam_ruby
+        should include(andy_hunt, sam_ruby)
+      end
+    end
+  end
+end

data/spec/vault/finders_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Vault do
+  let :person_klass do
+    model do
+      key :name
+      property :email
+      property :age
+    end
+  end
+
+  let :john do
+    person_klass.new(:name => "John", :email => "john@example.org", :age => 28)
+  end
+
+  let :mary do
+    person_klass.new(:name => "Mary", :email => "mary@example.org", :age => 23)
+  end
+
+  let :bob do
+    person_klass.new(:name => "Bob", :email => "bob@example.org", :age => 29)
+  end
+
+  let :jane do
+    person_klass.new(:name => "Jane", :email => "jane@example.org", :age => 28)
+  end
+
+  before do
+    john.save
+    mary.save
+    bob.save
+    jane.save
+  end
+
+  describe "#all" do
+    subject { person_klass.all }
+
+    it { should have(4).elements }
+
+    it "includes all the persisted objects" do
+      should include(john)
+      should include(mary)
+      should include(bob)
+      should include(jane)
+    end
+
+    it { should be_an(Enumerable) }
+  end
+
+  describe "#[]" do
+    it "finds an object by key" do
+      person_klass["Bob"].should == bob
+    end
+
+    it "returns nil if it doesn't find it" do
+      person_klass["Jamie"].should be_nil
+    end
+  end
+
+  describe "#size" do
+    it "returns the amount of elements in the store" do
+      person_klass.size.should == 4
+    end
+
+    it "is aliased to #count" do
+      person_klass.count.should == person_klass.size
+    end
+  end
+end

data/spec/vault/persistance_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe Vault do
+  let :book_klass do
+    model do
+      key :isbn
+      property :title
+      property :author
+    end
+  end
+
+  let :store do
+    book_klass.store
+  end
+
+  let :alice do
+    book_klass.new("title"  => "Alice in Wonderland",
+                   "author" => "Lewis Carroll",
+                   "isbn"   => "978-0862033248")
+  end
+
+  describe "#save" do
+    it "returns true" do
+      alice.save.should be(true)
+    end
+
+    it "marks the object as persisted" do
+      alice.save
+      alice.should be_persisted
+    end
+
+    it "stores the object in the model's store" do
+      alice.save
+      store[alice.isbn].should include("title", "author")
+    end
+
+    it "doesn't store the key among the object properties" do
+      alice.save
+      store[alice.isbn].should_not include("isbn")
+    end
+
+    it "updates an already saved object's attributes" do
+      alice.save
+      alice.update(:title => "Alice in Wonderland Illustrated")
+      alice.save
+
+      store[alice.isbn]["title"].should == "Alice in Wonderland Illustrated"
+    end
+
+    it "clears the tracked changed attributes" do
+      alice.save
+      alice.should_not be_changed
+    end
+
+    it "doesn't keep the old key when you change it" do
+      alice.save
+      alice.update("isbn" => "978-0517223628")
+      old_isbn = alice.isbn_was
+      alice.save
+
+      store[old_isbn].should be_blank
+      store[alice.isbn].should_not be_blank
+    end
+
+    context "when the object is invalid" do
+      let :person_klass do
+        named_model :Person do
+          key      :email
+          property :name
+
+          validates :email, :presence => true
+          validates :name,  :presence => true
+        end
+      end
+
+      let :store do
+        person_klass.store
+      end
+
+      let :nameless_person do
+        person_klass.new(:email => "john.doe@example.org")
+      end
+
+      it "returns false" do
+        nameless_person.save.should be(false)
+      end
+
+      it "doesn't persist the object" do
+        nameless_person.save
+        nameless_person.should_not be_persisted
+      end
+
+      context "but you skip validations" do
+        it "returns true" do
+          nameless_person.save(false).should be(true)
+        end
+
+        it "persists the object anyway" do
+          nameless_person.save(false)
+          nameless_person.should be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#destroy" do
+    before do
+      alice.save
+    end
+
+    it "should no longer be persisted after being destroyed" do
+      alice.destroy
+      alice.should_not be_persisted
+    end
+
+    it "removes the object from the model's store" do
+      alice.destroy
+      store[alice.isbn].should be_blank
+    end
+
+    it "freezes the model" do
+      alice.destroy
+      alice.should be_frozen
+    end
+  end
+end

data/spec/vault/properties_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Vault, "defining properties" do
+  it "defines accessors for each property" do
+    person_klass = model do
+      property :name
+      property :age
+    end
+
+    person = person_klass.new
+    person.should respond_to(:name, :name=, :age, :age=)
+  end
+
+  it "doesn't define duplicated properties" do
+    person_klass = model do
+      property :name
+      property :name
+    end
+
+    person_klass.should have(1).properties
+  end
+
+  it "doesn't support more than one key" do
+    person_klass = model do
+      key :name
+      key :age
+    end
+
+    person = person_klass.new(:name => "John", :age => 28)
+    person.save
+    person.to_key.should == [person.age]
+  end
+
+  it "can specify default values" do
+    person_klass = model do
+      property(:name) { "John" }
+      property(:age)  { 28 }
+    end
+
+    person = person_klass.new
+    person.name.should == "John"
+    person.age.should  == 28
+  end
+
+  it "doesn't flag an attribute as changed if you revert the change" do
+    person_klass = model do
+      property :name
+    end
+
+    person = person_klass.new(:name => "John")
+    person.name = "Joe"
+    person.name = "John"
+    person.should_not be_changed
+  end
+
+  it "provides 'dirty' attribute tracking" do
+    model.included_modules.should include(ActiveModel::Dirty)
+  end
+end

data/spec/vault/scoping_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Vault do
+  let :book_klass do
+    model do
+      scope :by_lewis_carroll do
+        { "author" => "Lewis Carroll" }
+      end
+
+      scope :titled_alice do
+        { "title" => "Alice in Wonderland" }
+      end
+
+      key :isbn
+      property :title
+      property :author
+    end
+  end
+
+  let :alice_in_wonderland do
+    book_klass.new(:isbn   => "978-0517223628",
+                   :title  => "Alice in Wonderland",
+                   :author => "Lewis Carroll")
+  end
+
+  let :through_the_looking_glass do
+    book_klass.new(:isbn   => "978-0140367096",
+                   :title  => "Through the Looking Glass",
+                   :author => "Lewis Carroll")
+  end
+
+  let :the_wonderful_wizard_of_oz do
+    book_klass.new(:isbn   => "978-0451530295",
+                   :title  => "The Wonderful Wizard of Oz",
+                   :author => "Lyman Frank Baum")
+  end
+
+  before do
+    alice_in_wonderland.save
+    through_the_looking_glass.save
+    the_wonderful_wizard_of_oz.save
+  end
+
+  it "filters the collection by the given scope" do
+    scoped = book_klass.by_lewis_carroll
+    scoped.all.should =~ [alice_in_wonderland, through_the_looking_glass]
+  end
+
+  it "lets you chain scopes" do
+    scoped = book_klass.by_lewis_carroll.titled_alice
+    scoped.all.should == [alice_in_wonderland]
+  end
+end

data/spec/vault/storage/in_memory_store_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe Vault::Storage::InMemoryStore do
+  it_should_behave_like "A storage adapter"
+end

data/spec/vault/storage/yaml_store_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "tempfile"
+
+describe Vault::Storage::YamlStore do
+  let :path do
+    begin
+      file = Tempfile.new("store.yml")
+      file.path
+    ensure
+      file.close
+    end
+  end
+
+  subject do
+    described_class.new(path)
+  end
+
+  before do
+    subject["key_a"] = { "attr_1" => "value_1", "attr_2" => "value_2" }
+    subject["key_b"] = { "attr_3" => "value_3" }
+  end
+
+  it_should_behave_like "A storage adapter"
+
+  it "serializes the file to disk on #flush" do
+    subject.flush
+    YAML.load_file(path).should include("key_a", "key_b")
+  end
+end

data/spec/vault_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Vault do
+  let :book_klass do
+    model do
+      key      :isbn
+      property :title
+    end
+  end
+
+  it "can initialize a new model from a hash of attributes" do
+    book = book_klass.new(:title => "Some Book", :isbn => "1234567890")
+    book.title.should == "Some Book"
+    book.isbn.should  == "1234567890"
+  end
+
+  describe "#update" do
+    let :book do
+      book_klass.new(:title => "Some Book", :isbn => "1234567890")
+    end
+
+    it "effectively changes the attribute values" do
+      book.update(:title => "Awesome Book", :isbn => "0987654321")
+      book.title.should == "Awesome Book"
+      book.isbn.should  == "0987654321"
+    end
+
+    it "flags attributes as changed when bulk-updating" do
+      book.update(:title => "Awesome Book")
+      book.changes.should include(:title)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: vault
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Nicol\xC3\xA1s Sanguinetti"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-14 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta
+        - 3
+        version: 3.0.0.beta.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id002
+description: 
+email: hi@nicolassanguinetti.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- MIT-LICENSE
+files: 
+- Rakefile
+- lib/vault/associations.rb
+- lib/vault/attribute_accessors.rb
+- lib/vault/bulk_attributes.rb
+- lib/vault/dirty.rb
+- lib/vault/finders.rb
+- lib/vault/persistance.rb
+- lib/vault/properties.rb
+- lib/vault/scoping.rb
+- lib/vault/storage/in_memory_store.rb
+- lib/vault/storage/yaml_store.rb
+- lib/vault/storage.rb
+- lib/vault/validations.rb
+- lib/vault/version.rb
+- lib/vault.rb
+- spec/active_model_compliance_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- spec/support/storage_api.rb
+- spec/vault/associations_spec.rb
+- spec/vault/finders_spec.rb
+- spec/vault/persistance_spec.rb
+- spec/vault/properties_spec.rb
+- spec/vault/scoping_spec.rb
+- spec/vault/storage/in_memory_store_spec.rb
+- spec/vault/storage/yaml_store_spec.rb
+- spec/vault_spec.rb
+- README.md
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://github.com/foca/vault
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Provides a very lightweight ODM
+test_files: []
+