ordinary 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bff706645249ee9b180396fa8dbd97c60de1a32
+  data.tar.gz: bef17919f5c25b578de54234e9b79d7611902a5b
+SHA512:
+  metadata.gz: c59a7bc904f9b0bcaa687dec7fa6b779cc2b257e615179086ad6d433bd9b320e296a1330950b2261052c10b7ee4b348c9a6ca3ca648d97e2a0ff3579df2db6f0
+  data.tar.gz: 544ffa6acca8a2412426b7f4c5dfc8d91a4c03437a4e66fe6be70a5735f049486ec7150a3f8ca25d1d0db5204f1fe23d6a9dbce7cacaaea85e9f3a3a9d47c020

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ordinary.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Takahiro Kondo
+
+MIT License
+
+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,232 @@
+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.
+
+```ruby
+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`.
+
+```ruby
+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`.
+
+```ruby
+normalized_person = person.normalize
+puts normalized_person.normalized? # => true
+puts normalized_person.name # => "Koyomi Araragi"
+```
+
+Off course, it doesn't affect the original model.
+
+```ruby
+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`.
+
+```ruby
+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`.
+
+```ruby
+class AnyModel
+  # ...
+
+  attr_accessor :attr1, :attr2
+
+  normalizes :attr1, :attr2 do |value|
+    # process for normalization
+  end
+
+  # ...
+end
+```
+
+You can define in a variety of ways.
+
+```ruby
+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.
+
+```ruby
+require 'ordinary/module'
+
+module AnyModule
+  extend Ordinary::Module
+
+  # define the module...
+end
+```
+
+And you can register to use the module with `Ordinary.register`.
+
+```ruby
+require 'ordinary'
+
+Ordinary.register(AnyModule)
+```
+
+### Define an unit
+
+An unit can define with `.unit` in the module.
+
+```ruby
+module AnyModule
+  # ...
+
+  unit :some_unit do |value|
+    # process for the unit...
+  end
+
+  # ...
+end
+```
+
+You can define in a variety of ways.
+
+```ruby
+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`.
+
+```ruby
+module AnyModule
+  # ...
+
+  requires 'nkf'
+
+  unit :to_half do |value|
+    NKF.nkf('-wWZ1', value)
+  end
+
+  # ...
+end
+```
+
+Contributing
+------------
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/ordinary.rb

@@ -0,0 +1,160 @@
+require 'ordinary/version'
+require 'ordinary/builder'
+require 'ordinary/normalizer'
+require 'ordinary/module'
+
+module Ordinary
+
+  # Normalize an attribute.
+  #
+  # @param [Symbol] attr_name an attribute to normalize
+  # @param [Symbol] context normalization context. defaults to nil
+  # @return [Object] the normalized attribute
+  def normalize_attribute(attr_name, context = nil)
+    value = __send__(attr_name)
+
+    unless value.nil?
+      self.class.normalizers[attr_name.to_sym].each do |normalizer|
+        next unless normalizer.coming_under?(self)
+        next unless normalizer.run_at?(context)
+        value = normalizer.normalize(value)
+      end
+    end
+
+    value
+  end
+
+  # Normalize all attributes and return the normalized object.
+  #
+  # @param [Symbol] context normalization context. defaults to nil
+  # @return [Object] the normalized object
+  def normalize(context = nil)
+    clone.normalize!(context)
+  end
+
+  # Normalize all attributes distructively.
+  #
+  # @param [Symbol] context normalization context. defaults to nil
+  # @return [Object] self
+  def normalize!(context = nil)
+    unless normalized?(context)
+      self.class.normalizers.keys.each do |attr_name|
+        __send__(:"#{attr_name}=", normalize_attribute(attr_name, context))
+      end
+
+      @normalization_context = context
+    end
+
+    self
+  end
+
+  # Determine if self is normalized.
+  #
+  # @param [Symbol] context normalization context. defaults to nil
+  # @return whether self is normalized
+  def normalized?(context = nil)
+    return false unless instance_variable_defined?(:@normalization_context)
+    @normalization_context.nil? or (@normalization_context == context)
+  end
+
+  # Register modules to the context of building.
+  #
+  # @scope class
+  # @param [Array<Ordinary::Module>] modules modules to register
+  def self.register(*modules)
+    Builder::Context.register(*modules)
+  end
+
+  # Unregister modules from the context of building.
+  #
+  # @scope class
+  # @param [Array<Ordinary::Module>] modules modules to unregister
+  def self.unregister(modules)
+    Builder::Context.unregister(*modules)
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+
+    if defined?(ActiveModel::Validations) and klass.include?(ActiveModel::Validations)
+      method = klass.instance_method(:run_validations!)
+
+      klass.__send__(:define_method, :run_validations!) do
+        context = validation_context
+        normalized?(context) ? method.bind(self).call : normalize(context).valid?(context)
+      end
+    end
+
+    if defined?(ActiveRecord::Base) and klass.include?(ActiveRecord::Base)
+    end
+  end
+
+  module ClassMethods
+
+    # @attribute [r] normalizers
+    # @return [Hash<Symbol, Array<Ordinary::Normalizer>>] normalizers for each
+    #   attribute
+    def normalizers
+      @normalizers ||= {}
+    end
+
+    # Define normalization for attributes.
+    #
+    # @example define normalization with a builder for the normalizer
+    #
+    #   normalizes :name, lambda { lstrip }
+    #   normalizes :name, lambda { lstrip | rstrip }
+    #
+    # @example define normalization with a block
+    #
+    #   normalizes :name do |value|
+    #     value.squeeze(' ')
+    #   end
+    #
+    # @example define normalization with a builder for the normalizer and a block
+    #
+    #   normalizes :name, -> { lstrip | block | rstrip } do |value|
+    #     value.squeeze(' ')
+    #   end
+    #
+    # @param [Array<Symbol>] attr_names attirubte names to normalize
+    # @yield [value] normalize the attribute
+    # @yieldparam [Object] value value of the attribute to normalize
+    def normalizes(*attr_names, &block)
+      attr_names = attr_names.dup
+      buil       = nil
+      options    = {}
+
+      case attr_names.last
+      when Proc
+        build = attr_names.pop
+      when Hash
+        options = attr_names.pop.dup
+        build = options.delete(:with)
+      end
+
+      unless build or block
+        raise ArgumentError, 'process for building a normalizer'  \
+                             '(with the last argument or :with option) or ' \
+                             'an unit of a normalizer ' \
+                             '(with block) are not given'
+      end
+
+      build ||= lambda { block }
+      unit = Builder.new(&block).build(&build)
+      normalizer = Normalizer.new(options, &unit)
+
+      attr_names.each do |attr_name|
+        raise ArgumentError, "##{attr_name} is not defined"  unless method_defined?(attr_name)
+        raise ArgumentError, "##{attr_name}= is not defined" unless method_defined?(:"#{attr_name}=")
+
+        (normalizers[attr_name.to_sym] ||= []) << normalizer
+
+        define_method :"normalized_#{attr_name}" do |context = nil|
+          normalize_attribute(attr_name, context)
+        end
+      end
+    end
+
+  end
+end

data/lib/ordinary/builder.rb

@@ -0,0 +1,79 @@
+require 'ordinary/unit'
+require 'set'
+
+module Ordinary
+  class Builder
+
+    def initialize(&block)
+      @context = Context.new(block)
+    end
+
+    # @attribute [r] context
+    # @return [Ordinary::Builder::Context] the context of building
+    attr_reader :context
+
+    # Build units for a normalizer.
+    #
+    # @yield build units for a normalizer
+    # @return [Ordinary::Unit, Ordinary::Units] units for a normalizer
+    def build(&build)
+      @context.instance_exec(&build)
+    end
+
+    module Context
+      class << self
+        attr_reader :current, :modules
+      end
+
+      def self.update(modules)
+        @current = Class.new { include *[*modules, Context] }.freeze
+        @modules = modules.freeze
+      end
+      private_class_method :update
+
+      update(Set.new)
+
+      def self.register(*modules)
+        update(@modules | modules)
+      end
+
+      def self.unregister(*modules)
+        update(@modules - modules)
+      end
+
+      def self.new(*args, &block)
+        @current.new(*args, &block)
+      end
+
+      def initialize(block = nil)
+        @block = block ? Unit.new(nil, &block) : nil
+      end
+
+      def block
+        unless @block
+          e = BlockNotGiven.new("`block' unit cannot use if a block is not given")
+          e.set_backtrace(caller)
+          raise e
+        end
+
+        @block
+      end
+
+      def method_missing(method_name, *args, &block)
+        e = UnitNotDefined.new("`#{method_name}' unit is not defined")
+        e.set_backtrace(caller)
+        raise e
+      end
+
+      def inspect
+        header      = "#{Context.name}:0x%014x" % (object_id << 1)
+        module_list = Context.modules.map(&:name).sort * ', '
+        with_block  = @block ? ' with a block' : ''
+        "#<#{header} [#{module_list}]#{with_block}>"
+      end
+    end
+
+    class UnitNotDefined < StandardError; end
+    class BlockNotGiven  < StandardError; end
+  end
+end

data/lib/ordinary/module.rb

@@ -0,0 +1,117 @@
+require 'ordinary/unit'
+require 'set'
+
+module Ordinary
+  module Module
+
+    # @attribute [r] requirements
+    # @return [Ordinary::Module::Requirements] libraries that the module
+    #   requires
+    def requirements
+      @requirements ||= Requirements.new
+    end
+
+    # Add libraries to the requirements.
+    #
+    # @param [Array<String>] libraries required libraries
+    #
+    # @see Ordinary::Module#requirements
+    def requires(*libraries)
+      requirements.add(*libraries)
+    end
+
+    # Define an unit for some normalizer.
+    #
+    # @example define an unit with a block
+    #
+    #   unit :lstrip do |value|
+    #     value.lstrip
+    #   end
+    #
+    #   # same as above
+    #   unit :lstrip, lambda { |value| value.lstrip }
+    #
+    # @example define an unit simply
+    #
+    #   # call .lstrip of a value
+    #   unit :lstrip
+    #
+    #   # and named "ltrim"
+    #   unit :ltrim, :lstrip
+    #
+    # @example define an unit with existing units
+    #
+    #   unit :lstrip
+    #   unit :rstrip
+    #
+    #   # use an existing unit
+    #   unit :ltrim, lstrip
+    #   unit :rtrim, rstrip
+    #
+    #   # use by combining existing units (by #|, #>> or #<<)
+    #   unit :trim, ltrim | rtrim
+    #
+    # @param [Symbol] name name of the unit
+    # @param [Symbol] unit
+    # @param [Proc] unit process of normalization that the unit plays
+    # @param [Ordinary::Unit, Ordinary::Units] unit an existing unit or
+    #   combination existing units
+    # @yield [value, *args] process of normalization that the unit plays
+    # @yieldparam [Object] value a value to process
+    # @yieldparam [Array<Object>] args additional arguments
+    def unit(name, unit = nil, &block)
+      unit = unit.to_sym if unit.is_a?(String)
+
+      unit = if unit.nil? and block.nil?
+               unit_by_send(name)
+             elsif unit.is_a?(Symbol)
+               unit_by_send(unit)
+             elsif unit.is_a?(Proc)
+               create_unit(&unit)
+             elsif block_given?
+               create_unit(&block)
+             else
+               unit
+             end
+
+      unit.owned_by(self, name) unless unit.owned?
+      define_method(name) { |*args| args.empty? ? unit : unit.with(*args) }
+      module_function name
+    end
+
+    private
+
+    def unit_by_send(method_name)
+      create_unit { |value, *args| value.__send__(method_name, *args) }
+    end
+
+    def create_unit(&process)
+      Unit.new(nil, requirements, &process)
+    end
+
+    class Requirements
+      def initialize
+        @libraries = Set.new
+        @loaded    = false
+      end
+
+      def add(*libraries)
+        @loaded    &= !(Set.new(libraries) - @libraries).empty?
+        @libraries |= libraries
+      end
+
+      def delete(*libraries)
+        @libraries -= libraries
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def load
+        @libraries.each(&method(:require))
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/ordinary/normalizer.rb

@@ -0,0 +1,46 @@
+module Ordinary
+  class Normalizer
+
+    def initialize(options = {}, &process)
+      @determine = extract_determiner(options)
+      @context   = options[:on]
+      @process   = process
+    end
+
+    # Normalize a value by the normalizer.
+    #
+    # @param [Object] value a value to normalize
+    # @return [Object] a normalized value
+    def normalize(value)
+      @process.call(value)
+    end
+
+    # Determine if a model coming under a target of the normalizer.
+    #
+    # @param [ActiveModel::Model] model a model to determine if be a target of
+    #   the normalizer
+    # @return whether the model is a target of the normalizer
+    def coming_under?(model)
+      @determine.nil? or !!@determine.call(model)
+    end
+
+    # Determine if
+    #
+    # @param [Symbol] context a context to determine
+    # @return whether
+    def run_at?(context)
+      @context.nil? or (@context == context)
+    end
+
+    private
+
+    def extract_determiner(options)
+      if determine = options[:if]
+        lambda { |model|  model.instance_eval(&determine) }
+      elsif determine = options[:unless]
+        lambda { |model| !model.instance_eval(&determine) }
+      end
+    end
+
+  end
+end

data/lib/ordinary/unit.rb

@@ -0,0 +1,85 @@
+module Ordinary
+  module Composable
+    def >>(other)
+      Units.new([*self, *other])
+    end
+    alias | >>
+
+    def <<(other)
+      other >> self
+    end
+
+    def owner
+      owned? ? "#{@module.name}##{@name}" : 'owner unknown'
+    end
+
+    def owned_by(mod, name)
+      @module = mod
+      @name   = name
+    end
+
+    def owned?
+      @module and @name
+    end
+
+    def instance_id
+      "#{self.class.name}:0x%014x" % (object_id << 1)
+    end
+  end
+
+  class Unit
+    include Composable
+
+    def initialize(original_unit, requirements = nil, arguments = [], &process)
+      raise ArgumentError, 'block not supplied' unless block_given?
+      @original_unit = original_unit
+      @requirements  = requirements
+      @arguments     = arguments
+      @process       = process
+    end
+
+    attr_reader :requirements
+
+    attr_reader :arguments
+
+    attr_reader :process
+
+    def with(*arguments)
+      self.class.new(self, @requirements, arguments, &@process)
+    end
+
+    def to_proc
+      @requirements.load if @requirements and !@requirements.loaded?
+      args = @arguments + (@original_unit ? @original_unit.arguments : [])
+      lambda { |value| @process.call(value, *args) }
+    end
+
+    def inspect
+      original_owner = ''
+
+      if @original_unit
+        argument_list  = @arguments.map(&:inspect) * ', '
+        original_owner = " (#{@original_unit.owner} with [#{argument_list}])"
+      end
+
+      "#<#{instance_id} #{owner}#{original_owner}>"
+    end
+  end
+
+  class Units < Array
+    include Composable
+
+    def with(*arguments)
+      self.class.new(map { |unit| unit.with(*arguments) })
+    end
+
+    def to_proc
+      processes = map(&:to_proc)
+      lambda { |value| processes.reduce(value) { |v, p| p.call(v) } }
+    end
+
+    def inspect
+      "#<#{instance_id} #{owner} [#{map(&:inspect) * ', '}]>"
+    end
+  end
+end

data/lib/ordinary/version.rb

@@ -0,0 +1,3 @@
+module Ordinary
+  VERSION = '0.0.1'
+end

data/ordinary.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ordinary/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ordinary'
+  spec.version       = Ordinary::VERSION
+  spec.authors       = ['Takahiro Kondo']
+  spec.email         = ['heartery@gmail.com']
+  spec.description   = %q{It normalizes nondistructively specified attributes of any model}
+  spec.summary       = %q{Normalizer for any model}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'activemodel'
+end

data/spec/ordinary/builder_spec.rb

@@ -0,0 +1,137 @@
+require 'ordinary/builder'
+
+describe Ordinary::Builder do
+  describe '#context' do
+    subject { described_class.new { }.context }
+
+    it          { should be_an(Ordinary::Builder::Context.current) }
+    its(:block) { should_not be_nil }
+  end
+
+  describe '#build' do
+    it '' do
+    end
+
+    context '' do
+      # it '' do
+      #   build = lambda { a }
+      #   builder = Ordinary::Builder.new(build)
+      #   builder.build
+      # end
+    end
+  end
+end
+
+describe Ordinary::Builder::Context do
+  before { described_class.__send__(:update, Set.new) }
+
+  def change_for_current_ancestors(*modules)
+    change(described_class, :current) do
+      described_class.current.ancestors.select { |mod| modules.include?(mod) }
+    end
+  end
+
+  def change_for_modules
+    change(described_class, :modules)
+  end
+
+  describe '.register' do
+    it do
+      expect {
+        described_class.register(Math)
+      }.to change_for_current_ancestors(Math).from([]).to([Math])
+    end
+
+    it do
+      expect {
+        described_class.register(Math)
+      }.to change_for_modules.from(Set.new).to(Set.new([Math]))
+    end
+  end
+
+  describe '.unregister' do
+    before { described_class.register(Math) }
+
+    it do
+      expect {
+        described_class.unregister(Math)
+      }.to change_for_current_ancestors(Math).from([Math]).to([])
+    end
+
+    it do
+      expect {
+        described_class.unregister(Math)
+      }.to change_for_modules.from(Set.new([Math])).to(Set.new)
+    end
+  end
+
+  describe '.new' do
+    before do
+      @original = described_class.current
+      described_class.instance_variable_set(:@current, Class.new)
+    end
+
+    after do
+      described_class.instance_variable_set(:@current, @original)
+    end
+
+    subject { described_class.new }
+
+    it { should be_a(described_class.current) }
+
+    it "should call #{described_class}.current.new with same arguments and same block" do
+      described_class.current.should_receive(:new).with('arg1', 'arg2').and_yield
+      described_class.new('arg1', 'arg2') { }
+    end
+  end
+
+  describe '#block' do
+    let (:sample_block) { lambda { } }
+
+    subject { context.block }
+
+    context 'with a block at construction' do
+      let (:context) { described_class.new(sample_block) }
+
+      it            { should be_an(Ordinary::Unit) }
+      its(:process) { should be(sample_block) }
+    end
+
+    context 'with no block at construction' do
+      let (:context) { described_class.new }
+
+      it { expect { subject }.to raise_error(Ordinary::Builder::BlockNotGiven) }
+    end
+  end
+
+  describe '#undefined_method' do
+    it do
+      expect {
+        described_class.new.undefined_method
+      }.to raise_error(Ordinary::Builder::UnitNotDefined, "`undefined_method' unit is not defined")
+    end
+  end
+
+  describe '#inspect' do
+    let (:header)      { "#{described_class.name}:0x%014x" % (context.object_id << 1) }
+    let (:module_list) { modules.map(&:name).sort * ', ' }
+    let (:modules)     { [Math, Enumerable] }
+
+    subject { context.inspect }
+
+    before { described_class.register(*modules) }
+    after  { described_class.unregister(*modules) }
+
+    context 'with a block at construction' do
+      let (:context) { described_class.new(lambda { }) }
+
+      it { should be == "#<#{header} [#{module_list}] with a block>" }
+    end
+
+    context 'with no block at construction' do
+      let (:context) { described_class.new }
+
+      it { should be == "#<#{header} [#{module_list}]>" }
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ordinary
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Takahiro Kondo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It normalizes nondistructively specified attributes of any model
+email:
+- heartery@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ordinary.rb
+- lib/ordinary/builder.rb
+- lib/ordinary/module.rb
+- lib/ordinary/normalizer.rb
+- lib/ordinary/unit.rb
+- lib/ordinary/version.rb
+- ordinary.gemspec
+- spec/ordinary/builder_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Normalizer for any model
+test_files:
+- spec/ordinary/builder_spec.rb