ardm 0.0.1 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Mzk3NGRlZjc5N2E0Nzc4MjFkZmI5ZDA3MWNiNDVjNTE3NzQ1ZTM5Mg==
-  data.tar.gz: !binary |-
-    YmZlNzI5MzMzMjdlZDQwYjExZjcxYjZiNjA5YTkyZTBmM2QxOGZlMQ==
+SHA1:
+  metadata.gz: 866545bbe125ccbada17fad21e0fcc1b3ff15fa0
+  data.tar.gz: 6d5ebf8a7cf672ec89125d8bace07470229ecd33
 SHA512:
-  metadata.gz: !binary |-
-    ZmViYjY2MmFiMjRmOGZiM2U1M2ZhY2MyN2I4YzJhZDc4NDcyYTcwZWE3ODQy
-    MTA5OWQ2ODUzMmRhN2M3ZWM2MWUyODkxOWU0ZmU2OTFjZGIwN2Y1ZmVkZGNh
-    Nzk3M2I3NzhmOTNiZDcxNjVkY2E2ZWE2MTY1MmQ1NGIwMjc3OTI=
-  data.tar.gz: !binary |-
-    NzcxYzU2NDRiMjU5NjVkYTVhNjNiZGEyMGRhYWVlYmYxOTc2ZDBhN2Q0YjE2
-    NzI3MTYzNDg5ODRjZTY1Y2U1N2JiYmMzZDdmNDlhYTBkYmZiYTJiMmFjMjk1
-    MWUzMmExYjQ5NGQxN2IxZjc2ZTIwZGU0ZGIzNzE4ZGM5Y2JiYTg=
+  metadata.gz: 60564ee06c22d8e54564a87ec294896b74f6753f2ce004cc615f325ef8521025eeaf821d7fb3e359de45b9a9ef3124b4ae663ebe6b26849b93ae494d121b8346
+  data.tar.gz: 7403cb0bbd7f8b636b572267977a9302fa4e35c4027bcede569b77f49645027df75e4ab1db2658e3976fbf0e773fa5b6748f169d9c82774cec728dd3c9dee572

data/Gemfile

@@ -3,11 +3,10 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'pry'
-gem 'pry-debugger'
 
 group :test do
   gem 'sqlite3'
-  gem 'activerecord', '~> 4.0.0'
+  gem 'activerecord', '~> 3.2'
   gem 'addressable'
   gem 'database_cleaner'
 end

data/LICENSE

@@ -1,5 +1,5 @@
-Code to adapt dm-types and dm-core properties to Active Record copyright (c) 2013 Martin Emde
-Code from dm-types and dm-core originally Copyright (c) 2011 Sam Smoot, Dan Kubb
+Adaptation of dm-core to run atop Active Record Copyright (c) 2013 Engine Yard
+dm-types and dm-core source code Copyright (c) 2011 Sam Smoot, Dan Kubb
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,32 +2,44 @@
 
 ActiveRecord plugin to provide a smooth migration from DataMapper to ActiveRecord.
 
+This code is currently in development and not feature complete.
+Your code is probably different than mine, so please contribute to bridge
+the gap from DataMapper to ActiveRecord and Rails 4.
+
 ## Why
 
 Ardm is intended for applications running Rails with DataMapper 1.2 who need
-to migrate to ActiveRecord. Lets examine some of the reasons why you might
-move to ActiveRecord.
+to migrate to ActiveRecord so they can move forward onto Rails 4.
+Lets examine some of the reasons why you might move to ActiveRecord.
 
 * DataMapper is no longer under development. Ruby Object Mapper (ROM) is the
-  imlicit replacement for DataMapper, but it's not a supported migration. ROM
-  is a completely new codebase and very few of the idioms transfer.
+  implicit replacement for DataMapper, but it's not a supported migration.
+  ROM is a completely new codebase and very few of the idioms transfer.
 * DataMapper produces inefficient queries. Includes, joins, and subqueries are
   either not supported or incorrect. Enabling subqueries in DM speeds up queries
   but causes other subtle query problems than can produce bad SQL that may
   select incorrect records.
-* DataMapper cannot currently run on Rails4. Someone may take the initiative to
+* DataMapper cannot currently run on Rails 4. Someone may take the initiative to
   upgrade DataMapper to work on Rails4, but I think you're much better off
   moving to ActiveRecord.
 * Arel is awesome. ActiveRecord and Arel together is quite nice. With the added
-  support properties and the advances in Rails4, I think this upgrade is a must.
-* ActiveRecord is used in more applications, better tested, and more performant.
+  support properties and the advances in Rails 4, I think this upgrade is a must.
+* ActiveRecord is used in more applications, is better tested, and is more
+  performant than DataMapper.
 
 ## Installation
 
-Incremental migration from DataMapper to ActiveRecord.
+    require 'ardm'
+
+Run your project using the ORM environment variable.
+
+    ORM=activerecord bundle exec rake spec
+    ORM=datamapper bundle exec rake spec
+
+## Incremental migration from DataMapper to ActiveRecord
 
-ActiveRecord requires your models to inherit from ActiveRecord::Base, but makes
-it difficult to approach the migration incrementally. All or nothing is a scary
+ActiveRecord requires your models to inherit from ActiveRecord::Base, which makes
+it difficult to approach this migration incrementally. All or nothing is a scary
 way to switch ORMs. To solve this, Ardm supplies Ardm::Record.
 
 Ardm::Record will be the new base class. You'll need to search and replace
@@ -50,16 +62,60 @@ Example:
 
 With this new base clase you can switch between ActiveRecord and DataMapper
 by flipping a swith in your application. This approach allows you to continue
-developing your application in DataMapper while you work on teasing out all
+developing your application in DataMapper while you work on removing all
 the "datamapper-isms" from your code. This library attempts to take care of
 most DataMapper features, but there are probably tons of small variations
 that are not accounted for.
 
-## Usage
-
-  require 'ardm'
-
-
+## General Strategy
+
+This is a complex thing to approach. I'm hoping this project can make this move
+into a repeatable strategy rather than everyone needing to create their own
+unique solution.
+
+1. Get the application running with Ardm installed. Don't even think about
+   ActiveRecord until you have Ardm working in DataMapper mode and you can
+   deploy your application normally with ardm installed.
+2. Start to remove references to `DataMapper` by using the conversions
+   mentioned below. The idea is to remove the `DataMapper` constant completely
+   so you can run without `dm-core` when in ActiveRecord mode.
+3. Once your application runs smoothly in DataMapper mode with all the
+   constants using Ardm, try to get the application to start the test run
+   in ActiveRecord mode. This will probably require a bunch of hunting through
+   the application for datamapper-isms that are not accounted for in Ardm.
+   **Please help by contributing these fixes back to Ardm!**
+4. Make all your tests pass in ActiveRecord and DataMapper mode. This is an
+   ideal. You could decide that you're close enough and start sacrificing
+   DataMapper specific code for ActiveRecord code. You can branch around
+   picky code with the `Ardme.activerecord?` and `Ardm.datamapper?` helpers.
+
+## Conversions
+
+Things that access DataMapper directly can be replaced with Ardm invocations:
+
+    DataMapper.finalize    =>  Ardm::Record.finalize (no-op in AR mode)
+    DataMapper.repository  =>  Ardm::Record.repository
+    DataMapper.logger      =>  Ardm::Record.logger
+
+    DataMapper::ObjectNotFoundError => Ardm::Record::NotFound
+    ActiveRecord::RecordNotFound    => Ardm::Record::NotFound
+
+    DataMapper::Property           =>  Ardm::Property
+    DataMapper::Property::String   =>  Ardm::Property::String
+
+This pattern follows for most DataMapper module methods. When running in
+DataMapper mode, these simply forward. In ActiveRecord mode, they provide
+adapters for accessing the same data through ActiveRecord.
+
+If you run into code that is particularly difficult to convert, you can
+duplicate the code and write a different version for each ORM:
+
+    if Ardm.activerecord?
+      Thing.where(Thing.arel_table[:field].matches('something'))
+    else
+      # This is just an example. This should actually work fine in Ardm.
+      Thing.all(:field.like => 'something')
+    end
 
 ## Copyright
 

data/ardm.gemspec

@@ -7,6 +7,7 @@ Gem::Specification.new do |gem|
   gem.summary       = "ActiveRecord plugin to provide a smooth migration from DataMapper to ActiveRecord"
   gem.description   = gem.summary
   gem.homepage      = "http://github.com/engineyard/ardm"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")

data/lib/ardm.rb

@@ -1,5 +1,6 @@
-puts __FILE__
 module Ardm
+  NotImplemented = Class.new(RuntimeError)
+
   # Check which ORM is loaded in Ardm.
   #
   # @api public

data/lib/ardm/active_record.rb

@@ -1,4 +1,3 @@
-puts __FILE__
 require 'ardm'
 
 # only load support libs in active record mode (dm will supply its own libs)
@@ -29,11 +28,19 @@ require 'active_record/relation'
 
 require 'ardm/active_record/record'
 require 'ardm/active_record/relation'
+require 'ardm/active_record/data_mapper_constant_proxy'
 
 module Ardm
   Record = Ardm::ActiveRecord::Record
+  SaveFailureError = ::ActiveRecord::RecordNotSaved
+  RecordNotFound = ::ActiveRecord::RecordNotFound
+
+  def self.define_datamapper_constant!
+    require 'ardm/active_record/data_mapper_constant'
+  end
 end
 
+
 #::ActiveRecord::Base.class_eval do
 #  include Ardm::ActiveRecord::Base
 #end

data/lib/ardm/active_record/associations.rb

@@ -40,13 +40,42 @@ module Ardm
       end
 
       module ClassMethods
-        def belongs_to(field, options={})
+
+        def dump_associations_hash(options)
+          options.inject({}) do |new_attrs, (key, value)|
+            if reflection = reflect_on_association(key.to_sym)
+              if value.is_a?(ActiveRecord::Base)
+                new_attrs[reflection.foreign_key] = value.id
+                if reflection.respond_to?(:polymorphic?) && reflection.polymorphic?
+                  new_attrs[reflection.foreign_type] = value.class.base_class
+                end
+              else
+                new_attrs[reflection.foreign_key] = value
+              end
+            else
+              new_attrs[key] = value
+            end
+            new_attrs
+          end
+        end
+
+        def belongs_to(field, *args)
+          options = args.shift || {}
+
+          if String === options || Class === options # belongs_to :name, 'Class', options: 'here'
+            options = (args.last || {}).merge(:model => options.to_s)
+          end
+
+          unless Hash === options
+            raise ArgumentError, "bad belongs_to #{field} options format #{options.inspect}"
+          end
+
           options.delete(:default)
           options.delete(:required)
           opts = Ardm::ActiveRecord::Associations.convert_options(self, options)
           super field, opts
           assoc = reflect_on_association(field)
-          property assoc.foreign_key, Ardm::Property::Integer
+          property assoc.foreign_key, assoc.klass.key.first.class
           nil
         end
 
@@ -57,8 +86,8 @@ module Ardm
         def has(count, name, *args)
           options = args.shift || {}
 
-          if String === options # has n, :name, 'Class', options: 'here'
-            options = (args.last || {}).merge(:model => options)
+          if String === options || Class === options # has n, :name, 'Class', options: 'here'
+            options = (args.last || {}).merge(:model => options.to_s)
           end
 
           unless Hash === options

data/lib/ardm/active_record/base.rb

@@ -2,6 +2,7 @@ require 'active_support/concern'
 
 require 'ardm/active_record/associations'
 require 'ardm/active_record/dirty'
+require 'ardm/active_record/finalize'
 require 'ardm/active_record/hooks'
 require 'ardm/active_record/is'
 require 'ardm/active_record/inheritance'
@@ -35,6 +36,7 @@ module Ardm
       extend ActiveSupport::Concern
 
       include Ardm::ActiveRecord::Associations
+      include Ardm::ActiveRecord::Finalize
       include Ardm::ActiveRecord::Hooks
       include Ardm::ActiveRecord::Dirty
       include Ardm::ActiveRecord::Is

data/lib/ardm/active_record/collection.rb

@@ -0,0 +1,5 @@
+require 'active_record/relation'
+
+module Ardm
+  Collection = ::ActiveRecord::Relation
+end

data/lib/ardm/active_record/data_mapper_constant.rb

@@ -0,0 +1 @@
+::DataMapper = Ardm::ActiveRecord::DataMapperConstantProxy

data/lib/ardm/active_record/data_mapper_constant_proxy.rb

@@ -0,0 +1,24 @@
+module Ardm
+  module ActiveRecord
+    module DataMapperConstantProxy
+
+      class << self
+        extend Forwardable
+        def_delegators 'Ardm::Record',
+          :finalize,
+          :repository,
+          :logger,
+          :logger=
+      end
+
+      module Resource
+      end
+
+      ObjectNotFoundError = ::ActiveRecord::RecordNotFound
+      SaveFailureError = ::ActiveRecord::RecordNotSaved
+
+      Property = Ardm::Property
+      Collection = Ardm::Collection
+    end
+  end
+end

data/lib/ardm/active_record/finalize.rb

@@ -0,0 +1,18 @@
+module Ardm
+  module ActiveRecord
+    module Finalize
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :on_finalize
+        self.on_finalize = []
+      end
+
+      module ClassMethods
+        def finalize
+          on_finalize.each { |f| f.call }
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/predicate_builder/array_handler.rb

@@ -3,27 +3,21 @@ module Ardm
     module PredicateBuilder
       class ArrayHandler # :nodoc:
         def call(attribute, value)
-          values = value.map { |x| x.is_a?(::ActiveRecord::Base) ? x.id : x }
-          ranges, values = values.partition { |v| v.is_a?(::Range) }
-
-          values_predicate = if values.include?(nil)
-            values = values.compact
-
-            case values.length
-            when 0
+          if value.include?(nil)
+            values = value.compact
+            if values.length == 0
               attribute.eq(nil)
-            when 1
-              attribute.eq(values.first).or(attribute.eq(nil))
             else
-              attribute.in(values).or(attribute.eq(nil))
+              call(attribute, values).or(attribute.eq(nil))
             end
           else
-            attribute.in(values)
-          end
+            values = value.map { |x| x.is_a?(::ActiveRecord::Base) ? x.id : x }
+            ranges, values = values.partition { |v| v.is_a?(::Range) }
 
-          array_predicates = ranges.map { |range| attribute.in(range) }
-          array_predicates << values_predicate
-          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+            array_predicates = ranges.map { |range| attribute.in(range) }
+            array_predicates << attribute.in(values)
+            array_predicates.inject { |composite, predicate| composite.or(predicate) }
+          end
         end
       end
     end

data/lib/ardm/active_record/predicate_builder/rails3.rb

@@ -40,7 +40,9 @@ module Ardm
 
           def build_from_hash(klass, attributes, default_table)
             queries = []
-            klass = attributes.klass # HAX (this method is added to the attributes hash by expand_hash_conditions_for_aggregates
+            # HAX (this method is added to the attributes hash by expand_hash_conditions_for_aggregates
+            # Rails 3 calls build_form_hash with the first arg that is not the klass.
+            klass = attributes.klass
 
             attributes.each do |column, value|
               table = default_table
@@ -85,26 +87,51 @@ module Ardm
           end
 
           def expand(klass, table, column, value)
-            queries = []
+            if klass && association = klass.reflect_on_association(column.to_sym)
+              expand_association(association, table, column, value)
+            else
+              [build(table[column], value)]
+            end
+          end
 
-            # Find the foreign key when using queries such as:
-            # Post.where(author: author)
-            #
-            # For polymorphic relationships, find the foreign key and type:
-            # PriceEstimate.where(estimate_of: treasure)
-            if klass && reflection = klass.reflect_on_association(column.to_sym)
-              column = reflection.foreign_key
-              if value.is_a?(Base) && reflection.respond_to?(:polymorphic?) && reflection.polymorphic?
-                queries << build(table[reflection.foreign_type], value.class.base_class)
+          # Find the foreign key when using queries such as:
+          # Post.where(author: author)
+          #
+          # For polymorphic relationships, find the foreign key and type:
+          # PriceEstimate.where(estimate_of: treasure)
+          #
+          # Attempt to build a query that makes sense for an association name
+          # in the query, but if we can't generate a propery query, fallback
+          # to using the original key we received.
+          def expand_association(association, table, column, value)
+            queries = []
+            case association.macro
+            when :belongs_to
+              if association.polymorphic? && base_class = polymorphic_base_class_from_value(value)
+                queries << build(table[association.foreign_type], base_class)
               end
+              queries << build(table[association.foreign_key], value)
+            when :has_many, :has_one
+              table = Arel::Table.new(association.klass.table_name, table.engine)
+              queries << build(table[association.klass.primary_key], value)
+            else
+              queries << build(table[column], value)
             end
-
-            #puts "expand(#{klass.name}, #{column.inspect}, #{value.inspect})"
-
-            queries << build(table[column], value)
             queries
           end
 
+          def polymorphic_base_class_from_value(value)
+            case value
+            when Relation
+              value.klass.base_class
+            when Array
+              val = value.compact.first
+              val.class.base_class if val.is_a?(Base)
+            when Base
+              value.class.base_class
+            end
+          end
+
           def references(attributes)
             attributes.map do |key, value|
               if value.is_a?(Hash)