normalizy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 781b68ea361e5e2a698bba7230a2a2459f2cb758
+  data.tar.gz: 01d9c17b15ee6ec08c5dda0da645897a43f9370d
+SHA512:
+  metadata.gz: cef08c0e44de84158e91659510c0d4bcd50715739a977452c9c7037b44dbaa06acfe29993388b357a1c0e863e7cafa22e8b5acbc8f995b740340c8efa7aeef76
+  data.tar.gz: 632e6116a884839be1e018f905599766ecf9223ef9336ae5ba79c503bd549c41242fdcab975a489372f75a530f97b495ec71e0f53d649e0c8cf844c870788341

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.1.0
+
+- First release.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Washington Botelho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,341 @@
+# Normalizy
+
+[![Build Status](https://travis-ci.org/wbotelhos/normalizy.svg)](https://travis-ci.org/wbotelhos/normalizy)
+[![Gem Version](https://badge.fury.io/rb/normalizy.svg)](https://badge.fury.io/rb/normalizy)
+
+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.
+
+## install
+
+Add the following code on your `Gemfile` and run `bundle install`:
+
+```ruby
+gem 'normalizy'
+```
+
+So generates an initializer for future custom configurations:
+
+```ruby
+rails g normalizy:install
+```
+
+It will generates a file `config/initializers/normalizy.rb` where you can configure you own normalizer and choose some defaults one.
+
+## Usage
+
+On your model, just add `normalizy` callback with the attribute you want to normalize and the filter to be used:
+
+```ruby
+class User < ApplicationRecord
+  normalizy :name, with: :strip
+end
+```
+
+Now some email like `  myemail@example.org  ` 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:
+
+### Number
+
+```ruby
+normalizy :age, with: :number
+
+' 32'
+# 32
+```
+
+By default, `number` works with input value before [Type Cast](#type-cast)
+### Strip
+
+Options:
+
+- `side`: `:left`, `:right` or `:both`. Default: `:both`
+
+```ruby
+normalizy :name, with: :strip
+'  Washington  Botelho  '
+# 'Washington  Botelho'
+```
+
+```ruby
+normalizy :name, with: { strip: { side: :left } }
+'  Washington  Botelho  '
+# 'Washington  Botelho  '
+```
+
+```ruby
+normalizy :name, with: { strip: { side: :right } }
+'  Washington  Botelho  '
+# '  Washington  Botelho'
+```
+
+```ruby
+normalizy :name, with: { strip: { side: :both } }
+'  Washington  Botelho  '
+# 'Washington  Botelho'
+```
+
+As you can see, the rules can be passed as Symbol/String or as Hash if it has options.
+
+## Multiple Filters
+
+You can normalize with a couple of filters at once:
+
+```ruby
+normalizy :name, with: %i[squish titleize]
+'  washington  botelho  '
+# 'Washington Botelho'
+```
+
+## Multiple Attributes
+
+You can normalize more than one attribute at once too, with one or muiltiple filters:
+
+```ruby
+normalizy :email, :username, with: :downcase
+```
+
+Of course you can declare muiltiples attribute and multiple filters together.
+It is possible to make sequential normalizy calls:
+
+```ruby
+normalizy :email, :username, with: :squish
+normalizy :email           , with: :downcase
+```
+
+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`:
+
+```ruby
+Normalizy.configure do |config|
+  config.default_filters = [:squish]
+end
+```
+
+Now, all normalization will include squish, even when no rule is declared.
+
+```ruby
+normalizy :name
+'  Washington  Botelho  '
+# 'Washington Botelho'
+```
+
+If you declare some filter, the default filter `squish` will be runned together:
+
+```ruby
+normalizy :name, with: :downcase
+'  washington  botelho  '
+# 'Washington Botelho'
+```
+
+## Custom Filter
+
+You can create a custom filter that implements `call` method with an `input` as argument and an optional `options`:
+
+```ruby
+module Normalizy
+  module Filters
+    module Blacklist
+      def self.call(input)
+        input.gsub 'Fuck', replacement: '***'
+      end
+    end
+  end
+end
+```
+
+```ruby
+Normalizy.configure do |config|
+  config.add :blacklist, Normalizy::Filters::Blacklist
+end
+```
+
+Now you can use your custom filter:
+
+```ruby
+normalizy :name, with: :blacklist
+
+'Washington Fuck Botelho'
+# '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:
+
+```ruby
+module Normalizy
+  module Filters
+    module Blacklist
+      def self.call(input, options: {})
+        input.gsub 'Fuck', replacement: options[:replacement]
+      end
+    end
+  end
+end
+```
+
+```ruby
+normalizy :name, with: blacklist: { replacement: '---' }
+
+'Washington Fuck Botelho'
+# 'Washington --- Botelho'
+```
+
+You can pass a block and it will be received on filter:
+
+```ruby
+module Normalizy
+  module Filters
+    module Blacklist
+      def self.call(input, options: {})
+        value = input.gsub('Fuck', 'filtered')
+
+        value = yield(value) if block_given?
+
+        value
+      end
+    end
+  end
+end
+```
+
+```ruby
+normalizy :name, with: :blacklist, &->(value) { value.sub('filtered', '(filtered 2x)') }
+
+'Washington Fuck Botelho'
+# '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:
+
+```ruby
+normalizy :birthday, with: :parse_date
+
+def parse_date(input, options = {})
+  Time.zone.parse(input).strftime '%Y/%m/%d'
+end
+
+'1984-10-23'
+# '1984/10/23'
+```
+
+If you gives an option, it will be passed to the function too:
+
+```ruby
+normalizy :birthday, with: { parse_date: { format: '%Y/%m/%d' }
+
+def parse_date(input, options = {})
+  Time.zone.parse(input).strftime options[:format]
+end
+
+'1984-10-23'
+# '1984/10/23'
+```
+
+Block methods works here too.
+
+## Native Filter
+
+After the missing built-in and class method, the fallback will be the value of native methods.
+
+```ruby
+normalizy :name, with: :reverse
+
+'Washington Botelho'
+# "ohletoB notgnihsaW"
+```
+
+## Inline Filter
+
+Maybe you want to declare an inline filter, in this case, just use a Lambda or Proc:
+
+```ruby
+normalizy :age, with: ->(input) { input.abs }
+
+-32
+# 32
+```
+
+You can use it on filters declaration too:
+
+```ruby
+Normalizy.configure do |config|
+  config.add :age, ->(input) { input.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.
+
+To receive the value before type cast, just pass a `raw` options as `true`:
+
+```ruby
+normalizy :amount, with: :number, raw: true
+
+'$ 42.00'
+# 4200
+```
+
+To avoid repeat the `raw: true` where you will always to use, you can register a filter with this options:
+
+```ruby
+Normalizy.configure do |config|
+  config.add :money, ->(input) { input.gsub(/\D/, '') }, raw: true
+end
+```
+
+## 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:
+
+```ruby
+Normalizy.configure do |config|
+  config.alias :money, :number
+end
+```
+
+Now, `money` will delegate to `number` filter.
+Since we already know the need of `raw` options, we can declare it here too:
+
+```ruby
+Normalizy.configure do |config|
+  config.alias :money, :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:
+
+```ruby
+normalizy :amount, with: :money
+
+'$ 42.00'
+# 4200
+```
+
+If you need to alias multiple filters, just provide an array of them:
+
+```ruby
+Normalizy.configure do |config|
+  config.alias :username, %i[squish downcase]
+end
+```
+
+## 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/generators/normalizy/install_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Normalizy
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc 'creates an initializer'
+
+    def copy_initializer
+      copy_file 'config/initializers/normalizy.rb', 'config/initializers/normalizy.rb'
+    end
+  end
+end

data/lib/generators/normalizy/templates/config/initializers/normalizy.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Normalizy.configure do |config|
+  config.default_filters = [:squish]
+
+  # config.filters[:blacklist] = Blacklist
+end

data/lib/normalizy/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'normalizy/filters'
+
+module Normalizy
+  class Config
+    attr_accessor :default_filters
+    attr_reader :filters, :normalizy_aliases, :normalizy_raws
+
+    def add(name, value, raw: false)
+      @filters[name] = value
+      @normalizy_raws << name if raw
+
+      self
+    end
+
+    def alias(name, to, raw: false)
+      @normalizy_aliases[name] = to
+      @normalizy_raws << name if raw
+
+      self
+    end
+
+    def initialize
+      @default_filters   = {}
+      @normalizy_aliases = {}
+      @normalizy_raws    = [:number]
+
+      @filters = {
+        number: Normalizy::Filters::Number,
+        strip:  Normalizy::Filters::Strip
+      }
+    end
+  end
+end

data/lib/normalizy/extensions.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Extension
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :apply_normalizy, if: -> {
+        self.class.respond_to? :normalizy
+      }
+
+      private
+
+      def apply_normalizy
+        (self.class.normalizy_rules || {}).each do |attribute, rules|
+          rules.each { |rule| normalizy! rule.merge(attribute: attribute) }
+        end
+      end
+
+      def extract_filter(rule, filters: Normalizy.config.filters)
+        if rule.is_a?(Hash)
+          result  = filters[rule.keys.first] || rule.keys.first
+          options = rule.values.first
+        else
+          result = filters[rule]
+        end
+
+        [result || rule, options || {}]
+      end
+
+      def extract_value(value, filter, options, block)
+        if filter.respond_to?(:call)
+          if filter.method(:call).arity == -2
+            filter.call value, options, &block
+          else
+            filter.call value, &block
+          end
+        elsif respond_to?(filter)
+          send filter, value, options, &block
+        elsif value.respond_to?(filter)
+          value.send filter, &block
+        else
+          value
+        end
+      end
+
+      def normalizy!(attribute:, rules:, options:, block:)
+        return if rules.blank? && block.blank?
+
+        aliases = Normalizy.config.normalizy_aliases
+        value   = nil
+
+        [rules].flatten.compact.each do |rule|
+          value         = original_value(attribute, rule, options)
+          aliased_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)
+          end
+        end
+
+        return unless value
+
+        write attribute, value
+      end
+
+      def original_value(attribute, rule, options)
+        if raw? attribute, rule, options
+          send "#{attribute}_before_type_cast"
+        else
+          send attribute
+        end
+      end
+
+      def raw?(attribute, rule, options)
+        return false unless respond_to?("#{attribute}_before_type_cast")
+
+        options[:raw] || Normalizy.config.normalizy_raws.include?(rule)
+      end
+
+      def write(attribute, value)
+        write_attribute attribute, value
+      rescue ActiveModel::MissingAttributeError
+        send "#{attribute}=", value
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :normalizy_rules
+
+      def normalizy(*args, &block)
+        options = args.extract_options!
+        rules   = options[:with] || Normalizy.config.default_filters
+
+        self.normalizy_rules ||= {}
+
+        args.each do |field|
+          normalizy_rules[field] ||= []
+          normalizy_rules[field] << { block: block, options: options.except(:with), rules: rules }
+        end
+      end
+    end
+  end
+end

data/lib/normalizy/filters/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Filters
+    module Number
+      def self.call(input)
+        return input unless input.is_a?(String)
+
+        value = input.gsub(/\D/, '')
+
+        return nil if value.blank?
+
+        value.to_i
+      end
+    end
+  end
+end

data/lib/normalizy/filters/strip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Filters
+    module Strip
+      def self.call(input, options = {})
+        return input unless input.is_a?(String)
+
+        regex = {
+          both:  '\A\s*|\s*\z',
+          left:  '\A\s*',
+          right: '\s*\z'
+        }[options[:side] || :both]
+
+        input.gsub Regexp.new(/#{regex}/), ''
+      end
+    end
+  end
+end

data/lib/normalizy/filters.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Normalizy
+  module Filters
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/filters/*.rb"].each { |file| require file }

data/lib/normalizy/rspec/matcher.rb

@@ -0,0 +1,115 @@
+module Normalizy
+  module RSpec
+    def normalizy(attribute)
+      Matcher.new attribute
+    end
+
+    class Matcher
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def description
+        return "normalizy #{@attribute} with #{with_expected}" if @with.present?
+
+        "normalizy #{@attribute} from #{from_value} to #{to_value}"
+      end
+
+      def failure_message
+        return "expected: #{with_expected}\n     got: #{actual_value}" if @with.present?
+
+        "expected: #{to_value}\n     got: #{actual_value}"
+      end
+
+      def failure_message_when_negated
+        return "expected: value != #{with_expected}\n     got: #{actual_value}" if @with.present?
+
+        "expected: value != #{to_value}\n     got: #{actual_value}"
+      end
+
+      def from(value)
+        @from = value
+
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject
+
+        if @with.present?
+          options = @subject.class.normalizy_rules[@attribute]
+
+          return false if options.blank?
+
+          options.each do |option|
+            rules = option[:rules]
+
+            return true if rules.is_a?(Array) && rules.include?(@with)
+            return true if rules == @with
+          end
+
+          false
+        else
+          @subject.send "#{@attribute}=", @from
+
+          @subject.send(@attribute) == @to
+        end
+      end
+
+      def to(value)
+        @to = value
+
+        self
+      end
+
+      def with(value)
+        @with = value
+
+        self
+      end
+
+      private
+
+      def actual_value
+        return with_value if @with
+
+        value = @subject.send(@attribute)
+
+        value.is_a?(String) ? %("#{value}") : value
+      end
+
+      def from_value
+        @from.nil? ? :nil : %("#{@from}")
+      end
+
+      def to_value
+        @to.nil? ? :nil : %("#{@to}")
+      end
+
+      def with_expected
+        @with
+      end
+
+      def with_value
+        options = @subject.class.normalizy_rules[@attribute]
+
+        return :nil            if options.nil?
+        return %("#{options}") if options.blank?
+
+        result = options.map do |option|
+          rules = option[:rules]
+
+          if rules.nil?
+            :nil
+          elsif rules.blank?
+            %("#{rules}")
+          else
+            rules
+          end
+        end
+
+        result.join ', '
+      end
+    end
+  end
+end

data/lib/normalizy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Normalizy
+  VERSION = '0.1.0'
+end