couch_potato 1.7.0 → 1.10.1

data/lib/couch_potato/database.rb

@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 module CouchPotato
   class Database
-
     class ValidationsFailedError < ::StandardError; end
+    # Pass in a cache to enable caching #load calls.
+    # A cache needs to respond to #[], #[]= and #clear (just use a Hash).
+    attr_accessor :cache
+    cattr_accessor :default_batch_size
+    self.default_batch_size = 500
+    attr_reader :name # the (unresolved) name of the database unless this is the default database
 
-    def initialize(couchrest_database)
+    def initialize(couchrest_database, name: nil)
+      @name = name
       @couchrest_database = couchrest_database
     end
 
@@ -37,30 +45,40 @@ module CouchPotato
     #
     #   db.view(User.all(keys: [1, 2, 3]))
     def view(spec)
-      ActiveSupport::Notifications.instrument('couch_potato.view', name: "#{spec.design_document}/#{spec.view_name}") do
-        results = CouchPotato::View::ViewQuery.new(
-          couchrest_database,
-          spec.design_document,
-          {spec.view_name => {
-            :map => spec.map_function,
-            :reduce => spec.reduce_function
-          }
-          },
-          ({spec.list_name => spec.list_function} unless spec.list_name.nil?),
-          spec.lib,
-          spec.language
-        ).query_view!(spec.view_parameters)
-        processed_results = spec.process_results results
-        processed_results.each do |document|
-          document.database = self if document.respond_to?(:database=)
-        end if processed_results.respond_to?(:each)
-        processed_results
+      id = view_cache_id(spec)
+      cached = cache && id.is_a?(String) && cache[id]
+      if cache
+        if cached
+          ActiveSupport::Notifications.instrument('couch_potato.view.cached') do
+            cached
+          end
+        else
+          cache[id] = view_without_caching(spec)
+          cache[id]
+        end
+      else
+        view_without_caching(spec)
+      end
+    end
+
+    # Same as #view but instead of returning the results, it yields them
+    # to a given block in batches of the given size, making multiple
+    # requests with according skip/limit params sent to CouchDB.
+    def view_in_batches(spec, batch_size: default_batch_size)
+      batch = 0
+      loop do
+        spec.view_parameters = spec.view_parameters.merge({ skip: batch * batch_size, limit: batch_size })
+        results = view(spec)
+        yield results
+        break if results.size < batch_size
+
+        batch += 1
       end
     end
 
     # returns the first result from a #view query or nil
     def first(spec)
-      spec.view_parameters = spec.view_parameters.merge({:limit => 1})
+      spec.view_parameters = spec.view_parameters.merge({ limit: 1 })
       view(spec).first
     end
 
@@ -74,33 +92,35 @@ module CouchPotato
     # * yield the object to be saved to the block and run if once before saving
     # * on conflict: reload the document, run the block again and retry saving
     def save_document(document, validate = true, retries = 0, &block)
+      cache&.clear
       begin
-        block.call document if block
+        block&.call document
         save_document_without_conflict_handling(document, validate)
-      rescue CouchRest::Conflict => e
+      rescue CouchRest::Conflict
         if block
           handle_write_conflict document, validate, retries, &block
         else
-          raise CouchPotato::Conflict.new
+          raise CouchPotato::Conflict
         end
       end
     end
-    alias_method :save, :save_document
+    alias save save_document
 
     # saves a document, raises a CouchPotato::Database::ValidationsFailedError on failure
     def save_document!(document)
-      save_document(document) || raise(ValidationsFailedError.new(document.errors.full_messages))
+      save_document(document) || raise(ValidationsFailedError, document.errors.full_messages)
     end
-    alias_method :save!, :save_document!
+    alias save! save_document!
 
     def destroy_document(document)
+      cache&.clear
       begin
         destroy_document_without_conflict_handling document
       rescue CouchRest::Conflict
         retry if document = document.reload
       end
     end
-    alias_method :destroy, :destroy_document
+    alias destroy destroy_document
 
     # loads a document by its id(s)
     # id - either a single id or an array of ids
@@ -108,28 +128,29 @@ module CouchPotato
     # returns nil if the single document could not be found. when passing an array and some documents
     # could not be found these are omitted from the returned array
     def load_document(id)
-      raise "Can't load a document without an id (got nil)" if id.nil?
-
-      ActiveSupport::Notifications.instrument('couch_potato.load') do
-        if id.is_a?(Array)
-          bulk_load id
+      cached = cache && id.is_a?(String) && cache[id]
+      if cache
+        if cached
+          ActiveSupport::Notifications.instrument('couch_potato.load.cached') do
+            cached
+          end
         else
-          instance = couchrest_database.get(id)
-          instance.database = self if instance
-          instance
+          cache[id] = load_document_without_caching(id)
+          cache[id]
         end
+      else
+        load_document_without_caching(id)
       end
     end
-    alias_method :load, :load_document
+    alias load load_document
 
     # loads one or more documents by its id(s)
     # behaves like #load except it raises a CouchPotato::NotFound if any of the documents could not be found
     def load!(id)
       doc = load(id)
-      if id.is_a?(Array)
-        missing_docs = id - doc.map(&:id)
-      end
+      missing_docs = id - doc.map(&:id) if id.is_a?(Array)
       raise(CouchPotato::NotFound, missing_docs.try(:join, ', ')) if doc.nil? || missing_docs.try(:any?)
+
       doc
     end
 
@@ -138,17 +159,94 @@ module CouchPotato
     end
 
     # returns the underlying CouchRest::Database instance
-    def couchrest_database
-      @couchrest_database
+    attr_reader :couchrest_database
+
+    # returns a new database instance connected to the CouchDB database
+    # with the given name. the name is passed through the
+    # additional_databases configuration to resolve it to a database
+    # configured there.
+    # if the current database has a cache, the new database will receive
+    # a cleared copy of it.
+    def switch_to(database_name)
+      resolved_database_name = CouchPotato.resolve_database_name(database_name)
+      self
+        .class
+        .new(CouchPotato.couchrest_database_for_name(resolved_database_name), name: database_name)
+        .tap(&copy_clear_cache_proc)
+    end
+
+    # returns a new database instance connected to the default CouchDB database.
+    # if the current database has a cache, the new database will receive
+    # a cleared copy of it.
+    def switch_to_default
+      self
+        .class
+        .new(CouchPotato.couchrest_database)
+        .tap(&copy_clear_cache_proc)
     end
 
     private
 
+    def copy_clear_cache_proc
+      lambda { |db|
+        next unless cache
+
+        db.cache = cache.dup
+        db.cache.clear
+      }
+    end
+
+    def view_without_caching(spec)
+      ActiveSupport::Notifications.instrument('couch_potato.view', name: "#{spec.design_document}/#{spec.view_name}") do
+        results = CouchPotato::View::ViewQuery.new(
+          couchrest_database,
+          spec.design_document,
+          { spec.view_name => {
+            map: spec.map_function,
+            reduce: spec.reduce_function
+          } },
+          ({ spec.list_name => spec.list_function } unless spec.list_name.nil?),
+          spec.lib,
+          spec.language
+        ).query_view!(spec.view_parameters)
+        processed_results = spec.process_results results
+        if processed_results.respond_to?(:database=)
+          processed_results.database = self
+        elsif processed_results.respond_to?(:each)
+          processed_results.each do |document|
+            document.database = self if document.respond_to?(:database=)
+          end
+        end
+        processed_results
+      end
+    end
+
+    def load_document_without_caching(id)
+      raise "Can't load a document without an id (got nil)" if id.nil?
+
+      ActiveSupport::Notifications.instrument('couch_potato.load') do
+        if id.is_a?(Array)
+          bulk_load id
+        else
+          instance = couchrest_database.get(id)
+          instance.database = self if instance
+          instance
+        end
+      end
+    end
+
+    def view_cache_id(spec)
+      spec.send(:klass).to_s + spec.view_name.to_s + spec.view_parameters.to_s
+    end
+
     def handle_write_conflict(document, validate, retries, &block)
-      document = document.reload
+      cache&.clear
       if retries == 5
-        raise CouchPotato::Conflict.new
+        raise CouchPotato::Conflict
       else
+        reloaded = document.reload
+        document.attributes = reloaded.attributes
+        document._rev = reloaded._rev
         save_document document, validate, retries + 1, &block
       end
     end
@@ -171,11 +269,13 @@ module CouchPotato
     end
 
     def bulk_load(ids)
+      return [] if ids.empty?
+
       response = couchrest_database.bulk_load ids
-      docs = response['rows'].map{|row| row["doc"]}.compact
-      docs.each{|doc|
+      docs = response['rows'].map { |row| row['doc'] }.compact
+      docs.each do |doc|
         doc.database = self if doc.respond_to?(:database=)
-      }
+      end
     end
 
     def create_document(document, validate)
@@ -183,51 +283,50 @@ module CouchPotato
 
       if validate
         document.errors.clear
-        return false if false == document.run_callbacks(:validation_on_save) do
-          return false if false == document.run_callbacks(:validation_on_create) do
+        return false if document.run_callbacks(:validation_on_save) do
+          return false if document.run_callbacks(:validation_on_create) do
             return false unless valid_document?(document)
-          end
-        end
+          end == false
+        end == false
       end
 
-      return false if false == document.run_callbacks(:save) do
-        return false if false == document.run_callbacks(:create) do
+      return false if document.run_callbacks(:save) do
+        return false if document.run_callbacks(:create) do
           res = couchrest_database.save_doc document.to_hash
           document._rev = res['rev']
           document._id = res['id']
-        end
-      end
+        end == false
+      end == false
+
       true
     end
 
     def update_document(document, validate)
       if validate
         document.errors.clear
-        return false if false == document.run_callbacks(:validation_on_save) do
-          return false if false == document.run_callbacks(:validation_on_update) do
+        return false if document.run_callbacks(:validation_on_save) do
+          return false if document.run_callbacks(:validation_on_update) do
             return false unless valid_document?(document)
-          end
-        end
+          end == false
+        end == false
       end
 
-      return false if false == document.run_callbacks(:save) do
-        return false if false == document.run_callbacks(:update) do
-          if document.dirty?
-            res = couchrest_database.save_doc document.to_hash
-            document._rev = res['rev']
-          end
-        end
-      end
+      return false if document.run_callbacks(:save) do
+        return false if document.run_callbacks(:update) do
+          res = couchrest_database.save_doc document.to_hash
+          document._rev = res['rev']
+        end == false
+      end == false
+
       true
     end
 
     def valid_document?(document)
-      errors = document.errors.errors.dup
-      errors.instance_variable_set("@messages", errors.messages.dup) if errors.respond_to?(:messages)
+      original_errors_hash = document.errors.to_hash
       document.valid?
-      errors.each do |k, v|
+      original_errors_hash.each do |k, v|
         if v.respond_to?(:each)
-          v.each {|message| document.errors.add(k, message)}
+          v.each { |message| document.errors.add(k, message) }
         else
           document.errors.add(k, v)
         end

data/lib/couch_potato/persistence/dirty_attributes.rb

@@ -6,37 +6,19 @@ module CouchPotato
       def self.included(base) #:nodoc:
         base.send :include, ActiveModel::Dirty
         base.class_eval do
-          after_save :reset_dirty_attributes
+          after_save :clear_changes_information
         end
       end
 
-      # returns true if a model has dirty attributes, i.e. their value has changed since the last save
-      def dirty?
-        changed? || @forced_dirty
-      end
-
-      # marks a model as dirty
-      def is_dirty
-        @forced_dirty = true
-      end
-
-      private
-
-      def reset_dirty_attributes
-        @previously_changed = changes
-        @changed_attributes.clear
-        @forced_dirty = nil
-      end
-
       def clone_attribute(value)
-        if [Fixnum, Symbol, TrueClass, FalseClass, NilClass, Float, BigDecimal].include?(value.class)
+        if [Integer, Symbol, TrueClass, FalseClass, NilClass, Float, BigDecimal].find{|klass| value.is_a?(klass)}
           value
         elsif [Hash, Array].include?(value.class)
           #Deep clone
           Marshal::load(Marshal::dump(value))
         else
           value.clone
-        end
+         end
       end
     end
   end

data/lib/couch_potato/persistence/magic_timestamps.rb

@@ -9,13 +9,13 @@ module CouchPotato
 
         before_create lambda {|model|
           model.created_at ||= (Time.zone || Time).now
-          @changed_attributes.try :delete, 'created_at'
+          clear_attribute_changes [:created_at]
           model.updated_at ||= (Time.zone || Time).now
-          @changed_attributes.try :delete, 'updated_at'
+          clear_attribute_changes [:updated_at]
         }
         before_update lambda {|model|
           model.updated_at = (Time.zone || Time).now
-          @changed_attributes.try :delete, 'updated_at'
+          clear_attribute_changes [:updated_at]
         }
       end
     end

data/lib/couch_potato/persistence/properties.rb

@@ -85,18 +85,23 @@ module CouchPotato
         #    property :next_year, default: ->(book) { book.year + 1 }
         #  end
         def property(name, options = {})
-          undefine_attribute_methods
-          define_attribute_methods property_names + [name]
+          # ActiveModel::AttributeMethods.generated_attribute_methods
+          active_support_module = send(:generated_attribute_methods)
+
+          # Mimic ActiveModel::AttributeMethods.undefine_attribute_methods, but only for this
+          # property's accessor method
+          active_support_module.module_eval do
+            undef_method(name) if instance_methods.include?(name)
+          end
+          cache = send(:attribute_method_matchers_cache)
+          cache.delete(name)
+
+          define_attribute_method name
           properties << SimpleProperty.new(self, name, options)
-          remove_attribute_accessors_from_activesupport_module
-        end
 
-        def remove_attribute_accessors_from_activesupport_module
-          active_support_module = ancestors[1..-1].find{|m| m.name.nil? && (property_names - m.instance_methods).empty?}
-          if active_support_module
-            property_names.each do |name|
-              active_support_module.send :remove_method, name if active_support_module.instance_methods.include?(name)
-            end
+          # Remove the default ActiveModel::AttributeMethods accessor
+          if active_support_module.instance_methods.include?(name)
+            active_support_module.send(:remove_method, name)
           end
         end
       end

data/lib/couch_potato/persistence/simple_property.rb

@@ -32,10 +32,6 @@ module CouchPotato
         object.send @setter_name, value
       end
 
-      def dirty?(object)
-        object.send("#{name}_changed?")
-      end
-
       def serialize(json, object)
         json[name] = object.send name
       end

data/lib/couch_potato/persistence/type_caster.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/util'
 module CouchPotato
   module Persistence
     class TypeCaster #:nodoc:
-      NUMBER_REGEX = /-?\d*\.?\d*/
+      NUMBER_REGEX = /-?\d*\.?\d*/.freeze
 
       def cast(value, type)
         if type == :boolean
           cast_boolean(value)
         elsif type.instance_of?(Array)
           nested_type = type.first
-          value.map { |val| cast_native(val, nested_type) } if value
+          value&.map { |val| cast_native(val, nested_type) }
         else
           cast_native(value, type)
         end
@@ -28,14 +31,17 @@ module CouchPotato
 
       def cast_native(value, type)
         if type && !value.is_a?(type)
-          if type == Fixnum
-            BigDecimal.new(value.to_s.scan(NUMBER_REGEX).join).round unless value.blank?
+
+          if %w[Integer Bignum Fixnum].include?(type.to_s)
+            value.to_s.scan(NUMBER_REGEX).join.to_d.round unless value.blank?
           elsif type == Float
             value.to_s.scan(NUMBER_REGEX).join.to_f unless value.blank?
           elsif type == BigDecimal
-            BigDecimal.new(value.to_s) unless value.blank?
+            value.to_d unless value.blank?
           elsif type == Hash
             value.to_hash unless value.blank?
+          elsif type.ancestors.include?(CouchPotato::Persistence)
+            type.new value unless value.blank?
           else
             type.json_create value unless value.blank?
           end
@@ -43,7 +49,6 @@ module CouchPotato
           value
         end
       end
-
     end
   end
 end

data/lib/couch_potato/persistence.rb

@@ -6,7 +6,6 @@ require File.dirname(__FILE__) + '/persistence/magic_timestamps'
 require File.dirname(__FILE__) + '/persistence/callbacks'
 require File.dirname(__FILE__) + '/persistence/json'
 require File.dirname(__FILE__) + '/persistence/dirty_attributes'
-require File.dirname(__FILE__) + '/persistence/deep_dirty_attributes'
 require File.dirname(__FILE__) + '/persistence/ghost_attributes'
 require File.dirname(__FILE__) + '/persistence/attachments'
 require File.dirname(__FILE__) + '/persistence/type_caster'

data/lib/couch_potato/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erb'
 
 module CouchPotato
@@ -6,23 +8,16 @@ module CouchPotato
     path = Rails.root.join('config/couchdb.yml')
     if File.exist?(path)
       require 'yaml'
-      config = YAML::load(ERB.new(File.read(path)).result)[Rails.env]
-      if config.is_a?(String)
-        CouchPotato::Config.database_name = config
-      else
-        CouchPotato::Config.database_name = config['database']
-        CouchPotato::Config.split_design_documents_per_view = config['split_design_documents_per_view'] if config['split_design_documents_per_view']
-        CouchPotato::Config.digest_view_names = config['digest_view_names'] if config['digest_view_names']
-        CouchPotato::Config.default_language = config['default_language'] if config['default_language']
-      end
+      config = YAML.safe_load(ERB.new(File.read(path)).result, [Symbol], [], ['default'])[Rails.env]
+      CouchPotato.configure(config)
     else
-      Rails.logger.warn "Rails.root/config/couchdb.yml does not exist. Not configuring a database."
+      Rails.logger.warn 'Rails.root/config/couchdb.yml does not exist. Not configuring a database.'
     end
   end
 
   if defined?(::Rails::Railtie)
     class Railtie < ::Rails::Railtie
-      initializer 'couch_potato.load_config' do |app|
+      initializer 'couch_potato.load_config' do |_app|
         CouchPotato.rails_init
       end
     end

data/lib/couch_potato/validation.rb

@@ -3,9 +3,17 @@ require 'active_model/translation'
 
 module CouchPotato
   module Validation
+    module ValidationContext
+      def valid?(context = nil)
+        context ||= new? ? :create : :update
+        super context
+      end
+    end
+
     def self.included(base) #:nodoc:
       base.send :include, ::ActiveModel::Validations
       base.send :include, ::ActiveModel::Validations::Callbacks
+      base.send :include, ValidationContext
     end
   end
 end

data/lib/couch_potato/version.rb

@@ -1,4 +1,4 @@
 module CouchPotato
-  VERSION = '1.7.0'.freeze
-  RSPEC_VERSION = '3.4.0'.freeze
+  VERSION = '1.10.1'.freeze
+  RSPEC_VERSION = '4.0.2'.freeze
 end

data/lib/couch_potato/view/base_view_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CouchPotato
   module View
     class BaseViewSpec
@@ -7,7 +9,7 @@ module CouchPotato
       private :klass, :options
 
       def initialize(klass, view_name, options, view_parameters)
-        normalized_view_parameters = normalize_view_parameters view_parameters
+        normalized_view_parameters = ViewParameters.normalize_view_parameters view_parameters
 
         @list_name = normalized_view_parameters.delete(:list) || options[:list]
         @language = options[:language] || Config.default_language
@@ -16,13 +18,13 @@ module CouchPotato
         @klass = klass
         @options = options
         @view_name = compute_view_name(view_name,
-          options.key?(:digest_view_name) ? options[:digest_view_name] : Config.digest_view_names)
+                                       options.key?(:digest_view_name) ? options[:digest_view_name] : Config.digest_view_names)
         @design_document = translate_to_design_doc_name(klass.to_s, @view_name, @list_name)
         @list_params = normalized_view_parameters.delete :list_params
 
         @list_function = klass.lists(@list_name) if @list_name
         @view_parameters = {}
-        [:group, :include_docs, :descending, :group_level, :limit].each do |key|
+        %i[group include_docs descending group_level limit].each do |key|
           @view_parameters[key] = options[key] if options.include?(key)
         end
         @view_parameters.merge!(normalized_view_parameters)
@@ -47,40 +49,14 @@ module CouchPotato
         end
       end
 
-      def normalize_view_parameters(params)
-        hash = wrap_in_hash params
-        remove_nil_stale(replace_range_key(hash))
-      end
-
-      def remove_nil_stale(params)
-        params.reject{|name, value| name.to_s == 'stale' && value.nil?}
-      end
-
-      def wrap_in_hash(params)
-        if params.is_a?(Hash)
-          params
-        else
-          {:key => params}
-        end
-      end
-
-      def replace_range_key(params)
-        if((key = params[:key]).is_a?(Range))
-          params.delete :key
-          params[:startkey] = key.first
-          params[:endkey] = key.last
-        end
-        params
-      end
-
       def assert_valid_view_parameters(params)
         params.keys.each do |key|
-          fail ArgumentError, "invalid view parameter: #{key}" unless valid_view_parameters.include?(key.to_s)
+          raise ArgumentError, "invalid view parameter: #{key}" unless valid_view_parameters.include?(key.to_s)
         end
       end
 
       def valid_view_parameters
-        %w(list_params key keys startkey startkey_docid endkey endkey_docid limit stale descending skip group group_level reduce include_docs inclusive_end)
+        %w[list_params key keys startkey startkey_docid endkey endkey_docid limit stale descending skip group group_level reduce include_docs inclusive_end]
       end
 
       def translate_to_design_doc_name(klass_name, view_name, list_name)
@@ -91,7 +67,7 @@ module CouchPotato
         doc_name = klass_name.downcase
 
         if CouchPotato::Config.split_design_documents_per_view
-          doc_name += "_view_#{view_name}"  if view_name.present?
+          doc_name += "_view_#{view_name}" if view_name.present?
           doc_name += "_list_#{list_name}" if list_name.present?
         end
         doc_name