active_repository 0.0.5 → 0.1.0

data/Gemfile

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

data/README.md

@@ -48,16 +48,16 @@ Or install it yourself as:
 
 Firstly you must inherit ActiveRepository::Base:
 
-  class User < ActiveHash::Base
-    # Defines the fields of the class
-    fields :name, :email, :birthdate
+    class User < ActiveHash::Base
+      # Defines the fields of the class
+      fields :name, :email, :birthdate
 
-    # Defines the class responsible for persisting data
-    set_model_class(Country)
+      # Defines the class responsible for persisting data
+      set_model_class(Country)
 
-    # Set this to true in order to ignore model_class attribute and persist in memory
-    set_save_in_memory(true)
-  end
+      # Set this to true in order to ignore model_class attribute and persist in memory
+      set_save_in_memory(true)
+    end
 
 Then it is just using it as if it was your ActiveRecord model or Mongoid Document.
 

data/active_repository.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/active_repository/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Caio Torres"]
+  gem.email         = ["efreesen@gmail.com"]
+  gem.description   = %q{An implementation of repository pattern that can connect with any ORM}
+  gem.summary       = %q{An implementation of repository pattern that can connect with any ORM}
+  gem.homepage      = "http://github.com/efreesen/active_repository"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "active_repository"
+  gem.require_paths = ["lib"]
+  gem.version       = ActiveRepository::VERSION
+  gem.license       = "MIT"
+  gem.files         = [
+    "LICENSE",
+    "README.md",
+    "active_repository.gemspec",
+    Dir.glob("lib/**/*")
+  ].flatten
+  gem.test_files = [
+    "Gemfile",
+    "spec/active_repository/base_spec.rb",
+    "spec/active_repository/associations_spec.rb",
+    "spec/active_repository/sql_query_executor_spec.rb",
+    "spec/support/shared_examples.rb",
+    "spec/support/sql_query_shared_examples.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  gem.add_runtime_dependency(%q<active_hash>, [">= 0.9.12"])
+  gem.add_runtime_dependency(%q<activemodel>, [">= 3.2.6"])
+  gem.add_development_dependency(%q<rspec>, [">= 2.2.0"])
+  gem.add_development_dependency(%q<activerecord>)
+  gem.add_development_dependency(%q<mongoid>)
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency(%q<sqlite3>) unless RUBY_PLATFORM == 'java'
+  gem.add_development_dependency(%q<jdbc-sqlite3>)  if RUBY_PLATFORM == 'java'
+  gem.add_development_dependency(%q<jruby-openssl>)  if RUBY_PLATFORM == 'java'
+  gem.add_development_dependency(%q<activerecord-jdbcsqlite3-adapter>)  if RUBY_PLATFORM == 'java'
+end

data/lib/active_repository/associations.rb

@@ -0,0 +1,110 @@
+# Defines the relations between ActiveRepository objects and/or ActiveRecord Models.
+#
+# Author::    Caio Torres  (mailto:efreesen@gmail.com)
+# License::   MIT
+
+module ActiveRepository
+  module Associations
+
+    #:nodoc:
+    module ActiveRecordExtensions
+
+      
+      # Defines belongs to type relation between ActiveRepository objects and ActivRecord Models.
+      def belongs_to_active_repository(association_id, options = {})
+        options = {
+          :class_name => association_id.to_s.classify,
+          :foreign_key => association_id.to_s.foreign_key
+        }.merge(options)
+
+        define_method(association_id) do
+          options[:class_name].constantize.find_by_id(send(options[:foreign_key]))
+        end
+
+        define_method("#{association_id}=") do |new_value|
+          send "#{options[:foreign_key]}=", new_value ? new_value.id : nil
+        end
+
+        create_reflection(
+            :belongs_to,
+            association_id.to_sym,
+            options,
+            options[:class_name].constantize
+            )
+      end
+
+    end
+
+    #:nodoc:
+    def self.included(base)
+      base.extend Methods
+    end
+
+    #:nodoc:
+    module Methods
+      # Defines "has many" type relation between ActiveRepository objects
+      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
+          }.merge(options)
+
+          klass = options[:class_name].constantize
+          objects = []
+
+          if klass.respond_to?(:scoped)
+            objects = klass.scoped(:conditions => {options[:foreign_key] => id})
+          else
+            objects = klass.send("find_all_by_#{options[:foreign_key]}", id)
+          end
+        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
+
+          if scope.respond_to?(:scoped) && options[:conditions]
+            scope = scope.scoped(:conditions => options[:conditions])
+          end
+          scope.send("find_by_#{options[:foreign_key]}", id)
+        end
+      end
+
+      # Defines "belongs to" type relation between ActiveRepository objects
+      def belongs_to(association_id, options = {})
+
+        options = {
+          :class_name => association_id.to_s.classify,
+          :foreign_key => association_id.to_s.foreign_key
+        }.merge(options)
+
+        field options[:foreign_key].to_sym
+
+        define_method(association_id) do
+          klass = options[:class_name].constantize
+          id    = send(options[:foreign_key])
+
+          if id.present?
+            object = klass.find_by_id(id)
+          else
+            nil
+          end
+        end
+
+        define_method("#{association_id}=") do |new_value|
+          attributes[options[:foreign_key].to_sym] = new_value ? new_value.id : nil
+        end
+
+      end
+    end
+
+  end
+end

data/lib/active_repository/base.rb

@@ -0,0 +1,216 @@
+require 'active_repository/associations'
+require 'active_repository/uniqueness'
+require 'active_repository/write_support'
+require 'active_repository/sql_query_executor'
+require 'active_repository/finders'
+require 'active_repository/writers'
+
+module ActiveRepository
+
+  # Base class for ActiveRepository gem.
+  # Extends it in order to use it.
+  # 
+  # == Options
+  #
+  # There are 2 class attributes to help configure your ActiveRepository class:
+  #
+  #   * +class_model+: Use it to specify the class that is responsible for the
+  #     persistence of the objects. Default is self, so it is always saving in
+  #     memory by default.
+  #
+  #   * +save_in_memory+: Used to ignore the class_model attribute, you can use
+  #     it in your test suite, this way all your tests will be saved in memory.
+  #     Default is set to true so it saves in memory by default.
+  #     
+  #
+  # == Examples
+  #
+  # Using ActiveHash to persist objects in memory:
+  #
+  #   class SaveInMemoryTest < ActiveRepository::Base
+  #   end
+  #
+  # Using ActiveRecord/Mongoid to persist objects:
+  #
+  #    class SaveInORMOrODMTest < ActiveRepository::Base
+  #      SaveInORMOrODMTest.set_model_class(ORMOrODMModelClass)
+  #      SaveInORMOrODMTest.set_save_in_memory(false)
+  #    end
+  #
+  # Author::    Caio Torres  (mailto:efreesen@gmail.com)
+  # License::   MIT
+  class Base < ActiveHash::Base
+    extend ActiveModel::Callbacks
+    extend ActiveRepository::Finders
+    extend ActiveRepository::Writers
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+    include ActiveRepository::Associations
+    include ActiveRepository::Writers::InstanceMethods
+
+    class_attribute :model_class, :save_in_memory, :instance_writer => false
+
+    before_validation :set_timestamps
+
+    fields :created_at, :updated_at
+
+    # Returns all persisted objects
+    def self.all
+      self == get_model_class ? super : get_model_class.all.map { |object| serialize!(object.attributes) }
+    end
+
+    # Constantize class name
+    def self.constantize
+      self.to_s.constantize
+    end
+
+    # Deletes all persisted objects
+    def self.delete_all
+      self == get_model_class ? super : get_model_class.delete_all
+    end
+
+    # Checks the existence of a persisted object with the specified id
+    def self.exists?(id)
+      if self == get_model_class
+        !find_by_id(id).nil?
+      else
+        if mongoid?
+          find_by_id(id).present?
+        else
+          get_model_class.exists?(id)
+        end
+      end
+    end
+
+    # Returns the Class responsible for persisting the objects
+    def self.get_model_class
+      return self if self.save_in_memory.nil?
+      save_in_memory? ? self : self.model_class
+    end
+
+    # Converts Persisted object(s) to it's ActiveRepository counterpart
+    def self.serialize!(other)
+      case other.class.to_s
+      when "Hash" then self.new.serialize!(other)
+      when "Array" then other.map { |o| serialize!(o.attributes) }
+      when "Moped::BSON::Document" then self.new.serialize!(other)
+      else self.new.serialize!(other.attributes)
+      end
+    end
+
+    # Returns a array with the field names of the Class
+    def self.serialized_attributes
+      field_names.map &:to_s
+    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?
+
+      field_names.each do |field_name|
+        define_custom_find_by_field(field_name)
+        define_custom_find_all_by_field(field_name)
+      end
+    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)
+      self.save_in_memory = value if save_in_memory.nil?
+    end
+
+    # Searches persisted objects that matches the criterias in the parameters.
+    # Can be used in ActiveRecord/Mongoid way or in SQL like way.
+    #
+    # Example:
+    #
+    #   * RelatedClass.where(:name => "Peter")
+    #   * RelatedClass.where("name = 'Peter'")
+    def self.where(*args)
+      raise ArgumentError.new("wrong number of arguments (0 for 1)") if args.empty?
+      if self == get_model_class
+        query = ActiveHash::SQLQueryExecutor.args_to_query(args)
+        super(query)
+      else
+        objects = []
+        args = args.first.is_a?(Hash) ? args.first : args
+        get_model_class.where(args).each do |object|
+          objects << self.serialize!(object.attributes)
+        end
+
+        objects
+      end
+    end
+
+    # Persists the object using the class defined on the model_class attribute, if none defined it 
+    # is saved in memory.
+    def persist
+      if self.valid?
+        save_in_memory? ? save : self.convert
+      end
+    end
+
+    # Gathers the persisted object from database and updates self with it's attributes.
+    def reload
+      serialize! self.class.get_model_class.find(self.id).attributes
+    end
+
+    # Returns the value of the save_in_memory class attribute
+    def save_in_memory?
+      self.save_in_memory.nil? ? true : save_in_memory
+    end
+
+    # Updates attributes from self with the attributes from the parameters
+    def serialize!(attributes)
+      unless attributes.nil?
+        self.attributes = attributes
+      end
+
+      self
+    end
+
+    protected
+      # 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 = self.class.get_model_class
+        object = klass.where(attribute.to_sym => self.send(attribute)).first
+        
+        object ||= self.class.get_model_class.new
+
+        attributes = self.attributes
+
+        attributes.delete(:id)
+
+        object.attributes = attributes
+
+        object.save
+
+        self.id = object.id
+
+        object
+      end
+
+      # Returns the value of the model_class attribute.
+      def model_class
+        self.model_class
+      end
+
+    private
+      # Checks if model_class is a Mongoid model
+      def self.mongoid?
+        get_model_class.included_modules.include?(Mongoid::Document)
+      end
+
+      # Checks if model_class is a Mongoid model
+      def mongoid?
+        self.class.mongoid?
+      end
+
+      # Updates created_at and updated_at
+      def set_timestamps
+        self.created_at = DateTime.now.utc if self.new_record?
+        self.updated_at = DateTime.now.utc
+      end
+  end
+end

data/lib/active_repository/finders.rb

@@ -0,0 +1,107 @@
+# Module containing methods responsible for searching ActiveRepository objects
+module ActiveRepository #:nodoc:
+  module Finders #:nodoc:
+    # Defines fiend_by_field methods for the Class
+    def define_custom_find_by_field(field_name)
+      method_name = :"find_all_by_#{field_name}"
+      the_meta_class.instance_eval do
+        define_method(method_name) do |*args|
+          object = nil
+
+          object = self.find_by_field(field_name.to_sym, args)
+
+          object.nil? ? nil : serialize!(object.attributes)
+        end
+      end
+    end
+
+    # Defines fiend_all_by_field methods for the Class
+    def define_custom_find_all_by_field(field_name)
+      method_name = :"find_all_by_#{field_name}"
+      the_meta_class.instance_eval do
+        define_method(method_name) do |*args|
+          objects = []
+
+          objects = self.find_all_by_field(field_name.to_sym, args)
+
+          objects.empty? ? [] : objects.map{ |object| serialize!(object.attributes) }
+        end
+      end
+    end
+
+    # Searches for a object containing the id in #id
+    def find(id)
+      begin
+        if self == get_model_class
+          super(id)
+        else
+          object = (id == :all) ? all : get_model_class.find(id)
+
+          serialize!(object)
+        end
+      rescue Exception => e
+        message = "Couldn't find #{self} with ID=#{id}"
+        message = "Couldn't find all #{self} objects with IDs (#{id.join(', ')})" if id.is_a?(Array)
+
+        raise ActiveHash::RecordNotFound.new(message)
+      end
+    end
+
+    # Searches all objects that matches #field_name field with the #args value(s)
+    def find_all_by_field(field_name, args)
+      objects = []
+
+      if self == get_model_class
+        objects = self.where(field_name.to_sym => args.first)
+      else
+        if mongoid?
+          objects = get_model_class.where(field_name.to_sym => args.first)
+        else
+          method_name = :"find_all_by_#{field_name}"
+          objects = get_model_class.send(method_name, args)
+        end
+      end
+
+      objects
+    end
+
+    # Searches first object that matches #field_name field with the #args value(s)
+    def find_by_field(field_name, args)
+      self.find_all_by_field(field_name, args).first
+    end
+
+    # Searches for an object that has id with #id value, if none is found returns nil
+    def find_by_id(id)
+      if self == get_model_class
+        super(id)
+      else
+        object = nil
+
+        if mongoid?
+          object = get_model_class.where(:id => id).entries.first
+        else
+          object = get_model_class.find_by_id(id)
+        end
+
+        object.nil? ? nil : serialize!(object.attributes)
+      end
+    end
+
+    # Returns first persisted object
+    def first
+      self == get_model_class ? super : get(:first)
+    end
+
+    # Returns last persisted object
+    def last
+      self == get_model_class ? super : get(:last)
+    end
+
+    private
+    # Returns the object in the position specified in #position
+    def get(position)
+      object = get_model_class.send(position)
+      serialize! object.attributes
+    end
+  end
+end

data/lib/active_repository/sql_query_executor.rb

@@ -0,0 +1,147 @@
+# Simulates a SQL where clause to filter objects from the database
+module ActiveHash #:nodoc:
+  class SQLQueryExecutor #:nodoc:
+    class << self #:nodoc:
+      # Prepares query by replacing all ? by it's real values in #args
+      def args_to_query(args)
+        return args.first if args.size == 1
+
+        query = args.first
+        param = args.delete(args[1])
+
+        param = convert_param(param)
+
+        args[0] = query.sub("?", param)
+
+        args_to_query(args)
+      end
+
+      # Recursive method that divides the query in sub queries, executes each part individually
+      # and finally relates its results as specified in the query.
+      def execute(klass, query)
+        @operator, @sub_query, @objects = process_first(klass, query, query.split(" ")[1])
+
+        @operator.nil? ? @objects : @objects.send(@operator, execute(klass, @sub_query)).sort_by{ |o| o.id }
+      end
+
+      private
+      # Splits the first sub query from the rest of the query and returns it.
+      def divide_query
+        array = @query.split(" ")
+        case @operator
+        when "between"
+          array[0..5]
+        when "is"
+          size = array[2].downcase == "not" ? 4 : 3
+          array[0..size]
+        else
+          array[0..3]
+        end
+      end
+
+      # Replaces white spaces for underscores inside quotes in order to avoid getting parameters
+      # split into separate components of the query.
+      def convert_attrs(field, *attrs)
+        attrs.each_with_index do |attribute, i|
+          attribute = attribute.gsub("_", " ")
+          attrs[i] = field.is_a?(Integer) ? attribute.to_i : attribute
+        end
+
+        field = field.is_a?(Integer) ? field : field.to_s
+
+        [field, attrs].flatten
+      end
+
+      # Returns converted #param based on its Class, so it can be used on the query
+      def convert_param(param)
+        case param.class.name
+        when "String"
+          param = "'#{param}'"
+        when "Date"
+          param = "'#{param.strftime("%Y-%m-%d")}'"
+        when "Time"
+          param = "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
+        else
+          param = param.to_s
+        end
+      end
+
+      # Execute SQL between filter
+      def execute_between(klass, sub_query)
+        klass.all.select do |o|
+          field, first_attr, second_attr = convert_attrs(o.send(sub_query.first), sub_query[2], sub_query[4])
+
+          (field >= first_attr && field <= second_attr)
+        end
+      end
+
+      # Executes SQL is filter
+      def execute_is(klass, sub_query)
+        klass.all.select do |o|
+          field = o.send(sub_query.first).blank?
+
+          sub_query.size == 3 ? field : !field
+        end
+      end
+
+      # Executes the #sub_quey defined operator filter
+      def execute_operator(klass, sub_query)
+        klass.all.select do |o|
+          field, attribute = convert_attrs(o.send(sub_query.first), sub_query[2])
+
+          field.blank? ? false : field.send(@operator, attribute)
+        end
+      end
+
+      # Executes the #sub_query
+      def execute_sub_query(klass, sub_query)
+        case @operator
+        when "between"
+          execute_between(klass, sub_query)
+        when "is"
+          execute_is(klass, sub_query)
+        else
+          execute_operator(klass, sub_query)
+        end
+      end
+
+      # Converts SQL where clause sub query operator to its Ruby Array counterpart
+      def get_operator(attributes)
+        operator = attributes.size >= 4 ? attributes.last : nil
+
+        case operator
+        when "or"  then "+"
+        when "and" then "&"
+        else nil
+        end
+      end
+
+      # Processes the first sub query in query
+      def process_first(klass, query, operator)
+        @operator = operator == "=" ? "==" : operator
+        @query    = sanitize_query(query)
+        sub_query = divide_query
+
+        binding_operator = get_operator(sub_query)
+
+        objects = execute_sub_query(klass, sub_query)
+
+        sub_query = query.gsub(sub_query.join(" "), "")
+
+        [binding_operator, sub_query, objects]
+      end
+
+      # Removes all accents and other non default characters
+      def sanitize_query(query)
+        new_query = query
+        params = query.scan(/([\"'])(.*?)\1/)
+
+        params.each do |quote, param|
+          new_query = new_query.gsub(quote,"").gsub(param, param.gsub(" ", "_"))
+        end
+
+        new_query
+      end
+    end
+  end
+end

data/lib/active_repository/uniqueness.rb

@@ -0,0 +1,196 @@
+module ActiveModel
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator #:nodoc:
+      def initialize(options)
+        super(options.reverse_merge(:case_sensitive => true))
+      end
+
+      # Unfortunately, we have to tie Uniqueness validators to a class.
+      def setup(klass)
+        @klass = klass
+      end
+
+      def validate_each(record, attribute, value)
+        finder_class = record.class.get_model_class
+
+        finder_class.all.each do |object|
+          if object.id != record.id && object.send(attribute) == record.send(attribute)
+            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope, :conditions).merge(:value => value))
+            break
+          end
+        end
+      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:
+        reflection = klass.reflect_on_association(attribute)
+        if reflection
+          column = klass.columns_hash[reflection.foreign_key]
+          attribute = reflection.foreign_key
+          value = value.attributes[reflection.primary_key_column.name]
+        else
+          column = klass.columns_hash[attribute.to_s]
+        end
+        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
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique
+      # across the system. Useful for making sure that only one user
+      # can be named "davidhh".
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are
+      # unique based on a <tt>:scope</tt> parameter:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name, scope: :account_id
+      #   end
+      #
+      # Or even multiple scope parameters. For example, making sure that a
+      # teacher can only be on the schedule once per semester for a particular
+      # class.
+      #
+      #   class TeacherSchedule < ActiveRecord::Base
+      #     validates_uniqueness_of :teacher_id, scope: [:semester_id, :class_id]
+      #   end
+      #
+      # It is also possible to limit the uniqueness constraint to a set of
+      # records matching certain conditions. In this example archived articles
+      # are not being taken into consideration when validating uniqueness
+      # of the title attribute:
+      #
+      #   class Article < ActiveRecord::Base
+      #     validates_uniqueness_of :title, conditions: where('status != ?', 'archived')
+      #   end
+      #
+      # When the record is created, a check is performed to make sure that no
+      # record exists in the database with the given value for the specified
+      # attribute (that maps to a column). When the record is updated,
+      # the same check is made but disregarding the record itself.
+      #
+      # Configuration options:
+      #
+      # * <tt>:message</tt> - Specifies a custom error message (default is:
+      #   "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of
+      #   the uniqueness constraint.
+      # * <tt>:conditions</tt> - Specify the conditions to be included as a
+      #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
+      #   (e.g. <tt>conditions: where('status = ?', 'active')</tt>).
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+      #   non-text columns (+true+ by default).
+      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
+      #   attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      #   determine if the validation should ot occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   value.
+      #
+      # === Concurrency and integrity
+      #
+      # Using this validation method in conjunction with ActiveRecord::Base#save
+      # does not guarantee the absence of duplicate record insertions, because
+      # uniqueness checks on the application level are inherently prone to race
+      # conditions. For example, suppose that two users try to post a Comment at
+      # the same time, and a Comment's title must be unique. At the database-level,
+      # the actions performed by these users could be interleaved in the following manner:
+      #
+      #               User 1                 |               User 2
+      #  ------------------------------------+--------------------------------------
+      #  # User 1 checks whether there's     |
+      #  # already a comment with the title  |
+      #  # 'My Post'. This is not the case.  |
+      #  SELECT * FROM comments              |
+      #  WHERE title = 'My Post'             |
+      #                                      |
+      #                                      | # User 2 does the same thing and also
+      #                                      | # infers that his title is unique.
+      #                                      | SELECT * FROM comments
+      #                                      | WHERE title = 'My Post'
+      #                                      |
+      #  # User 1 inserts his comment.       |
+      #  INSERT INTO comments                |
+      #  (title, content) VALUES             |
+      #  ('My Post', 'hi!')                  |
+      #                                      |
+      #                                      | # User 2 does the same thing.
+      #                                      | INSERT INTO comments
+      #                                      | (title, content) VALUES
+      #                                      | ('My Post', 'hello!')
+      #                                      |
+      #                                      | # ^^^^^^
+      #                                      | # Boom! We now have a duplicate
+      #                                      | # 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
+      # index to the database table using
+      # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
+      # rare case that a race condition occurs, the database will guarantee
+      # the field's uniqueness.
+      #
+      # When the database catches such a duplicate insertion,
+      # ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      # exception. You can either choose to let this error propagate (which
+      # will result in the default Rails exception page being shown), or you
+      # can catch it and restart the transaction (e.g. by telling the user
+      # that the title already exists, and asking him to re-enter the title).
+      # This technique is also known as optimistic concurrency control:
+      # http://en.wikipedia.org/wiki/Optimistic_concurrency_control
+      #
+      # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
+      # constraint errors from other types of database errors by throwing an
+      # ActiveRecord::RecordNotUnique exception. For other adapters you will
+      # have to parse the (database-specific) exception message to detect such
+      # a case.
+      #
+      # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
+      #
+      # * ActiveRecord::ConnectionAdapters::MysqlAdapter
+      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
+      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
+      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_repository/version.rb

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

data/lib/active_repository/write_support.rb

@@ -0,0 +1,95 @@
+require 'active_hash'
+require 'active_repository/sql_query_executor'
+
+# Changes made in order to make write support in ActiveHash.
+
+begin
+  klass = Module.const_get(ActiveRecord::Rollback)
+  unless klass.is_a?(Class)
+    raise "Not defined"
+  end
+rescue
+  module ActiveRecord
+    class ActiveRecordError < StandardError
+    end
+    class Rollback < ActiveRecord::ActiveRecordError
+    end
+  end
+end
+
+module ActiveHash
+  class Base
+    def self.insert(record)
+      record_id   = record.id.to_s
+      record_hash = record.hash
+
+      if self.all.map(&:hash).include?(record_hash)
+        record_index.delete(record_id)
+        self.all.delete(record)
+      end
+
+      if record_index[record_id].nil? || !self.all.map(&:hash).include?(record_hash)
+        insert_record(record)
+      end
+    end
+
+    def self.where(query)
+      if query.is_a?(String)
+        return ActiveHash::SQLQueryExecutor.execute(self, query)
+      else
+        (@records || []).select do |record|
+          query.all? { |col, match| record[col] == match }
+        end
+      end
+    end
+
+    def self.validate_unique_id(record)
+      raise IdError.new("Duplicate Id found for record #{record.attributes}") if record_index.has_key?(record.id.to_s)
+    end
+
+    def update_attribute(key, value)
+      self.send("#{key}=", value)
+      self.save(:validate => false)
+    end
+
+    def readonly?
+      false
+    end
+
+    def save(*args)
+      record = self.class.find_by_id(self.id)
+
+      self.class.insert(self) if record.nil? && record != self
+      true
+    end
+
+    def to_param
+      id.present? ? id.to_s : nil
+    end
+
+    def persisted?
+      other = self.class.find_by_id(id)
+      other.present?
+    end
+
+    def eql?(other)
+      (other.instance_of?(self.class) || other.instance_of?(self.class.get_model_class)) && id.present? && (id == other.id) && (created_at == other.created_at)
+    end
+
+    alias == eql?
+
+    private
+    def self.insert_record(record)
+      @records ||= []
+      record.attributes[:id] ||= next_id
+
+      validate_unique_id(record) if dirty
+      mark_dirty
+
+      if record.valid?
+        add_to_record_index({ record.id.to_s => @records.length })
+        @records << record
+      end
+    end
+  end
+end

data/lib/active_repository/writers.rb

@@ -0,0 +1,75 @@
+# Module containing writing methods of the ActiveRepository::Base class
+module ActiveRepository
+  module Writers
+    # Creates an object and persists it.
+    def create(attributes={})
+      object = get_model_class.new(attributes)
+
+      object.id = nil if exists?(object.id)
+
+      if get_model_class == self
+        object.save
+      else
+        repository = serialize!(object.attributes)
+        repository.valid? ? (object = get_model_class.create(attributes)) : false
+      end
+
+      serialize!(object.attributes) unless object.class.name == self
+    end
+
+    # Searches for an object that matches the attributes on the parameter, if none is found
+    # it creates one with the defined attributes.
+    def find_or_create(attributes)
+      object = get_model_class.where(attributes).first
+
+      object = model_class.create(attributes) if object.nil?
+
+      serialize!(object.attributes)
+    end
+
+    #:nodoc:
+    module InstanceMethods
+      # Assigns new_attributes parameter to the attributes in self.
+      def attributes=(new_attributes)
+        new_attributes.each do |k,v|
+          self.send("#{k.to_s == '_id' ? 'id' : k.to_s}=", v)
+        end
+      end
+
+      # Updates #key attribute with #value value.
+      def update_attribute(key, value)
+        if self.class == self.class.get_model_class
+          super(key,value)
+        else
+          object = self.class.get_model_class.find(self.id)
+
+          if mongoid?
+            super(key,value)
+            key = key.to_s == 'id' ? '_id' : key.to_s
+          end
+
+          object.update_attribute(key, value)
+          object.save
+        end
+
+        self.reload
+      end
+
+      # Updates attributes in self with the attributes in the parameter
+      def update_attributes(attributes)
+        object = nil
+        if mongoid?
+          object = self.class.get_model_class.find(self.id)
+        else
+          object = self.class.get_model_class.find(self.id)
+        end
+
+        attributes.each do |k,v|
+          object.update_attribute("#{k.to_s}", v) unless k == :id
+        end
+
+        self.reload
+      end
+    end
+  end
+end

data/lib/active_repository.rb

@@ -0,0 +1,15 @@
+require 'active_repository'
+
+begin
+  require 'active_model'
+  require 'active_model/naming'
+rescue LoadError
+end
+
+begin
+  require 'active_hash'
+  require 'associations/associations'
+rescue LoadError
+end
+
+require 'active_repository/base'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_repository
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000 Z
+date: 2012-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_hash
@@ -130,14 +130,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
 - LICENSE
-- spec/active_repository/associations_spec.rb
+- README.md
+- active_repository.gemspec
+- lib/active_repository/associations.rb
+- lib/active_repository/base.rb
+- lib/active_repository/finders.rb
+- lib/active_repository/sql_query_executor.rb
+- lib/active_repository/uniqueness.rb
+- lib/active_repository/version.rb
+- lib/active_repository/write_support.rb
+- lib/active_repository/writers.rb
+- lib/active_repository.rb
+- Gemfile
 - spec/active_repository/base_spec.rb
+- spec/active_repository/associations_spec.rb
 - spec/active_repository/sql_query_executor_spec.rb
-- spec/spec_helper.rb
 - spec/support/shared_examples.rb
 - spec/support/sql_query_shared_examples.rb
+- spec/spec_helper.rb
 homepage: http://github.com/efreesen/active_repository
 licenses:
 - MIT
@@ -164,9 +175,11 @@ signing_key:
 specification_version: 3
 summary: An implementation of repository pattern that can connect with any ORM
 test_files:
-- spec/active_repository/associations_spec.rb
+- Gemfile
 - spec/active_repository/base_spec.rb
+- spec/active_repository/associations_spec.rb
 - spec/active_repository/sql_query_executor_spec.rb
-- spec/spec_helper.rb
 - spec/support/shared_examples.rb
 - spec/support/sql_query_shared_examples.rb
+- spec/spec_helper.rb
+has_rdoc: