ardm-rails 1.2.1

data/lib/dm-rails/configuration.rb

@@ -0,0 +1,76 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/class/attribute_accessors'
+
+module Rails
+  module DataMapper
+
+    mattr_accessor :configuration
+
+    class Configuration
+
+      attr_accessor :raw
+      attr_accessor :root
+
+      def self.create
+        Rails::DataMapper.configuration ||= new
+      end
+
+      def environments
+        raw.keys
+      end
+
+      def repositories
+        @repositories ||= raw.reject { |k,v| k =~ /defaults/ }.inject({}) do |repositories, pair|
+          environment, config = pair.first, pair.last
+          repositories[environment] = begin
+            c = config['repositories'] || {}
+            c['default'] = config.except('repositories') if config.except('repositories')
+            normalize_repository_config(c)
+          end
+          repositories
+        end
+      end
+
+      def resource_naming_convention
+        @resource_naming_convention ||= {}
+      end
+
+      def field_naming_convention
+        @field_naming_convention ||= {}
+      end
+
+    private
+
+      def normalize_repository_config(hash)
+        config = {}
+        hash.each do |key, value|
+
+          config[key] = if value.kind_of?(Hash)
+            normalize_repository_config(value)
+          elsif key == 'port'
+            value.to_i
+          elsif key == 'adapter' && value == 'postgresql'
+            'postgres'
+          elsif (key == 'database' || key == 'path') && hash['adapter'] =~ /sqlite/
+            value == ':memory:' ? value : File.expand_path(hash[key], root)
+          else
+            value
+          end
+
+          # FIXME Rely on a new dm-sqlite-adapter to do the right thing
+          # For now, we need to make sure that both 'path' and 'database'
+          # point to the same thing, since dm-sqlite-adapter always passes
+          # both to the underlying do_sqlite3 adapter and there's no
+          # guarantee which one will be used
+
+          config['path']     = config[key] if key == 'database'
+          config['database'] = config[key] if key == 'path'
+
+        end
+        config
+      end
+
+    end
+
+  end
+end

data/lib/dm-rails/mass_assignment_security.rb

@@ -0,0 +1,89 @@
+require 'dm-core'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/concern'
+require 'active_model'
+
+module ActiveModel
+  module MassAssignmentSecurity
+    # Provides a patched version of the Sanitizer used in Rails to handle property
+    # and relationship objects as keys. There is no way to inject a custom sanitizer
+    # without reimplementing the permission sets.
+    Sanitizer.send(Sanitizer.is_a?(Module) ? :module_eval : :class_eval) do
+      # Returns all attributes not denied by the authorizer.
+      #
+      # @param [Hash{Symbol,String,::DataMapper::Property,::DataMapper::Relationship=>Object}] attributes
+      #   Names and values of attributes to sanitize.
+      # @return [Hash]
+      #   Sanitized hash of attributes.
+      def sanitize(attributes, authorizer = nil)
+        sanitized_attributes = attributes.reject do |key, value|
+          key_name = key.name rescue key
+          authorizer ? authorizer.deny?(key_name) : deny?(key_name)
+        end
+        debug_protected_attribute_removal(attributes, sanitized_attributes)
+        sanitized_attributes
+      end
+    end
+  end
+end
+
+module DataMapper
+  # Include this module into a DataMapper model to enable ActiveModel's mass
+  # assignment security.
+  #
+  # To use second parameter of {#attributes=} make sure to include this module
+  # last.
+  module MassAssignmentSecurity
+    extend ::ActiveSupport::Concern
+    include ::ActiveModel::MassAssignmentSecurity
+
+    module ClassMethods
+      extend ::ActiveModel::MassAssignmentSecurity::ClassMethods
+
+      def logger
+        @logger ||= ::DataMapper.logger
+      end
+    end
+
+    # Sanitizes the specified +attributes+ according to the defined mass-assignment
+    # security rules and calls +super+ with the result.
+    #
+    # Use either +attr_accessible+ to specify which attributes are allowed to be
+    # assigned via {#attributes=}, or +attr_protected+ to specify which attributes
+    # are *not* allowed to be assigned via {#attributes=}.
+    #
+    # +attr_accessible+ and +attr_protected+ are mutually exclusive.
+    #
+    # @param [Hash{Symbol,String,::DataMapper::Property,::DataMapper::Relationship=>Object}] attributes
+    #   Names and values of attributes to sanitize.
+    # @param [Boolean] guard_protected_attributes
+    #   Determines whether mass-security rules are applied (when +true+) or not.
+    # @return [Hash]
+    #   Sanitized hash of attributes.
+    # @api public
+    #
+    # @example [Usage]
+    #   class User
+    #     include DataMapper::Resource
+    #     include DataMapper::MassAssignmentSecurity
+    #
+    #     property :name, String
+    #     property :is_admin, Boolean
+    #
+    #     # Only allow name to be set via #attributes=
+    #     attr_accessible :name
+    #   end
+    #
+    #   user = User.new
+    #   user.attributes = { :username => 'Phusion', :is_admin => true }
+    #   user.username  # => "Phusion"
+    #   user.is_admin  # => false
+    #
+    #   user.send(:attributes=, { :username => 'Phusion', :is_admin => true }, false)
+    #   user.is_admin  # => true
+    def attributes=(attributes, guard_protected_attributes = true)
+      attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
+      super(attributes)
+    end
+  end
+end

data/lib/dm-rails/middleware/identity_map.rb

@@ -0,0 +1,20 @@
+module Rails
+  module DataMapper
+    module Middleware
+
+      class IdentityMap
+        def initialize(app, name = :default)
+          @app = app
+          @name = name.to_sym
+        end
+
+        def call(env)
+          ::DataMapper.repository(@name) do
+            @app.call(env)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dm-rails/multiparameter_attributes.rb

@@ -0,0 +1,167 @@
+require 'active_support/core_ext/module/aliasing'
+
+module Rails
+  module DataMapper
+    # Encapsulates an error of a multiparameter assignment.
+    class MultiparameterAssignmentError < StandardError
+      # Gets the target attribute of the assignment.
+      # @return [String]
+      attr_reader :attribute
+
+      # Gets the assigned values.
+      # @return [Array]
+      attr_reader :values
+
+      # Gets the exception raised on the assignment.
+      # @return [Exception]
+      attr_reader :exception
+
+      # Initializes a new instance of the {MultiparameterAssignmentError} class.
+      #
+      # @param [String] attribute The target attribute of the assignment.
+      # @param [Array] values The assigned values.
+      # @param [Exception] exception The exception raised on the assignment.
+      def initialize(attribute, values, exception)
+        super("Could not assign #{values.inspect} to #{attribute} (#{exception.message}).")
+        @attribute = attribute
+        @values = values
+        @exception = exception
+      end
+    end
+
+    # Raised by {MultiparameterAttributes#attributes=} when there are errors when
+    # merging multiparameter attributes. Use {#errors} to get the array of errors
+    # occured.
+    class MultiparameterAssignmentErrors < StandardError
+      # Gets the array of assignment errors.
+      # @return [Array<MultiparameterAssignmentError>]
+      attr_reader :errors
+
+      # Initializes a new instance of the {MultiparameterAssignmentErrors} class.
+      #
+      # @param [Array<MultiparameterAssignmentError>] errors
+      #   The array of assignment errors.
+      # @param [String] message Optional error message.
+      def initialize(errors, message = nil)
+        super(message || "#{errors.size} error#{errors.size == 1 ? '' : 's'} on assignment of multiparameter attributes.")
+        @errors = errors
+      end
+    end
+
+    # Include this module into a DataMapper model to enable multiparameter
+    # attributes.
+    #
+    # A multiparameter attribute has +attr(Xc)+ as name where +attr+ specifies
+    # the attribute, +X+ the position of the value, and +c+ an optional typecast
+    # identifier. All values that share an +attr+ are sorted by their position,
+    # optionally cast using +#to_c+ (where +c+ is the typecast identifier) and
+    # then used to instantiate the proper attribute value.
+    #
+    # @example
+    #   # Assigning a hash with multiparameter values for a +Date+ property called
+    #   # +written_on+:
+    #   resource.attributes = {
+    #       'written_on(1i)' => '2004',
+    #       'written_on(2i)' => '6',
+    #       'written_on(3i)' => '24' }
+    #
+    #   # +Date+ will be initialized with each string cast to a number using
+    #   # #to_i.
+    #   resource.written_on == Date.new(2004, 6, 24)
+    module MultiparameterAttributes
+      # Merges multiparameter attributes and calls +super+ with the merged
+      # attributes.
+      #
+      # @param [Hash{String,Symbol=>Object}] attributes
+      #   Names and values of attributes to assign.
+      # @return [Hash]
+      #   Names and values of attributes assigned.
+      # @raise [MultiparameterAssignmentErrors]
+      #   One or more multiparameters could not be assigned.
+      # @api public
+      def attributes=(attributes)
+        attribs = attributes.dup
+        multi_parameter_attributes = []
+        attribs.each do |k, v|
+          if k.to_s.include?("(")
+            multi_parameter_attributes << [ k, v ]
+            attribs.delete(k)
+          end
+        end
+
+        attribs.merge!(merge_multiparameter_attributes(multi_parameter_attributes))
+        super(attribs)
+      end
+
+    protected
+      def merge_multiparameter_attributes(pairs)
+        pairs = extract_multiparameter_attributes(pairs)
+
+        errors = []
+        attributes = {}
+        pairs.each do |name, values_with_empty_parameters|
+          # ActiveRecord keeps the empty values to set dates without a year.
+          # Removing all nils (instead of removing only trailing nils) seems
+          # like a weird behavior though.
+          values = values_with_empty_parameters.compact
+
+          if values.empty?
+            attributes[name] = nil
+            next
+          end
+
+          klass = properties[name].primitive
+          begin
+            attributes[name] =
+              if klass == Time
+                Time.local(*values)
+              elsif klass == Date
+                # Date does not replace nil values with defaults.
+                Date.new(*values_with_empty_parameters.map { |v| v.nil? ? 1 : v })
+              else
+                klass.new(*values)
+              end
+          rescue => ex
+            errors << MultiparameterAssignmentError.new(name, values, ex)
+          end
+        end
+
+        unless errors.empty?
+          raise MultiparameterAssignmentErrors.new(errors)
+        end
+
+        attributes
+      end
+
+      def extract_multiparameter_attributes(pairs)
+        attributes = {}
+
+        for multiparameter_name, value in pairs
+          unless multiparameter_name =~ /\A ([^\)]+) \(  ([0-9]+) ([a-z])?  \) \z/x
+            raise "Invalid multiparameter name #{multiparameter_name.inspect}."
+          end
+
+          name, position, typecast = $1, $2, $3
+          attributes[name] ||= []
+
+          parameter_value =
+            if value.empty?
+              nil
+            elsif typecast
+              value.send('to_' + typecast)
+            else
+              value
+            end
+
+          attributes[name] << [ position, parameter_value ]
+        end
+
+        # Order each parameter array according to the position, then discard the
+        # position.
+        attributes.each { |name, values|
+          attributes[name] = values.sort_by{ |v| v.first }.collect { |v| v.last }
+        }
+      end
+    end # MultiparameterAttributes
+  end
+end

data/lib/dm-rails/railtie.rb

@@ -0,0 +1,100 @@
+require 'dm-core'
+require 'dm-active_model'
+
+require 'rails'
+require 'active_model/railtie'
+
+# Comment taken from active_record/railtie.rb
+#
+# For now, action_controller must always be present with
+# rails, so let's make sure that it gets required before
+# here. This is needed for correctly setting up the middleware.
+# In the future, this might become an optional require.
+require 'action_controller/railtie'
+
+require 'dm-rails/setup'
+require "dm-rails/railties/log_subscriber"
+require "dm-rails/railties/i18n_support"
+
+# The module provided in there is made available
+# but users will still need to include it into the
+# models they want it to use it in.
+require 'dm-rails/mass_assignment_security'
+require 'dm-rails/multiparameter_attributes'
+
+module Rails
+  module DataMapper
+
+    class Railtie < Rails::Railtie
+
+      config.data_mapper = Rails::DataMapper::Configuration.create
+
+      config.app_generators.orm :data_mapper, :migration => true
+
+
+      # Support overwriting crucial steps in subclasses
+
+      def configure_data_mapper(app)
+        app.config.data_mapper.root = Rails.root
+        app.config.data_mapper.raw  = app.config.database_configuration
+      end
+
+      def setup_i18n_support(app)
+        ::DataMapper::Model.append_extensions(::ActiveModel::Translation)
+        ::DataMapper::Model.append_extensions(Rails::DataMapper::I18nSupport)
+      end
+
+      def setup_controller_runtime(app)
+        require "dm-rails/railties/controller_runtime"
+        ActiveSupport.on_load(:action_controller) do
+          include Rails::DataMapper::Railties::ControllerRuntime
+        end
+      end
+
+      def setup_logger(app, logger)
+        Rails::DataMapper.setup_logger(logger)
+      end
+
+
+      initializer 'data_mapper.configuration' do |app|
+        configure_data_mapper(app)
+        ::DataMapper::Model.append_inclusions(Rails::DataMapper::MultiparameterAttributes)
+      end
+
+      initializer 'data_mapper.logger' do |app|
+        setup_logger(app, Rails.logger)
+      end
+
+      initializer 'data_mapper.i18n_support' do |app|
+        setup_i18n_support(app)
+      end
+
+      # Expose database runtime to controller for logging.
+      initializer "data_mapper.log_runtime" do |app|
+        setup_controller_runtime(app)
+      end
+
+      # Preload all models once in production mode,
+      # and before every request in development mode
+      initializer "datamapper.add_to_prepare" do |app|
+        config.to_prepare { Rails::DataMapper.preload_models(app) }
+      end
+
+      # Run setup code once in after_initialize to make sure all initializers
+      # are in effect once we setup the connection. Also, this will make sure
+      # that the connection gets set up after all models have been loaded,
+      # because #after_initialize is guaranteed to run after #to_prepare.
+      # Both production and development environment will execute the setup
+      # code only once.
+      config.after_initialize do |app|
+        Rails::DataMapper.setup(Rails.env)
+      end
+
+      rake_tasks do
+        load 'dm-rails/railties/database.rake'
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module Rails
+  module DataMapper
+    module Railties
+
+      module ControllerRuntime
+
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :db_runtime
+
+        def cleanup_view_runtime
+          # TODO add checks if DataMapper is connected to a repository.
+          # If it is, do this, if it isn't, just delegate to super
+          db_rt_before_render = ::DataMapper::Railties::LogSubscriber.reset_runtime
+          runtime = super
+          db_rt_after_render = ::DataMapper::Railties::LogSubscriber.reset_runtime
+          self.db_runtime = db_rt_before_render + db_rt_after_render
+          runtime - db_rt_after_render
+        end
+
+        def append_info_to_payload(payload)
+          super
+          payload[:db_runtime] = db_runtime
+        end
+
+
+        module ClassMethods
+
+          def log_process_action(payload)
+            messages, db_runtime = super, payload[:db_runtime]
+            messages << ("Models: %.3fms" % db_runtime.to_f) if db_runtime
+            messages
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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