dolly 3.0.0 → 3.1.2

data/lib/dolly/property.rb

@@ -16,10 +16,15 @@ module Dolly
     def cast_value(value)
       return set_default if value.nil?
       return value unless class_name
-      return self_klass.new(value) unless respond_to?(klass_sym)
+      return custom_class(value) unless respond_to?(klass_sym)
       send(klass_sym, value)
     end
 
+    def custom_class(value)
+      value = value.is_a?(Hash) ? value.symbolize_keys : value
+      self_klass.new(value)
+    end
+
     def boolean?
       [TrueClass, FalseClass].include?(class_name)
     end
@@ -32,6 +37,14 @@ module Dolly
       value.to_h
     end
 
+    def hash_with_indifferent_access_value(value)
+      if defined?(Rails)
+        value.to_h.with_indifferent_access
+      else
+        value.to_h
+      end
+    end
+
     def integer_value(value)
       value.to_i
     end
@@ -70,7 +83,13 @@ module Dolly
     end
 
     def klass_sym
-      :"#{self_klass.name.underscore}_value"
+      klass_name = self_klass.
+                   name.
+                   split('::').
+                   last.
+                   underscore
+
+      :"#{klass_name}_value"
     end
 
     def self_klass

data/lib/dolly/property_manager.rb

@@ -2,9 +2,10 @@ module Dolly
   module PropertyManager
     def build_property(attributes)
       assign_identity_properties(attributes)
+      assign_rev_properties(attributes)
 
       lambda do |property|
-        name = property.key.to_sym
+        name = property.key
         next unless doc[name].nil?
         write_attribute(name, attributes[name])
       end
@@ -17,14 +18,14 @@ module Dolly
       end
     end
 
-    def write_attribute key, value
-      value = set_property_value(key, value)
-      instance_variable_set(:"@#{key}", value)
-      update_doc(key, value) unless value.nil?
+    def write_attribute(key, value)
+      casted_value = set_property_value(key, value)
+      instance_variable_set(:"@#{key}", casted_value)
+      update_doc(key, casted_value)
     end
 
     def valid_property?(name)
-      properties.include? name
+      properties.include?(name)
     end
 
     def update_doc(key, value)
@@ -43,5 +44,10 @@ module Dolly
       id_presence = opts[:id] || opts[:_id] || opts['id'] || opts['_id']
       self.id = id_presence if id_presence
     end
+
+    def assign_rev_properties(opts = {})
+      rev_presence = opts[:rev] || opts [:_rev] || opts['rev'] || opts['_rev']
+      self.rev = rev_presence if rev_presence
+    end
   end
 end

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,12 +1,15 @@
 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) }
 
@@ -14,6 +17,24 @@ module Dolly
         raise(Dolly::ResourceNotFound)
     end
 
+    def bulk_find(*keys_to_find)
+      data = {
+        query: { include_docs: true },
+        keys: keys_to_find.map { |key| namespace_key(key) }
+      }
+
+      res = connection.post('_all_docs', data)
+      Collection.new(rows: res, options: { doc_type: self.class_name })
+    end
+
+    def find_all(*keys)
+      query_hash = { keys: namespace_keys(keys) }
+      return [] if query_hash[:keys].none?
+
+      keys_to_find_counter = query_hash[:keys].length
+      build_collection(query_hash).first_or_all(true)&.itself
+    end
+
     def safe_find *keys
       find *keys
     rescue Dolly::ResourceNotFound
@@ -35,19 +56,14 @@ module Dolly
     end
 
     def find_with doc, view_name, opts = {}
-      opts          = opts.each_with_object({}) { |(k, v), h| h[k] = escape_value(v) }
+      opts          = opts.each_with_object({}) { |(k, v), h| h[k] = 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/query_arguments.rb

@@ -3,7 +3,7 @@
 module Dolly
   module QueryArguments
     def last_item_in_range
-      URI.escape("\ufff0")
+      "\ufff0"
     end
 
     def default_query_args

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/request_header.rb

@@ -7,7 +7,7 @@ module Dolly
     CONTENT_TYPE_KEY = 'Content-Type'
     JSON_CONTENT = 'application/json'
 
-    def_delegators :@collection, :[], :[]=, :keys, :each
+    def_delegators :@collection, :[], :[]=, :keys, :each, :present?, :merge!
 
     def initialize hash = nil
       @collection = hash || default_value

data/lib/dolly/version.rb

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

data/lib/dolly/view_query.rb

@@ -0,0 +1,21 @@
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module ViewQuery
+    def raw_view(design, view_name, opts = {})
+      design = "_design/#{design}/_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
+
+    def collection_view(design, view_name, opts = {})
+      opts.delete(:include_docs)
+      design = "_design/#{design}/_view/#{view_name}"
+      response = connection.view(design, opts)
+      Dolly::Collection.new(rows: response, options: opts)
+    end
+  end
+end

data/lib/dolly.rb

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

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,25 @@ 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))
+        database = index_data.fetch('db', 'default').to_sym
+        puts "*" * 100
+        puts "Creating index: #{index_data["name"]} for database: #{database}"
+
+        if database == Dolly::Connection::DEFAULT_DATABASE
+          puts Dolly::MangoIndex.create(index_data['name'], index_data['fields'])
+        else
+          puts Dolly::MangoIndex.create_in_database(database, index_data['name'], index_data['fields'])
+        end
+      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