granite-form 0.1.0

data/spec/lib/granite/form/model/attributes/reflections/base_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Granite::Form::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('Granite::Form::Model::Attributes::Borogoves')
+    end
+
+    specify { expect(described_class.attribute_class).to eq(Granite::Form::Model::Attributes::Base) }
+    specify { expect(SomeScope::Borogoves.attribute_class).to eq(Granite::Form::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('Granite::Form::Model::Attributes::Borogoves', Granite::Form::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(Granite::Form::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/granite/form/model/attributes/reflections/collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Granite::Form::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/granite/form/model/attributes/reflections/dictionary_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Granite::Form::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/granite/form/model/attributes/reflections/localized_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Granite::Form::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/granite/form/model/attributes/reflections/represents_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Granite::Form::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/granite/form/model/attributes/represents_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Represents do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    Dummy.add_attribute(Granite::Form::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 '#new' do
+    before { attribute(:full_name) }
+    let(:attributes) { {foo: 'bar'} }
+
+    specify { expect { Dummy.new(attributes) }.to_not change { attributes } }
+  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: %w[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
+end

data/spec/lib/granite/form/model/attributes_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes do
+  let(:model) do
+    stub_model do
+      include Granite::Form::Model::Associations
+      include Granite::Form::Model::Localization
+
+      attribute :id, Integer
+      attribute :full_name, String
+      alias_attribute :name, :full_name
+
+      localized :t, String
+      alias_attribute :title, :t
+
+      embeds_one(:author) {}
+      embeds_many(:projects) {}
+    end
+  end
+
+  describe '.reflect_on_attribute' do
+    specify { expect(model.reflect_on_attribute(:full_name).name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute('full_name').name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute(:name).name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute(:foobar)).to be_nil }
+  end
+
+  describe '.has_attribute?' do
+    specify { expect(model.has_attribute?(:full_name)).to eq(true) }
+    specify { expect(model.has_attribute?('full_name')).to eq(true) }
+    specify { expect(model.has_attribute?(:name)).to eq(true) }
+    specify { expect(model.has_attribute?(:foobar)).to eq(false) }
+  end
+
+  describe '.attribute_names' do
+    specify { expect(stub_model.attribute_names).to eq([]) }
+    specify { expect(model.attribute_names).to eq(%w[id full_name t author projects]) }
+    specify { expect(model.attribute_names(false)).to eq(%w[id full_name t]) }
+  end
+
+  describe '.inspect' do
+    specify { expect(stub_model.inspect).to match(/#<Class:0x\w+>\(no attributes\)/) }
+    specify { expect(stub_model(:user).inspect).to eq('User(no attributes)') }
+    specify do
+      expect(stub_model do
+               include Granite::Form::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/) end
+    specify do
+      expect(stub_model(:user) do
+               include Granite::Form::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.inspect).to match('User(*count: Integer, object: Object)') end
+  end
+
+  describe '#==' do
+    let(:model) do
+      stub_model do
+        attribute :name, String
+        attribute :count, Float, default: 0
+      end
+    end
+    subject { model.new name: 'hello', count: 42 }
+
+    it { is_expected.not_to eq(nil) }
+    it { is_expected.not_to eq('hello') }
+    it { is_expected.not_to eq(Object.new) }
+    it { is_expected.not_to eq(model.new) }
+    it { is_expected.not_to eq(model.new(name: 'hello1', count: 42)) }
+    it { is_expected.not_to eq(model.new(name: 'hello', count: 42.1)) }
+    it { is_expected.to eq(model.new(name: 'hello', count: 42)) }
+
+    it { is_expected.not_to eql(nil) }
+    it { is_expected.not_to eql('hello') }
+    it { is_expected.not_to eql(Object.new) }
+    it { is_expected.not_to eql(model.new) }
+    it { is_expected.not_to eql(model.new(name: 'hello1', count: 42)) }
+    it { is_expected.not_to eql(model.new(name: 'hello', count: 42.1)) }
+    it { is_expected.to eql(model.new(name: 'hello', count: 42)) }
+  end
+
+  describe '#attribute' do
+    let(:instance) { model.new }
+    specify { expect(instance.attribute(:full_name).reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute('full_name').reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute(:name).reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute(:foobar)).to be_nil }
+
+    specify { expect(instance.attribute('full_name')).to equal(instance.attribute(:name)) }
+  end
+
+  describe '#has_attribute?' do
+    specify { expect(model.new.has_attribute?(:full_name)).to eq(true) }
+    specify { expect(model.new.has_attribute?('full_name')).to eq(true) }
+    specify { expect(model.new.has_attribute?(:name)).to eq(true) }
+    specify { expect(model.new.has_attribute?(:foobar)).to eq(false) }
+  end
+
+  describe '#attribute_names' do
+    specify { expect(stub_model.new.attribute_names).to eq([]) }
+    specify { expect(model.new.attribute_names).to eq(%w[id full_name t author projects]) }
+    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name t]) }
+  end
+
+  describe '#attribute_present?' do
+    specify { expect(model.new.attribute_present?(:name)).to be(false) }
+    specify { expect(model.new(name: '').attribute_present?(:name)).to be(false) }
+    specify { expect(model.new(name: 'Name').attribute_present?(:name)).to be(true) }
+  end
+
+  describe '#attributes' do
+    specify { expect(stub_model.new.attributes).to eq({}) }
+    specify do
+      expect(model.new(name: 'Name').attributes)
+        .to match('id' => nil, 'full_name' => 'Name', 't' => {}, 'author' => nil, 'projects' => nil)
+    end
+    specify do
+      expect(model.new(name: 'Name').attributes(false))
+        .to match('id' => nil, 'full_name' => 'Name', 't' => {})
+    end
+  end
+
+  describe '#assign_attributes' do
+    let(:attributes) { {id: 42, full_name: 'Name', missed: 'value'} }
+    subject { model.new }
+
+    specify { expect { subject.assign_attributes(attributes) }.to change { subject.id }.to(42) }
+    specify { expect { subject.assign_attributes(attributes) }.to change { subject.full_name }.to('Name') }
+
+    context 'features stack and assign order' do
+      let(:model) do
+        stub_model do
+          attr_reader :logger
+
+          def self.log(a)
+            define_method("#{a}=") do |*args|
+              log(a)
+              super(*args)
+            end
+          end
+
+          def log(o)
+            (@logger ||= []).push(o)
+          end
+
+          attribute :plain1, String
+          attribute :plain2, String
+          log(:plain1)
+          log(:plain2)
+        end
+      end
+      subject { model.new }
+
+      specify do
+        expect { subject.assign_attributes(plain1: 'value', plain2: 'value') }
+          .to change { subject.logger }.to(%i[plain1 plain2])
+      end
+
+      specify do
+        expect { subject.assign_attributes(plain2: 'value', plain1: 'value') }
+          .to change { subject.logger }.to(%i[plain2 plain1])
+      end
+
+      context do
+        before do
+          model.class_eval do
+            include Granite::Form::Model::Representation
+            include Granite::Form::Model::Associations
+
+            embeds_one :assoc do
+              attribute :assoc_plain, String
+            end
+            accepts_nested_attributes_for :assoc
+
+            represents :assoc_plain, of: :assoc
+
+            log(:assoc_attributes)
+            log(:assoc_plain)
+
+            def assign_attributes(attrs)
+              super attrs.merge(attrs.extract!('plain2'))
+            end
+          end
+        end
+
+        specify do
+          expect { subject.assign_attributes(assoc_plain: 'value', assoc_attributes: {}, plain1: 'value', plain2: 'value') }
+            .to change { subject.logger }.to(%i[plain1 assoc_attributes assoc_plain plain2])
+        end
+
+        specify do
+          expect { subject.assign_attributes(plain1: 'value', plain2: 'value', assoc_plain: 'value', assoc_attributes: {}) }
+            .to change { subject.logger }.to(%i[plain1 assoc_attributes assoc_plain plain2])
+        end
+      end
+    end
+  end
+
+  describe '#inspect' do
+    specify { expect(stub_model.new.inspect).to match(/#<#<Class:0x\w+> \(no attributes\)>/) }
+    specify { expect(stub_model(:user).new.inspect).to match(/#<User \(no attributes\)>/) }
+    specify do
+      expect(stub_model do
+               include Granite::Form::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/) end
+    specify do
+      expect(stub_model(:user) do
+               include Granite::Form::Model::Primary
+               primary :count, Integer
+               attribute :object, Object
+             end.new.inspect).to match(/#<User \*count: nil, object: nil>/) end
+  end
+
+  context 'attributes integration' do
+    let(:model) do
+      stub_class do
+        include Granite::Form::Model::Attributes
+        include Granite::Form::Model::Associations
+        attr_accessor :name
+
+        attribute :id, Integer
+        attribute :hello, Object
+        attribute :string, String, default: ->(record) { record.name }
+        attribute :count, Integer, default: '10'
+        attribute(:calc, Integer) { 2 + 3 }
+        attribute :enum, Integer, enum: [1, 2, 3]
+        attribute :enum_with_default, Integer, enum: [1, 2, 3], default: '2'
+        attribute :foo, Boolean, default: false
+        collection :array, Integer, enum: [1, 2, 3], default: 7
+
+        def initialize(name = nil)
+          super()
+          @name = name
+        end
+      end
+    end
+
+    subject { model.new('world') }
+
+    its(:enum_values) { should == [1, 2, 3] }
+    its(:string_default) { should == 'world' }
+    its(:count_default) { should == '10' }
+    its(:name) { should == 'world' }
+    its(:hello) { should eq(nil) }
+    its(:hello?) { should eq(false) }
+    its(:count) { should == 10 }
+    its(:count_before_type_cast) { should == '10' }
+    its(:count_came_from_user?) { should eq(false) }
+    its(:count?) { should eq(true) }
+    its(:calc) { should == 5 }
+    its(:enum?) { should eq(false) }
+    its(:enum_with_default?) { should eq(true) }
+    specify { expect { subject.hello = 'worlds' }.to change { subject.hello }.from(nil).to('worlds') }
+    specify { expect { subject.count = 20 }.to change { subject.count }.from(10).to(20) }
+    specify { expect { subject.calc = 15 }.to change { subject.calc }.from(5).to(15) }
+    specify { expect { subject.count = '11' }.to change { subject.count_came_from_user? }.from(false).to(true) }
+
+    context 'enums' do
+      specify do
+        subject.enum = 3
+        expect(subject.enum).to eq(3)
+      end
+      specify do
+        subject.enum = '3'
+        expect(subject.enum).to eq(3)
+      end
+      specify do
+        subject.enum = 10
+        expect(subject.enum).to eq(nil)
+      end
+      specify do
+        subject.enum = 'hello'
+        expect(subject.enum).to eq(nil)
+      end
+      specify do
+        subject.enum_with_default = 3
+        expect(subject.enum_with_default).to eq(3)
+      end
+      specify do
+        subject.enum_with_default = 10
+        expect(subject.enum_with_default).to be_nil
+      end
+    end
+
+    context 'array' do
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array).to eq([2, nil])
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array?).to eq(true)
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array_values).to eq([1, 2, 3])
+      end
+      specify do
+        subject.array = [2, 4]
+        expect(subject.array_default).to eq(7)
+      end
+    end
+
+    context 'attribute caching' do
+      before do
+        subject.hello = 'blabla'
+        subject.hello
+        subject.hello = 'newnewnew'
+      end
+
+      specify { expect(subject.hello).to eq('newnewnew') }
+    end
+  end
+
+  context 'inheritance' do
+    let!(:ancestor) do
+      Class.new do
+        include Granite::Form::Model::Attributes
+        attribute :foo, String
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor do
+        attribute :bar, String
+      end
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor do
+        attribute :baz, String
+        attribute :moo, String
+      end
+    end
+
+    specify { expect(ancestor._attributes.keys).to eq(['foo']) }
+    specify { expect(ancestor.instance_methods).to include :foo, :foo= }
+    specify { expect(ancestor.instance_methods).not_to include :bar, :bar=, :baz, :baz= }
+    specify { expect(descendant1._attributes.keys).to eq(%w[foo bar]) }
+    specify { expect(descendant1.instance_methods).to include :foo, :foo=, :bar, :bar= }
+    specify { expect(descendant1.instance_methods).not_to include :baz, :baz= }
+    specify { expect(descendant2._attributes.keys).to eq(%w[foo baz moo]) }
+    specify { expect(descendant2.instance_methods).to include :foo, :foo=, :baz, :baz=, :moo, :moo= }
+    specify { expect(descendant2.instance_methods).not_to include :bar, :bar= }
+  end
+end