dm-appengine 0.0.7 → 0.0.8

data/Rakefile

@@ -5,7 +5,7 @@ require 'date'
 require 'spec/rake/spectask'
 
 GEM = "dm-appengine"
-GEM_VERSION = "0.0.7"
+GEM_VERSION = "0.0.8"
 AUTHOR = "Ryan Brown"
 EMAIL = "ribrdb@gmail.com"
 HOMEPAGE = "http://code.google.com/p/appengine-jruby"
@@ -23,13 +23,12 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
   
-  s.add_dependency("appengine-apis", ["~> 0.0.12"])
+  s.add_dependency("appengine-apis", ["~> 0.0.14"])
   s.add_dependency("dm-core", ["0.10.2"])
   
   s.require_path = 'lib'
   s.autorequire = GEM
-  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("spec/**/*") + 
-      %w(lib/appengine_adapter.rb lib/dm-appengine/types.rb)
+  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("spec/*.rb") + Dir.glob("lib/**/*.rb")
 end
 
 task :default => :spec

data/lib/appengine_adapter.rb

@@ -17,7 +17,8 @@
 #
 # Datamapper adapter for Google App Engine
 
-require 'date'
+autoload :Date, 'date'
+autoload :DateTime, 'date'
 require 'rubygems'
 require 'time'
 
@@ -26,6 +27,8 @@ require 'dm-core'
 require 'dm-appengine/types'
 
 module DataMapper
+  autoload(:AppEngineResource, 'dm-appengine/appengine_resource')
+  
   module Adapters
     class AppEngineAdapter < AbstractAdapter
       Datastore = AppEngine::Datastore
@@ -36,11 +39,6 @@ module DataMapper
           options = uri_or_options
           if options['host'] == 'memory'
             require 'appengine-apis/testing'
-            begin
-              AppEngine::ApiProxy.get_app_id
-            rescue NoMethodError
-              AppEngine::Testing::install_test_env
-            end
             AppEngine::Testing::install_test_datastore
           end
         end
@@ -66,13 +64,20 @@ module DataMapper
           keys = properties.key
           raise "Multiple keys in #{resource.inspect}" if keys.size > 1
           if keys.size == 1
-            key = attributes.delete(keys.first.name)
-            key = key.to_s if key
+            name = keys.first.name
+            property = properties[name]
+            key = convert_value(property, attributes.delete(name))
           end
-          if key && !(key == 0 || keys.first.serial?)
-            entity = Datastore::Entity.new(kind, key)
-          else
+          if key.nil? || keys.first.serial? || key==0
             entity = Datastore::Entity.new(kind)
+          elsif key.kind_of?(AppEngine::Datastore::Key)
+            entity = Datastore::Entity.new(key)
+          elsif key.kind_of?(Hash) && property.type == Types::Key
+            # AppEngine::Datastore::Key should already have filtered this.
+            # Since it didn't, we know it's a serial object with a parent.
+            entity = Datastore::Entity.new(kind, key[:parent])
+          else
+            entity = Datastore::Entity.new(kind, key)
           end
           
           attributes.each do |name, value|
@@ -88,6 +93,8 @@ module DataMapper
           key = entity.key
           if id = resource.model.serial(name)
             id.set!(resource, key.get_id)
+          elsif id = resource.model.key(name).find{|k|k.type == Types::Key}
+            id.set!(resource, key)
           end
           resource.instance_variable_set :@__entity__, entity
         end
@@ -242,14 +249,7 @@ module DataMapper
           unless property.key?
             raise ArgumentError, "#{property_name(property)} is not the key"
           end
-          case value
-          when Integer, String
-            Datastore::Key.from_path(@kind, value)
-          when Symbol
-            Datastore::Key.from_path(@kind, value.to_s)
-          else
-            raise ArgumentError, "Unsupported key value #{value.inspect} (a #{value.class})"
-          end
+          Types::Key.typecast(value, property)
         end
       
         def parse_or(or_op)
@@ -318,6 +318,8 @@ module DataMapper
         
           if op.kind_of?(InclusionComparison)
             parse_inclusion(op)
+          elsif property.type == Types::AncestorKey
+            @query.ancestor = value
           else
             if negated
               filter_op = @@NEGATED_OPERATORS[op.class]
@@ -406,7 +408,13 @@ module DataMapper
           @dm_query.fields.each do |property|
             name = property.field
             if property.key?
-              hash[name] = key.get_name || key.get_id
+              if property.serial?
+                hash[name] = key.get_id
+              elsif property.type == String
+                hash[name] = key.get_name
+              else
+                hash[name] = key
+              end
             else
               hash[name] = property.typecast(entity.get_property(name))
             end

data/lib/dm-appengine/appengine_resource.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Custom Resource class for App Engine.
+# Adds optimistic transactions and sane defaults for keys.
+# Thin wrapper around is(:entity), but it can be autoloaded.
+
+require 'dm-appengine/is_entity'
+
+module DataMapper
+  module AppEngineResource
+    
+    def self.included(klass)
+      klass.class_eval do
+        include DataMapper::Resource
+        is :entity
+      end
+    end
+    
+  end
+end

data/lib/dm-appengine/is_entity.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2010 David Masover
+# Original Author:: David Masover (mailto:ninja@slaphack.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module DataMapper
+  module Is
+    module Entity
+      DEFAULT_ENTITY_OPTIONS = {
+        :transaction => true,
+        :key => :id,
+        :parent => :parent,
+        :ancestor => :ancestor,
+        :descendants => :descendants
+      }.freeze
+      def is_entity(options={})
+        extend(ClassMethods)
+        
+        options = DEFAULT_ENTITY_OPTIONS.merge(options)
+        
+        # Override the builtin transactions
+        if options[:transaction]
+          include Transaction; extend Transaction
+        end
+        
+        # Pass :key_name => false if you don't want a key
+        if (key_name = options[:key])
+          primary_key(key_name)
+        end
+        
+        if (parent_name = options[:parent])
+          parent_property(parent_name)
+        end
+        
+        if (ancestor_name = options[:ancestor])
+          ancestor_property(ancestor_name)
+        end
+        
+        if (descendants_name = options[:descendants])
+          descendants_property(descendants_name)
+        end
+      end
+      
+      module ClassMethods
+        # Being somewhat more rigid here, because this really isn't that complicated (yet).
+        # TODO: If possible, a typeless query would be nice here.
+        def descendants_property(name)
+          define_method(name) do |type|
+            type.all(:ancestor => self.key.first)
+          end
+        end
+        
+        def has_descendants(name, options={})
+          model = options.delete(:model)  # or leave it nil
+          define_method(name) do
+            model ||= Extlib::Inflection.constantize(
+              Extlib::Inflection.camelize(
+                Extlib::Inflection.singularize(name.to_s)
+              )
+            )
+            model.all(options.merge(:ancestor => self.key.first))
+          end
+        end
+        
+        def ancestor_property(name)
+          property name, Types::AncestorKey
+          # We don't want to ever set this. It's just for queries.
+          undef_method name
+          undef_method :"#{name}="
+        end
+        
+        def primary_key(name)
+          property name, DataMapper::Types::Key, :key => true
+        end
+        
+        def parent_property(name)
+          define_method("#{name}_id") do
+            k = key.first
+            k.kind_of?(AppEngine::Datastore::Key) && k.parent
+          end
+          
+          belongs_to_entity(name, false)
+        end
+        
+        # Polymorphic belongs_to hack.
+        # (Datamapper doesn't support polymorphic associations, probably by design.)
+        # We already have the type in the key_name anyway.
+        # has(n) works at the other end, just set child_key.
+        def belongs_to_entity(name, add_id_property=true)
+          key_getter = :"#{name}_id"
+          key_setter = :"#{key_getter}="
+          variable = :"@#{name}"
+          
+          if add_id_property
+            property key_getter, Types::Key
+          end
+          
+          define_method(name) do
+            value = instance_variable_get(variable)
+            return value if value
+            
+            key = send(key_getter)
+            # All keys are polymorphic
+            value = Extlib::Inflection.constantize(Extlib::Inflection.singularize(key.kind)).get(key)
+            instance_variable_set(variable, value)
+          end
+          
+          define_method(:"#{name}=") do |value|
+            send(key_setter, value.key.first)
+            instance_variable_set(variable, value)
+          end
+        end
+      end
+      
+      module Transaction
+        def transaction(retries=3, &block)
+          AppEngine::Datastore.transaction(retries, &block)
+        end
+      end
+    end
+  end
+  
+  Model.append_extensions(Is::Entity)
+end

data/lib/dm-appengine/types.rb

@@ -18,6 +18,7 @@
 # Custom types for App Engine
 
 require 'dm-core/type' unless defined? DataMapper::Type::PROPERTY_OPTIONS
+require 'dm-core/property' unless defined? DataMapper::Property::PRIMITIVES
 
 module DataMapper
   module Types
@@ -113,7 +114,88 @@ module DataMapper
       end
     end
     
-    IMHandle = GeoPt = Key = User = AppEngineNativeType
+    IMHandle = GeoPt = User = AppEngineNativeType
+    
+    class Key < Type
+      primitive AppEngine::Datastore::Key
+      
+      def self.dump(value, property)
+        property.typecast(value)
+      end
+      
+      def self.load(value, property)
+        value
+      end
+      
+      def self.typecast(value, property)
+        case value
+        when AppEngine::Datastore::Key, NilClass
+          value
+        when Integer, String
+          AppEngine::Datastore::Key.from_path(kind(property), value)
+        when Symbol
+          AppEngine::Datastore::Key.from_path(kind(property), value.to_s)
+        when Hash
+          parent = property.typecast(value[:parent])
+          id = value[:id]
+          name = value[:name]
+          if id
+            id_or_name = id.to_i
+          elsif name
+            id_or_name = name.to_s
+          end
+          if parent
+            if id_or_name || (!property.key?)
+              parent.getChild(kind(property), id_or_name)
+            else
+              # TODO: is it sane to not typecast this?
+              value
+            end
+          else
+            property.typecast(id_or_name)
+          end
+        else
+          raise ArgumentError, "Unsupported key value #{value.inspect} (a #{value.class})"
+        end
+      end
+      
+      def self.kind(property)
+        property.model.repository.adapter.kind(property.model)
+      end
+    end
+    
+    # Hacks for primitive types.
+    # AppEngine::Datastore::Key truly IS a primitive,
+    # as far as AppEngine is concerned.
+    original_primitives = Property::PRIMITIVES
+    Property::PRIMITIVES = (original_primitives.dup << AppEngine::Datastore::Key).freeze
+    
+    # Hack to allow a property defined as AppEngine::Datastore::Key to work.
+    # This is needed for associations -- child_key tries to define it as
+    # the primitive of the parent key type. It then takes that type name and
+    # tries to resolve it in DM::Types, so we catch it here.
+    module Java
+      module ComGoogleAppengineApiDatastore
+      end
+    end
+    Java::ComGoogleAppengineApiDatastore::Key = Key
+    
+    # Should NOT be used directly!
+    # Also, should be sharing these better...
+    class AncestorKey < Type
+      primitive AppEngine::Datastore::Key
+      def self.dump(value, property)
+        property.typecast(value)
+      end
+      
+      def self.load(value, property)
+        value
+      end
+      
+      def self.typecast(value, property)
+        Key.typecast(value, property)
+      end
+    end
     
     # TODO store user as email and id?
   end

data/spec/dm-appengine_spec.rb

@@ -47,6 +47,8 @@ class TypeTest
   property :im, IMHandle
   property :point, GeoPt
   property :user, User
+  # the 'key' method is already defined on DataMapper::Resource.
+  property :key_property, Key
 end
 
 class Flower
@@ -60,6 +62,13 @@ class FooBar
   property :string, String
 end
 
+class KeyTest
+  include DataMapper::Resource
+  
+  property :appengine_key, Key, :key => true
+  property :string, String
+end
+
 describe DataMapper::Adapters::AppEngineAdapter do
   before :all do
     AppEngine::Testing.install_test_env
@@ -262,5 +271,151 @@ describe DataMapper::Adapters::AppEngineAdapter do
       a.point.latitude.should be_close(latitude, 0.1)
       a.point.longitude.should be_close(longitude, 0.1)
     end
+    
+    it "should support Key" do
+      obj = AppEngine::Datastore::Entity.new('Key Test')
+      AppEngine::Datastore.put obj
+      key = obj.key
+      a = TypeTest.new(:name => 'key', :key_property => key)
+      a.save
+      a.reload
+      a.key_property.should == key
+    end
+  end
+  
+  describe 'primary keys' do
+    before :each do 
+      @resource = KeyTest.new(:appengine_key => AppEngine::Datastore::Key.from_path('KeyTests', 'Foo'))
+    end
+    
+    it 'should support AppEngine::Datastore::Key' do
+      @resource.string = 'Make sure it has some data.'
+      @resource.save
+      @resource.reload
+      @resource.string.should == 'Make sure it has some data.'
+    end
+    
+    it 'should be an AppEngine::Datastore::Key under the hood' do
+      @resource.appengine_key.should be_a(AppEngine::Datastore::Key)
+      key = @resource.appengine_key
+      @resource.save
+      @resource.reload
+      @resource.appengine_key.should be_a(AppEngine::Datastore::Key)
+      @resource.appengine_key.should == key
+    end
+    
+    it "shouldn't save keys as actual entity properties" do
+      @resource.save
+      entity = AppEngine::Datastore.get(@resource.appengine_key)
+      entity.should_not have_property(:appengine_key)
+    end
+    
+    it 'should be possible to query by string' do
+      @resource.string = 'Querying by string'
+      @resource.save
+      fetched = KeyTest.get 'Foo'
+      fetched.string.should == 'Querying by string'
+    end
+    
+    it 'should be possible save by string' do
+      @resource.appengine_key = 'Bar'
+      @resource.string = 'Saving by string'
+      @resource.save
+      fetched = KeyTest.get 'Bar'
+      fetched.string.should == 'Saving by string'
+      fetched.appengine_key.should be_kind_of AppEngine::Datastore::Key
+    end
+    
+    it 'should be possible to save and query by id' do
+      @resource.appengine_key = 10
+      @resource.string = 'Querying by id'
+      @resource.save
+      fetched = KeyTest.get 10
+      fetched.string.should == 'Querying by id'
+      fetched.appengine_key.should be_kind_of AppEngine::Datastore::Key
+    end
+    
+    describe 'should support creating and fetching resources by Hash' do
+      it 'with parents' do
+        @resource.save
+        child = KeyTest.new
+        child.appengine_key = {:parent => @resource.appengine_key, :name => 'Child!'}
+        child.string = 'Some more data.'
+        child.save
+        child.reload
+        child = KeyTest.get :parent => @resource.appengine_key, :name => 'Child!'
+        child.string.should == 'Some more data.'
+      end
+      
+      it 'with ids instead of names' do
+        @resource.appengine_key = {:id => 5}
+        @resource.string = 'Even more data.'
+        @resource.save
+        @resource.reload
+        @resource.string.should == 'Even more data.'
+      end
+      
+      it 'without forgetting about parents' do
+        @resource.save
+        child = KeyTest.new
+        child.appengine_key = {:parent => @resource.appengine_key, :name => 'Child!'}
+        child.appengine_key.parent.should == @resource.appengine_key
+        child.string = "don't forget"
+        child.save
+        child.reload
+        child.string.should == "don't forget"
+        child.appengine_key.parent.should == @resource.appengine_key
+        child.appengine_key.parent.should_not be_nil
+      end
+    end
+    
+    it 'should typecast hash values' do
+      @resource.appengine_key = {:id => '5'}
+      @resource.string = 'Typecasting hash values.'
+      @resource.save
+      fetched = KeyTest.get 5
+      fetched.string.should == 'Typecasting hash values.'
+      @resource.appengine_key.id.should be 5
+    end
+    
+    it 'should allow nil (autoincrementing ids), even with parents' do
+      @resource.save
+      child = KeyTest.new
+      child.appengine_key = {:parent => @resource.appengine_key}
+      child.string = 'Should allow nil'
+      child.save
+      child.appengine_key.id.should_not be_nil
+      child.reload
+      child.string.should == 'Should allow nil'
+    end
+    
+    it 'should work when the key is not set at all' do
+      a = KeyTest.create(:string => 'Completely nil key')
+      a.save
+      a.reload
+      a.string.should == 'Completely nil key'
+      a.appengine_key.should_not be_nil
+      a.appengine_key.id.should_not be_nil
+      a.appengine_key.id.should be > 0
+    end
+    
+    # Probably not comprehensive.
+    # The idea is that if neither name nor id is specified,
+    # leave it nil and let the key be generated when it's saved.
+    it "shouldn't create serial keys until the entity is saved, even with a parent" do
+      AppEngine::Datastore::Key.should_not_receive :from_path
+      parent = KeyTest.create(:string => 'foo')
+      key = parent.appengine_key
+      key.should be_kind_of AppEngine::Datastore::Key
+      key.should_not_receive :getChild
+      
+      child = KeyTest.create(:appengine_key => {:parent => key})
+      child_key = child.appengine_key
+      child_key.should be_kind_of AppEngine::Datastore::Key
+      child_key.parent.should == key
+      
+      child_key.id.should_not be_nil
+      child_key.id.should be > 0
+    end
   end
 end

data/spec/dm-is-entity_spec.rb

@@ -0,0 +1,215 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 David Masover
+# Original Author:: David Masover (mailto:ninja@slaphack.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.dirname(__FILE__) + '/spec_helper'
+require 'dm-appengine/is_entity'
+
+class VanillaTest
+  include DataMapper::Resource
+  is :entity
+  property :string, String
+end
+
+class AppEngineResourceTest
+  include DataMapper::AppEngineResource
+  property :string, String
+end
+
+class HasManyTest
+  include DataMapper::AppEngineResource
+  property :string, String
+  has n, :belongs_to_tests
+end
+
+class BelongsToTest
+  include DataMapper::AppEngineResource
+  property :string, String
+  belongs_to :has_many_test
+end
+
+class Post
+  include DataMapper::AppEngineResource
+  property :title, String
+  property :body, Text
+  has n, :comments, :child_key => [:commentable_id]
+end
+
+class Image
+  include DataMapper::AppEngineResource
+  property :name, String
+  property :url, Link
+  has n, :comments, :child_key => [:commentable_id]
+end
+
+class Comment
+  include DataMapper::AppEngineResource
+  property :subject, String
+  property :body, Text
+  belongs_to_entity :commentable
+end
+
+class User
+  include DataMapper::AppEngineResource
+  property :name, String
+  
+  has_descendants :settings
+end
+
+class Setting
+  include DataMapper::AppEngineResource
+  property :value, String
+end
+
+describe 'An is(:entity) model' do
+  it 'should work without anything special' do
+    a = VanillaTest.create(:string => 'Plain Vanilla Test')
+    a.reload
+    a.string.should == 'Plain Vanilla Test'
+    a.id.should_not be_nil
+    a.id.should be_kind_of AppEngine::Datastore::Key
+  end
+  
+  describe 'in a relationship' do
+    before :each do
+      @parent = HasManyTest.create(:string => 'the parent')
+      @child = @parent.belongs_to_tests.create(:string => 'the child')
+    end
+    
+    it 'should have the parent' do
+      @child.reload
+      @child.has_many_test.should == @parent
+    end
+    
+    it 'should have the parent_id' do
+      @child.reload
+      @child.has_many_test_id.should == @parent.id
+      @child.has_many_test_id.should be_kind_of AppEngine::Datastore::Key
+    end
+    
+    it 'should have the child' do
+      @parent.belongs_to_tests.create(:string => 'another child')
+      parent = HasManyTest.get(@parent.id)
+      child_one = parent.belongs_to_tests.all(:string => 'the child')
+      child_one.count.should == 1
+      child_one.first.string.should == 'the child'
+    end
+  end
+  
+  describe 'with a polymorphic owner' do
+    before :each do
+      @post = Post.create(:title => 'I saw an image today', :body => 'and it was ugly.')
+      @post_comment = @post.comments.create(:subject => "No, it wasn't!", :body => 'it was beautiful!')
+      @image = Image.create(:name => 'Ugly image', :url => 'http://example.com/UGLY.png')
+      @image_comment = @image.comments.create(:subject => 'Beautiful', :body => 'I was touched!')
+    end
+    
+    it 'should reload properly' do
+      @post.reload.title.should == 'I saw an image today'
+      @post_comment.reload.subject.should == "No, it wasn't!"
+      @image.reload.name.should == 'Ugly image'
+      @image_comment.reload.subject.should == 'Beautiful'
+    end
+    
+    it 'should have the right children' do
+      @post.reload
+      @image.reload
+      
+      @post.comments.count.should == 1
+      @image.comments.count.should == 1
+      @post.comments.first.subject.should == @post_comment.subject
+      @image.comments.first.subject.should == @image_comment.subject
+    end
+    
+    it 'should have the right parents' do
+      @post_comment.reload.commentable.should == @post
+      @image_comment.reload.commentable.should == @image
+    end
+    
+    # This can happen when you forget to set child_key.
+    it "shouldn't have extra keys" do
+      [@post_comment, @image_comment].each do |comment|
+        properties = comment.send(:properties).map(&:name)
+        properties.should include :commentable_id
+        properties.should_not include :post_id
+        properties.should_not include :image_id
+      end
+    end
+  end
+  
+  describe 'with a parent' do
+    before :each do
+      @parent = VanillaTest.create(:string => 'Plain vanilla parent')
+      @child = VanillaTest.create(:id => {:parent => @parent.id}, :string => 'Plain vanilla child')
+    end
+    
+    it 'should work' do
+      @parent.reload.string.should == 'Plain vanilla parent'
+      @child.reload.string.should == 'Plain vanilla child'
+    end
+    
+    it 'should have the parent' do
+      @child.reload.parent.should == @parent
+    end
+    
+    it 'should be visible with an ancestor query' do
+      VanillaTest.all(:ancestor => @parent.id).should include @child
+      # Note: "ancestor" queries appear to include self.
+    end
+    
+    it 'should be visible with a "descendant" query' do
+      @parent.descendants(VanillaTest).should include @child
+    end
+    
+    # TODO: break into smaller specs
+    it "shouldn't include the whole world as siblings" do
+      stranger = VanillaTest.create(:string => 'Strange vanilla child')
+      children = VanillaTest.all(:ancestor => @parent.id)
+      children.should_not include stranger
+      children.none?{|x| x.string == 'Strange vanilla child'}.should be true
+      
+      stranger.update(:string => 'Plain vanilla child')
+      plain = VanillaTest.all(:string => 'Plain vanilla child')
+      plain.should include stranger
+      plain.should include @child
+      
+      our_plain = VanillaTest.all(:ancestor => @parent.id, :string => 'Plain vanilla child')
+      our_plain.should_not include stranger
+      our_plain.should include @child
+    end
+  end
+  
+  describe 'with has_descendants' do
+    before :each do
+      @user = User.create(:name => 'Billy')
+      @setting = Setting.create(:id => {:parent => @user.id, :name => 'displayname'}, :value => 'John')
+    end
+    
+    it 'should be possible to find the appropriate descendants' do
+      @user.settings.count.should == 1
+      @user.settings.first.should == @setting
+      @user.settings.first.value.should == 'John'
+    end
+  end
+end
+
+describe DataMapper::AppEngineResource do
+  it 'should work just like the vanilla test' do
+    a = AppEngineResourceTest.create(:string => 'AppEngineResource test')
+    a.reload
+    a.string.should == 'AppEngineResource test'
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: dm-appengine
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Ryan Brown
@@ -9,29 +14,37 @@ autorequire: dm-appengine
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 -08:00
+date: 2010-04-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: appengine-apis
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.0.12
-    version: 
+        segments: 
+        - 0
+        - 0
+        - 14
+        version: 0.0.14
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: dm-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
         version: 0.10.2
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: A DataMapper adapter for Google App Engine
 email: ribrdb@gmail.com
 executables: []
@@ -46,8 +59,11 @@ files:
 - README.rdoc
 - Rakefile
 - spec/dm-appengine_spec.rb
+- spec/dm-is-entity_spec.rb
 - spec/spec_helper.rb
 - lib/appengine_adapter.rb
+- lib/dm-appengine/appengine_resource.rb
+- lib/dm-appengine/is_entity.rb
 - lib/dm-appengine/types.rb
 has_rdoc: true
 homepage: http://code.google.com/p/appengine-jruby
@@ -62,18 +78,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A DataMapper adapter for Google App Engine