daodalus 0.1.1

data/lib/daodalus/dsl/clause.rb

@@ -0,0 +1,19 @@
+module Daodalus
+  module DSL
+    module Clause
+
+      def to_query
+        query.wheres
+      end
+
+      def to_projection
+        query.selects
+      end
+
+      def to_update
+        query.updates
+      end
+
+    end
+  end
+end

data/lib/daodalus/dsl/matchers.rb

@@ -0,0 +1,87 @@
+module Daodalus
+  module DSL
+    module Matchers
+
+      def eq value
+        add_clause value
+      end
+      alias_method :equals, :eq
+
+      def ne value
+        add_clause '$ne' => value
+      end
+      alias_method :not_equal, :ne
+
+      def lt value
+        add_clause '$lt' => value
+      end
+      alias_method :less_than, :lt
+
+      def gt value
+        add_clause '$gt' => value
+      end
+      alias_method :greater_than, :gt
+
+      def lte value
+        add_clause '$lte' => value
+      end
+      alias_method :less_than_or_equal, :lte
+
+      def gte value
+        add_clause '$gte' => value
+      end
+      alias_method :greater_than_or_equal, :gte
+
+      def in *values
+        add_clause '$in' => values
+      end
+
+      def nin *values
+        add_clause '$nin' => values
+      end
+      alias_method :not_in, :nin
+
+      def all *values
+        add_clause '$all' => values
+      end
+
+      def size value
+        add_clause '$size' => value
+      end
+
+      def exists value=true
+        add_clause '$exists' => value
+      end
+
+      def does_not_exist *values
+        exists false
+      end
+
+      def not
+        define_singleton_method :add_clause do |clause|
+          add_logical_clause field.to_s => { '$not' => clause }
+        end
+        define_singleton_method :eq do |value|
+          add_logical_clause field.to_s => { '$ne' => value}
+        end
+        self
+      end
+
+      def any *clauses
+        add_logical_clause '$or' => clauses.map(&:to_query)
+      end
+      alias_method :or, :any
+
+      def none *clauses
+        add_logical_clause '$nor' => clauses.map(&:to_query)
+      end
+      alias_method :nor, :none
+
+      def elem_match clause
+        add_clause '$elemMatch' => clause.to_query
+      end
+
+    end
+  end
+end
+

data/lib/daodalus/dsl/queries.rb

@@ -0,0 +1,29 @@
+module Daodalus
+  module DSL
+    module Queries
+
+      def find(options = {})
+        options = options.merge(fields: query.selects) if query.has_selects?
+        dao.find(query.wheres, options)
+      end
+
+      def find_one(options = {})
+        options = options.merge(fields: query.selects) if query.has_selects?
+        dao.find_one(query.wheres, options)
+      end
+
+      def where field=nil
+        if field.is_a? Hash
+          Where.new(dao, query.where(field), nil)
+        else
+          Where.new(dao, query, field)
+        end
+      end
+
+      def select *fields
+        Select.new(dao, query, fields)
+      end
+
+    end
+  end
+end

data/lib/daodalus/dsl/query.rb

@@ -0,0 +1,46 @@
+module Daodalus
+  module DSL
+    class Query
+
+      def initialize(wheres={}, selects={}, updates={})
+        @wheres  = wheres
+        @selects = selects
+        @updates = updates
+      end
+      attr_reader :wheres, :updates
+
+      def where clause
+        Query.new(add_where(clause), selects, updates)
+      end
+
+      def update clause
+        Query.new(wheres, selects, updates.merge(clause))
+      end
+
+      def select clause
+        Query.new(wheres, selects.merge(clause), updates)
+      end
+
+      def selects
+        @selects.empty? ? @selects : {'_id' => 0}.merge(@selects)
+      end
+
+      def has_selects?
+        !selects.empty?
+      end
+
+      private
+
+      def add_where clause
+        wheres.merge(clause) do |f, a, b|
+          if a.respond_to?(:merge) && b.respond_to?(:merge)
+            a.merge(b)
+          else
+            raise InvalidQueryError.new("Invalid Query: Cannot merge clauses '#{a}' and '#{b}' for field '#{f}'")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/daodalus/dsl/select.rb

@@ -0,0 +1,43 @@
+module Daodalus
+  module DSL
+    class Select
+      include Clause
+      include Queries
+
+      def initialize(dao, query, fields)
+        @dao   = dao
+        @query = query
+        @fields = fields
+      end
+
+      alias_method :and, :select
+
+      def by_position
+        raise InvalidQueryError, "Too many fields for positional operator: #{fields.inspect}" if fields.size > 1
+        Select.new(dao, @query.select("#{fields.first}.$" => 1), [])
+      end
+      alias_method :positional, :by_position
+
+      def slice skip=false, limit
+        raise InvalidQueryError, "Too many fields for slice operator: #{fields.inspect}" if fields.size > 1
+        if skip
+          Select.new(dao, @query.select(fields.first.to_s => { '$slice' => [skip, limit]}), [])
+        else
+          Select.new(dao, @query.select(fields.first.to_s => { '$slice' => limit}), [])
+        end
+      end
+
+      def elem_match clause
+        Select.new(dao, @query.select(fields.first.to_s => { '$elemMatch' => clause.to_query}), [])
+      end
+
+      private
+
+      def query
+        @query.select(fields.reduce({}) { |acc, f| acc.merge(f.to_s => 1) })
+      end
+
+      attr_reader :dao, :fields
+    end
+  end
+end

data/lib/daodalus/dsl/update.rb

@@ -0,0 +1,86 @@
+module Daodalus
+  module DSL
+    class Update
+      include Clause
+      include Queries
+      include Updates
+
+      def initialize(dao, query)
+        @dao    = dao
+        @query  = query
+      end
+
+      def set(fields)
+        with_clause '$set' => fields
+      end
+
+      def unset(fields)
+        with_clause '$unset' => fields.reduce({}) { |acc, f| acc.merge(f => 1) }
+      end
+
+      def inc(field, amount)
+        with_clause '$inc' => { field => amount }
+      end
+
+      def dec(field, amount)
+        with_clause '$inc' => { field => -amount }
+      end
+
+      def rename(field, value)
+        with_clause '$rename' => { field => value.to_s }
+      end
+
+      def push(field, values)
+        if values.length == 1
+          with_clause '$push' => { field => values.first }
+        else
+          push_all field, values
+        end
+      end
+
+      def push_all(field, values)
+        with_clause '$pushAll' => { field => values }
+      end
+
+      def add_to_set(field, values)
+        if values.length == 1
+          with_clause '$addToSet' => { field => values.first }
+        else
+          add_each_to_set field, values
+        end
+      end
+
+      def add_each_to_set(field, values)
+        with_clause '$addToSet' => { field => { '$each' => values } }
+      end
+
+      def pop_first(field)
+        with_clause '$pop' => { field => -1 }
+      end
+
+      def pop_last(field)
+        with_clause '$pop' => { field => 1 }
+      end
+
+      def pull(field, values)
+        if values.length == 1
+          with_clause '$pull' => { field => values.first }
+        else
+          pull_all field, values
+        end
+      end
+
+      def pull_all(field, values)
+        with_clause '$pullAll' => { field => values }
+      end
+
+      private
+
+      def with_clause clause
+        Update.new(dao, query.update(clause))
+      end
+
+      attr_reader :dao, :query
+    end
+  end
+end

data/lib/daodalus/dsl/updates.rb

@@ -0,0 +1,71 @@
+module Daodalus
+  module DSL
+    module Updates
+
+      def update(options = {})
+        dao.update(query.wheres, query.updates, options)
+      end
+
+      def upsert(options = {})
+        update(options.merge(upsert: true))
+      end
+
+      def find_and_modify(options = {})
+        dao.find_and_modify(options.merge(query: query.wheres, update: query.updates))
+      end
+
+      def set(fields)
+        Update.new(dao, query).set(fields)
+      end
+
+      def unset(*fields)
+        Update.new(dao, query).unset(fields)
+      end
+
+      def inc(field, amount=1)
+        Update.new(dao, query).inc(field, amount)
+      end
+
+      def dec(field, amount=1)
+        Update.new(dao, query).dec(field, amount)
+      end
+
+      def rename(field, value)
+        Update.new(dao, query).rename(field, value)
+      end
+
+      def push(field, *values)
+        Update.new(dao, query).push(field, values)
+      end
+
+      def push_all(field, values)
+        Update.new(dao, query).push_all(field, values)
+      end
+
+      def add_to_set(field, *values)
+        Update.new(dao, query).add_to_set(field, values)
+      end
+
+      def add_each_to_set(field, values)
+        Update.new(dao, query).add_each_to_set(field, values)
+      end
+
+      def pop_first(field)
+        Update.new(dao, query).pop_first(field)
+      end
+
+      def pop_last(field)
+        Update.new(dao, query).pop_last(field)
+      end
+
+      def pull(field, *values)
+        Update.new(dao, query).pull(field, values)
+      end
+
+      def pull_all(field, values)
+        Update.new(dao, query).pull_all(field, values)
+      end
+
+    end
+  end
+end

data/lib/daodalus/dsl/where.rb

@@ -0,0 +1,30 @@
+module Daodalus
+  module DSL
+    class Where
+      include Clause
+      include Updates
+      include Queries
+      include Matchers
+
+      def initialize(dao, query, field)
+        @dao    = dao
+        @query  = query
+        @field = field
+      end
+
+      alias_method :and, :where
+
+      private
+
+      def add_clause clause
+        Where.new(dao, query.where(field.to_s => clause), field)
+      end
+
+      def add_logical_clause clause
+        Where.new(dao, query.where(clause), field)
+      end
+
+      attr_reader :dao, :query, :field
+    end
+  end
+end

data/lib/daodalus/invalid_connection_error.rb

@@ -0,0 +1,7 @@
+module Daodalus
+  class InvalidConnectionError < StandardError
+    def initialize(name)
+      super("Daodalus::InvalidConnectionError - #{name.inspect}")
+    end
+  end
+end

data/lib/daodalus/invalid_query_error.rb

@@ -0,0 +1,4 @@
+module Daodalus
+  class InvalidQueryError < StandardError
+  end
+end

data/spec/lib/daodalus/connection_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Daodalus
+  describe Connection do
+
+    let (:conn) { Mongo::MongoClient.new('localhost', 27017, pool_size: 5) }
+
+    it 'allows connections to be registered and fetched by name' do
+      Daodalus::Connection.register(conn, :animalhouse)
+      Daodalus::Connection.fetch(:animalhouse).should eq conn
+    end
+
+    it 'allows the default connection to be registered and fetched without a name' do
+      Daodalus::Connection.register(conn)
+      Daodalus::Connection.fetch.should eq conn
+    end
+
+    it 'raises an invalid connection error if asked for a non-existent connection' do
+      expect { Daodalus::Connection.fetch(:wrong) }.to raise_error InvalidConnectionError
+    end
+  end
+end