tinymongo 0.1.7 → 0.1.8

data/README.rdoc

@@ -47,25 +47,31 @@ To create TinyMongo config file (config/tinymongo.yml) and initializer file (con
     end
   end
   
-  Person.drop                         # empty drop collection
+  Person.drop                         # empty person collection
   
-  p = Person.create(:name => 'John', :age => 20)  # create John
-  p.make_child                        # make Baby and set it as John's child
-  p.grow_up                           # increment age by 1 = 21
+  p = Person.create(:name => 'John', :age => 20)
+  p.make_child
+  p.grow_up
   
   Person.find.each do |person|
-    puts person.name                  # print Baby and John
+    puts person.name
   end
   
-  puts Person.find_one(:name => 'John').age  # print 21
+  Person.find_one(:name => 'John').age
   
   Person.create(:name => 'Jim')
   Person.create(:name => 'Pam')
 
-  puts Person.find.to_a.map { |person| person.name } # print Baby; John; Jim; Pam
+  Person.find.to_a.map { |person| person.name }
   
-  # Sort by name (ascending), Skip Baby and Jim, limit result by 1, print => John
-  puts Person.find.sort({:name => 1}).skip(2).limit(1).next_document.name 
+  Person.find.has_next?
+
+  Person.find.sort({:name => 1}).skip(2).limit(1).next!.name 
+  
+  Person.find({:name => 'John'}, {:age => 1}) # select only age field
+  
+  Person.find.count # count ignores skip and limit
+  Person.find.skip(1).size # size is affected by skip and limit
   
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.1.8

data/lib/tinymongo/cursor.rb

@@ -14,65 +14,28 @@ module TinyMongo
       @_tinymongo_cursor
     end
     
-    def batch_size
-      @_tinymongo_cursor.batch_size
-    end
-    
-    def collection
-      @_tinymongo_cursor.collection
-    end
-    
-    def fields 
-      @_tinymongo_cursor.fields
-    end
-    
-    def full_collection_name
-      @_tinymongo_cursor.full_collection_name
-    end
-    
-    def hint
-      @_tinymongo_cursor.hint
-    end 
-    
-    def order
-      @_tinymongo_cursor.order
-    end
-    
-    def selector
-      @_tinymongo_cursor.selector
-    end
-    
-    def snapshot
-      @_tinymongo_cursor.snapshot
-    end
-    
-    def timeout
-      @_tinymongo_cursor.timeout
-    end
-    
-    # instance methods in Mongo::Cursor
-    
-    def close
-      @_tinymongo_cursor.close
-    end
-    
-    def closed?
-      @_tinymongo_cursor.closed?
-    end
-    
     def count
       @_tinymongo_cursor.count
     end
     
+    def size
+      num = (count - skip)
+      num = (num > 0) ? (((num > limit) && limit != 0) ? limit : num) : 0
+    end
+    
     def each
       num_returned = 0
       while(has_next? && (@_tinymongo_cursor.instance_variable_get(:@limit) <= 0 ||
         num_returned < @_tinymongo_cursor.instance_variable_get(:@limit)))
-        yield next_document
+        yield next!
         num_returned += 1
       end
     end
     
+    def forEach(*args)
+      each(*args)
+    end
+    
     def explain
       @_tinymongo_cursor.explain
     end
@@ -81,21 +44,25 @@ module TinyMongo
       @_tinymongo_cursor.has_next?
     end
     
+    def hasNext
+      has_next?
+    end
+    
     def limit(*args)
       call_and_wrap_retval_in_tinymongo_cursor(:limit, args)
     end
     
-    def next_document
+    def next!
       doc = @_tinymongo_cursor.next_document
-      @_tinymongo_model_class.new(doc) if doc
+      Helper.deserialize_hashes_in(doc)
     end
     
-    def query_options_hash
-      @_tinymongo_cursor.query_options_hash
+    def next_document
+      next!
     end
     
-    def query_opts
-      @_tinymongo_cursor.query_opts
+    def nextDocument
+      next!
     end
     
     def skip(*args)
@@ -104,13 +71,7 @@ module TinyMongo
     
     def sort(*args)
       if(args.length > 0 && (args[0].instance_of? Hash))
-        sort_array = []
-        
-        args[0].each_pair do |key, value|
-          sort_array << [key, convert_ascending_descending_to_numeric(value)]
-        end
-        
-        args[0] = sort_array
+        args[0] = args[0].map { |k, v| [k, convert_ascending_descending_to_numeric(v)] }
       end
         
       call_and_wrap_retval_in_tinymongo_cursor(:sort, args)
@@ -120,7 +81,7 @@ module TinyMongo
       return [] if @_tinymongo_cursor.nil?
       
       hashes = @_tinymongo_cursor.to_a
-      hashes.map { |hash| @_tinymongo_model_class.new(hash) if hash }
+      hashes.map { |hash| Helper.deserialize_hashes_in(hash) }
     end
     
     protected

data/lib/tinymongo/errors.rb

@@ -19,4 +19,10 @@ module TinyMongo
       super('Modifier operations are not allowed on objects that are not yet saved!')
     end
   end
+  
+  class DeserializationError < Error
+    def initialize(class_name)
+      super("Unable to deserialize hash into #{class_name}!")
+    end
+  end
 end

data/lib/tinymongo/helper.rb

@@ -1,85 +1,78 @@
 module TinyMongo
   module Helper
     class << self
-      def deep_copy_hash(hash)
-        new_hash = {}
-        hash.each_pair do |key, obj|
-          new_hash[key] = if(obj.instance_of? Hash)
-            deep_copy_hash(obj)
-          elsif(obj.instance_of? Array)
-            deep_copy_array(obj)
-          else
-            begin 
-              obj.dup
-            rescue
-              obj
-            end
-          end
-        end
-        new_hash
+      def constantize(class_name)
+        return unless class_name.instance_of? String
+        class_name.split('::').inject(Object) { |mod, klass| mod.const_get(klass) }
       end
-
-      def deep_copy_array(array)
-        new_array = []
-        array.each do |obj|
-          new_array << if(obj.instance_of? Hash)
-            deep_copy_hash(obj)
-          elsif(obj.instance_of? Array)
-            deep_copy_array(obj)
-          else
-            begin 
-              obj.dup
-            rescue
-              obj
-            end
+      
+      def deep_copy(obj)
+        if(obj.kind_of? Hash)
+          Hash[obj.map { |k,v| [k.to_s, deep_copy(v)] }]
+        elsif(obj.kind_of? Array)
+          obj.map { |o| deep_copy(o)}
+        else
+          begin
+            obj.dup
+          rescue
+            obj
           end
         end
-        new_array
       end
-      
+        
       def stringify_keys_in_hash(hash)
-        new_hash = {}
-        hash.each_pair { |key, value| new_hash[key.to_s] = value }
+        new_hash = Hash[hash.map { |k,v| [k.to_s, v] }]
         new_hash['_id'] = bson_object_id(new_hash['_id']) if(new_hash['_id'])
         new_hash
       end
 
       def symbolify_keys_in_hash(hash)
-        new_hash = {}
-        hash.each_pair { |key, value| new_hash[key.to_sym] = value }
+        new_hash = Hash[hash.map { |k,v| [k.to_sym, v] }]
         new_hash[:_id] = bson_object_id(new_hash[:_id]) if(new_hash[:_id])
         new_hash
       end
       
-      def hashify_models_in(obj)
-        if(obj.instance_of? Hash)
-          hashify_models_in_hash(obj)
-        elsif(obj.instance_of? Array)
-          hashify_models_in_array(obj)
-        elsif(obj.kind_of? TinyMongo::Model)
-          obj.to_hash
+      def deserialize_hashes_in(obj)
+        if(obj.kind_of? Hash)
+          new_hash = Hash[obj.map { |k,v| [k.to_s, deserialize_hashes_in(v)] }]
+          class_name = new_hash['_tinymongo_model_class_name']
+          if(class_name)
+            begin
+              klass = constantize(new_hash['_tinymongo_model_class_name'])
+              if(klass.new.kind_of? TinyMongo::Model)
+                deserialized_obj = klass.new(new_hash)
+              else
+                raise
+              end
+            rescue
+              raise DeserializationError, class_name
+            end
+            deserialized_obj
+          else
+            new_hash
+          end
+        elsif(obj.kind_of? Array)
+          obj.map { |o| deserialize_hashes_in(o) }
         else
           obj
         end
       end
       
-      def hashify_models_in_array(array)
-        new_array = array.map { |value| hashify_models_in(value) }
-      end
-      
-      def hashify_models_in_hash(hash)
-        new_hash = {}
-        hash.each_pair do |key,value|
-          key_s = key.to_s
-          if(key_s == '_id')
-            new_hash[key_s] = bson_object_id(value)
-          else
-            new_hash[key_s] = hashify_models_in(value)
-          end
+      def hashify_models_in(obj)
+        if(obj.kind_of? Hash)
+          Hash[obj.map do |k,v| 
+            key = k.to_s
+            (key == '_id') ? [key, bson_object_id(v)] : [key, hashify_models_in(v)]
+          end]
+        elsif(obj.kind_of? Array)
+          obj.map { |o| hashify_models_in(o) }
+        elsif(obj.kind_of? TinyMongo::Model)
+          hashify_models_in(obj.to_hash)
+        else
+          obj
         end
-        new_hash
       end
-      
+
       def bson_object_id(id)
         if(id.instance_of? BSON::ObjectID)
           id

data/lib/tinymongo/model.rb

@@ -40,21 +40,31 @@ module TinyMongo
         end
       end
       
-      def find(*args)
-        new_args = args.map {|arg| Helper.hashify_models_in(arg) }
-        Cursor.new(collection.find(*new_args), self)
+      def find(query={}, fields=nil, limit=nil, skip=nil)
+        query = Helper.hashify_models_in(query)
+        fields = Helper.hashify_models_in(fields)
+        
+        add_tinymongo_model_class_name_key_to_fields(fields)
+        Cursor.new(collection.find(query, {:fields => fields, :limit => limit, :skip => skip}), self)
       end
-
-      def find_one(*args)
-        if((args.length > 0) && (args.compact.length == 0))
-          return nil
-        elsif((args.length == 1) && ([BSON::ObjectID, String].include? args[0].class))
-          hash = collection.find_one({'_id' => Helper.bson_object_id(args[0])})
+      
+      def find_one(query={}, fields=nil)
+        return nil unless query
+        
+        if([BSON::ObjectID, String].include? query.class)
+          query = {'_id' => Helper.bson_object_id(query)}
         else
-          new_args = args.map {|arg| Helper.hashify_models_in(arg) }
-          hash = collection.find_one(*new_args)
+          query = Helper.hashify_models_in(query)
+          fields = Helper.hashify_models_in(fields)
         end
-        hash ? self.new(hash) : nil
+        
+        add_tinymongo_model_class_name_key_to_fields(fields)
+        hash = collection.find_one(query, {:fields => fields})
+        hash ? Helper.deserialize_hashes_in(hash) : nil
+      end
+
+      def findOne(*args)
+        find_one(*args)
       end
 
       def create(hash={})
@@ -88,7 +98,9 @@ module TinyMongo
     end
     
     def initialize(hash={})
-      @_tinymongo_hash = (Helper.deep_copy_hash(self.class.instance_variable_get(:@_tinymongo_defaults)).merge(Helper.stringify_keys_in_hash(hash)) || {}) if hash
+      @_tinymongo_hash = (Helper.deep_copy(self.class.instance_variable_get(:@_tinymongo_defaults)).merge(Helper.stringify_keys_in_hash(hash)) || {}) if hash
+      set_tinymongo_model_class_name_in_hash(@_tinymongo_hash)
+      self
     end
 
     def _id
@@ -99,14 +111,6 @@ module TinyMongo
       @_tinymongo_hash['_id'] = Helper.bson_object_id(val)
     end
     
-    def id
-      @_tinymongo_hash['_id'].to_s
-    end
-    
-    def id=(val)
-      @_tinymongo_hash['_id'] = Helper.bson_object_id(val)
-    end
-    
     def ==(another)
       (self.instance_variable_get(:@_tinymongo_hash) == another.instance_variable_get(:@_tinymongo_hash)) &&
       (self.kind_of? TinyMongo::Model) && (another.kind_of? TinyMongo::Model)
@@ -121,7 +125,7 @@ module TinyMongo
     end
     
     def to_hash
-      @_tinymongo_hash.dup
+      hash = @_tinymongo_hash.dup
     end
     
     def to_param
@@ -131,19 +135,19 @@ module TinyMongo
     def reload
       if(@_tinymongo_hash['_id'])
         obj = collection.find_one({ '_id' => @_tinymongo_hash['_id'] })
-        @_tinymongo_hash = Helper.stringify_keys_in_hash(obj) if(obj)
+        @_tinymongo_hash = Hash[obj.map { |k,v| [k.to_s, Helper.deserialize_hashes_in(v)] }] if(obj)
       end
     end
 
     def save
       if(@_tinymongo_hash['_id'].nil?) # new 
-        oid = collection.save(@_tinymongo_hash)
+        oid = collection.save(Helper.hashify_models_in(@_tinymongo_hash))
         if(oid)
           @_tinymongo_hash.delete(:_id)
           @_tinymongo_hash['_id'] = oid
         end
       else # update
-        collection.update({ '_id' => @_tinymongo_hash['_id'] }, @_tinymongo_hash, :upsert => true)
+        collection.update({ '_id' => @_tinymongo_hash['_id'] }, Helper.hashify_models_in(@_tinymongo_hash), :upsert => true)
         reload
       end
       return self
@@ -184,14 +188,22 @@ module TinyMongo
     def push(hash={})
       do_modifier_operation_and_reload('$push', hash)
     end
-
+    
     def push_all(hash={})
       do_modifier_operation_and_reload('$pushAll', hash)
     end
+    
+    def pushAll(*args)
+      push_all(*args)
+    end
 
     def add_to_set(hash={})
       do_modifier_operation_and_reload('$addToSet', hash)
     end
+    
+    def addToSet(*args)
+      add_to_set(*args)
+    end
 
     def pop(hash={})
       do_modifier_operation_and_reload('$pop', hash)
@@ -204,12 +216,30 @@ module TinyMongo
     def pull_all(hash={})
       do_modifier_operation_and_reload('$pullAll', hash)
     end
+    
+    def pullAll(*args)
+      pull_all(*args)
+    end
   
     protected
     def do_modifier_operation_and_reload(operator, hash)
       raise ModifierOperationError unless @_tinymongo_hash['_id']
-      collection.update({ '_id' => @_tinymongo_hash['_id'] }, { operator => Helper.hashify_models_in_hash(hash) })
+      collection.update({ '_id' => @_tinymongo_hash['_id'] }, { operator => Helper.hashify_models_in(hash) })
       reload
     end
+    
+    def set_tinymongo_model_class_name_in_hash(hash)
+      hash['_tinymongo_model_class_name'] = self.class.to_s
+      hash
+    end
+    
+    def self.add_tinymongo_model_class_name_key_to_fields(fields)
+      if(fields.kind_of? Hash)
+        fields['_tinymongo_model_class_name'] = 1
+      elsif(fields.kind_of? Array)
+        fields << '_tinymongo_model_class_name'
+      end
+      fields
+    end
   end
 end

data/test/test_tinymongo.rb

@@ -38,24 +38,30 @@ class TinyMongoTest < Test::Unit::TestCase
     obj1 = Dummy.new(:foo => 'hello', :bar => 'world')
     obj2 = Dummy.new(:foo => 'love', :bar => 'ek')
     hash = { :obj1 => obj1, :obj2 => obj2, :hash => { :obj => obj1 }, :array => [obj1, obj2, 'yay'], :val => 'pete' }
-    assert_equal({ 'obj1'  => { 'foo' => 'hello', 'bar' => 'world' }, 
-                   'obj2'  => { 'foo' => 'love', 'bar' => 'ek' },
-                   'hash'  => { 'obj' => { 'foo' => 'hello', 'bar' => 'world' } },
-                   'array' => [ { 'foo' => 'hello', 'bar' => 'world' }, { 'foo' => 'love', 'bar' => 'ek' }, 'yay' ],
+    obj1_hash = { 'foo' => 'hello', 'bar' => 'world', '_tinymongo_model_class_name' => 'Dummy' }
+    obj2_hash = { 'foo' => 'love', 'bar' => 'ek', '_tinymongo_model_class_name' => 'Dummy' }
+    
+    assert_equal({ 'obj1'  => obj1_hash, 
+                   'obj2'  => obj2_hash,
+                   'hash'  => { 'obj' => obj1_hash },
+                   'array' => [ obj1_hash, obj2_hash, 'yay' ],
                    'val'   => 'pete' },
-                 TinyMongo::Helper.hashify_models_in_hash(hash))
+                 TinyMongo::Helper.hashify_models_in(hash))
   end
   
   def test_helper_hashify_models_in_array
     obj1 = Dummy.new(:foo => 'hello', :bar => 'world')
     obj2 = Dummy.new(:foo => 'love', :bar => 'ek')
     array = [ obj1, obj2, { :obj => obj1 }, [obj1, obj2, 'yay'], 'pete' ]
-    assert_equal([ { 'foo' => 'hello', 'bar' => 'world' }, 
-                   { 'foo' => 'love', 'bar' => 'ek' },
-                   { 'obj' => { 'foo' => 'hello', 'bar' => 'world' } },
-                   [ { 'foo' => 'hello', 'bar' => 'world' }, { 'foo' => 'love', 'bar' => 'ek' }, 'yay' ],
+    obj1_hash = { 'foo' => 'hello', 'bar' => 'world', '_tinymongo_model_class_name' => 'Dummy' }
+    obj2_hash = { 'foo' => 'love', 'bar' => 'ek', '_tinymongo_model_class_name' => 'Dummy' }
+    
+    assert_equal([ obj1_hash,
+                   obj2_hash,
+                   { 'obj' => obj1_hash },
+                   [ obj1_hash, obj2_hash, 'yay' ],
                    'pete' ],
-                 TinyMongo::Helper.hashify_models_in_array(array))
+                 TinyMongo::Helper.hashify_models_in(array))
   end
   
   def test_mongo_key
@@ -94,6 +100,7 @@ class TinyMongoTest < Test::Unit::TestCase
     obj = Dummy.new(hash) 
     obj.save # save to db
     hash['_id'] = obj._id # add _id to hash
+    hash['_tinymongo_model_class_name'] = 'Dummy'
     result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
     assert_equal TinyMongo::Helper.stringify_keys_in_hash(hash), result # compare
   end
@@ -103,6 +110,7 @@ class TinyMongoTest < Test::Unit::TestCase
     
     obj = Dummy.create(hash) # save to db
     hash['_id'] = obj._id # add _id to hash
+    hash['_tinymongo_model_class_name'] = 'Dummy'
     
     result = TinyMongo.db['dummies'].find_one({'_id' => obj._id})
     assert_equal TinyMongo::Helper.stringify_keys_in_hash(hash), result, result # compare
@@ -162,43 +170,66 @@ class TinyMongoTest < Test::Unit::TestCase
     assert_equal [obj3], found2
   end
   
-  def test_cursor_close
-    Dummy.create
-    cursor = Dummy.find
-    assert_equal true, cursor.close
-  end
-
-  def test_cursor_closed?
-    Dummy.create
-    cursor = Dummy.find
-    cursor.close
-    assert_equal true, cursor.closed?
+  def test_find_fields
+    Dummy.create('foo' => 'hello', 'bar' => 'world')
+    found = Dummy.find({}, {'foo' => 1}).next!
+    assert_equal 'hello', found.foo
+    assert_equal nil, found.bar
   end
-
-
+  
   def test_cursor_count
-    Dummy.create
-    Dummy.create
-    Dummy.create
+    3.times { Dummy.create }
     cursor = Dummy.find
     assert_equal 3, cursor.count
   end
   
   def test_cursor_limit
-    Dummy.create
-    Dummy.create
-    Dummy.create
+    3.times { Dummy.create }
     cursor = Dummy.find.limit(1)
     assert_equal 1, cursor.to_a.size
   end
   
   def test_cursor_limit_count
-    Dummy.create
-    Dummy.create
-    Dummy.create
+    3.times { Dummy.create }
     cursor = Dummy.find.limit(2)
     assert_equal 2, cursor.limit
   end
+  
+  def test_cursor_size
+    10.times { Dummy.create }
+    cursor = Dummy.find
+    assert_equal 10, cursor.size
+  end
+
+  def test_cursor_size_skip
+    10.times { Dummy.create }
+    cursor = Dummy.find.skip(4)
+    assert_equal 6, cursor.size
+  end
+
+  def test_cursor_size_limit
+    10.times { Dummy.create }
+    cursor = Dummy.find.limit(5)
+    assert_equal 5, cursor.size
+  end
+
+  def test_cursor_size_skip_limit
+    10.times { Dummy.create }
+    cursor = Dummy.find.skip(3).limit(5)
+    assert_equal 5, cursor.size
+  end
+
+  def test_cursor_size_skip_too_much
+    10.times { Dummy.create }
+    cursor = Dummy.find.skip(10)
+    assert_equal 0, cursor.size
+  end
+
+  def test_cursor_size_skip_limit_out_of_bounds
+    10.times { Dummy.create }
+    cursor = Dummy.find.skip(7).limit(5)
+    assert_equal 3, cursor.size
+  end
 
   def test_cursor_each
     Dummy.create('foo' => 1) 
@@ -224,16 +255,16 @@ class TinyMongoTest < Test::Unit::TestCase
     cursor = Dummy.find
     assert_equal false, cursor.has_next?
   end
-
-  def test_cursor_next_document
+  
+  def test_cursor_next!
     obj = Dummy.create
     cursor = Dummy.find
-    assert_equal obj, cursor.next_document
+    assert_equal obj, cursor.next!
   end
 
-  def test_cursor_next_document_nil
+  def test_cursor_next_nil
     cursor = Dummy.find
-    assert_equal nil, cursor.next_document
+    assert_equal nil, cursor.next!
   end
   
   def test_cursor_skip
@@ -242,7 +273,7 @@ class TinyMongoTest < Test::Unit::TestCase
     obj = Dummy.create('foo' => 3) 
     
     cursor = Dummy.find.skip(2)
-    assert_equal obj, cursor.next_document
+    assert_equal obj, cursor.next!
   end
 
   def test_cursor_skip_all
@@ -251,7 +282,7 @@ class TinyMongoTest < Test::Unit::TestCase
     obj = Dummy.create('foo' => 3) 
     
     cursor = Dummy.find.skip(3)
-    assert_equal nil, cursor.next_document
+    assert_equal nil, cursor.next!
   end
   
   def test_cursor_skip_count
@@ -338,12 +369,7 @@ class TinyMongoTest < Test::Unit::TestCase
   
   def test_to_hash
     obj = Dummy.create('foo' => 'hello')
-    assert_equal({'_id' => obj._id, 'foo' => 'hello'}, obj.to_hash)
-  end
-  
-  def test_id
-    obj = Dummy.create
-    assert_equal obj._id.to_s, obj.id
+    assert_equal({'_id' => obj._id, 'foo' => 'hello', '_tinymongo_model_class_name' => 'Dummy'}, obj.to_hash)
   end
   
   def test_to_param
@@ -455,4 +481,15 @@ class TinyMongoTest < Test::Unit::TestCase
     assert_equal [3], TinyMongo.db['dummies'].find_one()['foo']
   end
   
+  def test_deserialize
+    Dummy.create('foo' => 'array', 'bar' => [Dummy.create('foo' => 'hello'), Dummy.create('foo' => 'world')])
+    d = Dummy.find_one({'foo' => 'array'})
+    assert_equal 'Dummy', d.class.to_s
+    assert_equal 'array', d.foo
+    assert_equal 'Dummy', d.bar[0].class.to_s
+    assert_equal 'hello', d.bar[0].foo
+    assert_equal 'Dummy', d.bar[1].class.to_s
+    assert_equal 'world', d.bar[1].foo
+  end
+  
 end

data/tinymongo.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tinymongo}
-  s.version = "0.1.7"
+  s.version = "0.1.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Peter Jihoon Kim"]
-  s.date = %q{2010-07-28}
+  s.date = %q{2010-07-29}
   s.description = %q{Simple MongoDB wrapper}
   s.email = %q{raingrove@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 7
-  version: 0.1.7
+  - 8
+  version: 0.1.8
 platform: ruby
 authors: 
 - Peter Jihoon Kim
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-28 00:00:00 +09:00
+date: 2010-07-29 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency