cassandra_object 0.6.0.pre

data/vendor/activemodel/test/cases/validations/with_validation_test.rb

@@ -0,0 +1,166 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+
+class ValidatesWithTest < ActiveRecord::TestCase
+  include ActiveModel::TestsDatabase
+
+  def teardown
+    Topic.reset_callbacks(:validate)
+  end
+
+  ERROR_MESSAGE = "Validation error from validator"
+  OTHER_ERROR_MESSAGE = "Validation error from other validator"
+
+  class ValidatorThatAddsErrors < ActiveModel::Validator
+    def validate(record)
+      record.errors[:base] << ERROR_MESSAGE
+    end
+  end
+
+  class OtherValidatorThatAddsErrors < ActiveModel::Validator
+    def validate(record)
+      record.errors[:base] << OTHER_ERROR_MESSAGE
+    end
+  end
+
+  class ValidatorThatDoesNotAddErrors < ActiveModel::Validator
+    def validate(record)
+    end
+  end
+
+  class ValidatorThatValidatesOptions < ActiveModel::Validator
+    def validate(record)
+      if options[:field] == :first_name
+        record.errors[:base] << ERROR_MESSAGE
+      end
+    end
+  end
+
+  class ValidatorPerEachAttribute < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      record.errors[attribute] << "Value is #{value}"
+    end
+  end
+
+  class ValidatorCheckValidity < ActiveModel::EachValidator
+    def check_validity!
+      raise "boom!"
+    end
+  end
+
+  test "vaidation with class that adds errors" do
+    Topic.validates_with(ValidatorThatAddsErrors)
+    topic = Topic.new
+    assert !topic.valid?, "A class that adds errors causes the record to be invalid"
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+  end
+
+  test "with a class that returns valid" do
+    Topic.validates_with(ValidatorThatDoesNotAddErrors)
+    topic = Topic.new
+    assert topic.valid?, "A class that does not add errors does not cause the record to be invalid"
+  end
+
+  test "with a class that adds errors on update and a new record" do
+    Topic.validates_with(ValidatorThatAddsErrors, :on => :update)
+    topic = Topic.new
+    assert topic.valid?, "Validation doesn't run on create if 'on' is set to update"
+  end
+
+  test "with a class that adds errors on create and a new record" do
+    Topic.validates_with(ValidatorThatAddsErrors, :on => :create)
+    topic = Topic.new
+    assert !topic.valid?, "Validation does run on create if 'on' is set to create"
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+  end
+
+  test "with multiple classes" do
+    Topic.validates_with(ValidatorThatAddsErrors, OtherValidatorThatAddsErrors)
+    topic = Topic.new
+    assert !topic.valid?
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+    assert topic.errors[:base].include?(OTHER_ERROR_MESSAGE)
+  end
+
+  test "with if statements that return false" do
+    Topic.validates_with(ValidatorThatAddsErrors, :if => "1 == 2")
+    topic = Topic.new
+    assert topic.valid?
+  end
+
+  test "with if statements that return true" do
+    Topic.validates_with(ValidatorThatAddsErrors, :if => "1 == 1")
+    topic = Topic.new
+    assert !topic.valid?
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+  end
+
+  test "with unless statements that return true" do
+    Topic.validates_with(ValidatorThatAddsErrors, :unless => "1 == 1")
+    topic = Topic.new
+    assert topic.valid?
+  end
+
+  test "with unless statements that returns false" do
+    Topic.validates_with(ValidatorThatAddsErrors, :unless => "1 == 2")
+    topic = Topic.new
+    assert !topic.valid?
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+  end
+
+  test "passes all configuration options to the validator class" do
+    topic = Topic.new
+    validator = mock()
+    validator.expects(:new).with(:foo => :bar, :if => "1 == 1").returns(validator)
+    validator.expects(:validate).with(topic)
+
+    Topic.validates_with(validator, :if => "1 == 1", :foo => :bar)
+    assert topic.valid?
+  end
+
+  test "validates_with with options" do
+    Topic.validates_with(ValidatorThatValidatesOptions, :field => :first_name)
+    topic = Topic.new
+    assert !topic.valid?
+    assert topic.errors[:base].include?(ERROR_MESSAGE)
+  end
+
+  test "validates_with each validator" do
+    Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content])
+    topic = Topic.new :title => "Title", :content => "Content"
+    assert !topic.valid?
+    assert_equal ["Value is Title"], topic.errors[:title]
+    assert_equal ["Value is Content"], topic.errors[:content]
+  end
+
+  test "each validator checks validity" do
+    assert_raise RuntimeError do
+      Topic.validates_with(ValidatorCheckValidity, :attributes => [:title])
+    end
+  end
+
+  test "each validator expects attributes to be given" do
+    assert_raise RuntimeError do
+      Topic.validates_with(ValidatorPerEachAttribute)
+    end
+  end
+
+  test "each validator skip nil values if :allow_nil is set to true" do
+    Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content], :allow_nil => true)
+    topic = Topic.new :content => ""
+    assert !topic.valid?
+    assert topic.errors[:title].empty?
+    assert_equal ["Value is "], topic.errors[:content]
+  end
+
+  test "each validator skip blank values if :allow_blank is set to true" do
+    Topic.validates_with(ValidatorPerEachAttribute, :attributes => [:title, :content], :allow_blank => true)
+    topic = Topic.new :content => ""
+    assert topic.valid?
+    assert topic.errors[:title].empty?
+    assert topic.errors[:content].empty?
+  end
+end

data/vendor/activemodel/test/cases/validations_test.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/reply'
+require 'models/developer'
+require 'models/custom_reader'
+
+class ValidationsTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+
+  # Most of the tests mess with the validations of Topic, so lets repair it all the time.
+  # Other classes we mess with will be dealt with in the specific tests
+  def teardown
+    Topic.reset_callbacks(:validate)
+  end
+
+  def test_single_field_validation
+    r = Reply.new
+    r.title = "There's no content!"
+    assert !r.valid?, "A reply without content shouldn't be saveable"
+
+    r.content = "Messa content!"
+    assert r.valid?, "A reply with content should be saveable"
+  end
+
+  def test_single_attr_validation_and_error_msg
+    r = Reply.new
+    r.title = "There's no content!"
+    assert !r.valid?
+    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["content"], "A reply without content should contain an error"
+    assert_equal 1, r.errors.count
+  end
+
+  def test_double_attr_validation_and_error_msg
+    r = Reply.new
+    assert !r.valid?
+
+    assert r.errors[:title].any?, "A reply without title should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["title"], "A reply without title should contain an error"
+
+    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["content"], "A reply without content should contain an error"
+
+    assert_equal 2, r.errors.count
+  end
+
+  def test_single_error_per_attr_iteration
+    r = Reply.new
+    r.save
+
+    errors = []
+    r.errors.each {|attr, messages| errors << [attr.to_s, messages] }
+
+    assert errors.include?(["title", "Empty"])
+    assert errors.include?(["content", "Empty"])
+  end
+
+  def test_multiple_errors_per_attr_iteration_with_full_error_composition
+    r = Reply.new
+    r.title   = "Wrong Create"
+    r.content = "Mismatch"
+    r.save
+
+    errors = r.errors.to_a
+
+    assert_equal "Title is Wrong Create", errors[0]
+    assert_equal "Title is Content Mismatch", errors[1]
+    assert_equal 2, r.errors.count
+  end
+
+  def test_errors_on_nested_attributes_expands_name
+    t = Topic.new
+    t.errors["replies.name"] << "can't be blank"
+    assert_equal ["Replies name can't be blank"], t.errors.full_messages
+  end
+
+  def test_errors_on_base
+    r = Reply.new
+    r.content = "Mismatch"
+    r.save
+    r.errors[:base] << "Reply is not dignifying"
+
+    errors = []
+    r.errors.to_a.each { |error| errors << error }
+
+    assert_equal ["Reply is not dignifying"], r.errors[:base]
+
+    assert errors.include?("Title Empty")
+    assert errors.include?("Reply is not dignifying")
+    assert_equal 2, r.errors.count
+  end
+
+  def test_validates_each
+    hits = 0
+    Topic.validates_each(:title, :content, [:title, :content]) do |record, attr|
+      record.errors.add attr, 'gotcha'
+      hits += 1
+    end
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert !t.save
+    assert_equal 4, hits
+    assert_equal %w(gotcha gotcha), t.errors[:title]
+    assert_equal %w(gotcha gotcha), t.errors[:content]
+  end
+  
+  def test_validates_each_custom_reader
+    hits = 0
+    CustomReader.validates_each(:title, :content, [:title, :content]) do |record, attr|
+      record.errors.add attr, 'gotcha'
+      hits += 1
+    end
+    t = CustomReader.new("title" => "valid", "content" => "whatever")
+    assert !t.valid?
+    assert_equal 4, hits
+    assert_equal %w(gotcha gotcha), t.errors[:title]
+    assert_equal %w(gotcha gotcha), t.errors[:content]
+  end
+
+  def test_validate_block
+    Topic.validate { |topic| topic.errors.add("title", "will never be valid") }
+    t = Topic.create("title" => "Title", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["will never be valid"], t.errors["title"]
+  end
+
+  def test_invalid_validator
+    Topic.validate :i_dont_exist
+    assert_raise(NameError) { t = Topic.create }
+  end
+
+  def test_errors_to_xml
+    r = Reply.new :title => "Wrong Create"
+    assert !r.valid?
+    xml = r.errors.to_xml(:skip_instruct => true)
+    assert_equal "<errors>", xml.first(8)
+    assert xml.include?("<error>Title is Wrong Create</error>")
+    assert xml.include?("<error>Content Empty</error>")
+  end
+
+  def test_validation_order
+     Topic.validates_presence_of :title
+     Topic.validates_length_of :title, :minimum => 2
+
+     t = Topic.new("title" => "")
+     assert !t.valid?
+     assert_equal "can't be blank", t.errors["title"].first
+    Topic.validates_presence_of :title, :author_name
+    Topic.validate {|topic| topic.errors.add('author_email_address', 'will never be valid')}
+    Topic.validates_length_of :title, :content, :minimum => 2
+
+    t = Topic.new :title => ''
+    assert !t.valid?
+
+    assert_equal :title, key = t.errors.keys.first
+    assert_equal "can't be blank", t.errors[key].first
+    assert_equal 'is too short (minimum is 2 characters)', t.errors[key].second
+    assert_equal :author_name, key = t.errors.keys.second
+    assert_equal "can't be blank", t.errors[key].first
+    assert_equal :author_email_address, key = t.errors.keys.third
+    assert_equal 'will never be valid', t.errors[key].first
+    assert_equal :content, key = t.errors.keys.fourth
+    assert_equal 'is too short (minimum is 2 characters)', t.errors[key].first
+  end
+
+  def test_invalid_should_be_the_opposite_of_valid
+    Topic.validates_presence_of :title
+
+    t = Topic.new
+    assert t.invalid?
+    assert t.errors[:title].any?
+
+    t.title = 'Things are going to change'
+    assert !t.invalid?
+  end
+
+  def test_deprecated_error_messages_on
+    Topic.validates_presence_of :title
+
+    t = Topic.new
+    assert t.invalid?
+
+    [:title, "title"].each do |attribute|
+      assert_deprecated { assert_equal "can't be blank", t.errors.on(attribute) }
+    end
+
+    Topic.validates_each(:title) do |record, attribute|
+      record.errors[attribute] << "invalid"
+    end
+
+    assert t.invalid?
+
+    [:title, "title"].each do |attribute|
+      assert_deprecated do
+        assert t.errors.on(attribute).include?("invalid")
+        assert t.errors.on(attribute).include?("can't be blank")
+      end
+    end
+  end
+
+  def test_deprecated_errors_on_base_and_each
+    t = Topic.new
+    assert t.valid?
+
+    assert_deprecated { t.errors.add_to_base "invalid topic" }
+    assert_deprecated { assert_equal "invalid topic", t.errors.on_base }
+    assert_deprecated { assert t.errors.invalid?(:base) }
+
+    all_errors = t.errors.to_a
+    assert_deprecated { assert_equal all_errors, t.errors.each_full{|err| err} }
+  end
+end

data/vendor/activemodel/test/config.rb

@@ -0,0 +1,3 @@
+TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
+FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
+SCHEMA_FILE     = TEST_ROOT + "/schema.rb"

data/vendor/activemodel/test/fixtures/topics.yml

@@ -0,0 +1,41 @@
+first:
+  id: 1
+  title: The First Topic
+  author_name: David
+  author_email_address: david@loudthinking.com
+  written_on: 2003-07-16t15:28:11.2233+01:00
+  last_read: 2004-04-15
+  bonus_time: 2005-01-30t15:28:00.00+01:00
+  content: Have a nice day
+  approved: false
+  replies_count: 1
+
+second:
+  id: 2
+  title: The Second Topic of the day
+  author_name: Mary
+  written_on: 2004-07-15t15:28:00.0099+01:00
+  content: Have a nice day
+  approved: true
+  replies_count: 0
+  parent_id: 1
+  type: Reply
+
+third:
+  id: 3
+  title: The Third Topic of the day
+  author_name: Nick
+  written_on: 2005-07-15t15:28:00.0099+01:00
+  content: I'm a troll
+  approved: true
+  replies_count: 1
+
+fourth:
+  id: 4
+  title: The Fourth Topic of the day
+  author_name: Carl
+  written_on: 2006-07-15t15:28:00.0099+01:00
+  content: Why not?
+  approved: true
+  type: Reply
+  parent_id: 3

data/vendor/activemodel/test/models/contact.rb

@@ -0,0 +1,7 @@
+class Contact
+  attr_accessor :name, :age, :created_at, :awesome, :preferences
+
+  def initialize(options = {})
+    options.each { |name, value| send("#{name}=", value) }
+  end
+end

data/vendor/activemodel/test/models/custom_reader.rb

@@ -0,0 +1,17 @@
+class CustomReader
+  include ActiveModel::Validations
+
+  def initialize(data = {})
+    @data = data
+  end
+  
+  def []=(key, value)
+    @data[key] = value
+  end
+
+  private
+  
+  def read_attribute_for_validation(key)
+    @data[key]
+  end
+end

data/vendor/activemodel/test/models/developer.rb

@@ -0,0 +1,6 @@
+class Developer < ActiveRecord::Base
+  validates_inclusion_of :salary, :in => 50000..200000
+  validates_length_of :name, :within => 3..20
+
+  attr_accessor :name_confirmation
+end

data/vendor/activemodel/test/models/person.rb

@@ -0,0 +1,9 @@
+class Person
+  include ActiveModel::Validations
+  extend  ActiveModel::Translation
+
+  attr_accessor :title, :karma, :salary
+end
+
+class Child < Person
+end

data/vendor/activemodel/test/models/reply.rb

@@ -0,0 +1,34 @@
+require 'models/topic'
+
+class Reply < Topic
+  validate :errors_on_empty_content
+  validate :title_is_wrong_create, :on => :create
+
+  validate :check_empty_title
+  validate :check_content_mismatch, :on => :create
+  validate :check_wrong_update, :on => :update
+
+  attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read
+
+  def check_empty_title
+    errors[:title] << "Empty" unless attribute_present?("title")
+  end
+
+  def errors_on_empty_content
+    errors[:content] << "Empty" unless attribute_present?("content")
+  end
+
+  def check_content_mismatch
+    if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
+      errors[:title] << "is Content Mismatch"
+    end
+  end
+
+  def title_is_wrong_create
+    errors[:title] << "is Wrong Create" if attribute_present?("title") && title == "Wrong Create"
+  end
+
+  def check_wrong_update
+    errors[:title] << "is Wrong Update" if attribute_present?("title") && title == "Wrong Update"
+  end
+end

data/vendor/activemodel/test/models/topic.rb

@@ -0,0 +1,9 @@
+class Topic < ActiveRecord::Base
+  def condition_is_true
+    true
+  end
+
+  def condition_is_true_but_its_not
+    false
+  end
+end

data/vendor/activemodel/test/models/track_back.rb

@@ -0,0 +1,4 @@
+class Post
+  class TrackBack
+  end
+end

data/vendor/activemodel/test/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  create_table :topics, :force => true do |t|
+    t.string  :title
+    t.string  :author_name
+    t.text    :content
+    t.boolean :approved, :default => true
+    t.string  :type
+  end
+
+  create_table :developers, :force => true do |t|
+    t.string  :name
+    t.float   :salary
+  end
+end

data/vendor/activesupport/lib/active_support/autoload.rb

@@ -0,0 +1,48 @@
+
+module ActiveSupport
+  module Autoload
+    @@autoloads = {}
+    @@under_path = nil
+    @@at_path = nil
+    @@eager_autoload = false
+
+    def autoload(const_name, path = @@at_path)
+      full = [self.name, @@under_path, const_name.to_s, path].compact.join("::")
+      location = path || Inflector.underscore(full)
+
+      if @@eager_autoload
+        @@autoloads[const_name] = location
+      end
+      super const_name, location
+    end
+
+    def autoload_under(path)
+      @@under_path, old_path = path, @@under_path
+      yield
+    ensure
+      @@under_path = old_path
+    end
+
+    def autoload_at(path)
+      @@at_path, old_path = path, @@at_path
+      yield
+    ensure
+      @@at_path = old_path
+    end
+
+    def eager_autoload
+      old_eager, @@eager_autoload = @@eager_autoload, true
+      yield
+    ensure
+      @@eager_autoload = old_eager
+    end
+
+    def self.eager_autoload!
+      @@autoloads.values.each { |file| require file }
+    end
+
+    def autoloads
+      @@autoloads
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/concern.rb

@@ -0,0 +1,25 @@
+require 'active_support/dependency_module'
+
+module ActiveSupport
+  module Concern
+    include DependencyModule
+
+    def append_features(base)
+      if super
+        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+        base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
+        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    alias_method :include, :depends_on
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/array/wrap.rb

@@ -0,0 +1,20 @@
+unless Array.respond_to?(:wrap)
+  class Array
+    # Wraps the object in an Array unless it's an Array.  Converts the
+    # object to an Array using #to_ary if it implements that.
+    def self.wrap(object)
+      case object
+      when nil
+        []
+      when self
+        object
+      else
+        if object.respond_to?(:to_ary)
+          object.to_ary
+        else
+          [object]
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/object/blank.rb

@@ -0,0 +1,58 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end