vault 0.1.0 → 0.1.1

data/lib/vault/dirty.rb

@@ -1,37 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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.rb

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

data/lib/vault/storage/in_memory_store.rb

@@ -1,14 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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/validations.rb

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

data/spec/active_model_compliance_spec.rb

@@ -1,33 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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