active_data 0.3.0 → 1.0.0

data/lib/active_data/active_record/associations.rb

@@ -0,0 +1,50 @@
+module ActiveData
+  module ActiveRecord
+    module Associations
+      module Reflections
+        class EmbedsOne < ActiveData::Model::Associations::Reflections::EmbedsOne
+          def is_a? klass
+            super || klass == ::ActiveRecord::Reflection::AssociationReflection
+          end
+        end
+
+        class EmbedsMany < ActiveData::Model::Associations::Reflections::EmbedsMany
+          def is_a? klass
+            super || klass == ::ActiveRecord::Reflection::AssociationReflection
+          end
+        end
+      end
+
+      extend ActiveSupport::Concern
+
+      included do
+        { embeds_many: Reflections::EmbedsMany, embeds_one: Reflections::EmbedsOne }.each do |(name, reflection_class)|
+          define_singleton_method name do |name, options = {}, &block|
+            reflection = reflection_class.build(self, self, name, options.reverse_merge(
+              read: ->(reflection, object) {
+                value = object.read_attribute(reflection.name)
+                JSON.parse(value) if value.present?
+              },
+              write: ->(reflection, object, value) {
+                object.send(:write_attribute, reflection.name, value ? value.to_json : nil)
+              }
+            ), &block)
+            if ::ActiveRecord::Reflection.respond_to? :add_reflection
+              ::ActiveRecord::Reflection.add_reflection self, reflection.name, reflection
+            else
+              self.reflections = reflections.merge(reflection.name => reflection)
+            end
+
+            callback_name = :"update_#{reflection.name}_association"
+            before_save callback_name
+            class_eval <<-METHOD, __FILE__, __LINE__ + 1
+              def #{callback_name}
+                association(:#{reflection.name}).apply_changes!
+              end
+            METHOD
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/active_record/nested_attributes.rb

@@ -0,0 +1,24 @@
+module ActiveData
+  module ActiveRecord
+    module NestedAttributes
+      extend ActiveSupport::Concern
+
+      included do
+        singleton_class.alias_method_chain :accepts_nested_attributes_for, :active_data
+      end
+
+      module ClassMethods
+        def accepts_nested_attributes_for_with_active_data *attr_names
+          options = attr_names.extract_options!
+          active_data_associations, active_record_association = attr_names.partition do |association_name|
+            reflect_on_association(association_name).is_a?(ActiveData::Model::Associations::Reflections::Base)
+          end
+
+          ActiveData::Model::Associations::NestedAttributes::NestedAttributesMethods
+            .accepts_nested_attributes_for self, *active_data_associations, options.dup
+          accepts_nested_attributes_for_without_active_data *active_record_association, options.dup
+        end
+      end
+    end
+  end
+end

data/lib/active_data/config.rb

@@ -0,0 +1,40 @@
+module ActiveData
+  class Config
+    include Singleton
+
+    attr_accessor :include_root_in_json, :i18n_scope, :logger, :primary_attribute,
+      :_normalizers, :_typecasters
+
+    def self.delegated
+      public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
+    end
+
+    def initialize
+      @include_root_in_json = false
+      @i18n_scope = :active_data
+      @logger = Logger.new(STDERR)
+      @primary_attribute = :id
+      @_normalizers = {}
+      @_typecasters = {}
+    end
+
+    def normalizer name, &block
+      if block
+        _normalizers[name.to_sym] = block
+      else
+        _normalizers[name.to_sym] or raise NormalizerMissing.new(name)
+      end
+    end
+
+    def typecaster *classes, &block
+      classes = classes.flatten
+      if block
+        _typecasters[classes.first.to_s.camelize] = block
+      else
+        _typecasters[classes.detect do |klass|
+          _typecasters[klass.to_s.camelize]
+        end.to_s.camelize] or raise TypecasterMissing.new(*classes)
+      end
+    end
+  end
+end

data/lib/active_data/errors.rb

@@ -0,0 +1,93 @@
+module ActiveData
+  class ActiveDataError < StandardError
+  end
+
+  class NotFound < ActiveDataError
+  end
+
+  # Backported from active_model 5
+  class ValidationError < ActiveDataError
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      errors = @model.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@model.class.i18n_scope}.errors.messages.model_invalid", errors: errors, default: :'errors.messages.model_invalid'))
+    end
+  end
+
+  class UnsavableObject < ActiveDataError
+  end
+
+  class UndestroyableObject < ActiveDataError
+  end
+
+  class ObjectNotSaved < ActiveDataError
+  end
+
+  class ObjectNotDestroyed < ActiveDataError
+  end
+
+  class AssociationChangesNotApplied < ActiveDataError
+  end
+
+  class AssociationTypeMismatch < ActiveDataError
+    def initialize expected, got
+      super "Expected `#{expected}` (##{expected.object_id}), but got `#{got}` (##{got.object_id})"
+    end
+  end
+
+  class ObjectNotFound < ActiveDataError
+    def initialize object, association_name, record_id
+      message = "Couldn't find #{object.class.reflect_on_association(association_name).klass.name}" \
+        "with #{object.respond_to?(:_primary_name) ? object._primary_name : 'id'} = #{record_id} for #{object.inspect}"
+      super message
+    end
+  end
+
+  class TooManyObjects < ActiveDataError
+    def initialize limit, actual_size
+      super "Maximum #{limit} objects are allowed. Got #{actual_size} objects instead."
+    end
+  end
+
+  class UndefinedPrimaryAttribute < ActiveDataError
+    def initialize klass, association_name
+      super <<-EOS
+Undefined primary attribute for `#{association_name}` in #{klass}.
+It is required for embeds_many nested attributes proper operation.
+You can define this association as:
+
+  embeds_many :#{association_name} do
+    primary :attribute_name
+  end
+      EOS
+    end
+  end
+
+  class NormalizerMissing < NoMethodError
+    def initialize name
+      super <<-EOS
+Could not find normalizer `:#{name}`
+You can define it with:
+
+  ActiveData.normalizer(:#{name}) do |value, options|
+    # do some staff with value and options
+  end
+      EOS
+    end
+  end
+
+  class TypecasterMissing < NoMethodError
+    def initialize *classes
+      super <<-EOS
+Could not find typecaster for #{classes}
+You can define it with:
+
+  ActiveData.typecaster('#{classes.first}') do |value|
+    # do some staff with value and options
+  end
+      EOS
+    end
+  end
+end

data/lib/active_data/extensions.rb

@@ -0,0 +1,33 @@
+unless defined?(Boolean)
+  class Boolean; end
+end
+
+begin
+  require 'uuidtools'
+rescue LoadError
+else
+  class ActiveData::UUID < UUIDTools::UUID
+    def as_json *_
+      to_s
+    end
+
+    def to_param
+      to_s
+    end
+
+    def self.parse_string value
+      return nil if value.length == 0
+      if value.length == 36
+        parse value
+      elsif value.length == 32
+        parse_hexdigest value
+      else
+        parse_raw value
+      end
+    end
+
+    def inspect
+      "#<ActiveData::UUID:#{to_s}>"
+    end
+  end
+end

data/lib/active_data/model.rb

@@ -1,88 +1,30 @@
-require 'active_data/model/extensions'
-require 'active_data/model/collectionizable'
-require 'active_data/model/attributable'
-require 'active_data/model/localizable'
+require 'active_data/model/conventions'
+require 'active_data/model/attributes'
+require 'active_data/model/scopes'
+require 'active_data/model/primary'
+require 'active_data/model/lifecycle'
+require 'active_data/model/persistence'
+require 'active_data/model/callbacks'
 require 'active_data/model/associations'
-require 'active_data/model/nested_attributes'
-require 'active_data/model/parameterizable'
-
-require 'active_data/attributes/base'
-require 'active_data/attributes/localized'
+require 'active_data/model/validations'
+require 'active_data/model/localization'
+require 'active_data/model/dirty'
 
 module ActiveData
   module Model
-    class NotFound < ::StandardError
-    end
-
     extend ActiveSupport::Concern
 
     included do
-      include ActiveModel::Conversion
-      include ActiveModel::Validations
-      include ActiveModel::Serialization
-      include ActiveModel::Serializers::JSON
-
-      include Attributable
-      include Localizable
-      include Collectionizable
-      include Associations
-      include NestedAttributes
-      include Parameterizable
       extend ActiveModel::Naming
       extend ActiveModel::Translation
 
-      self.include_root_in_json = false
-
-      def initialize attributes = {}
-        @attributes = self.class.initialize_attributes
-        @new_record = true
-        assign_attributes attributes
-      end
-
-      def self.i18n_scope
-        :active_data
-      end
-
-      def serializable_hash *args
-        super(*args).stringify_keys!
-      end
-    end
-
-    module ClassMethods
-      def instantiate data
-        return data if data.class.include? ActiveData::Model
-
-        data = data.symbolize_keys
-        instance = allocate
-
-        attributes = initialize_attributes
-        attributes.merge!(data.slice(*attributes.keys))
-
-        data.slice(*association_names.map(&:to_sym)).each do |association, data|
-          instance.send(:"#{association}=", data)
-        end
-
-        instance.instance_variable_set(:@attributes, attributes)
-        instance.instance_variable_set(:@new_record, false)
-
-        instance
-      end
-    end
-
-    def errors
-      @errors ||= ActiveModel::Errors.new(self)
-    end
-
-    def persisted?
-      !@new_record
-    end
-
-    def == other
-      other.instance_of?(self.class) && other.attributes == attributes
-    end
+      include ActiveModel::Conversion
+      include ActiveModel::Serialization
+      include ActiveModel::Serializers::JSON
 
-    def inspect
-      "#<#{self.class} #{attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(' ')}>"
+      include Conventions
+      include Attributes
+      include Validations
     end
   end
 end

data/lib/active_data/model/associations.rb

@@ -1,6 +1,22 @@
-require 'active_data/model/associations/association'
-require 'active_data/model/associations/embeds_many'
+require 'active_data/model/associations/collection/proxy'
+require 'active_data/model/associations/collection/embedded'
+require 'active_data/model/associations/collection/referenced'
+
+require 'active_data/model/associations/reflections/base'
+require 'active_data/model/associations/reflections/embeds_one'
+require 'active_data/model/associations/reflections/embeds_many'
+require 'active_data/model/associations/reflections/reference_reflection'
+require 'active_data/model/associations/reflections/references_one'
+require 'active_data/model/associations/reflections/references_many'
+
+require 'active_data/model/associations/base'
 require 'active_data/model/associations/embeds_one'
+require 'active_data/model/associations/embeds_many'
+require 'active_data/model/associations/references_one'
+require 'active_data/model/associations/references_many'
+
+require 'active_data/model/associations/nested_attributes'
+require 'active_data/model/associations/validations'
 
 module ActiveData
   module Model
@@ -8,39 +24,92 @@ module ActiveData
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :_associations, instance_reader: false, instance_writer: false
+        include NestedAttributes
+        include Validations
+
+        class_attribute :_associations, :_association_aliases, instance_reader: false, instance_writer: false
         self._associations = {}
+        self._association_aliases = {}
+
+        delegate :association_names, to: 'self.class'
 
-        { embeds_many: EmbedsMany, embeds_one: EmbedsOne }.each do |(name, association_class)|
-          define_singleton_method name do |*args|
-            association = association_class.new *args
-            association.define_accessor self
-            self._associations = _associations.merge(association.name => association)
+        {
+          embeds_many: Reflections::EmbedsMany,
+          embeds_one: Reflections::EmbedsOne,
+          references_one: Reflections::ReferencesOne,
+          references_many: Reflections::ReferencesMany
+        }.each do |(name, reflection_class)|
+          define_singleton_method name do |*args, &block|
+            reflection = reflection_class.build self, generated_associations_methods, *args, &block
+            self._associations = _associations.merge(reflection.name => reflection)
+            reflection
           end
         end
       end
 
       module ClassMethods
+        def reflections
+          _associations
+        end
 
-        def reflect_on_association name
-          _associations[name.to_s]
+        def alias_association(alias_name, association_name)
+          reflection = reflect_on_association(association_name)
+          raise ArgumentError.new("Can't alias undefined association `#{attribute_name}` on #{self}") unless reflection
+          reflection.class.generate_methods alias_name, generated_associations_methods
+          self._association_aliases = _association_aliases.merge(alias_name.to_sym => reflection.name)
+          reflection
         end
 
-        def associations
-          _associations
+        def reflect_on_association name
+          name = name.to_sym
+          _associations[_association_aliases[name] || name]
         end
 
         def association_names
           _associations.keys
         end
+
+      private
+
+        def attributes_for_inspect
+          (_associations.map do |name, reflection|
+            "#{name}: #{reflection.inspect}"
+          end + [super]).join(', ')
+        end
+
+        def generated_associations_methods
+          @generated_associations_methods ||= const_set(:GeneratedAssociationsMethods, Module.new)
+            .tap { |proxy| include proxy }
+        end
       end
 
       def == other
-        super(other) && self.class.association_names.all? do |association|
-          send(association) == other.send(association)
+        super && association_names.all? do |association|
+          public_send(association) == other.public_send(association)
+        end
+      end
+      alias_method :eql?, :==
+
+      def association name
+        if reflection = self.class.reflect_on_association(name)
+          (@_associations ||= {})[reflection.name] ||= reflection.build_association(self)
+        end
+      end
+
+      def apply_association_changes!
+        association_names.all? do |name|
+          association(name).apply_changes!
         end
       end
 
+    private
+
+      def attributes_for_inspect
+        (association_names.map do |name|
+          association = association(name)
+          "#{name}: #{association.inspect}"
+        end + [super]).join(', ')
+      end
     end
   end
-end
+end