datamapper4rail 0.1.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-03-18
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,22 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+generators/dm_install/dm_install_generator.rb
+generators/dm_install/templates/datamapper.rake
+generators/dm_migration/dm_migration_generator.rb
+generators/dm_migration/templates/migration.rb
+generators/dm_model/dm_model_generator.rb
+generators/dm_model/templates/model.rb
+generators/dm_model/templates/unit_test.rb
+generators/rspec_default_values.rb
+generators/rspec_dm_model/rspec_dm_model_generator.rb
+generators/rspec_dm_model/templates/model.rb
+generators/rspec_dm_model/templates/model_spec.rb
+lib/datamapper4rails.rb
+lib/datamapper4rails/adapters/base_adapter.rb
+lib/datamapper4rails/adapters/restful_adapter.rb
+lib/datamapper4rails/database_config.rb
+lib/datamapper4rails/datamapper_store.rb
+lib/datamapper4rails/restful_transactions.rb
+lib/datamapper4rails/version.rb

data/README.txt

@@ -0,0 +1,101 @@
+= datamapper4rails
+
+* http://datamapper4rail.rubyforge.org
+
+== DESCRIPTION:
+
+collection of datamapper related extensions. mostly needed to run within rails. the restful transactions is around filter for rails. the restful adapter can be outside of rails. datamapper store is a session store for rails which uses datamapper as persistent layer. the generators produces datamapper models for your rails application. quite a few things are "stolen" from dm-more/rails_datamapper. a lot of things do not work there and patches are still in process to be applied so until dm-more/rails_datamapper catches up, ut I hope these two project merge someday again.
+
+== FEATURES/PROBLEMS:
+
+* restful adapter does handle associations partially and does not handle collections
+
+== SYNOPSIS:
+
+=== restful transaction
+
+wraps all modifying requests (POST, PUT, DELETE) into a transaction. any error/exception as well render of a page will rollback the transaction. typically if a POST, PUT or DELETE succeeds then a redirect gets send back to browser.
+
+credits of the main idea goes to http://www.redhillonrails.org
+
+is implemented as around filter in rails and gets prepend to the filters of the action_controller of rails
+
+  require 'datamapper4rails/restful_transations
+
+=== datamapper session store
+
+this is just the datamapper compaign to the activerecord_store.
+
+in config/environment.rb add
+
+  config.action_controller.session_store = :datamapper_store
+
+in case you need a memory cache for your sessions add this
+
+  config.action_controller.session = { :cache => true }
+
+=== generators for datamapper models
+
+this is taken from dm-more/rails_datamapper and extended it - to my liking. patches are submitted upstream until they get applied this will remain here.
+
+* dm-install: rake task for datamapper: automigrate, autoupgrade 
+* dm_model
+* rspec_dm_model
+
+=== database config
+
+this is also taken from dm-more/rails_datamapper and just uses the 
+'config/database.yml' to configure a database connection. it also allows to configure multiple repositories for a single environment just nest the config  in such a way:
+
+  development:
+    repositories:
+      default:
+        adapter: sqlite3
+        database: db/development.sqlite3
+        pool: 5
+        timeout: 5000
+      users:
+        adapter: ldap
+        host: localhost
+        port: 389
+        base: dc=example,dc=com
+        bind_name: cn=admin,dc=example,dc=com
+        password: secret
+
+
+=== restful adapter
+
+this comes partly from dm-ldap-adapter and partly from dm-more/adapter/rest_adapter. the restful adapter allows to Create, Retrieve, Update and Delete resources via a restful service.
+
+== REQUIREMENTS:
+
+* datamapper
+
+== INSTALL:
+
+* sudo gem install datamapper4rails
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Kristian Meier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,32 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/datamapper4rails/version.rb'
+
+Hoe.new('datamapper4rail', Datamapper4rails::VERSION) do |p|
+  p.rubyforge_name = 'datamapper4rail'
+  p.developer('mkristian', 'm.kristian@web.de')
+  p.extra_deps = ['slf4r']
+  p.remote_rdoc_dir = '' # Release to root
+end
+
+desc 'Install the package as a gem.'
+task :install => [:clean, :package] do
+  gem = Dir['pkg/*.gem'].first
+  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
+
+# require 'yard'
+
+# YARD::Rake::YardocTask.new
+
+# vim: syntax=Ruby

data/generators/dm_install/dm_install_generator.rb

@@ -0,0 +1,12 @@
+require 'rails_generator/base'
+
+class DmInstallGenerator < Rails::Generator::Base
+
+  def manifest
+    record do |m|
+      m.directory "lib/tasks"
+      m.template "datamapper.rake",      "lib/tasks/datamapper.rake"
+    end
+  end
+
+end

data/generators/dm_install/templates/datamapper.rake

@@ -0,0 +1,42 @@
+namespace :db do
+
+  desc "Perform automigration"
+  task :automigrate => :environment do
+    FileList["app/models/**/*.rb"].each do |model|
+      load model
+    end
+    ::DataMapper.auto_migrate!
+  end
+
+  desc "Perform non destructive automigration"
+  task :autoupgrade => :environment do
+    FileList["app/models/**/*.rb"].each do |model|
+      load model
+    end
+    ::DataMapper.auto_upgrade!
+  end
+
+  namespace :migrate do
+    task :load => :environment do
+      gem 'dm-migrations'
+      FileList["db/migrations/*.rb"].each do |migration|
+        load migration
+      end
+    end
+
+    desc "Migrate up using migrations"
+    task :up, :version, :needs => :load do |t, args|
+      version = args[:version]
+      migrate_up!(version)
+    end
+
+    desc "Migrate down using migrations"
+    task :down, :version, :needs => :load do |t, args|
+      version = args[:version]
+      migrate_down!(version)
+    end
+  end
+
+  desc "Migrate the database to the latest version"
+  task :migrate => 'db:migrate:up'
+end

data/generators/dm_migration/dm_migration_generator.rb

@@ -0,0 +1,10 @@
+require 'rails_generator/generators/components/migration/migration_generator'
+
+class DmMigrationGenerator < Rails::Generator::NamedBase
+
+  def manifest
+    record do |m|
+      m.migration_template "migration.rb", "db/migrate"
+    end
+  end
+end

data/generators/dm_migration/templates/migration.rb

@@ -0,0 +1,16 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+<% for attribute in attributes -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+<% unless options[:skip_timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/generators/dm_model/dm_model_generator.rb

@@ -0,0 +1,27 @@
+require 'rails_generator/generators/components/model/model_generator'
+require 'active_record'
+
+class DmModelGenerator <ModelGenerator
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      # Model, test, and fixture directories.
+      m.directory File.join('app/models', class_path)
+      m.directory File.join('test/unit', class_path)
+
+      # Model class, unit test, and fixtures.
+      m.template 'model.rb',      File.join('app/models', class_path, "#{file_name}.rb")
+      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+
+      unless options[:skip_migration]
+        m.migration_template 'model:migration.rb', 'db/migrate', :assigns => {
+          :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+        }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+      end
+    end
+  end
+
+end

data/generators/dm_model/templates/model.rb

@@ -0,0 +1,14 @@
+class <%= class_name %>
+  include DataMapper::Resource
+  property :id, Serial
+
+<% for attribute in attributes -%>
+  property :<%= attribute.name %>, <%= attribute.type.to_s.capitalize %>, :nullable => false 
+
+<% end -%>
+<% unless options[:skip_timestamps] %>
+  property :created_at, DateTime, :nullable => false
+  property :updated_at, DateTime, :nullable => false
+
+<% end -%>
+end

data/generators/dm_model/templates/unit_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class <%= class_name %>Test < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/generators/rspec_default_values.rb

@@ -0,0 +1,20 @@
+module Rails
+  module Generator
+    class GeneratedAttribute
+      def default_value
+        @default_value ||= case type
+          when :int, :integer               then "1"
+          when :float                       then "1.5"
+          when :decimal, :big_decimal       then "9.99"
+          when :date_time, :datetime, 
+                          :timestamp, :time then "Time.now"
+          when :date                        then "Date.today"
+          when :string, :text               then "\"value for #{@name}\""
+          when :boolean                     then "false"
+          else
+            ""
+        end      
+      end
+    end
+  end
+end

data/generators/rspec_dm_model/rspec_dm_model_generator.rb

@@ -0,0 +1,33 @@
+require 'rails_generator/generators/components/model/model_generator'
+require 'active_record'
+require File.dirname(__FILE__) + '/../rspec_default_values'
+
+class RspecDmModelExtendedGenerator <ModelGenerator
+
+  def manifest
+    record do |m|
+
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name
+
+      # Model, spec, and fixture directories.
+      m.directory File.join('app/models', class_path)
+      m.directory File.join('spec/models', class_path)
+
+      # Model class, spec and fixtures.
+      m.template 'model.rb',      File.join('app/models', 
+                                            class_path, 
+                                            "#{file_name}.rb")
+      m.template 'model_spec.rb', File.join('spec/models', 
+                                            class_path, 
+                                            "#{file_name}_spec.rb")
+    end
+
+#     unless options[:skip_migration]
+#       m.migration_template 'model:migration.rb', 'db/migrate', :assigns => {
+#         :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+#       }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+#     end
+  end
+
+end

data/generators/rspec_dm_model/templates/model.rb

@@ -0,0 +1,16 @@
+class <%= class_name %>
+  include DataMapper::Resource
+  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 -%>
+
+<% end -%>
+<% end -%>
+<% unless options[:skip_timestamps] %>
+  property :created_at, DateTime, :nullable => false
+  property :updated_at, DateTime, :nullable => false
+
+<% end -%>
+end

data/generators/rspec_dm_model/templates/model_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../spec_helper')
+
+describe <%= class_name %> do
+  before(:each) do
+    @valid_attributes = {
+<% attributes.each_with_index do |attribute, attribute_index| -%>
+      :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
+<% end -%>
+    }
+  end
+
+<% attributes.each do |attribute| -%>
+  it "should require <%= attribute.name %>" do
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => nil))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+  end
+
+<% if attribute.type == :string or attribute.type == :text -%>
+  it 'should not match <%= attribute.name %>' do
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => "<script" ))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => "sc'ript" ))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => "scr&ipt" ))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => 'scr"ipt' ))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => "script>" ))
+    <%= singular_name %>.errors.on(:<%= attribute.name %>).should_not == nil
+  end
+
+<% elsif [:integer, :big_decimal, :float].member? attribute.type %>
+  it "should be numerical <%= attribute.name %>" do
+    <%= singular_name %> = <%= class_name %>.create(@valid_attributes.merge(:<%= attribute.name %> => "none-numberic" ))
+    <%= singular_name %>.<%= attribute.name %>.to_i.should == 0
+    <%= singular_name %>.errors.size.should == 0
+  end
+
+<% end -%>
+<% end -%>
+end

data/lib/datamapper4rails.rb

@@ -0,0 +1,53 @@
+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()

data/lib/datamapper4rails/adapters/base_adapter.rb

@@ -0,0 +1,198 @@
+require 'dm-core'
+require 'slf4r'
+
+module DataMapper
+  module Adapters
+    class NoopTransaction
+      
+      def close ; end
+      def begin ; end
+      def prepare ; end
+      def commit ; end
+      def rollback ; end
+      def rollback_prepared ; end
+      
+    end
+    class BaseAdapter < AbstractAdapter
+
+      include Slf4r::Logger
+
+      # @see AbstractAdapter
+      def transaction_primitive
+        NoopTransaction.new
+      end
+
+      def initialize(name, uri_or_options)
+        super(name, uri_or_options)
+      end
+
+      protected
+      
+      # checks whether a given resource fullfils the conditions
+      # @param [DataMapper::Resource] resource
+      # @param [Array<Condition>] conditions
+      # @return [Boolean] 
+      #   true if the resource are within the conditions otherwise false
+      def filter_resource(resource, conditions)
+        #puts "condi"
+        #p conditions
+        # no conditation => no filter
+        if conditions.size == 0
+          true
+        else
+          conditions.all? do |tuple|
+            operator, property, bind_value = *tuple
+            
+            value = property.get!(resource)
+            case operator
+            when :eql, :in then equality_comparison(bind_value, value)
+            when :not      then !equality_comparison(bind_value, value)
+            when :like     then Regexp.new(bind_value.gsub(/%/, ".*")) =~ value
+            when :gt       then !value.nil? && value >  bind_value
+            when :gte      then !value.nil? && value >= bind_value
+            when :lt       then !value.nil? && value <  bind_value
+            when :lte      then !value.nil? && value <= bind_value
+            else raise "Invalid query operator: #{operator.inspect}"
+            end
+          end
+        end
+      end
+
+      # helper method to dispatch the equality test for different
+      # classes
+      def equality_comparison(bind_value, value)
+        case bind_value
+          when Array, Range then bind_value.include?(value)
+          when NilClass     then value.nil?
+          else                   bind_value == value
+        end
+      end
+
+      public
+
+      # @see AbstractAdapter
+      # @param [Array<DataMapper::Resources>] resources
+      #   aaaa
+      # @return [Fixnum] 
+      #    number of the newly created resources
+      def create(resources)
+        resources.select do |resource|
+
+          create_resource(resource)
+
+        end.size # just return the number of create resources
+      end
+
+      # @see AbstractAdapter
+      # @param [Hash] attributes
+      #   collection of attribute, i.e. the name/value pairs which 
+      #   needs to be updated
+      # @param [Query] 
+      #   on all resources which are selected by that query the 
+      #   update will be applied
+      # @return [Fixnum] 
+      #   number of the updated resources
+      def update(attributes, query)
+        read_many(query).select do |resource|
+          
+          update_resource(resource, attributes)
+
+        end.size
+      end
+
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #    which selects the resource
+      # @return [DataMapper::Resource] 
+      #    the found Resource or nil
+      def read_one(query)
+        result = read_resource(query)
+        if result.is_a? Resource
+          result
+        elsif result # assume result to be Array with the values
+          #puts "------------------"
+          #p result
+          query.model.load(result, query)
+        end
+      end
+      
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [DataMapper::Collection] 
+      #   collection of Resources
+      def read_many(query)
+        Collection.new(query) do |set|
+          result = read_resources(query)
+#puts "read_many"
+#p result
+          if result.size > 0 and result.first.is_a? Resource
+            set.replace(result)
+          else
+            result.each do |values|
+              set.load(values)
+            end
+          end
+        end
+      end
+
+      # @see AbstractAdapter
+      # @param [Query] query
+      #   which selects the resources to be deleted
+      # @return [Fixnum]
+      #   number of the deleted resources
+      def delete(query)
+        read_many(query).each do |resource|
+
+          delete_resource(resource)
+
+        end.size
+      end
+      
+      private
+
+      # @param [DataMapper::Resource] resource
+      #   which will be created
+      # @return [DataMapper::Resource] 
+      #   either the resource itself if the creation was successful or nil 
+      def create_resource(resource)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resource
+      # @return [DataMapper::Resource,Array<String>] 
+      #   the resource or a set of values ordered in the same manner as query.fields attributes
+      def read_resource(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [Array<DataMapper::Resource>,Array<String>]
+      #   resources or ordered values 
+      # @see #read_resource
+      def read_resources(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be updated with the given attributes.
+      # @param [Hash] attributes 
+      #    the keys are the property names and the values are the new values of that property. 
+      # @return [DataMapper::Resource] 
+      #   resource on success otherwise nil
+      def update_resource(resource, attributes)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be deleted
+      # @return [DataMapper::Resource]
+      #   either the resource if the deletion was successful or nil 
+      def delete_resource(resource)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/datamapper4rails/adapters/restful_adapter.rb

@@ -0,0 +1,252 @@
+require 'adapters/restful_adapter'
+require 'net/http'
+require 'extlib/inflection'
+require 'extlib/module'
+
+module DataMapper
+  module Adapters
+    class RestfulAdapter < BaseAdapter
+
+      include ::Slf4r::Logger
+
+      def resource_name_from_model(model)
+        ::Extlib::Inflection.underscore(model.name)
+      end
+
+      def resource_name_from_query(query)
+        resource_name_from_model(query.model)
+      end
+
+      def keys_from_query(query)
+        keys = query.model.key
+        # work around strange missing of properties in model
+        # but the query has still the fields :P
+        if keys.size == 0
+          query.fields.select do |f|
+            f.key?
+          end
+        else
+          keys
+        end
+      end
+
+      def key_value_from_query(query)
+        keys = keys_from_query(query)
+        logger.debug { "keys=#{keys.inspect}" }
+        if keys.size == 1
+          key = keys[0]
+          # return the third element of the condition array
+          # which belongs to the key
+          query.conditions.detect do |c|
+            c[1] == key
+          end[2]
+        else
+          raise "compound keys are not supported"
+        end
+      end
+
+      def http_get(uri)
+        send_request do |http|
+          request = Net::HTTP::Get.new(uri)
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request)
+        end
+      end
+
+      def http_post(uri, data = nil)
+        send_request do |http|
+          request = Net::HTTP::Post.new(uri, {
+                                          'content-type' => 'application/xml',
+                                          'content-length' => data.length.to_s
+                                        })
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request, data)
+        end
+      end
+
+      def http_put(uri, data = {})
+        send_request do |http|
+          request = Net::HTTP::Put.new(uri)
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          request.set_form_data(data)
+          http.request(request)
+        end
+      end
+
+      def http_delete(uri)
+        send_request do |http|
+          request = Net::HTTP::Delete.new(uri)
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request)
+        end
+      end
+
+      def send_request(&block)
+        res = nil
+        Net::HTTP.start(@uri[:host], @uri[:port].to_i) do |http|
+          res = yield(http)
+        end
+        logger.debug { "response=" + res.code }
+        res
+      end
+
+      def parse_resource(xml, model, query = nil)
+        elements = {}
+        associations = {}
+        many_to_many = {}
+        xml.elements.collect do |element|
+          if element.text.nil? 
+            if element.attributes['type'] == 'array'
+              many_to_many[element.name.gsub('-','_').to_sym] = element
+            else
+              associations[element.name.gsub('-','_').to_sym] = element
+            end
+          else
+            elements[element.name.gsub('-','_').to_sym] = element.text
+          end
+        end
+#puts
+#puts "elements"
+#p elements
+        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 = 
+            if rel = model.relationships[name]
+              if rel.child_model == model
+                rel.parent_model
+              else
+                rel.child_model
+              end
+              #                  else
+#::Extlib::Inflection.constantize(::Extlib::Inflection.classify(name))
+#                    model.find_const(::Extlib::Inflection.classify(name))
+            end
+          if resource.respond_to? "#{name}=".to_sym
+            resource.send("#{name}=".to_sym, 
+                          parse_resource(association, model,
+                                         ::DataMapper::Query.new(query.repository, model )))
+          else
+            resource.send(("#{name.to_s.pluralize}<" + "<").to_sym, 
+                          parse_resource(association, model,
+                                         ::DataMapper::Query.new(query.repository, model )))
+          end
+        end
+        resource.instance_variable_set(:@new_record, false)
+        resource
+      end
+
+      # @see BaseAdapter
+      def create_resource(resource)
+        name = resource.model.name
+        uri = "/#{name.pluralize}.xml"
+        logger.debug { "post #{uri}" }
+        response = http_post(uri, resource.to_xml )
+        resource_new = parse_resource(REXML::Document::new(response.body).root, 
+                                  resource.model,
+                                  ::DataMapper::Query.new(resource.repository, 
+                                                          resource.model ))
+
+        # copy all attributes/associations from the downloaded resource
+        # to the given resource
+        # TODO better pass the given resource into parse_resource
+        resource_new.attributes.each do |key, value|
+          resource.send(:properties)[key].set!(resource, value)
+        end
+        resource_new.send(:relationships).each do |key, value|
+          resource.send("#{key}=".to_sym, resource_new.send(key))
+        end
+        resource
+      end
+
+      # @see BaseAdapter
+      def read_resource(query)
+        if(query.conditions.empty?)
+          raise "not implemented"
+        else
+          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)
+            parse_resource(REXML::Document::new(response.body).root, 
+                           query.model, 
+                           query)
+          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
+        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
+      end
+
+      # @overwrite BaseAdapter
+      def delete(query)
+        # TODO limit == 1 is NOT sufficient ONLY necessary
+        if query.limit == 1 
+          name = resource_name_from_query(query)
+          key = key_value_from_query(query)
+          uri = "/#{name.pluralize}/#{key}.xml"
+          logger.debug { "delete #{uri}" }
+          response = http_delete(uri)
+          response.kind_of?(Net::HTTPSuccess) 
+        else
+          super
+        end
+      end
+
+      # @see BaseAdapter
+      def delete_resource(resource)
+        name = resource.name
+        key = key_value_from_query(resource.to_queryquery)
+        uri = "/#{name.pluralize}/#{key}.xml"
+        logger.debug { "delete #{uri}" }
+        response = http_delete(uri)
+        response.kind_of?(Net::HTTPSuccess) 
+      end
+    end
+  end
+end

data/lib/datamapper4rails/database_config.rb

@@ -0,0 +1,49 @@
+require 'dm-core'
+
+def config_file()
+  RAILS_ROOT + "/config/database.yml"
+end
+
+def create_connection()
+  conf = config.dup
+  repositories = conf.delete(:repositories)
+  ::DataMapper.setup(:default, conf) unless conf.empty?
+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()

data/lib/datamapper4rails/datamapper_store.rb

@@ -0,0 +1,67 @@
+require 'dm-core'
+
+module ActionController
+  module Session
+    class DatamapperStore < AbstractStore
+
+      def initialize(app, options = {})
+        super
+        if options.delete(:cache)
+          @@cache = {}
+        end
+        @@session_class = ::DatamapperStore::Session
+      end
+      
+      private
+      def get_session(env, sid)
+        sid ||= generate_sid
+        session = 
+          if @@cache
+            @@cache[sid] || @@session_class.get(sid)
+          else
+            @@session_class.get(sid)
+          end
+        [sid, session.nil? ? {} : session.data]
+      end
+      
+      def set_session(env, sid, session_data)
+        session = 
+          if @@cache
+            @@cache[sid] || @@session_class.get(sid)
+          else
+            @@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.save
+      end
+    end
+  end
+end
+
+module DatamapperStore
+  class Session
+    
+    include ::DataMapper::Resource
+    
+    def self.name
+      "session"
+    end
+    
+    property :session_id, String, :key => true
+    
+    property :data, Text, :nullable => false, :default => ::Base64.encode64(Marshal.dump({}))
+    
+    property :updated_at, DateTime, :nullable => true, :index => true
+    
+    def data=(data)
+      attribute_set(:data, ::Base64.encode64(Marshal.dump(data)))
+    end
+    def data
+      Marshal.load(::Base64.decode64(attribute_get(:data)))
+    end
+  end
+end

data/lib/datamapper4rails/restful_transactions.rb

@@ -0,0 +1,42 @@
+module Datamapper4rails
+  module RestfulTransactions
+
+    class Rollback < StandardError
+    end
+    
+    module Base
+      def self.included(base)
+        base.prepend_around_filter(TransactionFilter)
+      end
+    end
+  
+    class TransactionFilter
+      def self.filter(controller)
+        case controller.request.method
+        when :post, :put, :delete then
+          begin
+            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
+                unless controller.response.redirected_to
+                  raise Datamapper4rails::RestfulTransactions::Rollback      
+                end
+              end
+            end
+          rescue Datamapper4rails::RestfulTransactions::Rollback 
+            # ignore, 
+            # this is just needed to trigger the rollback on the transaction
+          end
+        else
+          yield if block_given?
+        end
+      end
+    end
+  end
+end
+
+::ActionController::Base.send(:include, Datamapper4rails::RestfulTransactions::Base)

data/lib/datamapper4rails/version.rb

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

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: datamapper4rail
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- mkristian
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-21 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: slf4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: collection of datamapper related extensions. mostly needed to run within rails. the restful transactions is around filter for rails. the restful adapter can be outside of rails. datamapper store is a session store for rails which uses datamapper as persistent layer. the generators produces datamapper models for your rails application. quite a few things are "stolen" from dm-more/rails_datamapper. a lot of things do not work there and patches are still in process to be applied so until dm-more/rails_datamapper catches up, ut I hope these two project merge someday again.
+email: 
+- m.kristian@web.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- generators/dm_install/dm_install_generator.rb
+- generators/dm_install/templates/datamapper.rake
+- generators/dm_migration/dm_migration_generator.rb
+- generators/dm_migration/templates/migration.rb
+- generators/dm_model/dm_model_generator.rb
+- generators/dm_model/templates/model.rb
+- generators/dm_model/templates/unit_test.rb
+- generators/rspec_default_values.rb
+- generators/rspec_dm_model/rspec_dm_model_generator.rb
+- generators/rspec_dm_model/templates/model.rb
+- generators/rspec_dm_model/templates/model_spec.rb
+- lib/datamapper4rails.rb
+- lib/datamapper4rails/adapters/base_adapter.rb
+- lib/datamapper4rails/adapters/restful_adapter.rb
+- lib/datamapper4rails/database_config.rb
+- lib/datamapper4rails/datamapper_store.rb
+- lib/datamapper4rails/restful_transactions.rb
+- lib/datamapper4rails/version.rb
+has_rdoc: true
+homepage: http://datamapper4rail.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: datamapper4rail
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: collection of datamapper related extensions
+test_files: []
+