perpetuity-mongodb 1.0.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1eb06e99c8f903ef80d322b5a5efafed98bdfe58
+  data.tar.gz: 0688a5ef4c25609887ef02748ba5fea2cf4d435e
+SHA512:
+  metadata.gz: e9a4df359600fa4bd7a5434b91adffe4cd492605769239990d5652cd14ae25288779df219eb04cf31a97262036186f262c65eb77003e34fdaf3912d920bb8853
+  data.tar.gz: 3167ead40e5411aea1b1df00340dba7ab8c7a062a51a9264f9b6c01096305cf29c42699f7c2fddc2b73516d825c649701a1e5cfbf57f8856632087a011846322

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in perpetuity-mongodb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jamie Gaskins
+
+MIT License
+
+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.md

@@ -0,0 +1,36 @@
+# Perpetuity::MongoDB
+
+This is the MongoDB adapter for Perpetuity.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'perpetuity-mongodb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install perpetuity-mongodb
+
+## Usage
+
+Put this at the top of your application (or in a Rails initializer):
+
+```ruby
+require 'perpetuity/mongodb' # Unnecessary if using Rails
+Perpetuity.data_source :mongodb, 'my_perpetuity_database'
+```
+
+For information on using Perpetuity to persist your Ruby objects, see the [main Perpetuity repo](https://github.com/jgaskins/perpetuity).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/perpetuity/mongodb.rb

@@ -0,0 +1,231 @@
+require 'perpetuity'
+require 'moped'
+require 'perpetuity/mongodb/query'
+require 'perpetuity/mongodb/nil_query'
+require 'perpetuity/mongodb/index'
+require 'perpetuity/mongodb/serializer'
+require 'set'
+require 'perpetuity/exceptions/duplicate_key_error'
+require 'perpetuity/attribute'
+
+module Perpetuity
+  class MongoDB
+    attr_accessor :host, :port, :db, :pool_size, :username, :password
+
+    def initialize options
+      @host       = options.fetch(:host, 'localhost')
+      @port       = options.fetch(:port, 27017)
+      @db         = options.fetch(:db)
+      @pool_size  = options.fetch(:pool_size, 5)
+      @username   = options[:username]
+      @password   = options[:password]
+      @session    = nil
+      @indexes    = Hash.new { |hash, key| hash[key] = active_indexes(key) }
+      @connected  = false
+    end
+
+    def session
+      @session ||= Moped::Session.new(["#{host}:#{port}"]).with(safe: true)
+    end
+
+    def connect
+      session.login(@username, @password) if @username and @password
+      @connected = true
+      session
+    end
+
+    def connected?
+      !!@connected
+    end
+
+    def database
+      session.use db
+      connect unless connected?
+      session
+    end
+
+    def collection klass
+      database[klass.to_s]
+    end
+
+    def insert klass, objects, _
+      if objects.is_a? Array
+        objects.each do |object|
+          object[:_id] = object.delete('id') || Moped::BSON::ObjectId.new
+        end
+
+        collection(klass).insert objects
+        objects.map { |object| object[:_id] }
+      else
+        insert(klass, [objects], _).first
+      end
+
+    rescue Moped::Errors::OperationFailure => e
+      if e.message =~ /duplicate key/
+        e.message =~ /\$(\w+)_\d.*dup key: { : (.*) }/
+        key = $1
+        value = $2.gsub("\\\"", "\"")
+        raise DuplicateKeyError, "Tried to insert #{klass} with duplicate unique index: #{key} => #{value}"
+      end
+    end
+
+    def count klass, criteria=nil_query, &block
+      q = block_given? ? query(&block).to_db : criteria.to_db
+      collection(klass).find(q).count
+    end
+
+    def delete_all klass
+      collection(klass.to_s).find.remove_all
+    end
+
+    def first klass
+      document = collection(klass.to_s).find.limit(1).first
+      document[:id] = document.delete("_id")
+
+      document
+    end
+
+    def retrieve klass, criteria, options = {}
+      # MongoDB uses '_id' as its ID field.
+      criteria = to_bson_id(criteria.to_db)
+
+      skipped = options.fetch(:skip) { 0 }
+
+      query = collection(klass.to_s)
+                .find(criteria)
+                .skip(skipped)
+                .limit(options[:limit])
+
+      sort(query, options).map do |document|
+        document[:id] = document.delete("_id")
+        document
+      end
+    end
+
+    def increment klass, id, attribute, count=1
+      find(klass, id).update '$inc' => { attribute => count }
+    end
+
+    def find klass, id
+      collection(klass).find(to_bson_id(_id: id))
+    end
+
+    def to_bson_id criteria
+      criteria = criteria.dup
+
+      # Check for both string and symbol ID in criteria
+      if criteria.has_key?('id')
+        criteria['_id'] = Moped::BSON::ObjectId(criteria['id']) rescue criteria['id']
+        criteria.delete 'id'
+      end
+
+      if criteria.has_key?(:id)
+        criteria[:_id] = Moped::BSON::ObjectId(criteria[:id]) rescue criteria[:id]
+        criteria.delete :id
+      end
+
+      criteria
+    end
+
+    def sort query, options
+      return query unless options[:attribute] &&
+                          options[:direction]
+
+      sort_orders = { ascending: 1, descending: -1 }
+      sort_field = options[:attribute]
+      sort_direction = options[:direction]
+      sort_criteria = { sort_field => sort_orders[sort_direction] }
+      query.sort(sort_criteria)
+    end
+
+    def all klass
+      retrieve klass, nil_query, {}
+    end
+
+    def delete id, klass
+      collection(klass.to_s).find("_id" => id).remove
+    end
+
+    def update klass, id, new_data
+      find(klass, id).update('$set' => new_data)
+    end
+
+    def can_serialize? value
+      serializable_types.include? value.class
+    end
+
+    def drop_collection to_be_dropped
+      collection(to_be_dropped.to_s).drop
+    end
+
+    def query &block
+      Query.new(&block)
+    end
+
+    def nil_query
+      NilQuery.new
+    end
+
+    def negate_query &block
+      Query.new(&block).negate
+    end
+
+    def index klass, attribute, options={}
+      @indexes[klass] ||= Set.new
+
+      index = Index.new(klass, attribute, options)
+      @indexes[klass] << index
+      index
+    end
+
+    def indexes klass
+      @indexes[klass]
+    end
+
+    def active_indexes klass
+      collection(klass).indexes.map do |index|
+        key = index['key'].keys.first
+        direction = index['key'][key]
+        unique = index['unique']
+        Index.new(klass, Attribute.new(key), order: Index::KEY_ORDERS[direction], unique: unique)
+      end.to_set
+    end
+
+    def activate_index! index
+      attribute = index.attribute.to_s
+      order = index.order == :ascending ? 1 : -1
+      unique = index.unique?
+
+      collection(index.collection).indexes.create({attribute => order}, unique: unique)
+      index.activate!
+    end
+
+    def remove_index index
+      coll = collection(index.collection)
+      db_indexes = coll.indexes.select do |db_index|
+        db_index['name'] =~ /\A#{index.attribute}/
+      end.map { |idx| idx['key'] }
+
+      if db_indexes.any?
+        collection(index.collection).indexes.drop db_indexes.first
+      end
+    end
+
+    def serialize object, mapper
+      Serializer.new(mapper).serialize object
+    end
+
+    def serialize_changed_attributes object, original, mapper
+      Serializer.new(mapper).serialize_changes object, original
+    end
+
+    def unserialize data, mapper
+      Serializer.new(mapper).unserialize data
+    end
+
+    private
+    def serializable_types
+      @serializable_types ||= [NilClass, TrueClass, FalseClass, Fixnum, Float, String, Array, Hash, Time]
+    end
+  end
+end

data/lib/perpetuity/mongodb/index.rb

@@ -0,0 +1,52 @@
+module Perpetuity
+  class MongoDB
+    class Index
+      KEY_ORDERS = { 1 => :ascending, -1 => :descending }
+      attr_reader :collection, :attribute
+
+      def initialize klass, attribute, options={}
+        @collection = klass
+        @attribute = attribute
+        @unique = options.fetch(:unique) { false }
+        @order = options.fetch(:order) { :ascending }
+        @activated = false
+      end
+
+      def active?
+        @activated
+      end
+
+      def inactive?
+        !active?
+      end
+
+      def activate!
+        @activated = true
+      end
+
+      def unique?
+        @unique
+      end
+
+      def order
+        @order
+      end
+
+      def == other
+        hash == other.hash
+      end
+
+      def eql? other
+        self == other
+      end
+
+      def attribute_name
+        attribute.respond_to?(:name) ? attribute.name : attribute
+      end
+
+      def hash
+        "#{collection}/#{attribute_name}:#{unique?}:#{order}".hash
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/nil_query.rb

@@ -0,0 +1,11 @@
+module Perpetuity
+  class NilQuery
+    def self.new
+      @instance ||= allocate
+    end
+
+    def to_db
+      {}
+    end
+  end
+end

data/lib/perpetuity/mongodb/query.rb

@@ -0,0 +1,33 @@
+require 'perpetuity/mongodb/query_attribute'
+require 'perpetuity/mongodb/nil_query'
+
+module Perpetuity
+  class MongoDB
+    class Query
+      attr_reader :query
+      def initialize &block
+        if block_given?
+          @query = block.call(self)
+        else
+          @query = NilQuery.new
+        end
+      end
+
+      def to_db
+        @query.to_db
+      end
+
+      def negate
+        @query.negate
+      end
+
+      def method_missing missing_method
+        QueryAttribute.new missing_method
+      end
+
+      def == other
+        query == other.query
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb/query_attribute.rb

@@ -0,0 +1,66 @@
+require 'perpetuity/mongodb/query_expression'
+
+module Perpetuity
+  class MongoDB
+    class QueryAttribute
+      attr_reader :name
+
+      def initialize name
+        @name = name
+      end
+
+      def == value
+        QueryExpression.new self, :equals, value
+      end
+
+      def < value
+        QueryExpression.new self, :less_than, value
+      end
+
+      def >= value
+        QueryExpression.new self, :gte, value
+      end
+
+      def > value
+        QueryExpression.new self, :greater_than, value
+      end
+
+      def <= value
+        QueryExpression.new self, :lte, value
+      end
+
+      def != value
+        QueryExpression.new self, :not_equal, value
+      end
+      alias :not_equal? :'!='
+
+      def =~ regexp
+        QueryExpression.new self, :matches, regexp
+      end
+
+      def in collection
+        QueryExpression.new self, :in, collection
+      end
+
+      def to_sym
+        name
+      end
+
+      def to_db
+        ((self != false) & (self != nil)).to_db
+      end
+
+      def method_missing name
+        if name.to_s == 'id'
+          name = :"#{self.name}.__metadata__.#{name}"
+        elsif name.to_s == 'klass'
+          name = :"#{self.name}.__metadata__.class"
+        else
+          name = :"#{self.name}.#{name}"
+        end
+
+        self.class.new(name)
+      end
+    end
+  end
+end