granite-form 0.3.0 → 0.5.0

data/lib/granite/form/model/attributes/dictionary.rb

@@ -1,28 +0,0 @@
-module Granite
-  module Form
-    module Model
-      module Attributes
-        class Dictionary < Attribute
-          delegate :keys, to: :reflection
-
-          def read
-            @value ||= begin
-                         hash = read_before_type_cast
-                         hash = hash.stringify_keys.slice(*keys) if keys.present?
-
-                         normalize(Hash[hash.map do |key, value|
-                           [key, enumerize(type_definition.ensure_type(value))]
-                         end].with_indifferent_access).with_indifferent_access
-                       end
-          end
-
-          def read_before_type_cast
-            @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |key, value|
-              [key, defaultize(value)]
-            end].with_indifferent_access
-          end
-        end
-      end
-    end
-  end
-end

data/lib/granite/form/model/attributes/localized.rb

@@ -1,44 +0,0 @@
-module Granite
-  module Form
-    module Model
-      module Attributes
-        class Localized < Attribute
-          def read
-            @value ||= Hash[read_before_type_cast.map do |locale, value|
-              [locale.to_s, normalize(enumerize(type_definition.ensure_type(value)))]
-            end]
-          end
-
-          def read_before_type_cast
-            @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |locale, value|
-              [locale.to_s, defaultize(value)]
-            end]
-          end
-
-          def write_locale(value, locale)
-            pollute do
-              write(read.merge(locale.to_s => value))
-            end
-          end
-
-          def read_locale(locale)
-            read[owner.class.fallbacks(locale).detect do |fallback|
-              read[fallback.to_s]
-            end.to_s]
-          end
-
-          def read_locale_before_type_cast(locale)
-            read_before_type_cast[owner.class.fallbacks(locale).detect do |fallback|
-              read_before_type_cast[fallback.to_s]
-            end.to_s]
-          end
-
-          def locale_query(locale)
-            value = read_locale(locale)
-            !(value.respond_to?(:zero?) ? value.zero? : value.blank?)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/granite/form/model/attributes/reflections/localized.rb

@@ -1,45 +0,0 @@
-module Granite
-  module Form
-    module Model
-      module Attributes
-        module Reflections
-          class Localized < Attribute
-            def self.build(target, generated_methods, name, *args, &block)
-              attribute = super(target, generated_methods, name, *args, &block)
-              generate_methods name, generated_methods
-              attribute
-            end
-
-            def self.generate_methods(name, target)
-              target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}_translations
-                attribute('#{name}').read
-              end
-
-              def #{name}_translations= value
-                attribute('#{name}').write(value)
-              end
-
-              def #{name}
-                attribute('#{name}').read_locale(self.class.locale)
-              end
-
-              def #{name}= value
-                attribute('#{name}').write_locale(value, self.class.locale)
-              end
-
-              def #{name}?
-                attribute('#{name}').locale_query(self.class.locale)
-              end
-
-              def #{name}_before_type_cast
-                attribute('#{name}').read_locale_before_type_cast(self.class.locale)
-              end
-              RUBY
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/granite/form/model/localization.rb

@@ -1,26 +0,0 @@
-require 'granite/form/model/attributes/reflections/localized'
-require 'granite/form/model/attributes/localized'
-
-module Granite
-  module Form
-    module Model
-      module Localization
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def localized(*args, &block)
-            add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, *args, &block)
-          end
-
-          def fallbacks(locale)
-            ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
-          end
-
-          def locale
-            I18n.locale
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Collection do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Collection, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
-    specify { expect(field.tap { |r| r.write([nil]) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
-    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([43, 44]) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write(['']) }.read).to eq([nil]) }
-    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read).to eq(%w[hello 42]) }
-    specify { expect(field.tap { |r| r.write(['hello', false]) }.read).to eq(['hello', nil]) }
-
-    context do
-      let(:field) { attribute(type: String, normalizer: ->(v) { v.uniq }, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
-      specify { expect(field.tap { |r| r.write([nil, nil]) }.read).to eq(['world']) }
-      specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
-      specify { expect(field.tap { |r| r.write([42]) }.read).to eq(['42']) }
-      specify { expect(field.tap { |r| r.write(['']) }.read).to eq(['']) }
-    end
-  end
-
-  describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
-    specify { expect(field.tap { |r| r.write([nil]) }.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([43, 44]) }.read_before_type_cast).to eq([43, 44]) }
-    specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
-    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read_before_type_cast).to eq(['hello', 42]) }
-    specify { expect(field.tap { |r| r.write(['hello', false]) }.read_before_type_cast).to eq(['hello', false]) }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
-      specify { expect(field.tap { |r| r.write([nil, nil]) }.read_before_type_cast).to eq(%i[world 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(['']) }.read_before_type_cast).to eq(['']) }
-    end
-  end
-
-  context 'integration' do
-    before do
-      stub_model(:post) do
-        collection :tags, String
-      end
-    end
-
-    specify { expect(Post.new(tags: ['hello', 42]).tags).to eq(%w[hello 42]) }
-    specify { expect(Post.new(tags: ['hello', 42]).tags_before_type_cast).to eq(['hello', 42]) }
-    specify { expect(Post.new.tags?).to eq(false) }
-    specify { expect(Post.new(tags: ['hello', 42]).tags?).to eq(true) }
-  end
-end

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

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Dictionary do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Dictionary, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) do
-      attribute(type: String,
-      normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
-      default: :world, enum: %w[hello 42])
-    end
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: '') }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 42) }.read).to eq('a' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read).to eq('a' => 'hello') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read).to eq('a' => 'hello', 'x' => '42') }
-
-    context do
-      let(:field) do
-        attribute(type: String,
-        normalizer: ->(val) { val.delete_if { |_, v| v.nil? } },
-        default: :world)
-      end
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1) }.read).to eq('a' => '1') }
-      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read).to eq('a' => 'world', 'b' => 'world') }
-      specify { expect(field.tap { |r| r.write(a: '') }.read).to eq('a' => '') }
-    end
-
-    context 'with :keys' do
-      let(:field) { attribute(type: String, keys: ['a', :b]) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read).to eq('a' => '1', 'b' => '2') }
-      specify { expect(field.tap { |r| r.write(a: 1, c: 3, 'd' => 4) }.read).to eq('a' => '1') }
-    end
-  end
-
-  describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
-    specify { expect(field.tap { |r| r.write(a: nil) }.read_before_type_cast).to eq('a' => :world) }
-    specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
-    specify { expect(field.tap { |r| r.write(a: 42) }.read_before_type_cast).to eq('a' => 42) }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '42') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', b: '1') }.read_before_type_cast).to eq('a' => 'hello', 'b' => '1') }
-    specify { expect(field.tap { |r| r.write(a: 'hello', x: '42') }.read_before_type_cast).to eq('a' => 'hello', 'x' => '42') }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write(a: 1) }.read_before_type_cast).to eq('a' => 1) }
-      specify { expect(field.tap { |r| r.write(a: nil, b: nil) }.read_before_type_cast).to eq('a' => :world, 'b' => :world) }
-      specify { expect(field.tap { |r| r.write(a: '') }.read_before_type_cast).to eq('a' => '') }
-    end
-
-    context 'with :keys' do
-      let(:field) { attribute(type: String, keys: ['a', :b]) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
-      specify do
-        expect(field.tap { |r| r.write(a: 1, 'b' => 2, c: 3, 'd' => 4) }.read_before_type_cast)
-          .to eq('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4)
-      end
-    end
-  end
-
-  context 'integration' do
-    before do
-      stub_model(:post) do
-        dictionary :options, type: String
-      end
-    end
-
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options).to eq('a' => 'hello', 'b' => '42') }
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options_before_type_cast).to eq('a' => 'hello', 'b' => 42) }
-    specify { expect(Post.new.options?).to eq(false) }
-    specify { expect(Post.new(options: {a: 'hello', b: 42}).options?).to eq(true) }
-  end
-end

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

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe Granite::Form::Model::Attributes::Localized do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, :field, options)
-    Dummy.new.attribute(:field)
-  end
-
-  describe '#read' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-    specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
-    specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
-    specify { expect(field.tap { |r| r.write(en: 43) }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => nil) }
-    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read).to eq('en' => 'hello', 'ru' => '42') }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
-      specify { expect(field.tap { |r| r.write(en: 'hello') }.read).to eq('en' => 'hello') }
-      specify { expect(field.tap { |r| r.write(en: 42) }.read).to eq('en' => '42') }
-      specify { expect(field.tap { |r| r.write(en: '') }.read).to eq('en' => '') }
-      specify { expect(field.tap { |r| r.write(en: nil) }.read).to eq('en' => 'world') }
-    end
-  end
-
-  describe '#read_before_type_cast' do
-    let(:field) { attribute(type: String, default: :world, enum: %w[hello 42]) }
-
-    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-    specify { expect(field.tap { |r| r.write(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
-    specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
-    specify { expect(field.tap { |r| r.write(en: 43) }.read_before_type_cast).to eq('en' => 43) }
-    specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
-    specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
-    specify { expect(field.tap { |r| r.write(en: 'hello', ru: 42) }.read_before_type_cast).to eq('en' => 'hello', 'ru' => 42) }
-
-    context do
-      let(:field) { attribute(type: String, default: :world) }
-
-      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
-      specify { expect(field.tap { |r| r.write(en: 'hello') }.read_before_type_cast).to eq('en' => 'hello') }
-      specify { expect(field.tap { |r| r.write(en: 42) }.read_before_type_cast).to eq('en' => 42) }
-      specify { expect(field.tap { |r| r.write(en: '') }.read_before_type_cast).to eq('en' => '') }
-      specify { expect(field.tap { |r| r.write(en: nil) }.read_before_type_cast).to eq('en' => :world) }
-    end
-  end
-
-  context 'integration' do
-    let(:klass) do
-      Class.new do
-        include Granite::Form::Model
-        include Granite::Form::Model::Localization
-
-        localized :name, type: String
-      end
-    end
-    let(:translations) { {en: 'Hello', ru: 'Привет'} }
-    before { I18n.locale = :en }
-
-    describe '#name_translations' do
-      subject { klass.new name_translations: translations }
-      its(:name_translations) { should == translations.stringify_keys }
-      its(:name) { should == translations[:en] }
-    end
-
-    describe '#name' do
-      subject { klass.new name: 'Hello' }
-      its(:name_translations) { should == {'en' => 'Hello'} }
-      its(:name) { should == 'Hello' }
-    end
-
-    describe '#name_before_type_cast' do
-      let(:object) { Object.new }
-      subject { klass.new name: object }
-      its(:name_before_type_cast) { should == object }
-    end
-
-    context 'fallbacks' do
-      subject { klass.new name_translations: {ru: 'Привет'} }
-      context do
-        its(:name) { should be_nil }
-      end
-
-      context do
-        before do
-          require 'i18n/backend/fallbacks'
-          I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-          I18n.fallbacks[:en] = [:ru]
-        end
-        after { I18n.fallbacks = false }
-        its(:name) { should == 'Привет' }
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-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