active_repository 0.0.3 → 0.0.4

data/spec/active_repository/associations_spec.rb

@@ -21,13 +21,9 @@ describe ActiveRepository::Base, "associations" do
     end
 
     class City < ActiveRepository::Base
-      City.set_model_class(self)
-      City.set_save_in_memory(true)
     end
 
     class Author < ActiveRepository::Base
-      Author.set_model_class(self)
-      Author.set_save_in_memory(true)
     end
 
     class Book < ActiveRecord::Base
@@ -261,14 +257,9 @@ describe ActiveRepository::Base, "associations" do
   describe "Multiple ORM" do
     before do
       Object.send :remove_const, :City
-      # Object.send :remove_const, :Author
       Object.send :remove_const, :Country
-      # Object.send :remove_const, :School
-      # Object.send :remove_const, :Book
 
       class Country < ActiveRepository::Base
-        Country.set_model_class(Country)
-        Country.set_save_in_memory(true)
         has_many :states
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_repository
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-26 00:00:00.000000000 Z
+date: 2012-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_hash
@@ -80,17 +80,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.11
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.11
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -130,31 +130,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
-- Gemfile
-- LICENSE
 - README.md
-- Rakefile
-- active_repository.gemspec
-- lib/active_repository.rb
-- 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
+- LICENSE
 - spec/active_repository/associations_spec.rb
 - spec/active_repository/base_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
-- support/mongoid.yml
 homepage: http://github.com/efreesen/active_repository
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:

data/.gitignore

@@ -1,18 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.rbenv-version

data/.travis.yml

@@ -1,10 +0,0 @@
-rvm:
-  - 1.9.3
-  - jruby-19mode
-
-matrix:
-  allow_failures:
-    - rvm: jruby-19mode
-
-services:
-  - mongodb

data/Gemfile

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

data/Rakefile

@@ -1,12 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-
-desc 'Default: run rspec tests.'
-task :default => [:travis]
-
-task :travis do
-  cmd = "rspec spec"
-  puts "Starting to run `#{cmd}`..."
-  system("export DISPLAY=:99.0 && bundle exec rspec spec -c")
-  raise "#{cmd} failed!" unless $?.exitstatus == 0
-end

data/active_repository.gemspec

@@ -1,27 +0,0 @@
-# -*- 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.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>, ["= 3.0.11"])
-  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.rb

@@ -1,15 +0,0 @@
-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'

data/lib/active_repository/associations.rb

@@ -1,97 +0,0 @@
-module ActiveRepository
-  module Associations
-
-    module ActiveRecordExtensions
-
-      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
-
-    def self.included(base)
-      base.extend Methods
-    end
-
-    module Methods
-      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
-
-      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
-# 
-      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

@@ -1,156 +0,0 @@
-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
-
-  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
-
-    def reload
-      serialize! self.class.get_model_class.find(self.id).attributes
-    end
-
-    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
-
-    def self.all
-      self == get_model_class ? super : get_model_class.all.map { |object| serialize!(object.attributes) }
-    end
-
-    def self.delete_all
-      self == get_model_class ? super : get_model_class.delete_all
-    end
-
-    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
-
-    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
-
-    def self.set_save_in_memory(value)
-      self.save_in_memory = value if save_in_memory.nil?
-    end
-
-    def persist
-      if self.valid?
-        save_in_memory? ? save : self.convert
-      end
-    end
-
-    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
-
-    def serialize!(attributes)
-      unless attributes.nil?
-        self.attributes = attributes
-      end
-
-      self
-    end
-
-    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
-
-    def self.serialized_attributes
-      field_names.map &:to_s
-    end
-
-    def self.constantize
-      self.to_s.constantize
-    end
-
-    def self.get_model_class
-      return self if self.save_in_memory.nil?
-      save_in_memory? ? self : self.model_class
-    end
-
-    def save_in_memory?
-      self.save_in_memory.nil? ? true : save_in_memory
-    end
-
-    protected
-      def model_class
-        self.model_class
-      end
-
-    private
-      def set_timestamps
-        self.created_at = DateTime.now.utc if self.new_record?
-        self.updated_at = DateTime.now.utc
-      end
-
-      def self.mongoid?
-        get_model_class.included_modules.include?(Mongoid::Document)
-      end
-
-      def mongoid?
-        self.class.mongoid?
-      end
-  end
-end

data/lib/active_repository/finders.rb

@@ -1,101 +0,0 @@
-module ActiveRepository
-  module Finders
-    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
-
-    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
-
-    def find_by_field(field_name, args)
-      self.find_all_by_field(field_name, args).first
-    end
-
-    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
-
-    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
-
-    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
-
-    def first
-      get("first")
-    end
-
-    def last
-      get("last")
-    end
-
-    private
-    def get(position)
-      if self == get_model_class
-        all.sort_by!{ |o| o.id }.send(position)
-      else
-        object = get_model_class.send(position)
-        serialize! object.attributes
-      end
-    end
-  end
-end

data/lib/active_repository/sql_query_executor.rb

@@ -1,135 +0,0 @@
-module ActiveHash
-  class SQLQueryExecutor
-    class << self
-      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
-
-      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
-
-      private
-      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
-
-      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
-
-      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
-
-      def get_operator(attributes)
-        operator = attributes.size >= 4 ? attributes.last : nil
-
-        case operator
-        when "or"
-          "+"
-        when "and"
-          "&"
-        else
-          nil
-        end
-      end
-
-      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
-
-      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
-
-      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
-
-      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
-
-      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
-
-      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
-    end
-  end
-end

data/lib/active_repository/uniqueness.rb

@@ -1,196 +0,0 @@
-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

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

data/lib/active_repository/write_support.rb

@@ -1,93 +0,0 @@
-require 'active_hash'
-require 'active_repository/sql_query_executor'
-
-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

@@ -1,67 +0,0 @@
-module ActiveRepository
-  module Writers
-    def find_or_create(attributes)
-      object = get_model_class.where(attributes).first
-
-      object = model_class.create(attributes) if object.nil?
-
-      serialize!(object.attributes)
-    end
-
-    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
-
-    module InstanceMethods
-      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
-
-      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
-
-      def attributes=(new_attributes)
-        new_attributes.each do |k,v|
-          self.send("#{k.to_s == '_id' ? 'id' : k.to_s}=", v)
-        end
-      end
-    end
-  end
-end

data/support/mongoid.yml

@@ -1,6 +0,0 @@
-development:
-  sessions:
-    default:
-      database: active_repository
-      hosts:
-        - localhost:27017