ohm-contrib 0.1.2 → 1.0.rc0

data/test/callbacks_lint.rb

@@ -1,141 +0,0 @@
-test "save on invalid" do
-  post = Post.new
-  post.save
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-
-  assert ! post.did?(:do_before_create)
-  assert ! post.did?(:do_after_create)
-  assert ! post.did?(:do_before_save)
-  assert ! post.did?(:do_after_save)
-  assert ! post.did?(:do_before_update)
-  assert ! post.did?(:do_after_update)
-end
-
-test "saving a valid model" do
-  post = Post.new(:body => "The Body")
-  post.save
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-  assert post.did?(:do_before_create)
-  assert post.did?(:do_after_create)
-  assert post.did?(:do_before_save)
-  assert post.did?(:do_after_save)
-  assert ! post.did?(:do_before_update)
-  assert ! post.did?(:do_after_update)
-end
-
-test "ensure create / save callbacks are only called once" do
-  post = Post.new(:body => "The Body")
-  post.save
-
-  assert 1 == post.count(:do_before_create)
-  assert 1 == post.count(:do_after_create)
-  assert 1 == post.count(:do_before_save)
-  assert 1 == post.count(:do_after_create)
-end
-
-test "Post::create on a valid model invokes all callbacks (except update)" do
-  post = Post.create(:body => "The Body")
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-  assert post.did?(:do_before_create)
-  assert post.did?(:do_after_create)
-  assert post.did?(:do_before_save)
-  assert post.did?(:do_after_save)
-  assert ! post.did?(:do_before_update)
-  assert ! post.did?(:do_after_update)
-end
-
-test "ensure Post::create only invokes save / create once" do
-  post = Post.create(:body => "The Body")
-
-  assert 1 == post.count(:do_before_create)
-  assert 1 == post.count(:do_after_create)
-  assert 1 == post.count(:do_before_save)
-  assert 1 == post.count(:do_after_create)
-end
-
-test "on successful save of existing record" do
-  post = Post.create(:body => "The Body")
-  post = Post[post.id]
-  post.save
-
-  assert ! post.did?(:do_before_create)
-  assert ! post.did?(:do_after_create)
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-  assert post.did?(:do_before_save)
-  assert post.did?(:do_after_save)
-  assert post.did?(:do_before_update)
-  assert post.did?(:do_after_update)
-
-  assert 1 == post.count(:do_before_save)
-  assert 1 == post.count(:do_after_save)
-  assert 1 == post.count(:do_before_update)
-  assert 1 == post.count(:do_after_update)
-end
-
-test "on successful save of existing record (using #update)" do
-  post = Post.create(:body => "The Body")
-  post = Post[post.id]
-  post.update(:body => "New Body")
-
-  assert ! post.did?(:do_before_create)
-  assert ! post.did?(:do_after_create)
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-  assert post.did?(:do_before_save)
-  assert post.did?(:do_after_save)
-  assert post.did?(:do_before_update)
-  assert post.did?(:do_after_update)
-
-  assert 1 == post.count(:do_before_save)
-  assert 1 == post.count(:do_after_save)
-  assert 1 == post.count(:do_before_update)
-  assert 1 == post.count(:do_after_update)
-end
-
-test "on failed save of existing record" do
-  post = Post.create(:body => "The Body")
-  post = Post[post.id]
-
-  post.body = nil
-  post.save
-
-  assert post.did?(:do_before_validate)
-  assert post.did?(:do_after_validate)
-
-  assert ! post.did?(:do_before_create)
-  assert ! post.did?(:do_after_create)
-
-  assert ! post.did?(:do_before_save)
-  assert ! post.did?(:do_after_save)
-
-  assert ! post.did?(:do_before_update)
-  assert ! post.did?(:do_after_update)
-end
-
-test "on delete" do
-  post = Post.create(:body => "The Body")
-  post = Post[post.id]
-  post.delete
-
-  assert 1 == post.count(:do_before_delete)
-  assert 1 == post.count(:do_after_delete)
-
-  assert ! post.did?(:do_before_validate)
-  assert ! post.did?(:do_after_validate)
-  assert ! post.did?(:do_before_create)
-  assert ! post.did?(:do_after_create)
-  assert ! post.did?(:do_before_save)
-  assert ! post.did?(:do_after_save)
-  assert ! post.did?(:do_before_update)
-  assert ! post.did?(:do_after_update)
-end
-

data/test/date_validations_test.rb

@@ -1,29 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Person < Ohm::Model
-  include Ohm::DateValidations
-
-  attribute :birthday
-
-  def validate
-    assert_date :birthday
-  end
-end
-
-test "accepts all canonical dates" do
-  assert Person.new(:birthday => "2010-05-05").valid?
-  assert Person.new(:birthday => "2010-5-5").valid?
-  assert Person.new(:birthday => "2010-05-5").valid?
-  assert Person.new(:birthday => "2010-5-05").valid?
-end
-
-test "also catches invalid dates" do
-  assert ! Person.new(:birthday => "2010-02-29").valid?
-end
-
-test "invalid when empty" do
-  assert ! Person.new(:birthday => "").valid?
-end
-

data/test/fixtures/ascii8bit.txt

@@ -1 +0,0 @@
-café

data/test/fulltext_searching_test.rb

@@ -1,63 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Video < Ohm::Model
-  include Ohm::FulltextSearching
-
-  attribute :title
-  attribute :description
-   
-  fulltext :title
-  fulltext :description
-end
-
-test "finding basic words using metaphones" do
-  v = Video.create(:title => "The quick brown fox jumps over the lazy dog")
-
-  assert Video.find(:fulltext_title => "KK").include?(v)
-  assert Video.find(:fulltext_title => "PRN").include?(v)
-  assert Video.find(:fulltext_title => "FKS").include?(v)
-  assert Video.find(:fulltext_title => "JMPS").include?(v)
-  assert Video.find(:fulltext_title => "AMPS").include?(v)
-  assert Video.find(:fulltext_title => ["JMPS", "AMPS"]).include?(v)
-  assert Video.find(:fulltext_title => "LS").include?(v)
-  assert Video.find(:fulltext_title => "TK").include?(v)
-end
-
-test "finding using the actual words" do
-  v = Video.create(:title => "The quick brown fox jumps over the lazy dog")
-  
-  assert Video.search(:title => "quick").include?(v)
-  assert Video.search(:title => "brown").include?(v)
-  assert Video.search(:title => "fox").include?(v)
-  assert Video.search(:title => "jumps").include?(v)
-  assert Video.search(:title => "lazy").include?(v)
-  assert Video.search(:title => "dog").include?(v)
-end
-
-test "finding using slightly mispelled words" do
-  v = Video.create(:title => "The quick brown fox jumps over the lazy dog")
-
-  assert Video.search(:title => "quik").include?(v)
-  assert Video.search(:title => "brwn").include?(v)
-  assert Video.search(:title => "fx").include?(v)
-  assert Video.search(:title => "fax").include?(v)
-  assert Video.search(:title => "jumps").include?(v)
-  assert Video.search(:title => "lazi").include?(v)
-  assert Video.search(:title => "dag").include?(v)
-end
-
-test "stopword stripping" do
-  # This is the actual code that strips out stopwords.
-
-  assert_equal [], Video.double_metaphone("about")
-  
-  # Here we just verify that actually on a long string level,
-  # stop words are in fact stripped.
-  assert Video.metaphones(Video::STOPWORDS.join(" ")).empty?
-
-  # Finally we need to make sure that finding stop words
-  # should not even proceed.
-  assert Video.hash_to_metaphones(:title => "about").empty?
-end

data/test/length_validations_test.rb

@@ -1,31 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Person < Ohm::Model
-  include Ohm::LengthValidations
-
-  attribute :name
-
-  def validate
-    assert_min_length :name, 5
-    assert_max_length :name, 10
-  end
-end
-
-test "valid length name" do
-  assert Person.new(:name => "bob smith").valid?
-end
-
-test "also catches short strings" do
-  assert ! Person.new(:name => "bob").valid?
-end
-
-test "also catches long strings" do
-  assert ! Person.new(:name => "robert smithson").valid?
-end
-
-test "invalid when empty" do
-  assert ! Person.new(:name => "").valid?
-end
-

data/test/membership_validation_test.rb

@@ -1,31 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Order < Ohm::Model
-  include Ohm::ExtraValidations
-
-  attribute :state
-
-  def validate
-    assert_member :state, %w(pending authorized declined)
-  end
-end
-
-test "validates for all members" do
-  order = Order.new(:state => 'pending')
-  assert order.valid?
-
-  order = Order.new(:state => 'authorized')
-  assert order.valid?
-
-  order = Order.new(:state => 'declined')
-  assert order.valid?
-end
-
-test "fails on a non-member" do
-  order = Order.new(:state => 'foobar')
-  assert ! order.valid?
-  assert [[:state, :not_member]] == order.errors
-end
-

data/test/number_validations_test.rb

@@ -1,37 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Product < Ohm::Model
-  include Ohm::NumberValidations
-
-  attribute :price
-  attribute :optional_price
-
-  def validate
-    assert_decimal :price
-    assert_decimal :optional_price unless optional_price.to_s.empty?
-  end
-end
-
-test "has error when empty" do
-  product = Product.new(:price => nil)
-  product.valid?
-
-  assert [[:price, :not_decimal]] == product.errors
-end
-
-test "validation scenarios" do
-  assert Product.new(:price => 0.10).valid?
-  assert Product.new(:price => 1).valid?
-
-  p = Product.new(:price => '1.')
-  assert ! p.valid?
-  assert [[:price, :not_decimal]] == p.errors
-end
-
-test "allows empty values through basic ruby conditions" do
-  assert Product.new(:price => 10.1, :optional_price => nil).valid?
-  assert Product.new(:price => 10.1, :optional_price => '').valid?
-end
-

data/test/slug_test.rb

@@ -1,30 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-module Finder
-  def [](id)
-    new(id)
-  end
-end
-
-class BaseWithoutToParam < Struct.new(:id)
-  extend Finder
-
-  include Ohm::Slug
-
-  def to_s
-    "A very Unique and Interesting String?'"
-  end
-end
-
-test "to_param" do
-  obj = BaseWithoutToParam.new(1)
-
-  assert '1-a-very-unique-and-interesting-string' == obj.to_param
-end
-
-test "finding" do
-  assert 1 == BaseWithoutToParam['1-a-very-unique'].id
-end
-

data/test/typecast_array_test.rb

@@ -1,146 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Post < Ohm::Model
-  include Ohm::Typecast
-
-  attribute :addresses, Array
-
-  def array
-    Array.new
-  end
-
-  def top_level_array
-    Array
-  end
-end
-
-test "importing" do
-  assert [] == Ohm::Types::Array[nil]
-  assert [] == Ohm::Types::Array[""]
-  assert [] == Ohm::Types::Array[[]]
-
-  assert ['a', 'b', 'c', 'd'] == Ohm::Types::Array[['a', 'b', 'c', 'd']]
-end
-
-test "exporting / dumping" do
-  assert "[]" == Ohm::Types::Array[nil].to_s
-  assert "[]" == Ohm::Types::Array[""].to_s
-  assert "[]" == Ohm::Types::Array[[]].to_s
-
-  assert %q{["a","b","c","d"]} == Ohm::Types::Array[['a', 'b', 'c', 'd']].to_s
-end
-
-test "still able to get top level methods" do
-  assert [] == Post.new.array
-  assert Array == Post.new.top_level_array
-end
-
-test "handles nil case correctly" do
-  post = Post.create(:addresses => nil)
-  assert [] == post.addresses
-
-  post = Post[post.id]
-  assert [] == post.addresses
-end
-
-test "handles empty string case correctly" do
-  post = Post.create(:addresses => "")
-  assert [] == post.addresses
-
-  post = Post[post.id]
-  assert [] == post.addresses
-end
-
-test "handles populated arrays" do
-  addresses = [{"city" => "Singapore", "country" => "SG"},
-               {"city" => "Manila", "country" => "PH"}]
-
-  post = Post.create(:addresses => addresses)
-  assert addresses == post.addresses
-
-  post = Post[post.id]
-  assert addresses == post.addresses
-end
-
-class AddressArr < Class.new(Struct.new(:city, :country))
-  def to_json(*args)
-    [city, country].to_json(*args)
-  end
-end
-
-test "handles an arbitrary class as an element of the array" do
-  addresses = [AddressArr.new("Singapore", "SG"),
-               AddressArr.new("Philippines", "PH")]
-
-  post = Post.create(:addresses => addresses)
-  assert [['Singapore', 'SG'], ['Philippines', 'PH']] == post.addresses
-
-  post = Post[post.id]
-  assert [['Singapore', 'SG'], ['Philippines', 'PH']] == post.addresses
-end
-
-test "allows for array operations" do
-  addresses = [{"city" => "Singapore", "country" => "SG"},
-               {"city" => "Manila", "country" => "PH"}]
-
-
-  post = Post.create(:addresses => addresses)
-  assert 2 == post.addresses.size
-
-  expected = addresses + [{"city" => "Hong Kong", "country" => "ZN"}]
-  actual   = post.addresses.push({"city" => "Hong Kong", "country" => "ZN"})
-
-  assert expected == actual
-
-  post = Post[post.id]
-  assert 2 == post.addresses.size
-
-  expected = addresses + [{"city" => "Hong Kong", "country" => "ZN"}]
-  actual   = post.addresses.push({ "city" => "Hong Kong", "country" => "ZN" })
-
-  assert expected == actual
-end
-
-test "looping! and other enumerablems" do
-  array = [1, 2, 3]
-  post = Post.create(:addresses => array)
-
-  total = 0
-  post.addresses.each { |e| total += e }
-  assert 6 == total
-
-  post = Post[post.id]
-  total = 0
-  post.addresses.each { |e| total += e }
-  assert 6 == total
-end
-
-test "handles mutation" do
-  post = Post.create(:addresses => [1, 2, 3])
-
-  post.addresses.push(4, 5, 6)
-  post.save
-
-  assert [1, 2, 3, 4, 5, 6] == post.addresses
-
-  post = Post[post.id]
-  assert [1, 2, 3, 4, 5, 6] == post.addresses
-end
-
-test "raises when trying to assign a non-array" do
-  assert_raise TypeError do
-    Post.new(:addresses => {})
-  end
-
-  assert_raise TypeError do
-    Post.new(:addresses => AddressArr.new)
-  end
-end
-
-test "type is array" do
-  post = Post.create(:addresses => ["address1"])
-
-  assert post.addresses.type == Array
-end

data/test/typecast_boolean_test.rb

@@ -1,43 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class User < Ohm::Model
-  include Ohm::Typecast
-
-  attribute :is_admin, Boolean
-end
-
-test "empty is nil" do
-  assert nil == User.new.is_admin
-
-  u = User.create
-  u = User[u.id]
-
-  assert nil == User.new.is_admin
-end
-
-test "false, 0, '0' is false" do
-  [false, 0, '0'].each do |val|
-    assert false == User.new(:is_admin => val).is_admin
-  end
-
-  [false, 0, '0'].each do |val|
-    u = User.create(:is_admin => val)
-    u = User[u.id]
-    assert false == u.is_admin
-  end
-end
-
-test "true, 1, '1' is true" do
-  [true, 1, '1'].each do |val|
-    assert true == User.new(:is_admin => val).is_admin
-  end
-
-  [true, 1, '1'].each do |val|
-    u = User.create(:is_admin => val)
-    u = User[u.id]
-    assert true == u.is_admin
-  end
-end
-

data/test/typecast_date_test.rb

@@ -1,82 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Post < Ohm::Model
-  include Ohm::Typecast
-
-  attribute :created_on, Date
-
-  def today
-    ::Date.today
-  end
-
-  def date
-    Date
-  end
-
-  def may_5
-    Date.new(2010, 05, 05)
-  end
-
-  def base_today
-    Date.today
-  end
-end
-
-test "still able to get top level methods" do
-  assert Date.today == Post.new.base_today
-end
-
-test "allows instantiation of dates" do
-  assert Date.new(2010, 05, 05) == Post.new.may_5
-end
-
-test "handles nil case correctly" do
-  post = Post.create(:created_on => nil)
-  post = Post[post.id]
-
-  assert nil == post.created_on
-end
-
-test "handles empty string case correctly" do
-  post = Post.create(:created_on => "")
-  post = Post[post.id]
-
-  assert "" == post.created_on.to_s
-end
-
-test "allows for real time operations" do
-  post = Post.create(:created_on => "2010-05-10")
-  post = Post[post.id]
-
-  assert post.created_on.respond_to?(:strftime)
-  assert "2010-05-10" == post.created_on.strftime('%Y-%m-%d')
-end
-
-test "raises when trying to do date operations on a non-date" do
-  post = Post.create(:created_on => "FooBar")
-  post = Post[post.id]
-
-  assert_raise ArgumentError do
-    post.created_on.strftime("%Y")
-  end
-end
-
-test "still able to access Date" do
-  assert Date.today == Post.new.today
-end
-
-test "inspecting" do
-  post = Post.create(:created_on => Date.new(2010, 5, 5))
-  assert '"2010-05-05"' == post.created_on.inspect
-
-  post.created_on = 'FooBar'
-  assert '"FooBar"' == post.created_on.inspect
-end
-
-test "type is Date" do
-  post = Post.create(:created_on => Date.new(2010, 5, 5))
-  assert Date == post.created_on.type
-end
-