supermodel 0.0.1 → 0.1.6

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

@@ -1,7 +1,7 @@
 
 Simple in-memory database using ActiveModel.
 
-Primarily developed for Bowline application.
+Primarily developed for Bowline applications.
 http://github.com/maccman/bowline
 
 Supports:
@@ -10,7 +10,8 @@ Supports:
   * Callbacks
   * Observers
   * Dirty (Changes)
-  * Persistance
+  * Ruby Marshalling to disk
+  * Redis
 
 Examples:
 
@@ -37,15 +38,27 @@ You can use a random ID rather than the object ID:
   t = Test.create(:name => "test")
   t.id #=> "7ee935377bb4aecc54ad4f9126"
   
-You can persist objects to disk on startup/shutdown
+You can marshal objects to disk on startup/shutdown
   
   class Test < SuperModel::Base
-    include SuperModel::Persist::Model
+    include SuperModel::Marshal::Model
   end
   
-  SuperModel::Persist.path = "dump.db"
-  SuperModel::Persist.load
+  SuperModel::Marshal.path = "dump.db"
+  SuperModel::Marshal.load
 
   at_exit {
-    SuperModel::Persist.dump
-  }
+    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

@@ -7,8 +7,8 @@ begin
     gemspec.homepage = "http://github.com/maccman/supermodel"
     gemspec.description = "In memory DB using ActiveModel"
     gemspec.authors = ["Alex MacCaw"]
-    gemspec.add_dependency("activemodel")
+    gemspec.add_dependency("activemodel", "~> 3.0.0")
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install jeweler"
-end
+end

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.6

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

@@ -1,16 +1,41 @@
 module SuperModel
   class Base    
-    include ActiveModel::Dirty
-        
+    class_attribute :known_attributes
+    self.known_attributes = []
+    
     class << self
-      attr_accessor_with_default(:primary_key, 'id') #:nodoc:
+      attr_accessor(:primary_key) #:nodoc:
+      
+      def primary_key
+        @primary_key ||= 'id'
+      end
+      
+      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 ||= []
+        @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.find {|r| r.id == id } || raise(UnknownRecord)
+        records[id] || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
       end
       
       # Find record by ID, or raise.
@@ -21,25 +46,33 @@ module SuperModel
       alias :[] :find
     
       def first
-        item = records[0]
+        item = records.values[0]
         item && item.dup
       end
       
       def last
-        item = records[1]
+        item = records.values[-1]
         item && item.dup
       end
       
+      def exists?(id)
+        records.has_key?(id)
+      end
+      
       def count
         records.length
       end
     
       def all
-        records.dup
+        collection.new(records.values.deep_dup)
       end
       
-      def update(id, data)
-        find(id).update(data)
+      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)
@@ -49,7 +82,7 @@ module SuperModel
       # Removes all records and executes 
       # destory callbacks.
       def destroy_all
-        records.dup.each {|r| r.destroy }
+        all.each {|r| r.destroy }
       end
       
       # Removes all records without executing
@@ -66,13 +99,21 @@ module SuperModel
         rec.save && rec
       end
       
-      def method_missing(method_symbol, *arguments) #:nodoc:
+      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}", *arguments) || raise(UnknownRecord)
+          send("find_by_#{$1}", *args) || raise(UnknownRecord)
         elsif method_name =~ /^find_by_(\w+)/
-          records.find {|r| r.send($1) == arguments.first }
+          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
@@ -80,9 +121,17 @@ module SuperModel
     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
     
@@ -96,7 +145,7 @@ module SuperModel
     end
     
     def new?
-      id.nil?
+      @new_record || false
     end
     alias :new_record? :new?
     
@@ -125,7 +174,8 @@ module SuperModel
     
     def dup
       self.class.new.tap do |base|
-        base.attributes = @attributes.dup
+        base.attributes = attributes
+        base.new_record = new_record?
       end
     end
     
@@ -140,9 +190,20 @@ module SuperModel
     def exists?
       !new?
     end
+    alias_method :persisted?, :exists?
     
     def load(attributes) #:nodoc:
-      @attributes.merge!(attributes)
+      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)
@@ -154,21 +215,31 @@ module SuperModel
       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
-      self.class.records.delete(self)
+      raw_destroy
       self
     end
     
@@ -185,21 +256,29 @@ module SuperModel
         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.class.records << self.dup
-        save_previous_changes
+        self.new_record = false
+        raw_create
+        self.id
       end
       
-      def update
+      def raw_update
         item = self.class.raw_find(id)
         item.load(attributes)
-        save_previous_changes
       end
       
-      def save_previous_changes
-        @previously_changed = changes
-        changed_attributes.clear
+      def update
+        raw_update
+        true
       end
     
     private
@@ -217,14 +296,18 @@ module SuperModel
           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
+    extend  ActiveModel::Naming
     include ActiveModel::Conversion
-    include Observing, Validations, Scriber
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Dirty, Observing, Callbacks, Validations
+    include Association::Model
   end
 end

data/lib/supermodel/callbacks.rb

@@ -1,15 +1,18 @@
 module SuperModel
   module Callbacks
     extend ActiveSupport::Concern
-    extend ActiveModel::Callbacks
-    
+
     included do
-      define_model_callbacks :create, :save, :update, :destroy
+      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_notifications(*args, &block)
+              #{method}_without_callbacks(*args, &block)
             end
           end
         EOS

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/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/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/lib/supermodel/validations.rb

@@ -27,4 +27,6 @@ module SuperModel
       false
     end
   end
-end
+end
+
+require "supermodel/validations/uniqueness"

data/lib/supermodel.rb

@@ -2,32 +2,36 @@ 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/misc"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/class/attribute"
+require "active_support/json"
 
 require "active_model"
 
-
 module SuperModel
   class SuperModelError < StandardError; end
   class UnknownRecord < SuperModelError; end
   class InvalidRecord < SuperModelError; end
 end
 
-$: << File.dirname(__FILE__)
+$:.unshift(File.dirname(__FILE__))
+require "supermodel/ext/array"
 
-require "supermodel/callbacks"
-require "supermodel/observing"
-require "supermodel/persist"
-require "supermodel/random_id"
-require "supermodel/scriber"
-require "supermodel/validations"
-require "supermodel/base"
+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

data/supermodel.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{supermodel}
-  s.version = "0.0.1"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex MacCaw"]
-  s.date = %q{2010-02-04}
+  s.date = %q{2010-08-30}
   s.description = %q{In memory DB using ActiveModel}
   s.email = %q{info@eribium.org}
   s.extra_rdoc_files = [
@@ -17,37 +17,43 @@ Gem::Specification.new do |s|
   ]
   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/persist.rb",
      "lib/supermodel/random_id.rb",
-     "lib/supermodel/scriber.rb",
+     "lib/supermodel/redis.rb",
+     "lib/supermodel/timestamp.rb",
      "lib/supermodel/validations.rb",
+     "lib/supermodel/validations/uniqueness.rb",
      "supermodel.gemspec"
   ]
   s.homepage = %q{http://github.com/maccman/supermodel}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  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::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activemodel>, [">= 0"])
+    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>, [">= 0"])
+      s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
     end
   else
-    s.add_dependency(%q<activemodel>, [">= 0"])
+    s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
   end
 end
 

metadata

@@ -1,77 +1,75 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: supermodel
-version: !ruby/object:Gem::Version 
-  version: 0.0.1
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alex MacCaw
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-02-04 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activemodel
+  requirement: &70347445690680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+  prerelease: false
+  version_requirements: *70347445690680
 description: In memory DB using ActiveModel
 email: info@eribium.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
-files: 
-- .gitignore
+files:
+- 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/persist.rb
 - lib/supermodel/random_id.rb
-- lib/supermodel/scriber.rb
+- lib/supermodel/redis.rb
+- lib/supermodel/timestamp.rb
 - lib/supermodel/validations.rb
+- lib/supermodel/validations/uniqueness.rb
 - supermodel.gemspec
-has_rdoc: true
 homepage: http://github.com/maccman/supermodel
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: In memory DB using ActiveModel
 test_files: []
-

data/.gitignore

@@ -1,2 +0,0 @@
-dump.db
-test.rb

data/lib/supermodel/persist.rb

@@ -1,56 +0,0 @@
-require "tempfile"
-require "fileutils"
-
-module SuperModel
-  module Persist
-    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)
-      records = []
-      File.open(path, "rb") {|file|
-        records = Marshal.load(file)
-      }
-      records.each {|r| r.class.records << r }
-      true
-    end
-  
-    def dump
-      return unless path
-      tmp_file = Tempfile.new("rbdump")
-      tmp_file.binmode
-      records  = klasses.map {|k| k.records }.flatten
-      Marshal.dump(records, tmp_file)
-      # Atomic serialization - so we never corrupt the db
-      FileUtils.mv(tmp_file.path, path)
-      true
-    end
-    
-    extend self
-    
-    module Model
-      def self.included(base)
-        Persist.klasses << base
-      end
-      
-      def marshal_dump
-        @attributes
-      end
-
-      def marshal_load(attributes)
-        @attributes = attributes
-      end
-    end
-  end
-end

data/lib/supermodel/scriber.rb

@@ -1,51 +0,0 @@
-module SuperModel
-  module Scriber
-    def klasses
-      @klasses ||= []
-    end
-    module_function :klasses
-    
-    class Observer < ActiveModel::Observer
-      def self.observed_classes
-        Scriber.klasses
-      end
-      
-      def after_create(rec)
-        rec.class.record(:create, rec.attributes)
-      end
-      
-      def after_update(rec)
-        changed_to = rec.previous_changes.inject({}) {|hash, (key, (from, to))| 
-          hash[key] = to
-          hash 
-        }
-        rec.class.record(:update, changed_to)
-      end
-      
-      def after_destroy
-        rec.class.record(:destroy, rec.id)
-      end      
-    end
-    
-    module Model
-      def self.extended(base)
-        Scriber.klasses << base
-      end
-
-      def scribe_load(type, data) #:nodoc:
-        case type
-        when :create  then create(data)
-        when :destroy then destroy(data)
-        when :update  then update(data)
-        else
-          method = "scribe_load_#{type}"
-          send(method) if respond_to?(method)
-        end
-      end
-      
-      def record(type, data)
-        ::Scriber.record(self, type, data)
-      end
-    end
-  end
-end