scratch 0.1.1 → 0.1.2

data/README.md

@@ -0,0 +1,117 @@
+# Scratch
+
+After seeing a presentation (by [Gary Haran]) on Rails engines and
+reading a [certain blog post], I decided that enough was enough! I had
+some Rails induced itches that needed some much needed relief. Thus here
+is Scratch, a library which tries to fix a bunch of Rails' most
+insignificant shortcomings.
+
+## Features
+
+ * The normalize model mixin
+ * A few core extensions
+
+## Installation
+
+Simply add Scratch to your Gemfile and bundle it up:
+
+```ruby
+gem 'scratch'
+```
+
+## Usage
+
+### Mixins (or Concerns if you prefer the Rails vocabulary)
+
+These mixins are included in ActiveRecord with this gem, they could
+(theoretically) be used inside any other classes, but this hasn't been
+tested (nor documented) yet.
+
+#### Normalize
+
+The `normalize` method help you create callbacks to normalize some
+attributes in a simple declarative manner.
+
+Say you'd like to set all blank attributes to nil before validation, you
+could do:
+
+```ruby
+normalize before: :validation, when: :blank?, set: nil
+```
+
+The `before` option default to `:validation` so it can be omitted in
+that case. You can also pass a block to `normalize` that will be given
+the value of the attribute and should return it's normalized form:
+
+```ruby
+normalize { |value| value.strip }
+```
+
+The block in that example is a common pattern that can be replaced by
+the `method` option:
+
+```ruby
+normalize method: :strip
+```
+
+There's two specialized mixins which are variant of the above
+examples...
+
+##### Stripify
+
+The `stripify` method will strip all attributes, it also support all of
+normalize options. Here's an example using the `except` option:
+
+```ruby
+stripify except: :foo
+```
+
+##### Nilify
+
+Don't like odd numbers, here's a solution:
+
+```ruby
+nilify only: [:foo, :bar], when: :odd?, before: :save
+```
+
+### Core Extensions
+
+#### Array
+
+Want to use `join` for user facing stuff but doesn't want to clean up
+the array yourself, use `strip_join`:
+
+```ruby
+[1, 2, nil, '', '    ' , '   3  '].strip_join ', '
+#=> "1, 2, 3"
+```
+
+#### Hash
+
+Have many keys to look-up and need the first one available, use `fetch_or`:
+
+```ruby
+h = { a: 1, b: 2, c: 3 }
+h.fetch_or :e, :d, :c
+#=> 3
+# also support a `default` option...
+h.fetch_or :x, :y, :z, default: nil
+#=> nil
+# when no default is given, act like `fetch` and raise a `KeyError`
+```
+
+You're stuck with a hash having arrays as values and need to invert it?
+
+```ruby
+h = { west_coast: %w(WA OR CA AZ), east_east: %w(ME VT NY NJ) }
+y = h.invert_splat
+y['NJ']
+#=> :east_coast
+```
+
+## License
+
+This project rocks and uses MIT-LICENSE!
+
+[Gary Haran]: https://github.com/garyharan
+[certain blog post]: http://gilesbowkett.blogspot.in/2012/02/rails-went-off-rails-why-im-rebuilding.html

data/lib/scratch/concerns/nilify.rb

@@ -7,13 +7,13 @@ module Scratch::Concerns::Nilify
     def nilify(options = {})
       options = HashWithIndifferentAccess.new options
 
-      options[:before]    ||= :validation
-      options[:predicate] ||= :blank?
-      options[:name]      ||=
-        "nilify_before_#{options[:before]}_if_#{options[:predicate]}"
+      options[:before] ||= :validation
+      options[:when]   ||= :blank?
+      options[:name]   ||=
+        "nilify_before_#{options[:before]}_when_#{options[:when]}"
 
       instance_eval do
-        normalize options.merge(default: nil)
+        normalize options.merge(set: nil)
       end
     end
   end

data/lib/scratch/concerns/normalize.rb

@@ -1,3 +1,4 @@
+require 'scratch/utils'
 
 # == Normalize Callbacks
 #
@@ -14,12 +15,6 @@ module Scratch::Concerns::Normalize
       if self == ActiveRecord::Base
         -> base { base.content_columns.map(&:name) }
       end
-
-    cattr_accessor :normalize_default_callback_format
-    self.normalize_default_callback_format =
-      if self == ActiveRecord::Base
-        'before_%s'
-      end
   end
 
   module ClassMethods
@@ -27,28 +22,37 @@ module Scratch::Concerns::Normalize
       callback_options = HashWithIndifferentAccess.new options
 
       options   = callback_options.slice!(:if, :unless)
-      default   = options[:default]
+      set       = options[:set]
       method    = options[:method]
-      predicate = Array.wrap options[:predicate]
-      callback  = options.fetch_or(:before, :after, :callback,
-                                   default: :validation)
+      predicate = Array.wrap options[:when]
+
+      trigger_format = options[:trigger_format] || '%s_%s'
 
-      callback_method = options[:name] ||
-        "normalize_before_#{callback}" +
-        (predicate.empty? ? '' : "_when_#{predicate}")
+      trigger = options[:trigger] ||
+        (options[:before] ? trigger_format % [:before , options[:before]] :
+         options[:after]  ? trigger_format % [:after  , options[:after]]  :
+         raise(ArgumentError, 'missing option, you must specify one of: ' +
+               'before, after or trigger'))
+
+      unless options.has_key?(:set) || method || block_given?
+        raise(ArgumentError, 'missing option or block, ' +
+              'you must give a block or specify one of: set or method')
+      end
+
+      callback = options[:name] || Scratch::Utils.gensym
 
       attributes = options[:attributes] ||
         Scratch::Options
           .except_only(options, normalize_default_attributes_source[self])
 
       instance_eval do
-        define_method callback_method do
+        define_method callback do
           attributes.each do |attribute|
             value = send(attribute)
             if predicate.empty? || value.send(*predicate)
               value =
-                if options.has_key? :default
-                  default
+                if options.has_key? :set
+                  set
                 elsif method
                   value.send method
                 else
@@ -61,11 +65,7 @@ module Scratch::Concerns::Normalize
         end
       end
 
-      callback_format = options[:callback_format] ||
-        normalize_default_callback_format
-
-      callback = callback_format ? callback_format % callback : callback
-      send callback, callback_method
+      send trigger, callback
     end
   end
 

data/lib/scratch/utils.rb

@@ -0,0 +1,9 @@
+require 'securerandom'
+
+module Scratch::Utils
+
+  def self.gensym
+    ('_' + SecureRandom.uuid.gsub('-', '_')).to_sym
+  end
+
+end

data/lib/scratch/version.rb

@@ -1,3 +1,3 @@
 module Scratch
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/test/dummy/app/models/nilify_test_model.rb

@@ -2,6 +2,6 @@
 class NilifyTestModel < ActiveRecord::Base
 
   nilify except: [:foo, :baz]
-  nilify only: :baz, predicate: :odd?, before: :save
+  nilify only: :baz, when: :odd?, before: :save
 
 end

data/test/dummy/app/models/normalize_test_model.rb

@@ -0,0 +1,18 @@
+
+class NormalizeTestModel < ActiveRecord::Base
+
+  normalize(after: :save,
+            only:  :foo,
+            set:   'foo',
+            name:  :normalize_after_save)
+
+  normalize(before: :validation,
+            only:   :bar,
+            set:    0)
+
+  normalize(trigger: :before_save,
+            only:    :baz) do |value|
+    value * 2
+  end
+
+end

data/test/dummy/db/migrate/20120329194042_create_normalize_test_models.rb

@@ -0,0 +1,9 @@
+class CreateNormalizeTestModels < ActiveRecord::Migration
+  def change
+    create_table :normalize_test_models do |t|
+      t.string :foo
+      t.integer :bar
+      t.text :baz
+    end
+  end
+end

data/test/dummy/db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20120226052737) do
+ActiveRecord::Schema.define(:version => 20120329194042) do
 
   create_table "nilify_test_models", :force => true do |t|
     t.string  "foo"
@@ -19,6 +19,12 @@ ActiveRecord::Schema.define(:version => 20120226052737) do
     t.integer "baz"
   end
 
+  create_table "normalize_test_models", :force => true do |t|
+    t.string  "foo"
+    t.integer "bar"
+    t.text    "baz"
+  end
+
   create_table "stripify_test_models", :force => true do |t|
     t.string "foo"
     t.string "bar"

data/test/dummy/log/development.log

@@ -113,3 +113,91 @@ Migrating to CreateStripifyTestModels (20120226052737)
    (0.3ms)  SELECT version FROM "schema_migrations"
    (29.6ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226052737')
    (21.0ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226002304')
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateNilifyTestModels (20120226002304)
+Migrating to CreateStripifyTestModels (20120226052737)
+Migrating to CreateNormalizeTestModels (20120329194042)
+   (0.1ms)  select sqlite_version(*)
+   (0.1ms)  begin transaction
+   (1.9ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text, "created_at" datetime NOT NULL, "updated_at" datetime NOT NULL) 
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20120329194042')
+   (36.6ms)  commit transaction
+   (0.2ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.0ms)  PRAGMA index_list("nilify_test_models")
+   (0.0ms)  PRAGMA index_list("normalize_test_models")
+   (0.0ms)  PRAGMA index_list("stripify_test_models")
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.2ms)  select sqlite_version(*)
+   (30.2ms)  CREATE TABLE "nilify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255), "baz" integer) 
+   (29.9ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text, "created_at" datetime NOT NULL, "updated_at" datetime NOT NULL) 
+   (29.0ms)  CREATE TABLE "stripify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255)) 
+   (19.3ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (19.7ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (25.3ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120329194042')
+   (28.8ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226002304')
+   (24.7ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226052737')
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateNormalizeTestModels (20120329194042)
+   (0.0ms)  select sqlite_version(*)
+   (0.0ms)  begin transaction
+   (0.3ms)  DROP TABLE "normalize_test_models"
+   (0.1ms)  DELETE FROM "schema_migrations" WHERE "schema_migrations"."version" = '20120329194042'
+   (39.3ms)  commit transaction
+   (0.2ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.0ms)  PRAGMA index_list("nilify_test_models")
+   (0.0ms)  PRAGMA index_list("stripify_test_models")
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateNilifyTestModels (20120226002304)
+Migrating to CreateStripifyTestModels (20120226052737)
+Migrating to CreateNormalizeTestModels (20120329194042)
+   (0.1ms)  select sqlite_version(*)
+   (0.0ms)  begin transaction
+   (0.3ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text) 
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20120329194042')
+   (22.6ms)  commit transaction
+   (0.2ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.0ms)  PRAGMA index_list("nilify_test_models")
+   (0.0ms)  PRAGMA index_list("normalize_test_models")
+   (0.0ms)  PRAGMA index_list("stripify_test_models")
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.3ms)  select sqlite_version(*)
+   (19.8ms)  CREATE TABLE "nilify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255), "baz" integer) 
+   (15.7ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text) 
+   (27.5ms)  CREATE TABLE "stripify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255)) 
+   (25.5ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (16.5ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (19.0ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120329194042')
+   (27.3ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226002304')
+   (25.6ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226052737')
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.3ms)  select sqlite_version(*)
+   (31.1ms)  CREATE TABLE "nilify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255), "baz" integer) 
+   (23.5ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text) 
+   (20.5ms)  CREATE TABLE "stripify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255)) 
+   (24.5ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (26.2ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (21.2ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120329194042')
+   (16.9ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226002304')
+   (28.7ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226052737')
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.2ms)  select sqlite_version(*)
+   (29.5ms)  CREATE TABLE "nilify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255), "baz" integer) 
+   (24.8ms)  CREATE TABLE "normalize_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "baz" text) 
+   (18.6ms)  CREATE TABLE "stripify_test_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" varchar(255)) 
+   (28.1ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (25.4ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (17.2ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120329194042')
+   (17.0ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226002304')
+   (24.0ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120226052737')

data/test/dummy/log/test.log

@@ -292,3 +292,298 @@
   SQL (26.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 22
    (0.1ms)  begin transaction
    (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (4.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (42.4ms)  commit transaction
+  SQL (23.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 23
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.3ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (25.0ms)  commit transaction
+  SQL (16.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 24
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.0ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (28.6ms)  commit transaction
+  SQL (27.6ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 25
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.4ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (29.6ms)  commit transaction
+  SQL (27.6ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 1
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (21.3ms)  commit transaction
+  SQL (25.0ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 2
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 1], ["baz", ""], ["foo", ""]]
+   (27.1ms)  commit transaction
+  SQL (22.2ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 1
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.7ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (25.9ms)  commit transaction
+  SQL (18.0ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 3
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 1], ["baz", ""], ["foo", ""]]
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (22.6ms)  commit transaction
+  SQL (17.0ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 4
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 1], ["baz", ""], ["foo", ""]]
+   (27.1ms)  commit transaction
+  SQL (27.0ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 2
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.3ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (33.1ms)  commit transaction
+  SQL (26.0ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 5
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 1], ["baz", ""], ["foo", ""]]
+   (21.6ms)  commit transaction
+  SQL (15.5ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 3
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (30.0ms)  commit transaction
+  SQL (25.0ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 6
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 1], ["baz", ""], ["foo", ""]]
+   (17.5ms)  commit transaction
+  SQL (17.6ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 4
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (23.9ms)  commit transaction
+  SQL (30.7ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 7
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (24.4ms)  commit transaction
+  SQL (17.3ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 5
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.8ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (31.1ms)  commit transaction
+  SQL (25.6ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 8
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (17.1ms)  commit transaction
+  SQL (16.2ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 6
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.4ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (30.5ms)  commit transaction
+  SQL (27.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 9
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (22.4ms)  commit transaction
+  SQL (16.5ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 7
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.6ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (22.4ms)  commit transaction
+  SQL (27.2ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 10
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (25.1ms)  commit transaction
+  SQL (21.0ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 8
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.0ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (25.7ms)  commit transaction
+  SQL (26.8ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 11
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (26.2ms)  commit transaction
+  SQL (17.1ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 9
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.4ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (21.6ms)  commit transaction
+  SQL (23.7ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 12
+   (0.1ms)  begin transaction
+  SQL (0.3ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (28.9ms)  commit transaction
+  SQL (26.1ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 10
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.3ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (26.5ms)  commit transaction
+  SQL (16.4ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 13
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (16.3ms)  commit transaction
+  SQL (29.0ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 11
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.9ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (26.7ms)  commit transaction
+  SQL (28.9ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 14
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (25.1ms)  commit transaction
+  SQL (18.3ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 12
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.6ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (25.4ms)  commit transaction
+  SQL (26.6ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 15
+   (0.1ms)  begin transaction
+  SQL (0.3ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", ""], ["foo", ""]]
+   (24.9ms)  commit transaction
+  SQL (20.8ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 13
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.6ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (21.0ms)  commit transaction
+  SQL (28.9ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 16
+   (0.2ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (25.1ms)  commit transaction
+  SQL (17.8ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 14
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.2ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (43.7ms)  commit transaction
+  SQL (27.7ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 17
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.3ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (30.1ms)  commit transaction
+  SQL (19.5ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 18
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (17.0ms)  commit transaction
+  SQL (22.6ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 15
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.6ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (24.3ms)  commit transaction
+  SQL (21.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 19
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (25.5ms)  commit transaction
+  SQL (19.2ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 20
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (28.3ms)  commit transaction
+  SQL (24.0ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 16
+   (0.1ms)  begin transaction
+   (0.2ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.3ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", 1], ["foo", ""]]
+   (38.8ms)  commit transaction
+  SQL (18.9ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 21
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (16.3ms)  commit transaction
+  SQL (20.6ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 17
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.1ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", 1], ["foo", ""]]
+   (33.8ms)  commit transaction
+  SQL (17.1ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 22
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (27.3ms)  commit transaction
+  SQL (28.3ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 18
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.7ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", 1], ["foo", ""]]
+   (32.6ms)  commit transaction
+  SQL (25.4ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 23
+   (0.1ms)  begin transaction
+  SQL (0.3ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (23.0ms)  commit transaction
+  SQL (26.1ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 19
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.6ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", 1], ["foo", ""]]
+   (29.1ms)  commit transaction
+  SQL (22.2ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 24
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (21.0ms)  commit transaction
+  SQL (14.6ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 20
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.1ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (29.3ms)  commit transaction
+  SQL (22.5ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 25
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (22.4ms)  commit transaction
+  SQL (15.2ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 21
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (2.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (20.0ms)  commit transaction
+  SQL (25.5ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 26
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (26.5ms)  commit transaction
+  SQL (23.0ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 22
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (16.5ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (45.9ms)  commit transaction
+  SQL (17.3ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 27
+   (0.1ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (15.4ms)  commit transaction
+  SQL (26.5ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 23
+   (0.1ms)  begin transaction
+   (0.1ms)  rollback transaction
+   (0.1ms)  begin transaction
+  SQL (3.0ms)  INSERT INTO "nilify_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", nil], ["baz", nil], ["foo", ""]]
+   (45.8ms)  commit transaction
+  SQL (17.4ms)  DELETE FROM "nilify_test_models" WHERE "nilify_test_models"."id" = 28
+   (0.2ms)  begin transaction
+  SQL (0.2ms)  INSERT INTO "normalize_test_models" ("bar", "baz", "foo") VALUES (?, ?, ?)  [["bar", 0], ["baz", "!!"], ["foo", ""]]
+   (22.9ms)  commit transaction
+  SQL (28.9ms)  DELETE FROM "normalize_test_models" WHERE "normalize_test_models"."id" = 24
+   (0.1ms)  begin transaction
+   (0.0ms)  rollback transaction

data/test/unit/concerns/nilify_test.rb

@@ -13,8 +13,8 @@ class Scratch::Concerns::NilifyTest < Test::Unit::TestCase
   end
 
   def test_callbacks_methods_are_defined
-    assert @entity.respond_to? :nilify_before_validation_if_blank?
-    assert @entity.respond_to? :nilify_before_save_if_odd?
+    assert_respond_to @entity, :nilify_before_validation_when_blank?
+    assert_respond_to @entity, :nilify_before_save_when_odd?
   end
 
   def test_effect_of_triggering_validation_callback

data/test/unit/concerns/normalize_test.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative '../../test_helper.rb'
+
+class Scratch::Concerns::NormalizeTest < Test::Unit::TestCase
+
+  def setup
+    @entity = NormalizeTestModel.new foo: '', bar: 1, baz: '!'
+  end
+
+  def teardown
+    @entity.delete
+  end
+
+  def test_must_specify_a_trigger_for_normalize
+    assert_raise ArgumentError do
+      NormalizeTestModel.class_eval { normalize }
+    end
+  end
+
+  def test_must_specify_an_action_for_normalize
+    assert_raise ArgumentError do
+      NormalizeTestModel.class_eval { normalize trigger: :foo }
+    end
+  end
+
+  def test_callbacks_methods_are_defined
+    assert_respond_to @entity, :normalize_after_save
+  end
+
+  def test_effect_of_triggering_validation_callback
+    @entity.valid?
+    assert_equal '',  @entity.foo
+    assert_equal 0 ,  @entity.bar
+    assert_equal '!', @entity.baz
+  end
+
+  def test_effect_of_triggering_save_callback
+    @entity.save
+    assert_equal 'foo', @entity.foo
+    assert_equal 0    , @entity.bar
+    assert_equal '!!',  @entity.baz
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scratch
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-26 00:00:00.000000000 Z
+date: 2012-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &16623240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: 3.2.1
   type: :runtime
   prerelease: false
-  version_requirements: *16623240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.1
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &16622000 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,8 +37,13 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *16622000
-description: A plugin to relieve from some Rails itches.
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: See README.md file.
 email:
 - nbuduroi@gmail.com
 executables: []
@@ -56,12 +66,14 @@ files:
 - lib/scratch/core_ext/hash.rb
 - lib/scratch/concerns.rb
 - lib/scratch/options.rb
+- lib/scratch/utils.rb
 - lib/scratch/engine.rb
 - lib/tasks/scratch_tasks.rake
 - MIT-LICENSE
 - Rakefile
-- README.rdoc
+- README.md
 - test/unit/concerns/nilify_test.rb
+- test/unit/concerns/normalize_test.rb
 - test/unit/concerns/stripify_test.rb
 - test/unit/core_ext/array_test.rb
 - test/unit/core_ext/hash_test.rb
@@ -96,7 +108,9 @@ files:
 - test/dummy/db/test.sqlite3
 - test/dummy/db/migrate/20120226002304_create_nilify_test_models.rb
 - test/dummy/db/migrate/20120226052737_create_stripify_test_models.rb
+- test/dummy/db/migrate/20120329194042_create_normalize_test_models.rb
 - test/dummy/app/models/nilify_test_model.rb
+- test/dummy/app/models/normalize_test_model.rb
 - test/dummy/app/models/stripify_test_model.rb
 - test/dummy/app/helpers/application_helper.rb
 - test/dummy/app/assets/stylesheets/application.css
@@ -119,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2465014890557268721
+      hash: -2245081140959681315
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -128,15 +142,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2465014890557268721
+      hash: -2245081140959681315
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.22
 signing_key: 
 specification_version: 3
 summary: A plugin to relieve from some Rails itches.
 test_files:
 - test/unit/concerns/nilify_test.rb
+- test/unit/concerns/normalize_test.rb
 - test/unit/concerns/stripify_test.rb
 - test/unit/core_ext/array_test.rb
 - test/unit/core_ext/hash_test.rb
@@ -171,7 +186,9 @@ test_files:
 - test/dummy/db/test.sqlite3
 - test/dummy/db/migrate/20120226002304_create_nilify_test_models.rb
 - test/dummy/db/migrate/20120226052737_create_stripify_test_models.rb
+- test/dummy/db/migrate/20120329194042_create_normalize_test_models.rb
 - test/dummy/app/models/nilify_test_model.rb
+- test/dummy/app/models/normalize_test_model.rb
 - test/dummy/app/models/stripify_test_model.rb
 - test/dummy/app/helpers/application_helper.rb
 - test/dummy/app/assets/stylesheets/application.css

data/README.rdoc

@@ -1,3 +0,0 @@
-= Scratch
-
-This project rocks and uses MIT-LICENSE.