daodalus 0.1.1

data/lib/daodalus.rb

@@ -0,0 +1,29 @@
+require 'mongo'
+require 'optional'
+
+require 'daodalus/connection'
+require 'daodalus/invalid_connection_error'
+require 'daodalus/invalid_query_error'
+
+require 'daodalus/dsl/query'
+require 'daodalus/dsl/clause'
+require 'daodalus/dsl/matchers'
+
+require 'daodalus/dsl/queries'
+require 'daodalus/dsl/updates'
+
+require 'daodalus/dsl/where'
+require 'daodalus/dsl/select'
+require 'daodalus/dsl/update'
+
+require 'daodalus/dsl/aggregations'
+require 'daodalus/dsl/aggregation/match'
+require 'daodalus/dsl/aggregation/group'
+require 'daodalus/dsl/aggregation/project'
+require 'daodalus/dsl/aggregation/limit'
+require 'daodalus/dsl/aggregation/skip'
+require 'daodalus/dsl/aggregation/sort'
+require 'daodalus/dsl/aggregation/unwind'
+
+require 'daodalus/dsl'
+require 'daodalus/dao'

data/lib/daodalus/connection.rb

@@ -0,0 +1,19 @@
+module Daodalus
+
+  module Connection
+    extend self
+
+    def register(connection, name='default')
+      connections[name.to_s] = connection
+    end
+
+    def fetch(name='default')
+      connections.fetch(name.to_s) { raise InvalidConnectionError.new(name) }
+    end
+
+    def connections
+      @connections ||= {}
+    end
+
+  end
+end

data/lib/daodalus/dao.rb

@@ -0,0 +1,41 @@
+require 'delegate'
+
+module Daodalus
+  class DAO
+    include DSL
+    extend Forwardable
+
+    def initialize(db, collection, connection=:default)
+      @db         = db
+      @collection = collection
+      @connection = connection
+    end
+
+    def coll
+      @coll ||= Daodalus::Connection.fetch(connection)[db.to_s][collection.to_s]
+    end
+
+    delegate [
+      :find,
+      :update,
+      :insert,
+      :save,
+      :remove,
+      :count,
+      :aggregate
+    ] => :coll
+
+    def find_one(*args)
+      Option[coll.find_one(*args)]
+    end
+
+    def find_and_modify(*args)
+      Option[coll.find_and_modify(*args)]
+    end
+
+    private
+
+    attr_reader :db, :collection, :connection
+
+  end
+end

data/lib/daodalus/dsl.rb

@@ -0,0 +1,21 @@
+module Daodalus
+  module DSL
+    include Clause
+    include Queries
+    include Updates
+    include Aggregations
+
+    def query
+      Query.new
+    end
+
+    def pipeline
+      []
+    end
+
+    def dao
+      self
+    end
+
+  end
+end

data/lib/daodalus/dsl/aggregation/group.rb

@@ -0,0 +1,88 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Group
+        include Aggregations
+
+        def initialize(dao, aggregations, id, values)
+          @dao          = dao
+          @aggregations = aggregations
+          @id           = id
+          @values       = values
+        end
+
+        def to_aggregation
+          { '$group' => values.merge('_id' => id) }
+        end
+
+        def sum(field)
+          aliased '$sum' => field
+        end
+        alias_method :total, :sum
+
+        def add_to_set(field)
+          aliased '$addToSet' => field
+        end
+        alias_method :distinct, :add_to_set
+
+        def push(field)
+          aliased '$push' => field
+        end
+        alias_method :collect, :push
+
+        def first(field)
+          aliased '$first' => field
+        end
+
+        def last(field)
+          aliased '$last' => field
+        end
+
+        def max(field)
+          aliased '$max' => field
+        end
+
+        def min(field)
+          aliased '$min' => field
+        end
+
+        def avg(field)
+          aliased '$avg' => field
+        end
+        alias_method :average, :avg
+
+        private
+
+        def id
+          case @id
+          when Symbol then @id.to_s
+          when Hash   then @id.reduce({}) {|acc, (a,b)| acc.merge(a.to_s => b.to_s) }
+          else @id
+          end
+        end
+
+        def aliased clause
+          Alias.new do |aka|
+            Group.new(dao, aggregations, id, values.merge(aka => clause))
+          end
+        end
+
+        attr_reader :dao, :aggregations, :values
+
+        class Alias
+          def initialize(&block)
+            @block = block
+          end
+
+          def as(aka)
+            block.call(aka)
+          end
+
+          private
+
+          attr_reader :block
+        end
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/limit.rb

@@ -0,0 +1,23 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Limit
+        include Aggregations
+
+        def initialize(dao, aggregations, limit)
+          @dao          = dao
+          @aggregations = aggregations
+          @limit        = limit
+        end
+
+        def to_aggregation
+          { '$limit' => limit }
+        end
+
+        private
+
+        attr_reader :dao, :aggregations, :limit
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/match.rb

@@ -0,0 +1,35 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Match
+        include Matchers
+        include Aggregations
+
+        def initialize(dao, aggregations, query, field)
+          @dao          = dao
+          @aggregations = aggregations
+          @query        = query
+          @field        = field
+        end
+
+        alias_method :and, :match
+
+        def to_aggregation
+          { '$match' => query.wheres }
+        end
+
+        private
+
+        def add_clause clause
+          Match.new(dao, aggregations, query.where(field.to_s => clause), field)
+        end
+
+        def add_logical_clause clause
+          Match.new(dao, aggregations, query.where(clause), field)
+        end
+
+        attr_reader :dao, :aggregations, :query, :field
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/project.rb

@@ -0,0 +1,79 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Project
+        include Aggregations
+
+        def initialize(dao, aggregations, projection = {}, keys)
+          @dao          = dao
+          @aggregations = aggregations
+          @projection   = projection
+          @keys         = keys
+        end
+
+        def to_aggregation
+          { '$project' => { '_id' => 0 }.merge(projection) }
+        end
+
+        def project(*keys)
+          Project.new(dao, aggregations, projection, keys)
+        end
+        alias_method :and, :project
+
+        def as(aka)
+          Project.new(dao, aggregations, @projection, [aka => keys.first])
+        end
+
+        def eq(*others)
+          Project.new(dao, aggregations, @projection, ['$eq' => keys + others])
+        end
+
+        def add(*others)
+          Project.new(dao, aggregations, @projection, ['$add' => keys + others])
+        end
+        alias_method :plus, :add
+
+        def divide(other)
+          Project.new(dao, aggregations, @projection, ['$divide' => keys + [other]])
+        end
+        alias_method :divided_by, :divide
+
+        def multiply(other)
+          Project.new(dao, aggregations, @projection, ['$multiply' => keys + [other]])
+        end
+        alias_method :multiplied_by, :multiply
+
+        def subtract(other)
+          Project.new(dao, aggregations, @projection, ['$subtract' => keys + [other]])
+        end
+        alias_method :minus, :subtract
+
+        def mod(other)
+          Project.new(dao, aggregations, @projection, ['$mod' => keys + [other]])
+        end
+
+        protected
+
+        def projection
+          keys.reduce(@projection) do |acc, k|
+            case k
+            when Hash then acc.merge(hashify k)
+            else acc.merge(k.to_s => 1)
+            end
+          end
+        end
+
+        private
+
+        def hashify(key)
+          case key
+          when Hash then key.reduce({}) { |acc, (k,v)| acc.merge(k => hashify(v)) }
+          when Project then hashify key.projection
+          else key
+          end
+        end
+        attr_reader :dao, :aggregations, :keys
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/skip.rb

@@ -0,0 +1,23 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Skip
+        include Aggregations
+
+        def initialize(dao, aggregations, skip)
+          @dao          = dao
+          @aggregations = aggregations
+          @skip         = skip
+        end
+
+        def to_aggregation
+          { '$skip' => skip }
+        end
+
+        private
+
+        attr_reader :dao, :aggregations, :skip
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/sort.rb

@@ -0,0 +1,29 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Sort
+        include Aggregations
+
+        def initialize(dao, aggregations, keys)
+          @dao          = dao
+          @aggregations = aggregations
+          @keys         = keys
+        end
+
+        def to_aggregation
+          { '$sort' => keys }
+        end
+
+        private
+
+        def keys
+          @keys.reduce({}) do |acc, (k,v)|
+            acc.merge(k => ([-1, :desc, 'desc'].include?(v) ? -1 : 1))
+          end
+        end
+
+        attr_reader :dao, :aggregations
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregation/unwind.rb

@@ -0,0 +1,23 @@
+module Daodalus
+  module DSL
+    module Aggregation
+      class Unwind
+        include Aggregations
+
+        def initialize(dao, aggregations, field)
+          @dao          = dao
+          @aggregations = aggregations
+          @field        = field
+        end
+
+        def to_aggregation
+          { '$unwind' => "$#{field}" }
+        end
+
+        private
+
+        attr_reader :dao, :aggregations, :field
+      end
+    end
+  end
+end

data/lib/daodalus/dsl/aggregations.rb

@@ -0,0 +1,44 @@
+module Daodalus
+  module DSL
+    module Aggregations
+
+      def aggregate
+        dao.aggregate(pipeline)
+      end
+
+      def match(field=nil)
+        Aggregation::Match.new(dao, pipeline, Query.new, field)
+      end
+
+      def group(keys)
+        Aggregation::Group.new(dao, pipeline, keys, {})
+      end
+      alias_method :group_by, :group
+
+      def project(*keys)
+        Aggregation::Project.new(dao, pipeline, keys)
+      end
+
+      def limit(limit)
+        Aggregation::Limit.new(dao, pipeline, limit)
+      end
+
+      def skip(skip)
+        Aggregation::Skip.new(dao, pipeline, skip)
+      end
+
+      def sort(sort)
+        Aggregation::Sort.new(dao, pipeline, sort)
+      end
+
+      def unwind(field)
+        Aggregation::Unwind.new(dao, pipeline, field)
+      end
+
+      def pipeline
+        aggregations + [to_aggregation]
+      end
+
+    end
+  end
+end