supermodel 0.0.1

data/.gitignore

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

data/README

@@ -0,0 +1,51 @@
+
+Simple in-memory database using ActiveModel.
+
+Primarily developed for Bowline application.
+http://github.com/maccman/bowline
+
+Supports:
+  * Serialisation
+  * Validations
+  * Callbacks
+  * Observers
+  * Dirty (Changes)
+  * Persistance
+
+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 persist objects to disk on startup/shutdown
+  
+  class Test < SuperModel::Base
+    include SuperModel::Persist::Model
+  end
+  
+  SuperModel::Persist.path = "dump.db"
+  SuperModel::Persist.load
+
+  at_exit {
+    SuperModel::Persist.dump
+  }

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

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/super_model.rb

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

data/lib/supermodel/base.rb

@@ -0,0 +1,230 @@
+module SuperModel
+  class Base    
+    include ActiveModel::Dirty
+        
+    class << self
+      attr_accessor_with_default(:primary_key, 'id') #:nodoc:
+      
+      def records
+        @records ||= []
+      end
+      
+      def raw_find(id) #:nodoc:
+        records.find {|r| r.id == id } || raise(UnknownRecord)
+      end
+      
+      # Find record by ID, or raise.
+      def find(id)
+        item = raw_find(id)
+        item && item.dup
+      end
+      alias :[] :find
+    
+      def first
+        item = records[0]
+        item && item.dup
+      end
+      
+      def last
+        item = records[1]
+        item && item.dup
+      end
+      
+      def count
+        records.length
+      end
+    
+      def all
+        records.dup
+      end
+      
+      def update(id, data)
+        find(id).update(data)
+      end
+      
+      def destroy(id)
+        find(id).destroy
+      end
+      
+      # Removes all records and executes 
+      # destory callbacks.
+      def destroy_all
+        records.dup.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 method_missing(method_symbol, *arguments) #:nodoc:
+        method_name = method_symbol.to_s
+
+        if method_name =~ /^find_by_(\w+)!/
+          send("find_by_#{$1}", *arguments) || raise(UnknownRecord)
+        elsif method_name =~ /^find_by_(\w+)/
+          records.find {|r| r.send($1) == arguments.first }
+        else
+          super
+        end
+      end
+    end
+    
+    attr_accessor :attributes
+    
+    def initialize(attributes = {})
+      @attributes = {}.with_indifferent_access
+      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?
+      id.nil?
+    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.dup
+      end
+    end
+    
+    def save
+      new? ? create : update
+    end
+    
+    def save!
+      save || raise(InvalidRecord)
+    end
+    
+    def exists?
+      !new?
+    end
+    
+    def load(attributes) #:nodoc:
+      @attributes.merge!(attributes)
+    end
+    
+    def update_attribute(name, value)
+      self.send("#{name}=".to_sym, value)
+      self.save
+    end
+    
+    def update_attributes(attributes)
+      load(attributes) && save
+    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 method_name =~ /(?:=|\?)$/ && attributes.include?($`)
+        true
+      else
+        super
+      end
+    end
+        
+    def destroy
+      self.class.records.delete(self)
+      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 create
+        self.id ||= generate_id
+        self.class.records << self.dup
+        save_previous_changes
+      end
+      
+      def update
+        item = self.class.raw_find(id)
+        item.load(attributes)
+        save_previous_changes
+      end
+      
+      def save_previous_changes
+        @previously_changed = changes
+        changed_attributes.clear
+      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)
+          super
+        end
+      end
+  end
+  
+  class Base
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include Observing, Validations, Scriber
+  end
+end

data/lib/supermodel/callbacks.rb

@@ -0,0 +1,20 @@
+module SuperModel
+  module Callbacks
+    extend ActiveSupport::Concern
+    extend ActiveModel::Callbacks
+    
+    included do
+      define_model_callbacks :create, :save, :update, :destroy
+      %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)
+            end
+          end
+        EOS
+        alias_method_chain(method, :callbacks)
+      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/persist.rb

@@ -0,0 +1,56 @@
+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/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/scriber.rb

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

data/lib/supermodel/validations.rb

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

data/lib/supermodel.rb

@@ -0,0 +1,33 @@
+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_model"
+
+
+module SuperModel
+  class SuperModelError < StandardError; end
+  class UnknownRecord < SuperModelError; end
+  class InvalidRecord < SuperModelError; end
+end
+
+$: << File.dirname(__FILE__)
+
+require "supermodel/callbacks"
+require "supermodel/observing"
+require "supermodel/persist"
+require "supermodel/random_id"
+require "supermodel/scriber"
+require "supermodel/validations"
+require "supermodel/base"

data/supermodel.gemspec

@@ -0,0 +1,53 @@
+# 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{supermodel}
+  s.version = "0.0.1"
+
+  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.description = %q{In memory DB using ActiveModel}
+  s.email = %q{info@eribium.org}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "lib/super_model.rb",
+     "lib/supermodel.rb",
+     "lib/supermodel/base.rb",
+     "lib/supermodel/callbacks.rb",
+     "lib/supermodel/observing.rb",
+     "lib/supermodel/persist.rb",
+     "lib/supermodel/random_id.rb",
+     "lib/supermodel/scriber.rb",
+     "lib/supermodel/validations.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.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"])
+    else
+      s.add_dependency(%q<activemodel>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activemodel>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: supermodel
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex MacCaw
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-04 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: In memory DB using ActiveModel
+email: info@eribium.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- lib/super_model.rb
+- lib/supermodel.rb
+- lib/supermodel/base.rb
+- lib/supermodel/callbacks.rb
+- lib/supermodel/observing.rb
+- lib/supermodel/persist.rb
+- lib/supermodel/random_id.rb
+- lib/supermodel/scriber.rb
+- lib/supermodel/validations.rb
+- supermodel.gemspec
+has_rdoc: true
+homepage: http://github.com/maccman/supermodel
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: In memory DB using ActiveModel
+test_files: []
+