tpitale-dm-rails 1.2.1

data/lib/dm-rails/railties/database.rake

@@ -0,0 +1,106 @@
+require 'dm-rails/setup'
+require 'dm-rails/storage'
+
+namespace :db do
+
+  desc 'Create the database, load the schema, and initialize with the seed data'
+  task :setup => [ 'db:create', 'db:automigrate', 'db:seed' ]
+
+  namespace :create do
+    desc 'Create all the local databases defined in config/database.yml'
+    task :all => :environment do
+      Rails::DataMapper.storage.create_all
+    end
+  end
+
+  desc "Create all local databases defined for the current Rails.env"
+  task :create => :environment do
+    Rails::DataMapper.storage.create_environment(Rails::DataMapper.configuration.repositories[Rails.env])
+  end
+
+  namespace :drop do
+    desc 'Drop all the local databases defined in config/database.yml'
+    task :all => :environment do
+      Rails::DataMapper.storage.drop_all
+    end
+  end
+
+  desc "Drop all local databases defined for the current Rails.env"
+  task :drop => :environment do
+    Rails::DataMapper.storage.drop_environment(Rails::DataMapper.configuration.repositories[Rails.env])
+  end
+
+
+  desc 'Perform destructive automigration of all repositories in the current Rails.env'
+  task :automigrate => :environment do
+    require 'dm-migrations'
+    Rails::DataMapper.configuration.repositories[Rails.env].each do |repository, config|
+      ::DataMapper.auto_migrate!(repository.to_sym)
+      puts "[datamapper] Finished auto_migrate! for :#{repository} repository '#{config['database']}'"
+    end
+  end
+
+  desc 'Perform non destructive automigration of all repositories in the current Rails.env'
+  task :autoupgrade => :environment do
+    require 'dm-migrations'
+    Rails::DataMapper.configuration.repositories[Rails.env].each do |repository, config|
+      ::DataMapper.auto_upgrade!(repository.to_sym)
+      puts "[datamapper] Finished auto_upgrade! for :#{repository} repository '#{config['database']}'"
+    end
+  end
+
+  desc 'Load the seed data from db/seeds.rb'
+  task :seed => :environment do
+    seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+    load(seed_file) if File.exist?(seed_file)
+  end
+
+  namespace :migrate do
+    task :load => :environment do
+      require 'dm-migrations/migration_runner'
+      FileList['db/migrate/*.rb'].each do |migration|
+        load migration
+      end
+    end
+
+    desc 'Migrate up using migrations'
+    task :up, [:version] => [:load] do |t, args|
+      ::DataMapper::MigrationRunner.migrate_up!(args[:version])
+    end
+
+    desc 'Migrate down using migrations'
+    task :down, [:version] => [:load] do |t, args|
+      ::DataMapper::MigrationRunner.migrate_down!(args[:version])
+    end
+  end
+
+  desc 'Migrate the database to the latest version'
+  task :migrate do
+    migrate_task = if Dir['db/migrate/*.rb'].empty?
+                     'db:autoupgrade'
+                   else
+                     'db:migrate:up'
+                   end
+
+    Rake::Task[migrate_task].invoke
+  end
+
+  namespace :sessions do
+    desc "Creates the sessions table for DataMapperStore"
+    task :create => :environment do
+      require 'dm-rails/session_store'
+      Rails::DataMapper::SessionStore::Session.auto_migrate!
+      database = Rails::DataMapper.configuration.repositories[Rails.env]['database']
+      puts "Created '#{database}.sessions'"
+    end
+
+    desc "Clear the sessions table for DataMapperStore"
+    task :clear => :environment do
+      require 'dm-rails/session_store'
+      Rails::DataMapper::SessionStore::Session.destroy!
+      database = Rails::DataMapper.configuration.repositories[Rails.env]['database']
+      puts "Deleted entries from '#{database}.sessions'"
+    end
+  end
+
+end

data/lib/dm-rails/railties/i18n_support.rb

@@ -0,0 +1,12 @@
+module Rails
+  module DataMapper
+
+    module I18nSupport
+      # Set the i18n scope to overwrite ActiveModel.
+      def i18n_scope #:nodoc:
+        :data_mapper
+      end
+    end
+
+  end
+end

data/lib/dm-rails/railties/log_listener.rb

@@ -0,0 +1,39 @@
+require 'active_support/notifications'
+
+# TODO This needs to be fixed upstream in active_support/notifications/instrumenter.rb
+#
+# We need to monkeypatch this for now, because the original implementation hardcodes the
+# duration to the time elapsed between start and end of the event. The current upstream
+# implementation is included here for reference:
+#
+#   def duration
+#     @duration ||= 1000.0 * (@end - @time)
+#   end
+#
+# It should be safe to assume that explicitly provided duration information should be at
+# least as precise as the current generic solution, if not more (as in our specific case).
+#
+module ActiveSupport
+  module Notifications
+    class Event
+      def duration
+        payload[:duration] ? (payload[:duration] / 1000.0) : 1000.0 * (self.end - self.time)
+      end
+    end
+  end
+end
+
+module LogListener
+  def log(message)
+    ActiveSupport::Notifications.instrument('sql.data_mapper',
+      :name          => 'SQL',
+      :sql           => message.query, # TODO think about changing the key to :query
+      :start         => message.start,
+      :duration      => message.duration,
+      :connection_id => self.object_id
+    )
+    super
+  rescue Exception => e
+    ::DataMapper.logger.error "[datamapper] #{e.class.name}: #{e.message}: #{message.inspect}}"
+  end
+end

data/lib/dm-rails/railties/log_subscriber.rb

@@ -0,0 +1,54 @@
+module DataMapper
+  module Railties
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+
+      def self.runtime=(value)
+        Thread.current["data_mapper_sql_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["data_mapper_sql_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def initialize
+        super
+        @odd_or_even = false
+      end
+
+      def sql(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        name = '%s (%.3fms)' % [event.payload[:name], event.duration]
+        sql  = event.payload[:sql].squeeze(' ')
+
+        if odd?
+          name = color(name, CYAN, true)
+          sql  = color(sql, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "  #{name}  #{sql}"
+      end
+
+      def odd?
+        @odd_or_even = !@odd_or_even
+      end
+
+      def logger
+        ::DataMapper.logger
+      end
+
+    end
+
+  end
+end
+
+DataMapper::Railties::LogSubscriber.attach_to :data_mapper

data/lib/dm-rails/session_store.rb

@@ -0,0 +1,77 @@
+require 'dm-core'
+require 'active_support/core_ext/class/attribute'
+
+# Implements DataMapper-specific session store.
+
+module Rails
+  module DataMapper
+
+    class SessionStore < ActionDispatch::Session::AbstractStore
+
+      class Session
+
+        include ::DataMapper::Resource
+
+        property :id,         Serial
+        property :session_id, String,   :required => true, :unique => true, :length => 0..150
+        property :data,       Object,   :required => false
+        property :updated_at, DateTime,                    :index => true
+
+        def self.name
+          'session'
+        end
+
+        def data
+          attribute_get(:data) || {}
+        end
+
+      end
+
+      # for backward compatibility with Rails 3.0
+      ENV_SESSION_OPTIONS_KEY = ::Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY unless const_defined?("ENV_SESSION_OPTIONS_KEY")
+      SESSION_RECORD_KEY      = 'rack.session.record'.freeze
+
+      class_attribute :session_class
+      self.session_class = Session
+
+      private
+
+      def get_session(env, sid)
+        sid ||= generate_sid
+        session = find_session(sid)
+        env[SESSION_RECORD_KEY] = session
+        [ sid, session.data ]
+      end
+
+      def set_session(env, sid, session_data, options = {})
+        session            = get_session_resource(env, sid)
+        session.data       = session_data
+        session.updated_at = DateTime.now if session.dirty?
+        session.save ? sid : false
+      end
+
+      def get_session_resource(env, sid)
+        if env[ENV_SESSION_OPTIONS_KEY][:id].nil?
+          env[SESSION_RECORD_KEY] = find_session(sid)
+        else
+          env[SESSION_RECORD_KEY] ||= find_session(sid)
+        end
+      end
+
+      def find_session(sid)
+        self.class.session_class.first_or_new(:session_id => sid)
+      end
+
+      def destroy_session(env, sid = nil, options = {})
+        sid ||= current_session_id(env)
+        find_session(sid).destroy
+      end
+
+      def destroy(env)
+        destroy_session(env)
+      end
+
+    end
+
+  end
+end

data/lib/dm-rails/setup.rb

@@ -0,0 +1,84 @@
+require 'active_support/core_ext/hash/except'
+
+require 'dm-rails/configuration'
+require 'dm-rails/railties/log_listener'
+
+module Rails
+  module DataMapper
+
+    def self.setup(environment)
+      ::DataMapper.logger.info "[datamapper] Setting up the #{environment.inspect} environment:"
+      configuration.repositories[environment].each do |name, config|
+        setup_with_instrumentation(name.to_sym, config)
+      end
+      finalize
+    end
+
+    def self.setup_with_instrumentation(name, options)
+
+      adapter = if options['uri']
+                  database_uri = ::Addressable::URI.parse(options['uri'])
+                  ::DataMapper.logger.info "[datamapper] Setting up #{name.inspect} repository: '#{database_uri.path}' on #{database_uri.scheme}"
+                  ::DataMapper.setup(name, database_uri)
+                else
+                  ::DataMapper.logger.info "[datamapper] Setting up #{name.inspect} repository: '#{options['database']}' on #{options['adapter']}"
+                 ::DataMapper.setup(name, options)
+                end
+
+      if convention = configuration.resource_naming_convention[name]
+        adapter.resource_naming_convention = convention
+      end
+      if convention = configuration.field_naming_convention[name]
+        adapter.field_naming_convention = convention
+      end
+      setup_log_listener(adapter.options['adapter'])
+    end
+
+    def self.setup_logger(logger)
+      ::DataMapper.logger = logger
+    end
+
+    def self.setup_log_listener(adapter_name)
+      adapter_name = 'sqlite3' if adapter_name == 'sqlite'
+      driver_name  = ActiveSupport::Inflector.camelize(adapter_name)
+
+      setup_do_driver(driver_name) do |driver|
+        DataObjects::Connection.send(:include, LogListener)
+        # FIXME Setting DataMapper::Logger.new($stdout, :off) alone won't work because the #log
+        # method is currently only available in DO and needs an explicit DO Logger instantiated.
+        # We turn the logger :off because ActiveSupport::Notifications handles displaying log messages
+        driver.logger = DataObjects::Logger.new($stdout, :off)
+      end
+    end
+
+    def self.finalize
+      ::DataMapper.finalize
+    end
+
+    def self.preload_models(app)
+      app.config.paths['app/models'].each do |path|
+        Dir.glob("#{path}/**/*.rb").sort.each { |file| require_dependency file[path.length..-1] }
+      end
+      finalize
+    end
+
+    class << self
+      private
+
+      if RUBY_VERSION < '1.9'
+        def setup_do_driver(driver_name)
+          if Object.const_defined?('DataObjects') && DataObjects.const_defined?(driver_name)
+            yield DataObjects.const_get(driver_name)
+          end
+        end
+      else
+        def setup_do_driver(driver_name)
+          if Object.const_defined?('DataObjects', false) && DataObjects.const_defined?(driver_name, false)
+            yield DataObjects.const_get(driver_name, false)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/dm-rails/storage.rb

@@ -0,0 +1,209 @@
+module Rails
+  module DataMapper
+
+    def self.storage
+      Storage
+    end
+
+    class Storage
+      attr_reader :name, :config
+
+      def self.create_all
+        with_local_repositories { |config| create_environment(config) }
+      end
+
+      def self.drop_all
+        with_local_repositories { |config| drop_environment(config) }
+      end
+
+      def self.create_environment(config)
+        config.each { |repo_name, repo_config| new(repo_name, repo_config).create }
+      end
+
+      def self.drop_environment(config)
+        config.each { |repo_name, repo_config| new(repo_name, repo_config).drop }
+      end
+
+      def self.new(name, config)
+        klass = lookup_class(config['adapter'])
+        if klass.equal?(self)
+          super(name, config)
+        else
+          klass.new(name, config)
+        end
+      end
+
+      class << self
+      private
+
+        def with_local_repositories
+          Rails::DataMapper.configuration.repositories.each_value do |config|
+            if config['host'].blank? || %w[ 127.0.0.1 localhost ].include?(config['host'])
+              yield(config)
+            else
+              puts "This task only modifies local databases. #{config['database']} is on a remote host."
+            end
+          end
+        end
+
+        def lookup_class(adapter)
+          klass_name = normalized_adapter_name(adapter).camelize.to_sym
+
+          unless Storage.const_defined?(klass_name)
+            raise "Adapter #{adapter} not supported (#{klass_name.inspect})"
+          end
+
+          const_get(klass_name)
+        end
+
+        def normalized_adapter_name(adapter_name)
+          adapter_name.to_s == 'sqlite3' ? 'sqlite' : adapter_name
+        end
+
+      end
+
+      def initialize(name, config)
+        @name, @config = name.to_sym, config
+      end
+
+      def create
+        puts create_message if _create
+      end
+
+      def drop
+        puts drop_message if _drop
+      end
+
+      def database
+        @database ||= config['database'] || config['path']
+      end
+
+      def username
+        @username ||= config['username'] || ''
+      end
+
+      def password
+        @password ||= config['password'] || ''
+      end
+
+      def charset
+        @charset ||= config['charset'] || ENV['CHARSET'] || 'utf8'
+      end
+
+      def create_message
+        "[datamapper] Created database '#{database}'"
+      end
+
+      def drop_message
+        "[datamapper] Dropped database '#{database}'"
+      end
+
+      # Create the configured database
+      #
+      # This is a noop so that calling this method
+      # won't explode on people who use adapters that
+      # don't support creating a storage recepticle
+      def _create
+        true
+      end
+
+      # Drop the configured database
+      #
+      # This is a noop so that calling this method
+      # won't explode on people who use adapters that
+      # don't support dropping a storage recepticle
+      def _drop
+        true
+      end
+
+      class Sqlite < Storage
+
+        # This is a noop for sqlite
+        #
+        # Overwritten solely for documentation purposes
+        #
+        # Both auto_migrate!/auto_upgrade! will create the actual database
+        # if the connection has been setup properly and there actually
+        # are statements to execute (i.e. at least one model is declared)
+        #
+        # DataMapper.setup alone won't create the actual database so there
+        # really is no API to simply create an empty database for sqlite3.
+        #
+        # we return true to indicate success nevertheless
+        def _create
+          true
+        end
+
+        def _drop
+          return if in_memory?
+          path.unlink if path.file?
+        end
+
+        def create_message
+          "[datamapper] db:create is a noop for sqlite3, use db:automigrate instead (#{database})"
+        end
+
+      private
+
+        def in_memory?
+          database == ':memory:'
+        end
+
+        def path
+          @path ||= Pathname(File.expand_path(database, Rails.root))
+        end
+
+      end
+
+      class Mysql < Storage
+        def _create
+          execute("CREATE DATABASE `#{database}` DEFAULT CHARACTER SET #{charset} DEFAULT COLLATE #{collation}")
+        end
+
+        def _drop
+          execute("DROP DATABASE IF EXISTS `#{database}`")
+        end
+
+      private
+
+        def execute(statement)
+          system(
+            'mysql',
+            (username.blank? ? '' : "--user=#{username}"),
+            (password.blank? ? '' : "--password=#{password}"),
+            '-e',
+            statement
+          )
+        end
+
+        def collation
+          @collation ||= config['collation'] || ENV['COLLATION'] || 'utf8_unicode_ci'
+        end
+
+      end
+
+      class Postgres < Storage
+        def _create
+          system(
+            'createdb',
+            '-E',
+            charset,
+            '-U',
+            username,
+            database
+          )
+        end
+
+        def _drop
+          system(
+            'dropdb',
+            '-U',
+            username,
+            database
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/dm-rails.rb

@@ -0,0 +1 @@
+require 'dm-rails/railtie'

data/lib/generators/data_mapper/migration/migration_generator.rb

@@ -0,0 +1,30 @@
+require 'generators/data_mapper'
+
+module DataMapper
+  module Generators
+
+    class MigrationGenerator < Base
+
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      class_option :id, :type => :numeric, :desc => "The id to be used in this migration"
+
+      def create_migration_file
+        set_local_assigns!
+        migration_template "migration.rb", "db/migrate/#{file_name}.rb"
+      end
+
+      protected
+
+      attr_reader :migration_action
+
+      def set_local_assigns!
+        if file_name =~ /^(add|remove|drop)_.*_(?:to|from)_(.*)/
+          @migration_action = $1 == 'add' ? 'add' : 'drop'
+          @table_name       = $2.pluralize
+        end
+      end
+
+    end
+
+  end
+end

data/lib/generators/data_mapper/migration/templates/migration.rb

@@ -0,0 +1,23 @@
+migration <%= migration_number.to_i %>, :<%= migration_file_name %> do
+
+  up do
+<% unless attributes.empty? -%>
+    modify_table :<%= table_name %> do
+<% attributes.each do |attribute| -%>
+      <%= migration_action %>_column :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type_class %><% end -%>
+<% end -%>
+    end
+<% end -%>
+  end
+
+  down do
+<% unless attributes.empty? -%>
+    modify_table :<%= table_name %> do
+<% attributes.reverse.each do |attribute| -%>
+      <%= migration_action == 'add' ? 'drop' : 'add' %>_column :<%= attribute.name %><% if migration_action == 'drop' %>, :<%= attribute.type_class %><% end -%>
+<% end -%>
+    end
+<% end -%>
+  end
+
+end

data/lib/generators/data_mapper/model/model_generator.rb

@@ -0,0 +1,23 @@
+require 'generators/data_mapper'
+
+module DataMapper
+  module Generators
+
+    class ModelGenerator < Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      check_class_collision
+
+      class_option :timestamps, :type => :boolean
+      class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
+
+      def create_model_file
+        template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+
+    end
+
+  end
+end

data/lib/generators/data_mapper/model/templates/model.rb

@@ -0,0 +1,11 @@
+class <%= class_name %><%= "< #{options[:parent].classify}" if options[:parent] %>
+
+<% unless options[:parent] -%>
+  include DataMapper::Resource
+
+  property :id, Serial
+<% end %>
+<% attributes.each do |attribute| -%>
+  property :<%= attribute.name -%>, <%= attribute.type_class %>
+<% end %>
+end

data/lib/generators/data_mapper/observer/observer_generator.rb

@@ -0,0 +1,19 @@
+require 'generators/data_mapper'
+
+module DataMapper
+  module Generators
+
+    class ObserverGenerator < Base
+
+      check_class_collision :suffix => "Observer"
+
+      def create_observer_file
+        template 'observer.rb', File.join('app/models', class_path, "#{file_name}_observer.rb")
+      end
+
+      hook_for :test_framework
+
+    end
+
+  end
+end