Ordinary

Normalizer for any model

Installation

Add this line to your application's Gemfile:

gem 'ordinary'

And then execute:

$ bundle

Or install it yourself as:

$ gem install ordinary

Usage

First, you will include Ordinary to the model of the object. Following is an example of using ActiveModel.

require 'ordinary'

class Person
  include ActiveModel::Model
  include Ordinary

  attr_accessor :name

  normalizes :name do |value|
    value.strip.squeeze(' ')
  end
end

You can get the normalized value with #normalize_attribute or #normalized_ATTR_NAME.

person = Person.new(:name => '      Koyomi    Araragi   ')
puts person.name # => "      Koyomi    Araragi   "
puts person.normalize_attribute(:name) # => "Koyomi Araragi"
puts person.normalized_name # => "Koyomi Araragi"

And you can get the normalized model with #normalize.

normalized_person = person.normalize
puts normalized_person.normalized? # => true
puts normalized_person.name # => "Koyomi Araragi"

Off course, it doesn't affect the original model.

puts person.normalized? # => false
puts person.name # => "      Koyomi    Araragi   "

However, if you use #normalize!, the original model will also be normalized.

How to define normalization

How to define normalization is from where you include Ordinary.

require 'ordinary'

class AnyModel
  include Ordinary

  # define normalization...
end

Incidentally, in order to enable to read and write to a target attirbute, you must define #ATTR_NAME and #ATTR_NAME=.

Normalization defines with .normalizes.

class AnyModel
  # ...

  attr_accessor :attr1, :attr2

  normalizes :attr1, :attr2 do |value|
    # process for normalization
  end

  # ...
end

You can define in a variety of ways.

class AnyModel
  # ...

  attr_accessor :attr1, :attr2

  # specify process with a block
  normalizes :attr1 do |value|
    "#{value}_1"
  end

  # if define normalization to same attribute, normalization runs in the order
  # in which you defined
  normalizes :attr1 do |value|
    "#{value}_2"
  end

  # If specify Proc to last argument, define composed unit in the Proc as
  # process of normalization (units described later)
  normalizes :attr2, lambda { lstrip | rstrip }

  # also specify both block and Proc (position of process of block decides by
  # block unit)
  normalizes :attr2, lambda { block | squeeze(' ') } do |value|
    "#{value}_3"
  end

  # also specify options
  normalizes :attr2, if: lambda { !attr2.nil? }, with: lambda { block | at(0) } do |value|
    (value.empty? or %w(0 false f).include?(value)) ? 'false' : 'true'
  end

  # ...
end

How to create an units module

You can create a module bundled some units. You'll use Ordinary::Module to do so.

require 'ordinary/module'

module AnyModule
  extend Ordinary::Module

  # define the module...
end

And you can register to use the module with Ordinary.register.

require 'ordinary'

Ordinary.register(AnyModule)

Define an unit

An unit can define with .unit in the module.

module AnyModule
  # ...

  unit :some_unit do |value|
    # process for the unit...
  end

  # ...
end

You can define in a variety of ways.

module AnyModule
  # ...

  # specify process with a block
  unit :lstrip do |value|
    value.lstrip
  end

  # okay as the argument
  unit :rstrip, lambda { |value| value.rstrip }

  # actually, above examples are okay at follows
  unit :lstrip

  # as aliasing
  unit :ltrim, :lstrip

  # by the way, units are defined as module functions, you can also see
  p lstrip # => #<Ordinary::Unit:0x0x007ff6ec8e7610 AnyModule#lstrip>

  # and compose units by #| (or #>>, #<<)
  unit :strip, lstrip | rstrip

  # ...
end

Define a dependency

If exist dependencies to some libraries to units in the module, will resolve with .requires.

module AnyModule
  # ...

  requires 'nkf'

  unit :to_half do |value|
    NKF.nkf('-wWZ1', value)
  end

  # ...
end

Contributing

Fork it
Create your feature branch (git checkout -b my-new-feature)
Commit your changes (git commit -am 'Add some feature')
Push to the branch (git push origin my-new-feature)
Create new Pull Request