normalizy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 781b68ea361e5e2a698bba7230a2a2459f2cb758
-  data.tar.gz: 01d9c17b15ee6ec08c5dda0da645897a43f9370d
+  metadata.gz: 76436253c67c497cba120a39bd71667b34cad65f
+  data.tar.gz: c5bb1d390b33e655ea7e5e9c865cf4bf8d903fc6
 SHA512:
-  metadata.gz: cef08c0e44de84158e91659510c0d4bcd50715739a977452c9c7037b44dbaa06acfe29993388b357a1c0e863e7cafa22e8b5acbc8f995b740340c8efa7aeef76
-  data.tar.gz: 632e6116a884839be1e018f905599766ecf9223ef9336ae5ba79c503bd549c41242fdcab975a489372f75a530f97b495ec71e0f53d649e0c8cf844c870788341
+  metadata.gz: 488852bd2f5c2ce038533f7dcd984b537b5e27cd185cccafa560553cf7f50a13d8a7bac0e15670c6647fff376957b91a53463b966713f887ed5e566f68d32415
+  data.tar.gz: 7205c44545020100f4663e2ca7e9d9af224dfda0e3bb6645acee7defb8798c76bec57582678a25670a5f4c07d2f6d07fed151d089e81f72e154ca6fd20afb806

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v0.2.0
+
+- Changes:
+  - `number` filter no more make cast automatically.
+  - `number` now accept `cast` options with method to be used on cast type;
+
+- Features:
+  - add `date` filter with `format`, `time_zone` and I18n error message support;
+  - add `money` filter with `cast`, `type` and I18n support;
+  - add `percent` filter with `cast`, `type` and I18n support.
+
 ## v0.1.0
 
 - First release.

data/README.md

@@ -7,7 +7,7 @@ Attribute normalizer for ActiveRecord.
 
 ## Description
 
-If you know the obvious format of an input, why not normalize it instead of raise an validation error to your use? Make the follow email `  myemail@example.org  ` valid like `email@example.com` with no need to override acessors methods.
+If you know the obvious format of an input, why not normalize it instead of raise an validation error to your use? Make the follow email `  Email@example.com  ` valid like `email@example.com` with no need to override acessors methods.
 
 ## install
 
@@ -35,22 +35,319 @@ class User < ApplicationRecord
 end
 ```
 
-Now some email like `  myemail@example.org  ` will be saved as `email@example.com`.
+Now some email like `  myemail@example.com  ` will be saved as `email@example.com`.
 
 ## Filters
 
-We have a couple of built-in filters. The most one is just a wrapper o the original String methods:
+We have a couple of built-in filters.
+
+### Date
+
+Transform a value to date format.
+
+```ruby
+normalizy :birthday, with: :date
+
+'1984-10-23'
+# Tue, 23 Oct 1984 00:00:00 UTC +00:00
+```
+
+By default, the date is treat as `%F` format and as `UTC` time.
+
+#### format
+
+You can change the format using the `format` options:
+
+```ruby
+normalizy :birthday, with: date: { format: '%y/%m/%d' }
+
+'84/10/23'
+# Tue, 23 Oct 1984 00:00:00 UTC +00:00
+```
+
+#### time zone
+
+To convert the date on your time zone, just provide the `time_zone` option:
+
+```ruby
+normalizy :birthday, with: date: { time_zone: '%y/%m/%d' }
+
+'1984-10-23'
+# Tue, 23 Oct 1984 00:00:00 EDT -04:00
+```
+
+#### error message
+
+If an invalid date is provided, Normalizy will add an error on attribute of the related object.
+You can customize the error via I18n config:
+
+```yml
+en:
+  normalizy:
+    errors:
+      date:
+        user:
+          birthday: '%{value} is an invalid date.'
+```
+
+If no configuration is provided, the default message will be `'%{value} is an invalid date.`.
+
+#### adjust
+
+If your model receive a `Time` or `DateTime`, you can provide `adjust` options to change you time to begin o the day:
+
+```ruby
+normalizy :birthday, with: date: { adjust: :begin }
+
+Tue, 23 Oct 1984 11:30:00 EDT -04:00
+# Tue, 23 Oct 1984 00:00:00 EDT -04:00
+```
+
+Or to the end of the day:
+
+```ruby
+normalizy :birthday, with: date: { adjust: :end }
+
+Tue, 23 Oct 1984 00:00:00 EDT -04:00
+# Tue, 23 Oct 1984 11:59:59 EDT -04:00
+```
+
+By default, `number` works with value before [Type Cast](#type-cast).
+
+### Money
+
+Transform a value to money format.
+
+```ruby
+normalizy :amount, with: :money
+
+'$ 42.00'
+# '42.00'
+```
+
+#### separator
+
+The `separator` will be keeped on value to be possible cast the right integer value.
+You can change this separator:
+
+```ruby
+normalizy :amount, with: money: { separator: ',' }
+
+'R$ 42,00'
+# '42,00'
+```
+
+If you do not want pass it as options, Normalizy will fetch your I18n config:
+
+```yaml
+en:
+  currency:
+    format:
+      separator: '.'
+```
+
+And if it does not exists, `.` will be used as default.
+
+#### type
+
+You can retrieve the value in *cents* format, use the `type` options as `cents`:
+
+```ruby
+normalizy :amount, with: money: { type: :cents }
+
+'$ 42.00'
+# '4200'
+```
+
+#### precision
+
+As you could see on the last example, when using `type: :cents` is important the number of decimal digits.
+So, you can configure it to avoid the following error:
+
+```ruby
+normalizy :amount, with: money: { type: :cents }
+
+'$ 42.0'
+# 420
+```
+
+When you parse it back, the value need to be divided by `100` to be presented, but it will result in a value you do not want: `4.2` instead of the original `42.0`. Just provide a `precision`:
+
+```ruby
+normalizy :amount, with: money: { precision: 2 }
+
+'$ 42.0'
+# 42.00
+```
+
+```ruby
+normalizy :amount, with: money: { precision: 2, type: :cents }
+
+'$ 42.0'
+# 4200
+```
+
+If you do not want pass it as options, Normalizy will fetch your I18n config:
+
+```yaml
+en:
+  currency:
+    format:
+      separator: 2
+```
+
+And if it does not exists, `2` will be used as default.
+
+#### cast
+
+If you need get a number over a normalized string in a number style, provide `cast` option with desired cast method:
+
+```ruby
+normalizy :amount, with: money: { cast: :to_i }
+
+'$ 42.00'
+# 4200
+```
+
+Just pay attention to avoid to use `type: :cents` together `cast` with float parses.
+Since `type` runs first, you will add decimal in a number that already is represented with decimal, but as integer:
+
+```ruby
+normalizy :amount, with: money: { cast: :to_f, type: :cents }
+
+'$ 42.00'
+# 4200.0
+```
+
+By default, `money` works with value before [Type Cast](#type-cast).
 
 ### Number
 
 ```ruby
 normalizy :age, with: :number
 
-' 32'
+' 32x'
+# '32'
+```
+
+If you want cast the value, provide `cast` option with desired cast method:
+
+```ruby
+normalizy :age, with: number: { cast: :to_i }
+
+' 32x'
 # 32
 ```
 
-By default, `number` works with input value before [Type Cast](#type-cast)
+By default, `number` works with value before [Type Cast](#type-cast).
+
+### Percent
+
+Transform a value to percent format.
+
+```ruby
+normalizy :amount, with: :percent
+
+'42.00 %'
+# '42.00'
+```
+
+#### separator
+
+The `separator` will be keeped on value to be possible cast the right integer value.
+You can change this separator:
+
+```ruby
+normalizy :amount, with: percent: { separator: ',' }
+
+'42,00 %'
+# '42,00'
+```
+
+If you do not want pass it as options, Normalizy will fetch your I18n config:
+
+```yaml
+en:
+  percentage:
+    format:
+      separator: '.'
+```
+
+And if it does not exists, `.` will be used as default.
+
+#### type
+
+You can retrieve the value in *integer* format, use the `type` options as `integer`:
+
+```ruby
+normalizy :amount, with: percent: { type: :integer }
+
+'42.00 %'
+# '4200'
+```
+
+#### precision
+
+As you could see on the last example, when using `type: :integer` is important the number of decimal digits.
+So, you can configure it to avoid the following error:
+
+```ruby
+normalizy :amount, with: percent: { type: :integer }
+
+'42.0 %'
+# 420
+```
+
+When you parse it back, the value need to be divided by `100` to be presented, but it will result in a value you do not want: `4.2` instead of the original `42.0`. Just provide a `precision`:
+
+```ruby
+normalizy :amount, with: percent: { precision: 2 }
+
+'42.0 %'
+# 42.00
+```
+
+```ruby
+normalizy :amount, with: percent: { precision: 2, type: :integer }
+
+'42.0 %'
+# 4200
+```
+
+If you do not want pass it as options, Normalizy will fetch your I18n config:
+
+```yaml
+en:
+  percentage:
+    format:
+      separator: 2
+```
+
+And if it does not exists, `2` will be used as default.
+
+#### cast
+
+If you need get a number over a normalized string in a number style, provide `cast` option with desired cast method:
+
+```ruby
+normalizy :amount, with: percent: { cast: :to_i }
+
+'42.00 %'
+# 4200
+```
+
+Just pay attention to avoid to use `type: :integer` together `cast` with float parses.
+Since `type` runs first, you will add decimal in a number that already is represented with decimal, but as integer:
+
+```ruby
+normalizy :amount, with: percent: { cast: :to_f, type: :integer }
+
+'42.00 %'
+# 4200.0
+```
+
+By default, `percent` works with value before [Type Cast](#type-cast).
+
 ### Strip
 
 Options:
@@ -101,7 +398,7 @@ You can normalize more than one attribute at once too, with one or muiltiple fil
 normalizy :email, :username, with: :downcase
 ```
 
-Of course you can declare muiltiples attribute and multiple filters together.
+Of course you can declare muiltiples attribute and multiple filters, either.
 It is possible to make sequential normalizy calls:
 
 ```ruby
@@ -113,7 +410,7 @@ In this case, each line will be evaluated from the top to the bottom.
 
 ## Default Filters
 
-You can configure some default filters to be runned. Edit you initializer at `config/initializers/normalizy.rb`:
+You can configure some default filters to be runned. Edit initializer at `config/initializers/normalizy.rb`:
 
 ```ruby
 Normalizy.configure do |config|
@@ -168,7 +465,9 @@ normalizy :name, with: :blacklist
 # 'Washington *** Botelho'
 ```
 
-If you want to pass options to your filter, just call it as hash and the value will be passed to the custom filter:
+#### options
+
+If you want to pass options to your filter, just call it as a hash and the value will be send to the custom filter:
 
 ```ruby
 module Normalizy
@@ -189,6 +488,13 @@ normalizy :name, with: blacklist: { replacement: '---' }
 # 'Washington --- Botelho'
 ```
 
+### options value
+
+By default, Modules and instance methods of class will receveis the following attributes on `options` argument:
+
+- `object`: The object that Normalizy is acting;
+- `attribute`: The attribute of the object that Normalizy is acting.
+
 You can pass a block and it will be received on filter:
 
 ```ruby
@@ -214,16 +520,14 @@ normalizy :name, with: :blacklist, &->(value) { value.sub('filtered', '(filtered
 # 'Washington (filtered 2x) Botelho'
 ```
 
-The block
-
 ## Method Filters
 
-If a built-in filter is not found, Normalizy will try to find a method to suply the normalize with the same name of the given filter:
+If a built-in filter is not found, Normalizy will try to find a method in the current class.
 
 ```ruby
 normalizy :birthday, with: :parse_date
 
-def parse_date(input, options = {})
+def parse_date(input)
   Time.zone.parse(input).strftime '%Y/%m/%d'
 end
 
@@ -231,7 +535,7 @@ end
 # '1984/10/23'
 ```
 
-If you gives an option, it will be passed to the function too:
+If you gives an option, it will be passed to the function:
 
 ```ruby
 normalizy :birthday, with: { parse_date: { format: '%Y/%m/%d' }
@@ -244,7 +548,7 @@ end
 # '1984/10/23'
 ```
 
-Block methods works here too.
+Block methods works here either.
 
 ## Native Filter
 
@@ -262,7 +566,7 @@ normalizy :name, with: :reverse
 Maybe you want to declare an inline filter, in this case, just use a Lambda or Proc:
 
 ```ruby
-normalizy :age, with: ->(input) { input.abs }
+normalizy :age, with: ->(input) { input.to_i.abs }
 
 -32
 # 32
@@ -272,60 +576,68 @@ You can use it on filters declaration too:
 
 ```ruby
 Normalizy.configure do |config|
-  config.add :age, ->(input) { input.abs }
+  config.add :age, ->(input) { input.to_i.abs }
 end
 ```
 
 ## Type Cast
 
-An input field with `$ 42.00` dollars when sent to model with a field with `integer` type,
-will be converted to `0`, since the type does not match. But you want to use the value before Rails do this cast the type.
+An input field with `= 42` value when sent to model with a field as `integer` type,
+will be converted to `0`, since the type does not match. But you want to use the value before Rails cast the type.
 
 To receive the value before type cast, just pass a `raw` options as `true`:
 
 ```ruby
 normalizy :amount, with: :number, raw: true
 
-'$ 42.00'
-# 4200
+'= 42'
+# 42
 ```
 
-To avoid repeat the `raw: true` where you will always to use, you can register a filter with this options:
+To avoid repeat the `raw: true` when you have multiple uses, you can register a filter:
 
 ```ruby
 Normalizy.configure do |config|
-  config.add :money, ->(input) { input.gsub(/\D/, '') }, raw: true
+  config.add :raw_number, ->(input) { input.gsub(/\D/, '') }, raw: true
 end
 ```
 
+And use it in short version:
+
+```ruby
+normalizy :amount, with: :raw_number
+
+'= 42'
+# 42
+```
+
 ## Alias
 
 Sometimes you want to give a better name to your filter, just to keep the things semantic.
-But duplicates the code just to redefine a new name is not a good idea, so, just create an alias:
+Duplicates the code, as you know, is not a good idea, so, create an alias:
 
 ```ruby
 Normalizy.configure do |config|
-  config.alias :money, :number
+  config.alias :age, :number
 end
 ```
 
-Now, `money` will delegate to `number` filter.
-Since we already know the need of `raw` options, we can declare it here too:
+Now, `age` will delegate to `number` filter.
+Since we already know the need of `raw` options, we can declare it here:
 
 ```ruby
 Normalizy.configure do |config|
-  config.alias :money, :number, raw: true
+  config.alias :age, :number, raw: true
 end
 ```
 
-But `number` filter already works with `raw: true`, don't need to tell it again.
-An our previous example, about `amount`, was refactored to:
+And now, the aliased filter will work fine:
 
 ```ruby
-normalizy :amount, with: :money
+normalizy :age, with: :age
 
-'$ 42.00'
-# 4200
+'= 42'
+# 42
 ```
 
 If you need to alias multiple filters, just provide an array of them:
@@ -336,6 +648,41 @@ Normalizy.configure do |config|
 end
 ```
 
+## RSpec
+
+If you use [RSpec](http://rspec.info), we did built-in matchers for you.
+Add the following code to your `rails_helper.rb`
+
+```ruby
+RSpec.configure do |config|
+ config.include Normalizy::RSpec
+end
+```
+
+And now you can use some of the matchers:
+
+##### Result Matcher
+
+```ruby
+it { is_expected.to normalizy(:email).from(' Email@example.com  ').to 'email@example.com' }
+```
+
+##### Filter Matcher
+
+It will match the given filter literally:
+
+```ruby
+it { is_expected.to normalizy(:email).with :downcase }
+```
+
+```ruby
+it { is_expected.to normalizy(:email).with %i[downcase squish] }
+```
+
+```ruby
+it { is_expected.to normalizy(:email).with(trim: { side: :left }) }
+```
+
 ## Love it!
 
 Via [PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=X8HEP2878NDEG&item_name=normalizy) or [Gratipay](https://gratipay.com/~wbotelhos). Thanks! (:

data/lib/normalizy/config.rb

@@ -9,6 +9,7 @@ module Normalizy
 
     def add(name, value, raw: false)
       @filters[name] = value
+
       @normalizy_raws << name if raw
 
       self
@@ -24,11 +25,14 @@ module Normalizy
     def initialize
       @default_filters   = {}
       @normalizy_aliases = {}
-      @normalizy_raws    = [:number]
+      @normalizy_raws    = %i[date money number percent]
 
       @filters = {
-        number: Normalizy::Filters::Number,
-        strip:  Normalizy::Filters::Strip
+        date:    Normalizy::Filters::Date,
+        money:   Normalizy::Filters::Money,
+        number:  Normalizy::Filters::Number,
+        percent: Normalizy::Filters::Percent,
+        strip:   Normalizy::Filters::Strip
       }
     end
   end

data/lib/normalizy/extensions.rb

@@ -51,17 +51,21 @@ module Normalizy
         value   = nil
 
         [rules].flatten.compact.each do |rule|
-          value         = original_value(attribute, rule, options)
-          aliased_rules = [aliases.key?(rule) ? aliases[rule] : rule]
+          result_rules = [aliases.key?(rule) ? aliases[rule] : rule]
 
-          aliased_rules.flatten.compact.each do |alias_rule|
-            filter, filter_options = extract_filter(alias_rule)
-            value = extract_value(value, filter, filter_options, block)
+          result_rules.flatten.compact.each do |result_rule|
+            filter, filter_options = extract_filter(result_rule)
+
+            if filter.respond_to?(:name)
+              rule_name = filter.name.tableize.split('/').last.singularize.to_sym
+            end
+
+            original     = original_value(attribute, rule_name, options)
+            full_options = filter_options.merge(attribute: attribute, object: self)
+            value        = extract_value(original, filter, full_options, block)
           end
         end
 
-        return unless value
-
         write attribute, value
       end
 

data/lib/normalizy/filters/date.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Filters
+    module Date
+      class << self
+        def call(input, options = {})
+          if input.is_a?(String)
+            return input if input.blank?
+
+            Time.use_zone(time_zone(options)) do
+              input = Time.zone.strptime(input, format(options))
+            end
+          end
+
+          if input.is_a?(Time) || input.is_a?(DateTime)
+            input = input.beginning_of_day if options[:adjust] == :begin
+            input = input.end_of_day       if options[:adjust] == :end
+          end
+
+          input
+        rescue ArgumentError
+          options[:object].errors.add options[:attribute], error_message(input, options)
+        end
+
+        private
+
+        def error_message(input, options)
+          I18n.t options[:attribute], scope: [
+            'normalizy.errors.date', options[:object].class.name.underscore
+          ], value: input, default: '%{value} is an invalid date.'
+        end
+
+        def format(options)
+          options.fetch :format, '%F'
+        end
+
+        def time_zone(options)
+          options.fetch :time_zone, 'UTC'
+        end
+      end
+    end
+  end
+end

data/lib/normalizy/filters/money.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Filters
+    module Money
+      class << self
+        def call(input, options = {})
+          return input unless input.is_a?(String)
+
+          value = input.gsub(/[^[0-9]#{separator(options)}]/, '')
+
+          return nil if value.blank?
+
+          value = "%0.#{precision(options)}f" % [value.sub(separator(options), '.')]
+          value = value.delete('.') if cents?(options)
+
+          return value.send(options[:cast]) if options[:cast]
+
+          value
+        end
+
+        private
+
+        def cents?(options)
+          options[:type]&.to_sym == :cents
+        end
+
+        def precision(options)
+          options.fetch :precision, I18n.t('currency.format.precision', default: 2)
+        end
+
+        def separator(options)
+          options.fetch :separator, I18n.t('currency.format.separator', default: '.')
+        end
+      end
+    end
+  end
+end