active_data 0.3.0 → 1.0.0

data/lib/active_data/model/localization.rb

@@ -0,0 +1,21 @@
+module ActiveData
+  module Model
+    module Localization
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def localized *args, &block
+          add_attribute(ActiveData::Model::Attributes::Reflections::Localized, *args, &block)
+        end
+
+        def fallbacks locale
+          ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
+        end
+
+        def locale
+          I18n.locale
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/persistence.rb

@@ -0,0 +1,57 @@
+module ActiveData
+  module Model
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def instantiate data
+          data = data.stringify_keys
+          instance = allocate
+
+          instance.instance_variable_set(:@initial_attributes, data.slice(*attribute_names))
+          instance.send(:mark_persisted!)
+
+          instance
+        end
+
+        def instantiate_collection data
+          collection = Array.wrap(data).map { |attrs| instantiate attrs }
+          collection = scope(collection, true) if respond_to?(:scope)
+          collection
+        end
+      end
+
+      def persisted?
+        !!@persisted
+      end
+
+      def destroyed?
+        !!@destroyed
+      end
+
+      def marked_for_destruction?
+        @marked_for_destruction
+      end
+
+      def mark_for_destruction
+        @marked_for_destruction = true
+      end
+
+      def _destroy
+        marked_for_destruction?
+      end
+
+    private
+
+      def mark_persisted!
+        @persisted = true
+        @destroyed = false
+      end
+
+      def mark_destroyed!
+        @persisted = false
+        @destroyed = true
+      end
+    end
+  end
+end

data/lib/active_data/model/primary.rb

@@ -0,0 +1,51 @@
+module ActiveData
+  module Model
+    module Primary
+      extend ActiveSupport::Concern
+      DEFAULT_PRIMARY_ATTRIBUTE_OPTIONS = -> { {
+        type: ActiveData::UUID,
+        default: -> { ActiveData::UUID.random_create }
+      } }
+
+      included do
+        class_attribute :_primary_name, instance_writer: false
+        delegate :has_primary_attribute?, to: 'self.class'
+
+        prepend PrependMethods
+        alias_method :eql?, :==
+      end
+
+      module ClassMethods
+        def primary *args
+          options = args.extract_options!
+          self._primary_name = (args.first.presence || ActiveData.primary_attribute).to_s
+          unless has_attribute?(_primary_name)
+            options.merge!(type: args.second) if args.second
+            attribute _primary_name, options.presence || DEFAULT_PRIMARY_ATTRIBUTE_OPTIONS.call
+          end
+          alias_attribute :primary_attribute, _primary_name
+        end
+        alias_method :primary_attribute, :primary
+
+        def has_primary_attribute?
+          has_attribute? _primary_name
+        end
+
+        def primary_name
+          _primary_name
+        end
+      end
+
+      module PrependMethods
+        def == other
+          other.instance_of?(self.class) &&
+            has_primary_attribute? ?
+              primary_attribute ?
+                primary_attribute == other.primary_attribute :
+                object_id == other.object_id :
+              super(other)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/scopes.rb

@@ -0,0 +1,77 @@
+module ActiveData
+  module Model
+    module Scopes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_scope_base
+        scopify
+      end
+
+      module ScopeProxy
+        extend ActiveSupport::Concern
+
+        def self.for(model)
+          klass = Class.new(model._scope_base) do
+            include ActiveData::Model::Scopes::ScopeProxy
+          end
+          klass.define_singleton_method(:_scope_model) { model }
+          model.const_set('ScopeProxy', klass)
+        end
+
+        included do
+          def initialize source = nil, trust = false
+            source ||= self.class.superclass.new
+
+            source.each do |entity|
+              raise AssociationTypeMismatch.new(self.class._scope_model, entity.class) unless entity.is_a?(self.class._scope_model)
+            end unless trust && source.is_a?(self.class)
+
+            super source
+          end
+        end
+
+        def respond_to_missing? method, _
+          super || self.class._scope_model.respond_to?(method)
+        end
+
+        def method_missing method, *args, &block
+          with_scope { self.class._scope_model.public_send(method, *args, &block) }
+        end
+
+        def with_scope
+          previous_scope, self.class._scope_model.current_scope = self.class._scope_model.current_scope, self
+          result = yield
+          self.class._scope_model.current_scope = previous_scope
+          result
+        end
+      end
+
+      module ClassMethods
+        def scopify scope_base = Array
+          self._scope_base = scope_base
+        end
+
+        def scope_class
+          @scope_class ||= ActiveData::Model::Scopes::ScopeProxy.for(self)
+        end
+
+        def scope *args
+          if args.empty?
+            current_scope
+          else
+            scope_class.new *args
+          end
+        end
+
+        def current_scope= value
+          @current_scope = value
+        end
+
+        def current_scope
+          @current_scope ||= scope_class.new
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/validations.rb

@@ -0,0 +1,27 @@
+module ActiveData
+  module Model
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+
+      included do
+        extend HelperMethods
+        include HelperMethods
+
+        alias_method :validate, :valid?
+      end
+
+      def validate! context = nil
+        valid?(context) || raise_validation_error
+      end
+
+    protected
+
+      def raise_validation_error
+        raise ActiveData::ValidationError.new(self)
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/validations/*.rb"].each { |file| require file }

data/lib/active_data/model/validations/associated.rb

@@ -0,0 +1,19 @@
+module ActiveData
+  module Model
+    module Validations
+      class AssociatedValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if Array.wrap(value).reject { |r| r.respond_to?(:valid?) && r.valid?(record.validation_context) }.any?
+            record.errors.add(attribute, :invalid, options.merge(value: value))
+          end
+        end
+      end
+
+      module HelperMethods
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/validations/nested.rb

@@ -0,0 +1,39 @@
+module ActiveData
+  module Model
+    module Validations
+      class NestedValidator < ActiveModel::EachValidator
+        def self.validate_nested(record, name, value)
+          if value.is_a?(Enumerable)
+            value.each.with_index do |object, i|
+              if yield(object)
+                object.errors.each do |key, message|
+                  key = "#{name}.#{i}.#{key}"
+                  record.errors[key] << message
+                  record.errors[key].uniq!
+                end
+              end
+            end
+          elsif value && yield(value)
+            value.errors.each do |key, message|
+              key = "#{name}.#{key}"
+              record.errors[key] << message
+              record.errors[key].uniq!
+            end
+          end
+        end
+
+        def validate_each(record, attribute, value)
+          self.class.validate_nested(record, attribute, value) do |object|
+            object.invalid?
+          end
+        end
+      end
+
+      module HelperMethods
+        def validates_nested(*attr_names)
+          validates_with NestedValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/railtie.rb

@@ -0,0 +1,7 @@
+module ActiveData
+  class Railtie < Rails::Railtie
+    initializer 'active_data.logger', after: 'active_record.logger' do
+      ActiveSupport.on_load(:active_record)  { ActiveData.logger ||= ActiveRecord::Base.logger }
+    end
+  end
+end

data/lib/active_data/version.rb

@@ -1,3 +1,3 @@
 module ActiveData
-  VERSION = "0.3.0"
+  VERSION = '1.0.0'
 end

data/spec/lib/active_data/active_record/associations_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe ActiveData::ActiveRecord::Associations do
+  before do
+    stub_model(:project) do
+      include ActiveData::Model::Lifecycle
+      include ActiveData::Model::Associations
+
+      attribute :title, String
+
+      validates :title, presence: true
+
+      embeds_one :author do
+        attribute :name, String
+
+        validates :name, presence: true
+      end
+    end
+
+    stub_model(:profile) do
+      include ActiveData::Model::Lifecycle
+
+      attribute :first_name, String
+      attribute :last_name, String
+    end
+
+    stub_class(:user, ActiveRecord::Base) do
+      embeds_many :projects
+      embeds_one :profile
+
+      validates :projects, associated: true
+    end
+  end
+
+  its(:projects) { should = [] }
+  its(:profile) { should = nil }
+
+  context 'new owner' do
+    subject(:user) { User.new }
+
+    describe '#projects' do
+      specify { expect { user.projects << Project.new }
+        .not_to change { user.read_attribute(:projects) } }
+      specify { expect { user.projects << Project.new(title: 'First') }
+        .not_to change { user.read_attribute(:projects) } }
+      specify { expect { user.projects << Project.new(title: 'First') }
+        .not_to change { user.projects.reload.count } }
+      specify do
+        user.projects << Project.new(title: 'First')
+        user.save
+        expect(user.reload.projects.first.title).to eq('First')
+      end
+    end
+
+    describe '#profile' do
+      specify { expect { user.profile = Profile.new(first_name: 'google.com') }
+        .not_to change { user.read_attribute(:profile) } }
+      specify { expect { user.profile = Profile.new(first_name: 'google.com') }
+        .to change { user.profile }.from(nil).to(an_instance_of(Profile)) }
+      specify do
+        user.profile = Profile.new(first_name: 'google.com')
+        user.save
+        expect(user.reload.profile.first_name).to eq('google.com')
+      end
+    end
+  end
+
+  context 'persisted owner' do
+    subject(:user) { User.create }
+
+    describe '#projects' do
+      specify { expect { user.projects << Project.new }
+        .not_to change { user.read_attribute(:projects) } }
+      specify { expect { user.projects << Project.new(title: 'First') }
+        .to change { user.projects.reload.count }.from(0).to(1) }
+      specify {
+        user.projects << Project.new(title: 'First')
+        user.save
+        expect(user.reload.projects.first.title).to eq('First') }
+
+      context do
+        let(:project) { Project.new(title: 'First') }
+        before { project.build_author(name: 'Author') }
+
+        specify { expect { user.projects << project }
+          .to change { user.attributes['projects'] }.from(nil)
+          .to([{title: 'First', author: {name: 'Author'}}].to_json) }
+        specify { expect { user.projects << project; user.save }
+          .to change { user.reload.attributes['projects'] }.from(nil)
+          .to([{title: 'First', author: {name: 'Author'}}].to_json) }
+      end
+    end
+
+    describe '#profile' do
+      specify { expect { user.profile = Profile.new(first_name: 'google.com') }
+        .to change { user.profile }.from(nil).to(an_instance_of(Profile)) }
+      specify {
+        user.profile = Profile.new(first_name: 'google.com')
+        user.save
+        expect(user.reload.profile.first_name).to eq('google.com') }
+      specify { expect { user.profile = Profile.new(first_name: 'google.com') }
+        .to change { user.attributes['profile'] }.from(nil)
+        .to({first_name: 'google.com', last_name: nil}.to_json) }
+      specify { expect { user.profile = Profile.new(first_name: 'google.com'); user.save }
+        .to change { user.reload.attributes['profile'] }.from(nil)
+        .to({first_name: 'google.com', last_name: nil}.to_json) }
+    end
+  end
+
+  context 'class determine errors' do
+    specify do
+      expect { stub_class(:book, ActiveRecord::Base) do
+        embeds_one :author, class_name: 'Borogoves'
+      end.reflect_on_association(:author).klass }.to raise_error NameError
+    end
+
+    specify do
+      expect { stub_class(:user, ActiveRecord::Base) do
+        embeds_many :projects, class_name: 'Borogoves' do
+          attribute :title
+        end
+      end.reflect_on_association(:projects).klass }.to raise_error NameError
+    end
+  end
+
+  context 'on the fly' do
+    before do
+      stub_class(:user, ActiveRecord::Base) do
+        embeds_many :projects do
+          attribute :title, String
+        end
+        embeds_one :profile, class_name: 'Profile' do
+          attribute :age, Integer
+        end
+      end
+    end
+
+    specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
+    specify { expect(User.new.projects).to eq([]) }
+    specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(ActiveData::Model::Associations::Collection::Embedded) }
+    specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{title: 'Project'}].to_json) }
+
+    specify { expect(User.reflect_on_association(:profile).klass).to eq(User::Profile) }
+    specify { expect(User.reflect_on_association(:profile).klass).to be < Profile }
+    specify { expect(User.new.profile).to be_nil }
+    specify { expect(User.new.tap { |u| u.create_profile(first_name: 'Profile') }.profile).to be_a(User::Profile) }
+    specify { expect(User.new.tap { |u| u.create_profile(first_name: 'Profile') }.read_attribute(:profile)).to eq({first_name: 'Profile', last_name: nil, age: nil}.to_json) }
+  end
+end