forminate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98167c9f1b4bb61b66458c8166c6c1406dc29426
+  data.tar.gz: 5e6e5c08e0467967649dba74a28677b07353ef06
+SHA512:
+  metadata.gz: 9d82544a8edb6a3a87d70d7ae76313942a73ce0242a618dcd55937dee533cfe1d3870001ca9614b4db8bf8f4f138f9aba167f55438ac1d8470d0b9b59622a74d
+  data.tar.gz: e156a1daa75023040fa9a04db1df13464d08a4afaba43718a9be20cbb7c35f0179e5e57bdb0d262b670a890a853d629be6890b5504591500fbfaef52cfad7c61

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/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mo Lawson
+
+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,32 @@
+# Forminate
+
+[![Build Status](https://travis-ci.org/molawson/forminate.png?branch=master)](https://travis-ci.org/molawson/forminate)
+[![Code Climate](https://codeclimate.com/github/molawson/forminate.png)](https://codeclimate.com/github/molawson/forminate)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'forminate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install forminate
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/forminate.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'forminate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "forminate"
+  spec.version       = Forminate::VERSION
+  spec.authors       = ["Mo Lawson"]
+  spec.email         = ["moklawson@gmail.com"]
+  spec.description   = "Form objects for Rails applications"
+  spec.summary       = "Create form objects from multiple Active Record and/or ActiveAttr models."
+  spec.homepage      = "https://github.com/molawson/forminate"
+  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_dependency "active_attr", "~> 0.8"
+  spec.add_dependency "activesupport", ">= 3.0.2", "< 4.1"
+  spec.add_dependency "client_side_validations", "~> 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.11"
+end

data/lib/forminate/client_side_validations.rb

@@ -0,0 +1,124 @@
+module ActiveModel
+  class Validator
+    # To make use of validators present on associated object, we need to be
+    # able to specify the original object that a given validator came from.
+    attr_accessor :target_object
+  end
+end
+
+module Forminate
+  # This module makes Forminate work with bcardarella's client_side_validations
+  # gem (https://github.com/bcardarella/client_side_validations).
+  #
+  # The majority of the methods contained here are overrides or alternative
+  # versions of methods in the client_side_validations gem. For the most part,
+  # they follow the shape and ideas of the original implementation, usually adding
+  # the ability to send messages to an associated object rather than the Forminate
+  # object itself.
+  module ClientSideValidations
+    extend ActiveSupport::Concern
+
+    # Where the magic happens. This overrides the client_side_validations gem's
+    # method of the same name, using Forminate's #association_validators rather
+    # than ActiveModel's _validators method. It still calls super so that it
+    # includes validations placed directly on the Forminate object.
+    def client_side_validation_hash(force = nil)
+      hash = super
+      assoc_hash = association_validators.reduce({}) do |assoc_hash, (attr, validators)|
+        unless [nil, :block].include?(attr)
+
+          validator_hash = validators.reduce(Hash.new { |h,k| h[k] = []}) do |kind_hash, validator|
+            model = validator.target_object
+            model_pattern = /^#{model.class.name.underscore}_/
+            target_attr = attr.to_s.sub(model_pattern, '').to_sym
+
+            if force.is_a? Hash
+              relevant_force = force.select { |k, v| k.to_s.match model_pattern }
+              assoc_force = relevant_force.reduce({}) do |assoc_force, (key, value)|
+                key = key.to_s.sub(model_pattern, '').to_sym
+                assoc_force.merge({ key => value })
+              end
+            else
+              assoc_force = force
+            end
+
+            if _can_use_for_client_side_validation?(model, target_attr, validator, assoc_force)
+              if client_side_hash = validator.client_side_hash(model, target_attr, extract_force_option(target_attr, assoc_force))
+                kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
+              end
+            end
+
+            kind_hash
+          end
+
+          if validator_hash.present?
+            assoc_hash.merge!(attr => validator_hash)
+          else
+            assoc_hash
+          end
+        else
+          assoc_hash
+        end
+      end
+      hash.merge assoc_hash
+    end
+
+    private
+
+    # Constructs the associated validators for use with client_side_validations.
+    # This is meant to mimic ActiveModel's #_validators method that the
+    # client_side_validations gem relies on for construction the client side
+    # validation hash.
+    def association_validators
+      associations.reduce({}) do |assoc_validators, (name, object)|
+        if should_validate_assoc?(name) && object.respond_to?(:_validators)
+          object._validators.each do |attr, validators|
+            new_validators = validators.reduce([]) do |new_validators, validator|
+              new_validator = validator.dup
+              new_validator.target_object = object
+              new_validators << new_validator
+            end
+            assoc_validators["#{name}_#{attr}".to_sym] = new_validators
+          end
+        end
+        assoc_validators
+      end
+    end
+
+    # Alternative version of the client_side_validation gem's
+    # #can_use_for_client_side_validation? method, allowing the target 'model'
+    # to be passed in as an argument.
+    def _can_use_for_client_side_validation?(model, attr, validator, force)
+      if validator_turned_off?(attr, validator, force)
+        result = false
+      else
+        result = ((model.respond_to?(:new_record?) && validator.options[:on] == (model.new_record? ? :create : :update)) || validator.options[:on].nil?)
+        result = result && validator.kind != :block
+
+        if validator.options[:if] || validator.options[:unless]
+          if result = can_force_validator?(attr, validator, force)
+            if validator.options[:if]
+              result = result && _run_conditional(model, validator.options[:if])
+            end
+            if validator.options[:unless]
+              result = result && !_run_conditional(model, validator.options[:unless])
+            end
+          end
+        end
+      end
+
+      result
+    end
+
+    # Alternative version of the client_side_validation gem's #run_conditional
+    # method, allowing the target 'model' to be passed in as an argument.
+    def _run_conditional(model, method_name_or_proc)
+      case method_name_or_proc
+      when Proc
+        method_name_or_proc.call(model)
+      else
+        model.send(method_name_or_proc)
+      end
+    end
+  end
+end

data/lib/forminate/version.rb

@@ -0,0 +1,3 @@
+module Forminate
+  VERSION = "0.1.0"
+end

data/lib/forminate.rb

@@ -0,0 +1,196 @@
+require "forminate/version"
+
+require 'active_support/concern'
+require 'active_attr'
+
+module Forminate
+  extend ActiveSupport::Concern
+  include ActiveAttr::Model
+
+  included do
+    validate do
+      associations.each do |name, object|
+        if should_validate_assoc?(name) && object.respond_to?(:invalid?) && object.invalid?
+          object.errors.each do |field, messages|
+            errors["#{name}_#{field}".to_sym] = messages
+          end
+        end
+      end
+    end
+  end
+
+  module ClassMethods
+    def attributes_for(name, options = {})
+      define_attributes name
+      define_association name, options
+    end
+
+    def association_names
+      @association_names ||= []
+    end
+
+    def association_validations
+      @association_validations ||= {}
+    end
+
+    private
+
+    def define_attributes(association_name)
+      attributes = association_name.to_s.classify.constantize.attribute_names
+      attributes.each { |attr| define_attribute(attr, association_name) }
+    end
+
+    def define_attribute(attr, assoc)
+      ActiveAttr::AttributeDefinition.new("#{assoc}_#{attr}").tap do |attribute_definition|
+        attribute_name = attribute_definition.name.to_s
+        attributes[attribute_name] = attribute_definition
+      end
+      define_attribute_reader(attr, assoc)
+      define_attribute_writer(attr, assoc)
+    end
+
+    def define_attribute_reader(attr, assoc)
+      define_method("#{assoc}_#{attr}") do
+        send(assoc.to_sym).send(attr.to_sym)
+      end
+    end
+
+    def define_attribute_writer(attr, assoc)
+      define_method("#{assoc}_#{attr}=") do |value|
+        send(assoc.to_sym).send("#{attr}=".to_sym, value)
+      end
+    end
+
+    def define_association(name, options = {})
+      association_names << name
+      should_validate = if options.has_key?(:validate)
+                          options[:validate]
+                        else
+                          true
+                        end
+      association_validations[name] = should_validate
+      send(:attr_accessor, name)
+    end
+  end
+
+  def initialize(attributes = {})
+    build_associations(attributes)
+    super
+  end
+
+  def persisted?
+    false
+  end
+
+  def association_names
+    self.class.association_names
+  end
+
+  def associations
+    Hash[association_names.map { |name| [name, send(name)] }]
+  end
+
+  def save
+    return false unless valid?
+
+    before_save
+    if defined? ActiveRecord
+      ActiveRecord::Base.transaction { persist_associations }
+    else
+      persist_associations
+    end
+    self
+  end
+
+  def before_save
+    # hook method
+  end
+
+  def method_missing(name, *args, &block)
+    assoc, assoc_method_name = association_for_method(name)
+    if assoc && assoc.respond_to?(assoc_method_name)
+      assoc.send(assoc_method_name, *args)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    assoc, assoc_method_name = association_for_method(name)
+    if assoc && assoc.respond_to?(assoc_method_name)
+      true
+    else
+      super
+    end
+  end
+
+  private
+
+  def build_associations(attributes)
+    association_names.each do |association_name|
+      association = build_association(association_name, attributes)
+      instance_variable_set("@#{association_name}".to_sym, association)
+    end
+  end
+
+  def build_association(name, attributes)
+    association_attributes = attributes_for_association(name, attributes)
+    klass = name.to_s.classify.constantize
+
+    if klass.respond_to? :primary_key
+      primary_key = attributes["#{name}_#{klass.primary_key}".to_sym]
+    end
+
+    if primary_key
+      object = klass.find primary_key
+      object.assign_attributes association_attributes
+      object
+    else
+      klass.new association_attributes
+    end
+  end
+
+  def attributes_for_association(association_name, attributes)
+    prefix = "#{association_name}_"
+    relevant_attributes = attributes.select { |k, v| k =~ /#{prefix}/ }
+    relevant_attributes.reduce({}) do |hash, (name, definition)|
+      new_key = name.to_s.sub(prefix, '').to_sym
+      hash[new_key] = definition
+      hash
+    end
+  end
+
+  def persist_associations
+    associations.each do |name, object|
+      object.save if object.respond_to? :save
+    end
+  end
+
+  def should_validate_assoc?(name)
+    method_name = assoc_validation_filter_method(name)
+    send(method_name)
+  end
+
+  def assoc_validation_filter_method(name)
+    filter = self.class.association_validations.fetch(name, true)
+    method_name = "should_validate_#{name}?".to_sym
+    case filter
+    when Symbol
+      filter
+    when TrueClass, FalseClass
+      self.class.send(:define_method, method_name) { filter }
+      method_name
+    else
+      raise NotImplementedError, "The attributes_for :validate option can only take a symbol, true, or false"
+    end
+  end
+
+  def association_for_method(name)
+    assoc_name = association_names.find { |an| name.match /^#{an}_/ }
+    if assoc_name
+      assoc_method_name = name.to_s.sub("#{assoc_name}_", '').to_sym
+      assoc = send(assoc_name)
+      return assoc, assoc_method_name
+    end
+  end
+end

data/spec/lib/forminate/client_side_validations.rb

@@ -0,0 +1,124 @@
+module ActiveModel
+  class Validator
+    # To make use of validators present on associated object, we need to be
+    # able to specify the original object that a given validator came from.
+    attr_accessor :target_object
+  end
+end
+
+module Forminate
+  # This module makes Forminate work with bcardarella's client_side_validations
+  # gem (https://github.com/bcardarella/client_side_validations).
+  #
+  # The majority of the methods contained here are overrides or alternative
+  # versions of methods in the client_side_validations gem. For the most part,
+  # they follow the shape and ideas of the original implementation, usually adding
+  # the ability to send messages to an associated object rather than the Forminate
+  # object itself.
+  module ClientSideValidations
+    extend ActiveSupport::Concern
+
+    # Where the magic happens. This overrides the client_side_validations gem's
+    # method of the same name, using Forminate's #association_validators rather
+    # than ActiveModel's _validators method. It still calls super so that it
+    # includes validations placed directly on the Forminate object.
+    def client_side_validation_hash(force = nil)
+      hash = super
+      assoc_hash = association_validators.reduce({}) do |assoc_hash, (attr, validators)|
+        unless [nil, :block].include?(attr)
+
+          validator_hash = validators.reduce(Hash.new { |h,k| h[k] = []}) do |kind_hash, validator|
+            model = validator.target_object
+            model_pattern = /^#{model.class.name.underscore}_/
+            target_attr = attr.to_s.sub(model_pattern, '').to_sym
+
+            if force.is_a? Hash
+              relevant_force = force.select { |k, v| k.to_s.match model_pattern }
+              assoc_force = relevant_force.reduce({}) do |assoc_force, (key, value)|
+                key = key.to_s.sub(model_pattern, '').to_sym
+                assoc_force.merge({ key => value })
+              end
+            else
+              assoc_force = force
+            end
+
+            if _can_use_for_client_side_validation?(model, target_attr, validator, assoc_force)
+              if client_side_hash = validator.client_side_hash(model, target_attr, extract_force_option(target_attr, assoc_force))
+                kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
+              end
+            end
+
+            kind_hash
+          end
+
+          if validator_hash.present?
+            assoc_hash.merge!(attr => validator_hash)
+          else
+            assoc_hash
+          end
+        else
+          assoc_hash
+        end
+      end
+      hash.merge assoc_hash
+    end
+
+    private
+
+    # Constructs the associated validators for use with client_side_validations.
+    # This is meant to mimic ActiveModel's #_validators method that the
+    # client_side_validations gem relies on for construction the client side
+    # validation hash.
+    def association_validators
+      associations.reduce({}) do |assoc_validators, (name, object)|
+        if should_validate_assoc?(name) && object.respond_to?(:_validators)
+          object._validators.each do |attr, validators|
+            new_validators = validators.reduce([]) do |new_validators, validator|
+              new_validator = validator.dup
+              new_validator.target_object = object
+              new_validators << new_validator
+            end
+            assoc_validators["#{name}_#{attr}".to_sym] = new_validators
+          end
+        end
+        assoc_validators
+      end
+    end
+
+    # Alternative version of the client_side_validation gem's
+    # #can_use_for_client_side_validation? method, allowing the target 'model'
+    # to be passed in as an argument.
+    def _can_use_for_client_side_validation?(model, attr, validator, force)
+      if validator_turned_off?(attr, validator, force)
+        result = false
+      else
+        result = ((model.respond_to?(:new_record?) && validator.options[:on] == (model.new_record? ? :create : :update)) || validator.options[:on].nil?)
+        result = result && validator.kind != :block
+
+        if validator.options[:if] || validator.options[:unless]
+          if result = can_force_validator?(attr, validator, force)
+            if validator.options[:if]
+              result = result && _run_conditional(model, validator.options[:if])
+            end
+            if validator.options[:unless]
+              result = result && !_run_conditional(model, validator.options[:unless])
+            end
+          end
+        end
+      end
+
+      result
+    end
+
+    # Alternative version of the client_side_validation gem's #run_conditional
+    # method, allowing the target 'model' to be passed in as an argument.
+    def _run_conditional(model, method_name_or_proc)
+      case method_name_or_proc
+      when Proc
+        method_name_or_proc.call(model)
+      else
+        model.send(method_name_or_proc)
+      end
+    end
+  end
+end

data/spec/lib/forminate/client_side_validations_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'client_side_validations'
+require 'forminate/client_side_validations'
+
+describe Forminate::ClientSideValidations do
+  subject(:model) { model_class.new }
+
+  let :model_class do
+    Class.new do
+      include Forminate
+      include Forminate::ClientSideValidations
+
+      attribute :total
+      attribute :tax
+
+      attributes_for :dummy_user
+      attributes_for :dummy_book, :validate => false
+      attributes_for :dummy_credit_card, :validate => :require_credit_card?
+
+      validates_numericality_of :total
+
+      def self.name
+        "Cart"
+      end
+
+      def calculate_total
+        self.total = dummy_book.price || 0.0
+      end
+
+      def require_credit_card?
+        dummy_book.price && dummy_book.price > 0.0
+      end
+    end
+  end
+
+  describe "#client_side_validation_hash" do
+    it "constructs a hash of validations and messages for use with the client_side_validations gem" do
+      expected_hash = {
+        total: {
+          numericality: [{ messages: { numericality: "is not a number" } }]
+        },
+        dummy_user_email: {
+          presence: [{ message: "can't be blank" }]
+        }
+      }
+      expect(model.client_side_validation_hash).to eq(expected_hash)
+      expected_hash = {
+        total: {
+          numericality: [{ messages: { numericality: "is not a number" } }]
+        },
+        dummy_user_email: {
+          presence: [{ message: "can't be blank" }]
+        },
+        dummy_credit_card_number: {
+          presence: [{ message: "can't be blank" }],
+          length: [{
+            messages: {
+              minimum: "is too short (minimum is 12 characters)",
+              maximum: "is too long (maximum is 19 characters)"
+            },
+            minimum: 12,
+            maximum: 19
+          }]
+        },
+      }
+      model.dummy_book_price = 12.95
+      expect(model.client_side_validation_hash).to eq(expected_hash)
+    end
+  end
+end

data/spec/lib/forminate_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Forminate do
+  subject(:model) { model_class.new }
+
+  let :model_class do
+    Class.new do
+      include Forminate
+
+      attribute :total
+      attribute :tax
+
+      attributes_for :dummy_user
+      attributes_for :dummy_book, :validate => false
+      attributes_for :dummy_credit_card, :validate => :require_credit_card?
+
+      validates_numericality_of :total
+
+      def self.name
+        "Cart"
+      end
+
+      def calculate_total
+        self.total = dummy_book.price || 0.0
+      end
+
+      def require_credit_card?
+        dummy_book.price && dummy_book.price > 0.0
+      end
+    end
+  end
+
+  describe ".attributes_for" do
+    it "adds a reader method for each attribute of the associated model" do
+      expect(model.respond_to?(:dummy_user_first_name)).to be_true
+    end
+
+    it "adds reader and writer methods for each attribute of the associated model" do
+      model.dummy_user_first_name = 'Mo'
+      expect(model.dummy_user_first_name).to eq('Mo')
+    end
+
+    it "adds reader methods for each associated model" do
+      expect(model.dummy_user).to be_an_instance_of(DummyUser)
+    end
+
+    it "adds the association to the list of association names" do
+      expect(model_class.association_names).to include(:dummy_user)
+    end
+
+    describe ":validate option" do
+      it "validates associated object based on true or false" do
+        model.calculate_total
+        expect(model.valid?).to be_false
+        model.dummy_user_email = 'bob@example.com'
+        expect(model.valid?).to be_true
+      end
+
+      it "validates associated objects based on a method name (as a symbol) that evaluates to true or false" do
+        model.calculate_total
+        model.dummy_user_email = 'bob@example.com'
+        expect(model.valid?).to be_true
+        model.dummy_book_price = 12.95
+        expect(model.valid?).to be_false
+        model.dummy_credit_card_number = 4242424242424242
+        expect(model.valid?).to be_true
+      end
+    end
+  end
+
+  describe ".attribute_names" do
+    it "includes the names of its own attributes and the attributes of associated models" do
+      expected_attributes = [
+        "total",
+        "tax",
+        "dummy_user_first_name",
+        "dummy_user_last_name",
+        "dummy_user_email",
+        "dummy_book_title",
+        "dummy_book_price",
+        "dummy_credit_card_number",
+        "dummy_credit_card_expiration",
+        "dummy_credit_card_cvv",
+      ]
+      expect(model_class.attribute_names).to eq(expected_attributes)
+    end
+  end
+
+  describe ".association_names" do
+    it "includes the names of associated models" do
+      expect(model_class.association_names).to eq([:dummy_user, :dummy_book, :dummy_credit_card])
+    end
+  end
+
+  describe ".association_validations" do
+    it "includes the names and conditions of association validations" do
+      expect(model_class.association_validations).to eq({ :dummy_user => true, :dummy_book => false, :dummy_credit_card => :require_credit_card? })
+    end
+  end
+
+  describe "#initialize" do
+    it "builds associated objects and creates reader methods" do
+      expect(model.dummy_user).to be_an_instance_of(DummyUser)
+    end
+
+    it "creates writer methods for associated objects" do
+      new_dummy_user = DummyUser.new(first_name: 'Mo')
+      expect(model.dummy_user).to_not be(new_dummy_user)
+      model.dummy_user = new_dummy_user
+      expect(model.dummy_user).to be(new_dummy_user)
+    end
+
+    it "sets association attributes based on an options hash" do
+      new_model = model_class.new(dummy_user_first_name: 'Mo', dummy_user_last_name: 'Lawson')
+      expect(new_model.dummy_user_first_name).to eq('Mo')
+      expect(new_model.dummy_user_last_name).to eq('Lawson')
+    end
+
+    it "sets attributes based on an options hash" do
+      new_model = model_class.new(total: 21.49)
+      expect(new_model.total).to eq(21.49)
+    end
+  end
+
+  describe "#association_names" do
+    it "delegates to self.association_names" do
+      expect(model.association_names).to eq(model_class.association_names)
+    end
+  end
+
+  describe "#associations" do
+    it "returns a hash of association names and associated objects" do
+      expect(model.associations[:dummy_user]).to be_an_instance_of(DummyUser)
+    end
+  end
+
+  describe "#save" do
+    context "object is valid" do
+      it "saves associations and returns self" do
+        model.dummy_user_email = 'bob@example.com'
+        model.calculate_total
+        DummyUser.any_instance.should_receive(:save)
+        expect(model.save).to eq(model)
+      end
+    end
+
+    context "object is not valid" do
+      it "does not save associations and returns false" do
+        DummyUser.any_instance.should_not_receive(:save)
+        expect(model.save).to be_false
+      end
+    end
+  end
+
+  context "setting an attribute using the attribute name" do
+    it "reflects the change on the associated object" do
+      model.dummy_user_first_name = 'Mo'
+      expect(model.dummy_user.first_name).to eq('Mo')
+    end
+  end
+
+  context "setting an attribute using the association's attribute" do
+    it "reflects the change on the attribute name" do
+      model.dummy_user.last_name = 'Lawson'
+      expect(model.dummy_user_last_name).to eq('Lawson')
+    end
+  end
+
+  it "delegates to attr_accessors of associated objects" do
+    model.dummy_user_full_name = 'Mo Lawson'
+    expect(model.dummy_user.full_name).to eq('Mo Lawson')
+    expect(model.dummy_user_full_name).to eq('Mo Lawson')
+  end
+
+  it "inherits the validations of its associated objects" do
+    model.valid?
+    expect(model.errors.full_messages).to eq(["Dummy user email can't be blank", "Total is not a number"])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+require 'forminate'
+
+# Requires supporting files in spec/support/
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each { |file| require file }

data/spec/support/dummy_book.rb

@@ -0,0 +1,10 @@
+require 'active_attr'
+
+class DummyBook
+  include ActiveAttr::Model
+
+  attribute :title
+  attribute :price
+
+  validates_presence_of :title
+end

data/spec/support/dummy_credit_card.rb

@@ -0,0 +1,13 @@
+require 'active_attr'
+
+class DummyCreditCard
+  include ActiveAttr::Model
+
+  attribute :number
+  attribute :expiration
+  attribute :cvv
+
+  validates_presence_of :number
+  validates_length_of :number, in: 12..19
+end
+

data/spec/support/dummy_user.rb

@@ -0,0 +1,17 @@
+require 'active_attr'
+
+class DummyUser
+  include ActiveAttr::Model
+
+  attribute :first_name
+  attribute :last_name
+  attribute :email
+
+  attr_accessor :full_name
+
+  validates_presence_of :email
+
+  def save
+    # fake a persisted model
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: forminate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mo Lawson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: client_side_validations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: Form objects for Rails applications
+email:
+- moklawson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- forminate.gemspec
+- lib/forminate.rb
+- lib/forminate/client_side_validations.rb
+- lib/forminate/version.rb
+- spec/lib/forminate/client_side_validations.rb
+- spec/lib/forminate/client_side_validations_spec.rb
+- spec/lib/forminate_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_book.rb
+- spec/support/dummy_credit_card.rb
+- spec/support/dummy_user.rb
+homepage: https://github.com/molawson/forminate
+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: Create form objects from multiple Active Record and/or ActiveAttr models.
+test_files:
+- spec/lib/forminate/client_side_validations.rb
+- spec/lib/forminate/client_side_validations_spec.rb
+- spec/lib/forminate_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_book.rb
+- spec/support/dummy_credit_card.rb
+- spec/support/dummy_user.rb