active_repository 0.0.1

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.0.1"
+end

data/lib/active_repository/write_support.rb

@@ -0,0 +1,76 @@
+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)
+      if self.all.map(&:to_s).include?(record.to_s)
+        record_index.delete(record.id.to_s)
+        self.all.delete(record)
+      end
+
+      if record_index[record.id.to_s].nil? || !self.all.map(&:to_s).include?(record.to_s)
+        @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
+
+    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 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 persisted?
+      other = self.class.find_by_id(id)
+      other.present? && other.created_at
+    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?
+  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'

data/spec/active_repository/base_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'support/shared_examples'
+
+require 'active_repository'
+require "active_record"
+require "mongoid"
+
+describe ActiveRepository, "Base" do
+
+  before do
+    class Country < ActiveRepository::Base
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Country
+  end
+
+  context "in_memory" do
+    before do
+      Country.fields :name, :monarch, :language
+      Country.set_model_class(Country)
+      Country.set_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")
+      Country.create(:id => 3, :name => "Mexico", :language => 'Spanish')
+      Country.create(:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 5, :name => "Brazil")
+    end
+
+    it_behaves_like '.update_attributes'
+    it_behaves_like '.all'
+    it_behaves_like '.where'
+    it_behaves_like '.exists?'
+    it_behaves_like '.count'
+    it_behaves_like '.first'
+    it_behaves_like '.last'
+    it_behaves_like '.find'
+    it_behaves_like '.find_by_id'
+    it_behaves_like 'custom finders'
+    it_behaves_like '#method_missing'
+    it_behaves_like '#attributes'
+    it_behaves_like 'reader_methods'
+    it_behaves_like 'interrogator methods'
+    it_behaves_like '#id'
+    it_behaves_like '#quoted_id'
+    it_behaves_like '#to_param'
+    it_behaves_like '#persisted?'
+    it_behaves_like '#eql?'
+    it_behaves_like '#=='
+    it_behaves_like '#hash'
+    it_behaves_like '#readonly?'
+    it_behaves_like '#cache_key'
+    it_behaves_like '#save'
+    it_behaves_like '.create'
+    it_behaves_like '#valid?'
+    it_behaves_like '#new_record?'
+    it_behaves_like '.transaction'
+    it_behaves_like '.delete_all'
+  end
+
+  context "active_record" do
+    before do
+      Country.fields :name, :monarch, :language
+
+      class CountryModel < ActiveRecord::Base
+        self.table_name = 'countries'
+        establish_connection :adapter => "sqlite3", :database => ":memory:"
+        connection.create_table(:countries, :force => true) do |t|
+          t.string :name
+          t.string :monarch
+          t.string :language
+          t.datetime :created_at
+          t.datetime :updated_at
+        end
+      end
+
+      Country.set_model_class(CountryModel)
+      Country.set_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")
+      Country.create(:id => 3, :name => "Mexico", :language => 'Spanish')
+      Country.create(:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 5, :name => "Brazil")
+    end
+
+    after do
+      Object.send :remove_const, :CountryModel
+    end
+
+    it_behaves_like '.update_attributes'
+    it_behaves_like '.all'
+    it_behaves_like '.where'
+    it_behaves_like '.exists?'
+    it_behaves_like '.count'
+    it_behaves_like '.first'
+    it_behaves_like '.last'
+    it_behaves_like '.find'
+    it_behaves_like '.find_by_id'
+    it_behaves_like 'custom finders'
+    it_behaves_like '#method_missing'
+    it_behaves_like '#attributes'
+    it_behaves_like 'reader_methods'
+    it_behaves_like 'interrogator methods'
+    it_behaves_like '#id'
+    it_behaves_like '#quoted_id'
+    it_behaves_like '#to_param'
+    it_behaves_like '#persisted?'
+    it_behaves_like '#eql?'
+    it_behaves_like '#=='
+    it_behaves_like '#hash'
+    it_behaves_like '#readonly?'
+    it_behaves_like '#cache_key'
+    it_behaves_like '#save'
+    it_behaves_like '.create'
+    it_behaves_like '#valid?'
+    it_behaves_like '#new_record?'
+    it_behaves_like '.transaction'
+    it_behaves_like '.delete_all'
+  end
+end

data/spec/active_repository/sql_query_executor_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'support/sql_query_shared_examples'
+
+require 'active_repository'
+require "active_record"
+require "mongoid"
+
+describe ActiveRepository, "Base" do
+
+  before do
+    class Country < ActiveRepository::Base
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Country
+  end
+
+  context "in_memory" do
+    before do
+      Country.fields :name, :monarch, :language, :founded_at
+      Country.set_model_class(Country)
+      Country.set_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")
+      Country.create(:id => 3, :name => "Mexico", :language => 'Spanish')
+      Country.create(:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 5, :name => "Brazil", :founded_at => Time.parse('1500-04-22 13:34:25'))
+    end
+
+    describe ".where" do
+      it_behaves_like '='
+      it_behaves_like '>'
+      it_behaves_like '>='
+      it_behaves_like '<'
+      it_behaves_like '<='
+      it_behaves_like 'between'
+      it_behaves_like 'is'
+    end
+  end
+
+  context "active_record" do
+    before do
+      Country.fields :name, :monarch, :language, :founded_at
+
+      class CountryModel < ActiveRecord::Base
+        self.table_name = 'countries'
+        establish_connection :adapter => "sqlite3", :database => ":memory:"
+        connection.create_table(:countries, :force => true) do |t|
+          t.string :name
+          t.string :monarch
+          t.string :language
+          t.datetime :founded_at
+          t.datetime :created_at
+          t.datetime :updated_at
+        end
+      end
+
+      Country.set_model_class(CountryModel)
+      Country.set_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")
+      Country.create(:id => 3, :name => "Mexico", :language => 'Spanish')
+      Country.create(:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 5, :name => "Brazil", :founded_at => Time.parse('1500-04-22 13:34:25'))
+    end
+
+    after do
+      Object.send :remove_const, :CountryModel
+    end
+
+    describe ".where" do
+      it_behaves_like '='
+      it_behaves_like '>'
+      it_behaves_like '>='
+      it_behaves_like '<'
+      it_behaves_like '<='
+      it_behaves_like 'between'
+      it_behaves_like 'is'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'rspec/autorun'
+
+# $LOAD_PATH.unshift(File.dirname(__FILE__))
+# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# require 'active_repository'