tpitale-dm-rails 1.2.1

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'jeweler', '~> 1.6.4'
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'dm-rails'
+    gem.summary     = 'Use DataMapper with Rails 3'
+    gem.description = 'Integrate DataMapper with Rails 3'
+    gem.email       = 'gamsnjaga@gmail.com'
+    gem.homepage    = 'http://github.com/datamapper/%s' % gem.name
+    gem.authors     = [ 'Martin Gamsjaeger (snusnu)', 'Dan Kubb' ]
+
+    gem.rubyforge_project = 'datamapper'
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  FileList['tasks/**/*.rake'].each { |task| import task }
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require "spec/rake/spectask"
+Spec::Rake::SpecTask.new

data/VERSION

@@ -0,0 +1 @@
+1.2.1

data/dm-rails.gemspec

@@ -0,0 +1,94 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "tpitale-dm-rails"
+  s.version = "1.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Gamsjaeger (snusnu)", "Dan Kubb"]
+  s.date = "2011-10-09"
+  s.description = "Integrate DataMapper with Rails 3"
+  s.email = "gamsnjaga@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "dm-rails.gemspec",
+    "lib/dm-rails.rb",
+    "lib/dm-rails/configuration.rb",
+    "lib/dm-rails/mass_assignment_security.rb",
+    "lib/dm-rails/middleware/identity_map.rb",
+    "lib/dm-rails/multiparameter_attributes.rb",
+    "lib/dm-rails/railtie.rb",
+    "lib/dm-rails/railties/controller_runtime.rb",
+    "lib/dm-rails/railties/database.rake",
+    "lib/dm-rails/railties/i18n_support.rb",
+    "lib/dm-rails/railties/log_listener.rb",
+    "lib/dm-rails/railties/log_subscriber.rb",
+    "lib/dm-rails/session_store.rb",
+    "lib/dm-rails/setup.rb",
+    "lib/dm-rails/storage.rb",
+    "lib/generators/data_mapper.rb",
+    "lib/generators/data_mapper/migration/migration_generator.rb",
+    "lib/generators/data_mapper/migration/templates/migration.rb",
+    "lib/generators/data_mapper/model/model_generator.rb",
+    "lib/generators/data_mapper/model/templates/model.rb",
+    "lib/generators/data_mapper/observer/observer_generator.rb",
+    "lib/generators/data_mapper/observer/templates/observer.rb",
+    "spec/models/fake.rb",
+    "spec/models/topic.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb",
+    "spec/unit/mass_assignment_security_spec.rb",
+    "spec/unit/multiparameter_attributes_spec.rb",
+    "tasks/clean.rake",
+    "tasks/yard.rake",
+    "tasks/yardstick.rake"
+  ]
+  s.homepage = "http://github.com/datamapper/dm-rails"
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "datamapper"
+  s.rubygems_version = "1.8.11"
+  s.summary = "Use DataMapper with Rails 3"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<dm-core>, ["~> 1.2.0"])
+      s.add_runtime_dependency(%q<dm-active_model>, ["~> 1.2.0"])
+      s.add_runtime_dependency(%q<actionpack>, ["~> 3.1.0"])
+      s.add_runtime_dependency(%q<railties>, ["~> 3.1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3.2"])
+    else
+      s.add_dependency(%q<dm-core>, ["~> 1.2.0"])
+      s.add_dependency(%q<dm-active_model>, ["~> 1.2.0"])
+      s.add_dependency(%q<actionpack>, ["~> 3.1.0"])
+      s.add_dependency(%q<railties>, ["~> 3.1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rake>, ["~> 0.9.2"])
+      s.add_dependency(%q<rspec>, ["~> 1.3.2"])
+    end
+  else
+    s.add_dependency(%q<dm-core>, ["~> 1.2.0"])
+    s.add_dependency(%q<dm-active_model>, ["~> 1.2.0"])
+    s.add_dependency(%q<actionpack>, ["~> 3.1.0"])
+    s.add_dependency(%q<railties>, ["~> 3.1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rake>, ["~> 0.9.2"])
+    s.add_dependency(%q<rspec>, ["~> 1.3.2"])
+  end
+end
+

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.
+    module Sanitizer
+      # 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)
+        sanitized_attributes = attributes.reject do |key, value|
+          key_name = key.name rescue key
+          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].dump_class
+          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