active_data 0.3.0 → 1.0.0

data/spec/lib/active_data/model/attributes/reflections/attribute_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Attribute do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify { expect(described_class.build(Class.new, Target, :field, String).type).to eq(String) }
+    specify { expect(described_class.build(Class.new, Target, :field) {}.defaultizer).to be_a(Proc) }
+    specify do
+      described_class.build(Class.new, Target, :field)
+
+      expect(Target).to be_method_defined(:field)
+      expect(Target).to be_method_defined(:field=)
+      expect(Target).to be_method_defined(:field?)
+      expect(Target).to be_method_defined(:field_before_type_cast)
+      expect(Target).to be_method_defined(:field_default)
+      expect(Target).to be_method_defined(:field_values)
+    end
+  end
+
+  describe '#generate_methods' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.generate_methods(:field_alias, Target)
+
+      expect(Target).to be_method_defined(:field_alias)
+      expect(Target).to be_method_defined(:field_alias=)
+      expect(Target).to be_method_defined(:field_alias?)
+      expect(Target).to be_method_defined(:field_alias_before_type_cast)
+      expect(Target).to be_method_defined(:field_alias_default)
+      expect(Target).to be_method_defined(:field_alias_values)
+    end
+  end
+
+  describe '#defaultizer' do
+    specify { expect(reflection.defaultizer).to be_nil }
+    specify { expect(reflection(default: 42).defaultizer).to eq(42) }
+    specify { expect(reflection(default: ->{ }).defaultizer).to be_a Proc }
+  end
+
+  describe '#typecaster' do
+    before do
+      stub_class(:dummy, String)
+      stub_class(:dummy_dummy, Dummy)
+    end
+
+    specify { expect(reflection(type: Object).typecaster).to eq(ActiveData.typecaster(Object)) }
+    specify { expect(reflection(type: String).typecaster).to eq(ActiveData.typecaster(String)) }
+    specify { expect(reflection(type: Dummy).typecaster).to eq(ActiveData.typecaster(String)) }
+    specify { expect(reflection(type: DummyDummy).typecaster).to eq(ActiveData.typecaster(String)) }
+  end
+
+  describe '#enumerizer' do
+    specify { expect(reflection.enumerizer).to be_nil }
+    specify { expect(reflection(enum: 42).enumerizer).to eq(42) }
+    specify { expect(reflection(enum: ->{ }).enumerizer).to be_a Proc }
+    specify { expect(reflection(in: 42).enumerizer).to eq(42) }
+    specify { expect(reflection(in: ->{ }).enumerizer).to be_a Proc }
+    specify { expect(reflection(enum: 42, in: ->{ }).enumerizer).to eq(42) }
+  end
+
+  describe '#normalizers' do
+    specify { expect(reflection.normalizers).to eq([]) }
+    specify { expect(reflection(normalizer: ->{}).normalizers).to be_a Array }
+    specify { expect(reflection(normalizer: ->{}).normalizers.first).to be_a Proc }
+  end
+end

data/spec/lib/active_data/model/attributes/reflections/base_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Base do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.build(Class.new, Target, :field)
+      expect(Target).not_to be_method_defined(:field)
+    end
+    specify { expect(described_class.build(Class.new, Target, :field).name).to eq('field') }
+  end
+
+  describe '.attribute_class' do
+    before do
+      stub_class('SomeScope::Borogoves', described_class)
+      stub_class('ActiveData::Model::Attributes::Borogoves')
+    end
+
+    specify { expect(described_class.attribute_class).to eq(ActiveData::Model::Attributes::Base) }
+    specify { expect(SomeScope::Borogoves.attribute_class).to eq(ActiveData::Model::Attributes::Borogoves) }
+  end
+
+  describe '#name' do
+    specify { expect(reflection.name).to eq('field') }
+  end
+
+  describe '#build_attribute' do
+    before do
+      stub_class('SomeScope::Borogoves', described_class)
+      stub_class('ActiveData::Model::Attributes::Borogoves', ActiveData::Model::Attributes::Base)
+      stub_class(:owner)
+    end
+
+    let(:reflection) { SomeScope::Borogoves.new(:field) }
+    let(:owner) { Owner.new }
+
+    specify { expect(reflection.build_attribute(owner, nil)).to be_a(ActiveData::Model::Attributes::Borogoves) }
+    specify { expect(reflection.build_attribute(owner, nil).name).to eq('field') }
+    specify { expect(reflection.build_attribute(owner, nil).owner).to eq(owner) }
+  end
+
+  describe '#type' do
+    before { stub_class(:dummy, String) }
+
+    specify { expect { reflection.type }.to raise_error('Type is not specified for `field`') }
+    specify { expect(reflection(type: String).type).to eq(String) }
+    specify { expect(reflection(type: :string).type).to eq(String) }
+    specify { expect(reflection(type: Dummy).type).to eq(Dummy) }
+    specify { expect { reflection(type: :blabla).type }.to raise_error NameError }
+  end
+end

data/spec/lib/active_data/model/attributes/reflections/collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Collection do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.build(Class.new, Target, :field)
+
+      expect(Target).to be_method_defined(:field)
+      expect(Target).to be_method_defined(:field=)
+      expect(Target).to be_method_defined(:field?)
+      expect(Target).to be_method_defined(:field_before_type_cast)
+      expect(Target).to be_method_defined(:field_default)
+      expect(Target).to be_method_defined(:field_values)
+    end
+  end
+
+  describe '#generate_methods' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.generate_methods(:field_alias, Target)
+
+      expect(Target).to be_method_defined(:field_alias)
+      expect(Target).to be_method_defined(:field_alias=)
+      expect(Target).to be_method_defined(:field_alias?)
+      expect(Target).to be_method_defined(:field_alias_before_type_cast)
+      expect(Target).to be_method_defined(:field_alias_default)
+      expect(Target).to be_method_defined(:field_alias_values)
+    end
+  end
+end

data/spec/lib/active_data/model/attributes/reflections/dictionary_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Dictionary do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.build(Class.new, Target, :field)
+
+      expect(Target).to be_method_defined(:field)
+      expect(Target).to be_method_defined(:field=)
+      expect(Target).to be_method_defined(:field?)
+      expect(Target).to be_method_defined(:field_before_type_cast)
+      expect(Target).to be_method_defined(:field_default)
+      expect(Target).to be_method_defined(:field_values)
+    end
+  end
+
+  describe '#generate_methods' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.generate_methods(:field_alias, Target)
+
+      expect(Target).to be_method_defined(:field_alias)
+      expect(Target).to be_method_defined(:field_alias=)
+      expect(Target).to be_method_defined(:field_alias?)
+      expect(Target).to be_method_defined(:field_alias_before_type_cast)
+      expect(Target).to be_method_defined(:field_alias_default)
+      expect(Target).to be_method_defined(:field_alias_values)
+    end
+  end
+
+  describe '#keys' do
+    specify { expect(reflection.keys).to eq([]) }
+    specify { expect(reflection(keys: ['a', :b]).keys).to eq(%w[a b]) }
+    specify { expect(reflection(keys: :c).keys).to eq(%w[c]) }
+  end
+end

data/spec/lib/active_data/model/attributes/reflections/localized_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Localized do
+  def reflection(options = {})
+    described_class.new(:field, options)
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.build(Class.new, Target, :field)
+
+      expect(Target).to be_method_defined(:field_translations)
+      expect(Target).to be_method_defined(:field_translations=)
+      expect(Target).to be_method_defined(:field)
+      expect(Target).to be_method_defined(:field=)
+      expect(Target).to be_method_defined(:field?)
+      expect(Target).to be_method_defined(:field_before_type_cast)
+    end
+  end
+
+  describe '#generate_methods' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.generate_methods(:field_alias, Target)
+
+      expect(Target).to be_method_defined(:field_alias_translations)
+      expect(Target).to be_method_defined(:field_alias_translations=)
+      expect(Target).to be_method_defined(:field_alias)
+      expect(Target).to be_method_defined(:field_alias=)
+      expect(Target).to be_method_defined(:field_alias?)
+      expect(Target).to be_method_defined(:field_alias_before_type_cast)
+    end
+  end
+end

data/spec/lib/active_data/model/attributes/reflections/represents_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Reflections::Represents do
+  def reflection(options = {})
+    described_class.new(:field, options.reverse_merge(of: :subject))
+  end
+
+  describe '.build' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.build(Class.new, Target, :field, of: :subject)
+
+      expect(Target).to be_method_defined(:field)
+      expect(Target).to be_method_defined(:field=)
+      expect(Target).to be_method_defined(:field?)
+      expect(Target).to be_method_defined(:field_before_type_cast)
+      expect(Target).to be_method_defined(:field_default)
+      expect(Target).to be_method_defined(:field_values)
+    end
+  end
+
+  describe '.generate_methods' do
+    before { stub_class(:target) }
+
+    specify do
+      described_class.generate_methods(:field_alias, Target)
+
+      expect(Target).to be_method_defined(:field_alias)
+      expect(Target).to be_method_defined(:field_alias=)
+      expect(Target).to be_method_defined(:field_alias?)
+      expect(Target).to be_method_defined(:field_alias_before_type_cast)
+      expect(Target).to be_method_defined(:field_alias_default)
+      expect(Target).to be_method_defined(:field_alias_values)
+    end
+  end
+
+  describe '#type' do
+    specify { expect(reflection.type).to eq(Object) }
+    specify { expect(reflection(type: :whatever).type).to eq(Object) }
+  end
+
+  describe '#reference' do
+    specify { expect { reflection(of: nil) }.to raise_error ArgumentError }
+    specify { expect(reflection(of: :subject).reference).to eq('subject') }
+  end
+
+  describe '#column' do
+    specify { expect(reflection.column).to eq('field') }
+    specify { expect(reflection(column: 'hello').column).to eq('hello') }
+  end
+
+  describe '#reader' do
+    specify { expect(reflection.reader).to eq('field') }
+    specify { expect(reflection(column: 'hello').reader).to eq('hello') }
+    specify { expect(reflection(reader: 'world').reader).to eq('world') }
+  end
+
+  describe '#reader_before_type_cast' do
+    specify { expect(reflection.reader_before_type_cast).to eq('field_before_type_cast') }
+    specify { expect(reflection(column: 'hello').reader_before_type_cast).to eq('hello_before_type_cast') }
+    specify { expect(reflection(reader: 'world').reader_before_type_cast).to eq('world_before_type_cast') }
+  end
+
+  describe '#writer' do
+    specify { expect(reflection.writer).to eq('field=') }
+    specify { expect(reflection(column: 'hello').writer).to eq('hello=') }
+    specify { expect(reflection(writer: 'world').writer).to eq('world=') }
+  end
+end

data/spec/lib/active_data/model/attributes/represents_spec.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Represents do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Represents, :full_name, options.reverse_merge(of: :subject))
+    Dummy.new.attribute(:full_name)
+  end
+
+  before do
+    stub_model :subject do
+      attribute :full_name, String
+    end
+  end
+
+  describe '#write' do
+    subject { Subject.new }
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
+    let(:field) { attribute }
+
+    specify { expect { field.write('hello') }.to change { subject.full_name }.to('hello') }
+  end
+
+  describe '#read' do
+    subject { Subject.new(full_name: :hello) }
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
+    let(:field) { attribute(normalizer: ->(v){ v && v.is_a?(String) ? v.strip : v }, default: :world, enum: ['hello', '42', 'world', :world]) }
+
+    specify { expect(field.read).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
+    specify { expect(field.tap { |r| r.write('hello') }.read).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(' hello ') }.read).to eq(nil) }
+    specify { expect(field.tap { |r| r.write(42) }.read).to eq('42') }
+    specify { expect(field.tap { |r| r.write(43) }.read).to eq(nil) }
+    specify { expect(field.tap { |r| r.write('') }.read).to eq(nil) }
+
+    specify { expect { subject.full_name = 42 }.to change { field.read }.to('42') }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read).to eq('hello') }
+    end
+
+    context do
+      subject { Subject.new }
+      let(:field) { attribute(default: -> { Time.now.to_f }) }
+      specify { expect { sleep(0.01) }.not_to change { field.read } }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    subject { Subject.new(full_name: :hello) }
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
+    let(:field) { attribute(normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+
+    specify { expect(field.read_before_type_cast).to eq(:hello) }
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(42) }.read_before_type_cast).to eq(42) }
+    specify { expect(field.tap { |r| r.write(43) }.read_before_type_cast).to eq(43) }
+    specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
+
+    specify { expect { subject.full_name = 42 }.to change { field.read_before_type_cast }.to(42) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read_before_type_cast).to eq(:hello) }
+    end
+
+    context do
+      subject { Subject.new }
+      let(:field) { attribute(default: -> { Time.now.to_f }) }
+      specify { expect { sleep(0.01) }.not_to change { field.read_before_type_cast } }
+    end
+  end
+
+  context 'integration' do
+    before do
+      stub_model(:author) do
+        attribute :rate, Integer
+      end
+
+      stub_model(:post) do
+        attribute :author, Object
+        alias_attribute :a, :author
+        represents :rate, of: :a
+        alias_attribute :r, :rate
+      end
+    end
+    let(:author) { Author.new(rate: '42') }
+
+    specify { expect(Post.reflect_on_attribute(:rate).reference).to eq('author') }
+
+    specify { expect(Post.new(author: author).rate).to eq(42) }
+    specify { expect(Post.new(author: author).rate_before_type_cast).to eq('42') }
+    specify { expect(Post.new(rate: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(rate: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(author: author).rate?).to eq(true) }
+    specify { expect(Post.new(rate: nil, author: author).rate?).to eq(false) }
+
+    specify { expect(Post.new.rate).to be_nil }
+    specify { expect(Post.new.rate_before_type_cast).to be_nil }
+    specify { expect { Post.new(rate: '33') }.to raise_error(NoMethodError) }
+
+    context do
+      before do
+        stub_class(:author, ActiveRecord::Base)
+
+        stub_model(:post) do
+          include ActiveData::Model::Associations
+
+          references_one :author
+          alias_association :a, :author
+          represents :name, of: :a
+        end
+      end
+      let!(:author) { Author.create!(name: 42) }
+
+      specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
+
+      specify { expect(Post.new(name: '33', author: author).name).to eq('33') }
+      specify { expect(Post.new(name: '33', author: author).author.name).to eq('33') }
+    end
+
+    context 'multiple attributes in a single represents definition' do
+      before do
+        stub_model(:author) do
+          attribute :first_name, String
+          attribute :last_name, String
+        end
+
+        stub_model(:post) do
+          attribute :author, Object
+          represents :first_name, :last_name, of: :author
+        end
+      end
+
+      let(:author) { Author.new(first_name: 'John', last_name: 'Doe') }
+      let(:post) { Post.new }
+
+      specify do
+        expect { post.update(author: author) }
+          .to change { post.first_name }.to('John')
+          .and change { post.last_name }.to('Doe')
+      end
+    end
+  end
+end