normalizy 0.1.0

data/lib/normalizy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Normalizy
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end
+
+require 'active_record'
+require 'normalizy/config'
+require 'normalizy/extensions'
+require 'normalizy/rspec/matcher'
+
+ActiveRecord::Base.send :include, Normalizy::Extension

data/spec/normalizy/config/add_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, '#add' do
+  it 'adds filters to the built-in filters' do
+    Normalizy.configure do |config|
+      config.add :blacklist, :blacklist_filter
+    end
+
+    expect(Normalizy.config.filters).to eq(
+      blacklist: :blacklist_filter,
+      number:    Normalizy::Filters::Number,
+      strip:     Normalizy::Filters::Strip
+    )
+  end
+end

data/spec/normalizy/config/alias_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, '#alias' do
+  context 'with no raw type' do
+    let!(:object) { User.new name: 'Washington Botelho' }
+
+    before do
+      object.class.normalizy_rules = {}
+
+      Normalizy.configure do |config|
+        config.alias :email, :downcase
+      end
+    end
+
+    it 'alias one filter to others' do
+      object.class.normalizy :name, with: :email
+
+      object.save
+
+      expect(object.name).to eq 'washington botelho'
+    end
+  end
+
+  context 'with raw type' do
+    let!(:object) { User.new amount: 'R$ 4.200,00' }
+
+    before { object.class.normalizy_rules = {} }
+
+    context 'configured on setup' do
+      before do
+        Normalizy.configure do |config|
+          config.alias :money, :number, raw: true
+        end
+      end
+
+      it 'alias one filter to others' do
+        object.class.normalizy :amount, with: :money
+
+        object.save
+
+        expect(object.amount).to eq 420_000
+      end
+    end
+
+    context 'configured on normalizy' do
+      before do
+        Normalizy.configure do |config|
+          config.alias :money, :number
+        end
+      end
+
+      it 'alias one filter to others' do
+        object.class.normalizy :amount, with: :money, raw: true
+
+        object.save
+
+        expect(object.amount).to eq 420_000
+      end
+    end
+  end
+end

data/spec/normalizy/config/default_filters_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, 'default_filters' do
+  context 'when get' do
+    it 'returns the default filters' do
+      expect(subject.default_filters).to eq({})
+    end
+  end
+
+  context 'when set' do
+    before { subject.default_filters = :blank }
+
+    it 'keeps the original' do
+      expect(subject.default_filters).to eq :blank
+    end
+  end
+end

data/spec/normalizy/config/initialize_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, 'filters' do
+  it 'loads some filters' do
+    expect(subject.filters).to eq(
+      number: Normalizy::Filters::Number,
+      strip:  Normalizy::Filters::Strip
+    )
+  end
+end

data/spec/normalizy/config/normalizy_aliases_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, 'normalizy_aliases' do
+  it 'has the right defaults' do
+    expect(subject.normalizy_aliases).to eq({})
+  end
+end

data/spec/normalizy/config/normalizy_raws_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Config, 'normalizy_raws' do
+  it 'has the right defaults' do
+    expect(subject.normalizy_raws).to eq [:number]
+  end
+end

data/spec/normalizy/extensions/apply_normalizations_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe '#apply_normalizations' do
+  context 'when object has no normalizy' do
+    let!(:object) { Clean.create name: '  washington  Botelho  ' }
+
+    it 'does not normalize' do
+      expect(object.name).to eq '  washington  Botelho  '
+    end
+  end
+
+  context 'when object has normalizy' do
+    let!(:object) { User.new name: '  Washington  Fuck  Botelho  ' }
+
+    before { object.class.normalizy_rules = {} }
+
+    context 'when a rule is not given' do
+      context 'and no block' do
+        before do
+          Normalizy.configure do |config|
+            config.default_filters = :squish
+          end
+
+          object.class.normalizy :name
+        end
+
+        it 'uses the default' do
+          object.save
+
+          expect(object.name).to eq 'Washington Fuck Botelho'
+        end
+      end
+
+      context 'but block is' do
+        let!(:block) { ->(value) { value.upcase } }
+
+        before do
+          Normalizy.configure do |config|
+            config.add :blacklist, Normalizy::Filters::Blacklist
+          end
+        end
+
+        it 'executes the block' do
+          object.class.normalizy :name, with: block
+
+          object.save
+
+          expect(object.name).to eq '  WASHINGTON  FUCK  BOTELHO  '
+        end
+      end
+    end
+
+    context 'when a rule is given' do
+      context 'as symbol format' do
+        before { object.class.normalizy :name, with: :squish }
+
+        specify do
+          object.save
+
+          expect(object.name).to eq 'Washington Fuck Botelho'
+        end
+      end
+
+      context 'as array of symbol format' do
+        before { object.class.normalizy :name, with: [:squish] }
+
+        specify do
+          object.save
+
+          expect(object.name).to eq 'Washington Fuck Botelho'
+        end
+      end
+
+      context 'as a hash format' do
+        context 'and filter does not receives options' do
+          before { object.class.normalizy :name, with: { squish: :options } }
+
+          specify do
+            object.save
+
+            expect(object.name).to eq 'Washington Fuck Botelho'
+          end
+        end
+
+        context 'and filter receives options' do
+          before { object.class.normalizy :name, with: { strip: { side: :left } } }
+
+          specify do
+            object.save
+
+            expect(object.name).to eq 'Washington  Fuck  Botelho  '
+          end
+        end
+      end
+
+      context 'as a module' do
+        before { object.class.normalizy :name, with: Normalizy::Filters::Blacklist }
+
+        specify do
+          object.save
+
+          expect(object.name).to eq '  Washington  filtered  Botelho  '
+        end
+      end
+
+      context 'and block too' do
+        let!(:block) { ->(value) { value.upcase } }
+
+        before do
+          Normalizy.configure do |config|
+            config.add :blacklist, Normalizy::Filters::Blacklist
+          end
+        end
+
+        it 'runs after rules' do
+          object.class.normalizy :name, with: :blacklist, &block
+
+          object.save
+
+          expect(object.name).to eq '  WASHINGTON  FILTERED  BOTELHO  '
+        end
+      end
+    end
+
+    context 'when no filter match' do
+      context 'and object has a method that responds' do
+        context 'with no options on rule' do
+          it 'runs the native method with empty options' do
+            object.class.normalizy :name, with: :custom_reverse
+
+            object.save
+
+            expect(object.name).to eq '  ohletoB  kcuF  notgnihsaW  .{}.custom'
+          end
+        end
+
+        context 'with no options on rule' do
+          it 'runs the native method with given options' do
+            object.class.normalizy :name, with: { custom_reverse: :options }
+
+            object.save
+
+            expect(object.name).to eq '  ohletoB  kcuF  notgnihsaW  .options.custom'
+          end
+        end
+      end
+
+      context 'and attribute has not a method that responds' do
+        context 'but attribute has a native method like it' do
+          it 'runs the native method' do
+            object.class.normalizy :name, with: :split
+
+            object.save
+
+            expect(object.name).to eq %(["Washington", "Fuck", "Botelho"])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/normalizy/extensions/normalizy_rules_spec.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Extension, '#normalizy_rules' do
+  let!(:model) { User }
+
+  before { model.normalizy_rules = {} }
+
+  context 'with default' do
+    before do
+      Normalizy.configure do |config|
+        config.default_filters = :squish
+      end
+    end
+
+    context 'with one field' do
+      context 'with no rules' do
+        before { model.normalizy :name }
+
+        it 'appends default' do
+          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :squish }])
+        end
+      end
+
+      context 'with one rule' do
+        before { model.normalizy :name, with: :upcase }
+
+        specify do
+          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
+        end
+      end
+
+      context 'with multiple rules' do
+        before { 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
+
+      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
+    end
+
+    context 'with multiple fields' do
+      context 'with no rule' do
+        before { 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
+
+      context 'with one rule' do
+        before { 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
+
+      context 'with multiple rules' do
+        before { 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
+
+      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
+    end
+  end
+
+  context 'with no default' do
+    before do
+      Normalizy.configure do |config|
+        config.default_filters = []
+      end
+    end
+
+    context 'with one field' do
+      context 'with no rules' do
+        before { model.normalizy :name }
+
+        specify do
+          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: [] }])
+        end
+      end
+
+      context 'with one rule' do
+        before { model.normalizy :name, with: :upcase }
+
+        specify do
+          expect(model.normalizy_rules).to eq(name: [{ block: nil, options: {}, rules: :upcase }])
+        end
+      end
+
+      context 'with multiple rules' do
+        before { 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
+
+      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
+    end
+
+    context 'with multiple fields' do
+      context 'with no rule' do
+        before { model.normalizy :email, :name }
+
+        specify do
+          expect(model.normalizy_rules).to eq(
+            email: [{ block: nil, options: {}, rules: [] }],
+            name:  [{ block: nil, options: {}, rules: [] }]
+          )
+        end
+      end
+
+      context 'with one rule' do
+        before { 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
+
+      context 'with multiple rules' do
+        before { 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
+
+      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
+    end
+  end
+
+  context 'when block is given' do
+    let!(:block) { ->(value) { value.downcase } }
+
+    before { model.normalizy(:name, &block) }
+
+    specify do
+      expect(model.normalizy_rules[:name][0][:block]).to eq block
+    end
+  end
+end

data/spec/normalizy/extensions/normalizy_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe User, 'active_record' do
+  xit 'norm the object' do
+    matcher.matches?(object)
+
+    expect(matcher.instance_variable_get(:@subject)).to eq object
+  end
+end

data/spec/normalizy/filters/number_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Filters::Number do
+  it { expect(subject.call('abcdefghijklmnopkrstuvxyz')).to eq nil }
+  it { expect(subject.call('ABCDEFGHIJKLMNOPKRSTUVXYZ')).to eq nil }
+  it { expect(subject.call('áéíóúàâêôãõ')).to               eq nil }
+  it { expect(subject.call('0123456789')).to                eq 123_456_789 }
+  it { expect(subject.call("\n")).to                        eq nil }
+  it { expect(subject.call(42)).to                          eq 42 }
+  it { expect(subject.call(nil)).to                         eq nil }
+  it { expect(subject.call('nil')).to                       eq nil }
+  it { expect(subject.call('')).to                          eq nil }
+end

data/spec/normalizy/filters/strip_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::Filters::Strip do
+  it { expect(subject.call('  Some  Text  ')).to               eq 'Some  Text' }
+  it { expect(subject.call('  Some  Text  ', side: :left)).to  eq 'Some  Text  ' }
+  it { expect(subject.call('  Some  Text  ', side: :right)).to eq '  Some  Text' }
+  it { expect(subject.call('  Some  Text  ', side: :both)).to  eq 'Some  Text' }
+  it { expect(subject.call("\n")).to                           eq '' }
+  it { expect(subject.call(42)).to                             eq 42 }
+  it { expect(subject.call(nil)).to                            eq nil }
+end

data/spec/normalizy/normalizy/configure_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy, '#configure' do
+  it 'yields the default config' do
+    described_class.configure do |conf|
+      expect(conf).to be_a_instance_of Normalizy::Config
+    end
+  end
+end

data/spec/normalizy/rspec/matcher/description_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Normalizy::RSpec::Matcher, '.description' do
+  let!(:matcher) { described_class.new :name }
+
+  before do
+    matcher.from :from
+    matcher.to   :to
+  end
+
+  context 'with no :with expectation' do
+    specify do
+      expect(matcher.description).to eq 'normalizy name from "from" to "to"'
+    end
+  end
+
+  context 'with :with expectation' do
+    before { matcher.with :blank }
+
+    specify do
+      expect(matcher.description).to eq 'normalizy name with blank'
+    end
+  end
+end