form_object 0.0.1 → 0.1.1

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+notifications:
+  disabled: true

data/Gemfile

@@ -6,3 +6,9 @@ gemspec
 gem 'rake'
 gem 'minitest'
 gem 'turn'
+
+group :test do
+  gem 'sqlite3'
+  gem 'activemodel'
+  gem 'activerecord'
+end

data/README.md

@@ -21,7 +21,51 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+We have a model
+
+``` ruby
+class User < ActiveRecord::Base
+end
+
+# attributes => {email: "test@example.com", name: "name"}
+```
+
+Define forms:
+
+``` ruby
+# For base auth
+class BaseAuthForm < FormObject::Base
+  map_model User, as: :base_auth
+  attribute :email, String # => map form attribute to model attribute
+
+  validates :email, presence: true # => validate email in form ONLY!
+end
+
+# For any other auth
+class TwitterAuthForm < FormObject::Base
+  map_model User      # name => twitter_auth (name will be generated 
+                      # automatically from class name)
+                      # There is nothing to validate
+end
+```
+
+In any place:
+
+``` ruby
+  @user = User.find(params[:id])
+  @form = @user.form( :base_auth ) # This retrive BaseAuthForm instance
+                                  # with attributes from model
+  @form.assign_attributes(params[:user]) # assign attributes from hash
+
+  if @form.valid?
+    @form.persist_model           # TODO: maybe other method name?
+  end
+```
+
+## Can I help you?
+
+Discuss the existing features and offer new features you can
+[here](https://groups.google.com/d/forum/formobject "FormObject").
 
 ## Contributing
 

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/lib/*_test.rb']
+  t.test_files = FileList['test/lib/**/*_test.rb']
   t.verbose = true
 end
 

data/TODO

@@ -2,14 +2,17 @@ Features list
 
 * Features
   - Model:
-    - Get the FormObject with filled attributes
-    - Forms collection for retrive named form
+    + Get the FormObject instance with filled attributes
+    + Forms collection for retrive named form
   - FormObject:
     - Get the model with filled attributes
     - Create builder for markup (form_for, simple_form_for, etc...)
 
 * Integrations
-  - ActiveRecord
+  +/- ActiveModel
+  +/- ActiveRecord
   - Mongoid
   - DataMapper 1.x
   - DataMapper 2.x
+  - Validations
+    - Move validations in the appropriate integration

data/lib/form_object.rb

@@ -3,7 +3,17 @@ require 'virtus'
 require 'active_model'
 
 module FormObject
-  autoload :Base, 'form_object/base'
-  autoload :Integrations, 'form_object/integrations'
+
+  class ModelUndefinedError < RuntimeError
+    def initialize( form )
+      super "Model not defined for #{form.inspect}"
+    end
+  end
+
+  autoload :Utils,                  'form_object/utils'
+  autoload :Integrations,           'form_object/integrations'
+  autoload :Base,                   'form_object/base'
+  autoload :Store,                  'form_object/store'
+  autoload :Dsl,                    'form_object/dsl'
   # Your code goes here...
 end

data/lib/form_object/base.rb

@@ -1,16 +1,17 @@
 module FormObject
   class Base
+    autoload :Collection,         'form_object/base/collection'
+    autoload :MappingInformation, 'form_object/base/mapping_information'
+    autoload :FormBuilder,        'form_object/base/form_builder'
     include Virtus
 
     extend ActiveModel::Naming
+    include Dsl
     include ActiveModel::Conversion
     include ActiveModel::Validations
 
     # Forms are never themselves persisted
     def persisted?; false; end  
 
-    def model
-      nil
-    end
   end
 end

data/lib/form_object/base/collection.rb

@@ -0,0 +1,33 @@
+module FormObject
+
+  class MappingInformationNotFound < RuntimeError
+    def initialize( critery )
+      super "#{critery.inspect} not found"
+    end
+  end
+
+  class Base::Collection
+    attr_reader :model, :form_classes
+    
+    def initialize( model )
+      @model = model
+      @form_classes = find_form_classes
+    end
+
+    def []( name )
+      build_form_instance(name)
+    end
+
+    protected
+
+    def find_form_classes
+      FormObject::Store.instance.find(model: @model.class).inject({}){|c, i| c[i.name] = i; c}
+    end
+
+    def build_form_instance( name )
+      mapping_information = @form_classes[name]
+      raise MappingInformationNotFound.new(mapping_information) if mapping_information.nil?
+      FormObject::Base::FormBuilder.new(mapping_information, @model).build
+    end
+  end
+end

data/lib/form_object/base/form_builder.rb

@@ -0,0 +1,29 @@
+module FormObject
+  class Base::FormBuilder
+    attr_reader :mapping_information, :model
+
+    def initialize( mapping_information, model )
+      @mapping_information, @model = mapping_information, model
+    end
+
+    def build
+      form_instance
+    end
+
+    protected
+
+    def form_instance
+      @form_instance ||= assign_model_attributes(empty_form)
+    end
+
+    def empty_form
+      @mapping_information.form.new
+    end
+
+    def assign_model_attributes( form_instance )
+      form_instance.assign_model( @model )
+      form_instance
+    end
+
+  end
+end

data/lib/form_object/base/mapping_information.rb

@@ -0,0 +1,14 @@
+module FormObject
+  class Base
+    MappingInformation = Struct.new(:form, :model, :name, :options) do
+
+      def match?( critery = {} )
+        critery.each do |k, v|
+          return false unless self[k] == v
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/form_object/dsl.rb

@@ -0,0 +1,12 @@
+module FormObject
+  module Dsl
+    autoload :ClassMethods, 'form_object/dsl/class_methods'
+    autoload :InstanceMethods, 'form_object/dsl/instance_methods'
+
+    def self.included(receiver) #:nodoc:
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+
+  end
+end

data/lib/form_object/dsl/class_methods.rb

@@ -0,0 +1,25 @@
+module FormObject
+  module Dsl
+    module ClassMethods
+      
+      def map_model( model_class, options = {} )
+        store.map_for_model( self, model_class, options )
+      end
+
+      def form_name
+        FormObject::Utils::StringConverter.form_name(self.name).to_sym
+      end
+
+      def model
+        store.find(form: self).first.try(:model)
+      end
+
+      protected
+
+      def store
+        FormObject::Store.instance
+      end
+
+    end
+  end
+end

data/lib/form_object/dsl/instance_methods.rb

@@ -0,0 +1,18 @@
+module FormObject
+  module Dsl
+    module InstanceMethods
+
+      def model
+        raise ModelUndefinedError.new(self) unless @model
+        @model.assign_form_object_attributes(self)
+        @model
+      end
+
+      def assign_model( model_instance )
+        @model = model_instance
+        self.attributes = @model.form_object_attributes
+      end
+
+    end
+  end
+end

data/lib/form_object/integrations.rb

@@ -1,11 +1,10 @@
 require 'form_object/integrations/base'
-Dir["#{File.dirname(__FILE__)}/integrations/*.rb"].sort.each do |path|
+Dir[File.join(File.dirname(__FILE__), "integrations", "*.rb")].sort.each do |path|
   require "form_object/integrations/#{File.basename(path)}"
 end
 
 module FormObject
-  # Invalid integration error
-  class IntegrationNotFound < StandardError
+  class InvalidIntegration < RuntimeError
     def initialize( name )
       super "#{name.inspect} is invalid integration"
     end
@@ -13,31 +12,36 @@ module FormObject
 
   module Integrations
 
-    # Get collection of all integrations
-    # ActiveModel must be last always
-    # == Example
+    # Find integrations for for selected class
     #
-    #  Object::Integrations.all
-    #  # => [FormObject::Integrations::ActiveRecord]
+    # == Examples:
+    #    class User
+    #    end
     #
-    def self.all
-      constants = self.constants.map{ |c| c.to_s }
-                                .select{ |c| c!= 'ActiveModel' }
-                                .sort << 'ActiveModel'
-      constants.map{ |c| const_get(c) }
+    #    class ActiveRecordUser < ActiveRecord::Base
+    #    end
+    #
+    #    FormObject::Integrations.match(User) # => nil
+    #    FormObject::Integrations.match(ActiveRecordUser) # => FormObject::Integrations::ActiveRecord
+    def self.match( klass )
+      all.detect {|integration| integration.matches?(klass)}
     end
 
     # Find integration by name
-    # 
-    # == Examples
-    #   FormObject::Integrations.find(:active_record) # => FormObject::Integrations::ActiveRecord
     #
-    def self.find( name )
-      all.detect {|i| i.integration_name == name} || raise(IntegrationNotFound.new(name))
+    # == Examples:
+    #    
+    #    FormObject::Integrations.find_by_name(:active_record) # => FormObject::Integrations::ActiveRecord
+    def self.find_by_name( name )
+      all.detect {|integration| integration.integration_name == name} || raise( InvalidIntegration.new(name) )
     end
 
-    def self.match( *args )
-      all.detect {|i| i.matches_ancestors?(args)}
+    def self.all
+      # ActiveModel should be last item
+      constants = self.constants.map {|c| c.to_s}
+                                .select {|c| c != 'ActiveModel'}
+                                .sort <<          'ActiveModel'
+      constants.map {|c| const_get(c)}
     end
   end
 end

data/lib/form_object/integrations/active_model.rb

@@ -1,12 +1,29 @@
 module FormObject
   module Integrations
     module ActiveModel
+
+      def self.included( base ) #:nodoc:
+        base.versions.unshift(*versions)
+      end
+
       include Base
+      extend ClassMethods
+      require 'form_object/integrations/active_model/versions'
+
+      @defaults = {}
 
-      def self.matching_ancestors
-        %w(ActiveModel ActiveModel::Observing ActiveModel::Validations)
+      def self.maching_ancestors
+        %w{ActiveModel ActiveModel::Observing ActiveModel::Validations}
       end
 
+      def assign_form_object_attributes( form )
+        self.assign_attributes( form.attributes )
+      end
+
+      def form_object_attributes
+        self.attributes
+      end
+      
     end
   end
 end

data/lib/form_object/integrations/active_model/versions.rb

@@ -0,0 +1,11 @@
+module FormObject
+  module Integrations
+    module ActiveModel
+      version '3.x' do
+        def self.active?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/form_object/integrations/active_record.rb

@@ -1,10 +1,22 @@
+require 'form_object/integrations/active_model'
+
 module FormObject
   module Integrations
     module ActiveRecord
-      include Base
       
+      include Base
+      include ActiveModel
+      require 'form_object/integrations/active_record/versions'
+
+      @defaults = {}
+
+      def self.extended( base ) #:nodoc:
+        require 'active_record/version'
+        super
+      end
+
       def self.matching_ancestors
-        %w(ActiveRecord::Base)
+        %w{ActiveRecord::Base}
       end
 
     end

data/lib/form_object/integrations/active_record/versions.rb

@@ -0,0 +1,15 @@
+module FormObject
+  module Integrations
+    module ActiveRecord
+      
+      version '3.x' do
+
+        def self.active?
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/form_object/integrations/base.rb

@@ -1,110 +1,108 @@
 module FormObject
   module Integrations
     module Base
+
+      # DSL methods for integrations
       module ClassMethods
-        # The default options to use for state machines using this integration
-        attr_reader :defaults
-        
-        # FormsCollection for this model
-        #
-        # == Example
-        #
-        #   class BaseForm < FormObject::Base
-        #     model User
-        #   end
-        #
-        #   class TwitterForm < FormObject::Base
-        #     model User, as: :twitter
-        #   end
-        #
-        #   @user = User.new
-        #   @base_form = @user.forms[:base]       # => instance of BaseForm
-        #   @twitter_form = @iser.forms[:twitter] # => instance of TwitterForm
-        #
-        # Forms must have names. If the form name is not specified, it is taken
-        # from class name.
-        def forms
-          nil
-        end
+        # The default optons for integration
+        attr_accessor :defaults
 
-        # The name of the integration
+        # The name of integration
         def integration_name
           @integration_name ||= begin
-            name = self.name.split('::').last
-            name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-            name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-            name.downcase!
-            name.to_sym
+            FormObject::Utils::StringConverter.integration_name(self.name).to_sym
           end
         end
-        
-        # Whether this integration is available for the current library.  This
-        # is only true if the ORM that the integration is for is currently
-        # defined.
-        def available?
+
+        # Integration avaliable only if the ORM that integration is for
+        # currently defined
+        def avaliable?
           matching_ancestors.any? && Object.const_defined?(matching_ancestors[0].split('::')[0])
         end
-        
-        # The list of ancestor names that cause this integration to matched.
+
+        # The list of ancestor names that cause this integration to
+        # matched.
         def matching_ancestors
           []
         end
 
-        # Whether the integration should be used for the given class.
-        def matches?(klasses)
-          ancestor_names = klasses.map {|klass| klass.ancestors.map(&:name)}
-          matches_ancestors?(ancestor_names)
+        def matches?( klass )
+          matches_ancestors?(klass.ancestors.map(&:name))
         end
 
-        # Whether the integration should be used for the given list of ancestors.
-        def matches_ancestors?(ancestors)
+        def matches_ancestors?( ancestors )
           (ancestors & matching_ancestors).any?
         end
 
-        # The path to the locale file containing translations for this
-        # integration.  This file will only exist for integrations that actually
-        # support i18n.
-        def locale_path
-          path = "#{File.dirname(__FILE__)}/#{integration_name}/locale.rb"
-          path if File.exists?(path)
-        end
-
-        # Extends the given object with any version overrides that are currently 
-        # active
-        def extended(base)
-          versions.each do |version|
-             base.extend(version) if version.active?
-          end
-        end
-
-        # Defined versions
         def versions
           @versions ||= []
         end
 
-        # DSL for define version and version based methods
+        # Define current version for integration
+        # Can override some methods for different versions
         #
-        def version( name, &block )
-          mod = Module.new(&block)
-          versions << mod
+        # == Example:
+        #
+        #    module FormObject
+        #      module Integrations
+        #        module DataMapper
+        #          version '1.x' do
+        #            def persist_model
+        #              # model.save
+        #            end
+        #          end
+        #
+        #          version '2.x' do
+        #            def persist_model
+        #              # DataMapper[model.class].persist(model)
+        #            end
+        #          end
+        #        end
+        #      end
+        #    end
+        #
+        def version( name, &blk )
+          versions << mod = Module.new( &blk )
           mod
         end
 
+        def assign_model_attributes( form_instance, model_instance )
+          form_instance.attributes = model_instance.attributes
+        end
+
+        # Extend only active versions
+        def extended( base )
+          versions.select(&:active?).each do |version|
+            base.extend(version)
+          end
+        end
+        
       end
 
-      extend ClassMethods
-    
       module InstanceMethods
 
-        # FormsCollection for this model
+        # Forms hash for current model
         def forms
-          self.class.forms
+          @forms ||= FormObject::Base::Collection.new(self)
+        end
+
+        # Get form by given name
+        def form( name )
+          forms[name]
+        end
+
+        def form_object_attributes
+          Hash.new
         end
+
+
       end
+
+      extend ClassMethods
     
-      def self.included(receiver) #:nodoc:
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
+      def self.included(receiver)
+        receiver.class_eval { extend ClassMethods }
+        receiver.class_eval { include InstanceMethods }
       end
     end
   end

data/lib/form_object/store.rb

@@ -0,0 +1,32 @@
+require 'singleton'
+
+module FormObject
+  class Store
+    include Singleton
+
+    def storage
+      @storage ||= Set.new
+    end
+    
+    def map_for_model( form, model, options = {})
+      form_name = retrive_form_name(form, options.delete(:as))
+      storage << FormObject::Base::MappingInformation.new(form, model, form_name, options )
+      include_integration( model )
+    end
+
+    def find(critery = {})
+      storage.select{|mapping_info| mapping_info.match?(critery)}
+    end
+
+    private
+
+    def retrive_form_name( form, name )
+      name ||= form.form_name
+    end
+
+    def include_integration( model_class )
+      integration = FormObject::Integrations.match(model_class)
+      model_class.send(:include, integration) unless integration.nil?
+    end
+  end
+end

data/lib/form_object/utils.rb

@@ -0,0 +1,5 @@
+module FormObject
+  module Utils
+    require 'form_object/utils/string_converter'
+  end
+end

data/lib/form_object/utils/string_converter.rb

@@ -0,0 +1,27 @@
+module FormObject
+  module Utils
+    module StringConverter
+
+      def self.integration_name( word )
+        name = word.split('::').last
+        underscore(name)
+      end
+
+      def self.form_name( word )
+        name = word.split('::').last
+        name.gsub!(/Form/, '')
+        underscore(name).to_sym
+      end
+
+      protected
+
+      def self.underscore( original_word, options = {} )
+        word = original_word.to_s.dup
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.downcase!
+        word
+      end
+    end
+  end
+end

data/lib/form_object/version.rb

@@ -1,3 +1,3 @@
 module FormObject
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/test/lib/form_object_test.rb

@@ -3,6 +3,8 @@ require 'test_helper'
 class FormObjectTest < TestCase
   def setup
     @form = Filter.new(query: "find me")
+    @base_form = BaseAuthForm.new(email: "test@example.com", name: "test")
+    @twitter_form = TwitterAuthForm.new
   end
 
   def test_should_form_not_persisted
@@ -15,16 +17,26 @@ class FormObjectTest < TestCase
 
   def test_should_be_valid_form
     assert @form.valid?
+    assert @base_form.valid?
   end
 
   def test_should_be_invalid_with_empty_query
     @form.query = ""
-    assert !@form.valid?
+    assert @form.invalid?
   end
 
   def test_should_have_not_nil_created_at_attribute
-    assert @form.created_at.kind_of?(DateTime)
+    assert_kind_of DateTime, @form.created_at
     assert @form.created_at.present?
   end
 
+  def test_base_form_have_a_model
+    assert_equal User, @base_form.class.model
+  end
+
+  def test_form_should_have_name
+    assert_equal :base_auth, @base_form.class.form_name
+    assert_equal :twitter_auth, @twitter_form.class.form_name
+  end
+
 end

data/test/lib/form_relation_test.rb

@@ -2,11 +2,26 @@ require 'test_helper'
 
 class FormRelationTest < TestCase
   def setup
+    @attributes = { email: "test@example.com", name: "name" }
     @form = Filter.new(query: "find me")
+    @model = User.new(@attributes)
   end
 
   def test_should_not_form_get_model
     assert_respond_to @form, :model
-    assert @form.model.nil?
+    assert_raises FormObject::ModelUndefinedError do
+      @form.model
+    end
   end
+
+  def test_model_should_have_forms
+    base_auth_form = @model.form( :base_auth )
+    assert @attributes[:email], base_auth_form.email
+  end
+
+  def test_model_hould_not_have_undefined_inForm_field
+    base_auth_form = @model.form( :base_auth )
+    assert !base_auth_form.respond_to?( :name )
+  end
+
 end

data/test/lib/integrations/active_model_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Integrations
+  # Test ActiveModel integration
+  class ActiveModelTest < ::TestCase
+    # Test setup
+    def setup
+      @integration_name = :active_model
+    end
+
+    def test_should_integration_finded_by_name
+      assert_equal FormObject::Integrations::ActiveModel, FormObject::Integrations.find_by_name(@integration_name)
+    end
+
+  end
+end

data/test/lib/integrations/active_record_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Integrations
+  # Test ActiveRecord integration
+  class ActiveRecordTest < ::TestCase
+    # Test setup
+    def setup
+      @integration_name = :active_record
+      @user = User.new email: "test@example.com"
+    end
+
+    def test_should_integration_finded_by_name
+      assert_equal FormObject::Integrations::ActiveRecord, FormObject::Integrations.find_by_name(@integration_name)
+    end
+
+    def test_should_match_active_record_integration
+      assert_equal FormObject::Integrations::ActiveRecord, FormObject::Integrations.match(User)
+    end
+
+    def test_should_have_base_auth_form_instance_for_user_model
+      form = @user.form( :base_auth )
+      assert form, "base_auth form is nil!"
+    end
+
+    def test_form_should_have_attributes_from_model
+      form = @user.form( :base_auth )
+      assert_equal @user.email, form.email
+    end
+
+    def test_should_form_get_model_with_new_attributes
+      form = @user.form( :base_auth )
+      new_user_email = "user@example.com"
+      form.attributes = {email: new_user_email}
+      model = form.model
+      assert_equal new_user_email, model.email
+    end
+
+  end
+end

data/test/lib/integrations/base_test.rb

@@ -1,19 +1,12 @@
 require 'test_helper'
 
 module Integrations
-
   class BaseTest < ::TestCase
-
     def setup
-      superclass = Class.new
-      self.class.const_set('Vehicle', superclass)
-      
-      @klass = Class.new(superclass)
     end
 
-    def test_should_return_nil_if_match_not_found
-      assert_nil FormObject::Integrations.match(@klass)
+    def test_filter_class_should_not_have_integrations
+      assert_nil FormObject::Integrations.match(Filter)
     end
-
   end
 end

data/test/lib/integrations_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class IntegrationsTest < TestCase
+  def setup
+    @integrations = [
+      FormObject::Integrations::Base,
+      FormObject::Integrations::ActiveModel,
+      FormObject::Integrations::ActiveRecord
+    ]
+    @base_form = BaseAuthForm.new(email: "test@example.com", name: "test")
+    @twitter_form = TwitterAuthForm.new
+  end
+
+  def test_integrations_should_bee
+    FormObject::Integrations.all.each do |integration|
+      assert_includes @integrations, integration
+    end
+  end
+
+end

data/test/lib/store_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class StoreTest < TestCase
+
+  def setup
+    @repo = FormObject::Store.instance
+  end
+
+  def test_should_have_base_auth_in_collection
+    assert_equal BaseAuthForm, @repo.find(name: :base_auth).first.form
+  end
+
+  def test_should_have_twitter_in_collection
+    assert_equal TwitterAuthForm, @repo.find(name: :twitter).first.form
+  end
+
+  def test_repo_shold_find_form_for_model
+    critery = {}
+    assert_operator 0, :<, @repo.find(critery).count
+  end
+
+  def test_should_find_by_model_class
+    assert_equal User, @repo.find(model: User).first.model
+  end
+
+  def test_repo_shold_find_form_for_model_with_critery
+    critery = {name: :base_auth}
+    assert_operator 0, :<, @repo.find(critery).count
+  end
+
+  def test_should_not_find_forms_for_wrong_critery
+    critery = { name: :wrong_name }
+    assert_equal [], @repo.find(critery)
+  end
+
+end

data/test/support/active_record.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+ActiveRecord::Migration.create_table :users do |t|
+  t.string :email
+  t.string :name
+  t.timestamps
+end
+
+class User < ActiveRecord::Base
+  # Without form validations.
+  # Only Domain Validations
+end
+
+class BaseAuthForm < FormObject::Base
+  map_model User
+
+  attribute :email, String
+
+  validates :email, :presence => true
+end
+
+class TwitterAuthForm < FormObject::Base
+  map_model User, :as => :twitter
+end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 require 'bundler/setup'
 Bundler.require
 require 'minitest/autorun'
+require 'turn/autorun'
 
 Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: form_object
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -51,25 +51,40 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - TODO
 - form_object.gemspec
 - lib/form_object.rb
 - lib/form_object/base.rb
+- lib/form_object/base/collection.rb
+- lib/form_object/base/form_builder.rb
+- lib/form_object/base/mapping_information.rb
+- lib/form_object/dsl.rb
+- lib/form_object/dsl/class_methods.rb
+- lib/form_object/dsl/instance_methods.rb
 - lib/form_object/integrations.rb
 - lib/form_object/integrations/active_model.rb
+- lib/form_object/integrations/active_model/versions.rb
 - lib/form_object/integrations/active_record.rb
+- lib/form_object/integrations/active_record/versions.rb
 - lib/form_object/integrations/base.rb
+- lib/form_object/store.rb
+- lib/form_object/utils.rb
+- lib/form_object/utils/string_converter.rb
 - lib/form_object/version.rb
 - test/lib/form_object_test.rb
 - test/lib/form_relation_test.rb
-- test/lib/forms_collection_test.rb
+- test/lib/integrations/active_model_test.rb
+- test/lib/integrations/active_record_test.rb
 - test/lib/integrations/base_test.rb
+- test/lib/integrations_test.rb
+- test/lib/store_test.rb
+- test/support/active_record.rb
 - test/support/filter.rb
-- test/support/model.rb
 - test/test_helper.rb
 homepage: 
 licenses: []
@@ -85,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -476988463
+      hash: 305297741
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -94,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -476988463
+      hash: 305297741
 requirements: []
 rubyforge_project: form_object
 rubygems_version: 1.8.24
@@ -104,8 +119,11 @@ summary: Form object implementation
 test_files:
 - test/lib/form_object_test.rb
 - test/lib/form_relation_test.rb
-- test/lib/forms_collection_test.rb
+- test/lib/integrations/active_model_test.rb
+- test/lib/integrations/active_record_test.rb
 - test/lib/integrations/base_test.rb
+- test/lib/integrations_test.rb
+- test/lib/store_test.rb
+- test/support/active_record.rb
 - test/support/filter.rb
-- test/support/model.rb
 - test/test_helper.rb

data/test/lib/forms_collection_test.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class FormsCollectionTest < TestCase
-  def setup
-    @form = Filter.new(query: "find me")
-  end
-
-  def test_should_model_have_forms_collection
-    
-  end
-end