ardm-rails 1.2.1

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,70 @@
+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
+        property :data,       Object,   :required => true
+        property :updated_at, DateTime,                    :index => true
+
+        def self.name
+          'session'
+        end
+
+        def data
+          attribute_get(:data) || {}
+        end
+
+      end
+
+      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)
+        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(env)
+        find_session(current_session_id(env)).destroy
+      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/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Rails
+    VERSION = '1.2.1'
+  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

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

@@ -0,0 +1,7 @@
+class <%= class_name %>Observer
+
+  include DataMapper::Observer
+
+  observe <%= class_name %>
+
+end

data/lib/generators/data_mapper.rb

@@ -0,0 +1,82 @@
+require 'rails/generators/named_base'
+require 'rails/generators/migration'
+require 'rails/generators/active_model'
+
+module DataMapper
+  module Generators
+
+    class Base < ::Rails::Generators::NamedBase #:nodoc:
+
+      include ::Rails::Generators::Migration
+
+      def self.source_root
+        @_datamapper_source_root ||=
+        File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+      end
+
+      protected
+
+      # Datamapper does not care if migrations have the same name as long as
+      # they have different ids.
+      #
+      def migration_exists?(dirname, file_name) #:nodoc:
+        false
+      end
+
+      # Implement the required interface for Rails::Generators::Migration.
+      #
+      def self.next_migration_number(dirname) #:nodoc:
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+
+    end
+
+    class ActiveModel < ::Rails::Generators::ActiveModel #:nodoc:
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil)
+        "#{klass}.get(#{params})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        "#{name}.update(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+
+  end
+end
+
+module Rails
+
+  module Generators
+    class GeneratedAttribute #:nodoc:
+      def type_class
+        return 'DateTime' if type.to_s == 'datetime'
+        return type.to_s.camelcase
+      end
+    end
+  end
+
+end

data/spec/models/fake.rb

@@ -0,0 +1,31 @@
+module Rails; module DataMapper; module Models
+  class Composite
+    attr_accessor :args
+
+    def initialize(*args)
+      @args = args
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def eql?(other)
+      !other.nil? && other.args == args
+    end
+  end
+
+  class Fake
+    super_module = Module.new do
+      def _super_attributes=(*args)
+      end
+
+      def attributes=(*args)
+        self.send(:_super_attributes=, *args)
+      end
+    end
+    include super_module
+
+    include ::Rails::DataMapper::MultiparameterAttributes
+  end
+end; end; end

data/spec/models/topic.rb

@@ -0,0 +1,11 @@
+module Rails; module DataMapper; module Models
+  class Topic
+    include ::DataMapper::Resource
+    include ::Rails::DataMapper::MultiparameterAttributes
+
+    property :id, Serial
+    property :last_read, Date
+    property :written_on, Time
+    property :updated_at, DateTime
+  end
+end; end; end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--format progress
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path File.dirname(__FILE__) + '../lib'
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+require 'dm-core/spec/lib/spec_helper'
+require 'dm-core/spec/lib/pending_helpers'
+
+DataMapper::Spec.setup
+DataMapper.finalize
+
+Spec::Runner.configure do |config|
+
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+
+  config.after :all do
+    DataMapper::Spec.cleanup_models
+  end
+
+end