dolly 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c26d50611f8efd7f5cd7b973256ddb6d885a747a
-  data.tar.gz: 4c16a1b2b21b55eeba0a9b7c0307dce20af3be90
+SHA256:
+  metadata.gz: 52fcc7a3f0888239aaff1a6398a81112d031722db14d3070d83d574179414197
+  data.tar.gz: 20d5efb134448842c4c547d85f0f395993fdd8817898e7b174e3e5f5714a7022
 SHA512:
-  metadata.gz: a4a534952347905e024d8da5eec35a31220305edb10528e2d8e30608691ab42143a09c08a005f0121c6acda6a7f6c53320907eb9c81f4b821966d1980c6040d8
-  data.tar.gz: b4f1d1f5994aa3d963d2fe77f2c8e4b67e4d657c66a4da5548924630da64d28a70f0902b9bd503c08c4a982a47a34e188a0468ee2559eab8a0c1599ede6881c1
+  metadata.gz: f684874eaa87448a0ae67fddf5df98f3e86c5c6a53f8fb7b75e1331d16d63f07e6ef8eb2db17e461609433ccaf770a1c3a3c27b1551b5cf7c823f2d010005075
+  data.tar.gz: f44fa8ea168a1d6ca31042c4eed5b8cf0fdb1fd11dfcc5fb76e177598cce96512e6cca8a842e6c646fa4f65f8e4e0ea9759379ad73954c42fb1694c9803d42c3

data/README.md

@@ -33,3 +33,46 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dolly3.
+
+
+## Migrating from couch 1.x to 2.x
+
+[Official docs](https://docs.couchdb.org/en/2.3.1/install/index.html)
+
+
+You will need to uninstall the couchdb service with brew
+
+`brew services stop couchdb`
+`brew services uninstall couchdb`
+
+Download the application from the following source
+
+http://couchdb.apache.org/#download
+
+launch fauxton and check your installation
+
+Copy [this file](https://github.com/apache/couchdb/blob/master/rel/overlay/bin/couchup) into your filesystem
+
+
+make it executable
+
+`chmod +x couchup.py`
+
+and run it
+
+`./couchup.py -h`
+
+You might need to install python 3 and pip3 and the following libs
+
+`pip3 install requests progressbar2`
+
+move your .couch files into the specified `database_dir` in your [fauxton config](http://127.0.0.1:5984/_utils/#_config/couchdb@localhost)
+
+
+```
+$ ./couchup list           # Shows your unmigrated 1.x databases
+$ ./couchup replicate -a   # Replicates your 1.x DBs to 2.x
+$ ./couchup rebuild -a     # Optional; starts rebuilding your views
+$ ./couchup delete -a      # Deletes your 1.x DBs (careful!)
+$ ./couchup list           # Should show no remaining databases!
+```

data/lib/dolly.rb

@@ -1,5 +1,6 @@
 require "dolly/version"
 require "dolly/document"
+require 'dolly/mango_index'
 require 'railties/railtie' if defined?(Rails)
 
 module Dolly

data/lib/dolly/bulk_document.rb

@@ -80,7 +80,7 @@ module Dolly
     end
 
     def response_error(item)
-      BulkError.new(error: 'Document saved but not local rev updated.', reason: "Document with id #{doc['id']} on bulk doc was not found in payload.", obj: nil)
+      BulkError.new(error: 'Document saved but not local rev updated.', reason: "Document with id #{item} on bulk doc was not found in payload.", obj: nil)
     end
   end
 end

data/lib/dolly/collection.rb

@@ -1,12 +1,12 @@
 module Dolly
   class Collection < DelegateClass(Array)
-    attr_reader :info
+    attr_reader :options
 
-    def initialize(rows: [], **info)
-      @info = info
+    def initialize(rows: [], options: {})
+      @options = options
       #TODO: We should raise an exception if one of the
       #      requested documents is missing
-      super rows.map(&collect_docs).compact
+      super rows[:rows].map(&collect_docs).compact
     end
 
     def first_or_all(forced_first = false)
@@ -23,13 +23,23 @@ module Dolly
     def collect_docs
       lambda do |row|
         next unless collectable_row?(row)
-        klass = Object.const_get doc_type(row[:id])
+        klass = Object.const_get(doc_model(row))
         klass.from_doc(row[:doc])
       end
     end
 
-    def doc_type(key)
-      key.match(%r{^([^/]+)/})[1].split('_').collect(&:capitalize).join
+    def doc_model(doc)
+      options[:doc_type] || constantize_key(doc[:doc_type]) || constantize_key(doc_type_for(doc[:id]))
+    end
+
+    def doc_type_for(key)
+      return false if key.nil?
+      key.match(%r{^([^/]+)/})[1]
+    end
+
+    def constantize_key(key)
+      return false if key.nil?
+      key.split('_').collect(&:capitalize).join
     end
 
     def collectable_row?(row)

data/lib/dolly/connection.rb

@@ -12,6 +12,7 @@ module Dolly
     attr_reader :db, :app_env
 
     DEFAULT_HEADER = { 'Content-Type' => 'application/json' }
+    SECURE_PROTOCOL = 'https'
 
     using StringRefinements
 
@@ -33,8 +34,10 @@ module Dolly
       request :put, resource.cgi_escape, data
     end
 
-    def delete resource, rev
-      request :delete, resource.cgi_escape, query: { rev: rev }
+    def delete resource, rev = nil, escape: true
+      query = { query: { rev: rev } } if rev
+      resource = resource.cgi_escape if escape
+      request :delete, resource, query
     end
 
     def view resource, opts
@@ -58,28 +61,35 @@ module Dolly
     end
 
     def request(method, resource, data = {})
-      headers  = Dolly::HeaderRequest.new data.delete(:headers)
-      uri      = build_uri(resource, data.delete(:query))
+      headers  = Dolly::HeaderRequest.new data&.delete(:headers)
+      uri      = build_uri(resource, data&.delete(:query))
       klass    = request_method(method)
       req      = klass.new(uri, headers)
       req.body = format_data(data, headers.json?)
       response = start_request(req)
 
-      response_format(response)
+      response_format(response, method)
     end
 
     private
 
     def start_request(req)
-      Net::HTTP.start(req.uri.hostname, req.uri.port) do |http|
-        req.basic_auth env['username'], env['password'] if env['username'].present?
-        http.request(req)
-      end
+      req.basic_auth env['username'], env['password'] if env['username']&.present?
+
+      http = Net::HTTP.new(req.uri.host, req.uri.port)
+      http.use_ssl = secure?
+
+      http.request(req)
+    end
+
+    def secure?
+      env['protocol'] == SECURE_PROTOCOL
     end
 
-    def response_format(res)
+    def response_format(res, method)
       raise Dolly::ResourceNotFound if res.code.to_i == 404
       raise Dolly::ServerError.new(res.body) if (400..600).include? res.code.to_i
+      return res if method == :head
       Oj.load(res.body, symbol_keys: true)
     end
 

data/lib/dolly/document.rb

@@ -1,9 +1,13 @@
+require 'dolly/mango'
+require 'dolly/mango_index'
 require 'dolly/query'
+require 'dolly/view_query'
 require 'dolly/connection'
 require 'dolly/request'
 require 'dolly/depracated_database'
 require 'dolly/document_state'
 require 'dolly/properties'
+require 'dolly/document_type'
 require 'dolly/identity_properties'
 require 'dolly/attachment'
 require 'dolly/property_manager'
@@ -15,11 +19,15 @@ require 'refinements/string_refinements'
 
 module Dolly
   class Document
+    extend Mango
     extend Query
+    extend ViewQuery
     extend Request
     extend DepracatedDatabase
     extend Properties
     extend DocumentCreation
+
+    include DocumentType
     include PropertyManager
     include Timestamp
     include DocumentState
@@ -30,7 +38,8 @@ module Dolly
 
     attr_writer :doc
 
-    def initialize attributes = {}
+    def initialize(attributes = {})
+      init_ancestor_properties
       properties.each(&build_property(attributes))
     end
 
@@ -39,5 +48,16 @@ module Dolly
     def doc
       @doc ||= {}
     end
+
+    def init_ancestor_properties
+      self.class.ancestors.map do |ancestor|
+        begin
+          ancestor.properties.entries.each do |property|
+            properties << property
+          end
+        rescue NoMethodError => e
+        end
+      end
+    end
   end
 end

data/lib/dolly/document_state.rb

@@ -6,6 +6,7 @@ module Dolly
 
     def save(options = {})
       return false unless options[:validate] == false || valid?
+      set_type if typed? && type.nil?
       write_timestamps(persisted?)
       after_save(connection.put(id, doc))
     end

data/lib/dolly/document_type.rb

@@ -13,8 +13,8 @@ module Dolly
       "#{name_paramitized}/#{key}"
     end
 
-    def base_id(id)
-      id.sub(%r{^#{name_paramitized}/}, '')
+    def base_id
+      self.id.sub(%r{^#{name_paramitized}/}, '')
     end
 
     def name_paramitized
@@ -24,5 +24,24 @@ module Dolly
     def class_name
       is_a?(Class) ? name : self.class.name
     end
+
+    def typed?
+      respond_to?(:type)
+    end
+
+    def set_type
+      return unless typed?
+      write_attribute(:type, name_paramitized)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def typed_model
+        property :type, class_name: String
+      end
+    end
   end
 end

data/lib/dolly/exceptions.rb

@@ -15,6 +15,17 @@ module Dolly
     end
   end
 
+  class InvalidMangoOperatorError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "Invalid Mango operator: #{@msg.inspect}"
+    end
+  end
+
+  class IndexNotFoundError < RuntimeError; end
   class InvalidConfigFileError < RuntimeError; end
   class InvalidProperty < RuntimeError; end
   class DocumentInvalidError < RuntimeError; end

data/lib/dolly/mango.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'refinements/hash_refinements'
+
+module Dolly
+  module Mango
+    using HashRefinements
+
+    SELECTOR_SYMBOL = '$'
+
+    COMBINATION_OPERATORS = %I[
+      and
+      or
+      not
+      nor
+      all
+      elemMatch
+      allMath
+    ].freeze
+
+    CONDITION_OPERATORS = %I[
+      lt
+      lte
+      eq
+      ne
+      gte
+      gt
+      exists
+      in
+      nin
+      size
+      mod
+      regex
+    ].freeze
+
+    TYPE_OPERATOR = %I[
+      type
+      $type
+    ]
+
+    ALL_OPERATORS = COMBINATION_OPERATORS + CONDITION_OPERATORS
+
+    DESIGN = '_find'
+
+    def find_by(query, opts = {})
+      build_model_from_doc(find_doc_by(query, opts))
+    end
+
+    def find_doc_by(query, opts = {})
+      raise Dolly::IndexNotFoundError unless index_exists?(query)
+      opts.merge!(limit: 1)
+      perform_query(build_query(query, opts))[:docs].first
+    end
+
+    def where(query, opts = {})
+      docs_where(query, opts).map do |doc|
+        build_model_from_doc(doc)
+      end
+    end
+
+    def docs_where(query, opts = {})
+      raise Dolly::IndexNotFoundError unless index_exists?(query)
+      perform_query(build_query(query, opts))[:docs]
+    end
+
+    private
+
+    def build_model_from_doc(doc)
+      return nil if doc.nil?
+      new(doc.slice(*all_property_keys))
+    end
+
+    def perform_query(structured_query)
+      connection.post(DESIGN, structured_query)
+    end
+
+    def build_query(query, opts)
+      { 'selector' => build_selectors(query) }.merge(opts)
+    end
+
+    def build_selectors(query)
+      query.deep_transform_keys do |key|
+        next build_key(key) if is_operator?(key)
+        next key if is_type_operator?(key)
+        raise Dolly::InvalidMangoOperatorError.new(key) unless has_property?(key)
+        key
+      end
+    end
+
+    def build_key(key)
+      "#{SELECTOR_SYMBOL}#{key}"
+    end
+
+    def is_operator?(key)
+      ALL_OPERATORS.include?(key)
+    end
+
+    def index_exists?(query)
+      Dolly::MangoIndex.find_by_fields(fetch_fields(query))
+    end
+
+    def fetch_fields(query)
+      deep_keys(query).reject do |key|
+        is_operator?(key) || is_type_operator?(key)
+      end
+    end
+
+    def has_property?(key)
+      self.all_property_keys.include?(key)
+    end
+
+    def is_type_operator?(key)
+      TYPE_OPERATOR.include?(key.to_sym)
+    end
+
+    def deep_keys(obj)
+      case obj
+      when Hash then obj.keys + obj.values.flat_map { |v| deep_keys(v) }
+      when Array then obj.flat_map { |i| deep_keys(i) }
+      else []
+      end
+    end
+  end
+end

data/lib/dolly/mango_index.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'dolly/document'
+
+module Dolly
+  class MangoIndex
+    class << self
+      extend Forwardable
+
+      ALL_DOCS = '_all_docs'
+      DESIGN = '_index'
+      ROWS_KEY = :rows
+      DESIGN_PREFIX = '_design/'
+
+      def_delegators :connection, :get, :post
+
+      def all
+        get(DESIGN)[:indexes]
+      end
+
+      def create(name, fields, type = 'json')
+        post(DESIGN, build_index_structure(name, fields, type))
+      end
+
+      def find_by_fields(fields)
+        rows = get(ALL_DOCS, key: key_from_fields(fields))[ROWS_KEY]
+        rows && rows.any?
+      end
+
+      def delete_all
+        all.each do |index_doc|
+          next if index_doc[:ddoc].nil?
+          delete(index_doc)
+        end
+      end
+
+      def delete(index_doc)
+        resource = "#{DESIGN}/#{index_doc[:ddoc]}/json/#{index_doc[:name]}"
+        connection.delete(resource, escape: false)
+      end
+
+      private
+
+      def connection
+        @connection ||= Dolly::Document.connection
+      end
+
+      def build_index_structure(name, fields, type)
+        {
+          ddoc: key_from_fields(fields).gsub(DESIGN_PREFIX, ''),
+          index: {
+            fields: fields
+          },
+          name: name,
+          type: type
+        }
+      end
+
+      def key_from_fields(fields)
+        "#{DESIGN_PREFIX}index_#{fields.join('_')}"
+      end
+    end
+  end
+end

data/lib/dolly/properties.rb

@@ -7,6 +7,7 @@ module Dolly
 
     def property *opts, class_name: nil, default: nil
       opts.each do |opt|
+
         properties << (prop = Property.new(opt, class_name, default))
         send(:attr_reader, opt)
 
@@ -20,8 +21,12 @@ module Dolly
       @properties ||= PropertySet.new
     end
 
+    def all_property_keys
+      properties.map(&:key) + SPECIAL_KEYS
+    end
+
     def property_keys
-      properties.map(&:key) - SPECIAL_KEYS
+      all_property_keys - SPECIAL_KEYS
     end
 
     def property_clean_doc(doc)

data/lib/dolly/property_set.rb

@@ -4,6 +4,11 @@ module Dolly
       keys.include?(key)
     end
 
+    def <<(property)
+      return if include?(property.key)
+      super(property)
+    end
+
     def [](key)
       return detect {|property| property.key == key } if key.is_a?(Symbol)
       super

data/lib/dolly/query.rb

@@ -1,14 +1,17 @@
 require 'dolly/collection'
 require 'dolly/query_arguments'
 require 'dolly/document_type'
+require 'refinements/string_refinements'
 
 module Dolly
   module Query
     include QueryArguments
     include DocumentType
 
+    using StringRefinements
+
     def find *keys
-      query_hash = { keys: namespace_keys(keys) }
+      query_hash = { keys: namespace_keys(keys).map { |k| k.cgi_escape } }
 
       build_collection(query_hash).first_or_all&.itself ||
         raise(Dolly::ResourceNotFound)
@@ -38,16 +41,11 @@ module Dolly
       opts          = opts.each_with_object({}) { |(k, v), h| h[k] = escape_value(v) }
       query_results = raw_view(doc, view_name, opts)
 
-      Collection.new(query_results).first_or_all
-    end
-
-    def raw_view doc, view_name, opts = {}
-      design = "_design/#{doc}/_view/#{view_name}"
-      connection.view(design, opts)
+      Collection.new({ rows: query_results, options: {} }).first_or_all
     end
 
     def build_collection(query)
-      Collection.new(connection.get('_all_docs', query.merge(include_docs: true)))
+      Collection.new({ rows: connection.get('_all_docs', query.merge(include_docs: true)), options: { doc_type: self.class_name }})
     end
 
     def bulk_document

data/lib/dolly/request.rb

@@ -1,7 +1,7 @@
 module Dolly
   module Request
     def set_namespace name
-      @namspace = name
+      @namespace = name
     end
 
     def set_app_env env

data/lib/dolly/version.rb

@@ -1,3 +1,3 @@
 module Dolly
-  VERSION = "3.0.0"
+  VERSION = "3.0.1"
 end

data/lib/dolly/view_query.rb

@@ -0,0 +1,14 @@
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module ViewQuery
+    def raw_view(doc, view_name, opts = {})
+      design = "_design/#{doc}/_view/#{view_name}"
+      connection.view(design, opts)
+    end
+
+    def view_value(doc, view_name, opts = {})
+      raw_view(doc, view_name, opts)[:rows].flat_map { |result| result[:value] }
+    end
+  end
+end

data/lib/refinements/hash_refinements.rb

@@ -0,0 +1,27 @@
+module HashRefinements
+  refine Hash do
+    # File activesupport/lib/active_support/core_ext/hash/keys.rb, line 82
+    def deep_transform_keys(&block)
+      _deep_transform_keys_in_object(self, &block)
+    end
+
+    def slice(*keys)
+      keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+    end
+
+    private
+
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map { |e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/tasks/db.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :db do
   desc "Will create if missing database and add default views"
   task setup: :environment do
@@ -40,7 +42,7 @@ namespace :db do
       begin
         hash_doc = Dolly::Document.connection.request(:get, view_doc["_id"])
 
-        rev = hash_doc.delete('_rev')
+        rev = hash_doc.delete(:_rev)
 
         if hash_doc == view_doc
           puts 'everything up to date'
@@ -59,5 +61,18 @@ namespace :db do
     end
   end
 
+  namespace :index do
+    desc 'Creates indexes for mango querys located in db/indexes/*.json'
+    task create: :environment do
+      indexes_dir = Rails.root.join('db', 'indexes')
+      files = Dir.glob File.join(indexes_dir, '**', '*.json')
+
+      files.each do |file|
+        index_data = JSON.parse(File.read(file))
+        puts "Creating index: #{index_data["name"]}"
+        puts Dolly::MangoIndex.create(index_data['name'], index_data['fields'])
+      end
+    end
+  end
 end
 

data/test/document_test.rb

@@ -1,7 +1,5 @@
 require 'test_helper'
 
-class BaseDolly < Dolly::Document; end
-
 class BarFoo < BaseDolly
   property :a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :persist
 end
@@ -54,7 +52,6 @@ class Bar < FooBar
 end
 
 class DocumentTest < Test::Unit::TestCase
-  DB_BASE_PATH = "http://localhost:5984/test".freeze
 
   def setup
     data     = {foo: 'Foo', bar: 'Bar', type: 'foo_bar'}
@@ -578,50 +575,4 @@ class DocumentTest < Test::Unit::TestCase
     assert bar = Bar.new(a: 1)
     assert_equal 1, bar.a
   end
-
-  private
-  def generic_response rows, count = 1
-    {total_rows: count, offset:0, rows: rows}
-  end
-
-  def build_view_response properties
-    rows = properties.map.with_index do |v, i|
-      {
-        id: "foo_bar/#{i}",
-        key: "foo_bar",
-        value: 1,
-        doc: {_id: "foo_bar/#{i}", _rev: SecureRandom.hex}.merge!(v)
-      }
-    end
-    generic_response rows, properties.count
-  end
-
-  def build_view_collation_response properties
-    rows = properties.map.with_index do |v, i|
-      id = i.zero? ? "foo_bar/#{i}" : "baz/#{i}"
-      {
-        id: id,
-        key: "foo_bar",
-        value: 1,
-        doc: {_id: id, _rev: SecureRandom.hex}.merge!(v)
-      }
-    end
-    generic_response rows, properties.count
-  end
-
-
-  def build_request keys, body, view_name = 'foo_bar'
-    query = "keys=#{CGI::escape keys.to_s.gsub(' ','')}&" unless keys&.empty?
-    stub_request(:get, "#{query_base_path}?#{query.to_s}include_docs=true").
-      to_return(body: body.to_json)
-  end
-
-  def query_base_path
-    "#{DB_BASE_PATH}/_all_docs"
-  end
-
-  def build_save_request(obj)
-    stub_request(:put, "#{DB_BASE_PATH}/#{CGI.escape(obj.id)}").
-      to_return(body: {ok: true, id: obj.id, rev: "FF0000" }.to_json)
-  end
 end

data/test/document_type_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class TypedDoc < Dolly::Document
+  typed_model
+end
+
+class UntypedDoc < Dolly::Document
+end
+
+class DocumentTypeTest < Test::Unit::TestCase
+  test 'typed?' do
+    assert_equal(TypedDoc.new.typed?, true)
+    assert_equal(UntypedDoc.new.typed?, false)
+  end
+
+  test 'typed_model' do
+    assert_equal(TypedDoc.new.type, nil)
+    assert_equal(UntypedDoc.new.respond_to?(:type), false)
+    assert_raise NoMethodError do
+      UntypedDoc.new.type
+    end
+  end
+
+  test 'set_type' do
+    assert_equal(TypedDoc.new.set_type, TypedDoc.name_paramitized)
+    assert_equal(UntypedDoc.new.set_type, nil)
+  end
+end

data/test/inheritance_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class BaseDoc < Dolly::Document
+  typed_model
+end
+
+class BaseBaseDoc < BaseDoc
+  property :supertype
+end
+
+class NewBar < BaseBaseDoc
+  property :a, :b
+end
+
+class InheritanceTest < Test::Unit::TestCase
+  test 'property inheritance' do
+    assert_equal(BaseBaseDoc.new.properties.map(&:key), [:supertype, :type])
+  end
+
+  test 'deep properties inheritance' do
+    assert_equal(NewBar.new.properties.map(&:key), [:a, :b, :supertype, :type])
+  end
+end

data/test/mango_index_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class FooBar < BaseDolly
+  property :foo, :bar
+  property :with_default, default: 1
+  property :boolean, class_name: TrueClass, default: true
+  property :date, class_name: Date
+  property :time, class_name: Time
+  property :datetime, class_name: DateTime
+  property :is_nil, class_name: NilClass, default: nil
+
+  timestamps!
+end
+
+class MangoIndexTest < Test::Unit::TestCase
+  DB_BASE_PATH = "http://localhost:5984/test".freeze
+
+  def setup
+    stub_request(:get, index_base_path).
+      to_return(body: { indexes:[ {
+        ddoc: nil,
+        name:"_all_docs",
+        type:"special",
+        def:{ fields:[{ _id:"asc" }] }
+      },
+      {
+        ddoc: "_design/1",
+        name:"foo-index-json",
+        type:"json",
+        def:{ fields:[{ foo:"asc" }] }
+      }
+    ]}.to_json)
+  end
+
+  test '#delete_all' do
+    previous_indexes = Dolly::MangoIndex.all
+
+    stub_request(:delete, index_delete_path(previous_indexes.last)).
+      to_return(body: { "ok": true }.to_json)
+
+    Dolly::MangoIndex.delete_all
+
+    stub_request(:get, index_base_path).
+      to_return(body: { indexes:[ {
+        ddoc: nil,
+        name:"_all_docs",
+        type:"special",
+        def:{ fields:[{ _id:"asc" }] }
+      }
+    ]}.to_json)
+
+    new_indexes = Dolly::MangoIndex.all
+    assert_not_equal(new_indexes.length, previous_indexes.length)
+    assert_equal(new_indexes.length, 1)
+  end
+
+  def index_base_path
+    "#{DB_BASE_PATH}/_index"
+  end
+
+  def index_delete_path(doc)
+    "#{index_base_path}/#{doc[:ddoc]}/json/#{doc[:name]}"
+  end
+end

data/test/mango_test.rb

@@ -0,0 +1,273 @@
+require 'test_helper'
+
+class FooBar < BaseDolly
+  property :foo, :bar
+  property :with_default, default: 1
+  property :boolean, class_name: TrueClass, default: true
+  property :date, class_name: Date
+  property :time, class_name: Time
+  property :datetime, class_name: DateTime
+  property :is_nil, class_name: NilClass, default: nil
+
+  timestamps!
+end
+
+class FooBarTyped < BaseDolly
+  typed_model
+end
+
+class MangoTest < Test::Unit::TestCase
+  DB_BASE_PATH = "http://localhost:5984/test".freeze
+
+  def setup
+    data     = {foo: 'Foo', bar: 'Bar', type: 'foo_bar'}
+
+    all_docs = [ {foo: 'Foo B', bar: 'Bar B', type: 'foo_bar'},  {foo: 'Foo A', bar: 'Bar A', type: 'foo_bar'}]
+
+    view_resp   = build_view_response [data]
+    empty_resp  =  build_view_response []
+    not_found_resp = generic_response [{ key: "foo_bar/2", error: "not_found" }]
+    @multi_resp = build_view_response all_docs
+    @multi_type_resp = build_view_collation_response all_docs
+
+    build_request [["foo_bar","1"]], view_resp
+    build_request [["foo_bar","2"]], empty_resp
+    build_request [["foo_bar","1"],["foo_bar","2"]], @multi_resp
+
+    stub_request(:get, "#{query_base_path}?startkey=%22foo_bar%2F%22&endkey=%22foo_bar%2F%EF%BF%B0%22&include_docs=true").
+      to_return(body: @multi_resp.to_json)
+
+    stub_request(:get, "#{all_docs_path}?key=\"index_foo\"").
+      to_return(body: {
+        total_rows: 2,
+        offset: 0,
+        rows: [{
+          id: '_design/index_foo',
+          key: '_design/index_foo',
+          value: { rev: '1-c5457a0d26da85f15c4ad6bd739e441d' }
+        }]}.to_json)
+
+    stub_request(:get, "#{all_docs_path}?key=\"index_date\"").
+      to_return(body: {
+        total_rows: 2,
+        offset: 0,
+        rows: []}.to_json)
+  end
+
+  test '#find_by' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.find_by(foo: 'bar').class, FooBar)
+  end
+
+  test '#find_by for a property that does not have an index' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+    key = 'date'
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: { rows: [] }.to_json)
+
+    assert_raise Dolly::IndexNotFoundError do
+      FooBar.find_by(date: Date.today)
+    end
+  end
+
+  test '#find_by with no returned data' do
+    resp = { docs: [] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.find_by(foo: 'bar'), nil)
+  end
+
+  test '#find_doc_by' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.find_doc_by(foo: 'bar').class, Hash)
+  end
+
+  test '#where' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.where(foo: { eq: 'bar' }).map(&:class).uniq, [FooBar])
+  end
+
+  test '#where for a property that does not have an index' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'date'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: { rows: [] }.to_json)
+
+    assert_raise Dolly::IndexNotFoundError do
+      FooBar.where(date: Date.today)
+    end
+  end
+
+  test '#where with no returned data' do
+    resp = { docs: [] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.where(foo: 'bar'), [])
+  end
+
+  test '#docs_where' do
+    #TODO: clean up all the fake request creation
+    resp = { docs: [{ foo: 'bar', id: "foo_bar/1"} ] }
+
+    stub_request(:post, query_base_path).
+     to_return(body: resp.to_json)
+
+    key = 'foo'
+    stub_request(:get, "#{all_docs_path}?key=\"_design/index_#{key}\"").
+     to_return(body: index_response(key).to_json)
+
+    assert_equal(FooBar.docs_where(foo: { eq: 'bar' }).map(&:class).uniq, [Hash])
+  end
+
+  test '#build_query' do
+    query = { and: [{ _id: { eq: 'foo_bar/1' } } , { foo: { eq: 'bar'}} ] }
+    opts = {}
+    expected = {"selector"=>{"$and"=>[{:_id=>{"$eq"=>"foo_bar/1"}}, {:foo=>{"$eq"=>"bar"}}]}}
+
+    assert_equal(FooBar.send(:build_query, query, opts), expected)
+  end
+
+  test '#build_query with options' do
+    query = { and: [{ _id: { eq: 'foo_bar/1' } } , { foo: { eq: 'bar'}} ] }
+    opts = { limit: 1, fields: ['foo']}
+    expected = {"selector"=>{"$and"=>[{:_id=>{"$eq"=>"foo_bar/1"}}, {:foo=>{"$eq"=>"bar"}}]}, limit: 1, fields: ['foo']}
+
+    assert_equal(FooBar.send(:build_query, query, opts), expected)
+  end
+
+  test '#build_selectors with invalid operator' do
+    query = { _id: { eeeq: 'foo_bar/1' } }
+
+    assert_raise Dolly::InvalidMangoOperatorError do
+      FooBar.send(:build_selectors, query)
+    end
+  end
+
+  test '#build_selectors with type operator' do
+    query = { _id: { type: "user" } }
+
+    assert_nothing_raised Dolly::InvalidMangoOperatorError do
+      FooBarTyped.send(:build_selectors, query)
+    end
+  end
+
+  test '#build_selectors with $type operator' do
+    query = { _id: { "$type" => "null" } }
+
+    assert_nothing_raised Dolly::InvalidMangoOperatorError do
+      FooBarTyped.send(:build_selectors, query)
+    end
+  end
+
+  private
+
+  def generic_response rows, count = 1
+    {total_rows: count, offset:0, rows: rows}
+  end
+
+  def build_view_response properties
+    rows = properties.map.with_index do |v, i|
+      {
+        id: "foo_bar/#{i}",
+        key: "foo_bar",
+        value: 1,
+        doc: {_id: "foo_bar/#{i}", _rev: SecureRandom.hex}.merge!(v)
+      }
+    end
+    generic_response rows, properties.count
+  end
+
+  def build_view_collation_response properties
+    rows = properties.map.with_index do |v, i|
+      id = i.zero? ? "foo_bar/#{i}" : "baz/#{i}"
+      {
+        id: id,
+        key: "foo_bar",
+        value: 1,
+        doc: {_id: id, _rev: SecureRandom.hex}.merge!(v)
+      }
+    end
+    generic_response rows, properties.count
+  end
+
+
+  def build_request keys, body, view_name = 'foo_bar'
+    query = "keys=#{CGI::escape keys.to_s.gsub(' ','')}&" unless keys&.empty?
+    stub_request(:get, "#{query_base_path}?#{query.to_s}include_docs=true").
+      to_return(body: body.to_json)
+  end
+
+  def query_base_path
+    "#{DB_BASE_PATH}/_find"
+  end
+
+  def all_docs_path
+    "#{DB_BASE_PATH}/_all_docs"
+  end
+
+  def build_save_request(obj)
+    stub_request(:put, "#{DB_BASE_PATH}/#{CGI.escape(obj.id)}").
+      to_return(body: {ok: true, id: obj.id, rev: "FF0000" }.to_json)
+  end
+
+  def index_response(key)
+    {
+      rows: [
+        {
+          id: "_design/index_#{key}",
+          key: "_design/index_#{key}",
+          value: { rev: '1-c5457a0d26da85f15c4ad6bd739e441d' }
+        }
+      ]
+    }
+  end
+end

data/test/test_helper.rb

@@ -13,6 +13,7 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 class Test::Unit::TestCase
   DEFAULT_DB = 'test'
+  DB_BASE_PATH = "http://localhost:5984/test".freeze
 
   setup :global_setup
 
@@ -28,4 +29,54 @@ class Test::Unit::TestCase
   def base_path
     %r{http://.*:5984/#{DEFAULT_DB}}
   end
+
+  def generic_response rows, count = 1
+    {total_rows: count, offset:0, rows: rows}
+  end
+
+  def build_view_response properties
+    rows = properties.map.with_index do |v, i|
+      {
+        id: "foo_bar/#{i}",
+        key: "foo_bar",
+        value: 1,
+        doc: {_id: "foo_bar/#{i}", _rev: SecureRandom.hex}.merge!(v)
+      }
+    end
+    generic_response rows, properties.count
+  end
+
+  def build_view_collation_response properties
+    rows = properties.map.with_index do |v, i|
+      id = i.zero? ? "foo_bar/#{i}" : "baz/#{i}"
+      {
+        id: id,
+        key: "foo_bar",
+        value: 1,
+        doc_type: id.split("/").first,
+        doc: {
+          _id: id, _rev: SecureRandom.hex
+        }.merge!(v)
+      }
+    end
+    generic_response rows, properties.count
+  end
+
+
+  def build_request keys, body, view_name = 'foo_bar'
+    query = "keys=#{CGI::escape keys.to_s.gsub(' ','')}&" unless keys&.empty?
+    stub_request(:get, "#{query_base_path}?#{query.to_s}include_docs=true").
+      to_return(body: body.to_json)
+  end
+
+  def query_base_path
+    "#{DB_BASE_PATH}/_all_docs"
+  end
+
+  def build_save_request(obj)
+    stub_request(:put, "#{DB_BASE_PATH}/#{CGI.escape(obj.id)}").
+      to_return(body: {ok: true, id: obj.id, rev: "FF0000" }.to_json)
+  end
 end
+
+class BaseDolly < Dolly::Document; end

data/test/view_query_test.rb

@@ -0,0 +1,27 @@
+ require 'test_helper'
+
+class Foo < Dolly::Document
+end
+
+class ViewQueryTest < Test::Unit::TestCase
+
+  def setup
+    all_docs = [ {foo: 'Foo B', bar: 'Bar B', type: 'foo_bar'},  {foo: 'Foo A', bar: 'Bar A', type: 'foo_bar'}]
+    @multi_type_resp = build_view_collation_response all_docs
+
+    stub_request(:get, "http://localhost:5984/test/_design/doc/_view/id?include_docs=true").
+      to_return(body: @multi_type_resp.to_json)
+
+  end
+
+  test 'raw_view' do
+    assert_equal(Foo.raw_view('doc', 'id'), @multi_type_resp)
+    assert_equal(Foo.raw_view('doc', 'id')[:rows].any?, true)
+    assert_equal(Foo.raw_view('doc', 'id')[:total_rows].nil?, false)
+  end
+
+  test 'view_value' do
+    expected = @multi_type_resp[:rows].flat_map{|res| res[:value]}
+    assert_equal(Foo.view_value('doc', 'id'), expected)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dolly
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - javierg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -116,6 +116,8 @@ files:
 - lib/dolly/document_type.rb
 - lib/dolly/exceptions.rb
 - lib/dolly/identity_properties.rb
+- lib/dolly/mango.rb
+- lib/dolly/mango_index.rb
 - lib/dolly/properties.rb
 - lib/dolly/property.rb
 - lib/dolly/property_manager.rb
@@ -126,15 +128,22 @@ files:
 - lib/dolly/request_header.rb
 - lib/dolly/timestamp.rb
 - lib/dolly/version.rb
+- lib/dolly/view_query.rb
 - lib/railties/railtie.rb
+- lib/refinements/hash_refinements.rb
 - lib/refinements/string_refinements.rb
 - lib/tasks/db.rake
 - test/bulk_document_test.rb
 - test/document_test.rb
+- test/document_type_test.rb
 - test/dummy/config/initializers/filter_parameter_logging.rb
 - test/dummy/log/test.log
+- test/inheritance_test.rb
+- test/mango_index_test.rb
+- test/mango_test.rb
 - test/support/test.txt
 - test/test_helper.rb
+- test/view_query_test.rb
 homepage: https://www.amco.me
 licenses: []
 metadata: {}
@@ -153,15 +162,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: will write something
 test_files:
 - test/dummy/config/initializers/filter_parameter_logging.rb
 - test/dummy/log/test.log
+- test/inheritance_test.rb
+- test/document_type_test.rb
+- test/mango_index_test.rb
 - test/bulk_document_test.rb
+- test/view_query_test.rb
+- test/mango_test.rb
 - test/support/test.txt
 - test/test_helper.rb
 - test/document_test.rb