dolly 3.1.2 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2242b051913632959c785357a5de12506673ae26c369bdaccb77763edcf5a15b
-  data.tar.gz: db0e1cb72dba11f0adc1184338754266dfccfe2eabd4188a23b1a313d236f2bf
+  metadata.gz: bc95f5c129eb675fa694d16b7f1eefaacd9d8c52dbadf38b0f039a02d4f547a8
+  data.tar.gz: 5a55b4eb560aee3ffe45796eed3834833a80ef2da2d8cae115db9c4561debb3d
 SHA512:
-  metadata.gz: '096b5264f6a0c36dc68c5c6179300fc7ca2b7fb9d8806b83929ae34180d0f900b8fb64053a6423b51d9d12b716d685cc580618290f5b80cb9041decaa217af1d'
-  data.tar.gz: 1220024efbc8a6bb491099f612b260f010d74bbf5d26bc96367ec676cb1095ecbf3f98194b1449f2563116770f23f5ba9bbac985a0b314ba18f3658ee85b5278
+  metadata.gz: 036f683c88a6a7c5b27852e3c9d874e182b2de313ead437e843d5b25c795e4ad68cea854c21856560c386df07f3c6d2d82ce837b58f7c0095dedd1f4c3701ea9
+  data.tar.gz: 78275f902a858c32e23f9964726fdd0048b3e9b114e67bd9ad58224ba32711ef32155fc3ec90bc8ad3ec5cac6b2b25781d54cc423268120ac74be7aaa7f7f82a

data/lib/dolly/collection.rb

@@ -1,3 +1,5 @@
+require 'delegate'
+
 module Dolly
   class Collection < DelegateClass(Array)
     attr_reader :options
@@ -21,7 +23,7 @@ module Dolly
     private
 
     def collect_docs
-      lambda do |row|
+      proc do |row|
         next unless collectable_row?(row)
         klass = Object.const_get(doc_model(row))
         klass.from_doc(row[:doc])

data/lib/dolly/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'curb'
 require 'oj'
 require 'cgi'
@@ -22,7 +24,7 @@ module Dolly
 
     def initialize db = DEFAULT_DATABASE, app_env = :development
       @db      = db
-      @app_env = app_env
+      @app_env = defined?(Rails) ? Rails.env : app_env
     end
 
     def get(resource, data = {})
@@ -71,14 +73,15 @@ module Dolly
       uri         = URI("#{base_uri}#{db_resource}")
 
       conn = curl_method_call(method, uri, body) do |curl|
-        if env['username'].present?
+        if env['username'] && !env['username'].empty?
           curl.http_auth_types = :basic
           curl.username = env['username']
           curl.password = env['password'].to_s
         end
 
-        headers.each { |k, v| curl.headers[k] = v } if headers.present?
+        headers.each { |k, v| curl.headers[k] = v } unless !headers || headers.empty?
       end
+
       response_format(conn, method)
     end
 
@@ -114,6 +117,8 @@ module Dolly
       data
     rescue Oj::ParseError
       res.body_str
+    ensure
+      GC.start if res&.body_str&.length&.to_i > 250000
     end
 
     def values_to_json hash

data/lib/dolly/depracated_database.rb

@@ -1,19 +1,19 @@
 module Dolly
   module DepracatedDatabase
     Database = Struct.new(:connection) do
-      def request *args
-        connection.request *args
+      def request(*args)
+        connection.request(*args)
       end
 
-      def post *args
-        connection.post *args
+      def post(*args)
+        connection.post(*args)
       end
     end
 
-    def view *args
+    def view(*args)
       opts = args.pop if args.last.is_a? Hash
       opts ||= {}
-      connection.view *args, opts.merge(include_docs: true)
+      connection.view(*args, opts.merge(include_docs: true))
     end
 
     def database

data/lib/dolly/document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dolly/mango'
 require 'dolly/mango_index'
 require 'dolly/query'
@@ -41,29 +43,25 @@ module Dolly
     attr_writer :doc
 
     def initialize(attributes = {})
-      init_ancestor_properties
+      @doc = doc_for_framework
       properties.each(&build_property(attributes))
     end
 
     protected
 
-    def doc
-      @doc ||= doc_for_framework
+    def self.inherited(base)
+      base.instance_variable_set(:@properties, properties.dup)
     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
+    def doc
+      @doc ||= doc_for_framework
     end
 
     def doc_for_framework
+      return @doc if @doc
+
       return {} unless rails?
+
       {}.with_indifferent_access
     end
   end

data/lib/dolly/document_creation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dolly/properties'
 require 'dolly/framework_helper'
 
@@ -10,7 +12,13 @@ module Dolly
       attributes = property_clean_doc(doc)
 
       new(attributes).tap do |model|
-        model.send(:doc).merge!(doc)
+        doc.each_key do |key|
+          if model.respond_to?(:"#{key}=")
+            model.send(:"#{key}=", doc[key])
+          else
+            model.send(:doc)[key] = doc[key]
+          end
+        end
       end
     end
 
@@ -21,7 +29,7 @@ module Dolly
     end
 
     def create(attributes)
-      new(attributes).tap { |model| model.save }
+      new(attributes).tap(&:save)
     end
   end
 end

data/lib/dolly/document_type.rb

@@ -9,12 +9,12 @@ module Dolly
     end
 
     def namespace_key(key)
-      return key if key =~ %r{^#{name_paramitized}/}
-      "#{name_paramitized}/#{key}"
+      return "#{key}" if "#{key}" =~ %r{^#{name_paramitized}#{type_sep}}
+      "#{name_paramitized}#{type_sep}#{key}"
     end
 
     def base_id
-      self.id.sub(%r{^#{name_paramitized}/}, '')
+      self.id.sub(%r{^#{name_paramitized}#{type_sep}}, '')
     end
 
     def name_paramitized
@@ -34,14 +34,38 @@ module Dolly
       write_attribute(:type, name_paramitized)
     end
 
+    def type_sep
+      return ':' if partitioned?
+      '/'
+    end
+
+    def partitioned?
+      false
+    end
+
     def self.included(base)
       base.extend(ClassMethods)
     end
 
     module ClassMethods
+      def absolute_id(id)
+        id.sub(%r{^[^/:]+(/|:)}, '')
+      end
+
       def typed_model
         property :type, class_name: String
       end
+
+      def partitioned!
+        check_db_partitioned!
+        define_method(:partitioned?) { true }
+      end
+
+      def check_db_partitioned!
+        !!connection.get('').
+          dig(:props, :partitioned) ||
+          raise(Dolly::PartitionedDataBaseExpectedError)
+      end
     end
   end
 end

data/lib/dolly/exceptions.rb

@@ -37,6 +37,17 @@ module Dolly
     end
   end
 
+  class MissingSlugableProperties < RuntimeError
+    def initialize(properties)
+      @properties = properties.join(', ')
+    end
+
+    def to_s
+      "Missing slugable: #{@properties}."
+    end
+  end
+
+  class PartitionedDataBaseExpectedError < RuntimeError; end
   class IndexNotFoundError < RuntimeError; end
   class InvalidConfigFileError < RuntimeError; end
   class InvalidProperty < RuntimeError; end

data/lib/dolly/mango.rb

@@ -123,12 +123,12 @@ module Dolly
     end
 
     def build_key(key)
-      return key if key.to_s.starts_with?(SELECTOR_SYMBOL)
+      return key if key.to_s.start_with?(SELECTOR_SYMBOL)
       "#{SELECTOR_SYMBOL}#{key}"
     end
 
     def is_operator?(key)
-      ALL_OPERATORS.include?(key) || key.to_s.starts_with?(SELECTOR_SYMBOL)
+      ALL_OPERATORS.include?(key) || key.to_s.start_with?(SELECTOR_SYMBOL)
     end
 
     def fetch_fields(query)

data/lib/dolly/mango_index.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'forwardable'
-require 'dolly/document'
 
 module Dolly
   class MangoIndex

data/lib/dolly/properties.rb

@@ -7,13 +7,29 @@ module Dolly
 
     def property *opts, class_name: nil, default: nil
       opts.each do |opt|
-
         properties << (prop = Property.new(opt, class_name, default))
+
+        silence_redefinition_of_method(opt.to_sym)
+        silence_redefinition_of_method(:"#{opt}=")
+        silence_redefinition_of_method(:"#{opt}?") if prop.boolean?
+        silence_redefinition_of_method(:"[]")
+
         send(:attr_reader, opt)
 
-        define_method(:"#{opt}=") { |value| write_attribute(opt, value) }
+        define_method(:"#{opt}=") do |value|
+          write_attribute(opt, value)
+        end
+
         define_method(:"#{opt}?") { send(opt) } if prop.boolean?
-        define_method(:"[]") {|name| send(name) }
+        define_method(:"[]") { |name| send(name) }
+      end
+    end
+
+    def silence_redefinition_of_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        # This suppresses the "method redefined" warning; the self-alias
+        # looks odd, but means we don't need to generate a unique name
+        alias_method method, method
       end
     end
 
@@ -30,7 +46,7 @@ module Dolly
     end
 
     def property_clean_doc(doc)
-      doc.reject { |key, _value| property_keys.exclude?(key.to_sym) }
+      doc.select { |key, _value| property_keys.include?(key.to_sym) }
     end
   end
 end

data/lib/dolly/property.rb

@@ -79,7 +79,8 @@ module Dolly
     private
 
     def truthy_value?(value)
-      value =~ /true/ || value === true
+      value === true ||
+        (value.is_a?(String) && value.match?(/true/))
     end
 
     def klass_sym

data/lib/dolly/property_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dolly
   module PropertyManager
     def build_property(attributes)
@@ -7,13 +9,15 @@ module Dolly
       lambda do |property|
         name = property.key
         next unless doc[name].nil?
+
         write_attribute(name, attributes[name])
       end
     end
 
     def update_attribute
-      lambda do |key, value|
-        raise InvalidProperty unless valid_property?(key)
+      lambda do |(key, value)|
+        raise InvalidProperty, "Invalid property: #{key}" unless valid_property?(key)
+
         write_attribute(key, value)
       end
     end
@@ -21,15 +25,15 @@ module Dolly
     def write_attribute(key, value)
       casted_value = set_property_value(key, value)
       instance_variable_set(:"@#{key}", casted_value)
-      update_doc(key, casted_value)
+      update_doc(key)
     end
 
     def valid_property?(name)
-      properties.include?(name)
+      properties.include?(name.to_sym)
     end
 
-    def update_doc(key, value)
-      doc[key] = value
+    def update_doc(key, _value = nil)
+      doc.regular_writer(key.to_s, instance_variable_get(:"@#{key}"))
     end
 
     def properties

data/lib/dolly/property_set.rb

@@ -10,8 +10,11 @@ module Dolly
     end
 
     def [](key)
-      return detect {|property| property.key == key } if key.is_a?(Symbol)
-      super
+      return to_a[key] if key.is_a?(Integer)
+
+      detect do |property|
+        property.key == key.to_sym
+      end
     end
 
     private

data/lib/dolly/query.rb

@@ -31,12 +31,11 @@ module Dolly
       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
+    def safe_find(*keys)
+      find(*keys)
     rescue Dolly::ResourceNotFound
       nil
     end
@@ -59,11 +58,11 @@ module Dolly
       opts          = opts.each_with_object({}) { |(k, v), h| h[k] = v }
       query_results = raw_view(doc, view_name, opts)
 
-      Collection.new({ rows: query_results, options: {} }).first_or_all
+      Collection.new(rows: query_results, options: {}).first_or_all
     end
 
     def build_collection(query)
-      Collection.new({ rows: connection.get('_all_docs', query.merge(include_docs: true)), options: { doc_type: self.class_name }})
+      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_header.rb

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

data/lib/dolly/slugable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Dolly
+  module Slugable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def slug
+      slugable_properties.
+        map(&normalize_property).
+        map(&parameterize_item).
+        join(slugable_separator)
+    end
+
+    def parameterize_item
+      proc do |message|
+        if message.respond_to?(:parameterize)
+          next message.parameterize
+        end
+
+        message
+      end
+    end
+
+    def id
+      doc[:_id] ||= self.class.namespace_key(slug)
+    end
+
+    def normalize_property
+      proc do |property|
+        send(:"#{property}").to_s
+      end
+    end
+
+    module ClassMethods
+      DEFAULT_SEPARATOR = '_'
+
+      def set_slug(*slugable_properties, separator: DEFAULT_SEPARATOR)
+        validate_slug_property_presence!(slugable_properties)
+        define_method(:slugable_separator) { separator }
+        define_method(:slugable_properties) { slugable_properties }
+      end
+
+      def validate_slug_property_presence!(slugable_properties)
+        missing_properties = slugable_properties.select do |prop|
+          !instance_methods(false).include?(prop)
+        end
+
+        unless missing_properties.empty?
+          raise Dolly::MissingSlugableProperties, missing_properties
+        end
+      end
+    end
+  end
+end

data/lib/dolly/version.rb

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

data/lib/dolly.rb

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

data/lib/tasks/db.rake

@@ -61,6 +61,77 @@ namespace :db do
     end
   end
 
+  namespace :search do
+    require 'optparse'
+
+    desc 'Creates search indexes for lucend style queries.'
+    task :create, [:db, :silent, :analyzer] => :environment do |_t, args|
+      options = {}
+      opts = OptionParser.new
+      opts.on("-d", "--db ARG", String) { |db| options[:db] = db }
+      opts.on("-s", "--silent", TrueClass) { options[:silent] = true }
+      opts.on("-a", "--analyzer ARG", String) { |analyzer| options[:analyzer] = analyzer }
+      args = opts.order!(ARGV) {}
+      opts.parse!(args)
+
+      analyzer = options[:analyzer].presence || 'standard'
+      db = options[:db].present? ? "/#{options[:db]}/" : ''
+      silent = options[:silent].present?
+
+      design_dir = Rails.root.join 'db', 'searches'
+      files = Dir.glob File.join design_dir, '**', '*.js'
+
+      puts "\n\e[44m== Updating search indexes ==\e[0m\n\n" unless silent
+
+      docs = files.map do |filename, acc|
+        name  = File.basename(filename).sub(/.js/i, '')
+        source = File.read filename
+        design_doc_name = "_design/#{name}"
+
+        doc = begin
+                Dolly::Document.connection.request(:get, "#{db}#{design_doc_name}")
+              rescue Dolly::ResourceNotFound
+                {}
+              end
+
+        data = {
+          _id: design_doc_name,
+          indexes: {
+            name => {
+              index: source,
+              analyzer: analyzer
+            }
+          }
+        }
+
+        if data[:indexes].to_json == doc[:indexes].to_json
+          puts "\e[32mSearch index #{name} is up to date.\e[0m" unless silent
+          {}
+        else
+          puts "\e[36mSearch Index #{name} will be updated.\e[0m" unless silent
+          doc.merge!(data)
+        end
+      end
+
+      res = Dolly::Document.connection.request :post, "#{db}_bulk_docs", docs: docs
+
+      next if silent
+
+      failed = res.reject { |r| r[:ok] }
+
+      if failed.present?
+        puts "\n\e[31mThe following indexes failed to be persisted:\e[0m"
+
+        failed.each do |doc|
+          puts "  \e[35m* #{doc[:id]}\e[0m"
+        end
+        puts "\n"
+      else
+        puts "\n\e[5m\e[42mAll search indexes saved successfully.\e[0m\e[25m\n\n"
+      end
+    end
+  end
+
   namespace :index do
     desc 'Creates indexes for mango querys located in db/indexes/*.json'
     task create: :environment do

data/test/document_type_test.rb

@@ -8,6 +8,10 @@ class UntypedDoc < Dolly::Document
 end
 
 class DocumentTypeTest < Test::Unit::TestCase
+  test 'absolute id' do
+    assert_equal(TypedDoc.absolute_id("typed_doc/a"), "a")
+  end
+
   test 'typed?' do
     assert_equal(TypedDoc.new.typed?, true)
     assert_equal(UntypedDoc.new.typed?, false)

data/test/inheritance_test.rb

@@ -14,10 +14,10 @@ end
 
 class InheritanceTest < Test::Unit::TestCase
   test 'property inheritance' do
-    assert_equal(BaseBaseDoc.new.properties.map(&:key), [:supertype, :type])
+    assert_equal(BaseBaseDoc.new.properties.map(&:key).sort, [:supertype, :type])
   end
 
   test 'deep properties inheritance' do
-    assert_equal(NewBar.new.properties.map(&:key), [:a, :b, :supertype, :type])
+    assert_equal(NewBar.new.properties.map(&:key).sort, [:a, :b, :supertype, :type])
   end
 end

data/test/mango_test.rb

@@ -26,7 +26,9 @@ class MangoTest < Test::Unit::TestCase
 
     view_resp   = build_view_response [data]
     empty_resp  =  build_view_response []
-    not_found_resp = generic_response [{ key: "foo_bar/2", error: "not_found" }]
+
+    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
 
@@ -68,22 +70,6 @@ class MangoTest < Test::Unit::TestCase
     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: [] }
 
@@ -125,22 +111,6 @@ class MangoTest < Test::Unit::TestCase
     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: [] }