granite-form 0.1.0 → 0.2.0

data/spec/{lib/granite → granite}/form/model/attributes/attribute_spec.rb

@@ -57,51 +57,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(attribute(default: false, type: Boolean).defaultize(nil)).to eq(false) }
   end
 
-  describe '#typecast' do
-    context 'when Object' do
-      specify { expect(attribute.typecast(:hello)).to eq(:hello) }
-    end
-
-    context 'when Integer' do
-      specify { expect(attribute(type: Integer).typecast(42)).to eq(42) }
-      specify { expect(attribute(type: Integer).typecast('42')).to eq(42) }
-    end
-
-    context 'when Hash' do
-      let(:to_h) { {'x' => {'foo' => 'bar'}, 'y' => 2} }
-      let(:parameters) { ActionController::Parameters.new(to_h) }
-
-      before(:all) do
-        @default_hash_typecaster = Granite::Form.typecaster('Hash')
-        require 'action_controller'
-        Class.new(ActionController::Base)
-        @action_controller_hash_typecaster = Granite::Form.typecaster('Hash')
-      end
-
-      context 'when ActionController is loaded' do
-        before { Granite::Form.typecaster('Hash', &@action_controller_hash_typecaster) }
-        after { Granite::Form.typecaster('Hash', &@default_hash_typecaster) }
-
-        specify { expect(attribute(type: Hash).typecast(nil)).to be_nil }
-        specify { expect(attribute(type: Hash).typecast(to_h)).to eq(to_h) }
-        specify { expect(attribute(type: Hash).typecast(parameters)).to be_nil }
-        specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to eq(to_h) }
-      end
-
-      context 'when ActionController is not loaded' do
-        before { Granite::Form.typecaster('Hash', &@default_hash_typecaster) }
-
-        specify { expect(attribute(type: Hash).typecast(nil)).to be_nil }
-        specify { expect(attribute(type: Hash).typecast(to_h)).to eq(to_h) }
-        if ActiveSupport.version > Gem::Version.new('4.3')
-          specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to be_nil }
-        else
-          specify { expect(attribute(type: Hash).typecast(parameters.permit(:y, x: [:foo]))).to eq(to_h) }
-        end
-      end
-    end
-  end
-
   describe '#enum' do
     before { allow_any_instance_of(Dummy).to receive_messages(value: 1..5) }
 
@@ -144,7 +99,10 @@ describe Granite::Form::Model::Attributes::Attribute do
 
     context 'integration' do
       before do
-        allow(Granite::Form).to receive_messages(config: Granite::Form::Config.send(:new))
+        config = Granite::Form::Config.send(:new)
+        config.types.merge! Granite::Form.config.types
+        allow(Granite::Form).to receive_messages(config: config)
+
         Granite::Form.normalizer(:strip) { |value, _, _| value.strip }
         Granite::Form.normalizer(:trim) do |value, options, _attribute|
           value.first(length || options[:length] || 2)

data/spec/{lib/granite → granite}/form/model/attributes/base_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Granite::Form::Model::Attributes::Base do
+  let(:model) { Dummy.new }
+
   before { stub_model(:dummy) }
 
   def attribute(*args)
     options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field, options)
-    Dummy.new.attribute(:field)
+    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Base, :field, options.reverse_merge(type: Object))
+    model.attribute(:field)
   end
 
   describe '#read' do
@@ -94,4 +96,11 @@ describe Granite::Form::Model::Attributes::Base do
     specify { expect(attribute(readonly: -> { false })).not_to be_readonly }
     specify { expect(attribute(readonly: -> { true })).to be_readonly }
   end
+
+  describe '#type_definition' do
+    subject { attr.type_definition }
+    let(:attr) { attribute(type: String) }
+
+    it { is_expected.to have_attributes(type: String, reflection: subject.reflection, owner: model) }
+  end
 end

data/spec/{lib/granite → granite}/form/model/attributes/localized_spec.rb

@@ -6,7 +6,7 @@ describe Granite::Form::Model::Attributes::Localized do
   def attribute(*args)
     options = args.extract_options!
     Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, :field, options)
-    described_class.new('field', Dummy.new)
+    Dummy.new.attribute(:field)
   end
 
   describe '#read' do

data/spec/{lib/granite → granite}/form/model/attributes/reflections/attribute_spec.rb

@@ -43,18 +43,6 @@ describe Granite::Form::Model::Attributes::Reflections::Attribute do
     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(Granite::Form.typecaster(Object)) }
-    specify { expect(reflection(type: String).typecaster).to eq(Granite::Form.typecaster(String)) }
-    specify { expect(reflection(type: Dummy).typecaster).to eq(Granite::Form.typecaster(String)) }
-    specify { expect(reflection(type: DummyDummy).typecaster).to eq(Granite::Form.typecaster(String)) }
-  end
-
   describe '#enumerizer' do
     specify { expect(reflection.enumerizer).to be_nil }
     specify { expect(reflection(enum: 42).enumerizer).to eq(42) }

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

@@ -36,7 +36,7 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
       stub_class(:owner)
     end
 
-    let(:reflection) { SomeScope::Borogoves.new(:field) }
+    let(:reflection) { SomeScope::Borogoves.new(:field, type: Object) }
     let(:owner) { Owner.new }
 
     specify { expect(reflection.build_attribute(owner, nil)).to be_a(Granite::Form::Model::Attributes::Borogoves) }

data/spec/{lib/granite → granite}/form/model/primary_spec.rb

@@ -54,7 +54,7 @@ describe Granite::Form::Model::Primary do
         include Granite::Form::Model::Primary
 
         primary_attribute type: Integer
-        attribute :name
+        attribute :name, Object
       end
     end
 

data/spec/{lib/granite → granite}/form/model/representation_spec.rb

@@ -126,13 +126,25 @@ describe Granite::Form::Model::Representation do
 
     specify do
       expect { post.validate }.to change { post.errors.messages }
-        .to(hash_including('author.user.email': ['is invalid'], name: ["can't be blank"]))
+        .to('author.user.email': ['is invalid'], name: ["can't be blank"])
     end
 
     if ActiveModel.version >= Gem::Version.new('6.1.0')
       specify do
         expect { post.validate }.to change { post.errors.details }
-          .to(hash_including('author.user.email': [{error: 'is invalid'}], name: [{error: :blank}]))
+          .to('author.user.email': [{error: 'is invalid'}], name: [{error: :blank}])
+      end
+    end
+
+    context 'when using symbol in error message of represented model' do
+      before do
+        Author.validates :name, inclusion: {in: ['Author'], message: :invalid_name, allow_blank: true}
+        post.author.name = 'Not Author'
+      end
+
+      specify do
+        expect { post.validate }.to change { post.errors.messages }
+          .to('author.user.email': ['is invalid'], name: ['must be Author'])
       end
     end
   end

data/spec/{lib/granite → granite}/form/model/validations/nested_spec.rb

@@ -114,35 +114,79 @@ describe Granite::Form::Model::Validations::NestedValidator do
 
   context 'object field is invalid and referenced object does not include AutosaveAssociation' do
     before do
-      stub_class(:validated_object) do
-        include Granite::Form::Model::Validations
-        include Granite::Form::Model::Attributes
-        include Granite::Form::Model::Primary
-
-        primary :id
+      stub_model(:validated_object) do
         attribute :title, String
         validates_presence_of :title
       end
 
-      Main.class_eval do
-        include Granite::Form::Model::Associations
+      stub_model(:main) do
+        include Granite::Form::Model::Persistence
+
         attribute :object, Object
         validates :object, nested: true
       end
     end
 
-    subject(:instance) { Main.instantiate name: 'hello', object: object, validated_one: {name: 'name'} }
+    subject(:instance) { Main.instantiate name: 'hello', object: object }
 
-    context do
+    context 'nested object is valid' do
       let(:object) { ValidatedObject.new(title: 'Mr.') }
+
       it { is_expected.to be_valid }
     end
 
-    context do
+    context 'nested object is invalid' do
       let(:object) { ValidatedObject.new }
+
       it do
         expect { subject.valid? }.not_to raise_error
         expect(subject).not_to be_valid
+        expect(subject.errors.count).to eq(1)
+      end
+
+      context 'nested validation runs twice' do
+        before do
+          stub_model(:main) do
+            include Granite::Form::Model::Persistence
+
+            attribute :object, Object
+            validates :object, nested: true
+            validates :object, nested: true
+          end
+        end
+
+        it do
+          subject.validate
+          expect(subject.errors.count).to eq(1)
+        end
+
+        context 'nested object validation has condition' do
+          before do
+            stub_model(:validated_object) do
+              attribute :title, String
+              validates_presence_of :title, if: -> { true }
+            end
+          end
+
+          it do
+            subject.validate
+            expect(subject.errors.count).to eq(1)
+          end
+        end
+
+        context 'nested object validation has message' do
+          before do
+            stub_model(:validated_object) do
+              attribute :title, String
+              validates_presence_of :title, message: 'test'
+            end
+          end
+
+          it do
+            subject.validate
+            expect(subject.errors.count).to eq(1)
+          end
+        end
       end
     end
   end

data/spec/granite/form/types/active_support/time_zone_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::ActiveSupport::TimeZone do
+  describe 'typecasting' do
+    include_context 'type setup', 'ActiveSupport::TimeZone'
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast(Object.new)).to be_nil }
+    specify { expect(typecast(Time.now)).to be_nil }
+    specify { expect(typecast('blablabla')).to be_nil }
+    specify { expect(typecast(TZInfo::Timezone.all.first)).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast('Moscow')).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast('+4')).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast('-3')).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast('3600')).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast('-7200')).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast(4)).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast(-3)).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast(3600)).to be_a ActiveSupport::TimeZone }
+    specify { expect(typecast(-7200)).to be_a ActiveSupport::TimeZone }
+  end
+end

data/spec/granite/form/types/array_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Array do
+  describe 'typecasting' do
+    include_context 'type setup', 'Array'
+
+    specify { expect(typecast([1, 2, 3])).to eq([1, 2, 3]) }
+    specify { expect(typecast('hello, world')).to eq(%w[hello world]) }
+    specify { expect(typecast(10)).to be_nil }
+  end
+end

data/spec/granite/form/types/big_decimal_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::BigDecimal do
+  describe 'typecasting' do
+    include_context 'type setup', 'BigDecimal'
+
+    specify { expect(typecast('hello')).to be_nil }
+    specify { expect(typecast('123hello')).to be_nil }
+    specify { expect(typecast('123')).to eq(BigDecimal('123.0')) }
+    specify { expect(typecast('123.')).to be_nil }
+    specify { expect(typecast('123.5')).to eq(BigDecimal('123.5')) }
+    specify { expect(typecast(123)).to eq(BigDecimal('123.0')) }
+    specify { expect(typecast(123.5)).to eq(BigDecimal('123.5')) }
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast([123.5])).to be_nil }
+  end
+end

data/spec/granite/form/types/boolean_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Boolean do
+  describe 'typecasting' do
+    include_context 'type setup', 'Boolean'
+
+    specify { expect(typecast('hello')).to be_nil }
+    specify { expect(typecast('true')).to eq(true) }
+    specify { expect(typecast('false')).to eq(false) }
+    specify { expect(typecast('1')).to eq(true) }
+    specify { expect(typecast('0')).to eq(false) }
+    specify { expect(typecast(true)).to eq(true) }
+    specify { expect(typecast(false)).to eq(false) }
+    specify { expect(typecast(1)).to eq(true) }
+    specify { expect(typecast(0)).to eq(false) }
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast([123])).to be_nil }
+  end
+end

data/spec/granite/form/types/date_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Date do
+  describe 'typecasting' do
+    include_context 'type setup', 'Date'
+    let(:date) { Date.new(2013, 6, 13) }
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast('2013-06-13')).to eq(date) }
+    specify { expect(typecast('2013-55-55')).to be_nil }
+    specify { expect(typecast('blablabla')).to be_nil }
+    specify { expect(typecast(DateTime.new(2013, 6, 13, 23, 13))).to eq(date) } # rubocop:disable Style/DateTime
+    specify { expect(typecast(Time.new(2013, 6, 13, 23, 13))).to eq(date) }
+    specify { expect(typecast(Date.new(2013, 6, 13))).to eq(date) }
+  end
+end

data/spec/granite/form/types/date_time_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::DateTime do
+  # rubocop:disable Style/DateTime
+  describe 'typecasting' do
+    include_context 'type setup', 'DateTime'
+    let(:datetime) { DateTime.new(2013, 6, 13, 23, 13) }
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast('2013-06-13 23:13')).to eq(datetime) }
+    specify { expect(typecast('2013-55-55 55:55')).to be_nil }
+    specify { expect(typecast('blablabla')).to be_nil }
+    specify { expect(typecast(Date.new(2013, 6, 13))).to eq(DateTime.new(2013, 6, 13, 0, 0)) }
+    specify { expect(typecast(Time.utc(2013, 6, 13, 23, 13).utc)).to eq(datetime) }
+    specify { expect(typecast(DateTime.new(2013, 6, 13, 23, 13))).to eq(datetime) }
+  end
+  # rubocop:enable Style/DateTime
+end

data/spec/granite/form/types/float_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Float do
+  describe 'typecasting' do
+    include_context 'type setup', 'Float'
+
+    specify { expect(typecast('hello')).to be_nil }
+    specify { expect(typecast('123hello')).to be_nil }
+    specify { expect(typecast('123')).to eq(123.0) }
+    specify { expect(typecast('123.')).to be_nil }
+    specify { expect(typecast('123.5')).to eq(123.5) }
+    specify { expect(typecast(123)).to eq(123.0) }
+    specify { expect(typecast(123.5)).to eq(123.5) }
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast([123.5])).to be_nil }
+  end
+end

data/spec/granite/form/types/hash_with_action_controller_parameters_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::HashWithActionControllerParameters do
+  describe 'typecasting' do
+    include_context 'type setup', 'Hash'
+
+    before(:all) do
+      require 'action_controller'
+      Class.new(ActionController::Base)
+    end
+
+    let(:to_h) { {'x' => {'foo' => 'bar'}, 'y' => 2} }
+    let(:parameters) { ActionController::Parameters.new(to_h) }
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast(to_h)).to eq(to_h) }
+    specify { expect(typecast(parameters)).to be_nil }
+    specify { expect(typecast(parameters.permit(:y, x: [:foo]))).to eq(to_h) }
+  end
+end

data/spec/granite/form/types/integer_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Integer do
+  describe 'typecasting' do
+    include_context 'type setup', 'Integer'
+
+    specify { expect(typecast('hello')).to be_nil }
+    specify { expect(typecast('123hello')).to be_nil }
+    specify { expect(typecast('123')).to eq(123) }
+    specify { expect(typecast('123.5')).to eq(123) }
+    specify { expect(typecast(123)).to eq(123) }
+    specify { expect(typecast(123.5)).to eq(123) }
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast([123])).to be_nil }
+  end
+end

data/spec/granite/form/types/object_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Object do
+  subject(:type) { described_class.new(String, reflection, model.new) }
+  let(:model) { stub_model }
+  let(:reflection) { Granite::Form::Model::Attributes::Reflections::Base.new(:field) }
+
+  describe '#initialize' do
+    it { is_expected.to have_attributes(type: String, reflection: reflection, owner: an_instance_of(model)) }
+  end
+
+  describe 'typecasting' do
+    before { stub_class(:descendant) }
+
+    context 'with Object type' do
+      include_context 'type setup', 'Object'
+
+      specify { expect(typecast('hello')).to eq('hello') }
+      specify { expect(typecast([])).to eq([]) }
+      specify { expect(typecast(Descendant.new)).to be_a(Descendant) }
+      specify { expect(typecast(Object.new)).to be_a(Object) }
+      specify { expect(typecast(nil)).to be_nil }
+    end
+
+    context 'with Descendant type' do
+      include_context 'type setup', 'Descendant'
+
+      before { stub_class(:descendant2, Descendant) }
+
+      specify { expect(typecast('hello')).to be_nil }
+      specify { expect(typecast([])).to be_nil }
+      specify { expect(typecast(Descendant.new)).to be_a(Descendant) }
+      specify { expect(typecast(Descendant2.new)).to be_a(Descendant2) }
+      specify { expect(typecast(Object.new)).to be_nil }
+      specify { expect(typecast(nil)).to be_nil }
+    end
+  end
+end

data/spec/granite/form/types/string_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::String do
+  describe 'typecasting' do
+    include_context 'type setup', 'String'
+
+    specify { expect(typecast('hello')).to eq('hello') }
+    specify { expect(typecast(123)).to eq('123') }
+    specify { expect(typecast(nil)).to be_nil }
+  end
+end

data/spec/granite/form/types/time_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::Time do
+  # rubocop:disable Style/DateTime
+  describe 'typecasting' do
+    include_context 'type setup', 'Time'
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast('2013-06-13 23:13')).to eq('2013-06-13 23:13'.to_time) }
+    specify { expect(typecast('2013-55-55 55:55')).to be_nil }
+    specify { expect(typecast('blablabla')).to be_nil }
+    specify { expect(typecast(Date.new(2013, 6, 13))).to eq(Time.new(2013, 6, 13, 0, 0)) }
+    specify { expect(typecast(DateTime.new(2013, 6, 13, 19, 13))).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+    specify { expect(typecast(Time.new(2013, 6, 13, 23, 13))).to eq(Time.new(2013, 6, 13, 23, 13)) }
+
+    context 'Time.zone set' do
+      around { |example| Time.use_zone('Bangkok', &example) }
+
+      specify { expect(typecast(nil)).to be_nil }
+      specify { expect(typecast('2013-06-13 23:13')).to eq(Time.zone.parse('2013-06-13 23:13')) }
+      specify { expect(typecast('2013-55-55 55:55')).to be_nil }
+      specify { expect(typecast('blablabla')).to be_nil }
+      specify { expect(typecast(Date.new(2013, 6, 13))).to eq(Time.new(2013, 6, 13, 0, 0)) }
+      specify { expect(typecast(DateTime.new(2013, 6, 13, 19, 13))).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+      specify { expect(typecast(Time.new(2013, 6, 13, 23, 13))).to eq(Time.new(2013, 6, 13, 23, 13)) }
+    end
+  end
+  # rubocop:enable Style/DateTime
+end

data/spec/granite/form/types/uuid_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::Types::UUID do
+  describe 'typecasting' do
+    include_context 'type setup', 'Granite::Form::UUID'
+    let(:uuid) { Granite::Form::UUID.random_create }
+    let(:uuid_tools) { UUIDTools::UUID.random_create }
+
+    specify { expect(typecast(nil)).to be_nil }
+    specify { expect(typecast(Object.new)).to be_nil }
+    specify { expect(typecast(uuid_tools)).to be_a Granite::Form::UUID }
+    specify { expect(typecast(uuid_tools)).to eq(uuid_tools) }
+    specify { expect(typecast(uuid)).to eq(uuid) }
+    specify { expect(typecast(uuid.to_s)).to eq(uuid) }
+    specify { expect(typecast(uuid.to_i)).to eq(uuid) }
+    specify { expect(typecast(uuid.hexdigest)).to eq(uuid) }
+    specify { expect(typecast(uuid.raw)).to eq(uuid) }
+  end
+end

data/spec/spec_helper.rb

@@ -8,8 +8,7 @@ require 'rack/test'
 require 'action_controller/metal/strong_parameters'
 require 'database_cleaner'
 
-require 'support/model_helpers'
-require 'support/muffle_helper'
+Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |f| require f }
 
 ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 ActiveRecord::Base.logger = Logger.new('/dev/null')

data/spec/support/shared/type_examples.rb

@@ -0,0 +1,7 @@
+shared_context 'type setup' do |type_name|
+  let(:model) { stub_model { attribute :column, type_name.constantize } }
+
+  def typecast(value)
+    model.new(column: value).column
+  end
+end

data/spec/support/translations.rb

@@ -0,0 +1,6 @@
+I18n.backend.store_translations(:en, YAML.safe_load(<<-YAML))
+  activerecord:
+    errors:
+      messages:
+        invalid_name: "must be Author"
+YAML