ohm-contrib 1.0.0 → 1.0.1

data/lib/ohm/datatypes.rb

@@ -9,12 +9,21 @@ module Ohm
       Integer   = lambda { |x| x.to_i }
       Decimal   = lambda { |x| BigDecimal(x.to_s) }
       Float     = lambda { |x| x.to_f }
-      Boolean   = lambda { |x| !!x }
+      Boolean   = lambda { |x| Ohm::DataTypes.bool(x) }
       Time      = lambda { |t| t && (t.kind_of?(::Time) ? t : ::Time.parse(t)) }
       Date      = lambda { |d| d && (d.kind_of?(::Date) ? d : ::Date.parse(d)) }
       Timestamp = lambda { |t| t && UnixTime.at(t.to_i) }
-      Hash      = lambda { |h| h && (h.kind_of?(::Hash) ? SerializedHash[h] : JSON(h)) }
-      Array     = lambda { |a| a && (a.kind_of?(::Array) ? SerializedArray.new(a) : JSON(a)) }
+      Hash      = lambda { |h| h && SerializedHash[h.kind_of?(::Hash) ? h : JSON(h)] }
+      Array     = lambda { |a| a && SerializedArray.new(a.kind_of?(::Array) ? a : JSON(a)) }
+    end
+
+    def self.bool(val)
+      case val
+      when "false", "0" then false
+      when "true", "1"  then true
+      else
+        !! val
+      end
     end
 
     class UnixTime < Time
@@ -35,4 +44,4 @@ module Ohm
       end
     end
   end
-end
+end

data/ohm-contrib.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ohm-contrib"
-  s.version = "1.0.0"
+  s.version = "1.0.1"
   s.summary = %{A collection of decoupled drop-in modules for Ohm.}
   s.description = %{Includes a couple of core functions such as callbacks, timestamping, typecasting and lots of generic validation routines.}
   s.author = "Cyril David"

data/test/plugin.rb

@@ -45,166 +45,228 @@ test "class-level, instance level callbacks" do
   assert_equal 1, a.comments.size
 end
 
-class Post < Ohm::Model
-  attribute :title
+# slugging
+scope do
+  class Post < Ohm::Model
+    attribute :title
 
-  include Ohm::Slug
+    include Ohm::Slug
 
-  def to_s
-    title
+    def to_s
+      title
+    end
   end
-end
 
-test "slugging" do
-  post = Post.create(:title => "Foo Bar Baz")
-  assert_equal "1-foo-bar-baz", post.to_param
+  test "slugging" do
+    post = Post.create(:title => "Foo Bar Baz")
+    assert_equal "1-foo-bar-baz", post.to_param
 
-  post = Post.create(:title => "Décor")
-  assert_equal "2-decor", post.to_param
+    post = Post.create(:title => "Décor")
+    assert_equal "2-decor", post.to_param
+  end
 end
 
-class Order < Ohm::Model
-  include Ohm::Scope
+# Ohm::Scope
+scope do
+  class Order < Ohm::Model
+    include Ohm::Scope
 
-  attribute :state
-  index :state
+    attribute :state
+    index :state
 
-  attribute :deleted
-  index :deleted
+    attribute :deleted
+    index :deleted
 
-  scope do
-    def paid
-      find(:state => "paid")
-    end
+    scope do
+      def paid
+        find(:state => "paid")
+      end
 
-    def deleted
-      find(:deleted => 1)
+      def deleted
+        find(:deleted => 1)
+      end
     end
   end
-end
 
-test "scope" do
-  paid = Order.create(:state => "paid", :deleted => nil)
+  test "scoping" do
+    paid = Order.create(:state => "paid", :deleted => nil)
 
-  assert Order.all.paid.include?(paid)
-  assert_equal 0, Order.all.paid.deleted.size
+    assert Order.all.paid.include?(paid)
+    assert_equal 0, Order.all.paid.deleted.size
 
-  paid.update(:deleted => 1)
-  assert Order.all.paid.deleted.include?(paid)
+    paid.update(:deleted => 1)
+    assert Order.all.paid.deleted.include?(paid)
+  end
 end
 
-class User < Ohm::Model
-  include Ohm::SoftDelete
+# soft delete
+scope do
+  class User < Ohm::Model
+    include Ohm::SoftDelete
 
-  attribute :email
-  index :email
-end
+    attribute :email
+    index :email
+  end
 
-test "soft delete" do
-  user = User.create(:email => "a@a.com")
-  user.delete
+  setup do
+    user = User.create(:email => "a@a.com")
+    user.delete
 
-  assert User.all.empty?
-  assert User.deleted.include?(user)
-  assert User.find(:email => "a@a.com").include?(user)
+    user
+  end
+
+  test "removes from User.all" do |user|
+    assert User.all.empty?
+  end
 
-  assert user.deleted?
-  assert User[user.id] == user
+  test "adds to User.deleted" do |user|
+    assert User.deleted.include?(user)
+  end
 
-  user.restore
+  test "doesn't remove from indices" do |user|
+    assert User.find(:email => "a@a.com").include?(user)
+  end
 
-  assert User.all.include?(user)
-  assert User.deleted.empty?
+  test "makes it deleted?" do |user|
+    assert user.deleted?
+  end
 
-  assert ! user.deleted?
-end
+  test "is still retrievable" do |user|
+    assert_equal user, User[user.id]
+  end
 
-class Product < Ohm::Model
-  include Ohm::DataTypes
-
-  attribute :name
-  attribute :stock, Type::Integer
-  attribute :price, Type::Decimal
-  attribute :rating, Type::Float
-  attribute :bought_at, Type::Time
-  attribute :date_released, Type::Date
-  attribute :sizes, Type::Hash
-  attribute :stores, Type::Array
-  attribute :published, Type::Boolean
+  test "restore" do |user|
+    user.restore
+
+    assert User.all.include?(user)
+    assert User.deleted.empty?
+
+    assert ! user.deleted?
+  end
 end
 
-test "datatypes" do
-  p = Product.new(:stock => "1")
+# datatypes
+scope do
+  class Product < Ohm::Model
+    include Ohm::DataTypes
+
+    attribute :name
+    attribute :stock, Type::Integer
+    attribute :price, Type::Decimal
+    attribute :rating, Type::Float
+    attribute :bought_at, Type::Time
+    attribute :date_released, Type::Date
+    attribute :sizes, Type::Hash
+    attribute :stores, Type::Array
+    attribute :published, Type::Boolean
+  end
+
+  test "Type::Integer" do
+    p = Product.new(:stock => "1")
+
+    assert_equal 1, p.stock
+    p.save
+
+    p = Product[p.id]
+    assert_equal 1, p.stock
+  end
+
+  test "Type::Time" do
+    time = Time.utc(2011, 11, 22)
+    p = Product.new(:bought_at => time)
+    assert p.bought_at.kind_of?(Time)
 
-  assert_equal 1, p.stock
-  p.save
+    p.save
 
-  p = Product[p.id]
-  assert_equal 1, p.stock
+    p = Product[p.id]
+    assert p.bought_at.kind_of?(Time)
+    assert_equal time, p.bought_at
 
-  time = Time.now.utc
-  p = Product.new(:bought_at => time)
-  assert p.bought_at.kind_of?(Time)
+    assert_equal "2011-11-22 00:00:00 UTC", p.key.hget(:bought_at)
+    assert_equal "2011-11-22 00:00:00 UTC", p.bought_at.to_s
+  end
 
-  p.save
+  test "Type::Date" do
+    p = Product.new(:date_released => Date.today)
 
-  p = Product[p.id]
-  assert p.bought_at.kind_of?(Time)
-  assert_equal time, p.bought_at
+    assert p.date_released.kind_of?(Date)
 
-  p = Product.new(:date_released => Date.today)
+    p = Product.new(:date_released => "2011-11-22")
+    assert p.date_released.kind_of?(Date)
 
-  assert p.date_released.kind_of?(Date)
+    p.save
 
-  p = Product.new(:date_released => "2011-11-22")
-  assert p.date_released.kind_of?(Date)
+    p = Product[p.id]
+    assert_equal Date.new(2011, 11, 22), p.date_released
+    assert_equal "2011-11-22", p.key.hget(:date_released)
+    assert_equal "2011-11-22", p.date_released.to_s
+  end
 
-  p.save
+  test "Type::Hash" do
+    sizes = { "XS" => 1, "S" => 2, "L" => 3 }
 
-  p = Product[p.id]
-  assert_equal Date.new(2011, 11, 22), p.date_released
+    p = Product.new(:sizes => sizes)
+    assert p.sizes.kind_of?(Hash)
+    p.save
 
-  sizes = { "XS" => 1, "S" => 2, "L" => 3 }
+    p = Product[p.id]
+    assert_equal sizes, p.sizes
+    assert_equal %Q[{"XS":1,"S":2,"L":3}], p.key.hget(:sizes)
+    assert_equal %Q[{"XS":1,"S":2,"L":3}], p.sizes.to_s
+  end
 
-  p = Product.new(:sizes => sizes)
-  assert p.sizes.kind_of?(Hash)
-  p.save
+  test "Type::Array" do
+    stores = ["walmart", "marshalls", "jcpenny"]
+    p = Product.new(:stores => stores)
+    assert p.stores.kind_of?(Array)
 
-  p = Product[p.id]
-  assert_equal sizes, p.sizes
+    p.save
 
-  stores = ["walmart", "marshalls", "jcpenny"]
-  p = Product.new(:stores => stores)
-  assert p.stores.kind_of?(Array)
+    p = Product[p.id]
+    assert_equal stores, p.stores
+    assert_equal %Q(["walmart","marshalls","jcpenny"]), p.key.hget(:stores)
+    assert_equal %Q(["walmart","marshalls","jcpenny"]), p.stores.to_s
+  end
 
-  p.save
+  test "Type::Decimal" do
+    p = Product.new(:price => 0.001)
 
-  p = Product[p.id]
-  assert_equal stores, p.stores
+    # This fails if 0.001 is a float.
+    x = 0
+    1000.times { x += p.price }
+    assert_equal 1, x
 
-  p = Product.new(:price => 0.001)
+    p.save
 
-  x = 0
-  1000.times { x += p.price }
-  assert_equal 1, x
+    p = Product[p.id]
+    assert_equal 0.001, p.price
+    assert_equal "0.1E-2", p.key.hget(:price)
+  end
 
-  p.save
+  test "Type::Float" do
+    p = Product.new(:rating => 4.5)
+    assert p.rating.kind_of?(Float)
 
-  p = Product[p.id]
-  assert_equal 0.001, p.price
+    p.save
+    p = Product[p.id]
+    assert_equal 4.5, p.rating
+    assert_equal "4.5", p.key.hget(:rating)
+  end
 
-  p = Product.new(:rating => 4.5)
-  assert p.rating.kind_of?(Float)
+  test "Type::Boolean" do
+    p = Product.new(:published => 1)
+    assert_equal true, p.published
 
-  p.save
-  p = Product[p.id]
-  assert_equal 4.5, p.rating
+    p.save
 
-  p = Product.new(:published => 1)
-  assert_equal true, p.published
+    p = Product[p.id]
+    assert_equal true, p.published
 
-  p.save
+    p.published = false
+    p.save
 
-  p = Product[p.id]
-  assert_equal true, p.published
+    p = Product[p.id]
+    assert_equal "false", p.key.hget(:published)
+    assert_equal false, p.published
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm-contrib
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-25 00:00:00.000000000 Z
+date: 2012-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ohm