ardm 0.0.1 → 0.1.0

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

@@ -78,25 +78,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 && value.is_a?(Base) && reflection = klass.reflect_on_association(column.to_sym)
-              if 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
-
-              column = reflection.foreign_key
+              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
-
-            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)

data/lib/ardm/active_record/property.rb

@@ -51,7 +51,7 @@ module Ardm
           # use that class rather than the primitive
           klass = Ardm::Property.determine_class(type)
 
-          unless klass
+          if !klass || klass == NilClass
             raise ArgumentError, "+type+ was #{type.inspect}, which is not a supported type"
           end
 
@@ -100,7 +100,11 @@ module Ardm
         end
 
         def columns
-          @columns ||= properties.map do |property|
+          @columns ||= _ardm_load_columns
+        end
+
+        def _ardm_load_columns
+          properties.map do |property|
             sql_type = connection.type_to_sql(
               property.dump_as.name.to_sym,
               property.options[:limit],
@@ -109,8 +113,7 @@ module Ardm
             )
 
             column = ::ActiveRecord::ConnectionAdapters::Column.new(
-              #property.name.to_s,
-              property.field.to_s,
+              property.field.to_s, #property.name.to_s,
               nil,#property.dump(property.default),
               sql_type,
               property.allow_nil?
@@ -141,6 +144,13 @@ module Ardm
           end
         end
 
+        def assert_valid_attributes(options)
+          options.each do |key, value|
+            property = properties[key]
+            property.assert_valid_value(value)
+          end
+        end
+
         # Gets the list of key fields for this Model
         #
         # @return [Array]
@@ -280,19 +290,21 @@ module Ardm
 
       # This not the same as read_attribute in AR
       def attribute_get(name)
-        property = self.class.properties[name]
-        val = read_attribute property.field
-        if new_record? && val.nil? && property.default?
-          write_attribute property.field, property.typecast(property.default_for(self))
+        if property = self.class.properties[name]
+          val = read_attribute property.field
+          if new_record? && val.nil? && property.default?
+            write_attribute property.field, property.typecast(property.default_for(self))
+          end
+          read_attribute property.field
         end
-        read_attribute property.field
       end
 
       # This not the same as write_attribute in AR
       def attribute_set(name, value)
-        property = self.class.properties[name]
-        write_attribute property.field, property.typecast(value)
-        read_attribute property.field
+        if property = self.class.properties[name]
+          write_attribute property.field, property.typecast(value)
+          read_attribute property.field
+        end
       end
 
       # Retrieve the key(s) for this resource.

data/lib/ardm/active_record/query.rb

@@ -52,10 +52,18 @@ module Ardm
         end
 
         def get(id)
-          all(id: id).first
+          if Array === id && id.size == 1
+            # Model#key returns an array
+            id = id.first
+          end
+          where(primary_key => id).first
         end
 
         def get!(id)
+          if Array === id && id.size == 1
+            # Model#key returns an array
+            id = id.first
+          end
           find(id)
         end
 
@@ -71,23 +79,6 @@ module Ardm
           all(find_params).first_or_initialize
         end
 
-        #def first(args=nil)
-        #  if Hash === args
-        #    all(args).first
-        #  else
-        #    puts "#{self}.first(#{args.inspect})"
-        #    puts caller[0..1]
-        #    super(args)
-        #  end
-        #end
-
-        #def all(options={})
-        #  puts "#{self}.all(#{options.inspect})"
-        #  puts caller[0..1]
-        #  binding.pry if options[:account]
-        #  Ardm::Query.all(self, options)
-        #end
-
         #def exist?(options={})
         #  puts "#{self}.exist?(#{options.inspect})"
         #  puts caller[0..10]

data/lib/ardm/active_record/record.rb

@@ -9,42 +9,85 @@ module Ardm
 
       self.abstract_class = true
 
-      JSON = Json
+      class_attribute :raise_on_save_failure
+      self.raise_on_save_failure = false
 
-      def self.finalize
-      end
+      JSON = Json
 
       def self.execute_sql(sql)
         connection.execute(sql)
       end
 
       def self.property(property_name, property_type, options={})
-        property = super
+        prop = super
         begin
-        attr_accessible property.name
-        attr_accessible property.field
+        attr_accessible prop.name
+        attr_accessible prop.field
         rescue => e
-          puts "WARNING: Error silenced. FIXME before release.\n#{e}"
+          puts "WARNING: Error silenced. FIXME before release.\n#{e}" unless $attr_accessible_warning
+          $attr_accessible_warning = true
         end
-        property
+        prop
       end
 
       # no-op in active record
-      def self.timestamps(*a)
+      def self.timestamps(at=:at)
+        case at
+        when :at
+          property :created_at, DateTime
+          property :updated_at, DateTime
+        when :on
+          property :created_on, Date
+          property :updated_on, Date
+        else
+          raise ArgumentError, "Unknown argument: timestamps(#{at.inspect})"
+        end
+      end
+
+      # The reflections returned here don't look like datamapper relationships.
+      # @todo improve this if needed with a wrapper
+      def self.relationships
+        reflections
+      end
+
+      def self.update(*a)
+        options = dump_properties_hash(a.first)
+        options = dump_associations_hash(options)
+        assert_valid_attributes(options)
+        update_all(options) != 0
       end
 
-      def key
-        id
+      def self.update!(*a)
+        options = dump_properties_hash(a.first)
+        options = dump_associations_hash(options)
+        assert_valid_attributes(options)
+        update_all(options) != 0
+      end
+
+      def self.destroy(*a)
+        destroy_all
+      end
+
+      def self.destroy!(*a)
+        delete_all
       end
 
       def new?
         new_record?
       end
 
+      def saved?
+        !new_record?
+      end
+
       def save_self(*)
         save
       end
 
+      def save
+        super || (raise_on_save_failure && raise(Ardm::SaveFailureError, "Save Failed"))
+      end
+
       def update(*a)
         if a.size == 1
           update_attributes(*a)

data/lib/ardm/active_record/relation.rb

@@ -1,5 +1,5 @@
 require 'active_support/concern'
-require 'active_record'
+require 'ardm/active_record/collection'
 
 module Ardm
   module ActiveRecord
@@ -15,7 +15,8 @@ module Ardm
           def update(*a)
             if a.size == 1
               # need to translate attributes
-              options = @klass.send(:dump_properties_hash, a.first)
+              options = @klass.dump_properties_hash(a.first)
+              options = @klass.dump_associations_hash(options)
               update_all(options)
             else
               update_without_ardm(*a)
@@ -48,13 +49,42 @@ module Ardm
         apply_finder_options(options)
       end
 
+      #def apply_finder_options(options)
+      #  return super if options.nil? || options.empty?
+      #  options = options.dup
+      #  conditions = options.slice!(*::ActiveRecord::SpawnMethods::VALID_FIND_OPTIONS)
+      #  super(options).where(conditions)
+      #end
+
+      VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
+        :order, :select, :readonly, :group, :having, :from, :lock ]
+
+      # We used to just patch this, like above, but we need to copy it over
+      # completely for rails4 since it no longer supports the old style finder
+      # methods that act more like the datamapper finders.
       def apply_finder_options(options)
-        return super if options.nil? || options.empty?
-        options = options.dup
-        conditions = options.slice!(*::ActiveRecord::SpawnMethods::VALID_FIND_OPTIONS)
-        super(options).where(conditions)
+        relation = clone
+        return relation if options.nil?
+
+        finders = options.dup
+        finders[:select] = finders.delete(:fields)
+        conditions = finders.slice!(*VALID_FIND_OPTIONS)
+
+        finders.delete_if { |key, value| value.nil? && key != :limit }
+
+        ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
+          relation = relation.send(finder, finders[finder])
+        end
+
+        relation = relation.where(conditions)           if conditions.any?
+        relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+        relation = relation.includes(finders[:include]) if options.has_key?(:include)
+        relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
+
+        relation
       end
 
+
       def calculate(operation, column_name, options={})
         if property = properties[column_name]
           column_name = property.field

data/lib/ardm/active_record/repository.rb

@@ -5,12 +5,16 @@ module Ardm
     module Repository
       extend ActiveSupport::Concern
 
-      def repository
+      def repository(name=nil)
         self.class.repository
       end
 
       module ClassMethods
-        def repository
+        def repository(name=nil)
+          if name && name != :default
+            raise Ardm::NotImplemented, "Alternate repository names not supported"
+          end
+
           if block_given?
             yield
           else

data/lib/ardm/data_mapper.rb

@@ -2,4 +2,6 @@ require 'ardm/data_mapper/record'
 
 module Ardm
   Record = Ardm::DataMapper::Record
+  SaveFailureError = ::DataMapper::SaveFailureError
+  RecordNotFound = ::DataMapper::ObjectNotFoundError
 end

data/lib/ardm/data_mapper/record.rb

@@ -5,12 +5,11 @@ module Ardm
     module Record
       extend ActiveSupport::Concern
 
-      NotFound = DataMapper::ObjectNotFoundError
-
       module ClassMethods
+        extend Forwardable
+
         def inherited(base)
           base.send(:include, DataMapper::Resource)
-          base.send(:include, Awsm::Resource)
           #base.send(:extend, DataMapper::CollectionRaise)
 
           unless %w[Alert Association Nonce Account::Cancellation::Handler].include?(base.name)
@@ -18,13 +17,8 @@ module Ardm
           end
         end
 
-        extend Forwardable
-        def datamapper() DataMapper end
         def_delegators :datamapper, :repository, :finalize, :logger, :logger=
-
-          def execute_sql(sql)
-            DataMapper.repository.adapter.execute(sql)
-          end
+        def datamapper() DataMapper end
 
         def alias_attribute(new, old)
           alias_method new, old

data/lib/ardm/version.rb

@@ -1,3 +1,3 @@
 module Ardm
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/spec/ardm/datamapper_constants_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Ardm::ActiveRecord::DataMapperConstantProxy do
+  it 'defines Resource' do
+    expect(described_class::Resource).to be_kind_of(Module)
+  end
+
+  it 'defines ObjectNotFoundError to ActiveRecord::RecordNotFound' do
+    expect(described_class::ObjectNotFoundError).to be(ActiveRecord::RecordNotFound)
+  end
+
+  it 'defines SaveFailureError to ActiveRecord::RecordNotSaved' do
+    expect(described_class::SaveFailureError).to be(ActiveRecord::RecordNotSaved)
+  end
+
+  it 'responds to finalize' do
+    expect(described_class.respond_to?(:finalize)).to be_truthy
+  end
+
+  it 'responds to repository' do
+    expect(described_class.respond_to?(:repository)).to be_truthy
+  end
+
+  it 'responds to logger' do
+    expect(described_class.respond_to?(:logger)).to be_truthy
+  end
+
+  it 'responds to logger=' do
+    expect(described_class.respond_to?(:logger=)).to be_truthy
+  end
+end

data/spec/fixtures/article.rb

@@ -14,6 +14,8 @@ module Ardm
 
       property :slug, Slug
 
+      timestamps :at
+
       before_validation do
         self.slug = self.title
       end