mongo_light 0.0.1

data/lib/mongo_light/connection.rb

@@ -0,0 +1,36 @@
+require 'mongo'
+
+module MongoLight
+  module Connection 
+
+    def self.setup(connection, database_name)
+      @@connection = connection
+      @@database = @@connection.db(database_name)
+      handle_passenger_forking
+    end
+    
+    def self.connection
+      @@connection
+    end
+    
+    def self.database
+      @@database
+    end
+  
+    def self.collections
+      @@database.collections
+    end
+
+    def self.[](collection_name)
+      @@database.collection(collection_name)
+    end
+  
+    def self.handle_passenger_forking
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          @@connection.connect if forked
+        end
+      end
+    end
+  end
+end

data/lib/mongo_light/document.rb

@@ -0,0 +1,75 @@
+module MongoLight
+  module Document
+    extend ActiveSupport::Concern
+    include EmbeddedDocument
+  
+    module ClassMethods
+      def collection
+        Connection[self.to_s.tableize]
+      end
+      def find_by_id(id)
+        real_id = Id.from_string(id)
+        return nil if real_id.nil?
+      
+        found = collection.find_one(real_id)
+        found.nil? ? nil : self.new(unmap(found))
+      end
+      def find_one(selector = {})
+        found = collection.find_one(map(selector))
+        found.nil? ? nil : self.new(unmap(found))
+      end
+      def find(selector={}, opts={}, collection = nil)
+        raw = opts.delete(:raw) || false
+        opts[:transformer] = Proc.new{|data| raw ? unmap(data, raw) : self.new(unmap(data)) }
+        c = collection || self.collection
+        c.find(map(selector), map_options(opts))
+      end
+      def remove(selector={}, collection = nil)
+        c = collection || self.collection
+        c.remove(map(selector))
+      end
+      def update(selector, document, options = {}, collection = nil)
+        c = collection || self.collection
+        c.update(map(selector), map(document), options)
+      end
+      def count(selector={}, collection = nil)
+        c = collection || self.collection
+        c.find(map(selector)).count
+      end
+    end
+    module InstanceMethods
+      def initialize(attributes = {})
+        attributes[:_id] = Id.new unless attributes.include?('_id') || attributes.include?(:_id)
+        @attributes = attributes
+        attributes.each do |k,v|
+          send("#{k}=", v)  unless k == :_id || k == '_id' 
+        end
+      end
+      def eql?(other)
+        other.is_a?(self.class) && id == other.id
+      end
+      alias :== :eql?
+      def hash
+        id.hash
+      end
+      def id
+        @attributes[:_id] || @attributes['_id']
+      end
+      def id=(value)
+        @attributes[:_id] = value
+      end
+      def ==(other)
+        other.class == self.class && id == other.id
+      end
+      def collection
+        self.class.collection
+      end
+      def save
+        collection.save(self.class.map(@attributes))
+      end
+      def save!
+        collection.save(self.class.map(@attributes), {:safe => true})
+      end
+    end
+  end
+end

data/lib/mongo_light/embedded_document.rb

@@ -0,0 +1,75 @@
+module MongoLight
+  module EmbeddedDocument
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def mongo_accessor(map)
+        @map = map
+        @unmap = {}
+        map.each do |k,v|
+          define_method(k) { @attributes[k] }
+          define_method("#{k}=") {|value| @attributes[k] = value }
+          if v.is_a?(Hash)
+            @unmap[v[:field].to_s] = {:prop => k, :class => v[:class]}
+          else
+            @unmap[v.to_s] = k
+          end
+        end
+      end
+      def map(raw)
+        return {} if raw.blank? || !raw.is_a?(Hash)
+        hash = {}
+        raw.each do |key, value|
+          if value.is_a?(EmbeddedDocument)
+            v = value.class.map(value.attributes)
+          elsif value.is_a?(Hash)
+            v = map(value)
+          else
+            v = value
+          end
+          hash[map_key(key.to_sym)] = v
+        end
+        return hash
+      end
+      def map_options(options)
+        options[:fields] = map(options[:fields]) if options.include?(:fields)
+        options[:sort][0] = map_key(options[:sort][0]) if options.include?(:sort)
+        options
+      end
+      def unmap(data, raw = false)
+        return {} if data.blank? || !data.is_a?(Hash)
+        hash = {}
+        data.each do |key, value|
+          if @unmap[key].is_a?(Hash)
+            real_key = @unmap[key][:prop]
+            c = @unmap[key][:class]
+            v = raw ? c.unmap(value) : c.new(c.unmap(value))
+          else
+            real_key = key == '_id' ? :_id : @unmap[key]
+            v = value
+          end
+          hash[real_key] = v
+        end
+        hash
+      end
+      def map_key(key)
+        return key unless @map.include?(key)
+        @map[key].is_a?(Hash) ? @map[key][:field] : @map[key]
+      end
+    end
+    module InstanceMethods
+      def initialize(attributes = {})
+        @attributes = attributes
+        attributes.each do |k,v|
+          send("#{k}=", v)
+        end
+      end
+      def [](name)
+        @attributes[name]
+      end
+      def attributes
+        @attributes
+      end
+    end
+  end
+end

data/lib/mongo_light/id.rb

@@ -0,0 +1,17 @@
+module MongoLight
+  module Id
+    def self.new
+      BSON::ObjectId.new
+    end
+    def self.valid?(id)
+      return false if id.blank? || id.class == Fixnum
+      return true if id.class == BSON::ObjectId
+      BSON::ObjectId.legal?(id)
+    end
+    def self.from_string(id)
+      return nil unless Id.valid?(id)
+      return id if id.class == BSON::ObjectId
+      BSON::ObjectId.from_string(id)
+    end
+  end
+end

data/lib/mongo_light/version.rb

@@ -0,0 +1,3 @@
+module MongoLight
+  Version = '0.0.1'
+end

data/lib/mongo_light.rb

@@ -0,0 +1,4 @@
+require 'mongo_light/id'
+require 'mongo_light/connection'
+require 'mongo_light/embedded_document'
+require 'mongo_light/document'

data/license

@@ -0,0 +1,14 @@
+This file is part of MongoLight.
+
+    MongoLight is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    MongoLight is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with MongoLight.  If not, see <http://www.gnu.org/licenses/>.

data/readme.markdown

@@ -0,0 +1,68 @@
+# MongoLight #
+MongoLight is a lightweight object-relational mapper for Rails and MongoDB. It is **not** ActiveRecord compatible. Rather, the primary purpose is to be a thin wrapper around the excellent core [MongoDB driver](https://github.com/mongodb/mongo-ruby-driver). 
+
+The only Rails dependency is on ActiveSupport::Concern.
+
+The wrapper fits a specific use-case (mine).
+
+## Setup ##
+During initialization (such as in an initializer), call `MongoLight::Connection.setup`, supplying 2 parameters. The first is a MongoDB connection (that you get from the core driver). The second parameter is the database name. For example:
+
+	MongoLight::Connection.setup(Mongo::Connection.new, 'test')
+
+This'll automatically handle Passenger forking issues (if Passenger is running).
+
+## Documents ##
+To define a document include `MongoLight::Document` and define your properties using the `mongo_accessor` method:
+
+	class User
+		include MongoLight::Document
+		mongo_accessor({:name => :name, password => :pw, :email => :e})
+	end
+
+Within your code, you can access the `name`, `password` and `email` properties. However, internally, MongoDB will store the fields as `name`, `pw` and `e` (document databases store the field names with each document, this can save a lot of space (we saved 25%)).
+
+## Document Manipulation ##
+Most of what you can do on a MongoDB collection (again, the Ruby driver), you can do on a MongoLight document:
+
+	#string ids which are valid BsonIds will automatically get converted
+	User.find_by_id(some_id)
+	User.find_one(hash_selector)
+	User.find(selector, options)
+	User.remove(selector)
+	User.update(selector, new_document, options)
+
+In addition to any options which the ruby driver supports, the `find` method can be passed ``{:raw => true}` which'll cause a hash to be returned rather than a mapped object.
+
+Instances can be saved via `save` or `save!` (safe mode).
+
+New instances can be created by passing a hash into the constructor:
+
+	User.new({:name => 'goku', :password => 'over 9000!!!'})
+
+Finally, you can always access the underlying `collection` from a class or object (`User.collection` or `user.collection`).
+
+## Embedded Documents ##
+Embedded documents are supported. First, define an embedded document using `include MongoLight::EmbeddedDocument` and the same `mongo_accessor` method:
+
+	class Comment
+		include MongoLight::EmbeddedDocument
+		mongo_accessor({:title => :t, description => :d})
+	end
+
+Next, use the following fancy syntax for your root document:
+
+	class User
+		include MongoLight::Document
+		mongo_accessor({:name => :name, password => :pw, :email => :e, :comments => {:field => :c, :class => Comment}})
+	end
+
+Again, this'll make `comments` accessible on your objects, but store it within the `c` field.
+
+Please note that aliasing completely fails when querying embedded documents - you need to use the shortened name:
+
+	User.find({:name => 'blah', 'c.t' => 'blah2}) #yes, it sucks
+
+
+
+	

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: mongo_light
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Karl Seguin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-27 00:00:00 Z
+dependencies: []
+
+description: 
+email: 
+- karlseguin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mongo_light/connection.rb
+- lib/mongo_light/document.rb
+- lib/mongo_light/embedded_document.rb
+- lib/mongo_light/id.rb
+- lib/mongo_light/version.rb
+- lib/mongo_light.rb
+- license
+- readme.markdown
+homepage: http://github.com/karlseguib/MongoLight
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: A Lightweight ORM for Rails and MongoDB
+test_files: []
+