Couchdb2 mango query interface

lib/dolly/collection.rb

@@ -56,9 +56,20 @@ def rows= ary
       end
     end
 
+    def doc_rows= ary
+      ary.each do |doc|
+        id = doc.delete '_id'
+        rev = doc.delete '_rev' if doc['_rev']
+        document = (docs_class || doc_class(id)).new doc
+        document.doc = doc.merge({'_id' => id, '_rev' => rev})
+        self << document
+      end
+    end
+
     def load
       parsed = JSON::parse json
-      self.rows = parsed['rows']
+      self.rows = parsed['rows'] if parsed['rows']
+      self.doc_rows = parsed['docs'] if parsed['docs']
     end
 
     def to_json options = {}

lib/dolly/document.rb

@@ -1,6 +1,7 @@
 require "dolly/query"
 require "dolly/property"
 require 'dolly/timestamps'
+require "dolly/mango"
 
 module Dolly
   class Document
@@ -9,7 +10,7 @@ class Document
     extend Dolly::Timestamps
 
     attr_accessor :rows, :doc, :key
-    class_attribute :properties
+    class_attribute :properties, :mango_scopes
     cattr_accessor :timestamps do
       {}
     end
@@ -149,6 +150,27 @@ def self.property *ary
       end
     end
 
+    class << self
+      def mango_scope scope_name, scope
+        self.mango_scopes ||= {}
+        name = scope_name.to_sym
+        self.mango_scopes[name] = ->(query_object, args=nil) { Mango::Scope.new(query_object, scope, args) }
+
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            self.mango_scopes[name].call(Mango::Query.new(self), *args)
+          end
+        end
+      end
+
+      def selector name, *operator, value
+        anonymous_scope = ->{ selector(name, *operator, value) }
+        query_object = Mango::Query.new(self)
+        args = nil
+        Mango::Scope.new query_object, anonymous_scope, args
+      end
+    end
+
     private
     #TODO: create a PropertiesSet service object, to do all this
     def self.write_methods name

lib/dolly/mango.rb

@@ -0,0 +1,10 @@
+require 'dolly/mango/query_validator'
+require 'dolly/mango/selector'
+require 'dolly/mango/query'
+require 'dolly/mango/scope'
+
+module Dolly
+  module Mango
+
+  end
+end

lib/dolly/mango/query.rb

@@ -0,0 +1,38 @@
+module Dolly
+  module Mango
+    class Query
+      include Dolly::Mango::Selector
+
+      FIELDS_KEY   = 'fields'.freeze
+      LIMIT_KEY    = 'limit'.freeze
+      SKIP_KEY     = 'skip'.freeze
+      SORT_KEY     = 'sort'.freeze
+
+      attr_reader :proxy_class, :query
+
+      def initialize proxy_class
+        @proxy_class = proxy_class
+        @query = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
+        query.compare_by_identity
+      end
+
+      def limit value
+        query[LIMIT_KEY] = value
+      end
+
+      def sort name, operator
+        query[SORT_KEY] ||= []
+        query[SORT_KEY] << {name => operator}
+      end
+
+      def fields *fields
+        query[FIELDS_KEY] ||= []
+        query[FIELDS_KEY].push *fields
+      end
+
+      def skip integer
+        query[SKIP_KEY] = integer.to_i
+      end
+    end
+  end
+end

lib/dolly/mango/query_validator.rb

@@ -0,0 +1,52 @@
+module Dolly
+  module Mango
+    class QueryValidator
+
+      def initialize operator, value
+        @operator, @value = operator, value
+      end
+
+      def validate!
+        return if Selector::EQUALITY_OPERATORS.include? operator
+        raise Dolly::BadQueryArguement.new(operator, 'Boolean') if boolean_op?
+        raise Dolly::BadQueryArguement.new(operator, Selector::POSSIBLE_TYPE_VALUES.join(', ')) if type_op?
+        raise Dolly::BadQueryArguement.new(operator, Array) if array_op?
+        raise Dolly::BadQueryArguement.new(operator, Integer) if int_op?
+        raise Dolly::BadQueryArguement.new(operator, '[Divisor, Remainder] Array of Integers') if mod_op?
+        raise Dolly::BadQueryArguement.new(operator, String) if regex_op?
+        raise Dolly::BadQueryArguement.new(operator, Array) if combination_op?
+      end
+
+      private
+      attr_reader :operator, :value
+
+      def boolean_op?
+        operator == Selector::EXISTS_OPERATOR && ![true, false].include?(value)
+      end
+
+      def type_op?
+        operator == Selector::TYPE_OPERATOR && !Selector::POSSIBLE_TYPE_VALUES.include?(value)
+      end
+
+      def array_op?
+        Selector::ARRAY_OPERATORS.include?(operator) && !value.is_a?(Array)
+      end
+
+      def int_op?
+        operator == Selector::SIZE_OPERATOR && !value.is_a?(Integer)
+      end
+
+      def mod_op?
+        operator == Selector::MOD_OPERATOR && (!value.is_a?(Array) || value.count != 2 || value.none? {|el| el.is_a? Integer })
+      end
+
+      def regex_op?
+        operator == Selector::REGEX_OPERATOR && !value.is_a?(String)
+      end
+
+      def combination_op?
+        Selector::COMBINATION_OPERATORS.include?(operator) && !value.is_a?(Array)
+      end
+    end
+  end
+end

lib/dolly/mango/scope.rb

@@ -0,0 +1,33 @@
+module Dolly
+  module Mango
+    class Scope
+      attr_reader :query_object, :scope, :scope_args
+
+      delegate :proxy_class, :query, to: :query_object
+
+      def initialize query_object, scope, scope_args
+        @query_object, @scope, @scope_args = query_object, scope, scope_args
+        evaluate_scope
+      end
+
+      def method_missing(method, *args, &block)
+        if proxy_class.mango_scopes.include?(method)
+          proxy_class.mango_scopes[method].call(query_object, args)
+        elsif query_object.respond_to? method
+          query_object.send(method, *args, &block)
+          return self
+        else
+          resp = proxy_class.database.mango query.to_json
+          collection = Dolly::Collection.new(resp.response.body, proxy_class)
+          collection.send(method, *args, &block)
+        end
+      end
+
+      private
+
+      def evaluate_scope
+        query_object.instance_exec(*scope_args, &scope)
+      end
+    end
+  end
+end

lib/dolly/mango/selector.rb

@@ -0,0 +1,125 @@
+module Dolly
+  module Mango
+    module Selector
+
+      SELECTOR     = 'selector'.freeze
+
+      # Equality Operators
+      EQ_OPERATOR  = '$eq'.freeze
+      NE_OPERATOR  = '$ne'.freeze
+      GT_OPERATOR  = '$gt'.freeze
+      LT_OPERATOR  = '$lt'.freeze
+      GTE_OPERATOR = '$gte'.freeze
+      LTE_OPERATOR = '$lte'.freeze
+
+      EQUALITY_OPERATORS = [ EQ_OPERATOR, NE_OPERATOR, GT_OPERATOR, LT_OPERATOR, GTE_OPERATOR, LTE_OPERATOR ].freeze
+
+      # Object Operators
+      EXISTS_OPERATOR = '$exists'.freeze
+      TYPE_OPERATOR   = '$type'.freeze
+
+      OBJECT_OPERATORS = [EXISTS_OPERATOR, TYPE_OPERATOR].freeze
+
+      # Array Operators
+      IN_OPERATOR  = '$in'.freeze
+      NIN_OPERATOR = '$nin'.freeze
+      SIZE_OPERATOR = '$size'.freeze
+
+      ARRAY_OPERATORS = [IN_OPERATOR, NIN_OPERATOR].freeze
+
+      # Miscellaneous Operators
+      MOD_OPERATOR   = '$mod'.freeze
+      REGEX_OPERATOR = '$regex'.freeze
+
+      MISC_OPERATORS = [MOD_OPERATOR, REGEX_OPERATOR].freeze
+
+      # Combination Operators
+      OR_OPERATOR  = '$or'.freeze
+      NOT_SELECTOR = '$not'.freeze
+      NOR_SELECTOR = '$nor'.freeze
+      AND_OPERATOR = '$and'.freeze
+      ALL_OPERATOR = '$all'.freeze
+      EM_OPERATOR  = '$elemMatch'.freeze
+
+      COMBINATION_OPERATORS = [ OR_OPERATOR, NOT_SELECTOR, NOR_SELECTOR, AND_OPERATOR, ALL_OPERATOR, EM_OPERATOR ].freeze
+
+      POSSIBLE_TYPE_VALUES = %w/null boolean number string array object/.freeze
+
+      ALL_OPERATORS = [ EQUALITY_OPERATORS, OBJECT_OPERATORS, ARRAY_OPERATORS, SIZE_OPERATOR, MISC_OPERATORS, COMBINATION_OPERATORS ].flatten.freeze
+
+      def selector name, *operator, value
+        proxy_operator = operator.last
+        operator_check! proxy_operator
+        operator = operator.count > 1 ? operator : operator.first
+        select_operator_map[operator].call(name, value)
+      end
+
+      private
+
+      def select_operator_map
+        {
+          eq:            ->(name, value) { build_equality_selector name, value, EQ_OPERATOR },
+          ne:            ->(name, value) { build_equality_selector name, value, NE_OPERATOR },
+          gt:            ->(name, value) { build_equality_selector name, value, GT_OPERATOR },
+          gte:           ->(name, value) { build_equality_selector name, value, GTE_OPERATOR },
+          lt:            ->(name, value) { build_equality_selector name, value, LT_OPERATOR },
+          lte:           ->(name, value) { build_equality_selector name, value, LTE_OPERATOR },
+
+          exists:        ->(name, value=true) { build_equality_selector name, value, EXISTS_OPERATOR },
+          type:          ->(name, value) { build_equality_selector name, value, TYPE_OPERATOR },
+
+          in:            ->(name, value) { build_equality_selector name, value, IN_OPERATOR },
+          nin:           ->(name, value) { build_equality_selector name, value, NIN_OPERATOR },
+          size:          ->(name, value) { build_equality_selector name, value, SIZE_OPERATOR },
+
+          mod:           ->(name, value) { build_equality_selector name, value, MOD_OPERATOR },
+          regex:         ->(name, value) { build_equality_selector name, value, REGEX_OPERATOR },
+
+          nor:           ->(name, value) { build_exclusive_selector name, value, NOR_SELECTOR} ,
+          all:           ->(name, value) { build_exclusive_selector name, value, ALL_OPERATOR },
+          and:           ->(name, value) { build_exclusive_selector name, value, AND_OPERATOR },
+          or:            ->(name, value) { build_exclusive_selector name, value, OR_OPERATOR },
+
+          [:em, :gt] =>  ->(name, value) { build_composite_selector name, value, EM_OPERATOR, GT_OPERATOR },
+          [:em, :gte] => ->(name, value) { build_composite_selector name, value, EM_OPERATOR, GTE_OPERATOR },
+          [:em, :lt] =>  ->(name, value) { build_composite_selector name, value, EM_OPERATOR, LT_OPERATOR },
+          [:em, :lte] => ->(name, value) { build_composite_selector name, value, EM_OPERATOR, LTE_OPERATOR },
+          [:em, :or] =>  ->(name, value) { build_composite_selector name, value, EM_OPERATOR, OR_OPERATOR },
+          [:em, :and] => ->(name, value) { build_composite_selector name, value, EM_OPERATOR, AND_OPERATOR },
+
+          [:not, :gt] =>  ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, GT_OPERATOR },
+          [:not, :gte] => ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, GTE_OPERATOR },
+          [:not, :lt] =>  ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, LT_OPERATOR },
+          [:not, :lte] => ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, LTE_OPERATOR },
+          [:not, :or] =>  ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, OR_OPERATOR },
+          [:not, :and] => ->(name, value) { build_composite_selector name, value, NOT_OPERATOR, AND_OPERATOR }
+        }.freeze
+      end
+
+      def build_equality_selector name, value, operator
+        operator_value_type_check!(operator, value)
+        query[SELECTOR][name][operator] = value
+      end
+
+      def build_exclusive_selector name, value, operator
+        operator_value_type_check!(operator, value)
+        query[SELECTOR][operator][name] = value
+      end
+
+      def build_composite_selector name, value, *operators
+        first, second = operators
+        operator_value_type_check!(second, value)
+
+        query[SELECTOR][name][first][second] = value
+      end
+
+      def operator_check! operator
+        raise Dolly::UnrecognizedOperator.new(operator) unless select_operator_map.keys.include? operator
+      end
+
+      def operator_value_type_check! operator, value
+        QueryValidator.new(operator, value).validate!
+      end
+    end
+  end
+end

lib/dolly/query.rb

@@ -51,7 +51,7 @@ def last limit = 1
 
       def build_collection q
         res = database.all_docs(q)
-        Collection.new res.response.body, name_for_class
+        Collection.new res.parsed_response.to_json, name_for_class
       end
 
       def find_with doc, view_name, opts = {}

lib/dolly/request.rb

@@ -7,6 +7,7 @@ class Request
     include HTTParty
     DEFAULT_HOST = 'localhost'
     DEFAULT_PORT = '5984'
+    MANGO_QUERY = '_find'.freeze
 
     attr_accessor :database_name, :host, :port, :bulk_document
 
@@ -44,6 +45,10 @@ def delete resource
       request :delete, full_path(resource), {}
     end
 
+    def mango data
+      request :post, full_path(MANGO_QUERY), {body: data}
+    end
+
     def attach resource, attachment_name, data, headers = {}
       data = StringIO.new(data) if data.is_a?(String)
       request :put, attachment_path(resource, attachment_name), {body: data, headers: headers}
@@ -59,7 +64,7 @@ def uuids opts = {}
 
     def all_docs data = {}
       data =  values_to_json data.merge( include_docs: true )
-      request :get, full_path('_all_docs'), {query: data}
+      request(:get, full_path('_all_docs'), { query: data })
     end
 
     def request method, resource, data = nil

lib/exceptions/dolly.rb

@@ -35,4 +35,22 @@ def to_s
   end
   class DocumentInvalidError < RuntimeError; end
   class MissingPropertyError < RuntimeError; end
+  class BadQueryArguement < RuntimeError
+    def initialize operator, expected_type
+      @operator, @expected_type = operator, expected_type
+    end
+
+    def to_s
+      "The operator #{@operator} only accepts a(n) #{@expected_type}"
+    end
+  end
+  class UnrecognizedOperator < RuntimeError
+    def initialize operator
+      @operator = operator
+    end
+
+    def to_s
+      "The operator #{@operator} is unrecognized"
+    end
+  end
 end