active_repository 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 605ad373409e52ed436bd85e89904760fe97e049
-  data.tar.gz: 39716333dfbdaa9d447bb8be5f384148d8815b4d
+  metadata.gz: b4e5ff5317491bb88742d8486544d1ed31a60181
+  data.tar.gz: 0acb8ac3cd7df689eb9c811b6b7c4b04683f46eb
 SHA512:
-  metadata.gz: 2841548917d159c2ac40c46fc2aaea7d724cd3479a4842b6e71ce53b7ed076e3781539a5a2e54391b83cc9bae310267450ac179b9340057a767de655944e7b14
-  data.tar.gz: cd3890fb5aa63a1cbcd90c533121710eb2b68a9839b92dcbdd0b4db0d267d7c0dce11e2e6eb625b6193faf50e64c03bb6213deac7c924fff2175cd4d8cac9381
+  metadata.gz: 94c813e8ebae6c3837693041bd3780b557f9e52e759b0d81e7be118568202cae8962b1d70ea2173cc80f5f5ed34bd5f75b32682a523d455fce6c052ba7794328
+  data.tar.gz: cc1b12d0d86d3399318bc4f0b2dd673baedf1dfbcff94f96f98a290488daf677baf5722926de82200d7a675ce7b58db083b397fb119f40d3034f9ce984492b64

data/README.md

@@ -2,27 +2,27 @@
 
 [[![Coverage Status](https://coveralls.io/repos/efreesen/active_repository/badge.png)](https://coveralls.io/r/efreesen/active_repository)![Build Status](https://secure.travis-ci.org/efreesen/active_repository.png)](http://travis-ci.org/efreesen/active_repository)[![Dependency Status](https://gemnasium.com/efreesen/active_repository.png)](https://gemnasium.com/efreesen/active_repository) [![Code Climate](https://codeclimate.com/github/efreesen/active_repository.png)](https://codeclimate.com/github/efreesen/active_repository)
 
-ActiveRepository was designed so you can build your Business Models without depending on any ORM. It by default saves your data in memory using ActiveHash (https://github.com/zilkey/active_hash). Then when you decide which ORM you want to use you only have to connect ActiveRepository with it.
+ActiveRepository was designed so you can build your Business Models without any dependence on persistence. It by default saves your data in memory using ActiveHash (https://github.com/zilkey/active_hash). Then when you decide which kind of persistence you want to use, all you have to do is connect ActiveRepository with it.
 
-Currently it only works with ActiveRecord and/or Mongoid.
+Currently it only works with ActiveRecord and/or Mongoid, but it is easy to add adaptors. If you need any adaptor, just open an issue!
 
-It also has the advantage of letting you test directly in memory, with no need to save data on disk, which gives a great boost to your test suite speed.
+With it you can always run your tests directly into memory, boosting your suite's speed. If you need to run all tests or a single spec using persistence you can do it too.
 
-Here are some data for comparison:
+Check out our benchmark:
 
 * **ActiveRepository:**
-  Finished in **0.63357** seconds;
-  78 examples, 0 failures
+  Finished in **2.96** seconds
+  90 examples, 0 failures
 
 * **ActiveRecord:**
-  Finished in **3.78** seconds;
-  78 examples, 0 failures
+  Finished in **6.29** seconds
+  90 examples, 0 failures
 
 * **Mongoid:**
-  Finished in **5.25** seconds;
-  78 examples, 0 failures
+  Finished in **7.01** seconds
+  90 examples, 0 failures
 
-With ActiveRepository you can make associations with ActiveRecord, Mongoid and ActiveRepository seamlessly.
+In ActiveRepository you will always work with ActiveRepository objects, so you can create relations between ActiveRecord and Mongoid seamlessly. You can even use Mongoid's Origin query format or keep with the SQL format no matter what kind of persistence you are using, we convert it for you!
 
 ## Requirements
 
@@ -46,45 +46,69 @@ Or install it yourself as:
 
 ## Usage
 
-To use it you should inherit ActiveRepository::Base:
+To use it your class should inherit ActiveRepository::Base:
 
-    class User < ActiveRepository::Base
+    class UserRepository < ActiveRepository::Base
+      persistence_class = User
+      save_in_memory = false
     end
 
-ActiveRepository::Base has two class attributes to help it identify where it is going to persist data
+ActiveRepository::Base has two class attributes to help it identify where it is going to persist data.
 
-###model_class
+###persistence_class
 
-This attribute is used to identify the class responsible for persisting data, it should be the ActiveRecord model or the Mongoid Document.
+This attribute is used to identify the class responsible for persisting data, it should be the ActiveRecord model or the Mongoid Document. Let's say your ActiveRecord Model is called User, using the example above, all database actions would be passed to User class, and you can extract all your business logic to the UserRepository class.
 
 ###save_in_memory
 
-This attribute is used to persist data directly into memory. When set to true, it ignores the model_class attribute value and save in the memory, if set to false it user model_class to persist data.
+This attribute is used to persist data directly into memory. When set to true, it ignores the persistence_class attribute and save in memory. If set to false it goes back to persistence_class. You can use it to keep your tests saving in memory, or set it to false manually if a test need to touch the database.
 
-P.S.: Just be careful, the set_save_in_memory method should always be called after set_model_class method.
+If using Rails you can even tie it to your environment, so in tests it is set to true and otherwise it is set to false, like this:
 
-    class User < ActiveRepository::Base
-      # Defines the class responsible for persisting data
-      set_model_class(UserModel)
+    class UserRepository < ActiveRepository::Base
+      persistence_class = User
+      save_in_memory = Rails.env.test?
+    end
+
+###postfix
+
+ActiveRepository also has an attribute to help you keep your code clean, the postfix. It can be used to define a pattern for Persistence classes so you don't need to keep declaring it everywhere. When using it, your persistence_class name would be \<repository_class_name\> + \<postfix\>.
+
+Here is an example, let's say you have a bunch of Mongoid Documents and you don't want to declare persistence_class for each repository. So you can create a Base Repository and declare the postfix:
 
-      # Set this to true in order to ignore model_class attribute and persist in memory
-      set_save_in_memory(true)
+    class BaseRepository < ActiveRepository::Base
+      # Defines the postfix
+      postfix "Document"
+
+      save_in_memory = false
     end
 
-Then, you have only to set the fields it is going to use:
+You have to rename your Mongoid Documents to the defined pattern, like this:
 
-    class User < ActiveRepository::Base
-      # Defines the fields of the class
-      fields :name, :email, :birthdate
+    class UserDocument
+      include Mongoid::Document
+    end
 
-      set_model_class(UserModel)
+And you can create your repositories inheriting from BaseRepository:
 
-      set_save_in_memory(true)
+    class User < BaseRepository
     end
 
-Now you are all set and ready to go. It is just using ActiveRepository as if it was your ActiveRecord model or Mongoid Document.
+Then you are good to go!!!
+
+###Setting fields
+
+After defining the persistence options, you can set the fields it is going to use:
+
+    class UserRepository < ActiveRepository::Base
+      # Defines the fields of the class
+      fields :name, :email, :birthdate
+
+      persistence_class = User
+      save_in_memory = false
+    end
 
-You can check an example project here: https://github.com/efreesen/sports_betting_engine
+Now you are all set and ready to go. Your business logic is decoupled from the persistence tier!
 
 ## Contributing
 

data/active_repository.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency(%q<active_hash>, [">= 1.2.3"])
   gem.add_runtime_dependency(%q<activemodel>, [">= 3.2"])
-  gem.add_runtime_dependency(%q<sql_query_executor>, [">= 0.3.1"])
+  gem.add_runtime_dependency(%q<sql_query_executor>, [">= 0.3.4"])
   gem.add_development_dependency(%q<pry>)
   gem.add_development_dependency(%q<rspec>, [">= 2.2.0"])
   gem.add_development_dependency(%q<activerecord>, [">= 3.2"])

data/lib/active_repository/adapters/default_adapter.rb

@@ -1,42 +1,42 @@
 class DefaultAdapter
   class << self
     def all(klass)
-      klass.get_model_class.all
+      klass.persistence_class.all
     end
 
     def delete(klass, id)
-      object = klass.get_model_class.where(id: id).first
+      object = klass.persistence_class.where(id: id).first
       object.delete if object
     end
 
     def delete_all(klass)
-      klass.get_model_class.delete_all
+      klass.persistence_class.delete_all
     end
 
     def exists?(klass, id)
-      klass.get_model_class.exists?(id)
+      klass.persistence_class.exists?(id)
     end
 
     def find(klass, id)
       id = normalize_id(id) if id
 
-      klass.get_model_class.find(id)
+      klass.persistence_class.find(id)
     end
 
     def first(klass)
-      klass.get_model_class.first
+      klass.persistence_class.first
     end
 
     def last(klass)
-      klass.get_model_class.last
+      klass.persistence_class.last
     end
 
     def create(klass, attributes)
-      object = klass.get_model_class.create(attributes)
+      object = klass.persistence_class.create(attributes)
     end
 
     def update_attribute(klass, id, key, value)
-      object = id.nil? ? klass.get_model_class.new(key.to_sym => value) : klass.get_model_class.find(id)
+      object = id.nil? ? klass.persistence_class.new(key.to_sym => value) : klass.persistence_class.find(id)
 
       ret = object.update_attribute(key, value)
 
@@ -44,7 +44,7 @@ class DefaultAdapter
     end
 
     def update_attributes(klass, id, attributes)
-      object = id.nil? ? klass.get_model_class.new : klass.get_model_class.find(id)
+      object = id.nil? ? klass.persistence_class.new : klass.persistence_class.find(id)
 
       ret = object.update_attributes(attributes)
 
@@ -52,7 +52,7 @@ class DefaultAdapter
     end
 
     def where(klass, query)
-      klass.get_model_class.where(query.to_sql)
+      klass.persistence_class.where(query.to_sql)
     end
 
   private

data/lib/active_repository/adapters/mongoid_adapter.rb

@@ -11,7 +11,7 @@ class MongoidAdapter < DefaultAdapter
   #   end
 
     def exists?(klass, id)
-      klass.get_model_class.where(:id => id).present?
+      klass.persistence_class.where(:id => id).present?
     end
 
   #   def find(klass, id)
@@ -47,7 +47,7 @@ class MongoidAdapter < DefaultAdapter
   #   end
 
     def where(klass, query)
-      klass.get_model_class.where(query.selector)
+      klass.persistence_class.where(query.selector)
     end
   end
 end

data/lib/active_repository/adapters/persistence_adapter.rb

@@ -4,7 +4,7 @@ require 'active_repository/adapters/mongoid_adapter'
 class PersistenceAdapter
   class << self
     def get_adapter(klass)
-      modules = klass.get_model_class.included_modules.map(&:to_s)
+      modules = klass.persistence_class.included_modules.map(&:to_s)
       if modules.include?("Mongoid::Document")
         MongoidAdapter
       else
@@ -56,8 +56,4 @@ class PersistenceAdapter
       get_adapter(klass).where(klass, args)
     end
   end
-
-  def method_missing(sym, *args, &block)
-    get_adapter(args.first).send(sym, args)
-  end
 end

data/lib/active_repository/associations.rb

@@ -3,6 +3,7 @@
 # Author::    Caio Torres  (mailto:efreesen@gmail.com)
 # License::   GPL
 
+
 module ActiveRepository
   module Associations
     def self.included(base)
@@ -14,33 +15,23 @@ module ActiveRepository
       def has_many(association_id, options = {})
         define_method(association_id) do
           options = {
-            class_name:  association_id.to_s.classify,
-            foreign_key: self.class.to_s.foreign_key
+            class_name:  association_id.to_s.classify
           }.merge(options)
 
+          foreign_key = self.class.to_s.foreign_key
           klass = options[:class_name].constantize
-          objects = []
 
-          klass.where(options[:foreign_key] => id)
+          klass.where(foreign_key => id)
         end
       end
 
       # Defines "has one" type relation between ActiveRepository objects
       def has_one(association_id, options = {})
-        define_method(association_id) do
-          options = {
-            class_name:  association_id.to_s.classify,
-            foreign_key: self.class.to_s.foreign_key
-          }.merge(options)
-
-          scope = options[:class_name].constantize
-
-          scope = scope.where(options[:conditions]) if options[:conditions]
-
-          send_params = scope.respond_to?(:find_by) ? ["find_by", id: id] : ["find_by_id", id]
+        options = {
+          class_name:  association_id.to_s.classify
+        }.merge(options)
 
-          scope.send(*send_params)
-        end
+        has_one_methods(association_id, options)
       end
 
       # Defines "belongs to" type relation between ActiveRepository objects
@@ -52,22 +43,85 @@ module ActiveRepository
 
         field options[:foreign_key].to_sym
 
+        belongs_to_methods(association_id, options)
+      end
+
+    private
+      def has_one_methods(association_id, options)
+        define_has_one_method(association_id, options)
+        define_has_one_setter(association_id, options)
+        define_has_one_create(association_id, options)
+      end
+
+      def belongs_to_methods(association_id, options)
+        define_belongs_to_method(association_id, options)
+        define_belongs_to_setter(association_id, options)
+        define_belongs_to_create(association_id, options)
+      end
+
+      def define_has_one_method(association_id, options)
+        define_method(association_id) do
+          foreign_key = self.class.to_s.foreign_key
+          klass       = options[:class_name].constantize
+
+          klass.where(foreign_key => self.id).first
+        end
+      end
+
+      def define_has_one_setter(association_id, options)
+        define_method("#{association_id}=") do |object|
+          primary_key = self.send(self.class.primary_key)
+          foreign_key = self.class.to_s.foreign_key
+          association = self.send(association_id)
+
+          association.update_attribute(foreign_key, nil) if association
+
+          object.update_attribute(foreign_key, primary_key) if object
+        end
+      end
+
+      def define_has_one_create(association_id, options)
+        define_method("create_#{association_id}") do |attributes|
+          primary_key = self.send(self.class.primary_key)
+          foreign_key = self.class.to_s.foreign_key
+          association = self.send(association_id)
+          klass       = options[:class_name].constantize
+
+          association.update_attribute(foreign_key, nil) if 
+          self.send("#{association_id}=", nil)
+
+          klass.create(attributes.merge(foreign_key => primary_key))
+        end
+      end
+
+      def define_belongs_to_method(association_id, options)
         define_method(association_id) do
           klass = options[:class_name].constantize
-          id    = send(options[:foreign_key])
+          foreign_key = send(options[:foreign_key])
 
-          if id.present?
-            object = klass.respond_to?(:find_by) ? klass.find_by(id: id) : klass.find_by_id(id)
-          else
-            nil
-          end
+          klass.where(klass.primary_key => foreign_key).first
         end
+      end
 
+      def define_belongs_to_setter(association_id, options)
         define_method("#{association_id}=") do |new_value|
           attributes.delete(association_id.to_sym)
           send("#{options[:foreign_key]}=", (new_value.try(:id) ? new_value.id : new_value))
         end
       end
+
+      def define_belongs_to_create(association_id, options)
+        define_method("create_#{association_id}") do |attributes|
+          klass = options[:class_name].constantize
+
+          object = klass.create(attributes)
+
+          self.update_attribute(options[:foreign_key], object.id)
+
+          object
+        end
+      end
+
     end
   end
 end

data/lib/active_repository/base.rb

@@ -47,8 +47,8 @@ module ActiveRepository
   # Using ActiveRecord/Mongoid to persist objects:
   #
   #    class SaveInORMOrODMTest < ActiveRepository::Base
-  #      SaveInORMOrODMTest.set_model_class(ORMOrODMModelClass)
-  #      SaveInORMOrODMTest.set_save_in_memory(false)
+  #      SaveInORMOrODMTest.persistence_class = ORMOrODMModelClass
+  #      SaveInORMOrODMTest.save_in_memory = false
   #    end
   #
   # Author::    Caio Torres (mailto:efreesen@gmail.com)
@@ -62,12 +62,11 @@ module ActiveRepository
     include ActiveRepository::Associations
     include ActiveRepository::Writers::InstanceMethods
 
-    class_attribute :model_class, :save_in_memory, :instance_writer => false
+    class_attribute :model_class, :instance_writer => false
+    class_attribute :save_in_memory, :postfix, :instance_writer => true
 
     after_validation :set_timestamps
 
-    self.save_in_memory = true if self.save_in_memory == nil
-
     # Returns all persisted objects
     def self.all
       (repository? ? super : PersistenceAdapter.all(self).map { |object| serialize!(object.attributes) })
@@ -88,10 +87,16 @@ module ActiveRepository
       repository? ? find_by(id: id).present? : PersistenceAdapter.exists?(self, id)
     end
 
+    def self.persistence_class
+      return self if save_in_memory? || (postfix.nil? && self.model_class.nil?)
+      return "#{self}#{postfix.classify}".constantize if postfix.present?
+      self.model_class.to_s.constantize
+    end
+
     # Returns the Class responsible for persisting the objects
     def self.get_model_class
-      return self if self.model_class.nil? || self.save_in_memory?
-      save_in_memory? ? self : self.model_class
+      puts '[deprecation warning] This method is going to be deprecated, use "persistence_class" instead.'
+      persistence_class
     end
 
     # Searches all objects that matches #field_name field with the #args value(s)
@@ -121,21 +126,29 @@ module ActiveRepository
       end
     end
 
-    # Returns a array with the field names of the Class
+    # Returns an array with the field names of the Class
     def self.serialized_attributes
       field_names.map &:to_s
     end
 
+    def self.persistence_class=(value)
+      self.model_class = value
+    end
+
     # Sets the class attribute model_class, responsible to persist the ActiveRepository objects
     def self.set_model_class(value)
-      self.model_class = value if model_class.nil?
+      puts '[deprecation warning] This method is going to be deprecated, use "persistence_class=" instead.'
+      persistence_class = value
+    end
 
-      self.set_save_in_memory(repository?)
+    def self.save_in_memory?
+      self.save_in_memory == nil ? true : self.save_in_memory
     end
 
     # Sets the class attribute save_in_memory, set it to true to ignore model_class attribute
     # and persist objects in memory
     def self.set_save_in_memory(value)
+      puts '[deprecation warning] This method is going to be deprecated, use "save_in_memory=" instead.'
       self.save_in_memory = value
     end
 
@@ -151,8 +164,6 @@ module ActiveRepository
 
       result_set = ActiveRepository::ResultSet.new(self)
 
-      # binding.pry
-
       result_set.where(args)
 
       # if repository?
@@ -168,8 +179,13 @@ module ActiveRepository
       # end
     end
 
+    def persistence_class
+      self.class.persistence_class
+    end
+
     def get_model_class
-      self.class.get_model_class
+      puts '[deprecation warning] This method is going to be deprecated, use "persistence_class" instead.'
+      self.class.persistence_class
     end
 
     # Persists the object using the class defined on the model_class attribute, if none defined it 
@@ -183,15 +199,15 @@ module ActiveRepository
     # Gathers the persisted object from database and updates self with it's attributes.
     def reload
       object = self.id.present? ? 
-                 get_model_class.where(id: self.id).first_or_initialize : 
+                 persistence_class.where(id: self.id).first_or_initialize : 
                  self
 
       serialize! object.attributes
     end
 
     def save(force=false)
-      if self.class == get_model_class
-        object = get_model_class.where(id: self.id).first_or_initialize
+      if self.class == persistence_class
+        object = persistence_class.where(id: self.id).first_or_initialize
 
         if force || self.id.nil?
           self.id = nil if self.id.nil?
@@ -223,10 +239,10 @@ module ActiveRepository
       # Find related object on the database and updates it with attributes in self, if it didn't
       # find it on database it creates a new one.
       def convert(attribute="id")
-        klass = get_model_class
+        klass = persistence_class
         object = klass.where(attribute.to_sym => self.send(attribute)).first
 
-        object ||= get_model_class.new
+        object ||= persistence_class.new
 
         attributes = self.attributes
 
@@ -243,7 +259,7 @@ module ActiveRepository
 
     private
       def self.repository?
-        self == get_model_class
+        self == persistence_class
       end
 
       # Updates created_at and updated_at

data/lib/active_repository/finders.rb

@@ -1,7 +1,7 @@
 # Module containing methods responsible for searching ActiveRepository objects
 module ActiveRepository #:nodoc:
   module Finders #:nodoc:
-    # Searches for a object containing the id in #id
+    # Searches for an object containing the id in #id
     def find(id)
       begin
         if repository?

data/lib/active_repository/result_set.rb

@@ -2,13 +2,21 @@ class ActiveRepository::ResultSet
 	def initialize(klass, query={}, attributes={})
     @klass = klass
     convert_query(query)
-    @attributes = query.is_a?(Hash) ? attributes.merge(query) : attributes
+    @attributes = attributes.merge(SqlQueryExecutor::Query::Normalizers::QueryNormalizer.attributes_from_query(query))
   end
 
   def all
     @query ? get_result(@query) : @klass.all
   end
 
+  def build(attributes)
+    @klass.new(@attributes.merge(attributes))
+  end
+
+  def create(attributes)
+    @klass.create(@attributes.merge(attributes))
+  end
+
   def count
     all.size
   end
@@ -51,7 +59,7 @@ class ActiveRepository::ResultSet
 
 private
   def convert_query(query)
-    @query = SqlQueryExecutor::Query::QueryNormalizer.clean_query(query)
+    @query = SqlQueryExecutor::Query::Normalizers::QueryNormalizer.clean_query(query)
   end
 
   def get_result(args)
@@ -70,7 +78,7 @@ private
   end
 
   def join_query(query, separator)
-    query = SqlQueryExecutor::Query::QueryNormalizer.clean_query(query)
+    query = SqlQueryExecutor::Query::Normalizers::QueryNormalizer.clean_query(query)
     query.blank? ? @query : (@query.blank? ? query : "(#{@query}) #{separator} (#{query})")
   end
 end

data/lib/active_repository/uniqueness.rb

@@ -11,62 +11,15 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        duplicate = record.get_model_class.where("id != ?", record.id).select do |object|
+        duplicate = record.class.where("id is not ?", (record.id ? record.id : 'null')).all.select do |object|
           object.id != record.id && object.send(attribute) == record.send(attribute)
         end
 
         record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope, :conditions).merge(:value => value)) if duplicate.any?
       end
-
-    protected
-
-      # The check for an existing value should be run from a class that
-      # isn't abstract. This means working down from the current class
-      # (self), to the first non-abstract class. Since classes don't know
-      # their subclasses, we have to build the hierarchy between self and
-      # the record's class.
-      def find_finder_class_for(record) #:nodoc:
-        class_hierarchy = [record.class]
-
-        while class_hierarchy.first != @klass
-          class_hierarchy.prepend(class_hierarchy.first.superclass)
-        end
-
-        class_hierarchy.detect { |klass| klass.respond_to?(:abstract_class?) ? !klass.abstract_class? : true }
-      end
-
-      def build_relation(klass, table, attribute, value) #:nodoc:
-        column, attribute, value = get_reflection_attributes(klass)
-
-        value = column.limit ? value.to_s[0, column.limit] : value.to_s if !value.nil? && column.text?
-
-        if !options[:case_sensitive] && value && column.text?
-          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
-          relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
-        else
-          value    = klass.connection.case_sensitive_modifier(value) unless value.nil?
-          relation = table[attribute].eq(value)
-        end
-
-        relation
-      end
-
-    private
-      def get_reflection_attributes(klass, attribute, value)
-        reflection = klass.reflect_on_association(attribute)
-        column     = klass.columns_hash[reflection.foreign_key]
-
-        if reflection
-          attribute = reflection.foreign_key
-          value = value.attributes[reflection.primary_key_column.name]
-        else
-          column = klass.columns_hash[attribute.to_s]
-        end
-
-        [column, attribute, value]
-      end
     end
 
+    private
     module ClassMethods
       # Validates whether the value of the specified attributes are unique
       # across the system. Useful for making sure that only one user
@@ -167,7 +120,7 @@ module ActiveModel
       #                                      | # title!
       #
       # This could even happen if you use transactions with the 'serializable'
-      # isolation level. The best way to work around this problem is to add a unique
+      # isolation level. The best way to work around this problem is to add an unique
       # index to the database table using
       # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
       # rare case that a race condition occurs, the database will guarantee

data/lib/active_repository/version.rb

@@ -1,3 +1,3 @@
 module ActiveRepository
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/active_repository/write_support.rb

@@ -79,7 +79,7 @@ module ActiveHash
     end
 
     def eql?(other)
-      (other.instance_of?(self.class) || other.instance_of?(get_model_class)) && id.present? && (id == other.id) && (!self.respond_to?(:created_at) || (created_at == other.created_at))
+      (other.instance_of?(self.class) || other.instance_of?(persistence_class)) && id.present? && (id == other.id) && (!self.respond_to?(:created_at) || (created_at == other.created_at))
     end
 
     alias == eql?

data/lib/active_repository/writers.rb

@@ -7,7 +7,7 @@ module ActiveRepository
       object = self.new(attributes)
 
       if object.present? && object.valid?
-        if get_model_class == self
+        if persistence_class == self
           object.id = nil unless exists?(object.id)
 
           object.save
@@ -35,7 +35,7 @@ module ActiveRepository
       # Deletes self from the repository.
       def delete
         klass = self.class
-        if klass.get_model_class == klass
+        if klass.persistence_class == klass
           super
         else
           PersistenceAdapter.delete(klass, self.id)
@@ -47,7 +47,7 @@ module ActiveRepository
         ret = true
         key = key.to_sym
 
-        if self.class == get_model_class
+        if self.class == persistence_class
           object = self.class.where(:id => self.id).first_or_initialize
 
           self.send("#{key}=", value)
@@ -68,7 +68,7 @@ module ActiveRepository
       def update_attributes(attributes)
         attributes  = attributes.symbolize_keys if attributes.respond_to?(:symbolize_keys)
         klass       = self.class
-        model_class = get_model_class
+        model_class = persistence_class
 
         if klass == model_class
           attributes.each do |key, value|

data/spec/active_repository/associations_spec.rb

@@ -18,6 +18,7 @@ describe ActiveRepository::Base, "associations" do
     end
 
     class City < ActiveRepository::Base
+      fields :name
     end
 
     class Author < ActiveRepository::Base
@@ -68,7 +69,7 @@ describe ActiveRepository::Base, "associations" do
       end
     end
 
-    context "with ActiveHash children" do
+    context "with ActiveRepository children" do
       before do
         Author.field :city_id
         @included_author_1 = Author.create :city_id => 1
@@ -92,7 +93,6 @@ describe ActiveRepository::Base, "associations" do
   end
 
   describe "#belongs_to" do
-
     context "with an ActiveRecord parent" do
       it "find the correct records" do
         City.belongs_to :country
@@ -108,7 +108,7 @@ describe ActiveRepository::Base, "associations" do
       end
     end
 
-    context "with an ActiveHash parent" do
+    context "with an ActiveRepository parent" do
       it "find the correct records" do
         Author.belongs_to :city
         city = City.create
@@ -164,6 +164,21 @@ describe ActiveRepository::Base, "associations" do
         author.city_id.should == @city.id
       end
     end
+
+    describe '#create_association' do
+      before do
+        Author.belongs_to :city
+      end
+
+      it "creates a city related to author" do
+        author = Author.new
+        city = author.create_city(name: 'Metropolis')
+
+        author.city.name.should == 'Metropolis'
+        author.city_id.should == city.id
+        author.city.should == city
+      end
+    end
   end
 
   describe "#has_one" do
@@ -184,7 +199,7 @@ describe ActiveRepository::Base, "associations" do
       end
     end
 
-    context "with ActiveHash children" do
+    context "with ActiveRepository children" do
       before do
         City.has_one :author
         Author.field :city_id
@@ -201,6 +216,34 @@ describe ActiveRepository::Base, "associations" do
         city.author.should be_nil
       end
     end
+
+    describe '#create_association' do
+      before do
+        City.has_one :author
+        Author.field :city_id
+        Author.field :name
+      end
+
+      it "creates a city related to author" do
+        city = City.create
+        author = city.create_author(name: 'Clark Kent')
+
+        city.author.name.should == 'Clark Kent'
+        author.city_id.should == city.id
+        city.author.should == author
+      end
+
+      it "replaces existing relation" do
+        city = City.create
+        old_author = city.create_author(name: 'Clark Kent')
+        author = city.create_author(name: 'Bruce Wayne')
+
+        Author.where(city_id: city.id).count.should == 1
+        city.author.name.should == 'Bruce Wayne'
+        author.city_id.should == city.id
+        city.author.should == author
+      end
+    end
   end
 
   describe "#marked_for_destruction?" do
@@ -227,8 +270,8 @@ describe ActiveRepository::Base, "associations" do
       end
 
       class State < ActiveRepository::Base
-        State.set_model_class(StateModel)
-        State.set_save_in_memory(false)
+        State.persistence_class = StateModel
+        State.save_in_memory = false
         belongs_to :country
         has_many :cities
 
@@ -244,8 +287,8 @@ describe ActiveRepository::Base, "associations" do
       end
 
       class City < ActiveRepository::Base
-        City.set_model_class(CityModel)
-        City.set_save_in_memory(false)
+        City.persistence_class = CityModel
+        City.save_in_memory = false
         belongs_to :state
         has_many   :regions
       end

data/spec/active_repository/base_spec.rb

@@ -9,6 +9,7 @@ describe ActiveRepository, "Base" do
 
   before do
     class Country < ActiveRepository::Base
+      validates_presence_of :name
     end
   end
 
@@ -16,11 +17,51 @@ describe ActiveRepository, "Base" do
     Object.send :remove_const, :Country
   end
 
+  describe 'postfix' do
+    before do
+      class CountryPersistence
+      end
+    end
+
+    context 'when postfix is present' do
+      before do
+        Country.postfix = "persistence"
+        Country.save_in_memory = false
+      end
+
+      it 'in persistence_class returns class name and postfix' do
+        Country.persistence_class.to_s.should == "CountryPersistence"
+      end
+    end
+
+    context 'when postfix and persistence_class are present' do
+      before do
+        Country.postfix = "persistence"
+        Country.persistence_class = "CountryModel"
+        Country.save_in_memory = false
+      end
+
+      it 'in persistence_class returns class name and postfix' do
+        Country.persistence_class.to_s.should == "CountryPersistence"
+      end
+    end
+
+    context 'whe postfix and savi_in_memory are present' do
+      before do
+        Country.postfix = "persistence"
+      end
+
+      it 'in persistence_class returns class name and postfix' do
+        Country.persistence_class.to_s.should == "Country"
+      end
+    end
+  end
+
   context "in_memory", :in_memory do
     before do
       Country.fields :name, :monarch, :language, :created_at, :updated_at
-      Country.set_model_class(Country)
-      Country.set_save_in_memory(true)
+      Country.persistence_class = Country
+      Country.save_in_memory = true
 
       Country.create(:id => 1, :name => "US",     :language => 'English')
       Country.create(:id => 2, :name => "Canada", :language => 'English', :monarch => "The Crown of England")
@@ -63,6 +104,7 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
     it_behaves_like '#delete'
+    it_behaves_like 'uniqueness'
   end
 
   context "active_record", :active_record do
@@ -81,8 +123,8 @@ describe ActiveRepository, "Base" do
         end
       end
 
-      Country.set_model_class(CountryModel)
-      Country.set_save_in_memory(false)
+      Country.persistence_class = CountryModel
+      Country.save_in_memory = false
 
       Country.create(:id => 1, :name => "US",     :language => 'English')
       Country.create(:id => 2, :name => "Canada", :language => 'English', :monarch => "The Crown of England")
@@ -129,6 +171,7 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
     it_behaves_like '#delete'
+    it_behaves_like 'uniqueness'
   end
 
   context "mongoid", :mongoid do
@@ -150,8 +193,8 @@ describe ActiveRepository, "Base" do
         field :created_at
       end
 
-      Country.set_model_class(CountryModel)
-      Country.set_save_in_memory(false)
+      Country.persistence_class = CountryModel
+      Country.save_in_memory = false
 
       Country.delete_all
 
@@ -200,5 +243,6 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
     it_behaves_like '#delete'
+    it_behaves_like 'uniqueness'
   end
 end

data/spec/active_repository/result_set_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 require 'active_repository'
 require 'active_repository/result_set'
-require 'pry'
 
 describe ActiveRepository::ResultSet, :result_set do
   before do
@@ -85,7 +84,7 @@ describe ActiveRepository::ResultSet, :result_set do
   end
 
   describe '#and' do
-    it 'is a alias for #where' do
+    it 'is an alias for #where' do
       expect(described_class.instance_method(:and)).to eq described_class.instance_method(:where)
     end
   end
@@ -112,6 +111,48 @@ describe ActiveRepository::ResultSet, :result_set do
     end
   end
 
+  describe '#build' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    it "returns a Country object" do
+      expect(subject.build(name: 'Canada')).to be_a(Country)
+    end
+
+    it 'returns a new_record' do
+      result = subject.build(continent: 'America')
+
+      expect(result).to be_new_record
+    end
+
+    it 'merges attributes' do
+      result_set = subject.where(name: 'Canada')
+      result = result_set.build(continent: 'America')
+
+      expect(result.attributes).to eq(name: 'Canada', continent: 'America')
+    end
+  end
+
+  describe '#create' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    it "returns a Country object" do
+      expect(subject.create(name: 'Canada')).to be_a(Country)
+    end
+
+    it 'returns a persisted object' do
+      result = subject.create(continent: 'America')
+
+      expect(result).not_to be_new_record
+    end
+
+    it 'merges attributes' do
+      result_set = subject.where(name: 'Canada')
+      result = result_set.create(continent: 'America')
+
+      expect(result.attributes).to eq(name: 'Canada', continent: 'America', id: result.id)
+    end
+  end
+
   describe '#all' do
     before do
       Country.delete_all
@@ -243,7 +284,7 @@ describe ActiveRepository::ResultSet, :result_set do
           it 'returns a new object with specified attributes' do
             object = subject.where("name = 'Poland'").first_or_initialize
 
-            expect(object.attributes).to eq({})
+            expect(object.attributes).to eq(name: 'Poland')
           end
         end
       end
@@ -271,13 +312,13 @@ describe ActiveRepository::ResultSet, :result_set do
           it 'returns a new object with all Hashes as attributes' do
             object = subject.where(name: 'Poland').and("continent = 'Europe'").first_or_initialize
 
-            expect(object.attributes).to eq(name: 'Poland')
+            expect(object.attributes).to eq(name: 'Poland', continent: 'Europe')
           end
 
           it 'returns a new object with all Hashes as attributes' do
             object = subject.where("name = 'Poland'").and("continent = 'Europe'").first_or_initialize
 
-            expect(object.attributes).to eq({})
+            expect(object.attributes).to eq(name: 'Poland', continent: 'Europe')
           end
         end
       end
@@ -323,7 +364,7 @@ describe ActiveRepository::ResultSet, :result_set do
           it 'returns a new object with specified attributes' do
             object = subject.where("name = 'Poland'").first_or_create
 
-            expect(object.attributes).to eq(id: 5)
+            expect(object.attributes).to eq(name: 'Poland', id: 5)
           end
         end
       end
@@ -351,13 +392,13 @@ describe ActiveRepository::ResultSet, :result_set do
           it 'returns a new object with all Hashes as attributes' do
             object = subject.where(name: 'Poland').and("continent = 'Europe'").first_or_create
 
-            expect(object.attributes).to eq(id: 5, name: 'Poland')
+            expect(object.attributes).to eq(id: 5, name: 'Poland', continent: 'Europe')
           end
 
           it 'returns a new object with all Hashes as attributes' do
             object = subject.where("name = 'Poland'").and("continent = 'Europe'").first_or_create
 
-            expect(object.attributes).to eq(id: 5)
+            expect(object.attributes).to eq(:name=>"Poland", :continent=>"Europe", :id=>5)
           end
         end
       end

data/spec/support/shared_examples.rb

@@ -88,7 +88,7 @@ shared_examples ".where" do
     results.last.name.should == "UK"
   end
 
-  it "filters the records from a AR-like conditions hash" do
+  it "filters the records from an AR-like conditions hash" do
     first_id = Country.first.id
 
     results = Country.where(:name => 'US').all
@@ -194,7 +194,7 @@ shared_examples ".find_by" do
     end
   end
 
-  context 'with a existing name' do
+  context 'with an existing name' do
     it "returns found element" do
       Country.find_by(name: 'Canada').should == Country.all[1]
     end
@@ -236,7 +236,7 @@ shared_examples ".find_by!" do
     end
   end
 
-  context 'with a existing name' do
+  context 'with an existing name' do
     it "returns found element" do
       Country.find_by!(name: 'Canada').should == Country.all[1]
     end
@@ -441,7 +441,7 @@ end
 
 shared_examples "#to_param" do
   it "should return id as a string" do
-    country = Country.create
+    country = Country.create(name: 'Brazil')
     country.to_param.should == country.id.to_s
   end
 end
@@ -449,7 +449,7 @@ end
 shared_examples "#persisted?" do
   it "should return true if the object has been saved" do
     Country.delete_all
-    Country.create(:id => 2).should be_persisted
+    Country.create(:id => 2, name: 'Brazil').should be_persisted
   end
 
   it "should return false if the object has not been saved" do
@@ -563,6 +563,12 @@ shared_examples "#save" do
     Country.delete_all
   end
 
+  it "does not add object to the collection if it is not valid" do
+    country = Country.new :monarch => "King", :language => "bar"
+    country.save.should be_false
+    Country.count.should == 0
+  end
+
   it "adds the new object to the data collection" do
     Country.all.should be_empty
     country = Country.new :name => "foo", :monarch => "King", :language => "bar"
@@ -589,7 +595,7 @@ shared_examples ".create" do
 
   it "works with no args" do
     Country.all.should be_empty
-    country = Country.create
+    country = Country.create(name: 'Brazil')
 
     country.id.should == Country.last.id
   end
@@ -656,7 +662,7 @@ end
 
 shared_examples "#valid?" do
   it "should return true" do
-    Country.new.should be_valid
+    Country.new(name: 'Brazil').should be_valid
   end
 end
 
@@ -704,7 +710,7 @@ shared_examples "#delete" do
   end
 
   it "removes a record" do
-    country = Country.create
+    country = Country.create(name: 'Brazil')
 
     Country.count.should == 1
 
@@ -720,8 +726,8 @@ shared_examples ".delete_all" do
   end
 
   it "clears out all record" do
-    country1 = Country.create
-    country2 = Country.create
+    country1 = Country.create(name: 'Brazil')
+    country2 = Country.create(name: 'Brazil')
 
     countries_attributes = Country.all.map(&:attributes)
     expected_attributes  = [country1, country2].map(&:attributes)
@@ -740,4 +746,21 @@ shared_examples ".delete_all" do
     Country.delete_all
     Country.all.should be_empty
   end
+end
+
+shared_examples "uniqueness" do
+  before do
+    Country.delete_all
+    Country.validates_uniqueness_of :name
+  end
+
+  it "does not accept duplicated ids" do
+    country1 = Country.create(name: 'Brazil')
+    country2 = Country.create(name: 'Brazil')
+
+    country1.should be_valid
+    country2.should_not be_valid
+    Country.count.should == 1
+    Country.all.should == [country1]
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_repository
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Caio Torres
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_hash
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.3.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement