ardm 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Mzk3NGRlZjc5N2E0Nzc4MjFkZmI5ZDA3MWNiNDVjNTE3NzQ1ZTM5Mg==
+  data.tar.gz: !binary |-
+    YmZlNzI5MzMzMjdlZDQwYjExZjcxYjZiNjA5YTkyZTBmM2QxOGZlMQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZmViYjY2MmFiMjRmOGZiM2U1M2ZhY2MyN2I4YzJhZDc4NDcyYTcwZWE3ODQy
+    MTA5OWQ2ODUzMmRhN2M3ZWM2MWUyODkxOWU0ZmU2OTFjZGIwN2Y1ZmVkZGNh
+    Nzk3M2I3NzhmOTNiZDcxNjVkY2E2ZWE2MTY1MmQ1NGIwMjc3OTI=
+  data.tar.gz: !binary |-
+    NzcxYzU2NDRiMjU5NjVkYTVhNjNiZGEyMGRhYWVlYmYxOTc2ZDBhN2Q0YjE2
+    NzI3MTYzNDg5ODRjZTY1Y2U1N2JiYmMzZDdmNDlhYTBkYmZiYTJiMmFjMjk1
+    MWUzMmExYjQ5NGQxN2IxZjc2ZTIwZGU0ZGIzNzE4ZGM5Y2JiYTg=

data/.gitignore

@@ -0,0 +1,35 @@
+## MAC OS
+.DS_Store
+._*
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+
+## PROJECT::GENERAL
+*.gem
+coverage
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.*
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'
+gem 'pry-debugger'
+
+group :test do
+  gem 'sqlite3'
+  gem 'activerecord', '~> 4.0.0'
+  gem 'addressable'
+  gem 'database_cleaner'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+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
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# Ardm
+
+ActiveRecord plugin to provide a smooth migration from DataMapper to ActiveRecord.
+
+## 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.
+
+* 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.
+* 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
+  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.
+
+## Installation
+
+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
+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
+all models that include DataMapper::Resource, remove it, and add Ardm::Record
+as the base class. If your model is STI, add it to the base model and remove
+DataMapper::Resource from all models.
+
+Example:
+
+    class MyModel
+      include DataMapper::Resource
+      # ...
+    end
+
+    # The model above changes to:
+
+    class MyModel < Ardm::Record
+      # ...
+    end
+
+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
+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'
+
+
+
+## Copyright
+
+This is an adaptation of the original DataMapper source code to allow
+users of the now defunct DataMapper to migrate to ActiveRecord.
+Much of this code was originally written by Sam Smoot and Dan Kubb as
+[dm-types](https://github.com/datamapper/dm-types) and
+[dm-core](https://github.com/datamapper/dm-core). See LICENSE for details.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/ardm.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ardm/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = [ 'Martin Emde', 'Dan Kubb' ]
+  gem.email         = [ "me@martinemde.com" ]
+  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.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.md]
+
+  gem.name          = "ardm"
+  gem.require_paths = [ "lib" ]
+  gem.version       = Ardm::VERSION
+
+  gem.add_runtime_dependency('activesupport', '>= 3.2')
+  gem.add_runtime_dependency('bcrypt-ruby',   '~> 3.0.0')
+  gem.add_runtime_dependency('fastercsv',     '~> 1.5.4')
+  gem.add_runtime_dependency('multi_json',    '> 1.3.2')
+  gem.add_runtime_dependency('stringex',      '~> 1.3.3')
+  gem.add_runtime_dependency('uuidtools',     '~> 2.1.2')
+  gem.add_runtime_dependency('coercible')
+
+  gem.add_development_dependency('rake',  '~> 0.9.2')
+  gem.add_development_dependency('rspec', '~> 2.0')
+end

data/db/.gitignore

@@ -0,0 +1 @@
+*.sqlite

data/lib/ardm/active_record/associations.rb

@@ -0,0 +1,80 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module Associations
+      extend ActiveSupport::Concern
+
+      def assign_attributes(attrs, *a)
+        new_attrs = attrs.inject({}) do |memo,(k,v)|
+          if assoc = self.class.reflect_on_association(k)
+            memo[assoc.foreign_key] = v && v.send(v.class.primary_key)
+          else
+            memo[k] = v
+          end
+          memo
+        end
+        super new_attrs, *a
+      end
+
+
+      # Convert options from DM style to AR style.
+      #
+      # Keep any unknown keys to use as conditions.
+      def self.convert_options(klass, options, *keep)
+        keep += [:class_name, :foreign_key]
+
+        ar = options.dup
+        ar[:class_name]  = ar.delete(:model)      if ar[:model]
+        ar[:foreign_key] = ar.delete(:child_key)  if ar[:child_key]
+        ar[:foreign_key] = ar[:foreign_key].first if ar[:foreign_key].respond_to?(:to_ary)
+
+        if ar[:foreign_key] && property = klass.properties[ar[:foreign_key]]
+          ar[:foreign_key] = property.field
+        end
+
+        if (conditions = ar.slice!(*keep)).any?
+          ar[:conditions] = conditions
+        end
+        ar
+      end
+
+      module ClassMethods
+        def belongs_to(field, options={})
+          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
+          nil
+        end
+
+        def n
+          "many"
+        end
+
+        def has(count, name, *args)
+          options = args.shift || {}
+
+          if String === options # has n, :name, 'Class', options: 'here'
+            options = (args.last || {}).merge(:model => options)
+          end
+
+          unless Hash === options
+            raise ArgumentError, "bad has #{count} options format #{options.inspect}"
+          end
+
+          options[:order] = Ardm::ActiveRecord::Query.order(self, options[:order]) if options[:order]
+          opts = Ardm::ActiveRecord::Associations.convert_options(self, options, :through, :order)
+
+          case count
+          when 1      then has_one  name, opts
+          when "many" then has_many name, opts
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ardm/active_record/base.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+
+require 'ardm/active_record/associations'
+require 'ardm/active_record/dirty'
+require 'ardm/active_record/hooks'
+require 'ardm/active_record/is'
+require 'ardm/active_record/inheritance'
+require 'ardm/active_record/property'
+require 'ardm/active_record/query'
+require 'ardm/active_record/repository'
+require 'ardm/active_record/storage_names'
+require 'ardm/active_record/validations'
+
+module Ardm
+  module ActiveRecord
+    # Include all the Ardm modules.
+    #
+    # You can use this directly if you want your own abstract base class.
+    #
+    #   require 'ardm/active_record/base'
+    #
+    #   class MyRecord < ActiveRecord::Base
+    #     include Ardm::ActiveRecord::Base
+    #   end
+    #
+    # Or Ardm::ActiveRecord::Base is built in to Ardm::Record
+    #
+    #   require 'ardm/active_record/record'
+    #
+    #   class MyRecord < Ardm::Record
+    #     # already included
+    #   end
+    #
+    module Base
+      extend ActiveSupport::Concern
+
+      include Ardm::ActiveRecord::Associations
+      include Ardm::ActiveRecord::Hooks
+      include Ardm::ActiveRecord::Dirty
+      include Ardm::ActiveRecord::Is
+      include Ardm::ActiveRecord::Inheritance
+      include Ardm::ActiveRecord::Property
+      include Ardm::ActiveRecord::Query
+      include Ardm::ActiveRecord::Repository
+      include Ardm::ActiveRecord::StorageNames
+      include Ardm::ActiveRecord::Validations
+    end
+  end
+end

data/lib/ardm/active_record/dirty.rb

@@ -0,0 +1,25 @@
+module Ardm
+  module ActiveRecord
+    module Dirty
+      def dirty?
+        changed?
+      end
+
+      def dirty_attributes
+        changes.inject({}) do |memo, (attr, val)|
+          property = properties[attr]
+          memo[property] = val
+          memo
+        end
+      end
+
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^([\w_]+)_dirty\?$/
+          send("#{$1}_changed?", *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/hooks.rb

@@ -0,0 +1,31 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module Hooks
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def before(event, meth=nil, &block)
+          _ardm_hook(:before, event, meth, &block)
+        end
+
+        def after(event, meth=nil, &block)
+          _ardm_hook(:after, event, meth, &block)
+        end
+
+        def _ardm_hook(order, event, meth=nil, &block)
+          if event.to_sym == :valid?
+            event = "validation"
+          end
+
+          if meth.nil?
+            send "#{order}_#{event}", &block
+          else
+            send "#{order}_#{event}", meth
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/inheritance.rb

@@ -0,0 +1,37 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module Inheritance
+      extend ActiveSupport::Concern
+
+      included do
+        # ActiveRecord would prefer that you not use the column "type"
+        # for anything other than single table inheritance.
+        # The solution is to point ActiveRecord elsewhere.
+        unless respond_to?(:inheritance_column=)
+          class_attribute :inheritance_column
+        end
+        self.inheritance_column = "override-active-record-default-sti-column-type"
+      end
+
+      module ClassMethods
+        def new(attrs={}, *a, &b)
+          type = attrs && attrs.stringify_keys[inheritance_column.to_s]
+          if type && type != name && type != self
+            #puts "STI found for #{type} #{self}"
+            con = type.is_a?(Class) ? type : type.constantize
+            if con < self
+              con.new(attrs, *a, &b)
+            else
+              raise "Tried to create subclass from #{type} (from key #{inheritance_column}) that is not a subclass of #{name}."
+            end
+          else
+            #puts "No STI found for #{self} (#{attrs.inspect})"
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/is/state_machine.rb

@@ -0,0 +1,21 @@
+module Ardm
+  module ActiveRecord
+    module Is
+      module StateMachine
+        extend ActiveSupport::Concern
+
+        included do
+          include AASM
+        end
+
+        module ClassMethods
+          def is_state_machine(options, &block)
+            STDERR.puts "TODO: dm state machine on #{self}"
+            property options[:column], Ardm::Property::String, default: options[:initial]
+            aasm column: options[:column], &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/is.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+require 'ardm/active_record/is/state_machine'
+
+module Ardm
+  module ActiveRecord
+    module Is
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def is(target, options={}, &block)
+          case target
+          when :state_machine
+            include Ardm::ActiveRecord::Is::StateMachine
+            is_state_machine(options, &block)
+          else
+            STDERR.puts "TODO: #{self} is #{target.inspect}, #{options.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ardm/active_record/not_found.rb

@@ -0,0 +1,7 @@
+require 'ardm/active_record/record'
+
+module Ardm
+  class Record < ::ActiveRecord::Base
+    NotFound = ::ActiveRecord::RecordNotFound
+  end
+end

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

@@ -0,0 +1,31 @@
+module Ardm
+  module ActiveRecord
+    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
+              attribute.eq(nil)
+            when 1
+              attribute.eq(values.first).or(attribute.eq(nil))
+            else
+              attribute.in(values).or(attribute.eq(nil))
+            end
+          else
+            attribute.in(values)
+          end
+
+          array_predicates = ranges.map { |range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+require 'active_support/concern'
+
+module Ardm
+  module ActiveRecord
+    module PredicateBuilder
+      module Rails3
+        extend ActiveSupport::Concern
+
+        Base       = ::ActiveRecord::Base
+        Relation   = ::ActiveRecord::Relation
+        Collection = ::ActiveRecord::Associations::CollectionProxy
+
+        included do
+          class << self
+            alias_method :original_build_from_hash, :build_from_hash
+          end
+
+          class_attribute :handlers
+          self.handlers = []
+
+          register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+          register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
+          register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
+          register_handler(Range, ->(attribute, value) { attribute.in(value) })
+          register_handler(Relation, RelationHandler.new)
+          register_handler(Collection, ArrayHandler.new)
+          register_handler(Array, ArrayHandler.new)
+        end
+
+        module ClassMethods
+          def resolve_column_aliases(klass, hash)
+            hash = hash.dup
+            hash.keys.grep(Symbol) do |key|
+              if klass.attribute_alias? key
+                hash[klass.attribute_alias(key)] = hash.delete key
+              end
+            end
+            hash
+          end
+
+          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
+
+            attributes.each do |column, value|
+              table = default_table
+
+              if value.is_a?(Hash)
+                if value.empty?
+                  queries << '1=0'
+                else
+                  table       = Arel::Table.new(column, default_table.engine)
+                  association = klass.reflect_on_association(column.to_sym)
+
+                  value.each do |k, v|
+                    queries.concat expand(association && association.klass, table, k, v)
+                  end
+                end
+              else
+                if Ardm::Query::Operator === column
+                  original = column
+                  operator = column.operator
+                  column   = column.target.to_s
+                else
+                  column = column.to_s
+                end
+
+                if column.include?('.')
+                  table_name, column = column.split('.', 2)
+                  table = Arel::Table.new(table_name, default_table.engine)
+                end
+
+                query = expand(klass, table, column, value)
+                # TODO make nicer
+                if operator == :not
+                  # Logical not factorization !(a && b) == (!a || !b)
+                  query.map! &:not
+                  query = [query.inject { |composite, predicate| composite.or(predicate) }]
+                end
+                queries.concat query
+              end
+            end
+
+            queries
+          end
+
+          def expand(klass, table, column, value)
+            queries = []
+
+            # 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)
+              end
+            end
+
+            #puts "expand(#{klass.name}, #{column.inspect}, #{value.inspect})"
+
+            queries << build(table[column], value)
+            queries
+          end
+
+          def references(attributes)
+            attributes.map do |key, value|
+              if value.is_a?(Hash)
+                key
+              else
+                key = key.to_s
+                key.split('.').first if key.include?('.')
+              end
+            end.compact
+          end
+
+          # Define how a class is converted to Arel nodes when passed to +where+.
+          # The handler can be any object that responds to +call+, and will be used
+          # for any value that +===+ the class given. For example:
+          #
+          #     MyCustomDateRange = Struct.new(:start, :end)
+          #     handler = proc do |column, range|
+          #       Arel::Nodes::Between.new(column,
+          #         Arel::Nodes::And.new([range.start, range.end])
+          #       )
+          #     end
+          #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
+          def register_handler(klass, handler)
+            handlers.unshift([klass, handler])
+          end
+
+          private
+
+          def build(attribute, value)
+            handler_for(value).call(attribute, value)
+          end
+
+          def handler_for(object)
+            handlers.detect { |klass, _| klass === object }.last
+          end
+        end
+      end
+    end
+  end
+end