normalizy 0.2.0 → 1.0.0

data/spec/normalizy/extensions/model_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe '#apply_normalizy' do
+  context 'when object has no normalizy' do
+    specify do
+      expect(Model.create(none: '  Botelho  ').none).to eq '  Botelho  '
+    end
+  end
+
+  context 'when object has normalizy' do
+    specify do
+      Normalizy.configure do |config|
+        config.default_filters = [:squish]
+      end
+
+      expect(Model.create(default: '  Botelho  ').default).to eq 'Botelho'
+    end
+
+    specify do
+      expect(Model.create(block: 'Botelho').block).to eq 'BOTELHO'
+    end
+  end
+
+  context 'when a filter is given' do
+    specify do
+      expect(Model.create(symbol: '  Bote  lho  ').symbol).to eq 'Bote lho'
+    end
+
+    specify do
+      expect(Model.create(array_symbol: '  Bote  lho  ').array_symbol).to eq 'Bote lho'
+    end
+
+    specify do
+      expect(Model.create(array_symbols: '  Bote  lho  ').array_symbols).to eq 'bote lho'
+    end
+
+    specify do
+      expect(Model.create(hash_no_args: '  Bote  lho  ').hash_no_args).to eq 'Bote lho'
+    end
+
+    specify do
+      expect(Model.create(hash_with_args: '  Botelho  ').hash_with_args).to eq 'Botelho  '
+    end
+
+    specify do
+      expect(Model.create(module_one_arg: 'Fuck').module_one_arg).to eq 'filtered'
+    end
+
+    specify do
+      expect(Model.create(module_two_args: 'Botelho').module_two_args).to eq 'module_two_args, Botelho, Model'
+    end
+
+    specify do
+      Normalizy.configure do |config|
+        config.add :blacklist, Normalizy::Filters::Block
+      end
+
+      expect(Model.create(module_and_block: 'Botelho').module_and_block).to eq 'BOTELHO'
+    end
+
+    specify do
+      expect(Model.create(method_with_no_options_field: 'Botelho').method_with_no_options_field).to eq 'Botelho'
+    end
+
+    specify do
+      expect(Model.create(method_with_options_field: 'Botelho').method_with_options_field).to eq [
+        'Botelho',
+        {
+          key:       :value,
+          attribute: :method_with_options_field,
+          object:    Model.new
+        }
+      ].join ', '
+    end
+
+    specify do
+      expect(Model.create(native: 'Botelho').native).to eq '["Botelho"]'
+    end
+
+    specify do
+      expect(Model.create(multiple: 'BoteLho').multiple).to eq 'bote lho'
+    end
+  end
+
+  context 'when assign is made via set' do
+    context 'with no save' do
+      specify do
+        object        = Model.new
+        object.symbol = '  Bote  lho  '
+
+        expect(object.symbol).to eq 'Bote lho'
+      end
+    end
+
+    context 'with save' do
+      specify do
+        object        = Model.new
+        object.symbol = '  Bote  lho  '
+        object.save
+
+        expect(object.symbol).to eq 'Bote lho'
+      end
+    end
+  end
+end

data/spec/normalizy/extensions/normalizy_rules_spec.rb

@@ -3,7 +3,7 @@
 require 'rails_helper'
 
 RSpec.describe Normalizy::Extension, ':normalizy_rules' do
-  let!(:model) { User }
+  let!(:model) { Rule }
 
   before { model.normalizy_rules = {} }
 
@@ -14,111 +14,87 @@ RSpec.describe Normalizy::Extension, ':normalizy_rules' do
       end
     end
 
-    context 'with one field' do
-      context 'with no rules' do
-        before { model.normalizy :name }
+    specify do
+      model.normalizy :name
 
-        it 'appends default' do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :squish }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: nil }])
+    end
 
-      context 'with one rule' do
-        before { model.normalizy :name, with: :upcase }
+    specify do
+      model.normalizy :name, with: :upcase
 
-        specify do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
+    end
 
-      context 'with multiple rules' do
-        before { model.normalizy :name, with: [:upcase, 'blank', { trim: { side: :left } }] }
+    specify do
+      model.normalizy :name, with: [:upcase, 'blank', { trim: { side: :left } }]
 
-        specify do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: [:upcase, 'blank', { trim: { side: :left } }] }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: [:upcase, 'blank', { trim: { side: :left } }] }])
+    end
 
-      context 'with multiple normalizes including repeated rules' do
-        before do
-          model.normalizy :name, with: [:upcase, { trim: { side: :left } }]
-          model.normalizy :name, with: :squish
-          model.normalizy :name, with: [:upcase, { trim: { side: :right } }]
-          model.normalizy :name, with: :squish
-        end
-
-        it 'includes all' do
-          expect(model.normalizy_rules).to eq(
-            name: [
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
-              { block: nil, options: {}, rules: :squish }
-            ]
-          )
-        end
-      end
+    specify do
+      model.normalizy :name, with: [:upcase, { trim: { side: :left } }]
+      model.normalizy :name, with: :squish
+      model.normalizy :name, with: [:upcase, { trim: { side: :right } }]
+      model.normalizy :name, with: :squish
+
+      expect(model.normalizy_rules).to eq(
+        name: [
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
+          { block: nil, options: {}, rules: :squish }
+        ]
+      )
     end
 
-    context 'with multiple fields' do
-      context 'with no rule' do
-        before { model.normalizy :email, :name }
+    specify do
+      model.normalizy :email, :name
 
-        it 'appends default' do
-          expect(model.normalizy_rules).to eq(
-            email: [{ block: nil, options: {}, rules: :squish }],
-            name:  [{ block: nil, options: {}, rules: :squish }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        email: [{ block: nil, options: {}, rules: nil }],
+        name:  [{ block: nil, options: {}, rules: nil }]
+      )
+    end
 
-      context 'with one rule' do
-        before { model.normalizy :email, :name, with: :upcase }
+    specify do
+      model.normalizy :email, :name, with: :upcase
 
-        specify do
-          expect(model.normalizy_rules).to eq(
-            name:  [{ block: nil, options: {}, rules: :upcase }],
-            email: [{ block: nil, options: {}, rules: :upcase }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        name:  [{ block: nil, options: {}, rules: :upcase }],
+        email: [{ block: nil, options: {}, rules: :upcase }]
+      )
+    end
 
-      context 'with multiple rules' do
-        before { model.normalizy :email, :name, with: [:upcase, :blank, { trim: { side: :left } }] }
+    specify do
+      model.normalizy :email, :name, with: [:upcase, :blank, { trim: { side: :left } }]
 
-        specify do
-          expect(model.normalizy_rules).to eq(
-            email: [{ block: nil, options: {}, rules: [:upcase, :blank, { trim: { side: :left } }] }],
-            name:  [{ block: nil, options: {}, rules: [:upcase, :blank, { trim: { side: :left } }] }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        email: [{ block: nil, options: {}, rules: [:upcase, :blank, { trim: { side: :left } }] }],
+        name:  [{ block: nil, options: {}, rules: [:upcase, :blank, { trim: { side: :left } }] }]
+      )
+    end
 
-      context 'with multiple normalizes including repeated rules' do
-        before do
-          model.normalizy :email, :name, with: [:upcase, { trim: { side: :left } }]
-          model.normalizy :email, :name, with: :squish
-          model.normalizy :email, :name, with: [:upcase, { trim: { side: :right } }]
-          model.normalizy :email, :name, with: :squish
-        end
-
-        it 'merges all as unique with the last one having priority in deep levels too' do
-          expect(model.normalizy_rules).to eq(
-            email: [
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
-              { block: nil, options: {}, rules: :squish }
-            ],
-            name:  [
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
-              { block: nil, options: {}, rules: :squish }
-            ]
-          )
-        end
-      end
+    specify do
+      model.normalizy :email, :name, with: [:upcase, { trim: { side: :left } }]
+      model.normalizy :email, :name, with: :squish
+      model.normalizy :email, :name, with: [:upcase, { trim: { side: :right } }]
+      model.normalizy :email, :name, with: :squish
+
+      expect(model.normalizy_rules).to eq(
+        email: [
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
+          { block: nil, options: {}, rules: :squish }
+        ],
+        name:  [
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :left } }] },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: [:upcase, { trim: { side: :right } }] },
+          { block: nil, options: {}, rules: :squish }
+        ]
+      )
     end
   end
 
@@ -129,115 +105,91 @@ RSpec.describe Normalizy::Extension, ':normalizy_rules' do
       end
     end
 
-    context 'with one field' do
-      context 'with no rules' do
-        before { model.normalizy :name }
+    specify do
+      model.normalizy :name
 
-        specify do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: [] }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: nil }])
+    end
 
-      context 'with one rule' do
-        before { model.normalizy :name, with: :upcase }
+    specify do
+      model.normalizy :name, with: :upcase
 
-        specify do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
+    end
 
-      context 'with multiple rules' do
-        before { model.normalizy :name, with: %i[upcase blank] }
+    specify do
+      model.normalizy :name, with: %i[upcase blank]
 
-        specify do
-          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: %i[upcase blank] }])
-        end
-      end
+      expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: %i[upcase blank] }])
+    end
 
-      context 'with multiple normalizes including repeated rules' do
-        before do
-          model.normalizy :name, with: :upcase
-          model.normalizy :name, with: :squish
-          model.normalizy :name, with: :upcase
-        end
-
-        it 'merges all as unique' do
-          expect(model.normalizy_rules).to eq(
-            name: [
-              { block: nil, options: {}, rules: :upcase },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: :upcase }
-            ]
-          )
-        end
-      end
+    specify do
+      model.normalizy :name, with: :upcase
+      model.normalizy :name, with: :squish
+      model.normalizy :name, with: :upcase
+
+      expect(model.normalizy_rules).to eq(
+        name: [
+          { block: nil, options: {}, rules: :upcase },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: :upcase }
+        ]
+      )
     end
 
-    context 'with multiple fields' do
-      context 'with no rule' do
-        before { model.normalizy :email, :name }
+    specify do
+      model.normalizy :email, :name
 
-        specify do
-          expect(model.normalizy_rules).to eq(
-            email: [{ block: nil, options: {}, rules: [] }],
-            name:  [{ block: nil, options: {}, rules: [] }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        email: [{ block: nil, options: {}, rules: nil }],
+        name:  [{ block: nil, options: {}, rules: nil }]
+      )
+    end
 
-      context 'with one rule' do
-        before { model.normalizy :email, :name, with: :upcase }
+    specify do
+      model.normalizy :email, :name, with: :upcase
 
-        specify do
-          expect(model.normalizy_rules).to eq(
-            email: [{ block: nil, options: {}, rules: :upcase }],
-            name:  [{ block: nil, options: {}, rules: :upcase }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        email: [{ block: nil, options: {}, rules: :upcase }],
+        name:  [{ block: nil, options: {}, rules: :upcase }]
+      )
+    end
 
-      context 'with multiple rules' do
-        before { model.normalizy :email, :name, with: %i[upcase blank] }
+    specify do
+      model.normalizy :email, :name, with: %i[upcase blank]
 
-        specify do
-          expect(model.normalizy_rules).to eq(
-            email: [{ block: nil, options: {}, rules: %i[upcase blank] }],
-            name:  [{ block: nil, options: {}, rules: %i[upcase blank] }]
-          )
-        end
-      end
+      expect(model.normalizy_rules).to eq(
+        email: [{ block: nil, options: {}, rules: %i[upcase blank] }],
+        name:  [{ block: nil, options: {}, rules: %i[upcase blank] }]
+      )
+    end
 
-      context 'with multiple normalizes including repeated rules' do
-        before do
-          model.normalizy :email, :name, with: :upcase
-          model.normalizy :email, :name, with: :squish
-          model.normalizy :email, :name, with: :upcase
-        end
-
-        it 'merges all as unique' do
-          expect(model.normalizy_rules).to eq(
-            email: [
-              { block: nil, options: {}, rules: :upcase },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: :upcase }
-            ],
-            name:  [
-              { block: nil, options: {}, rules: :upcase },
-              { block: nil, options: {}, rules: :squish },
-              { block: nil, options: {}, rules: :upcase }
-            ]
-          )
-        end
-      end
+    specify do
+      model.normalizy :email, :name, with: :upcase
+      model.normalizy :email, :name, with: :squish
+      model.normalizy :email, :name, with: :upcase
+
+      expect(model.normalizy_rules).to eq(
+        email: [
+          { block: nil, options: {}, rules: :upcase },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: :upcase }
+        ],
+        name:  [
+          { block: nil, options: {}, rules: :upcase },
+          { block: nil, options: {}, rules: :squish },
+          { block: nil, options: {}, rules: :upcase }
+        ]
+      )
     end
   end
 
   context 'when block is given' do
     let!(:block) { ->(value) { value.downcase } }
 
-    before { model.normalizy(:name, &block) }
-
     specify do
+      model.normalizy :name, &block
+
       expect(model.normalizy_rules[:name][0][:block]).to eq block
     end
   end

data/spec/normalizy/filters/date_spec.rb

@@ -21,15 +21,15 @@ RSpec.describe Normalizy::Filters::Date do
   end
 
   context 'with invalid date' do
-    let!(:object)  { User.new }
-    let!(:options) { { attribute: :birthday, object: object } }
+    let!(:object)  { ModelDate.new }
+    let!(:options) { { attribute: :date, object: object } }
 
     context 'with i18n present' do
       before do
-        allow(I18n).to receive(:t).with(:birthday,
-          scope:   ['normalizy.errors.date', 'user'],
+        allow(I18n).to receive(:t).with(:date,
+          scope:   ['normalizy.errors.date', 'model_date'],
           value:   '1984-10-00',
-          default: '%{value} is an invalid date.') { 'birthday.error' }
+          default: '%{value} is an invalid date.') { 'date.error' }
       end
 
       it 'writes an error on object and does not set the values' do
@@ -37,8 +37,8 @@ RSpec.describe Normalizy::Filters::Date do
 
         subject.call '1984-10-00', options
 
-        expect(object.errors[:birthday]).to eq ['birthday.error']
-        expect(object.birthday).to          eq nil
+        expect(object.errors[:date]).to eq ['date.error']
+        expect(object.date).to          eq nil
       end
     end
 
@@ -48,8 +48,8 @@ RSpec.describe Normalizy::Filters::Date do
 
         subject.call '1984-10-00', options
 
-        expect(object.errors[:birthday]).to eq ['1984-10-00 is an invalid date.']
-        expect(object.birthday).to          eq nil
+        expect(object.errors[:date]).to eq ['1984-10-00 is an invalid date.']
+        expect(object.date).to          eq nil
       end
     end
   end