mingo 0.1.0

data/Rakefile

@@ -0,0 +1,5 @@
+task :default => :spec
+
+task :spec do
+  exec *%w[bundle exec ruby lib/mingo.rb --color]
+end

data/lib/mingo/cursor.rb

@@ -0,0 +1,46 @@
+class Mingo
+  # TODO: contribute this to the official driver
+  class Cursor < Mongo::Cursor
+    module CollectionPlugin
+      def find(selector={}, opts={})
+        opts = opts.dup
+        convert = opts.delete(:convert)
+        cursor = Cursor.from_mongo(super(selector, opts), convert)
+        
+        if block_given?
+          yield cursor
+          cursor.close()
+          nil
+        else
+          cursor
+        end
+      end
+    end
+    
+    def self.from_mongo(cursor, convert)
+      new(cursor.collection, :convert => convert).tap do |sub|
+        cursor.instance_variables.each { |ivar|
+          sub.instance_variable_set(ivar, cursor.instance_variable_get(ivar))
+        }
+      end
+    end
+    
+    def initialize(collection, options={})
+      super
+      @convert = options[:convert]
+    end
+    
+    def next_document
+      convert_document super
+    end
+    
+    private
+    
+    def convert_document(doc)
+      if @convert.nil? or doc.nil? then doc
+      elsif @convert.respond_to?(:call) then @convert.call(doc)
+      else @convert.new(doc)
+      end
+    end
+  end
+end

data/lib/mingo/many_proxy.rb

@@ -0,0 +1,88 @@
+class Mingo
+  class ManyProxy
+    def self.decorate_with(mod = nil, &block)
+      if mod or block_given?
+        @decorate_with = mod || Module.new(&block)
+      else
+        @decorate_with
+      end
+    end
+    
+    def self.decorate_each(&block)
+      if block_given?
+        @decorate_each = block
+      else
+        @decorate_each
+      end
+    end
+    
+    def initialize(parent, property, model)
+      @parent = parent
+      @property = property
+      @model = model
+      @collection = nil
+      @embedded = (@parent[@property] ||= [])
+      @parent.changes.delete(@property)
+    end
+    
+    def find_options
+      @find_options ||= begin
+        decorator = self.class.decorate_with
+        decorate_block = self.class.decorate_each
+        
+        if decorator or decorate_block
+          {:convert => lambda { |doc|
+            @model.new(doc).tap do |obj|
+              obj.extend decorator if decorator
+              decorate_block.call(obj, @embedded) if decorate_block
+            end
+          }}
+        else
+          {}
+        end
+      end
+    end
+  
+    undef :to_a, :inspect
+  
+    def object_ids
+      @embedded
+    end
+  
+    def convert(doc)
+      doc.id
+    end
+  
+    def <<(doc)
+      doc = convert(doc)
+      @parent.update '$addToSet' => { @property => doc }
+      unload_collection
+      @embedded << doc
+      self
+    end
+  
+    def delete(doc)
+      doc = convert(doc)
+      @parent.update '$pull' => { @property => doc }
+      unload_collection
+      @embedded.delete doc
+    end
+  
+    private
+  
+    def method_missing(method, *args, &block)
+      load_collection
+      @collection.send(method, *args, &block)
+    end
+  
+    def unload_collection
+      @collection = nil
+    end
+  
+    def load_collection
+      @collection ||= if @embedded.empty? then []
+      else @model.find({:_id => {'$in' => self.object_ids}}, find_options)
+      end
+    end
+  end
+end

data/lib/mingo.rb

@@ -0,0 +1,254 @@
+require 'mongo'
+require 'active_model'
+require 'hashie/dash'
+
+BSON::ObjectId.class_eval do
+  def self.[](id)
+    self === id ? id : from_string(id)
+  end
+end
+
+class Mingo < Hashie::Dash
+  # ActiveModel::Callbacks
+  include ActiveModel::Conversion
+  extend ActiveModel::Translation
+  
+  autoload :Cursor, 'mingo/cursor'
+  autoload :ManyProxy, 'mingo/many_proxy'
+  
+  class << self
+    attr_writer :db, :collection
+    
+    def db
+      @db || superclass.db
+    end
+    
+    def connect(dbname_or_uri)
+      self.collection = nil
+      self.db = if dbname_or_uri.index('mongodb://') == 0
+        connection = Mongo::Connection.from_uri(dbname_or_uri)
+        connection.db(connection.auths.last['db_name'])
+      else
+        Mongo::Connection.new.db(dbname_or_uri)
+      end
+    end
+    
+    def collection_name
+      self.name
+    end
+    
+    def collection
+      @collection ||= db.collection(collection_name).tap { |col|
+        col.extend Cursor::CollectionPlugin
+      }
+    end
+    
+    def first(id_or_selector = nil, options = {})
+      unless id_or_selector.nil? or Hash === id_or_selector
+        id_or_selector = BSON::ObjectId[id_or_selector]
+      end
+      collection.find_one(id_or_selector, {:convert => self}.update(options))
+    end
+    
+    def find(selector = {}, options = {}, &block)
+      collection.find(selector, {:convert => self}.update(options), &block)
+    end
+    
+    def create(obj = nil)
+      new(obj).tap { |doc| doc.save }
+    end
+    
+    def many(property, model, &block)
+      proxy_class = block_given?? Class.new(ManyProxy, &block) : ManyProxy
+      ivar = "@#{property}"
+      
+      define_method(property) {
+        (instance_variable_defined?(ivar) && instance_variable_get(ivar)) ||
+          instance_variable_set(ivar, proxy_class.new(self, property, model))
+      }
+    end
+  end
+  
+  attr_reader :changes
+  
+  def initialize(obj = nil)
+    @changes = Hash.new { |c, key| c[key] = [self[key]] }
+    @destroyed = false
+    
+    if obj and obj['_id'].is_a? BSON::ObjectId
+      # a doc loaded straight from the db
+      merge!(obj)
+    else
+      super
+    end
+  end
+  
+  # overwrite these to avoid checking for declared properties
+  # (which is default behavior in Dash)
+  def [](property)
+    _regular_reader(property.to_s)
+  end
+
+  def []=(property, value)
+    _regular_writer(property.to_s, value)
+  end
+  
+  def id
+    self['_id']
+  end
+  
+  def persisted?
+    !!id
+  end
+
+  def save(options = {})
+    if persisted?
+      update(values_for_update, options)
+    else
+      self['_id'] = self.class.collection.insert(self.to_hash, options)
+    end.
+      tap { changes.clear }
+  end
+  
+  def update(doc, options = {})
+    self.class.collection.update({'_id' => self.id}, doc, options)
+  end
+  
+  def reload
+    doc = self.class.first(id, :convert => nil)
+    replace doc
+  end
+
+  def destroy
+    self.class.collection.remove('_id' => self.id)
+    @destroyed = true
+    self.freeze
+  end
+  
+  def destroyed?
+    @destroyed
+  end
+  
+  def changed?
+    changes.any?
+  end
+  
+  def ==(other)
+    other.is_a?(self.class) and other.id == self.id
+  end
+  
+  private
+  
+  def values_for_update
+    changes.inject('$set' => {}, '$unset' => {}) do |doc, (key, values)|
+      value = values[1]
+      value.nil? ? (doc['$unset'][key] = 1) : (doc['$set'][key] = value)
+      doc
+    end
+  end
+  
+  def _regular_writer(key, value)
+    old_value = _regular_reader(key)
+    changes[key.to_sym][1] = value unless value == old_value
+    super
+  end
+end
+
+if $0 == __FILE__
+  require 'rspec'
+  
+  Mingo.connect('mingo')
+
+  class User < Mingo
+    property :name
+    property :age
+  end
+  
+  describe User do
+    before :all do
+      User.collection.remove
+    end
+    
+    it "tracks changes attribute" do
+      user = build
+      user.should_not be_persisted
+      user.should_not be_changed
+      user.name = 'Mislav'
+      user.should be_changed
+      user.changes.keys.should include(:name)
+      user.name = 'Mislav2'
+      user.changes[:name].should == [nil, 'Mislav2']
+      user.save
+      user.should be_persisted
+      user.should_not be_changed
+      user.id.should be_a(BSON::ObjectId)
+    end
+    
+    it "has a human model name" do
+      described_class.model_name.human.should == 'User'
+    end
+    
+    it "can reload values from the db" do
+      user = create :name => 'Mislav'
+      user.update '$unset' => {:name => 1}, '$set' => {:age => 26}
+      user.age.should be_nil
+      user.reload
+      user.age.should == 26
+      user.name.should be_nil
+    end
+    
+    it "saves only changed values" do
+      user = create :name => 'Mislav', :age => 26
+      user.update '$inc' => {:age => 1}
+      user.name = 'Mislav2'
+      user.save
+      user.reload
+      user.name.should == 'Mislav2'
+      user.age.should == 27
+    end
+    
+    it "unsets values set to nil" do
+      user = create :name => 'Mislav', :age => 26
+      user.age = nil
+      user.save
+
+      raw_doc(user.id).tap do |doc|
+        doc.should_not have_key('age')
+        doc.should have_key('name')
+      end
+    end
+    
+    it "finds a doc by string ID" do
+      user = create :name => 'Mislav'
+      user_dup = described_class.first(user.id.to_s)
+      user_dup.id.should == user.id
+      user_dup.name.should == 'Mislav'
+    end
+    
+    it "returns nil for non-existing doc" do
+      doc = described_class.first('nonexist' => 1)
+      doc.should be_nil
+    end
+    
+    it "compares with another record" do
+      one = create :name => "One"
+      two = create :name => "Two"
+      one.should_not == two
+      
+      one_dup = described_class.first(one.id)
+      one_dup.should == one
+    end
+    
+    def build(*args)
+      described_class.new(*args)
+    end
+    
+    def create(*args)
+      described_class.create(*args)
+    end
+    
+    def raw_doc(selector)
+      described_class.first(selector, :convert => nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: mingo
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 62196427
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 20
+        version: 2.0.0.beta.20
+  type: :development
+  version_requirements: *id003
+description: Mingo is a minimal document-object mapper for MongoDB.
+email: mislav.marohnic@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/mingo/cursor.rb
+- lib/mingo/many_proxy.rb
+- lib/mingo.rb
+has_rdoc: false
+homepage: http://github.com/mislav/mingo
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Minimal Mongo
+test_files: []
+