fauxsql 0.1.2 → 0.2.0

data/.gitignore

@@ -19,3 +19,5 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+.bundle
+ruby-1.9.1-p378/

data/Gemfile

@@ -18,5 +18,5 @@ gem 'dm-validations',                      :git => 'git://github.com/datamapper/
 gem 'dm-aggregates',                       :git => 'git://github.com/datamapper/dm-aggregates.git'
 gem 'dm-constraints',                      :git => 'git://github.com/datamapper/dm-constraints.git'
 gem 'dm-observer',                         :git => 'git://github.com/datamapper/dm-observer.git'
-gem "dm-core",                             :git => "git://github.com/collin/dm-core.git", "branch" => "next"
+gem "dm-core",                             :git => "git://github.com/datamapper/dm-core.git", "branch" => "next"
 gem "datamapper"

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/fauxsql.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{fauxsql}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Collin Miller"]
-  s.date = %q{2010-04-20}
+  s.date = %q{2010-05-06}
   s.description = %q{And description}
   s.email = %q{collintmiller@gmail.com}
   s.extra_rdoc_files = [
@@ -27,12 +27,16 @@ Gem::Specification.new do |s|
      "fauxsql.gemspec",
      "lib/fauxsql.rb",
      "lib/fauxsql/attribute_list.rb",
+     "lib/fauxsql/attribute_manymany.rb",
      "lib/fauxsql/attribute_map.rb",
      "lib/fauxsql/attribute_wrapper.rb",
+     "lib/fauxsql/attributes.rb",
      "lib/fauxsql/dereferenced_attribute.rb",
      "lib/fauxsql/dsl.rb",
      "lib/fauxsql/list_wrapper.rb",
+     "lib/fauxsql/manymany_wrapper.rb",
      "lib/fauxsql/map_wrapper.rb",
+     "lib/fauxsql/options.rb",
      "test/helper.rb",
      "test/test_fauxsql.rb"
   ]

data/lib/fauxsql/attribute_list.rb

@@ -5,29 +5,46 @@ module Fauxsql
     def <<(attribute)
       super Fauxsql.dereference_fauxsql_attribute(attribute)
     end
-    
+
     def [] index
       Fauxsql.resolve_fauxsql_attribute super(index)
     end
-    
+
     def first
       self[0]
     end
-    
+
     def last
       self[length - 1]
     end
-        
+
+    def all
+      map{|item| Fauxsql.resolve_fauxsql_attribute item }
+    end
+
     def equals list
       map_resolved == list
     end
     
-    def map_resolved
-      map = []
-      each_with_index do |item, index| 
-        map[index] = self[index]
-      end
-      map
-    end    
+    def each
+      super{|item| yield(Fauxsql.resolve_fauxsql_attribute(item)) }
+    end
+    
+    def each_with_index
+      super{|item, index| yield(Fauxsql.resolve_fauxsql_attribute(item), index) }
+    end
+
+    def -(others)
+      others = others.map{|other| Fauxsql.dereference_fauxsql_attribute(other).hash }
+      reject!{|one| others.include?(one.hash) }
+      self
+    end
+
+    # Always being not eql is expensive
+    # TODO make this work without this hack
+    def eql?(other)
+      return false
+    end
+
   end
 end

data/lib/fauxsql/attribute_manymany.rb

@@ -0,0 +1,11 @@
+module Fauxsql
+  # AttributeMap is an Hash that dereferences and resolves fauxsql attributes
+  # when setting/reading members in the Hash
+  class AttributeManymany < AttributeList
+    # Always being not eql is expensive
+    # TODO make this work without this hack
+    def eql?(other)
+      return false
+    end
+  end
+end

data/lib/fauxsql/attribute_map.rb

@@ -1,18 +1,31 @@
 module Fauxsql
   # AttributeMap is an Hash that dereferences and resolves fauxsql attributes
   # when setting/reading members in the Hash
+  def self.dereference_fauxsql_key(key)
+    real_key   = Fauxsql.dereference_fauxsql_attribute(key)
+    if (real_key.is_a? Fauxsql::DereferencedAttribute)
+      real_key = real_key.hash
+    end
+    real_key
+  end
+  
   class AttributeMap < Hash
-    # We dereference and resolve the key because in Ruby _any_ object
+    # We dereference and resolve the key because in Ruby not _any_ object
     # can be a hash key. Even a DataMapper record.
     def []= key, value
-      real_key   = Fauxsql.dereference_fauxsql_attribute(key)
+      real_key   = Fauxsql.dereference_fauxsql_key(key)
       real_value = Fauxsql.dereference_fauxsql_attribute(value)
-      super real_key.hash, real_value
+      super real_key, real_value
     end
 
     def [] key
-      real_key = Fauxsql.dereference_fauxsql_attribute(key)
-      Fauxsql.resolve_fauxsql_attribute super(real_key.hash)
+      real_key = Fauxsql.dereference_fauxsql_key(key)
+      Fauxsql.resolve_fauxsql_attribute super(real_key)
+    end
+    
+    def delete key
+      real_key = Fauxsql.dereference_fauxsql_key(key)
+      super(real_key)
     end
     
     def each(&block)
@@ -30,7 +43,7 @@ module Fauxsql
     end
         
     def resolve_key(key)
-      if key.respond_to?(:match) && key.match(/^.+Fauxsql::DereferencedAttribute.+@klass.+@lookup_key.+$/)
+      if key.respond_to?(:match) && key.match(/^.+Fauxsql::DereferencedAttribute.+@lookup_key.+$/)
         Fauxsql.resolve_fauxsql_attribute Fauxsql::DereferencedAttribute.load(key)
       else
         key
@@ -41,11 +54,10 @@ module Fauxsql
       Fauxsql.resolve_fauxsql_attribute value
     end
     
+    # Always being not eql is expensive
+    # TODO make this work without this hack
     def eql?(other)
       return false
-      raise [self, other.inspect].inspect
     end
-    
-    
   end
 end

data/lib/fauxsql/attribute_wrapper.rb

@@ -1,20 +1,31 @@
 module Fauxsql
   class AttributeWrapper
+    class MissingOptions < ArgumentError
+      def initialize(missing, options)
+        super "Missing option :#{missing} in #{options.inspect}"
+      end
+    end
     extend ActiveSupport::Concern
     attr_reader:attribute
     attr_reader:record
     attr_reader:name
+    attr_reader:options
     
-    def initialize(attribute, record, name)
-      @attribute, @record, @name = attribute, record, name
+    def initialize(attribute, record, name, options)
+      raise MissingOptions if options.nil?
+      @attribute, @record, @name, @options = attribute, record, name, options
       @record.fauxsql_attributes[name] ||= attribute
     end
 
+    def get_nested_record(vals)
+      model = vals[:type].constantize
+      raise MissingOptions.new(:nest, options) unless options[:nest]
+      raise InvalidNesting unless options[:nest].include?(model)
+      model.get(vals["#{model.name}_id".to_sym])
+    end
+
     def dirty!
-      record.attribute_set(:fauxsql_attributes, record.fauxsql_attributes.dup)
-      value = yield
-      record.attribute_set(:fauxsql_attributes, record.fauxsql_attributes)
-      value
+      Fauxsql.dirty!(record){ yield }
     end
   end
 end

data/lib/fauxsql/attributes.rb

@@ -0,0 +1,5 @@
+class Fauxsql::Attributes < Hash
+  def eql?(other)
+    return false
+  end
+end

data/lib/fauxsql/dereferenced_attribute.rb

@@ -1,3 +1,4 @@
+require "active_support/inflector"
 module Fauxsql
   # DereferencedAttribute stores objects that quack like DataMapper::Resource
   # This is the object that Fauxsql stores in the database when a 
@@ -6,12 +7,12 @@ module Fauxsql
   class DereferencedAttribute
     @@identity_map = {}
     def initialize(attribute)
-      @klass      = attribute.class
+      @klass      = attribute.class.to_s
       @lookup_key = attribute.key
     end
     
     def resolve
-      @klass.get(*@lookup_key)
+      ActiveSupport::Inflector.constantize(@klass.to_s).get(*@lookup_key)
     end
     
     def dump
@@ -20,7 +21,8 @@ module Fauxsql
     alias hash dump
     
     def self.get(attribute)
-      @@identity_map[attribute] ||= new(attribute)
+      dereferenced = new(attribute)
+      @@identity_map[dereferenced.hash] ||= dereferenced
     end
     
     def self.load(dump)

data/lib/fauxsql/dsl.rb

@@ -1,5 +1,7 @@
+require "active_support/inflector"
 module Fauxsql
   module DSL
+    class InvalidNesting < StandardError; end
     # DSL method to define a named Fauxsql attribute
     #
     # calling with 'power' is like writing:
@@ -10,8 +12,9 @@ module Fauxsql
     #   def power=(value)
     #     set_fauxsql_attribute(:power, value)
     #   end
-    def attribute(attribute_name)
-      class_eval <<EORUBY
+    def attribute(attribute_name, options={})
+      fauxsql_options[attribute_name] = normalize_options!(options)
+      class_eval <<EORUBY, __FILE__, __LINE__
         def #{attribute_name}
           get_fauxsql_attribute(:#{attribute_name})
         end
@@ -20,6 +23,15 @@ module Fauxsql
           set_fauxsql_attribute(:#{attribute_name}, value)
         end
 EORUBY
+
+      if options[:nest]
+        class_eval <<EORUBY, __FILE__, __LINE__
+          def #{attribute_name}_attributes=(vals)
+            vals = Fauxsql::DSL.normalize_nested_vals!(vals)
+            #{attribute_name} = #{attribute_name}.get_nested_record(vals)
+          end
+EORUBY
+      end
     end
 
     # DSL method to define a named Fauxsql list
@@ -28,12 +40,26 @@ EORUBY
     #   def squad_members
     #     get_fauxsql_list(:squad_members)
     #   end
-    def list(attribute_name)
-      class_eval <<EORUBY
+    def list(attribute_name, options={})
+      fauxsql_options[attribute_name] = normalize_options!(options)
+      class_eval <<EORUBY, __FILE__, __LINE__
         def #{attribute_name}
           get_fauxsql_list(:#{attribute_name})
         end
 EORUBY
+
+      if options[:nest]
+        class_eval <<EORUBY, __FILE__, __LINE__
+          def #{attribute_name}=(attrs)
+            #{attribute_name}.clear
+            attrs.each do |index, vals|
+              vals = Fauxsql::DSL.normalize_nested_vals!(vals)
+              record = #{attribute_name}.get_nested_record(vals)
+              #{attribute_name} << record if record unless vals[:_delete]
+            end
+          end
+EORUBY
+      end
     end
 
     # DSL method to define a named Fauxsql map
@@ -42,12 +68,53 @@ EORUBY
     #   def mitigates
     #     get_fauxsql_map(:mitigates)
     #   end
-    def map(attribute_name)
-      class_eval <<EORUBY
+    def map(attribute_name, options={})
+      fauxsql_options[attribute_name] = normalize_options!(options)
+      class_eval <<EORUBY, __FILE__, __LINE__
         def #{attribute_name}
           get_fauxsql_map(:#{attribute_name})
         end
 EORUBY
+
+      if options[:nest]
+        class_eval <<EORUBY, __FILE__, __LINE__
+          def #{attribute_name}=(attrs)
+            deletes = []
+            attrs.each do |index, vals|
+              vals = Fauxsql::DSL.normalize_nested_vals!(vals)
+              key = #{attribute_name}.get_nested_record(vals)
+              #{attribute_name}[key] = vals[:value]
+              deletes << key if vals[:_delete]
+            end
+            deletes.each{ |key| #{attribute_name}.delete(key) }
+          end
+EORUBY
+      end
+    end
+
+    # DSL method to define a named Fauxsql manymany relationship
+    #
+    # calling with 'friends' is like writing:
+    #   def friends
+    #     get_fauxsql_manymany(:friends, Other, :through => :friends)
+    #   end
+    def manymany(attribute_name, classes, options)
+      define_method attribute_name do
+        get_fauxsql_manymany(attribute_name, classes, options)
+      end
+    end
+
+  private
+  
+    def normalize_options!(options)
+      options[:nest] = [options[:nest]] if options[:nest] unless options[:nest].is_a?(Array)
+      options.freeze
+    end
+    
+    def self.normalize_nested_vals!(vals)
+      vals[:_delete] = true if vals[:_delete] == "1" # Rails forms return "1" for nested attributes deletion.
+      vals[:_delete] = false unless vals[:_delete] == true
+      vals.freeze
     end
   end
 end

data/lib/fauxsql/list_wrapper.rb

@@ -1,12 +1,15 @@
-require "active_support/dependencies"
 require "active_support/core_ext/module/delegation"
 module Fauxsql
   class ListWrapper < AttributeWrapper
     alias list attribute
-    delegate :[], :==, :<<, :first, :last, :equals, :map_resolved, :to => :list
+    delegate :[], :==, :first, :last, :each, :each_with_index, :map, :all, :equals, :to => :list
     
     def <<(item)
       dirty! { list << item }
     end
+    
+    def clear
+      dirty! { list.clear }
+    end
   end
 end

data/lib/fauxsql/manymany_wrapper.rb

@@ -0,0 +1,43 @@
+require "active_support/core_ext/module/delegation"
+require 'active_support/core_ext/array/extract_options'
+module Fauxsql
+  class ManymanyWrapper < AttributeWrapper
+    class ThroughOptionMissing < StandardError; end
+    class InvalidManymanyAssociationClass < StandardError; end
+    
+    alias list attribute
+    delegate :-, :[], :==, :first, :last, :each, :each_with_index, :map, :all, :equals, :to => :list
+    
+    def initialize(attribute, record, name, *classes)
+      super(attribute, record, name, {})
+      options = classes.extract_options!
+      raise ThroughOptionMissing unless options[:through]
+      @classes, @through = classes, options[:through]
+    end
+    
+    def <<(other)
+      raise InvalidManymanyAssociationClass unless @classes.include?(other.class)
+      other.send(@through).clean_push(record)
+      clean_push(other)
+    end
+    
+    def delete(*others)
+      raise InvalidManymanyAssociationClass if (@classes - others.map{|other| other.class }).any?
+      clean_subtract(others)
+      others.each{ |other| other.send(@through).clean_subtract([record]) }
+      # # DataMapper.transaction do # TODO the transaction?
+        others.each{|other| other.save}
+        record.save
+      # end
+    end
+    
+  protected
+    def clean_push(other)
+      dirty! { list << other }
+    end
+    
+    def clean_subtract(others)
+      dirty! { @attribute = list - others }
+    end
+  end
+end

data/lib/fauxsql/map_wrapper.rb

@@ -1,12 +1,20 @@
-require "active_support/dependencies"
 require "active_support/core_ext/module/delegation"
 module Fauxsql
   class MapWrapper < AttributeWrapper
     alias map attribute
-    delegate :[], :each, :keys, :resolve_key, :resolve_value, :to => :map
+    delegate :[], :each, :each_with_index, :keys, :resolve_key, :resolve_value, :to => :map
     
     def []=(key, value)
+      value = value.send(options[:value_type]) if options[:value_type]
       dirty! { map[key] = value }
     end
+    
+    def [](key)
+      options[:value_type] ? map[key].send(options[:value_type]) : map[key]
+    end
+    
+    def delete(key)
+      dirty! { map.delete(key) }
+    end
   end
 end

data/lib/fauxsql/options.rb

@@ -0,0 +1,5 @@
+class Fauxsql::Options < Hash
+  def [](key)
+    super(key) || {}
+  end
+end

data/lib/fauxsql.rb

@@ -6,48 +6,69 @@ require 'pathname'
 # Internal Libs
 root = Pathname.new(__FILE__).dirname.expand_path
 require root+'fauxsql/dereferenced_attribute'
+require root+'fauxsql/attributes'
+require root+'fauxsql/options'
 require root+'fauxsql/attribute_list'
 require root+'fauxsql/attribute_map'
+require root+'fauxsql/attribute_manymany'
 require root+'fauxsql/attribute_wrapper'
 require root+'fauxsql/map_wrapper'
 require root+'fauxsql/list_wrapper'
+require root+'fauxsql/manymany_wrapper'
 require root+'fauxsql/dsl'
 module Fauxsql
   extend ActiveSupport::Concern
   
   included do
-    property :fauxsql_attributes, Object, :default => {}
+    # Property is lazy. Benchmark for lazy loading shows
+    # performance is up to 5x slower when accessing fauxsql attributes.
+    property :fauxsql_attributes, Object, 
+      :default => lambda{|*| Fauxsql::Attributes.new },
+      :lazy => false
     extend Fauxsql::DSL
+    cattr_accessor :fauxsql_options
+    self.fauxsql_options = Fauxsql::Options.new
   end
   
   # Getter method for attributes defined as:
   #   attribute :attribute_name
   def get_fauxsql_attribute(attribute_name)
     attribute = fauxsql_attributes[attribute_name]
-    Fauxsql.resolve_fauxsql_attribute(attribute)
+    value = Fauxsql.resolve_fauxsql_attribute(attribute)
+
+    options = fauxsql_options[attribute_name]
+    options and options[:type] ? value.send(options[:type]) : value
   end
 
   # Setter method for attributes defined as:
   #   attribute :attribute_name
   def set_fauxsql_attribute(attribute_name, value)
+    options = fauxsql_options[attribute_name]
+    value = value.send(options[:type]) if options and options[:type]
+    
     attribute = Fauxsql.dereference_fauxsql_attribute(value)
-    fauxsql_attributes[attribute_name] = attribute
+    Fauxsql.dirty!(self){ fauxsql_attributes[attribute_name] = attribute }    
   end
   
   # Gets a reference to an AttributeList object. AttributeList quacks like
   # a Ruby Array. Except it uses Fauxsql's dereference and resolve strategy to
   # store members.
-  def get_fauxsql_list(list_name)
-    list = fauxsql_attributes[list_name] || AttributeList.new
-    ListWrapper.new(list, self, list_name)
+  def get_fauxsql_list(attribute_name)
+    list = fauxsql_attributes[attribute_name] || AttributeList.new
+    ListWrapper.new(list, self, attribute_name, fauxsql_options[attribute_name])
   end
 
   # Gets a reference to an AttributeMap object. AttributeMap quacks like
   # a Ruby Hash. Except it uses Fauxsql's dereference and resolve strategy to
   # store keys and values.  
-  def get_fauxsql_map(map_name)
-    map = fauxsql_attributes[map_name] || AttributeMap.new
-    MapWrapper.new(map, self,  map_name)
+  def get_fauxsql_map(attribute_name)
+    map = fauxsql_attributes[attribute_name] || AttributeMap.new
+    MapWrapper.new(map, self,  attribute_name, fauxsql_options[attribute_name])
+  end
+
+  def get_fauxsql_manymany(attribute_name, classes, options)
+    manymany = fauxsql_attributes[attribute_name] || AttributeManymany.new
+    ManymanyWrapper.new(manymany, self, attribute_name, classes, options)
   end
 
   # When setting values, all attributes pass through this method.
@@ -71,4 +92,12 @@ module Fauxsql
       attribute
     end
   end
+  
+  def self.dirty!(record)
+    record.attribute_set(:fauxsql_attributes, record.fauxsql_attributes.dup)
+    value = yield
+    record.attribute_set(:fauxsql_attributes, record.fauxsql_attributes)
+    value
+  end
+
 end

data/test/helper.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
-
+require 'dm-core'
 require 'datamapper'
 DataMapper.setup(:default, "sqlite3://:memory:")
 
@@ -10,8 +10,15 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'fauxsql'
 
 class Test::Unit::TestCase
-  def reload
-    @faux.save
-    @faux.reload
+  def checkpoint!
+    if @faux
+      @faux.save
+      @faux.reload
+    end
+    
+    if @other
+      @other.save
+      @other.reload
+    end
   end
 end

data/test/test_fauxsql.rb

@@ -18,9 +18,13 @@ class FauxObject
   property :id, Serial
   property :type, Discriminator
   attribute :name
-  attribute :record
-  list :things
-  map :dictionary
+  attribute :record, :nest => FauxObject
+  attribute :number, :type => :to_i
+  list :things, :nest => FauxObject
+  map :dictionary, :nest => FauxObject
+  map :numbers, :value_type => :to_i
+  
+  manymany :others, FauxObject, :through => :others#, :nest => true TODO implement nesting on manymany
 end
 
 class OtherFauxObject < FauxObject; end
@@ -47,21 +51,29 @@ class TestFauxsql < Test::Unit::TestCase
     
     should "persist attributes" do
       @faux.name = "MyName"
-      reload
+      checkpoint!
       assert_equal "MyName", @faux.name
     end
     
+    should "update attributes" do
+      @faux.name = "AName"
+      checkpoint!
+      @faux.name = "OtherName"
+      checkpoint!
+      assert_equal "OtherName", @faux.name
+    end
+    
     should "persist lists" do
       @faux.things << :hello
       @faux.things << :goodbye
-      reload
+      checkpoint!
       assert @faux.things == [:hello, :goodbye]
     end
     
     should "persist maps" do
       @faux.dictionary[:a] = 1
       @faux.dictionary[:b] = 2
-      reload
+      checkpoint!
       assert_equal 1, @faux.dictionary[:a]
       assert_equal 2, @faux.dictionary[:b]
     end
@@ -69,14 +81,14 @@ class TestFauxsql < Test::Unit::TestCase
     should "dereference and resolve objects that include Fauxsql" do
       has_fauxsql = OtherFauxObject.create
       @faux.record = has_fauxsql
-      reload
+      checkpoint!
       assert_equal has_fauxsql, @faux.record
     end
     
     should "dereference and resolve dm objects with simple keys" do
       simple_key = SimpleKey.create
       @faux.record = simple_key
-      reload
+      checkpoint!
       assert @faux.fauxsql_attributes[:record].is_a?(Fauxsql::DereferencedAttribute)
       assert_equal simple_key, @faux.record
     end
@@ -84,7 +96,7 @@ class TestFauxsql < Test::Unit::TestCase
     should "deference and resolve dm objects with complex keys" do
       complex_key = ComplexKey.create(:string => "string", :integer => 1)
       @faux.record = complex_key
-      reload
+      checkpoint!
       assert @faux.fauxsql_attributes[:record].is_a?(Fauxsql::DereferencedAttribute)
       assert_equal complex_key, @faux.record
     end
@@ -94,24 +106,36 @@ class TestFauxsql < Test::Unit::TestCase
       @faux.things << :hello
       @faux.things << simple
       @faux.things << :goodbye
-      reload
-      assert_equal [:hello, simple, :goodbye], @faux.things.map_resolved
+      checkpoint!
+      assert_equal [:hello, simple, :goodbye], @faux.things.all
     end
-    
+
     should "derefencenc and resolve fauxsql objects in lists" do
       has_fauxsql = OtherFauxObject.create
       @faux.things << :hello
       @faux.things << has_fauxsql
       @faux.things << :goodbye
-      reload
-      assert_equal [:hello, has_fauxsql, :goodbye], @faux.things.map_resolved
+      checkpoint!
+      assert_equal [:hello, has_fauxsql, :goodbye], @faux.things.all
+    end
+
+    should "derefencenc and resolve fauxsql objects in lists when calling each/each_with_index" do
+      has_fauxsql = OtherFauxObject.create
+      @faux.things << has_fauxsql
+      checkpoint!
+      @faux.things.each_with_index do |thing, index|
+        assert_equal has_fauxsql, thing
+      end
+      @faux.things.each do |thing|
+        assert_equal has_fauxsql, thing
+      end
     end
 
     should "derference and resolve dm objects with fauxsql in maps" do
       has_fauxsql1 = OtherFauxObject.create
       has_fauxsql2 = OtherFauxObject.create
       @faux.dictionary[has_fauxsql1] = has_fauxsql2
-      reload
+      checkpoint!
       assert_equal has_fauxsql2, @faux.dictionary[has_fauxsql1]
     end
 
@@ -120,7 +144,7 @@ class TestFauxsql < Test::Unit::TestCase
       simple2 = SimpleKey.create
       @faux.dictionary[simple1] = simple2
       assert_equal SimpleKey, @faux.dictionary.keys.first.class
-      reload
+      checkpoint!
       assert_equal simple2, @faux.dictionary[simple1]
     end
     
@@ -128,7 +152,7 @@ class TestFauxsql < Test::Unit::TestCase
       simple1 = SimpleKey.create
       simple2 = SimpleKey.create
       @faux.dictionary[simple1] = simple2
-      reload
+      checkpoint!
       @faux.dictionary.each do |key, value|
         assert_equal simple1, key
         assert_equal simple2, value
@@ -138,18 +162,188 @@ class TestFauxsql < Test::Unit::TestCase
     should "not choke on normal values in hash when calling #each" do
       simple1 = SimpleKey.create
       @faux.dictionary[simple1] = 33
-      reload
+      checkpoint!
       @faux.dictionary.each{|key, value| }
       assert true, "choked on normal values in #each"
     end
-    
+
     should "persist changes to maps" do
       simple1 = SimpleKey.create
       @faux.dictionary[simple1] = 33
-      reload
+      checkpoint!
       @faux.dictionary[simple1] = 50
-      reload
+      checkpoint!
       assert_equal 50, @faux.dictionary[simple1]
     end
+
+    should "persist changes to lists" do
+      has_fauxsql = OtherFauxObject.create
+      @faux.things << :hello
+      @faux.things << has_fauxsql
+      @faux.things << :goodbye
+      checkpoint!
+      @faux.things.clear
+      checkpoint!
+      assert_equal [], @faux.things.all
+    end
+  
+    should "delete items from maps" do
+      simple1 = SimpleKey.create
+      @faux.dictionary[simple1] = 33
+      checkpoint!
+      @faux.dictionary.delete(simple1)
+      checkpoint!
+      assert_equal nil, @faux.dictionary[simple1]
+    end
+    
+    should "obey typecasting directives for attributes" do
+      @faux.number = "33"
+      checkpoint!
+      assert_equal 33, @faux.number
+    end
+    
+    should "obey typecasting directives for map values" do
+      @faux.numbers[:a] = "400"
+      checkpoint!
+      assert_equal 400, @faux.numbers[:a]
+    end
+    
+    should "obey typecasting directives for map keys" do
+      assert false
+    end
+    
+    should "obey typecasting directives for list items" do
+      assert false
+    end
+    
+    context "with :nested => *" do
+      context "on a map" do
+        should "accept nested attributes" do
+          other = FauxObject.create
+          @faux.dictionary = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id,
+            :value => "Nested"
+          }}
+          checkpoint!
+          assert_equal "Nested", @faux.dictionary[other]
+        end
+        
+        should "delete nested attributes" do
+          other = FauxObject.create
+          @faux.dictionary = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id,
+            :value => "Nested"
+          }}
+          checkpoint!
+          @faux.dictionary = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id,
+            :_delete => true
+          }}
+          checkpoint!
+          assert_equal [], @faux.dictionary.keys
+        end
+      end
+
+      context "on a list" do
+        should "accept nested attributes" do
+          other = FauxObject.create
+          @faux.things = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id
+          }}
+          checkpoint!
+          assert_equal [other], @faux.things.all
+        end        
+
+        should "delete nested attributes" do
+          other = FauxObject.create
+          @faux.things = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id
+          }}
+          checkpoint!
+          @faux.things = { "0" => {
+            :type => other.class.name,
+            "#{other.class.name}_id".intern => other.id,
+            :_delete => true
+          }}
+          checkpoint!
+          assert_equal [], @faux.things.all
+        end        
+      end
+      
+      context "on an attribute" do
+        should "accept nested attribute" do
+        assert false
+        #   other = FauxObject.create
+        #   @faux.record = {
+        #     :type => other.class.name,
+        #     "#{other.class.name}_id".intern => other.id
+        #   }
+        #   checkpoint!
+        #   assert_equal other, @faux.record
+        end
+        
+        should "delete nested attribute" do
+          assert false
+          # other = FauxObject.create
+          # @faux.record = {
+          #   :type => other.class.name,
+          #   "#{other.class.name}_id".intern => other.id
+          # }
+          # checkpoint!
+          # other = FauxObject.create
+          # @faux.record = {
+          #   :type => other.class.name,
+          #   "#{other.class.name}_id".intern => other.id,
+          #   :_delete => true
+          # }
+          # checkpoint!
+          # assert_equal nil, @faux.record
+        end
+      end
+    end
+        
+    context "with a manymany relationship" do
+      setup do
+        @faux =  FauxObject.create!
+        @other = FauxObject.create!
+        @faux.others << @other
+        checkpoint!
+      end
+      
+      should "associate manymany relationships" do
+        assert_equal [@faux], @other.others.all # LOL "LOST" JOKE
+        assert_equal [@other], @faux.others.all
+      end
+    
+      should "delete from manymany relationships" do
+        third = FauxObject.create
+        @faux.others << third
+        checkpoint!
+        @faux.others.delete(@other)
+        checkpoint!
+        third.save; third.reload
+        assert_equal [third], @faux.others.all
+        assert_equal [], @other.others.all
+      end
+      
+      # TODO think about paranoid deletion
+    end
+    
+    should "allow changing of hash key when key is record" do
+      assert false
+    end
+    
+    should "return keys for dictionary stores" do
+      @faux.dictionary['a'] = 1
+      @faux.dictionary['b'] = 1
+      @faux.dictionary['c'] = 1
+      checkpoint!
+      assert_equal ['a', 'b', 'c'], @faux.dictionary.keys
+    end
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Collin Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-20 00:00:00 -04:00
+date: 2010-05-06 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -87,12 +87,16 @@ files:
 - fauxsql.gemspec
 - lib/fauxsql.rb
 - lib/fauxsql/attribute_list.rb
+- lib/fauxsql/attribute_manymany.rb
 - lib/fauxsql/attribute_map.rb
 - lib/fauxsql/attribute_wrapper.rb
+- lib/fauxsql/attributes.rb
 - lib/fauxsql/dereferenced_attribute.rb
 - lib/fauxsql/dsl.rb
 - lib/fauxsql/list_wrapper.rb
+- lib/fauxsql/manymany_wrapper.rb
 - lib/fauxsql/map_wrapper.rb
+- lib/fauxsql/options.rb
 - test/helper.rb
 - test/test_fauxsql.rb
 has_rdoc: true