zentradi 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,12 @@
+source :gemcutter
+
+gem "jeweler"
+
+gem "weak_hash"
+gem "hashie"
+
+gem "mongo"
+gem "mongo_ext"
+
+gem "rake"
+gem "rspec"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Emmanuel Oga
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,98 @@
+= zentradi
+
+Zentradi provides a [wannabe] minimalistic set of tools for managing the mongodb ruby driver.
+
+For now this is basically my playground for experimenting with mongodb.
+
+Developed mainly under ruby 1.9.1, using bundler for development mode dependencies management.
+
+== Usage
+
+The class just acts as a convenient way to group all the mongo artefacts:
+
+  Zentradi::Document.connection
+  Zentradi::Document.database
+  Zentradi::Document.collection
+
+The Zentradi::Document.mongo method is a short cut for setting all those at the same time:
+
+  class Post < Zentradi::Document
+    mongo :database => "zentradi", :collection => "posts"
+
+    collection.create_index "key", true # Access the collection directly, set an index.
+
+    mongo_accessor :other_key
+  end
+
+Some examples:
+
+  Post.create!(:some => :attributes)
+
+  Post.first.destroy
+
+  Post.first(:some => :attribute)
+
+  p = Post.new(some: "attributes")
+  p.some
+  p.document.some.other!.key = "hey!"
+  p.save
+  p.reload
+
+etc...
+
+I opted for explicit configuration of each document class. While using the
+Class.inherited hook might sound cool, I'm still undecided about wetter adding
+such magic is really worth the effort.
+
+The Zentradi::Document#document method provide access to the "raw" mongo
+document, which is an instance of Hashie::Mash object (instead of a Hash) for
+convenience.
+
+The mongo_accessor class method is a shortcut to access the keys of the
+document (Mash) from an instance of Document, but that is not really necessary.
+
+=== BUT WHY?!
+
+In brief, the [pretentious? :p] philosophy of this project is "less code is
+better code".
+
+In particular, I want:
+
+  [
+    "magic",
+    "ruby hooks overrides",
+    "additions to the mongo mapper API",
+    "plugins paraphernalia",
+    "use and abuse of generated methods -- find_by_blah_blah anyone? -- ",
+    "features of ActiveRecord, Datamapper, [INSERT ORM HERE]"
+  ].map do |bad_thing|
+    "As little #{ bad_thing } as possible"
+  end
+
+=== How about validations, callbacks, state machines, carbonated time bomb mirror device?
+
+I'm afraid you'll have to implement all those yourself if you need them. Or
+better yet! grab some gems!
+
+I haven't toyed yet with adding ActiveModel compatibility. Really, such thing
+is a little out of this scope of this project, although sounds like a fun
+thing to try on a rainy weekend :p.
+
+=== DISCLAIMER
+
+You might be interested to know, this is alpha quality software. I don't use it
+myself for any production project yet. Standard disclaimers apply.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Emmanuel Oga. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+begin
+  # Try to require the preresolved locked set of gems.
+  require File.expand_path('.bundle/environment', __FILE__)
+rescue LoadError
+  # Fall back on doing an unlocked resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+Bundler.require
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "zentradi"
+    gem.summary = %Q{minimalistic tools for accessing mongodb}
+    gem.description = %Q{minimalistic tools for accessing mongodb}
+    gem.email = "EmmanuelOga@gmail.com"
+    gem.homepage = "http://github.com/EmmanuelOga/zentradi"
+    gem.authors = ["Emmanuel Oga"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "rake"
+    gem.add_dependency "mongo"
+    gem.add_dependency "mongo_ext"
+    gem.add_dependency "weak_hash"
+    gem.add_dependency "hashie"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+$LOAD_PATH.unshift File.expand_path('lib')
+
+require 'zentradi'
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zentradi #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/zentradi.rb

@@ -0,0 +1,13 @@
+require 'hashie'
+require 'weak_hash'
+require 'mongo'
+
+module Zentradi
+  autoload :Utils,           "zentradi/utils"
+  autoload :ClassHelpers,    'zentradi/class_helpers'
+  autoload :Instantiators,   'zentradi/instantiators'
+  autoload :IdentityMap,     'zentradi/identity_map'
+  autoload :Connection,      'zentradi/connection'
+  autoload :Finders,         'zentradi/finders'
+  autoload :Document,        'zentradi/document'
+end

data/lib/zentradi/class_helpers.rb

@@ -0,0 +1,46 @@
+module Zentradi
+  # Some random helpers to be used at class level.
+  module ClassHelpers
+
+    def instance_access_to_class_methods(*names)
+      names.each do |name|
+        module_eval(<<-EOMETHOD, __FILE__, __LINE__ + 1)
+          def #{ name }(*args, &block)
+            self.class.#{ name }(*args, &block)
+          end
+        EOMETHOD
+      end
+    end
+
+    # creates a shortcut for accessing keys
+    # on the mongo document.
+    # Not really needed but seems like after
+    # ActiveRecord nobody can live without this
+    # (including me? :-)
+    def mongo_accessor(*keys)
+      keys.each do |key|
+        module_eval(<<-EOMETHOD, __FILE__, __LINE__ + 1)
+          def #{ key }
+            document[#{key.inspect}]
+          end
+
+          def #{ key }=(val)
+            document[#{key.inspect}] = val
+          end
+        EOMETHOD
+      end
+    end
+
+    def delegate(*methods)
+      to = methods.pop[:to]
+      methods.each do |name|
+        module_eval(<<-EOMETHOD, __FILE__, __LINE__ + 1)
+          def #{ name }(*args, &block)
+            #{to}.#{name}(*args, &block)
+          end
+        EOMETHOD
+      end
+    end
+
+  end
+end

data/lib/zentradi/connection.rb

@@ -0,0 +1,48 @@
+module Zentradi
+  # methods to manage the mongo driver communication artefacts
+  module Connection
+
+    def connection(*args)
+      @_connection = nil unless args.empty?
+      @_connection ||= Mongo::Connection.new(*args)
+    end
+
+    def database(database_name = nil)
+      @_database = nil unless database_name.nil?
+      @_database ||= connection.db(database_name)
+    end
+
+    def collection(collection_name = nil)
+      @_collection = nil unless collection_name.nil?
+      @_collection ||= database[collection_name]
+    end
+
+    # configuration shortcut
+    def mongo(options)
+      connection *options[:connection] if options.member?(:connection)
+      database   options[:database]    if options.member?(:database)
+      collection options[:collection]  if options.member?(:collection)
+    end
+
+    # -------------------------------------------------------------------------
+
+    def ensure_collection
+      database.create_collection(collection.name)
+    end
+
+    def drop_collection!
+      collection.drop
+    end
+
+    def recreate_collection!
+      drop_collection! and ensure_collection
+    end
+
+    def identity_map
+      raise RuntimeError, "please set the mongo database first" unless database
+      raise RuntimeError, "please set the mongo collection first" unless collection
+      Zentradi::IdentityMap[database.name, collection.name]
+    end
+
+  end
+end

data/lib/zentradi/document.rb

@@ -0,0 +1,83 @@
+module Zentradi
+  class Document
+
+    extend Connection
+    extend ClassHelpers
+    extend Instantiators
+
+    attr_accessor :document
+    instance_access_to_class_methods :identity_map, :collection
+
+    def initialize(document = nil)
+      raise ArgumentError, "provide a Hash like object or no parameters" unless document.nil? || document.class.ancestors.include?(Hash)
+
+      @document = document ? Hashie::Mash.new(document) : Hashie::Mash.new
+    end
+
+    def update(document)
+      @document.update(document) and save
+    end
+
+    def update!(document)
+      @document.update(document) and save!
+    end
+
+    def [](key)
+      @document[key]
+    end
+
+    def []=(key, value)
+      @document[key] = value
+    end
+
+    def id
+      @document["_id"]
+    end
+
+    def new?
+      not saved?
+    end
+
+    def saved?
+      id && collection.find("_id" => id).count != 0
+    end
+
+    def save(safe = false)
+      if id
+        collection.update({"_id" => id}, @document, :safe => safe)
+      else
+        update("_id" => collection.save(@document, :safe => safe))
+      end
+    end
+
+    def save!
+      save(true)
+    end
+
+    def destroy
+      if id
+        collection.remove("_id" => id)
+        @document.delete("_id")
+      end
+    end
+
+    def reload
+      if _id = id
+        @document.clear["_id"] = _id # clear and set.
+        update(mongo_document)
+      end
+
+      self
+    end
+
+    private
+    def mongo_document
+      raise RuntimeError, "cannot retrieve a new document" if new?
+
+      collection.find_one("_id" => id).tap do |i|
+        raise RuntimeError, "nothing was retrieved while loading the mongo instance ( #{ i.inspect } )" if i.nil? || i.empty?
+      end
+    end
+
+  end
+end

data/lib/zentradi/identity_map.rb

@@ -0,0 +1,75 @@
+module Zentradi
+  # NOTE: WIP, not working yet.
+  #
+  # Stores weak references to objects to ensure only one
+  # instance of a ruby class is used for holding a reference
+  # to a specific mongo collection.
+  class IdentityMap
+    class << self
+      # one identity map per db/collection tuple
+      def [](db_name, collection_name)
+        @hash ||= Hash.new { |h,k| h[k] = Hash.new { |hh, kk| hh[kk] = IdentityMap.new } }
+        @hash[db_name][collection_name]
+      end
+    end
+
+    def initialize
+      @map = WeakHash.new
+    end
+
+    # retrieves a document with given _id
+    def get(_id)
+      @map[_id].tap { |instance| check(_id, instance) }
+    end
+
+    # stores a reference to the mongo document.
+    def set(_id, instance)
+      check(_id, @map[_id] = instance)
+    end
+
+  private
+    def check(_id, instance)
+      raise ArgumentError, "instance must be a Zentradi::Document" unless instance.nil? || instance.is_a?(Zentradi::Document)
+      raise RuntimeError, "instance #{ instance.inspect } does not match _id: #{ _id }" if instance && ( instance.id != _id )
+      instance
+    end
+
+    # Some helper methods to enable / disable the identity map at a class level.
+    module Management
+      def enable_identity_map
+        @_identity_map = true
+      end
+
+      def disable_identity_map
+        @_identity_map = false
+      end
+
+      # enabled by default
+      def identity_map_enabled?
+        @_identity_map.nil? || @_identity_map
+      end
+
+    private
+
+      def fetch_instance(param_doc)
+        if param_doc.nil?
+          nil
+        elsif identity_map_enabled? && param_doc["_id"]
+
+          if instance = identity_map.get(param_doc["_id"])
+            instance.update(param_doc)
+          else
+            document = param_doc.is_a?(Document) ? param_doc : new(param_doc)
+            instance = identity_map.set(document["_id"], document)
+          end
+
+          instance
+        else
+          param_doc.is_a?(Document) ? param_doc : new(param_doc)
+        end
+      end
+
+    end # end module Management
+
+  end
+end

data/lib/zentradi/instantiators.rb

@@ -0,0 +1,36 @@
+module Zentradi
+  module Instantiators
+    extend ClassHelpers
+
+    delegate :remove, :update, :to => :collection
+
+    def all(params = nil)
+      collection.find(params).map(&method(:instantiate))
+    end
+
+    def first(params = nil)
+      query = params.is_a?(String) || params.is_a?(Numeric) ? {"_id" => params} :  params
+
+      instantiate collection.find_one(query)
+    end
+
+    def find_or_initialize(params)
+      raise RuntimeError, "cannot find a document without params" if params.nil?
+
+      first(params) || instantiate(params)
+    end
+
+    def create(params)
+      instantiate(params).tap { |n| n.save }
+    end
+
+    def create!(params)
+      instantiate(params).tap { |n| n.save! }
+    end
+
+    def instantiate(document)
+      document ? new(document) : nil
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'zentradi'

data/spec/zentradi/document_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class Post < Zentradi::Document
+  mongo :collection => "post", :database => "zentradi"
+
+  mongo_accessor :title
+end
+
+describe Zentradi::Document do
+  before do
+    Post.remove
+  end
+
+  it "creates a document" do
+    post = Post.new
+    post.id.should be_nil
+    post.should be_new
+
+    post.save
+
+    post.id.should_not be_nil
+    post.should_not be_new
+  end
+
+  it "finds a document through the identity map" do
+    @post = Post.create(:title => "Hola Mundo", :body => "Hi.")
+    Post.first("_id" => @post.id).should be_an_instance_of(Post)
+  end
+
+  it "finds or initializes a document" do
+    @post = Post.create(:title => "Test")
+
+    found = Post.find_or_initialize(:title => "Test")
+    found.title.should == "Test"
+
+    found = Post.find_or_initialize(:title => "Test 2")
+    found.title.should == "Test 2"
+    found.should be_new
+    found.save
+
+    found.should_not be_new
+    found.title.should == "Test 2"
+  end
+
+  it "updates a document" do
+    @post = Post.create(:title => "Hola Mundo", :body => "Hi.")
+    @post.title = "ABC"
+    @post.save
+    @post.reload
+    @post.title.should == "ABC"
+  end
+
+  it "destroys a document" do
+    @post = Post.create(:title => "Hola Mundo", :body => "Hi.")
+    id = @post.id
+    @post.should_not be_new
+    @post.destroy
+    Post.first(id).should be_nil
+  end
+
+  it "finds all the documents" do
+    Post.remove
+    Post.create(:title => "First")
+    Post.create(:title => "Second")
+    Post.all.map(&:title).should include("First")
+    Post.all.map(&:title).should include("Second")
+  end
+
+end

data/spec/zentradi/identity_map_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Zentradi::IdentityMap do
+  before do
+    @oh = Zentradi::Document.new
+    @oh["_id"] = "123456"
+
+    @im = Zentradi::IdentityMap["a_db", "a_collection"]
+
+    GC.start # make sure @im is collected if it was overwritten (e.g. in second example run)
+  end
+
+  it "stores an object" do
+    @im.set("123456", @oh)
+    @im.get("123456").should == @oh
+  end
+
+  it "stores a weak reference" do
+    @im.set("123456", @oh)
+    @im.get("123456").should == @oh
+
+    @oh = nil; GC.start
+
+    @im.get("123456").should be_nil
+  end
+end

data/spec/zentradi/indexes_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class Book < Zentradi::Document
+  mongo :collection => "books", :database => "zentradi"
+
+  mongo_accessor :checksum
+end
+
+describe Zentradi, "managing indexes" do
+  before do
+    Book.recreate_collection!
+  end
+
+  it "is able to create indexes" do
+    Book.collection.create_index "checksum", true
+    #Book.collection.create_index([[ "checksum", Mongo::ASCENDING ]], true)
+    Book.collection.index_information.keys.detect { |k| k =~ /checksum/ }.should be_true
+  end
+
+  it "throws an error if we insert the same value twice on an unique index column" do
+    Book.collection.create_index "checksum", true
+    Book.create(checksum: 1234)
+    lambda { Book.create!(checksum: 1234) }.should raise_error(Mongo::OperationFailure)
+  end
+end
+

data/spec/zentradi_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Zentradi do
+  it "works" do
+    true.should be_true
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification 
+name: zentradi
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Emmanuel Oga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-16 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mongo_ext
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: weak_hash
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+description: minimalistic tools for accessing mongodb
+email: EmmanuelOga@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/zentradi.rb
+- lib/zentradi/class_helpers.rb
+- lib/zentradi/connection.rb
+- lib/zentradi/document.rb
+- lib/zentradi/identity_map.rb
+- lib/zentradi/instantiators.rb
+- spec/spec_helper.rb
+- spec/zentradi/document_spec.rb
+- spec/zentradi/identity_map_spec.rb
+- spec/zentradi/indexes_spec.rb
+- spec/zentradi_spec.rb
+has_rdoc: true
+homepage: http://github.com/EmmanuelOga/zentradi
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: minimalistic tools for accessing mongodb
+test_files: 
+- spec/zentradi_spec.rb
+- spec/zentradi/document_spec.rb
+- spec/zentradi/identity_map_spec.rb
+- spec/zentradi/indexes_spec.rb
+- spec/spec_helper.rb