active_data 0.3.0 → 1.0.0

data/lib/active_data/model/associations/references_many.rb

@@ -0,0 +1,96 @@
+module ActiveData
+  module Model
+    module Associations
+      class ReferencesMany < Base
+        def apply_changes
+          present_keys = target.reject { |t| t.marked_for_destruction? }.map(&reflection.primary_key).compact
+          write_source(present_keys)
+          true
+        end
+
+        def target= object
+          loaded!
+          @target = object.to_a
+        end
+
+        def load_target
+          source = read_source
+          source.present? ? scope(source).to_a : default
+        end
+
+        def default
+          unless evar_loaded?
+            default = Array.wrap(reflection.default(owner))
+            if default.all? { |object| object.is_a?(reflection.klass) }
+              default
+            elsif default.all? { |object| object.is_a?(Hash) }
+              default.map { |attributes| reflection.klass.new(attributes) }
+            else
+              scope(default).to_a
+            end if default.present?
+          end || []
+        end
+
+        def read_source
+          attribute.read_before_type_cast
+        end
+
+        def write_source value
+          attribute.write_value value
+        end
+
+        def reader force_reload = false
+          reload if force_reload
+          @proxy ||= Collection::Referenced.new self
+        end
+
+        def replace objects
+          loaded!
+          transaction do
+            clear
+            append objects
+          end
+        end
+        alias_method :writer, :replace
+
+        def concat(*objects)
+          append objects.flatten
+          reader
+        end
+
+        def clear
+          attribute.pollute do
+            write_source([])
+          end
+          reload.empty?
+        end
+
+        def scope source = read_source
+          reflection.scope.where(reflection.primary_key => source)
+        end
+
+        def identify
+          target.map(&reflection.primary_key)
+        end
+
+      private
+
+        def append objects
+          attribute.pollute do
+            objects.each do |object|
+              next if target.include?(object)
+              raise AssociationTypeMismatch.new(reflection.klass, object.class) unless object.is_a?(reflection.klass)
+              target.push(object)
+              apply_changes!
+            end
+          end
+          target
+        end
+
+        def attribute
+          @attribute ||= owner.attribute(reflection.reference_key)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/references_one.rb

@@ -0,0 +1,83 @@
+module ActiveData
+  module Model
+    module Associations
+      class ReferencesOne < Base
+        def apply_changes
+          if target && !target.marked_for_destruction?
+            write_source identify
+          else
+            write_source nil
+          end
+          true
+        end
+
+        def target= object
+          loaded!
+          @target = object
+        end
+
+        def load_target
+          source = read_source
+          source ? scope(source).first : default
+        end
+
+        def default
+          unless evar_loaded?
+            default = reflection.default(owner)
+            case default
+            when reflection.klass
+              default
+            when Hash
+              reflection.klass.new(default)
+            else
+              scope(default).first
+            end if default
+          end
+        end
+
+        def read_source
+          attribute.read_before_type_cast
+        end
+
+        def write_source value
+          attribute.write_value value
+        end
+
+        def reader force_reload = false
+          reset if force_reload
+          target
+        end
+
+        def replace object
+          unless object.nil? || object.is_a?(reflection.klass)
+            raise AssociationTypeMismatch.new(reflection.klass, object.class)
+          end
+
+          transaction do
+            attribute.pollute do
+              self.target = object
+              apply_changes!
+            end
+          end
+
+          target
+        end
+        alias_method :writer, :replace
+
+        def scope source = read_source
+          reflection.scope.where(reflection.primary_key => source)
+        end
+
+        def identify
+          target.try(reflection.primary_key)
+        end
+
+      private
+
+        def attribute
+          @attribute ||= owner.attribute(reflection.reference_key)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/base.rb

@@ -0,0 +1,100 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class Base
+          READ = ->(reflection, object) { object.read_attribute reflection.name }
+          WRITE = ->(reflection, object, value) { object.write_attribute reflection.name, value }
+
+          attr_reader :name, :options
+          # AR compatibility
+          attr_accessor :parent_reflection
+          delegate :association_class, to: 'self.class'
+
+          def self.build target, generated_methods, name, options = {}, &block
+            if block
+              options[:class] = proc do |reflection|
+                superclass = reflection.options[:class_name].to_s.presence.try(:constantize)
+                klass = Class.new(superclass || Object) do
+                  include ActiveData::Model
+                  include ActiveData::Model::Associations
+                  include ActiveData::Model::Lifecycle
+                  include ActiveData::Model::Primary
+                end
+                target.const_set(name.to_s.classify, klass)
+                klass.class_eval(&block)
+                klass
+              end
+            end
+            generate_methods name, generated_methods
+            target.validates_nested name if options.delete(:validate) && target.respond_to?(:validates_nested)
+            new(name, options)
+          end
+
+          def self.generate_methods name, target
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name} force_reload = false
+                association(:#{name}).reader(force_reload)
+              end
+
+              def #{name}= value
+                association(:#{name}).writer(value)
+              end
+            RUBY
+          end
+
+          def self.association_class
+            @association_class ||= "ActiveData::Model::Associations::#{name.demodulize}".constantize
+          end
+
+          def initialize name, options = {}
+            @name, @options = name.to_sym, options
+          end
+
+          def macro
+            self.class.name.demodulize.underscore.to_sym
+          end
+
+          def klass
+            @klass ||= options[:class] ?
+              options[:class].call(self) :
+              (options[:class_name].presence || name.to_s.classify).to_s.constantize
+          end
+
+          def belongs_to?
+            false
+          end
+
+          def build_association object
+            self.class.association_class.new object, self
+          end
+
+          def read_source object
+            (options[:read] || READ).call(self, object)
+          end
+
+          def write_source object, value
+            (options[:write] || WRITE).call(self, object, value)
+          end
+
+          def default object
+            defaultizer = options[:default]
+            if defaultizer.is_a?(Proc)
+              if defaultizer.arity != 0
+                defaultizer.call(object)
+              else
+                object.instance_exec(&defaultizer)
+              end
+            else
+              defaultizer
+            end
+          end
+
+          def inspect
+            "#{self.class.name.demodulize}(#{klass})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/embeds_many.rb

@@ -0,0 +1,25 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class EmbedsMany < Base
+          def self.build target, generated_methods, name, options = {}, &block
+            if target < ActiveData::Model::Attributes
+              target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name)
+            end
+            options[:validate] = true unless options.key?(:validate)
+            super
+          end
+
+          def collection?
+            true
+          end
+
+          def embedded?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/embeds_one.rb

@@ -0,0 +1,49 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class EmbedsOne < Base
+          def self.build target, generated_methods, name, options = {}, &block
+            if target < ActiveData::Model::Attributes
+              target.add_attribute(ActiveData::Model::Attributes::Reflections::Base, name)
+            end
+            options[:validate] = true unless options.key?(:validate)
+            super
+          end
+
+          def self.generate_methods name, target
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name} force_reload = false
+                association(:#{name}).reader(force_reload)
+              end
+
+              def #{name}= value
+                association(:#{name}).writer(value)
+              end
+
+              def build_#{name} attributes = {}
+                association(:#{name}).build(attributes)
+              end
+
+              def create_#{name} attributes = {}
+                association(:#{name}).create(attributes)
+              end
+
+              def create_#{name}! attributes = {}
+                association(:#{name}).create!(attributes)
+              end
+            RUBY
+          end
+
+          def collection?
+            false
+          end
+
+          def embedded?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/reference_reflection.rb

@@ -0,0 +1,45 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class ReferenceReflection < Base
+          def self.build target, generated_methods, name, *args, &block
+            reflection = new(name, *args)
+            generate_methods name, generated_methods
+            reflection
+          end
+
+          def initialize name, *args
+            @options = args.extract_options!
+            @scope_proc = args.first
+            @name = name.to_sym
+          end
+
+          def read_source object
+            object.read_attribute(reference_key)
+          end
+
+          def write_source object, value
+            object.write_attribute(reference_key, value)
+          end
+
+          def primary_key
+            @primary_key ||= options[:primary_key].presence.try(:to_sym) || :id
+          end
+
+          def scope
+            @scope ||= begin
+              scope = klass.unscoped
+              scope = scope.instance_exec(&@scope_proc) if @scope_proc
+              scope
+            end
+          end
+
+          def embedded?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/references_many.rb

@@ -0,0 +1,28 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class ReferencesMany < ReferenceReflection
+          def self.build target, generated_methods, name, *args, &block
+            reflection = super
+
+            target.add_attribute(
+              ActiveData::Model::Attributes::Reflections::ReferenceMany,
+              reflection.reference_key, association: name)
+
+            reflection
+          end
+
+          def collection?
+            true
+          end
+
+          def reference_key
+            @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
+              :"#{name.to_s.singularize}_#{primary_key.to_s.pluralize}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/associations/reflections/references_one.rb

@@ -0,0 +1,28 @@
+module ActiveData
+  module Model
+    module Associations
+      module Reflections
+        class ReferencesOne < ReferenceReflection
+          def self.build target, generated_methods, name, *args, &block
+            reflection = super
+
+            target.add_attribute(
+              ActiveData::Model::Attributes::Reflections::ReferenceOne,
+              reflection.reference_key, association: name)
+
+            reflection
+          end
+
+          def collection?
+            false
+          end
+
+          def reference_key
+            @reference_key ||= options[:reference_key].presence.try(:to_sym) ||
+              :"#{name}_#{primary_key}"
+          end
+        end
+      end
+    end
+  end
+end