csun-student-affairs-supermodel 0.1.5

data/.gitignore

@@ -0,0 +1,6 @@
+dump.db
+test.rb
+redis_test.rb
+pkg
+lib/supermodel/cassandra.rb
+*.gem

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alexander MacCaw (info@eribium.org)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,64 @@
+
+Simple in-memory database using ActiveModel.
+
+Primarily developed for Bowline applications.
+http://github.com/maccman/bowline
+
+Supports:
+  * Serialisation
+  * Validations
+  * Callbacks
+  * Observers
+  * Dirty (Changes)
+  * Ruby Marshalling to disk
+  * Redis
+
+Examples:
+
+  require "supermodel"
+
+  class Test < SuperModel::Base
+  end
+
+  t = Test.new
+  t.name = "foo"
+  t.save #=> true
+
+  Test.all
+  Test.first
+  Test.last
+  Test.find_by_name('foo)
+
+You can use a random ID rather than the object ID:
+  
+  class Test < SuperModel::Base
+    include SuperModel::RandomID
+  end
+  
+  t = Test.create(:name => "test")
+  t.id #=> "7ee935377bb4aecc54ad4f9126"
+  
+You can marshal objects to disk on startup/shutdown
+  
+  class Test < SuperModel::Base
+    include SuperModel::Marshal::Model
+  end
+  
+  SuperModel::Marshal.path = "dump.db"
+  SuperModel::Marshal.load
+
+  at_exit {
+    SuperModel::Marshal.dump
+  }
+  
+You can use Redis, you need the Redis gem installed:
+
+  require "redis"
+  class Test < SuperModel::Base
+    include SuperModel::Redis::Model
+  
+    attributes :name
+    indexes :name
+  end
+  
+  Test.find_or_create_by_name("foo")

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "supermodel"
+    gemspec.summary = "In memory DB using ActiveModel"
+    gemspec.email = "info@eribium.org"
+    gemspec.homepage = "http://github.com/maccman/supermodel"
+    gemspec.description = "In memory DB using ActiveModel"
+    gemspec.authors = ["Alex MacCaw"]
+    gemspec.add_dependency("activemodel", "~> 3.0.0")
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.4

data/lib/super_model.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "supermodel")

data/lib/supermodel.rb

@@ -0,0 +1,42 @@
+gem "activesupport"
+gem "activemodel"
+
+require "active_support/core_ext/class/attribute_accessors"
+require "active_support/core_ext/class/inheritable_attributes"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/module/attr_accessor_with_default"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/module/aliasing"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/object/to_query"
+require "active_support/json"
+
+require "active_model"
+
+module SuperModel
+  class SuperModelError < StandardError; end
+  class UnknownRecord < SuperModelError; end
+  class InvalidRecord < SuperModelError; end
+end
+
+$:.unshift(File.dirname(__FILE__))
+require "supermodel/ext/array"
+
+module SuperModel
+  autoload :Association, "supermodel/association"
+  autoload :Callbacks,   "supermodel/callbacks"
+  autoload :Observing,   "supermodel/observing"
+  autoload :Marshal,     "supermodel/marshal"
+  autoload :RandomID,    "supermodel/random_id"
+  autoload :Timestamp,   "supermodel/timestamp"
+  autoload :Validations, "supermodel/validations"
+  autoload :Dirty,       "supermodel/dirty"
+  autoload :Redis,       "supermodel/redis"
+  autoload :Base,        "supermodel/base"
+end
+
+module ActiveModel
+  autoload :SerializeOptions, "active_model/serialize_options"
+end

data/lib/supermodel/association.rb

@@ -0,0 +1,51 @@
+require "active_support/core_ext/string/inflections.rb"
+
+module SuperModel
+  module Association
+    module ClassMethods
+      def belongs_to(to_model, options = {})
+        to_model    = to_model.to_s
+        class_name  = options[:class_name]  || to_model.classify
+        foreign_key = options[:foreign_key] || "#{to_model}_id"
+        primary_key = options[:primary_key] || "id"
+        
+        attributes foreign_key
+        
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{to_model}                                             # def user
+            #{foreign_key} && #{class_name}.find(#{foreign_key})      #   user_id && User.find(user_id)
+          end                                                         # end
+                                                                      # 
+          def #{to_model}?                                            # def user?
+            #{foreign_key} && #{class_name}.exists?(#{foreign_key})   #   user_id && User.exists?(user_id)
+          end                                                         # end
+                                                                      # 
+          def #{to_model}=(object)                                    # def user=(model)
+            self.#{foreign_key} = (object && object.#{primary_key})   #   self.user_id = (model && model.id)
+          end                                                         # end
+        EOS
+      end
+      
+      def has_many(to_model, options = {})
+        to_model    = to_model.to_s
+        class_name  = options[:class_name]  || to_model.classify
+        foreign_key = options[:foreign_key] || "#{model_name.singular}_id"
+        primary_key = options[:primary_key] || "id"
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{to_model}                                             # def user
+            #{class_name}.find_all_by_attribute(                      #   User.find_all_by_attribute(
+              :#{foreign_key},                                        #    :task_id,
+              #{primary_key}                                          #    id
+            )                                                         #   )
+          end                                                         # end
+        EOS
+      end
+    end
+    
+    module Model
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/supermodel/base.rb

@@ -0,0 +1,309 @@
+module SuperModel
+  class Base    
+    class_inheritable_array :known_attributes
+    self.known_attributes = []
+    
+    class << self
+      attr_accessor_with_default(:primary_key, 'id') #:nodoc:
+      
+      def collection(&block)
+        @collection ||= Class.new(Array)
+        @collection.class_eval(&block) if block_given?
+        @collection
+      end
+
+      def attributes(*attributes)
+        self.known_attributes += attributes.map(&:to_s)
+      end
+      
+      def records
+        @records ||= {}
+      end
+      
+      def find_by_attribute(name, value) #:nodoc:
+        item = records.values.find {|r| r.send(name) == value }
+        item && item.dup
+      end
+      
+      def find_all_by_attribute(name, value) #:nodoc:
+        items = records.values.select {|r| r.send(name) == value }
+        collection.new(items.deep_dup)
+      end
+      
+      def raw_find(id) #:nodoc:
+        records[id] || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+      
+      # Find record by ID, or raise.
+      def find(id)
+        item = raw_find(id)
+        item && item.dup
+      end
+      alias :[] :find
+    
+      def first
+        item = records.values[0]
+        item && item.dup
+      end
+      
+      def last
+        item = records.values[-1]
+        item && item.dup
+      end
+      
+      def exists?(id)
+        records.has_key?(id)
+      end
+      
+      def count
+        records.length
+      end
+    
+      def all
+        collection.new(records.values.deep_dup)
+      end
+      
+      def select(&block)
+        collection.new(records.values.select(&block).deep_dup)
+      end
+      
+      def update(id, atts)
+        find(id).update_attributes(atts)
+      end
+      
+      def destroy(id)
+        find(id).destroy
+      end
+      
+      # Removes all records and executes 
+      # destory callbacks.
+      def destroy_all
+        all.each {|r| r.destroy }
+      end
+      
+      # Removes all records without executing
+      # destroy callbacks.
+      def delete_all
+        records.clear
+      end
+      
+      # Create a new record.
+      # Example:
+      #   create(:name => "foo", :id => 1)
+      def create(atts = {})
+        rec = self.new(atts)
+        rec.save && rec
+      end
+      
+      def create!(*args)
+        create(*args) || raise(InvalidRecord)
+      end
+      
+      def method_missing(method_symbol, *args) #:nodoc:
+        method_name = method_symbol.to_s
+
+        if method_name =~ /^find_by_(\w+)!/
+          send("find_by_#{$1}", *args) || raise(UnknownRecord)
+        elsif method_name =~ /^find_by_(\w+)/
+          find_by_attribute($1, args.first)
+        elsif method_name =~ /^find_or_create_by_(\w+)/
+          send("find_by_#{$1}", *args) || create($1 => args.first)
+        elsif method_name =~ /^find_all_by_(\w+)/
+          find_all_by_attribute($1, args.first)
+        else
+          super
+        end
+      end
+    end
+    
+    attr_accessor :attributes
+    attr_writer   :new_record
+    
+    def known_attributes
+      self.class.known_attributes + self.attributes.keys.map(&:to_s)
+    end
+    
+    def initialize(attributes = {})
+      @new_record = true
+      @attributes = {}.with_indifferent_access
+      @attributes.merge!(known_attributes.inject({}) {|h, n| h[n] = nil; h })
+      @changed_attributes = {}
+      load(attributes)
+    end
+    
+    def clone
+      cloned = attributes.reject {|k,v| k == self.class.primary_key }
+      cloned = cloned.inject({}) do |attrs, (k, v)|
+        attrs[k] = v.clone
+        attrs
+      end
+      self.class.new(cloned)
+    end
+    
+    def new?
+      @new_record || false
+    end
+    alias :new_record? :new?
+    
+    # Gets the <tt>\id</tt> attribute of the item.
+    def id
+      attributes[self.class.primary_key]
+    end
+
+    # Sets the <tt>\id</tt> attribute of the item.
+    def id=(id)
+      attributes[self.class.primary_key] = id
+    end
+    
+    def ==(other)
+      other.equal?(self) || (other.instance_of?(self.class) && other.id == id)
+    end
+
+    # Tests for equality (delegates to ==).
+    def eql?(other)
+      self == other
+    end
+    
+    def hash
+      id.hash
+    end
+    
+    def dup
+      self.class.new.tap do |base|
+        base.attributes = attributes
+        base.new_record = new_record?
+      end
+    end
+    
+    def save
+      new? ? create : update
+    end
+    
+    def save!
+      save || raise(InvalidRecord)
+    end
+    
+    def exists?
+      !new?
+    end
+    alias_method :persisted?, :exists?
+    
+    def load(attributes) #:nodoc:
+      return unless attributes
+      attributes.each do |(name, value)| 
+        self.send("#{name}=".to_sym, value) 
+      end
+    end
+    
+    def reload
+      return self if new?
+      item = self.class.find(id)
+      load(item.attributes)
+      return self
+    end
+    
+    def update_attribute(name, value)
+      self.send("#{name}=".to_sym, value)
+      self.save
+    end
+    
+    def update_attributes(attributes)
+      load(attributes) && save
+    end
+    
+    def update_attributes!(attributes)
+      update_attributes(attributes) || raise(InvalidRecord)
+    end
+    
+    def has_attribute?(name)
+      @attributes.has_key?(name)
+    end
+    
+    alias_method :respond_to_without_attributes?, :respond_to?
+    
+    def respond_to?(method, include_priv = false)
+      method_name = method.to_s
+      if attributes.nil?
+        super
+      elsif known_attributes.include?(method_name)
+        true
+      elsif method_name =~ /(?:=|\?)$/ && attributes.include?($`)
+        true
+      else
+        super
+      end
+    end
+    
+    def destroy
+      raw_destroy
+      self
+    end
+    
+    protected    
+      def read_attribute(name)
+        @attributes[name]
+      end
+      
+      def write_attribute(name, value)
+        @attributes[name] = value
+      end
+      
+      def generate_id
+        object_id
+      end
+      
+      def raw_destroy
+        self.class.records.delete(self.id)
+      end
+      
+      def raw_create
+        self.class.records[self.id] = self.dup
+      end
+      
+      def create
+        self.id ||= generate_id
+        self.new_record = false
+        raw_create
+        self.id
+      end
+      
+      def raw_update
+        item = self.class.raw_find(id)
+        item.load(attributes)
+      end
+      
+      def update
+        raw_update
+        true
+      end
+    
+    private
+      
+      def method_missing(method_symbol, *arguments) #:nodoc:
+        method_name = method_symbol.to_s
+
+        if method_name =~ /(=|\?)$/
+          case $1
+          when "="
+            attribute_will_change!($`)
+            attributes[$`] = arguments.first
+          when "?"
+            attributes[$`]
+          end
+        else
+          return attributes[method_name] if attributes.include?(method_name)
+          return nil if known_attributes.include?(method_name)
+          super
+        end
+      end
+  end
+  
+  class Base
+    extend  ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Dirty, Observing, Callbacks, Validations
+    include Association::Model
+  end
+end

data/lib/supermodel/callbacks.rb

@@ -0,0 +1,23 @@
+module SuperModel
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      instance_eval do
+        extend ActiveModel::Callbacks
+        define_model_callbacks :create, :save, :update, :destroy
+      end
+      
+      %w( create save update destroy ).each do |method|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method}_with_callbacks(*args, &block)
+            _run_#{method}_callbacks do
+              #{method}_without_callbacks(*args, &block)
+            end
+          end
+        EOS
+        alias_method_chain(method, :callbacks)
+      end
+    end
+  end
+end

data/lib/supermodel/dirty.rb

@@ -0,0 +1,24 @@
+module SuperModel
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    included do
+      %w( create update ).each do |method|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method}_with_dirty(*args, &block)
+            result = #{method}_without_dirty(*args, &block)
+            save_previous_changes
+            result
+          end
+        EOS
+        alias_method_chain(method, :dirty)
+      end
+    end
+        
+    def save_previous_changes
+      @previously_changed = changes
+      @changed_attributes.clear
+    end
+  end
+end

data/lib/supermodel/ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+  unless defined?(deep_dup)
+    def deep_dup
+      Marshal.load(Marshal.dump(self))
+    end
+  end
+end

data/lib/supermodel/marshal.rb

@@ -0,0 +1,91 @@
+require "tempfile"
+require "fileutils"
+
+module SuperModel
+  module Marshal
+    def path
+      @path || raise("Provide a path")
+    end
+    
+    def path=(p)
+      @path = p
+    end
+    
+    def klasses
+      @klasses ||= []
+    end
+    
+    def load
+      return unless path
+      return unless File.exist?(path)
+      data = []
+      File.open(path, "rb") do |file|
+        begin
+          data = ::Marshal.load(file)
+        rescue => e
+          if defined?(Bowline)
+            Bowline::Logging.log_error(e)
+          end
+          # Lots of errors can occur during
+          # marshaling - such as EOF etc
+          return false
+        end
+      end
+      data.each do |klass, records| 
+        klass.marshal_records = records
+      end
+      true
+    end
+  
+    def dump
+      return unless path
+      tmp_file = Tempfile.new("rbdump")
+      tmp_file.binmode
+      data = klasses.inject({}) {|hash, klass|
+        hash[klass] = klass.marshal_records
+        hash
+      }
+      ::Marshal.dump(data, tmp_file)
+  	  tmp_file.close
+      # Atomic serialization - so we never corrupt the db
+      FileUtils.mv(tmp_file.path, path)
+      true
+    end
+    
+    extend self
+    
+    module Model
+      def self.included(base)
+        base.extend ClassMethods
+        Marshal.klasses << base
+      end
+      
+      def marshal_dump
+        serializable_hash(self.class.marshal)
+      end
+
+      def marshal_load(atts)
+        # Can't call load, since class
+        # isn't setup properly
+        @attributes         = atts.with_indifferent_access
+        @changed_attributes = {}
+      end
+      
+      module ClassMethods
+        def marshal(options = nil)
+          @marshal = options if options
+          @marshal ||= {}
+        end
+        alias_method :marshal=, :marshal
+                
+        def marshal_records=(records)
+          @records = records
+        end
+        
+        def marshal_records
+          @records
+        end    
+      end
+    end
+  end
+end

data/lib/supermodel/observing.rb

@@ -0,0 +1,21 @@
+module SuperModel
+  module Observing
+    extend ActiveSupport::Concern
+    include ActiveModel::Observing
+
+    included do
+      %w( create save update destroy ).each do |method|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method}_with_notifications(*args, &block)
+            notify_observers(:before_#{method})
+            if result = #{method}_without_notifications(*args, &block)
+              notify_observers(:after_#{method})
+            end
+            result
+          end
+        EOS
+        alias_method_chain(method, :notifications)
+      end
+    end
+  end
+end

data/lib/supermodel/random_id.rb

@@ -0,0 +1,8 @@
+module SuperModel
+  module RandomID
+    protected
+      def generate_id
+        ActiveSupport::SecureRandom.hex(13)
+      end
+  end
+end

data/lib/supermodel/redis.rb

@@ -0,0 +1,167 @@
+module SuperModel
+  module Redis
+    module ClassMethods
+      def self.extended(base)
+        base.class_eval do
+          class_inheritable_array :indexed_attributes
+          self.indexed_attributes = []
+                    
+          class_inheritable_hash :redis_options
+          self.redis_options = {}
+        end
+      end
+      
+      def namespace
+        @namespace ||= self.name.downcase
+      end
+      
+      def namespace=(namespace)
+        @namespace = namespace
+      end
+      
+      def redis
+        @redis ||= ::Redis.connect(redis_options)
+      end
+      
+      def indexes(*indexes)
+        self.indexed_attributes += indexes.map(&:to_s)
+      end
+            
+      def redis_key(*args)
+        args.unshift(self.namespace)
+        args.join(":")
+      end
+      
+      def find(id)
+        if redis.sismember(redis_key, id.to_s)
+          existing(:id => id)
+        else
+          raise UnknownRecord, "Couldn't find #{self.name} with ID=#{id}"
+        end
+      end
+      
+      def first
+        item_ids = redis.sort(redis_key, :order => "ASC", :limit => [0, 1])
+        item_id  = item_ids.first
+        item_id && existing(:id => item_id)        
+      end
+      
+      def last
+        item_ids = redis.sort(redis_key, :order => "DESC", :limit => [0, 1])
+        item_id  = item_ids.first
+        item_id && existing(:id => item_id)        
+      end
+      
+      def exists?(id)
+        redis.sismember(redis_key, id.to_s)
+      end
+      
+      def count
+        redis.scard(redis_key)
+      end
+      
+      def all
+        from_ids(redis.sort(redis_key))
+      end
+      
+      def select
+        raise "Not implemented"
+      end
+      
+      def delete_all
+        raise "Not implemented"
+      end
+      
+      def find_by_attribute(key, value)
+        item_ids = redis.sort(redis_key(key, value.to_s))
+        item_id  = item_ids.first
+        item_id && existing(:id => item_id)
+      end
+      
+      def find_all_by_attribute(key, value)
+        from_ids(redis.sort(redis_key(key, value.to_s)))
+      end
+      
+      protected
+        def from_ids(ids)
+          ids.map {|id| existing(:id => id) }
+        end
+        
+        def existing(atts = {})
+          item = self.new(atts)
+          item.new_record = false
+          item.redis_get
+          item
+        end
+    end
+    
+    module InstanceMethods    
+      protected
+        def raw_destroy
+          return if new?
+
+          destroy_indexes
+          redis.srem(self.class.redis_key, self.id)
+          redis.del(redis_key)
+        end
+      
+        def destroy_indexes
+          indexed_attributes.each do |index|
+            old_attribute = changes[index].try(:first) || send(index)
+            redis.srem(self.class.redis_key(index, old_attribute), id)
+          end
+        end
+      
+        def create_indexes
+          indexed_attributes.each do |index|
+            new_attribute = send(index)
+            redis.sadd(self.class.redis_key(index, new_attribute), id)
+          end
+        end
+    
+        def generate_id
+          redis.incr(self.class.redis_key(:uid))
+        end
+
+        def indexed_attributes
+          attributes.keys & self.class.indexed_attributes
+        end
+      
+        def redis
+          self.class.redis
+        end
+
+        def redis_key(*args)
+          self.class.redis_key(id, *args)
+        end
+      
+        def redis_set
+          redis.set(redis_key, serializable_hash.to_json)
+        end
+      
+        def redis_get
+          load(ActiveSupport::JSON.decode(redis.get(redis_key)))
+        end
+        public :redis_get
+    
+        def raw_create
+          redis_set
+          create_indexes
+          redis.sadd(self.class.redis_key, self.id)
+        end
+      
+        def raw_update
+          destroy_indexes
+          redis_set
+          create_indexes
+        end
+    end
+    
+    module Model
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+    end
+  end
+end

data/lib/supermodel/timestamp.rb

@@ -0,0 +1,53 @@
+module SuperModel
+  module Timestamp
+    module Model
+      def self.included(base)
+        base.class_eval do
+          attributes :created_at, :updated_at
+          
+          before_create :set_created_at
+          before_save   :set_updated_at
+        end
+      end
+        
+      def touch
+        set_updated_at
+        save!
+      end
+      
+      def created_at=(time)
+        write_attribute(:created_at, parse_time(time))
+      end
+
+      def updated_at=(time)
+        write_attribute(:updated_at, parse_time(time))
+      end
+      
+      private
+        def parse_time(time)
+          return time unless time.is_a?(String)
+          if Time.respond_to?(:zone) && Time.zone
+            Time.zone.parse(time)
+          else
+            Time.parse(time)
+          end
+        end
+
+        def current_time
+          if Time.respond_to?(:current)
+            Time.current
+          else
+            Time.now
+          end
+        end
+      
+        def set_created_at
+          self.created_at = current_time
+        end
+        
+        def set_updated_at
+          self.updated_at = current_time
+        end
+    end
+  end
+end

data/lib/supermodel/validations.rb

@@ -0,0 +1,32 @@
+module SuperModel
+  module Validations
+    extend  ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    included do
+      alias_method_chain :save, :validation
+    end
+  
+    def save_with_validation(options = nil)
+      perform_validation = case options
+      when Hash
+        options[:validate] != false
+      when NilClass
+        true
+      else
+        options
+      end
+    
+      if perform_validation && valid? || !perform_validation
+        save_without_validation
+        true
+      else
+        false
+      end
+    rescue InvalidRecord => error
+      false
+    end
+  end
+end
+
+require "supermodel/validations/uniqueness"

data/lib/supermodel/validations/uniqueness.rb

@@ -0,0 +1,40 @@
+module SuperModel
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      attr_reader :klass
+      
+      def validate_each(record, attribute, value)
+        alternate = klass.find_by_attribute(attribute, value)
+        return unless alternate
+        record.errors.add(attribute, "must be unique", :default => options[:message])
+      end
+      
+      def setup(klass)
+        @klass = klass
+      end
+    end
+
+    module ClassMethods
+
+      # Validates that the specified attribute is unique.
+      #   class Person < ActiveRecord::Base
+      #     validates_uniquness_of :essay
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
+      # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>, <tt>:maximum</tt>, or <tt>:is</tt> violation.  An alias of the appropriate <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+      # * <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
+      #   not 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.
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/supermodel.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{csun-student-affairs-supermodel}
+  s.version = "0.1.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex MacCaw", "Mani Tadayon"]
+  s.date = %q{2010-08-30}
+  s.description = %q{In memory DB using ActiveModel}
+  s.email = %q{info@eribium.org}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "lib/super_model.rb",
+     "lib/supermodel.rb",
+     "lib/supermodel/association.rb",
+     "lib/supermodel/base.rb",
+     "lib/supermodel/callbacks.rb",
+     "lib/supermodel/dirty.rb",
+     "lib/supermodel/ext/array.rb",
+     "lib/supermodel/marshal.rb",
+     "lib/supermodel/observing.rb",
+     "lib/supermodel/random_id.rb",
+     "lib/supermodel/redis.rb",
+     "lib/supermodel/timestamp.rb",
+     "lib/supermodel/validations.rb",
+     "lib/supermodel/validations/uniqueness.rb",
+     "supermodel.gemspec"
+  ]
+  s.homepage = %q{https://github.com/csun-student-affairs/supermodel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{In memory DB using ActiveModel}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activemodel>, ["~> 3.0.0"])
+    else
+      s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
+    end
+  else
+    s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: csun-student-affairs-supermodel
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 5
+  version: 0.1.5
+platform: ruby
+authors: 
+- Alex MacCaw
+- Mani Tadayon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: In memory DB using ActiveModel
+email: info@eribium.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/super_model.rb
+- lib/supermodel.rb
+- lib/supermodel/association.rb
+- lib/supermodel/base.rb
+- lib/supermodel/callbacks.rb
+- lib/supermodel/dirty.rb
+- lib/supermodel/ext/array.rb
+- lib/supermodel/marshal.rb
+- lib/supermodel/observing.rb
+- lib/supermodel/random_id.rb
+- lib/supermodel/redis.rb
+- lib/supermodel/timestamp.rb
+- lib/supermodel/validations.rb
+- lib/supermodel/validations/uniqueness.rb
+- supermodel.gemspec
+has_rdoc: true
+homepage: https://github.com/csun-student-affairs/supermodel
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: In memory DB using ActiveModel
+test_files: []
+