moped 0.0.0.beta → 1.0.0.alpha

data/lib/moped/collection.rb

@@ -0,0 +1,67 @@
+module Moped
+
+  # The class for interacting with a MongoDB collection.
+  #
+  # @example
+  #   users = session[:users] # => <Moped::Collection ...>
+  #   users.drop
+  #   users.insert(name: "John")
+  #   users.find.to_a # => [{ name: "John" }]
+  class Collection
+
+    # @return [Database] the database this collection belongs to
+    attr_reader :database
+
+    # @return [String, Symbol] the collection's name
+    attr_reader :name
+
+    # @param [Database] database the database this collection belongs to
+    # @param [String, Symbol] name the collection's name
+    def initialize(database, name)
+      @database = database
+      @name     = name
+    end
+
+    # Access information about this collection's indexes.
+    #
+    # @return [Indexes]
+    def indexes
+      Indexes.new(database, name)
+    end
+
+    # Drop the collection.
+    def drop
+      database.command drop: name
+    end
+
+    # Build a query for this collection.
+    #
+    # @param [Hash] selector the selector
+    # @return [Moped::Query]
+    def find(selector = {})
+      Query.new self, selector
+    end
+    alias where find
+
+    # Insert one or more documents into the collection.
+    #
+    # @overload insert(document)
+    #   @example
+    #     db[:people].insert(name: "John")
+    #   @param [Hash] document the document to insert
+    #
+    # @overload insert(documents)
+    #   @example
+    #     db[:people].insert([{name: "John"}, {name: "Joe"}])
+    #   @param [Array<Hash>] documents the documents to insert
+    def insert(documents)
+      documents = [documents] unless documents.is_a? Array
+      insert = Protocol::Insert.new(database.name, name, documents)
+
+      database.session.with(consistency: :strong) do |session|
+        session.execute insert
+      end
+
+    end
+  end
+end

data/lib/moped/cursor.rb

@@ -0,0 +1,60 @@
+module Moped
+
+  # @api private
+  class Cursor
+    attr_reader :session
+
+    attr_reader :query_op
+    attr_reader :get_more_op
+    attr_reader :kill_cursor_op
+
+    def initialize(session, query_operation)
+      @session = session
+      @query_op = query_operation.dup
+
+      @get_more_op = Protocol::GetMore.new(
+        @query_op.database,
+        @query_op.collection,
+        0,
+        @query_op.limit
+      )
+
+      @kill_cursor_op = Protocol::KillCursors.new([0])
+    end
+
+    def each
+      documents = query @query_op
+      documents.each { |doc| yield doc }
+
+      while more?
+        return kill if limited? && @get_more_op.limit <= 0
+
+        documents = query @get_more_op
+        documents.each { |doc| yield doc }
+      end
+    end
+
+    def query(operation)
+      reply = session.query operation
+
+      @get_more_op.limit -= reply.count if limited?
+      @get_more_op.cursor_id = reply.cursor_id
+      @kill_cursor_op.cursor_ids = [reply.cursor_id]
+
+      reply.documents
+    end
+
+    def limited?
+      @query_op.limit > 0
+    end
+
+    def more?
+      @get_more_op.cursor_id != 0
+    end
+
+    def kill
+      session.execute kill_cursor_op
+    end
+  end
+
+end

data/lib/moped/database.rb

@@ -0,0 +1,76 @@
+module Moped
+
+  # The class for interacting with a MongoDB database. One only interacts with
+  # this class indirectly through a session.
+  #
+  # @example
+  #   session.use :moped
+  #   session.drop
+  #   session[:users].insert(name: "John")
+  #
+  # @example
+  #   session.with(database: :moped) do |moped|
+  #     moped[:users].drop
+  #   end
+  class Database
+
+    # @return [Session] the database's session
+    attr_reader :session
+
+    # @return [String, Symbol] the database's name
+    attr_reader :name
+
+    # @param [Session] session the session
+    # @param [String, Symbol] name the database's name
+    def initialize(session, name)
+      @session = session
+      @name = name
+    end
+
+    # Drop the database.
+    def drop
+      command dropDatabase: 1
+    end
+
+    # Log in with +username+ and +password+ on the current database.
+    #
+    # @param [String] username the username
+    # @param [String] password the password
+    def login(username, password)
+      session.cluster.login(name, username, password)
+    end
+
+    # Log out from the current database.
+    def logout
+      session.cluster.logout(name)
+    end
+
+    # Run +command+ on the database.
+    #
+    # @example
+    #   db.command(ismaster: 1)
+    #   # => { "master" => true, hosts: [] }
+    #
+    # @param [Hash] command the command to run
+    # @return [Hash] the result of the command
+    def command(command)
+      operation = Protocol::Command.new(name, command)
+
+      result = session.with(consistency: :strong) do |session|
+        session.simple_query(operation)
+      end
+
+      raise Errors::OperationFailure.new(
+        operation, result
+      ) unless result["ok"] == 1.0
+
+      result
+    end
+
+    # @param [Symbol, String] collection the collection name
+    # @return [Moped::Collection] an instance of +collection+
+    def [](collection)
+      Collection.new(self, collection)
+    end
+  end
+end

data/lib/moped/errors.rb

@@ -0,0 +1,61 @@
+module Moped
+
+  # The namespace for all errors generated by Moped.
+  module Errors
+
+    # Mongo's exceptions are sparsely documented, but this is the most accurate
+    # source of information on error codes.
+    ERROR_REFERENCE = "https://github.com/mongodb/mongo/blob/master/docs/errors.md"
+
+    # Generic error class for exceptions related to connection failures.
+    class ConnectionFailure < StandardError; end
+
+    # Generic error class for exceptions generated on the remote MongoDB
+    # server.
+    class MongoError < StandardError; end
+
+    # Exception class for exceptions generated as a direct result of an
+    # operation, such as a failed insert or an invalid command.
+    class OperationFailure < MongoError
+
+      # @return the command that generated the error
+      attr_reader :command
+
+      # @return [Hash] the details about the error
+      attr_reader :details
+
+      # Create a new operation failure exception.
+      #
+      # @param command the command that generated the error
+      # @param [Hash] details the details about the error
+      def initialize(command, details)
+        @command = command
+        @details = details
+
+        super build_message
+      end
+
+      private
+
+      def build_message
+        "The operation: #{command.inspect}\n#{error_message}"
+      end
+
+      def error_message
+        err = details["err"] || details["errmsg"] || details["$err"]
+
+        if code = details["code"]
+          "failed with error #{code}: #{err.inspect}\n\n" <<
+            "See #{ERROR_REFERENCE}\nfor details about this error."
+        else
+          "failed with error #{err.inspect}"
+        end
+      end
+    end
+
+    # A special kind of OperationFailure, raised when Mongo sets the
+    # :query_failure flag on a query response.
+    class QueryFailure < OperationFailure; end
+
+  end
+end

data/lib/moped/indexes.rb

@@ -0,0 +1,93 @@
+module Moped
+  class Indexes
+    include Enumerable
+
+    private
+
+    attr_reader :database
+    attr_reader :collection_name
+    attr_reader :namespace
+
+    def initialize(database, collection_name)
+      @database = database
+      @collection_name = collection_name
+      @namespace = "#{database.name}.#{collection_name}"
+    end
+
+    public
+
+    # Retrive an index by its definition.
+    #
+    # @param [Hash] key an index key definition
+    # @return [Hash, nil] the index with the provided key, or nil.
+    #
+    # @example
+    #   session[:users].indexes[id: 1]
+    #   # => {"v"=>1, "key"=>{"_id"=>1}, "ns"=>"moped_test.users", "name"=>"_id_" }
+    def [](key)
+      database[:"system.indexes"].find(ns: namespace, key: key).one
+    end
+
+    # Create an index unless it already exists.
+    #
+    # @param [Hash] key the index spec
+    # @param [Hash] options the options for the index.
+    # @see http://www.mongodb.org/display/DOCS/Indexes#Indexes-CreationOptions
+    #
+    # @example Without options
+    #   session[:users].indexes.create(name: 1)
+    #   session[:users].indexes[name: 1]
+    #   # => {"v"=>1, "key"=>{"name"=>1}, "ns"=>"moped_test.users", "name"=>"name_1" }
+    #
+    # @example With options
+    #   session[:users].indexes.create(
+    #     { location: "2d", name: 1 },
+    #     { unique: true, dropDups: true }
+    #   )
+    #   session[:users][location: "2d", name: 1]
+    #   {"v"=>1,
+    #     "key"=>{"location"=>"2d", "name"=>1},
+    #     "unique"=>true,
+    #     "ns"=>"moped_test.users",
+    #     "dropDups"=>true,
+    #     "name"=>"location_2d_name_1"}
+    def create(key, options = {})
+      spec = options.merge(ns: namespace, key: key)
+      spec[:name] ||= key.to_a.join("_")
+
+      database[:"system.indexes"].insert(spec)
+    end
+
+    # Drop an index, or all indexes.
+    #
+    # @param [Hash] key the index's key
+    # @return [Boolean] whether the indexes were dropped.
+    #
+    # @example Drop all indexes
+    #   session[:users].indexes.count # => 3
+    #   # Does not drop the _id index
+    #   session[:users].indexes.drop
+    #   session[:users].indexes.count # => 1
+    #
+    # @example Drop a particular index
+    #   session[:users].indexes.drop(name: 1)
+    #   session[:users].indexes[name: 1] # => nil
+    def drop(key = nil)
+      if key
+        index = self[key] or return false
+        name = index["name"]
+      else
+        name = "*"
+      end
+
+      result = database.command deleteIndexes: collection_name, index: name
+      result["ok"] == 1
+    end
+
+    # @yield [Hash] each index for the collection.
+    def each(&block)
+      database[:"system.indexes"].find(ns: namespace).each(&block)
+    end
+
+  end
+end

data/lib/moped/logging.rb

@@ -0,0 +1,25 @@
+module Moped
+  module Logging
+    def logger
+      return @logger if defined?(@logger)
+
+      @logger = rails_logger || default_logger
+    end
+
+    def rails_logger
+      defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+    end
+
+    def default_logger
+      Logger.new(STDOUT).tap do |logger|
+        logger.level = Logger::INFO
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+
+  extend Logging
+end

data/lib/moped/protocol.rb

@@ -0,0 +1,20 @@
+module Moped #:nodoc:
+
+  # The +Moped::Protocol+ namespace contains convenience classes for
+  # building all of the possible messages defined in the Mongo Wire Protocol.
+  module Protocol
+  end
+end
+
+require "moped/protocol/message"
+
+require "moped/protocol/delete"
+require "moped/protocol/get_more"
+require "moped/protocol/insert"
+require "moped/protocol/kill_cursors"
+require "moped/protocol/query"
+require "moped/protocol/reply"
+require "moped/protocol/update"
+
+require "moped/protocol/command"
+require "moped/protocol/commands"

data/lib/moped/protocol/command.rb

@@ -0,0 +1,27 @@
+module Moped
+  module Protocol
+
+    # This is a convenience class on top of +Query+ for quickly creating a
+    # command.
+    #
+    # @example
+    #   command = Moped::Protocol::Command.new :moped, ismaster: 1
+    #   socket.write command.serialize
+    class Command < Query
+
+      # @param [String, Symbol] database the database to run this command on
+      # @param [Hash] command the command to run
+      def initialize(database, command)
+        super database, :$cmd, command, limit: -1
+      end
+
+      def log_inspect
+        type = "COMMAND"
+
+        "%-12s database=%s command=%s" % [type, database, selector.inspect]
+      end
+
+    end
+
+  end
+end

data/lib/moped/protocol/commands.rb

@@ -0,0 +1,11 @@
+module Moped
+  module Protocol
+
+    # The +Moped::Protocol::Commands+ namespace contains classes for
+    # specific commands, such as authentication, to execute on a database.
+    module Commands
+    end
+  end
+end
+
+require "moped/protocol/commands/authenticate"