granite-form 0.3.0 → 0.4.0

data/lib/granite/form/model.rb

@@ -5,7 +5,6 @@ require 'granite/form/model/scopes'
 require 'granite/form/model/primary'
 require 'granite/form/model/persistence'
 require 'granite/form/model/associations'
-require 'granite/form/model/localization'
 require 'granite/form/model/representation'
 require 'granite/form/model/dirty'
 
@@ -22,6 +21,7 @@ module Granite
         include ActiveModel::Serialization
         include ActiveModel::Serializers::JSON
 
+        include Util
         include Conventions
         include Attributes
         include Validations

data/lib/granite/form/types/active_support/time_zone.rb

@@ -5,6 +5,8 @@ module Granite
     module Types
       module ActiveSupport
         class TimeZone < Float
+        private
+
           def typecast(value)
             case value
             when ::ActiveSupport::TimeZone

data/lib/granite/form/types/array.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class Array < Object
+      private
+
         def typecast(value)
           if value.is_a?(::String)
             value.split(',').map(&:strip)

data/lib/granite/form/types/big_decimal.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class BigDecimal < Object
+      private
+
         def typecast(value)
           BigDecimal(Float(value).to_s) if value
         rescue ArgumentError, TypeError

data/lib/granite/form/types/boolean.rb

@@ -29,6 +29,8 @@ module Granite
           MAPPING[value]
         end
 
+      private
+
         def typecast(value)
           self.class.typecast(value)
         end

data/lib/granite/form/types/collection.rb

@@ -0,0 +1,11 @@
+module Granite
+  module Form
+    module Types
+      class Collection < HasSubtype
+        def prepare(value)
+          ::Array.wrap(value).map { |v| subtype_definition.prepare(v) }
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/types/date.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class Date < Object
+      private
+
         def typecast(value)
           value.try(:to_date)
         rescue ArgumentError

data/lib/granite/form/types/date_time.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class DateTime < Object
+      private
+
         def typecast(value)
           value.try(:to_datetime)
         rescue ArgumentError

data/lib/granite/form/types/dictionary.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Granite
+  module Form
+    module Types
+      class Dictionary < HasSubtype
+        def prepare(value)
+          value = to_hash(value)
+          value = value.stringify_keys.slice(*reflection.keys) if reflection.keys.present?
+          value.transform_values { |v| subtype_definition.prepare(v) }.with_indifferent_access
+        end
+
+      private
+
+        def to_hash(value)
+          Hash[value]
+        rescue ArgumentError
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/types/float.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class Float < Object
+      private
+
         def typecast(value)
           Float(value)
         rescue ArgumentError, TypeError

data/lib/granite/form/types/has_subtype.rb

@@ -0,0 +1,18 @@
+module Granite
+  module Form
+    module Types
+      class HasSubtype
+        attr_reader :subtype_definition
+        delegate :reflection, :owner, :type, :name, :enum, to: :subtype_definition
+
+        def initialize(subtype_definition)
+          @subtype_definition = subtype_definition
+        end
+
+        def build_duplicate(*args)
+          self.class.new(subtype_definition.build_duplicate(*args))
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/types/hash_with_action_controller_parameters.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class HashWithActionControllerParameters < Object
+      private
+
         def typecast(value)
           case value
           when ActionController::Parameters

data/lib/granite/form/types/integer.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class Integer < Float
+      private
+
         def typecast(value)
           super.try(:to_i)
         end

data/lib/granite/form/types/object.rb

@@ -13,6 +13,29 @@ module Granite
           @owner = owner
         end
 
+        def build_duplicate(reflection, owner)
+          self.class.new(type, reflection, owner)
+        end
+
+        def prepare(value)
+          enumerize(ensure_type(value))
+        end
+
+        def enum
+          source = owner.evaluate(reflection.enum)
+
+          case source
+          when ::Range
+            source.to_a
+          when ::Set
+            source
+          else
+            ::Array.wrap(source)
+          end.to_set
+        end
+
+      private
+
         def ensure_type(value)
           if value.instance_of?(type)
             value
@@ -24,6 +47,11 @@ module Granite
         def typecast(value)
           value if value.is_a?(type)
         end
+
+        def enumerize(value)
+          set = enum if reflection.enum
+          value if !set || (set.none? || set.include?(value))
+        end
       end
     end
   end

data/lib/granite/form/types/string.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class String < Object
+      private
+
         def typecast(value)
           value.to_s
         end

data/lib/granite/form/types/time.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class Time < Object
+      private
+
         def typecast(value)
           value.is_a?(::String) && ::Time.zone ? ::Time.zone.parse(value) : value.try(:to_time)
         rescue ArgumentError

data/lib/granite/form/types/uuid.rb

@@ -4,6 +4,8 @@ module Granite
   module Form
     module Types
       class UUID < Object
+      private
+
         def typecast(value)
           case value
           when UUIDTools::UUID

data/lib/granite/form/types.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'granite/form/types/has_subtype'
 require 'granite/form/types/object'
 require 'granite/form/types/array'
 require 'granite/form/types/big_decimal'
 require 'granite/form/types/boolean'
+require 'granite/form/types/collection'
 require 'granite/form/types/date'
 require 'granite/form/types/date_time'
+require 'granite/form/types/dictionary'
 require 'granite/form/types/hash_with_action_controller_parameters'
 require 'granite/form/types/float'
 require 'granite/form/types/integer'

data/lib/granite/form/util.rb

@@ -0,0 +1,55 @@
+module Granite
+  module Form
+    module Util
+      extend ActiveSupport::Concern
+
+      # Evaluates value and returns result based on what was passed:
+      # - if Proc was passed, then executes it in context of self
+      # - if Symbol was passed, then calls a method with that name and returns result
+      # - otherwise just returns the value itself
+      # @param value [Object] value to evaluate
+      # @return [Object] result of evaluation
+      def evaluate(value, *args)
+        value.is_a?(Symbol) ? evaluate_symbol(value, *args) : evaluate_if_proc(value, *args)
+      end
+
+      # Evaluates value and returns result based on what was passed:
+      # - if Proc was passed, then executes it in context of self
+      # - otherwise just returns the value itself
+      # @param value [Object] value to evaluate
+      # @return [Object] result of evaluation
+      def evaluate_if_proc(value, *args)
+        value.is_a?(Proc) ? evaluate_proc(value, *args) : value
+      end
+
+      # Evaluates `if` or `unless` conditions present in the supplied
+      # `options` being it a symbol or callable.
+      #
+      # @param [Hash] options The method options to evaluate.
+      # @option options :if method name or callable
+      # @option options :unless method name or callable
+      # @return [Boolean] whether conditions are satisfied
+      def conditions_satisfied?(**options)
+        raise ArgumentError, 'You cannot specify both if and unless' if options.key?(:if) && options.key?(:unless)
+
+        if options.key?(:if)
+          evaluate(options[:if])
+        elsif options.key?(:unless)
+          !evaluate(options[:unless])
+        else
+          true
+        end
+      end
+
+    private
+
+      def evaluate_proc(value, *args)
+        instance_exec(*args, &value)
+      end
+
+      def evaluate_symbol(value, *args)
+        __send__(value, *args)
+      end
+    end
+  end
+end

data/lib/granite/form/version.rb

@@ -1,5 +1,5 @@
 module Granite
   module Form
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/granite/form.rb

@@ -8,6 +8,7 @@ require 'singleton'
 require 'active_model'
 
 require 'granite/form/version'
+require 'granite/form/util'
 require 'granite/form/errors'
 require 'granite/form/extensions'
 require 'granite/form/undefined_class'

data/spec/granite/form/model/associations/references_many_spec.rb

@@ -34,7 +34,7 @@ describe Granite::Form::Model::Associations::ReferencesMany do
 
   describe 'book#inspect' do
     specify { expect(existing_book.inspect).to eq(<<~STR.chomp) }
-      #<Book authors: #<ReferencesMany [#{author.inspect}]>, title: "Genesis", author_ids: [#{author.id}]>
+      #<Book authors: #<ReferencesMany #{[author].inspect.truncate(50, omission: '...]')}>, title: "Genesis", author_ids: [#{author.id}]>
     STR
   end
 

data/spec/granite/form/model/associations/references_one_spec.rb

@@ -30,7 +30,7 @@ describe Granite::Form::Model::Associations::ReferencesOne do
 
   describe 'book#inspect' do
     specify { expect(existing_book.inspect).to eq(<<~STR.chomp) }
-      #<Book author: #<ReferencesOne #{author.inspect}>, title: "My Life", author_id: #{author.id}>
+      #<Book author: #<ReferencesOne #{author.inspect.truncate(50)}>, title: "My Life", author_id: #{author.id}>
     STR
   end
 
@@ -127,7 +127,7 @@ describe Granite::Form::Model::Associations::ReferencesOne do
       end
       specify do
         expect { association.writer(new_author) }
-          .to change { association.reader.try(:attributes) }.from(nil).to('id' => new_author.id, 'name' => 'Morty')
+          .to change { association.reader }.from(nil).to(new_author)
       end
       specify do
         expect { association.writer(new_author) }
@@ -160,8 +160,8 @@ describe Granite::Form::Model::Associations::ReferencesOne do
       end
       specify do
         expect { existing_association.writer(new_author) }
-          .to change { existing_association.reader.try(:attributes) }
-          .from('id' => author.id, 'name' => 'Johny').to('id' => new_author.id, 'name' => 'Morty')
+          .to change { existing_association.reader }
+          .from(author).to(new_author)
       end
       specify do
         expect { existing_association.writer(new_author) }

data/spec/granite/form/model/attributes/attribute_spec.rb

@@ -46,8 +46,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(attribute.default).to eq(nil) }
     specify { expect(attribute(default: 'hello').default).to eq('hello') }
     specify { expect(attribute(default: -> { value }).default).to eq(42) }
-    specify { expect(attribute(default: ->(object) { object.value }).default).to eq(42) }
-    specify { expect(attribute(default: ->(*args) { args.first.value }).default).to eq(42) }
   end
 
   describe '#defaultize' do
@@ -57,31 +55,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(attribute(default: false, type: Boolean).defaultize(nil)).to eq(false) }
   end
 
-  describe '#enum' do
-    before { allow_any_instance_of(Dummy).to receive_messages(value: 1..5) }
-
-    specify { expect(attribute.enum).to eq([].to_set) }
-    specify { expect(attribute(enum: []).enum).to eq([].to_set) }
-    specify { expect(attribute(enum: 'hello').enum).to eq(['hello'].to_set) }
-    specify { expect(attribute(enum: %w[hello world]).enum).to eq(%w[hello world].to_set) }
-    specify { expect(attribute(enum: [1..5]).enum).to eq([1..5].to_set) }
-    specify { expect(attribute(enum: 1..5).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: -> { 1..5 }).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: -> { 'hello' }).enum).to eq(['hello'].to_set) }
-    specify { expect(attribute(enum: -> { ['hello', 42] }).enum).to eq(['hello', 42].to_set) }
-    specify { expect(attribute(enum: -> { value }).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: ->(object) { object.value }).enum).to eq((1..5).to_a.to_set) }
-  end
-
-  describe '#enumerize' do
-    specify { expect(attribute.enumerize('anything')).to eq('anything') }
-    specify { expect(attribute(enum: ['hello', 42]).enumerize('hello')).to eq('hello') }
-    specify { expect(attribute(enum: ['hello', 42]).enumerize('world')).to eq(nil) }
-    specify { expect(attribute(enum: -> { 'hello' }).enumerize('hello')).to eq('hello') }
-    specify { expect(attribute(enum: -> { 1..5 }).enumerize(2)).to eq(2) }
-    specify { expect(attribute(enum: -> { 1..5 }).enumerize(42)).to eq(nil) }
-  end
-
   describe '#normalize' do
     specify { expect(attribute.normalize(' hello ')).to eq(' hello ') }
     specify { expect(attribute(normalizer: ->(v) { v.strip }).normalize(' hello ')).to eq('hello') }
@@ -93,8 +66,6 @@ describe Granite::Form::Model::Attributes::Attribute do
       let(:other) { 'other' }
 
       specify { expect(attribute(normalizer: ->(_v) { value }).normalize(' hello ')).to eq('value') }
-      specify { expect(attribute(normalizer: ->(_v, object) { object.value }).normalize(' hello ')).to eq('value') }
-      specify { expect(attribute(normalizer: ->(_v, _object) { other }).normalize(' hello ')).to eq('other') }
     end
 
     context 'integration' do

data/spec/granite/form/model/attributes/reflections/attribute_spec.rb

@@ -43,15 +43,6 @@ describe Granite::Form::Model::Attributes::Reflections::Attribute do
     specify { expect(reflection(default: -> {}).defaultizer).to be_a Proc }
   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 }

data/spec/granite/form/model/attributes/reflections/base/build_type_definition_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Base::BuildTypeDefinition do
+  def build_type_definition(**options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Base.new(:field, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_type(type)
+    have_attributes(type: type, reflection: @reflection, owner: owner)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  specify { expect { build_type_definition }.to raise_error('Type is not specified for `field`') }
+  specify { expect(build_type_definition(type: String)).to have_type(String) }
+  specify { expect(build_type_definition(type: :string)).to have_type(String) }
+  specify { expect(build_type_definition(type: Dummy)).to have_type(Dummy) }
+  specify { expect { build_type_definition(type: :blabla) }.to raise_error NameError }
+end

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

@@ -30,6 +30,8 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
   end
 
   describe '#build_attribute' do
+    subject { reflection.build_attribute(owner, nil) }
+
     before do
       stub_class('SomeScope::Borogoves', described_class)
       stub_class('Granite::Form::Model::Attributes::Borogoves', Granite::Form::Model::Attributes::Base)
@@ -39,18 +41,22 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
     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) }
-    specify { expect(reflection.build_attribute(owner, nil).name).to eq('field') }
-    specify { expect(reflection.build_attribute(owner, nil).owner).to eq(owner) }
+    it { is_expected.to be_a(Granite::Form::Model::Attributes::Borogoves) }
+    it { is_expected.to have_attributes(reflection: reflection, owner: owner, type: Object) }
   end
 
-  describe '#type' do
-    before { stub_class(:dummy, String) }
+  describe '#enum' do
+    specify { expect(reflection.enum).to be_nil }
+    specify { expect(reflection(enum: 42).enum).to eq(42) }
+    specify { expect(reflection(enum: -> {}).enum).to be_a Proc }
+    specify { expect(reflection(in: 42).enum).to eq(42) }
+    specify { expect(reflection(in: -> {}).enum).to be_a Proc }
+    specify { expect(reflection(enum: 42, in: -> {}).enum).to eq(42) }
+  end
 
-    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 }
+  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/granite/form/model/attributes/reflections/collection/build_type_definition_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Collection::BuildTypeDefinition do
+  def build_type_definition(name = :name, **options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Collection.new(name, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_collection_type(type)
+    subtype_definition = have_attributes(type: type, reflection: @reflection, owner: owner)
+    have_attributes(subtype_definition: subtype_definition)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  it { expect(build_type_definition(type: String)).to have_collection_type(String) }
+end

data/spec/granite/form/model/attributes/reflections/dictionary/build_type_definition_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Dictionary::BuildTypeDefinition do
+  def build_type_definition(name = :name, **options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Dictionary.new(name, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_dictionary_type(type)
+    subtype_definition = have_attributes(type: type, reflection: @reflection, owner: owner)
+    have_attributes(subtype_definition: subtype_definition)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  it { expect(build_type_definition(type: String)).to have_dictionary_type(String) }
+end

data/spec/granite/form/model/attributes/reflections/dictionary_spec.rb

@@ -34,10 +34,4 @@ describe Granite::Form::Model::Attributes::Reflections::Dictionary do
       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