granite-form 0.1.1 → 0.2.0

data/lib/granite/form.rb

@@ -11,6 +11,7 @@ require 'granite/form/version'
 require 'granite/form/errors'
 require 'granite/form/extensions'
 require 'granite/form/undefined_class'
+require 'granite/form/types'
 require 'granite/form/config'
 require 'granite/form/railtie' if defined? Rails
 require 'granite/form/model'
@@ -19,130 +20,26 @@ require 'granite/form/model/associations/persistence_adapters/active_record'
 
 module Granite
   module Form
-    BOOLEAN_MAPPING = {
-      1 => true,
-      0 => false,
-      '1' => true,
-      '0' => false,
-      't' => true,
-      'f' => false,
-      'T' => true,
-      'F' => false,
-      true => true,
-      false => false,
-      'true' => true,
-      'false' => false,
-      'TRUE' => true,
-      'FALSE' => false,
-      'y' => true,
-      'n' => false,
-      'yes' => true,
-      'no' => false
-    }.freeze
-
     def self.config
       Granite::Form::Config.instance
     end
 
     singleton_class.delegate(*Granite::Form::Config.delegated, to: :config)
 
-    typecaster('Object') { |value, attribute| value if value.class < attribute.type }
-    typecaster('String') { |value, _| value.to_s }
-    typecaster('Array') do |value|
-      case value
-      when ::Array then
-        value
-      when ::String then
-        value.split(',').map(&:strip)
-      end
-    end
-    typecaster('Hash') do |value|
-      case value
-      when ::Hash then
-        value
-      end
-    end
-    ActiveSupport.on_load :action_controller do
-      Granite::Form.typecaster('Hash') do |value|
-        case value
-        when ActionController::Parameters
-          value.to_h if value.permitted?
-        when ::Hash then
-          value
-        end
-      end
-    end
-    typecaster('Date') do |value|
-      begin
-        value.to_date
-      rescue ArgumentError, NoMethodError
-        nil
-      end
-    end
-    typecaster('DateTime') do |value|
-      begin
-        value.to_datetime
-      rescue ArgumentError
-        nil
-      end
-    end
-    typecaster('Time') do |value|
-      begin
-        value.is_a?(String) && ::Time.zone ? ::Time.zone.parse(value) : value.to_time
-      rescue ArgumentError
-        nil
-      end
-    end
-    typecaster('ActiveSupport::TimeZone') do |value|
-      case value
-      when ActiveSupport::TimeZone
-        value
-      when ::TZInfo::Timezone
-        ActiveSupport::TimeZone[value.name]
-      when String, Numeric, ActiveSupport::Duration
-        value = begin
-                  Float(value)
-                rescue ArgumentError, TypeError
-                  value
-                end
-        ActiveSupport::TimeZone[value]
-      end
-    end
-    typecaster('BigDecimal') do |value|
-      next unless value
-      begin
-        BigDecimal(Float(value).to_s)
-      rescue ArgumentError, TypeError
-        nil
-      end
-    end
-    typecaster('Float') do |value|
-      begin
-        Float(value)
-      rescue ArgumentError, TypeError
-        nil
-      end
-    end
-    typecaster('Integer') do |value|
-      begin
-        Float(value).to_i
-      rescue ArgumentError, TypeError
-        nil
-      end
-    end
-    typecaster('Boolean') { |value| BOOLEAN_MAPPING[value] }
-    typecaster('Granite::Form::UUID') do |value|
-      case value
-      when UUIDTools::UUID
-        Granite::Form::UUID.parse_raw value.raw
-      when Granite::Form::UUID
-        value
-      when String
-        Granite::Form::UUID.parse_string value
-      when Integer
-        Granite::Form::UUID.parse_int value
-      end
-    end
+    config.types = {
+      'Object' => Types::Object,
+      'String' => Types::String,
+      'Array' => Types::Array,
+      'Date' => Types::Date,
+      'DateTime' => Types::DateTime,
+      'Time' => Types::Time,
+      'ActiveSupport::TimeZone' => Types::ActiveSupport::TimeZone,
+      'BigDecimal' => Types::BigDecimal,
+      'Float' => Types::Float,
+      'Integer' => Types::Integer,
+      'Boolean' => Types::Boolean,
+      'Granite::Form::UUID' => Types::UUID
+    }
   end
 end
 
@@ -150,6 +47,10 @@ require 'granite/form/base'
 
 Granite::Form.base_class = Granite::Form::Base
 
+ActiveSupport.on_load :action_controller do
+  Granite::Form.config.types['Hash'] = Granite::Form::Types::HashWithActionControllerParameters
+end
+
 ActiveSupport.on_load :active_record do
   require 'granite/form/active_record/associations'
   require 'granite/form/active_record/nested_attributes'

data/spec/{lib/granite → granite}/form/active_record/nested_attributes_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'shared/nested_attribute_examples'
 
 describe Granite::Form::ActiveRecord::NestedAttributes do
   before do

data/spec/{lib/granite → granite}/form/config_spec.rb

@@ -47,20 +47,32 @@ describe Granite::Form::Config do
 
   describe '#typecaster' do
     specify do
-      expect { subject.typecaster('Object') {} }
-        .to change { muffle(Granite::Form::TypecasterMissing) { subject.typecaster(Time, Object) } }
-        .from(nil).to(an_instance_of(Proc))
+      expect { subject.typecaster('Object', &:to_s) }
+        .to change { subject.types['Object'] }.from(nil).to(an_instance_of(Class))
+
+      expect(subject.types['Object'].new(Object, nil, stub_model.new).typecast(1)).to eq('1')
     end
+
+    specify do
+      expect { subject.typecaster(Object) {} }
+        .to change { subject.types['Object'] }.from(nil).to(an_instance_of(Class))
+    end
+
     specify do
-      expect { subject.typecaster('Object') {} }
-        .to change { muffle(Granite::Form::TypecasterMissing) { subject.typecaster('time', 'object') } }
-        .from(nil).to(an_instance_of(Proc))
+      expect { subject.typecaster('object') {} }
+        .to change { subject.types['Object'] }.from(nil).to(an_instance_of(Class))
     end
+  end
+
+  describe '#type_for' do
+    let(:definition) { subject.types['Numeric'] }
+
+    before { subject.typecaster('Numeric') {} }
+
     specify do
-      expect { subject.typecaster('Object') {} }
-        .to change { muffle(Granite::Form::TypecasterMissing) { subject.typecaster(Object) } }
-        .from(nil).to(an_instance_of(Proc))
+      expect(subject.type_for(Numeric)).to eq(definition)
+      expect(subject.type_for(Integer)).to eq(definition)
+      expect { subject.type_for(String) }.to raise_error(Granite::Form::TypecasterMissing)
     end
-    specify { expect { subject.typecaster(Object) }.to raise_error Granite::Form::TypecasterMissing }
   end
 end

data/spec/granite/form/extensions_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Granite::Form::UUID do
+  subject(:uuid) { Granite::Form::UUID.random_create }
+
+  specify { expect(uuid.as_json).to eq(uuid.to_s) }
+  specify { expect(uuid.to_json).to eq("\"#{uuid}\"") }
+  specify { expect(uuid.to_param).to eq(uuid.to_s) }
+  specify { expect(uuid.to_query(:key)).to eq("key=#{uuid}") }
+end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'shared/nested_attribute_examples'
 
 describe Granite::Form::Model::Associations::NestedAttributes do
   context '' do

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/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