datamapper-shim 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify dependencies in datamapper-shim.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (3.2.16)
+      activesupport (= 3.2.16)
+      builder (~> 3.0.0)
+    activerecord (3.2.16)
+      activemodel (= 3.2.16)
+      activesupport (= 3.2.16)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.16)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    attribute-defaults (0.6.0)
+      activerecord (>= 3.0.0)
+    builder (3.0.4)
+    coderay (1.1.0)
+    composite_primary_keys (5.0.13)
+      activerecord (~> 3.2.0, >= 3.2.9)
+    i18n (0.6.9)
+    json (1.8.1)
+    method_source (0.8.2)
+    minitest (5.2.3)
+    multi_json (1.8.4)
+    pry (0.9.12.4)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    slop (3.4.7)
+    sqlite3 (1.3.8)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.2.0)
+  attribute-defaults (~> 0.6.0)
+  composite_primary_keys (~> 5.0.0)
+  json (~> 1.4)
+  minitest (~> 5.2.3)
+  pry
+  sqlite3 (~> 1.3.8)

data/datamapper-shim.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "datamapper-shim"
+  spec.version       = "0.0.1"
+  spec.authors       = ["ecin"]
+  spec.email         = ["ecin@copypastel.com"]
+  spec.description   = "Dress ActiveRecord models in DataMapper robes."
+  spec.summary       = "Migrate DataMapper models to ActiveRecord."
+  spec.homepage      = "https://github.com/typekit/datamapper-shim"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json", "~> 1.4"
+  spec.add_dependency "activerecord", "~> 3.2.0"
+  spec.add_dependency "attribute-defaults", "~> 0.6.0"
+  spec.add_dependency "composite_primary_keys", "~> 5.0.0"
+  spec.add_dependency "json", "~> 1.4"
+  spec.add_dependency "sqlite3", "~> 1.3.8"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "minitest", "~> 5.2.3"
+  spec.add_development_dependency "pry", "~> 0.9.12.4"
+end

data/lib/data_mapper/shim.rb

@@ -0,0 +1,724 @@
+require "active_record"
+require "active_support/concern"
+require "attribute_defaults"
+require "composite_primary_keys"
+require "json"
+
+module DataMapper
+  module Shim
+    RAISE_ON_UNHANDLED_OPTIONS = true
+
+    extend ActiveSupport::Concern
+
+    # Placeholders for DataMapper types
+    BigInt = Class.new
+    Boolean = Class.new
+    Discriminator = Class.new
+    ParanoidDateTime = Class.new
+    Resource = Class.new
+    Serial = Class.new
+    Text = Class.new
+
+    # Serializable classes
+    Yaml = Class.new
+    Json = Class.new
+
+    class Enum
+      attr_accessor :values
+
+      def self.[](*values)
+        self.new(values)
+      end
+
+      def initialize(values)
+        # [:active, :inactive] => { :active => 1, :inactive => 2, 1 => :active, 2 => :inactive }
+        self.values = values.each_with_index.inject({}) do |hash, (val, i)|
+          hash[val] = i + 1
+          hash[i + 1] = val
+          hash
+        end
+      end
+
+      def [](index)
+        self.values[index]
+      end
+    end
+
+    class List
+      def load(value)
+        value ? value.to_s.split(",") : nil
+      end
+
+      def dump(value)
+        value ? value.collect { |x| x.to_s.strip }.join(',') : nil
+      end
+    end
+
+    # Mischellaneous helpers
+
+    def attribute_get(name)
+      read_attribute(name)
+    end
+
+    def attribute_set(name, value)
+      write_attribute(name, value)
+    end
+
+    def attribute_dirty?(attribute)
+      changed_attributes.has_key?(attribute.to_s)
+    end
+
+    def dirty?
+      changed?
+    end
+
+    class OriginalValues
+      def initialize(model)
+        @model = model
+      end
+
+      def [](attribute)
+        @model.__send__ :"#{attribute}_was"
+      end
+    end
+
+    class ActiveRecord::Relation
+      def destroy!
+        destroy_all
+      end
+    end
+
+    def original_values
+      OriginalValues.new(self)
+    end
+
+    module ClassMethods
+
+      # RFC2822 (No attribution reference available)
+      EmailAddress = begin
+        alpha = "a-zA-Z"
+        digit = "0-9"
+        atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+        dot_atom_text = "#{atext}+([.]#{atext}*)*"
+        dot_atom = "#{dot_atom_text}"
+        qtext = '[^\\x0d\\x22\\x5c\\x8  0-\\xff]'
+        text = "[\\x01-\\x09\\x11\\x12\\x14-\\x7f]"
+        quoted_pair = "(\\x5c#{text})"
+        qcontent = "(?:#{qtext}|#{quoted_pair})"
+        quoted_string = "[\"]#{qcontent}+[\"]"
+        atom = "#{atext}+"
+        word = "(?:#{atom}|#{quoted_string})"
+        obs_local_part = "#{word}([.]#{word})*"
+        local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+        no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f"
+        dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+        dcontent = "(?:#{dtext}|#{quoted_pair})"
+        domain_literal = "\\[#{dcontent}+\\]"
+        obs_domain = "#{atom}([.]#{atom})*"
+        domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+        addr_spec = "#{local_part}\@#{domain}"
+        pattern = /^#{addr_spec}$/
+      end
+
+      # Helpers
+
+      # As in 'has n, :messages'
+      def n
+        1/0.0
+      end
+
+      class Property
+        attr_reader :name, :type
+
+        def initialize(name, type)
+          @name = name
+          @type = type
+        end
+      end
+
+      def properties
+        @__datamapper_shim_properties ||= Set.new
+      end
+
+      def storage_names
+        storage = Object.new
+        storage.instance_variable_set :@model, self
+
+        def storage.[]=(repo, name)
+          @model.table_name = name
+        end
+        storage
+      end
+
+      def timestamps(suffix)
+        # ActiveRecord handles timestamps (created_at, updated_at)
+        # automatically if the columns exist.
+      end
+
+      # Finders
+
+      def all(*args)
+        if args.empty?
+          scoped
+        else
+          where(*args)
+        end
+      end
+
+      def first(*args)
+        if args.empty?
+          scoped.first
+        else
+          where(*args).first
+        end
+      end
+
+      def get(*args)
+        find_by_id(*args)
+      end
+      # Model definition
+
+      def property(name, type, options = {})
+        properties << Property.new(name, type)
+
+        case
+        when type == Boolean
+          # property :trial, Boolean
+          #
+          # If the :trial column in the DB is created with TINYINT(4),
+          # Rails doesn't map it to a boolean type,
+          # so we need to coerce it here if necessary.
+          define_method name do
+            value = read_attribute(name)
+            if value.is_a? Integer
+              value.zero? ? false : true
+            else
+              value
+            end
+          end
+        when type.is_a?(Enum)
+          warn "Rails 4 handles enums out of the box."
+
+          # Attribute accessors for the property
+          self.instance_eval do
+            define_method(name) do
+              type[read_attribute(name)]
+            end
+
+            define_method("#{name}=") do |value|
+              value = value.is_a?(Integer) ? value : type[value]
+              write_attribute(name, value)
+            end
+          end
+
+          @__datamapper_shim_enums ||= {}
+          @__datamapper_shim_enums[name] = type
+
+          # Substitute enum values in where clauses
+          # Note, we don't define this on ActiveRecord::Relation
+          def self.where(opts, *rest)
+            @__datamapper_shim_enums.each do |name, enum|
+              if opts.has_key?(name) && !opts[name].is_a?(Integer)
+                opts[name] = enum[opts[name]]
+              end
+            end
+
+            super
+          end
+        when type == Json
+          serialize name, JSON
+        when type == List
+          serialize name, List.new
+        when type == ParanoidDateTime
+          self.instance_eval do
+            define_method :destroy do
+              update_attribute(name, Time.zone.try(:now) || Time.now)
+            end
+          end
+
+          default_scope where(:deleted_at => nil)
+
+          def self.with_deleted
+            self.unscoped.where("`#{self.table_name}`.deleted_at IS NOT NULL").scoping do
+              yield if block_given?
+            end
+          end
+        when type == Yaml
+          serialize name
+        end
+
+        if type == DateTime || type == ParanoidDateTime
+          # ActiveRecord maps datetime columns to TimeWithZone,
+          # which can have some slight inconsistencies with DateTime
+          self.instance_eval do
+            define_method "#{name}" do
+              read_attribute(name).try(:to_datetime)
+            end
+          end
+        end
+
+        if options.has_key?(:default)
+          default = options.delete(:default)
+          # :if => :class guarantees that the default value is always returned
+          attr_default(name, :if => :class, :persisted => false) do |record|
+            if record.new_record? && !record.__send__(:"#{name}_changed?")
+              default
+            else
+              record.instance_eval do
+                read_attribute(name)
+              end
+            end
+          end
+        end
+
+        if reader = options.delete(:reader)
+          self.instance_eval do
+            define_method name do
+              read_attribute(name)
+            end
+          end
+
+          case reader
+          when :private
+            private name
+          when :protected
+            protected name
+          else
+            raise "option :#{reader} for :reader not handled in shim"
+          end
+        end
+
+        if writer = options.delete(:writer)
+          self.instance_eval do
+            define_method(:"#{name}=") do |value|
+              write_attribute(name, value)
+            end
+          end
+
+          case writer
+          when :protected
+            protected :"#{name}="
+            attr_protected name
+          when :private
+            private :"#{name}="
+            attr_protected name
+          else
+            raise "option :#{writer} for :writer not handled in shim"
+          end
+        else
+          attr_accessible name
+        end
+
+        # http://rubydoc.info/github/datamapper/dm-core/master/DataMapper/Property
+        # No validation necessary here, as these just create a database index.
+        options.delete(:index)
+        options.delete(:unique_index)
+
+        # DataMapper does some default validation on certain datatypes, e.g.
+        # Strings can't have a length longer than 50 chars. ActiveRecord doesn't
+        # do any such validations, so we can ignore this option.
+        options.delete(:auto_validation)
+
+        # http://stackoverflow.com/questions/95061/stop-activerecord-from-loading-blob-column
+        # No obvious way to lazily load an attribute
+        options.delete(:lazy)
+
+        # Primary keys
+
+        if options.delete(:key)
+          @__datamapper_shim_primary_keys ||= []
+          @__datamapper_shim_primary_keys << name
+
+          self.primary_keys = *@__datamapper_shim_primary_keys
+          validates_presence_of name
+        end
+
+        # Validations
+
+        validation_options = {}
+
+        if length = options.delete(:length) || options.delete(:size)
+          validation_options.merge! :length => { :maximum => length }
+        end
+
+        if unique = options.delete(:unique)
+          validation_options.merge! :uniqueness => true
+        end
+
+        if format = options.delete(:format)
+          if format == :email_address
+            validation_options.merge! :format => { :with => EmailAddress }
+          else
+            validation_options.merge! :format => { :with => format }
+          end
+        end
+
+        # This needs to be checked last due to how
+        # :allow_nil works.
+        if options.has_key?(:nullable)
+          if options.delete(:nullable) == false
+            if type == Boolean
+              # http://stackoverflow.com/questions/7781174/rspec-validation-failed-attribute-cant-be-blank-but-it-isnt-blank
+              validation_options.merge! :inclusion => { :in => [true, false, 0, 1] }
+            else
+              validation_options.merge! :presence => true
+            end
+          else
+            # Can't add an :allow_nil option unless there's an actual
+            # validation happening.
+            unless validation_options.empty?
+              validation_options.merge! :allow_nil => true
+            end
+          end
+        end
+
+        validates(name, validation_options) unless validation_options.empty?
+        handle_leftover_options(options)
+      end
+
+      # Relationships
+
+      def has(cardinality, name, options = {})
+        relationship_options = {}
+
+        if class_name = options.delete(:class_name)
+          relationship_options.merge! :class_name => class_name
+        end
+
+        if foreign_key = options.delete(:child_key)
+          relationship_options.merge! :foreign_key => foreign_key
+        end
+
+        if key = options.delete(:association_foreign_key)
+          relationship_options.merge! :association_foreign_key => key
+        end
+
+        if order = options.delete(:order)
+          relationship_options.merge! :order => order
+        end
+
+        if inverse_of = options.delete(:inverse_of)
+          relationship_options.merge! :inverse_of => inverse_of
+        end
+
+        if mutable = options.delete(:mutable)
+          # no-op, ActiveRecord relationships are mutable by default
+        end
+
+       if constraint = options.delete(:constraint)
+          # https://github.com/datamapper/dm-constraints for more information on
+          # all possible values for :constraint
+          case constraint
+          when :protect
+            relationship_options[:dependent] = :restrict
+
+            # DataMapper returns false if a model can't be destroyed.
+            # Here, we capture the exception AR raises if a model
+            # can't be destroyed due to an association.
+            self.instance_eval do
+              define_method(:destroy) do
+                begin
+                  super
+                rescue ActiveRecord::DeleteRestrictionError => e
+                  false
+                end
+              end
+            end
+          when :destroy
+            relationship_options[:dependent] = :destroy
+          when :destroy!
+            relationship_options[:dependent] = :delete_all
+          when :set_nil
+            relationship_options[:dependent] = :nullify
+          when :skip
+            # no-op
+          end
+        end
+
+        if through = options.delete(:through)
+          if through == Resource
+            cardinality = -1
+          else
+            relationship_options.merge! :through => through
+          end
+        end
+
+        case cardinality
+        when -1
+          if relationship_options.key?(:dependent)
+            case dependent = relationship_options.delete(:dependent)
+            when :destroy
+              before_destroy do
+                self.__send__(name).each do |record|
+                  record.destroy
+                end
+              end
+            when :restrict
+              warn "ActiveRecord's HABTM doesn't support :dependent => :restrict; implement relationship as a has_many :through instead"
+            else
+              raise "Missing implementation for :#{dependent} constraint on #{name} for #{self}"
+            end
+          end
+
+          has_and_belongs_to_many name, relationship_options
+        when 1
+          has_one name, relationship_options
+        when n
+          has_many name, relationship_options
+        end
+
+        attr_accessible name
+        handle_leftover_options(options)
+      end
+
+      def belongs_to(name, options = {})
+        relationship_options = {}
+
+        if options.has_key?(:nullable) && options.delete(:nullable) == false
+          validates_presence_of name
+        end
+
+        if foreign_key = options.delete(:child_key)
+          if foreign_key.is_a?(Enumerable) && foreign_key.length == 1
+            foreign_key = foreign_key.first
+          end
+
+          relationship_options.merge! :foreign_key => foreign_key
+        end
+
+        if class_name = options.delete(:class_name)
+          relationship_options.merge! :class_name => class_name
+        end
+
+        if foreign_key = options.delete(:parent_key)
+          warn "Not handling parent_key options in belongs_to"
+        end
+
+        if inverse_of = options.delete(:inverse_of)
+          relationship_options.merge! :inverse_of => inverse_of
+        end
+
+        if autosave = options.delete(:autosave)
+          relationship_options.merge! :autosave => autosave
+        end
+
+        handle_leftover_options(options)
+        attr_accessible name
+        super name, relationship_options
+      end
+
+      # Callbacks
+
+      def after(event, callback = nil, &block)
+        case event
+        when :create
+          callback ? after_create(callback, &block) : after_create(&block)
+        when :save
+          callback ? after_save(callback, &block) : after_save(&block)
+        when :destroy
+          callback ? after_destroy(callback, &block) : after_destroy(&block)
+        else
+          raise "Implement `after #{event.inspect}` in DataMapper::Shim"
+        end
+      end
+
+      def before(event, callback = nil, &block)
+        case event
+        when :create
+          callback ? before_create(callback, &block) : before_create(&block)
+        when :save
+          callback ? before_save(callback, &block) : before_save(&block)
+        when :destroy
+          callback ? before_destroy(callback, &block) : before_destroy(&block)
+        when :valid?
+          # Per http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html,
+          # before_validation callbacks in AR cause a #save call to fail if they
+          # return false. Since this wasn't the case in DM, we need to wrap
+          # before_validation callbacks in a proc that always returns true.
+          if callback
+            raise "Need to handle before_validation with callback AND block" unless block.nil?
+            callback_with_true_return = proc do |*args|
+              self.__send__ callback
+              true
+            end
+            before_validation &callback_with_true_return
+          else
+            block_with_true_return = block && proc { |*args| self.instance_eval &block; true }
+            before_validation &block_with_true_return
+          end
+        when :update
+          callback ? before_update(callback, &block) : before_update(&block)
+        else
+          raise "Add before case statement for #{event} event"
+        end
+      end
+
+      # Validations
+
+      def validates_present(name, options = {})
+        validation_options = {}
+
+        if message = options.delete(:message)
+          validation_options.merge! :message => message
+        end
+
+        if condition = options.delete(:if)
+          validation_options.merge! :if => condition
+        end
+
+        if on = options.delete(:when)
+          if on.length > 1
+            raise "Can't handle :when option with more than one value (had #{on})"
+          else
+            validation_options.merge! :on => on.first
+          end
+        end
+
+        validates name, :presence => validation_options
+        handle_leftover_options(options)
+      end
+
+      def validates_is_unique(name, options = {})
+        validation_options = { :uniqueness => true }
+
+        if options.delete(:allow_nil)
+          validation_options.merge! :allow_nil => true
+        end
+
+        if scope = options.delete(:scope)
+          validation_options.merge! :uniqueness => { :scope => scope }
+        end
+
+        if condition = options.delete(:if)
+          validation_options.merge! :if => condition
+        end
+
+        validates name, validation_options
+        handle_leftover_options(options)
+      end
+
+      def validates_length(name, options)
+        validation_options = {}
+
+        if max = options.delete(:max)
+          validation_options.merge! :maximum => max
+        end
+
+        if max = options.delete(:maximum)
+          validation_options.merge! :maximum => max
+        end
+
+        if min = options.delete(:min)
+          validation_options.merge! :minimum => min
+        end
+
+        if condition = options.delete(:if)
+          validation_options.merge! :if => condition
+        end
+
+        if message = options.delete(:message)
+          validation_options.merge! :message => message
+        end
+
+        validates name, :length => validation_options
+        handle_leftover_options(options)
+      end
+
+      def validates_is_confirmed(name, options = {})
+        confirmation_options = { }
+
+        if message = options.delete(:message)
+          confirmation_options.merge! :message => message
+        end
+
+        if condition = options.delete(:if)
+          confirmation_options.merge! :if => condition
+        end
+
+        validates name, :confirmation => confirmation_options
+        validates :"#{name}_confirmation", :presence => true, :if => confirmation_options[:if]
+
+        handle_leftover_options(options)
+      end
+
+      def validates_with_block(name, &block)
+        validates_each name do |record, property_name|
+          valid, error_message = record.instance_exec(record.__send__(property_name), &block)
+          unless valid
+            record.errors.add(name, error_message)
+          end
+        end
+      end
+
+      def validates_format(name, options = {})
+        validation_options = {}
+
+        if with = options.delete(:with)
+          validation_options.merge! :format => { :with => with }
+        end
+
+        validates name, validation_options
+        handle_leftover_options(options)
+      end
+
+      def validates_within(name, options = {})
+        validation_options = {}
+
+        if set = options.delete(:set)
+          validation_options.merge! :inclusion => { :in => set }
+        end
+
+        validates name, validation_options
+        handle_leftover_options(options)
+      end
+
+      def validates_with_method(name, options)
+        validation_options = {}
+
+        if on = options.delete(:when)
+          case on
+          when Array
+            if on.length > 1
+              raise "Can't handle :when option with more than one value (had #{on})"
+            else
+              validation_options.merge! :on => on.first
+            end
+          else
+            validation_options.merge! :on => on
+          end
+        end
+
+        method = options.delete(:method)
+
+        # Validation methods made for DM return either true if the model validation passed,
+        # or [false, "error message"] if validation failed. Here we add the error message to
+        # the model's ActiveModel::Errors object.
+        block = proc do
+          valid, error_message = self.__send__ method
+          unless valid
+            self.errors.add(name, error_message)
+          end
+        end
+
+        validate validation_options, &block
+        handle_leftover_options(options)
+      end
+
+      protected
+
+      def handle_leftover_options(options)
+        return if options.empty?
+
+        method = caller[0][/`.*'/][1..-2]
+        message = "DataMapper::Shim##{method} doesn't yet handle #{options.inspect} (#{name})"
+
+        if RAISE_ON_UNHANDLED_OPTIONS
+          raise NotImplementedError, message
+        else
+          warn message
+        end
+      end
+    end
+  end
+end
+