couch_potato 1.6.5 → 1.10.0

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
@@ -172,10 +270,10 @@ module CouchPotato
 
     def bulk_load(ids)
       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 +281,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/revisions.rb

@@ -0,0 +1,14 @@
+module CouchPotato
+  module Persistence
+    module Revisions
+      # returns all available revisions of a document, first to last.
+      # causes n+1 requests. do not use in production code.
+      def _revisions
+        with_revs = database.couchrest_database.get(id, revs: true, revs_info: true)._document
+        revs_info = with_revs[:_revs_info]
+        revs = revs_info.select {|info| info[:status] == 'available' }.map {|info| info[:rev] }
+        revs.reverse.map {|rev| database.couchrest_database.get(id, rev: rev) }
+      end
+    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,10 +6,10 @@ 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'
+require File.dirname(__FILE__) + '/persistence/revisions'
 require File.dirname(__FILE__) + '/forbidden_attributes_protection'
 require File.dirname(__FILE__) + '/view/custom_views'
 require File.dirname(__FILE__) + '/view/lists'
@@ -20,9 +20,11 @@ module CouchPotato
   module Persistence
 
     def self.included(base) #:nodoc:
-      base.send :include, Properties, Callbacks, Json, CouchPotato::View::CustomViews, CouchPotato::View::Lists
+      base.send :include, Properties, Callbacks, Json, CouchPotato::View::CustomViews,
+        CouchPotato::View::Lists
       base.send :include, DirtyAttributes, GhostAttributes, Attachments
-      base.send :include, MagicTimestamps, ActiveModelCompliance, ForbiddenAttributesProtection
+      base.send :include, MagicTimestamps, ActiveModelCompliance,
+        ForbiddenAttributesProtection, Revisions
       base.send :include, Validation
       base.class_eval do
         attr_accessor :_id, :_rev, :_deleted, :database

data/lib/couch_potato/railtie.rb

@@ -1,28 +1,23 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../rails/reload_classes')
+# frozen_string_literal: true
+
 require 'erb'
 
 module CouchPotato
   def self.rails_init
+    require File.expand_path(File.dirname(__FILE__) + '/../../rails/reload_classes') if Rails.env.development?
     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.6.5'
-  RSPEC_VERSION = '3.0.0'
+  VERSION = '1.10.0'.freeze
+  RSPEC_VERSION = '4.0.2'.freeze
 end