datamapper4rail 0.1.0 → 0.2.0

data/Manifest.txt

@@ -18,5 +18,11 @@ lib/datamapper4rails/adapters/base_adapter.rb
 lib/datamapper4rails/adapters/restful_adapter.rb
 lib/datamapper4rails/database_config.rb
 lib/datamapper4rails/datamapper_store.rb
+lib/datamapper4rails/identity_maps.rb
+lib/datamapper4rails/preload_models.rb
 lib/datamapper4rails/restful_transactions.rb
 lib/datamapper4rails/version.rb
+spec/datamapper_store_spec.rb
+spec/restful_adapter_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/Rakefile

@@ -2,6 +2,11 @@
 
 require 'rubygems'
 require 'hoe'
+
+require 'spec'
+require 'spec/rake/spectask'
+require 'pathname'
+
 require './lib/datamapper4rails/version.rb'
 
 Hoe.new('datamapper4rail', Datamapper4rails::VERSION) do |p|
@@ -17,16 +22,16 @@ task :install => [:clean, :package] do
   sh "gem install --local #{gem} --no-ri --no-rdoc"
 end
 
-# desc 'Run specifications'
-# Spec::Rake::SpecTask.new(:spec) do |t|
-#   if File.exists?('spec/spec.opts')
-#     t.spec_opts << '--options' << 'spec/spec.opts'
-#   end
-#   t.spec_files = Pathname.glob('./spec/**/*_spec.rb')
-# end
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  if File.exists?('spec/spec.opts')
+    t.spec_opts << '--options' << 'spec/spec.opts'
+  end
+  t.spec_files = Pathname.glob('./spec/**/*_spec.rb')
+end
 
-# require 'yard'
+require 'yard'
 
-# YARD::Rake::YardocTask.new
+YARD::Rake::YardocTask.new
 
 # vim: syntax=Ruby

data/generators/rspec_dm_model/rspec_dm_model_generator.rb

@@ -2,13 +2,13 @@ require 'rails_generator/generators/components/model/model_generator'
 require 'active_record'
 require File.dirname(__FILE__) + '/../rspec_default_values'
 
-class RspecDmModelExtendedGenerator <ModelGenerator
+class RspecDmModelGenerator <ModelGenerator
 
   def manifest
     record do |m|
 
       # Check for class naming collisions.
-      m.class_collisions class_path, class_name
+      #m.class_collisions class_path, class_name
 
       # Model, spec, and fixture directories.
       m.directory File.join('app/models', class_path)

data/generators/rspec_dm_model/templates/model.rb

@@ -1,16 +1,19 @@
 class <%= class_name %>
   include DataMapper::Resource
+<% if options[:add_constraints] -%>
+  include DataMapper::Constraints
+<% end -%>
+
   property :id, Serial
 
 <% for attribute in attributes -%>
-  property :<%= attribute.name %>, <%= attribute.type.to_s.camelize %>, :nullable => false <% if attribute.type == :string or attribute.type == :text -%>, :format => /^[^<'&">]*$/<% if attribute.type == :string %>, :length => 50<% end -%>
-<% else -%>
+  property :<%= attribute.name %>, <%= attribute.type.to_s.camelize %>, :nullable => false <% if attribute.type == :string or attribute.type == :text -%>, :format => /^[^<'&">]*$/<% if attribute.type == :string %>, :length => 255<% end -%>
+<% #else -%>
 
 <% end -%>
 <% end -%>
 <% unless options[:skip_timestamps] %>
-  property :created_at, DateTime, :nullable => false
-  property :updated_at, DateTime, :nullable => false
+  timestamps :at
 
 <% end -%>
 end

data/lib/datamapper4rails.rb

@@ -1,53 +1 @@
-require 'dm-core'
-def config_file()
-  RAILS_ROOT + "/config/database.yml"
-end
-
-def create_connection()
-  conf = config.dup
-  if repositories = conf.delete(:repositories)
-    repositories.each do |repo, conf|
-      ::DataMapper.setup(repo, conf) unless conf.empty?
-    end
-  else
-    ::DataMapper.setup(:default, conf) unless conf.empty?
-  end
-end
-
-def get_config_for_environment
-  if hash = full_config[RAILS_ENV]
-    symbolize_keys(hash)
-  elsif hash = full_config[RAILS_ENV.to_sym]
-    hash
-  else
-    raise ArgumentError, "missing environment '#{RAILS_ENV}' in config file #{config_file}"
-  end
-end
-
-def full_config
-  @full_config ||= YAML::load(ERB.new(IO.read(config_file)).result)
-end
-
-def config
-  @config ||= get_config_for_environment
-end
-
-def symbolize_keys(h)
-  config = {}
-
-  h.each do |k, v|
-    if k == 'port'
-      config[k.to_sym] = v.to_i
-    elsif k == 'adapter' && v == 'postgresql'
-      config[k.to_sym] = 'postgres'
-    elsif v.is_a?(Hash)
-      config[k.to_sym] = symbolize_keys(v)
-    else
-      config[k.to_sym] = v
-    end
-  end
-
-  config
-end
-
-create_connection()
+require 'datamapper4rails/database_config'

data/lib/datamapper4rails/adapters/restful_adapter.rb

@@ -1,7 +1,8 @@
-require 'adapters/restful_adapter'
+require 'datamapper4rails/adapters/base_adapter'
 require 'net/http'
 require 'extlib/inflection'
 require 'extlib/module'
+require 'dm-serializer'
 
 module DataMapper
   module Adapters
@@ -44,6 +45,18 @@ module DataMapper
           raise "compound keys are not supported"
         end
       end
+      
+      def single_entity_query?(query)
+        query.conditions.count {|c| c[1].key? and c[0] == :eql} == query.model.key.size
+      end
+
+      def attributes_to_xml(name, attributes)
+        xml = "<#{name}>"
+        attributes.each do |attr, val|
+          xml += "<#{attr.name}>#{val}</#{attr.name}>"
+        end
+        xml += "</#{name}>"
+      end
 
       def http_get(uri)
         send_request do |http|
@@ -66,13 +79,16 @@ module DataMapper
         end
       end
 
-      def http_put(uri, data = {})
+      def http_put(uri, data = nil)
         send_request do |http|
-          request = Net::HTTP::Put.new(uri)
+          request = Net::HTTP::Put.new(uri, {
+                                          'content-type' => 'application/xml',
+                                          'content-length' => data.length.to_s
+                                        })
           request.basic_auth(@uri[:login], 
                              @uri[:password]) unless @uri[:login].blank?
-          request.set_form_data(data)
-          http.request(request)
+#          request.set_form_data(data)
+          http.request(request, data)
         end
       end
 
@@ -112,14 +128,25 @@ module DataMapper
 #puts
 #puts "elements"
 #p elements
+#p query
+#p model
         resource = model.load(model.properties.collect do |f|
                                   elements[f.name]
                                 end, query)
         resource.send("#{keys_from_query(query)[0].name}=".to_sym, elements[keys_from_query(query)[0].name] )
-#p resource
-        associations.each do |name, association|          
-          model = 
+# p resource
+#p associations
+        associations.each do |name, association| 
+#          puts "asso"
+#          p model
+#          p name
+#          p association
+#p model.relationships
+          is_one_to_one = false
+          asso_model = 
             if rel = model.relationships[name]
+#puts "rel"
+#p rel
               if rel.child_model == model
                 rel.parent_model
               else
@@ -129,17 +156,38 @@ module DataMapper
 #::Extlib::Inflection.constantize(::Extlib::Inflection.classify(name))
 #                    model.find_const(::Extlib::Inflection.classify(name))
             end
+  #        p asso_model
           if resource.respond_to? "#{name}=".to_sym
+           #  puts
+#             puts "association"
+#             puts name
+#             p model
+#             p asso_model
             resource.send("#{name}=".to_sym, 
-                          parse_resource(association, model,
-                                         ::DataMapper::Query.new(query.repository, model )))
+                          parse_resource(association, asso_model,
+                                         ::DataMapper::Query.new(query.repository, asso_model ))) unless asso_model.nil?
           else
             resource.send(("#{name.to_s.pluralize}<" + "<").to_sym, 
-                          parse_resource(association, model,
-                                         ::DataMapper::Query.new(query.repository, model )))
+                          parse_resource(association, asso_model,
+                                         ::DataMapper::Query.new(query.repository, asso_model ))) unless asso_model.nil?
+          end
+        end
+
+#puts "many 2 many"
+#p many_to_many
+        many_to_many.each do |name, many|
+          if model.relationships[name]
+            # TODO
+          else
+ #           p ::Extlib::Inflection.classify(name.to_s.singularize)
+            many_model = Object.const_get(::Extlib::Inflection.classify(name.to_s.singularize))
+            resource.send(name).send(("<" + "<").to_sym, 
+                       parse_resource(many, many_model,
+                                      ::DataMapper::Query.new(query.repository, many_model ))) unless many_model.nil?
           end
         end
         resource.instance_variable_set(:@new_record, false)
+#p resource
         resource
       end
 
@@ -168,65 +216,70 @@ module DataMapper
 
       # @see BaseAdapter
       def read_resource(query)
-        if(query.conditions.empty?)
-          raise "not implemented"
+        key = key_value_from_query(query)
+        uri = "/#{resource_name_from_query(query).pluralize}/#{key}.xml"
+        logger.debug { "get #{uri}" }
+        response = http_get(uri)
+        if response.kind_of?(Net::HTTPSuccess)
+          logger.debug { response.body.to_s }
+          parse_resource(REXML::Document::new(response.body).root, 
+                         query.model, 
+                         query)
         else
-          key = key_value_from_query(query)
-          uri = "/#{resource_name_from_query(query).pluralize}/#{key}.xml"
+            #TODO may act on different response codes differently
+        end
+      end
+
+      # @see BaseAdapter
+      def read_resources(query)
+        if single_entity_query?(query)
+          [read_resource(query)]
+        else
+          uri = "/#{resource_name_from_query(query).pluralize}.xml"
           logger.debug { "get #{uri}" }
           response = http_get(uri)
           if response.kind_of?(Net::HTTPSuccess)
-            parse_resource(REXML::Document::new(response.body).root, 
-                           query.model, 
-                           query)
+            result = []
+            logger.debug { response.body.to_s }
+            REXML::Document::new(response.body).root.each do |element|
+              result << parse_resource(element, 
+                                       query.model, 
+                                       query)
+            end
+            result
           else
             #TODO may act on different response codes differently
           end
         end
       end
 
-      # @see BaseAdapter
-      def read_resources(query)
-#        raise "not implemented"
-        [read_resource(query)]
-      end
-
       # @overwrite BaseAdapter
       def update(attributes, query)
-        name = resource_name_from_query(query)
-        params = {}
-        attributes.each do |attr, val|
-          params["#{name}[#{attr.name}]"]=val
+        if query.limit == 1 or single_entity_query?(query)
+          xml = attributes_to_xml(resource_name_from_query(query), attributes)
+          key = key_value_from_query(query)
+          uri = "/#{resource_name_from_query(query).pluralize}/#{key}.xml"
+          logger.debug { "put #{uri}" }
+          response = http_put(uri, xml)
+          response.kind_of?(Net::HTTPSuccess)
+        else
+          super
         end
-        key = key_value_from_query(query)
-        uri = "/#{name.pluralize}/#{key}.xml"
-        logger.debug { "put #{uri}" }
-        response = http_put(uri, params)
-        response.kind_of?(Net::HTTPSuccess)
       end
 
       # @see BaseAdapter
       def update_resource(resource, attributes)
         query = resource.to_query
-        if(query.conditions.empty?)
-          raise "not implemented"
-        else
-          name = resource.name
-          params = {}
-          attributes.each do |attr, val|
-            params["#{name}[#{attr.name}]"]=val
-          end
-          key = key_value_from_query(query)
-          logger.debug {resource.to_xml}
-          response = http_put("/#{resource_name_from_query(query).pluralize}/#{key}.xml", params)
-          response.kind_of?(Net::HTTPSuccess)
-        end
+        xml = attributes_to_xml(resource.name, attributes)
+        key = key_value_from_query(query)
+        logger.debug {resource.to_xml}
+        response = http_put("/#{resource_name_from_query(query).pluralize}/#{key}.xml", xml)
+        response.kind_of?(Net::HTTPSuccess)
       end
-
+      
       # @overwrite BaseAdapter
       def delete(query)
-        # TODO limit == 1 is NOT sufficient ONLY necessary
-        if query.limit == 1 
+        if query.limit == 1 or single_entity_query?(query)
           name = resource_name_from_query(query)
           key = key_value_from_query(query)
           uri = "/#{name.pluralize}/#{key}.xml"
@@ -241,7 +294,7 @@ module DataMapper
       # @see BaseAdapter
       def delete_resource(resource)
         name = resource.name
-        key = key_value_from_query(resource.to_queryquery)
+        key = key_value_from_query(resource.to_query)
         uri = "/#{name.pluralize}/#{key}.xml"
         logger.debug { "delete #{uri}" }
         response = http_delete(uri)

data/lib/datamapper4rails/database_config.rb

@@ -6,8 +6,13 @@ end
 
 def create_connection()
   conf = config.dup
-  repositories = conf.delete(:repositories)
-  ::DataMapper.setup(:default, conf) unless conf.empty?
+  if repositories = conf.delete(:repositories)
+    repositories.each do |repo, conf|
+      ::DataMapper.setup(repo, conf) unless conf.empty?
+    end
+  else
+    ::DataMapper.setup(:default, conf) unless conf.empty?
+  end
 end
 
 def get_config_for_environment

data/lib/datamapper4rails/datamapper_store.rb

@@ -8,8 +8,10 @@ module ActionController
         super
         if options.delete(:cache)
           @@cache = {}
+        else
+          @@cache = nil unless self.class.class_variable_defined? :@@cache
         end
-        @@session_class = ::DatamapperStore::Session
+        @@session_class = options.delete(:session_class) || ::DatamapperStore::Session unless (self.class.class_variable_defined? :@@session_class and @@session_class)
       end
       
       private
@@ -32,10 +34,8 @@ module ActionController
             @@session_class.get(sid)
           end || @@session_class.new(:session_id => sid)
         session.data = session_data || {}
-        if session.new_record?
-          session.updated_at = Time.now
-          @@cache[sid] = session if @@cache
-        end
+        session.updated_at = Time.now if session.dirty?
+        @@cache[sid] = session if @@cache
         session.save
       end
     end
@@ -60,6 +60,7 @@ module DatamapperStore
     def data=(data)
       attribute_set(:data, ::Base64.encode64(Marshal.dump(data)))
     end
+
     def data
       Marshal.load(::Base64.decode64(attribute_get(:data)))
     end

data/lib/datamapper4rails/identity_maps.rb

@@ -0,0 +1,23 @@
+module Datamapper4rails
+  module IdentityMaps
+
+    module Base
+      def self.included(base)
+        base.prepend_around_filter(IdentityMapFilter)
+      end
+    end
+  
+    class IdentityMapFilter
+
+      def self.filter(controller)
+        DataMapper.repository(:default) do |*block_args|
+          if block_given? 
+            yield (*block_args)
+          end
+        end
+      end
+    end
+  end
+end
+
+::ActionController::Base.send(:include, Datamapper4rails::IdentityMaps::Base)

data/lib/datamapper4rails/preload_models.rb

@@ -0,0 +1,26 @@
+# load all models before each request so relations in datamapper find their classes
+MODELS = []
+Dir[RAILS_ROOT + "/app/models/**/*.rb"].each do |model|
+  model.sub!(/.*models\//, '').sub!(/.rb/, '')
+  m = ::Extlib::Inflection.classify(model.to_s)
+  MODELS << m
+  Object.const_get(m)
+end
+
+module ModelLoader
+  module Base
+    def self.included(base)
+      base.prepend_before_filter(ModelLoaderFilter)
+    end
+  end
+  
+  class ModelLoaderFilter
+    def self.filter(controller)
+      MODELS.each do |model|
+        Object.const_get(model)
+      end
+    end
+  end
+end
+
+::ActionController::Base.send(:include, ModelLoader::Base)

data/lib/datamapper4rails/restful_transactions.rb

@@ -11,17 +11,18 @@ module Datamapper4rails
     end
   
     class TransactionFilter
+
       def self.filter(controller)
         case controller.request.method
         when :post, :put, :delete then
           begin
+            # TODO remove the :default repository and make it more general
             DataMapper::Transaction.new(DataMapper.repository(:default)) do |*block_args|
               if block_given? 
                 yield (*block_args)
                 # added rollback for all actions which just render
-                # a page with validation errors and do not redirect to new idem potent 
-                # page (http-method get is idem potent within the
-                # restful paradigma
+                # a page (with validation errors) and do not redirect to
+                # another page
                 unless controller.response.redirected_to
                   raise Datamapper4rails::RestfulTransactions::Rollback      
                 end

data/lib/datamapper4rails/version.rb

@@ -1,3 +1,3 @@
 class Datamapper4rails
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/datamapper_store_spec.rb

@@ -0,0 +1,127 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'spec_helper'
+require 'datamapper4rails/datamapper_store'
+
+describe DatamapperStore do
+
+  before :each do
+    load 'lib/datamapper4rails/datamapper_store.rb'
+    ActionController::Session::DatamapperStore.send(:class_variable_set, :@@session_class, nil)
+  end
+
+  it 'should initialize with no cache and default session class' do
+    store = ActionController::Session::DatamapperStore.new(nil)
+    store.class.send(:class_variable_get, :@@cache).should be_nil
+    store.class.send(:class_variable_get, :@@session_class).should == DatamapperStore::Session
+
+    store = ActionController::Session::DatamapperStore.new(nil, :session_class => :some_class)
+    store.class.send(:class_variable_get, :@@cache).should be_nil
+    store.class.send(:class_variable_get, :@@session_class).should == DatamapperStore::Session
+  end
+
+  it 'should initialize with cache and default session class' do
+    store = ActionController::Session::DatamapperStore.new(nil, :cache => true)
+    store.class.send(:class_variable_get, :@@cache).instance_of?(Hash).should be_true
+
+    store = ActionController::Session::DatamapperStore.new(nil)
+    store.class.send(:class_variable_get, :@@cache).instance_of?(Hash).should be_true
+  end
+
+  it 'should initialize with custom session class' do
+    store = ActionController::Session::DatamapperStore.new(nil, :session_class => Session)
+    store.class.send(:class_variable_get, :@@session_class).should == Session
+
+    store = ActionController::Session::DatamapperStore.new(nil, :session_class => :some_class)
+    store.class.send(:class_variable_get, :@@session_class).should == Session
+  end
+end
+
+describe 'DatamapperStore without cache' do
+
+  def mock_session(stubs={})
+    @mock_session ||= mock(Session, stubs)
+  end
+
+  before :each do
+    load 'lib/datamapper4rails/datamapper_store.rb'
+    ActionController::Session::DatamapperStore.send(:class_variable_set, :@@cache, nil)
+    ActionController::Session::DatamapperStore.send(:class_variable_set, :@@session_class, nil)
+    @store = ActionController::Session::DatamapperStore.new(nil, :session_class => Session)
+  end
+
+  it 'should get the session data' do
+    Session.stub!(:get)
+    @store.send(:get_session, nil, "sid").should == ["sid",{}]
+    Session.stub!(:get).and_return(mock_session)
+    mock_session.should_receive(:data).and_return({:id => "id"})
+    @store.send(:get_session, nil, "sid").should == ["sid",{:id => "id"}]
+  end
+
+  it 'should set the session data on new session' do
+    Session.should_receive(:get)
+    Session.should_receive(:new).with(:session_id => "sid").and_return(mock_session)
+    mock_session.should_receive(:data=).with({})
+    mock_session.should_receive(:dirty?).and_return(true)
+    mock_session.should_receive(:updated_at=)
+    mock_session.should_receive(:save).and_return(true)
+    @store.send(:set_session, nil, "sid", {}).should == true
+  end
+
+  it 'should set the session data' do
+    Session.should_receive(:get).and_return(mock_session)
+    mock_session.should_receive(:data=).with({})
+    mock_session.should_receive(:dirty?).and_return(true)
+    mock_session.should_receive(:updated_at=)
+    mock_session.should_receive(:save).and_return(true)
+    @store.send(:set_session, nil, "sid", {}).should == true
+  end
+end
+
+describe 'DatamapperStore with cache' do
+
+  def mock_session(stubs={})
+    @mock_session ||= mock(Session, stubs)
+  end
+
+  before :each do
+    load 'lib/datamapper4rails/datamapper_store.rb'
+    ActionController::Session::DatamapperStore.send(:class_variable_set, :@@cache, nil)
+    ActionController::Session::DatamapperStore.send(:class_variable_set, :@@session_class, nil)
+    @store = ActionController::Session::DatamapperStore.new(nil, :cache => true, :session_class => Session)
+  end
+
+  it 'should get the session data from storage' do
+    Session.stub!(:get)
+    @store.send(:get_session, nil, "sid").should == ["sid",{}]
+    Session.stub!(:get).and_return(mock_session)
+    mock_session.should_receive(:data).and_return({:id => "id"})
+    @store.send(:get_session, nil, "sid").should == ["sid",{:id => "id"}]
+  end
+
+  it 'should get the session data from cache' do
+    ActionController::Session::DatamapperStore.send(:class_variable_get, :@@cache)["sid"] = mock_session
+    mock_session.should_receive(:data).and_return({:id => "id"})
+    @store.send(:get_session, nil, "sid").should == ["sid",{:id => "id"}]
+  end
+
+  it 'should set the session data on new session' do
+    Session.should_receive(:get)
+    Session.should_receive(:new).with(:session_id => "sid").and_return(mock_session)
+    mock_session.should_receive(:data=).with({})
+    mock_session.should_receive(:dirty?).and_return(true)
+    mock_session.should_receive(:updated_at=)
+    mock_session.should_receive(:save).and_return(true)
+    @store.send(:set_session, nil, "sid", {}).should == true
+    ActionController::Session::DatamapperStore.send(:class_variable_get, :@@cache)["sid"].should == mock_session
+    
+  end
+
+  it 'should set the session data' do
+    Session.should_receive(:get).and_return(mock_session)
+    mock_session.should_receive(:data=).with({})
+    mock_session.should_receive(:dirty?).and_return(false)
+    mock_session.should_receive(:save).and_return(true)
+    @store.send(:set_session, nil, "sid", {}).should == true
+    ActionController::Session::DatamapperStore.send(:class_variable_get, :@@cache)["sid"].should == mock_session
+  end
+end

data/spec/restful_adapter_spec.rb

@@ -0,0 +1,187 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'spec_helper'
+require 'datamapper4rails/adapters/restful_adapter'
+require 'slf4r/ruby_logger'
+
+class Item
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  belongs_to :container
+end
+class User
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  belongs_to :container
+  has n, :groups, :through => Resource
+end
+class Group
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  has n, :users, :through => Resource
+end
+
+class Container
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  has 1, :user
+  has n, :items
+end
+
+def mock_attribute(name)
+  attr = Object.new
+  def attr.name
+    @name
+  end
+  def attr.name=(name)
+    @name = name
+  end
+  attr.name= name
+  attr
+end
+
+def mock_item(stubs={})
+  @mock_item ||= mock(Item, stubs)
+end
+
+def mock_query(stubs={})
+  @mock_query ||= mock(DataMapper::Query, stubs)
+end
+
+describe DataMapper::Adapters::RestfulAdapter do
+
+  before :each do
+    @adapter = DataMapper::Adapters::RestfulAdapter.new(:name, "uri://")
+
+    def @adapter.key_value_from_query(query)
+      432
+    end
+    def @adapter.resource_name_from_query(query)
+      "item"
+    end
+    def @adapter.http_put(uri, data)
+      @uri = uri
+      @data = data
+    end
+    def @adapter.http_delete(uri)
+      @uri = uri
+    end
+    def @adapter.data
+      @data
+    end
+    def @adapter.uri
+      @uri
+    end
+    def @adapter.body=(b)
+      @body = b
+    end
+    def @adapter.send_request
+      res = Object.new
+      def res.body=(b)
+        @body = b
+      end
+      def res.body
+        @body
+      end
+      def res.kind_of?(clazz)
+        true
+      end
+      res.body= @body
+      res
+    end
+    
+  end
+
+  it 'should create an Item' do
+    @adapter.body = "<item><id>123</id><name>zappa</name></item>"
+
+    item = Item.new
+    @adapter.create_resource(item).should == item
+    item.id.should == 123
+    item.name.should == 'zappa'
+  end
+
+  it 'should update an Item' do
+    mock_item.should_receive(:to_query)
+    mock_item.should_receive(:name).and_return("item")
+    mock_item.should_receive(:to_xml)
+    
+    @adapter.update_resource(mock_item, mock_attribute(:name) => "frank zappa")
+
+    @adapter.data.should == "<item><name>frank zappa</name></item>"
+  end
+
+  it 'should update Items' do    
+    mock_query.should_receive(:limit).and_return(1)
+    @adapter.update({mock_attribute(:name) => "frank zappa"}, mock_query)
+
+    @adapter.data.should == "<item><name>frank zappa</name></item>"
+  end
+
+  it 'should delete an Item' do
+    mock_item.should_receive(:name).and_return("item")
+    mock_item.should_receive(:to_query)
+    @adapter.delete_resource(mock_item)
+    @adapter.uri.should == "/items/432.xml"
+  end
+
+  it 'should delete Items' do    
+    mock_query.should_receive(:limit).and_return(1)
+    @adapter.delete(mock_query)
+
+    @adapter.uri.should == "/items/432.xml"
+  end
+
+  it 'should read an Item' do
+    @adapter.body = "<item><id>123</id><name>zappa</name></item>"
+
+    query = DataMapper::Query.new(Item.new.repository, Item)
+    item = @adapter.read_resource(query)
+    item.id.should == 123
+    item.name.should == 'zappa'
+  end
+
+  it 'should read Items' do
+    @adapter.body = "<items type='array'><item><id>123</id><name>zappa</name></item></items>"
+
+    query = DataMapper::Query.new(Item.new.repository, Item)
+    items = @adapter.read_resources(query)
+    items.size.should == 1
+    items[0].id.should == 123
+    items[0].name.should == 'zappa'
+  end
+#end
+
+
+#describe 'associations of ' + DataMapper::Adapters::RestfulAdapter.to_s do
+  it 'should read nested resource (belongs_to)' do
+    @adapter.body = "<item><id>123</id><name>zappa</name>" +
+      "<container><id>342</id>" + #<items tpye='array'><item><id>1234</id><name>frank zappa</name></item></items>" + 
+      "</container>" +
+      "</item>"
+
+    query = DataMapper::Query.new(Item.new.repository, Item)
+    item = @adapter.read_resource(query)
+    item.id.should == 123
+    item.name.should == 'zappa'
+    item.container.id.should == 342
+  end
+
+#   it 'should read nested resource (has 1)' do
+#     @adapter.body = "<container><id>342</id>" +
+#       "<user><id>543</id></user>" +
+#       "</container>"
+
+#     query = DataMapper::Query.new(Container.new.repository, Container)
+#     c = @adapter.read_resource(query)
+#     c.id.should == 342
+#   end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'dm-core'
+$LOAD_PATH << Pathname(__FILE__).dirname.parent.expand_path + 'lib'
+
+# just define a empty abstract store
+module ActionController
+  module Session
+    class AbstractStore 
+      def initialize(app, options = {})
+      end
+    end
+  end
+end
+
+class Session
+  
+  include ::DataMapper::Resource
+
+  property :session_id, String, :key => true
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: datamapper4rail
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - mkristian
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-21 00:00:00 +05:30
+date: 2009-03-28 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,8 +64,14 @@ files:
 - lib/datamapper4rails/adapters/restful_adapter.rb
 - lib/datamapper4rails/database_config.rb
 - lib/datamapper4rails/datamapper_store.rb
+- lib/datamapper4rails/identity_maps.rb
+- lib/datamapper4rails/preload_models.rb
 - lib/datamapper4rails/restful_transactions.rb
 - lib/datamapper4rails/version.rb
+- spec/datamapper_store_spec.rb
+- spec/restful_adapter_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://datamapper4rail.rubyforge.org
 post_install_message: