formality 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Arun Srinivasan
+
+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,253 @@
+# Formality
+
+Form objects. For rails.
+
+    gem install formality
+
+Forms have both data and behavior. Sounds suspiciously like they should be
+objects. Let's make them so.
+
+Additionally, let's get all that validation logic out of the ORM. Enforcing
+data integrity is one thing; making sure that you get either a phone number or
+an email from a user is another.
+
+## Quick Example
+
+Let's make a signup form.
+
+```ruby
+class SignupForm
+  include Formality
+
+  attribute :email
+  attribute :password
+  attribute :password_confirmation
+
+  validates_presence_of :email, :password, :password_confirmation
+  validates_confirmation_of :password
+end
+```
+
+In, say, a UsersController:
+
+```ruby
+class UsersController < ApplicaationController
+  def new
+    @form = SignupForm.new
+  end
+
+  def create
+    @form = SignupForm.assign params[:signup_form]
+
+    @form.valid do
+      User.create! @form.attributes
+    end
+
+    @form.invalid do
+      render :new
+    end
+  end
+end
+```
+
+In the view:
+
+```haml
+= form_for @form do |f|
+  = f.text_field :email, :placeholder => "Email"
+  = f.password_field :password, :placeholder => "Password"
+  = f.password_field :password_confirmation, :placeholder => "Confirm Password"
+  = f.submit "Sign up!"
+```
+
+## More docs
+
+#### Attributes
+
+Use the `attribute` class method to declare attributes. It accepts a `:default`
+option.
+
+```ruby
+class TodoForm
+  include Formality
+
+  attribute :description
+  attribute :done, :default => false
+end
+
+default = TodoForm.new
+default.description    #=> nil
+default.done           #=> false
+```
+
+`assign` is available as a class or instance method, and will:
+
+1. Assign any declared attributes from the hash it receives.
+2. Assign an `:id` if one is present, whether declared or not (this allows us
+   to get some nice behavior when working with models).
+3. Return the form object.
+
+```ruby
+# Continuing using the TodoForm
+
+form = TodoForm.assign :id => 1, :description => "Buy some milk"
+# or
+form = TodoForm.new.assign :id => 1, :description => "Buy some milk"
+
+form.id          #=> 1
+form.description #=> "Buy some milk"
+form.done        #=> false
+```
+
+`attributes` gets you a Hash of the attributes:
+
+```ruby
+form = TodoForm.assign :id => 1, :description => "Buy some milk"
+
+form.attributes #=> {"description" => "Buy some milk", "done" => false}
+
+# It's an ActiveSupport::HashWithIndifferentAccess, so:
+attrs = form.attributes
+attrs[:description] == attrs["description"] == "Buy some milk"
+```
+
+`attribute_names` returns an Array of attribute names:
+
+```ruby
+form = TodoForm.new
+form.attribute_names #=> ["description", "done"]
+```
+
+#### Validations
+
+This one's easy to write docs for, as they are [already
+written][validddocs].
+
+You get all your standard ActiveModel validations to play with:
+
+```ruby
+class SignupForm
+  include Formality
+
+  attribute :email
+  attribute :password
+  attribute :password_confirmation
+
+  validates_presence_of :email, :password, :password_confirmation,
+    :message => "can't be blank"
+  validates_confirmation_of :password,
+    :message => "confirmation mismatch"
+end
+
+form = SignupForm.assign :password => "123", :password_confirmation => "456"
+form.valid?            #=> false
+form.invalid?          #=> true
+form.errors[:email]    #=> ["can't be blank"]
+form.errors[:password] #=> ["confirmation mismatch"]
+```
+
+You can, of course, use `:valid?` and `:invalid?` directly, but Formality also
+provides with a little bit of sugar:
+
+```ruby
+form = SignupForm.assign(some_attrs_from_somewhere)
+
+form.valid do
+  # this block will run only if the form is valid
+end
+
+form.invalid do
+  # this block will run only if the form is NOT valid
+end
+```
+
+It's a couple of lines longer than `if form.valid?...else...end`, but I feel it
+reads a little more clearly. Use it if you like it, don't if you don't.
+
+#### Working With Models
+
+The `from_model` class method builds a from object from an associated model.
+The model object must have an `attributes` method (in case you're looking at
+using this with something that's not ActiveRecord).
+
+The `model` class method lets you specify which model the form object
+represents. This lets `form_for` generate the right resourceful routes for your
+object from the form object itself.
+
+```ruby
+# config.routes.rb
+resources :todos
+
+# models/todo.rb
+class Todo < ActiveRecord::Base; end
+
+# models/forms/todo_form.rb (or wherever you want to put it)
+class TodoForm
+  include Formality
+
+  model :todo
+
+  attribute :description
+  attribute :done, :default => false
+end
+
+todo = Todo.create!(:description => "Feed the dog")
+todo.id          #=> 42 (or whatever)
+
+form = TodoForm.from_model(todo)
+form.id          #=> 42
+form.description #=> "Feed the dog"
+form.done        #=> false
+
+# Now, when you pass your form into `form_for`, it will
+# automatically create a form that points to "/todos/42"
+# with the method set to put.
+```
+
+#### Nesting
+
+Use `nest_many` or `nest_one` to declare nested form objects. This will define
+reader and writer methods such that the form object will work cleanly with
+a `fields_for` call.
+
+If you also add a `:from_model_attribute` option, nested form objects will get
+correctly populated when you use `from_model`.
+
+```ruby
+Question = Struct.new(:id, :text, :answers) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+Answer = Struct.new(:id, :text) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+class QuestionForm
+  include Formality
+  attribute :text
+  nest_many :answer_forms, :from_model_attribute => :answers
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+class AnswerForm
+  include Formality
+  attribute :text
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+question = Question.new(1, "Question 1")
+question.answers = [Answer.new(1, "Answer 1"), Answer.new(2, "Answer 2")]
+
+form = QuestionForm.from_model(question)
+form.attributes #=> {"text" => "Question 1",
+                     "answer_forms_attributes" => [{"text"=>"Answer 1"},
+                                                   {"text"=>"Answer 2"}]}
+
+form.answer_forms[0].id #=> 1
+form.answer_forms[1].id #=> 2
+```
+
+I think there are still maybe some API kinks to work out with the nested forms,
+but this gets it most of the way there.
+
+[validdocs]: http://guides.rubyonrails.org/active_record_validations_callbacks.html

data/Rakefile

@@ -0,0 +1,38 @@
+$:.push("lib")
+require "formality"
+
+desc "Run the tests"
+task :test do
+  require "tst"
+  Tst.run "test/*.rb",
+    :load_paths => ['.', 'lib'],
+    :reporter => Tst::Reporters::Pretty.new
+end
+
+NAME = "formality"
+VERSION = Formality::VERSION
+
+namespace :gem do
+  desc 'Clean up generated files'
+  task :clean do
+    sh 'rm -rf pkg'
+  end
+
+  desc "Build the gem"
+  task :build => :clean do
+    sh "mkdir pkg"
+    sh "gem build #{NAME}.gemspec"
+    sh "mv #{NAME}-#{VERSION}.gem pkg/"
+  end
+
+  desc "Release v#{VERSION}"
+  task :release => :build do
+    sh "git commit --allow-empty -a -m 'Release #{VERSION}'"
+    sh "git tag v#{VERSION}"
+    sh "git push origin master"
+    sh "git push origin v#{VERSION}"
+    sh "gem push pkg/#{NAME}-#{VERSION}.gem"
+  end
+end
+
+task :default => :test

data/test/attributes.rb

@@ -0,0 +1,89 @@
+require 'test/lint'
+require 'formality'
+
+class ::Form
+  include Formality
+  attribute :no_default
+  attribute :answer, :default => 42
+end
+
+lint(Form.new)
+
+tst ".attribute defines reader and writer" do
+  assert Form.new.respond_to? :answer
+  assert Form.new.respond_to? :answer=
+end
+
+tst "an attribute without a :default defaults to nil" do
+  assert_equal nil, Form.new.no_default
+end
+
+tst ":default option sets a default value" do
+  assert_equal 42, Form.new.answer
+end
+
+tst "#attribute_names returns an Array of attribute names" do
+  assert_equal ["no_default", "answer"], Form.new.attribute_names
+end
+
+tst "#attributes returns a HashWithIndifferentAccess" do
+  form = Form.new
+  assert ActiveSupport::HashWithIndifferentAccess === form.attributes
+end
+
+tst "#attributes hash contains all the attribute values" do
+  form = Form.new
+  assert_equal nil, form.attributes[:no_default]
+  assert_equal 42, form.attributes[:answer]
+end
+
+tst "#attribute? returns true if the attribute was declared" do
+  form = Form.new
+  assert form.attribute?(:answer)
+  assert form.attribute?(:no_default)
+  assert form.attribute?("answer")
+  assert form.attribute?("no_default")
+end
+
+tst "#assign assigns attribute values" do
+  form = Form.new
+  form.assign :answer => "hello", :no_default => "some value"
+
+  assert_equal "some value", form.attributes[:no_default]
+  assert_equal "hello", form.attributes[:answer]
+end
+
+tst "#assign returns the form instance for chaining/assignment convenience" do
+  form = Form.new
+  the_same = form.assign :answer => "hello", :no_default => "some value"
+
+  assert_equal form, the_same
+end
+
+
+tst "#assign does not assign undeclared attributes" do
+  form = Form.new
+  def form.undeclared=(*args) raise("shouldn't get here") end
+  form.assign(:undeclared => 123,
+              :answer => "hello",
+              :no_default => "some value")
+
+  assert_equal "some value", form.attributes[:no_default]
+  assert_equal "hello", form.attributes[:answer]
+end
+
+tst "#assign will assign to @id if an :id key comes in" do
+  form = Form.new
+  form.assign :id => "123", :answer => "hello", :no_default => "some value"
+  assert_equal "123", form.id
+end
+
+tst ".assign: just a thin wrapper to not have to call new" do
+  form = Form.assign :answer => "hello", :no_default => "some value"
+
+  assert form.kind_of?(Form)
+  assert_equal "hello", form.answer
+  assert_equal "some value", form.no_default
+end
+
+Object.send(:remove_const, :Form)

data/test/compliance.rb

@@ -0,0 +1,13 @@
+require 'test/lint'
+require 'formality'
+
+#
+# Run the ActiveModel::Lint tests on a fresh class
+# that includes Formality.
+#
+
+class Form
+  include Formality
+end
+
+lint(Form.new)

data/test/lint.rb

@@ -0,0 +1,77 @@
+#
+# Checks `model` for ActiveModel compliance.
+#
+# The tests are ported directly from ActiveModel::Lint
+#
+
+def lint(model)
+  tst "responds to :to_key" do
+    assert model.respond_to? :to_key
+  end
+
+  tst ":to_key returns nil when :persisted? returns false" do
+    form = model
+    def form.persisted?; false end
+    assert_equal nil, form.to_key
+  end
+
+  tst "responds to :to_param" do
+    assert model.respond_to? :to_param
+  end
+
+  tst ":to_param returns nil when :persisted? returns false" do
+    form = model
+    def form.persisted?; false end
+    assert_equal nil, form.to_param
+  end
+
+  tst "responds to :to_partial_path" do
+    assert model.respond_to? :to_partial_path
+  end
+
+  tst ":to_partial_path returns a String" do
+    assert String === model.to_partial_path
+  end
+
+  tst "responds to :valid?" do
+    assert model.respond_to? :valid?
+  end
+
+  tst ":valid? returns a Boolean" do
+    valid = model.valid?
+    assert valid === true || valid === false
+  end
+
+  tst "responds to :persisted?" do
+    assert model.respond_to? :persisted?
+  end
+
+  tst ":persisted? returns a Boolean" do
+    persisted = model.persisted?
+    assert persisted === true || persisted === false
+  end
+
+  tst "responds to :model_name" do
+    assert model.class.respond_to? :model_name
+  end
+
+  tst ":model_name returns a string with convenience methods" do
+    name = model.class.model_name
+    assert String === name
+    assert String === name.human
+    assert String === name.singular
+    assert String === name.plural
+  end
+
+  tst "responds to :errors" do
+    assert model.respond_to? :errors
+  end
+
+  tst "error#[] returns an Array" do
+    assert Array === model.errors[:hello]
+  end
+
+  tst "errors#full_messages returns an Array" do
+    assert Array === model.errors.full_messages
+  end
+end

data/test/nest_many.rb

@@ -0,0 +1,116 @@
+require 'test/lint'
+require 'formality'
+
+::Question = Struct.new(:id, :text, :answers) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+::Answer = Struct.new(:id, :text) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+class ::QuestionForm
+  include Formality
+  attribute :text
+  nest_many :answer_forms, :from_model_attribute => :answers
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+class ::AnswerForm
+  include Formality
+  attribute :text
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+lint(AnswerForm.new)
+lint(QuestionForm.new)
+
+tst ".nest_many: defines an '<assoc>' reader" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_forms)
+end
+
+tst ".nest_many: defines an '<assoc>_attributes' reader" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_forms_attributes)
+end
+
+tst ".nest_many: reader defaults to an empty array" do
+  form = QuestionForm.new
+  assert_equal [], form.answer_forms
+end
+
+tst ".nest_many: defines an '<assoc>_attributes=' writer" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_forms_attributes=)
+end
+
+tst ".nest_many: reader returns an Array of child form objects" do
+  form = QuestionForm.new
+  form.answer_forms_attributes = [{:text => "first"}]
+  answer_form = form.answer_forms.first
+
+  assert answer_form.kind_of?(AnswerForm)
+  assert_equal "first", answer_form.text
+end
+
+tst "#attributes: includes the nested form's attributes" do
+  form = QuestionForm.new
+  form.assign :answer_forms_attributes => [{:text => "first"}]
+
+
+  expected = {"text" => nil,
+              "answer_forms_attributes" => [{"text" => "first"}]}
+
+  assert_equal expected, form.attributes
+end
+
+tst "#valid?: returns false if any nested forms are invalid" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_forms_attributes = [{:text => ""}]
+
+  assert_equal false, form.valid?
+end
+
+tst "valid?: sets errors on the nested forms" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_forms_attributes = [{:text => ""}]
+  form.valid?
+  answer_form = form.answer_forms.first
+
+  assert_equal ["can't be empty"], answer_form.errors[:text]
+end
+
+tst "#invalid?: returns true if any nested forms are invalid" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_forms_attributes = [{:text => ""}]
+
+  assert_equal true, form.invalid?
+end
+
+tst "#invalid?: sets errors on the nested forms" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_forms_attributes = [{:text => ""}]
+  form.invalid?
+  answer_form = form.answer_forms.first
+
+  assert_equal ["can't be empty"], answer_form.errors[:text]
+end
+
+tst "#from_model: assigns to nested form from nested models" do
+  question = Question.new(1, "Question 1")
+  question.answers = [Answer.new(1, "Answer 1"), Answer.new(2, "Answer 2")]
+  form = QuestionForm.from_model(question)
+
+  answer_form_1, answer_form_2 = form.answer_forms
+
+  assert_equal 1, answer_form_1.id
+  assert_equal "Answer 1", answer_form_1.text
+  assert_equal 2, answer_form_2.id
+  assert_equal "Answer 2", answer_form_2.text
+end
+
+Object.send(:remove_const, :QuestionForm)
+Object.send(:remove_const, :AnswerForm)
+Object.send(:remove_const, :Question)
+Object.send(:remove_const, :Answer)

data/test/nest_one.rb

@@ -0,0 +1,106 @@
+require 'test/lint'
+require 'formality'
+
+::Question = Struct.new(:id, :text, :answer) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+::Answer = Struct.new(:id, :text) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+
+class ::QuestionForm
+  include Formality
+  attribute :text
+  nest_one :answer_form, :from_model_attribute => :answer
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+class ::AnswerForm
+  include Formality
+  attribute :text
+  validates_presence_of :text, :message => "can't be empty"
+end
+
+tst ".nest_one: defines an '<assoc>' reader" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_form)
+end
+
+tst ".nest_one: defines an '<assoc>_attributes' reader" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_form_attributes)
+end
+
+tst ".nest_one: reader defaults to nil" do
+  form = QuestionForm.new
+  assert_equal nil, form.answer_form
+end
+
+tst ".nest_one: defines an '<assoc>_attributes=' writer" do
+  form = QuestionForm.new
+  assert form.respond_to?(:answer_form_attributes=)
+end
+
+tst ".nest_many: reader returns a child form object" do
+  form = QuestionForm.new
+  form.answer_form_attributes = {:text => "first"}
+
+  assert form.answer_form.kind_of?(AnswerForm)
+  assert_equal "first", form.answer_form.text
+end
+
+tst "#attributes: includes the nested form's attributes" do
+  form = QuestionForm.new
+  form.answer_form_attributes = {:text => "first"}
+
+  expected = {"text" => nil,
+              "answer_form_attributes" => {"text" => "first"}}
+
+  assert_equal expected, form.attributes
+end
+
+tst "#valid?: returns false if the nested form is invalid" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_form_attributes = {:text => ""}
+
+  assert_equal false, form.valid?
+end
+
+tst "valid?: sets errors on the nested form" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_form_attributes = {:text => ""}
+  form.valid?
+
+  assert_equal ["can't be empty"], form.answer_form.errors[:text]
+end
+
+tst "#invalid?: returns true if the nested form is invalid" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_form_attributes = {:text => ""}
+
+  assert_equal true, form.invalid?
+end
+
+tst "invalid?: sets errors on the nested form" do
+  form = QuestionForm.new.assign :text => "question text"
+  form.answer_form_attributes = {:text => ""}
+  form.invalid?
+
+  assert_equal ["can't be empty"], form.answer_form.errors[:text]
+end
+
+tst "#from_model: assigns to nested form from nested model" do
+  question = Question.new(1, "Question 1")
+  question.answer = Answer.new(1, "Answer 1")
+  form = QuestionForm.from_model(question)
+
+  assert_equal 1, form.answer_form.id
+  assert_equal "Answer 1", form.answer_form.text
+end
+
+Object.send(:remove_const, :QuestionForm)
+Object.send(:remove_const, :AnswerForm)
+Object.send(:remove_const, :Question)
+Object.send(:remove_const, :Answer)

data/test/rails.rb

@@ -0,0 +1,88 @@
+require 'test/lint'
+require 'formality'
+require 'action_dispatch/routing'
+
+#
+# Some tests to make sure that Formality forms work
+# well with the Rails view helpers (:form_for, et al.)
+#
+
+# A little fake AR-like model
+::Person = Struct.new(:id, :first, :last) do
+  def attributes; Hash[members.zip(values)] end
+end
+
+# Our intrepid hero
+class ::PersonForm
+  include Formality
+  attribute :first
+  attribute :last
+end
+
+lint(PersonForm.new)
+
+# For testing correct route generation delegation
+class Route
+  include ActionDispatch::Routing::UrlFor
+
+  def self.url_for(*args)
+    new.url_for(*args)
+  end
+
+  def person_url(person) "person/#{person.id}" end
+  def people_url; "people" end
+end
+
+tst "#from_model assigns form's attributes" do
+  person = Person.new(1, "Arthur", "Dent")
+  form = PersonForm.from_model(person)
+
+  assert_equal "Arthur", form.first
+  assert_equal "Dent", form.last
+end
+
+tst "#from_model assigns form's id" do
+  person = Person.new(1, "Arthur", "Dent")
+  form = PersonForm.from_model(person)
+
+  assert_equal 1, form.id
+end
+
+tst "just to confirm, :id doesn't show up in #attributes" do
+  person = Person.new(1, "Arthur", "Dent")
+  form = PersonForm.from_model(person)
+
+  assert !form.attributes.has_key?(:id)
+  assert !form.attributes.has_key?("id")
+end
+
+tst "#persisted? is true if there's an id present" do
+  person = Person.new(1, "Arthur", "Dent")
+  form = PersonForm.from_model(person)
+
+  assert form.persisted?
+end
+
+tst ".model method lets you set the model for the form" do
+  klass = PersonForm.dup
+  klass.model :person
+
+  assert_equal "Person", klass.model_name
+  assert_equal "people", klass.model_name.route_key
+  assert_equal "person", klass.model_name.singular_route_key
+end
+
+tst ".model lets rails generate routes for underlying model" do
+  klass = PersonForm.dup
+  klass.model :person
+
+  dent = Person.new(1, "Arthur", "Dent")
+  dent_form = klass.from_model(dent)
+  anon_form = klass.new
+
+  assert_equal "person/1", Route.url_for(dent_form)
+  assert_equal "people", Route.url_for(anon_form)
+end
+
+Object.send(:remove_const, :Person)
+Object.send(:remove_const, :PersonForm)

data/test/valid.rb

@@ -0,0 +1,91 @@
+require 'test/lint'
+require 'formality'
+
+# A form class with validations
+class ::LoginForm
+  include Formality
+
+  attribute :email
+  attribute :password
+  attribute :password_confirmation
+
+  validates_presence_of :email, :password, :password_confirmation,
+    :message => "can't be empty"
+
+  validates_confirmation_of :password,
+    :message => "don't match"
+end
+
+# Check that we still pass ActiveModel::Lint
+lint(LoginForm.new)
+
+# A little helper to generate valid attributes
+def valid_attributes
+  { :email => 'test@example.com',
+    :password => '123',
+    :password_confirmation => '123' }
+end
+
+tst "the builtin ActiveModel validations exist" do
+  [ :validates, :validates!, :validate, :validates_each,
+    :validates_confirmation_of, :validates_exclusion_of,
+    :validates_inclusion_of, :validates_format_of, :validates_length_of,
+    :validates_numericality_of, :validates_presence_of, :validates_with
+  ].each do |validator|
+    assert LoginForm.respond_to?(validator)
+  end
+end
+
+tst "#valid? and #invalid? do the right thing when conditions ARE NOT met" do
+  form = LoginForm.new
+  assert_equal false, form.valid?
+  assert_equal true, form.invalid?
+end
+
+tst "#valid? and #invalid? do the right thing when conditions ARE met" do
+  form = LoginForm.new.assign(valid_attributes)
+  assert_equal true, form.valid?
+  assert_equal false, form.invalid?
+end
+
+tst "#errors contains the error messages" do
+  form = LoginForm.new
+
+  assert_equal false, form.valid?
+  assert_equal ["can't be empty"], form.errors[:email]
+  assert_equal ["can't be empty"], form.errors[:password]
+  assert_equal ["can't be empty"], form.errors[:password_confirmation]
+
+  form.email = "test@example.com"
+  form.password = "123"
+  form.password_confirmation = "1234"
+
+  assert_equal false, form.valid?
+  assert_equal ["don't match"], form.errors[:password]
+end
+
+tst "#valid runs its block if the form is valid" do
+  form = LoginForm.new.assign(valid_attributes)
+  called = 0
+  form.valid { called += 1 }
+  assert_equal 1, called
+end
+
+tst "#valid does NOT run its block if the form is invalid" do
+  form = LoginForm.new
+  form.valid { raise("it's an error if you get here") }
+end
+
+tst "#invalid runs its block if the form is invalid" do
+  form = LoginForm.new
+  called = 0
+  form.invalid { called += 1 }
+  assert_equal 1, called
+end
+
+tst "#invalid does NOT run its block if the form is valid" do
+  form = LoginForm.new.assign(valid_attributes)
+  form.invalid { raise("it's an error if you get here") }
+end
+
+Object.send(:remove_const, :LoginForm)

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: formality
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Arun Srinivasan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70175687157900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70175687157900
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70175687157400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70175687157400
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: &70175687156940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70175687156940
+- !ruby/object:Gem::Dependency
+  name: tst
+  requirement: &70175687156560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70175687156560
+description: ! 'ActiveModel-compliant form objects for rails app.
+
+
+  Forms have data and behavior. Let them be the
+
+  objects they want to be. Plus, get presentation-
+
+  specific validation logic out of your models.
+
+'
+email: satchmorun@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+- test/attributes.rb
+- test/compliance.rb
+- test/lint.rb
+- test/nest_many.rb
+- test/nest_one.rb
+- test/rails.rb
+- test/valid.rb
+homepage: https://github.com/satchmorun/formality
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Form objects for your rails app.
+test_files:
+- test/attributes.rb
+- test/compliance.rb
+- test/lint.rb
+- test/nest_many.rb
+- test/nest_one.rb
+- test/rails.rb
+- test/valid.rb