simple_record 2.0.5 → 2.1.0

data/lib/simple_record/validations.rb

@@ -0,0 +1,69 @@
+# This is actually still used to continue support for this.
+# ActiveModel does not work the same way so need to continue using this, will change name.
+
+module SimpleRecord
+  module Validations
+
+#    if defined?(:valid?) # from ActiveModel
+#      alias_method :am_valid?, :valid?
+#    end
+
+    def self.included(base)
+      puts 'Validations included ' + base.inspect
+#      if defined?(ActiveModel)
+#        base.class_eval do
+#          alias_method :am_valid?, :valid?
+#        end
+#      end
+    end
+
+    def valid?
+      puts 'in rails2 valid?'
+      errors.clear
+
+      if defined?(:am_valid?)
+        # And now ActiveModel validations too
+        am_valid?
+      end
+
+      #            run_callbacks(:validate)
+      validate
+
+
+      if new_record?
+        #                run_callbacks(:validate_on_create)
+        validate_on_create
+      else
+        #                run_callbacks(:validate_on_update)
+        validate_on_update
+      end
+
+
+      errors.empty?
+    end
+
+    def invalid?
+      !valid?
+    end
+
+
+    def read_attribute_for_validation(key)
+      @attributes[key.to_s]
+    end
+
+    def validate
+      true
+    end
+
+    def validate_on_create
+      true
+    end
+
+    def validate_on_update
+      true
+    end
+
+
+  end
+end
+

data/test/my_model.rb

@@ -1,60 +1,96 @@
 require File.expand_path(File.dirname(__FILE__) + "/../lib/simple_record")
 require_relative 'my_base_model'
+require_relative 'my_sharded_model'
 
 class MyModel < MyBaseModel
 
-    has_strings :name, :nickname, :s1, :s2
-    has_ints :age, :save_count
-    has_booleans :cool
-    has_dates :birthday, :date1, :date2, :date3
+  has_strings :name, :nickname, :s1, :s2
+  has_ints :age, :save_count
+  has_booleans :cool
+  has_dates :birthday, :date1, :date2, :date3
 
-    has_clobs :clob1, :clob2
+#    validates_presence_of :name
 
-    #callbacks
-    before_create :set_nickname
+#  validate :validate
+#  before_create :validate_on_create
+#  before_update :validate_on_update
 
-    before_save :bump_save_count
+  belongs_to :my_sharded_model
 
-    def set_nickname
-        self.nickname = name if self.nickname.blank?
-    end
+  has_clobs :clob1, :clob2
 
-    def bump_save_count
-#        puts 'save_count=' + save_count.to_s
-        if save_count.nil?
-            self.save_count = 1
-        else
-            self.save_count += 1
-        end
-#         puts 'save_count=' + self.save_count.to_s
-    end
+  attr_accessor :attr_before_save, :attr_after_save, :attr_before_create, :attr_after_create
 
-    def validate
-        errors.add("name", "can't be empty.") if name.blank?
-    end
+  #callbacks
+  before_create :set_nickname
+  after_create :after_create
+
+  before_save :before_save
+
+  after_save :after_save
+
+  def set_nickname
+    puts 'before_create set nickname'
+    @attr_before_create = true
+    self.nickname = name if self.nickname.blank?
+  end
+
+  def before_save
+    puts 'before_save'
+    @attr_before_save = true
+  end
 
-    def validate_on_create
-        errors.add("save_count", "should be zero.") if !save_count.blank? && save_count > 0
+  def after_create
+    puts 'after_create'
+    @attr_after_create = true
+  end
+  
+  def after_save
+    puts "after_save"
+    @attr_after_save = true
+    bump_save_count
+  end
+
+  def bump_save_count
+    puts 'after_save bump save_count=' + save_count.to_s
+    if save_count.nil?
+      self.save_count = 1
+    else
+      self.save_count += 1
     end
+#         puts 'save_count=' + self.save_count.to_s
+  end
+
+  def validate
+    puts 'MyModel.validate'
+    errors.add("name", "can't be empty.") if name.blank?
+#    errors.add("nickname", "can't be empty.") if nickname.blank?
+  end
+
+  def validate_on_create
+    puts 'MyModel.validate_on_create'
+    errors.add("save_count", "should be zero.") if !save_count.blank? && save_count > 0
+  end
 
-    def validate_on_update
+  def validate_on_update
+    puts 'MyModel.validate_on_update'
 #        puts 'save_count = ' + save_count.to_s
-        errors.add("save_count", "should not be zero.") if save_count.blank? || save_count == 0
-    end
+#    errors.add("save_count", "should not be zero.") if save_count.blank? || save_count == 0
+  end
 
-    def atts
-        @@attributes
-    end
+  def atts
+    @@attributes
+  end
 
-end
 
+end
 
 
 class SingleClobClass < SimpleRecord::Base
 
-    sr_config :single_clob=>true
+  sr_config :single_clob=>true
 
-    has_strings :name
+  has_strings :name
 
-    has_clobs :clob1, :clob2
+  has_clobs :clob1, :clob2
 end

data/test/my_sharded_model.rb

@@ -4,38 +4,43 @@ require File.expand_path(File.dirname(__FILE__) + "/../lib/simple_record")
 
 class MyShardedModel < SimpleRecord::Base
 
-    shard :shards=>:my_shards, :map=>:my_mapping_function
+  shard :shards=>:my_shards, :map=>:my_mapping_function
 
-    has_strings :name
+  has_strings :name
 
-    def self.my_shards
-        Array(0...4)
-    end
+  def self.num_shards
+    4
+  end
 
-    def my_mapping_function
-        shard_num = SimpleRecord::Sharding::Hashing.sdbm_hash(self.id) % 4
-        puts "shard_num=" + shard_num.inspect
-        shard_num
-    end
+  def self.my_shards
+    Array(0...self.num_shards)
+  end
 
+  def my_mapping_function
+    shard_num = SimpleRecord::Sharding::Hashing.sdbm_hash(self.id) % self.class.num_shards
+    puts "shard_num=" + shard_num.inspect
+    shard_num
+  end
 
+  def self.shard_for_find(id)
+    shard_num = SimpleRecord::Sharding::Hashing.sdbm_hash(id) % self.num_shards
+  end
 
 end
 
 
 class MyShardedByFieldModel < SimpleRecord::Base
 
-    shard :shards=>:my_shards, :map=>:my_mapping_function
+  shard :shards=>:my_shards, :map=>:my_mapping_function
 
-    has_strings :name, :state
+  has_strings :name, :state
 
-    def self.my_shards
-        ['AL', 'CA', 'FL', 'NY']
-    end
+  def self.my_shards
+    ['AL', 'CA', 'FL', 'NY']
+  end
 
-    def my_mapping_function
-        state
-    end
+  def my_mapping_function
+    state
+  end
 
-
-end
+end

data/test/my_simple_model.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/simple_record")
+require_relative 'my_base_model'
+require_relative 'my_sharded_model'
+
+class MySimpleModel < SimpleRecord::Base
+
+  has_strings :name, :nickname, :s1, :s2
+  has_ints :age, :save_count
+  has_booleans :cool
+  has_dates :birthday, :date1, :date2, :date3
+
+
+end

data/test/test_shards.rb

@@ -10,136 +10,139 @@ require_relative 'my_sharded_model'
 #
 class TestShards < TestBase
 
-    def setup
-        super
-        delete_all MyShardedModel
-        delete_all MyShardedByFieldModel
+  def setup
+    super
+    delete_all MyShardedModel
+    delete_all MyShardedByFieldModel
+  end
+
+  def teardown
+    super
+
+  end
+
+  # We'll want to shard based on ID's, user decides how many shards and some mapping function will
+  # be used to select the shard.
+  def test_id_sharding
+
+    mm = MyShardedModel.new(:name=>"single")
+    mm.save
+    sleep 1
+    puts 'finding by id'
+    mm2 = MyShardedModel.find(mm.id)
+    p mm2
+    assert_equal mm.id, mm2.id
+    puts 'deleting'
+    mm2.delete
+    sleep 1
+    mm3 = MyShardedModel.find(mm.id)
+    assert_nil mm3
+
+    puts "saving 20 now"
+    saved = []
+    20.times do |i|
+      mm = MyShardedModel.new(:name=>"name #{i}")
+      mm.save
+      saved << mm
     end
 
-    def teardown
-        super
+    # todo: assert that we're actually sharding
 
+    puts "finding them all"
+    found = []
+    rs    = MyShardedModel.find(:all)
+    rs.each do |m|
+      p m
+      found << m
     end
+    saved.each do |so|
+      assert(found.find { |m1| m1.id == so.id })
+    end
+
+    puts "deleting all of them"
+    found.each do |fo|
+      fo.delete
+    end
+
+    puts "Now ensure that all are deleted"
+    rs = MyShardedModel.find(:all)
+    assert rs.size == 0
+
+    puts "Testing belongs_to sharding"
+
+
+  end
+
+  def test_field_sharding
+
+    states = MyShardedByFieldModel.shards
+    puts "states=" + states.inspect
 
-    # We'll want to shard based on ID's, user decides how many shards and some mapping function will
-    # be used to select the shard.
-    def test_id_sharding
-
-        mm = MyShardedModel.new(:name=>"single")
-        mm.save
-        sleep 1
-        puts 'finding by id'
-        mm2 = MyShardedModel.find(mm.id)
-        p mm2
-        assert_equal mm.id, mm2.id
-        puts 'deleting'
-        mm2.delete
-        sleep 1
-        mm3 = MyShardedModel.find(mm.id)
-        assert_nil mm3
-
-        puts "saving 20 now"
-        saved = []
-        20.times do |i|
-            mm = MyShardedModel.new(:name=>"name #{i}")
-            mm.save
-            saved << mm
-        end
-
-        # todo: assert that we're actually sharding
-
-        puts "finding them all"
-        found = []
-        rs    = MyShardedModel.find(:all)
-        rs.each do |m|
-            p m
-            found << m
-        end
-        saved.each do |so|
-            assert(found.find { |m1| m1.id == so.id })
-        end
-
-        puts "deleting all of them"
-        found.each do |fo|
-            fo.delete
-        end
-
-        puts "Now ensure that all are deleted"
-        rs = MyShardedModel.find(:all)
-        assert rs.size == 0
+    mm = MyShardedByFieldModel.new(:name=>"single", :state=>"CA")
+    mm.save
+    sleep 1
+    puts 'finding by id'
+    mm2 = MyShardedByFieldModel.find(mm.id)
+    p mm2
+    assert_equal mm.id, mm2.id
+    puts 'deleting'
+    mm2.delete
+    sleep 1
+    mm3 = MyShardedByFieldModel.find(mm.id)
+    assert_nil mm3
 
+    puts "saving 20 now"
+    saved = []
+    20.times do |i|
+      mm = MyShardedByFieldModel.new(:name=>"name #{i}", :state=>states[i % states.size])
+      mm.save
+      p mm
+      saved << mm
     end
 
-    def test_field_sharding
-
-        states = MyShardedByFieldModel.shards
-        puts "states=" + states.inspect
-
-        mm = MyShardedByFieldModel.new(:name=>"single", :state=>"CA")
-        mm.save
-        sleep 1
-        puts 'finding by id'
-        mm2 = MyShardedByFieldModel.find(mm.id)
-        p mm2
-        assert_equal mm.id, mm2.id
-        puts 'deleting'
-        mm2.delete
-        sleep 1
-        mm3 = MyShardedByFieldModel.find(mm.id)
-        assert_nil mm3
-
-        puts "saving 20 now"
-        saved = []
-        20.times do |i|
-            mm = MyShardedByFieldModel.new(:name=>"name #{i}", :state=>states[i % states.size])
-            mm.save
-            p mm
-            saved << mm
-        end
-
-        sleep 1
-        # todo: assert that we're actually sharding
-
-        puts "finding them all"
-        found = []
-        rs    = MyShardedByFieldModel.find(:all)
-        rs.each do |m|
-            p m
-            found << m
-        end
-        saved.each do |so|
-            assert(found.find { |m1| m1.id == so.id })
-        end
-
-        rs    = MyShardedByFieldModel.find(:all)
-        rs.each do |m|
-            p m
-            found << m
-        end
-        saved.each do |so|
-            assert(found.find { |m1| m1.id == so.id })
-        end
-
-        # Try to find on a specific known shard
-        selects = SimpleRecord.stats.selects
-        cali_models = MyShardedByFieldModel.find(:all, :shard => "CA")
-        puts 'cali_models=' + cali_models.inspect
-        assert_equal(5, cali_models.size)
-        assert_equal(selects + 1, SimpleRecord.stats.selects)
-
-        puts "deleting all of them"
-        found.each do |fo|
-            fo.delete
-        end
-        sleep 1
-
-        puts "Now ensure that all are deleted"
-        rs = MyShardedByFieldModel.find(:all)
-        assert rs.size == 0
+    sleep 1
+    # todo: assert that we're actually sharding
+
+    puts "finding them all"
+    found = []
+    rs    = MyShardedByFieldModel.find(:all)
+    rs.each do |m|
+      p m
+      found << m
+    end
+    saved.each do |so|
+      assert(found.find { |m1| m1.id == so.id })
+    end
+
+    rs = MyShardedByFieldModel.find(:all)
+    rs.each do |m|
+      p m
+      found << m
+    end
+    saved.each do |so|
+      assert(found.find { |m1| m1.id == so.id })
     end
 
-    def test_time_sharding
+    # Try to find on a specific known shard
+    selects     = SimpleRecord.stats.selects
+    cali_models = MyShardedByFieldModel.find(:all, :shard => "CA")
+    puts 'cali_models=' + cali_models.inspect
+    assert_equal(5, cali_models.size)
+    assert_equal(selects + 1, SimpleRecord.stats.selects)
 
+    puts "deleting all of them"
+    found.each do |fo|
+      fo.delete
     end
+    sleep 1
+
+    puts "Now ensure that all are deleted"
+    rs = MyShardedByFieldModel.find(:all)
+    assert rs.size == 0
+  end
+
+  def test_time_sharding
+
+  end
 
 end