supermodel 0.0.6 → 0.0.8

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.beta")
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install jeweler"
-end
+end

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.8

data/lib/supermodel/base.rb

@@ -1,24 +1,26 @@
 module SuperModel
   class Base    
     include ActiveModel::Dirty
-        
+    class_inheritable_array :known_attributes
+    self.known_attributes = []
+    
     class << self
       attr_accessor_with_default(:primary_key, 'id') #:nodoc:
-      
+
       def attributes(*attributes)
-        @known_attributes = attributes.map(&:to_s)
-      end
-      
-      def known_attributes
-        @known_attributes ||= []
+        self.known_attributes += attributes.map(&:to_s)
       end
       
       def records
         @records ||= []
       end
       
+      def find_by_attribute(name, value) #:nodoc:
+        records.find {|r| r.send(name) == value }
+      end
+      
       def raw_find(id) #:nodoc:
-        records.find {|r| r.id == id } || raise(UnknownRecord)
+        find_by_attribute(:id, id) || raise(UnknownRecord)
       end
       
       # Find record by ID, or raise.
@@ -46,8 +48,8 @@ module SuperModel
         records.dup
       end
       
-      def update(id, data)
-        find(id).update(data)
+      def update(id, atts)
+        find(id).update_attributes(atts)
       end
       
       def destroy(id)
@@ -74,10 +76,6 @@ module SuperModel
         rec.save && rec
       end
       
-      def find_by_attribute(name, value) #:nodoc:
-        records.find {|r| r.name == value }
-      end
-      
       def method_missing(method_symbol, *args) #:nodoc:
         method_name = method_symbol.to_s
 
@@ -94,12 +92,14 @@ 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
       load(attributes)
     end
@@ -114,7 +114,7 @@ module SuperModel
     end
     
     def new?
-      id.nil?
+      @new_record || false
     end
     alias :new_record? :new?
     
@@ -143,7 +143,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
     
@@ -193,8 +194,12 @@ module SuperModel
       end
     end
         
-    def destroy
+    def raw_destroy
       self.class.records.delete(self)
+    end
+    
+    def destroy
+      raw_destroy
       self
     end
     
@@ -211,16 +216,27 @@ module SuperModel
         object_id
       end
       
+      def raw_create
+        self.class.records << self.dup
+      end
+      
       def create
         self.id ||= generate_id
-        self.class.records << self.dup
+        self.new_record = false
+        raw_create
         save_previous_changes
+        self.id
       end
       
-      def update
+      def raw_update
         item = self.class.raw_find(id)
         item.load(attributes)
+      end
+      
+      def update
+        raw_update
         save_previous_changes
+        true
       end
       
       def save_previous_changes

data/lib/supermodel/marshal.rb

@@ -45,11 +45,13 @@ module SuperModel
       end
       
       def marshal_dump
-        @attributes
+        serializable_hash
       end
 
-      def marshal_load(attributes)
-        @attributes = attributes
+      def marshal_load(atts)
+        # Can't call load, since class
+        # isn't setup properly
+        @attributes = atts
       end
     end
   end

data/lib/supermodel/redis.rb

@@ -1,36 +1,43 @@
 module SuperModel
-  class Redis < Base
-    class << self
-      def redis
-        @redis ||= ::Redis.new
+  module Redis
+    module ClassMethods
+      def self.extended(base)
+        base.class_eval do
+          class_inheritable_array :indexed_attributes
+          self.indexed_attributes = []
+          class_inheritable_array :serialized_attributes
+          self.serialized_attributes = []
+        end
       end
       
-      def indexes(*indexes)
-        @known_indexes = indexes.map(&:to_s)
+      def namespace
+        @namespace ||= self.name.downcase
       end
       
-      def known_indexes
-        @known_indexes ||= []
+      def namespace=(namespace)
+        @namespace = namespace
       end
       
-      def serialize(*attributes)
-        @serialized_attributes = attributes.map(&:to_s)
+      def redis
+        @redis ||= ::Redis.new
       end
       
-      def serialized_attributes
-        @serialized_attributes ||= []
+      def indexes(*indexes)
+        self.indexed_attributes += indexes.map(&:to_s)
+      end
+      
+      def serialize(*attributes)
+        self.serialized_attributes += attributes.map(&:to_s)
       end
       
       def redis_key(*args)
-        args.unshift(self.name.downcase)
+        args.unshift(self.namespace)
         args.join(":")
       end
       
       def find(id)
         if redis.set_member?(redis_key, id)
-          res = self.new(:id => id)
-          res.redis_get
-          res
+          existing(:id => id)
         else
           raise(UnknownRecord)
         end
@@ -59,104 +66,116 @@ module SuperModel
       def find_by_attribute(key, value)
         item_ids = redis.set_members(redis_key(key, value))
         return if item_ids.empty?
-        res = self.new(:id => item_ids.first)
-        res.redis_get
-        res
+        existing(:id => item_ids.first)
       end
       
       protected
         def from_ids(ids)
-          ids.map do |id| 
-            res = self.new(:id => id)
-            res.redis_get
-            res
-          end
+          ids.map {|id| existing(:id => id) }
         end
-    end
         
-    def destroy
-      return if new?
-
-      destroy_indexes
-      redis.set_delete(self.class.redis_key, self.id)
-      
-      attributes.keys.each do |key|
-        redis.delete(redis_key(key))
-      end
+        def existing(atts = {})
+          item = self.new(atts)
+          item.new_record = false
+          item.redis_get
+          item
+        end
     end
     
-    protected
-      def destroy_indexes
-        known_indexes.each do |index|
-          old_attribute = changes[index].try(:first) || send(index)
-          redis.set_delete(self.class.redis_key(index, old_attribute), id)
-        end
+    module InstanceMethods
+      # Redis integers are stored as strings
+      def id
+        super.try(:to_i)
       end
       
-      def create_indexes
-        known_indexes.each do |index|
-          new_attribute = send(index)
-          redis.set_add(self.class.redis_key(index, new_attribute), id)
+      def raw_destroy
+        return if new?
+
+        destroy_indexes
+        redis.set_delete(self.class.redis_key, self.id)
+      
+        attributes.keys.each do |key|
+          redis.delete(redis_key(key))
         end
       end
     
-      def generate_id
-        redis.incr(self.class.redis_key(:uid))
-      end
+      protected
+        def destroy_indexes
+          indexed_attributes.each do |index|
+            old_attribute = changes[index].try(:first) || send(index)
+            redis.set_delete(self.class.redis_key(index, old_attribute), id)
+          end
+        end
       
-      def known_indexes
-        attributes.keys & self.class.known_indexes
-      end
+        def create_indexes
+          indexed_attributes.each do |index|
+            new_attribute = send(index)
+            redis.set_add(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
+          self.class.redis
+        end
     
-      def redis_key(*args)
-        self.class.redis_key(id, *args)
-      end
+        def redis_key(*args)
+          self.class.redis_key(id, *args)
+        end
       
-      def serialized_attributes
-        self.class.serialized_attributes
-      end
+        def serialized_attributes
+          self.class.serialized_attributes
+        end
       
-      def serialize_attribute(key, value)
-        return value unless serialized_attributes.include?(key)
-        value.to_json
-      end
+        def serialize_attribute(key, value)
+          return value unless serialized_attributes.include?(key)
+          value.to_json
+        end
       
-      def deserialize_attribute(key, value)
-        return value unless serialized_attributes.include?(key)
-        JSON.parse(value)
-      end
+        def deserialize_attribute(key, value)
+          return value unless serialized_attributes.include?(key)
+          value && JSON.parse(value)
+        end
       
-      def redis_set
-        attributes.each do |(key, value)|
-          redis.set(redis_key(key), serialize_attribute(key, value))
+        def redis_set
+          serializable_hash.each do |(key, value)|
+            redis.set(redis_key(key), serialize_attribute(key, value))
+          end
         end
-      end
       
-      def redis_get
-        known_attributes.each do |key|
-          result = deserialize_attribute(key, redis.get(redis_key(key)))
-          send("#{key}=", result)
+        def redis_get
+          known_attributes.each do |key|
+            result = deserialize_attribute(key, redis.get(redis_key(key)))
+            send("#{key}=", result)
+          end
         end
-      end
-      public :redis_get
+        public :redis_get
     
-      def create
-        self.id ||= generate_id
-        redis_set
-        create_indexes
-        redis.set_add(self.class.redis_key, self.id)
-        save_previous_changes
-      end
+        def raw_create
+          redis_set
+          create_indexes
+          redis.set_add(self.class.redis_key, self.id)
+        end
       
-      def update
-        destroy_indexes
-        redis_set
-        create_indexes
-        save_previous_changes
+        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
+end

data/lib/supermodel.rb

@@ -28,7 +28,6 @@ require "supermodel/callbacks"
 require "supermodel/observing"
 require "supermodel/marshal"
 require "supermodel/random_id"
-require "supermodel/scriber"
 require "supermodel/validations"
 require "supermodel/base"
 require "supermodel/redis"

data/supermodel.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{supermodel}
-  s.version = "0.0.6"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex MacCaw"]
-  s.date = %q{2010-02-06}
+  s.date = %q{2010-02-10}
   s.description = %q{In memory DB using ActiveModel}
   s.email = %q{info@eribium.org}
   s.extra_rdoc_files = [
@@ -28,7 +28,6 @@ Gem::Specification.new do |s|
      "lib/supermodel/observing.rb",
      "lib/supermodel/random_id.rb",
      "lib/supermodel/redis.rb",
-     "lib/supermodel/scriber.rb",
      "lib/supermodel/validations.rb",
      "supermodel.gemspec"
   ]
@@ -43,12 +42,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activemodel>, [">= 0"])
+      s.add_runtime_dependency(%q<activemodel>, [">= 3.0.0.beta"])
     else
-      s.add_dependency(%q<activemodel>, [">= 0"])
+      s.add_dependency(%q<activemodel>, [">= 3.0.0.beta"])
     end
   else
-    s.add_dependency(%q<activemodel>, [">= 0"])
+    s.add_dependency(%q<activemodel>, [">= 3.0.0.beta"])
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: supermodel
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors: 
 - Alex MacCaw
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-06 00:00:00 +00:00
+date: 2010-02-10 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 3.0.0.beta
     version: 
 description: In memory DB using ActiveModel
 email: info@eribium.org
@@ -43,7 +43,6 @@ files:
 - lib/supermodel/observing.rb
 - lib/supermodel/random_id.rb
 - lib/supermodel/redis.rb
-- lib/supermodel/scriber.rb
 - lib/supermodel/validations.rb
 - supermodel.gemspec
 has_rdoc: true

data/lib/supermodel/scriber.rb

@@ -1,80 +0,0 @@
-module SuperModel
-  module Scriber    
-    class Observer
-      include Singleton
-      
-      class << self
-        def disabled?
-          @disabled
-        end
-        
-        def disable(&block)
-          @disabled = true
-          yield
-          @disabled = false
-        end
-      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
-      
-      def update(observed_method, object) #:nodoc:
-        return if self.class.disabled?
-        send(observed_method, object) if respond_to?(observed_method)
-      end
-
-      def observed_class_inherited(subclass) #:nodoc:
-        subclass.add_observer(self)
-      end
-    end
-    
-    def klasses
-      @klasses ||= []
-    end
-    module_function :klasses
-    
-    module Model
-      def self.included(base)
-        Scriber.klasses << base
-        base.extend ClassMethods
-        base.add_observer(Observer.instance)
-      end
-      
-      module ClassMethods
-        def scribe_play(type, data) #:nodoc:
-          Observer.disable do
-            case type
-            when :create  then create(data)
-            when :destroy then destroy(data)
-            when :update  then update(data)
-            else
-              method = "scribe_play_#{type}"
-              send(method) if respond_to?(method)
-            end
-          end
-        end
-      
-        def record(type, data = nil)
-          ::Scriber.record(
-            :klass => self, 
-            :type => type, 
-            :data => data
-          )
-        end
-      end
-    end
-  end
-end