couch_potato 1.7.1 → 1.9.0

data/lib/couch_potato/view/custom_views.rb

@@ -1,9 +1,10 @@
 require 'couch_potato/view/base_view_spec'
+require 'couch_potato/view/flex_view_spec'
 require 'couch_potato/view/model_view_spec'
 require 'couch_potato/view/properties_view_spec'
 require 'couch_potato/view/custom_view_spec'
 require 'couch_potato/view/raw_view_spec'
-
+require 'couch_potato/view/view_parameters'
 
 module CouchPotato
   module View
@@ -25,7 +26,7 @@ module CouchPotato
         def execute_view(view_name, view_parameters) #:nodoc:
           view_spec_class(views(view_name)[:type]).new(self, view_name, views(view_name), view_parameters)
         end
-        
+
         # Declare a CouchDB view, for examples on how to use see the *ViewSpec classes in CouchPotato::View
         def view(view_name, options)
           view_name = view_name.to_s
@@ -42,7 +43,7 @@ module CouchPotato
             CouchPotato::View.const_get("#{name}ViewSpec")
           end
         end
-        
+
         def _find_view(view) #:nodoc:
           (@views && @views[view]) || (superclass._find_view(view) if superclass.respond_to?(:_find_view))
         end

data/lib/couch_potato/view/flex_view_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module CouchPotato
+  module View
+    # A flexible view spec.
+    # It allows to either just define a key and option conditions like
+    # the model view spec or custom map/reduce functions.
+    # In addition, it returns a result object that allows convenient access
+    # to either the raw result, the keys, values, ids or docs. The result object can
+    # be extended with custom module, too.
+    # Examples:
+    # class Thing
+    #   module ResultsExt
+    #     def average_time
+    #       keys.sum / keys.size # can access other result methods
+    #     end
+    #   end
+    #   property :time
+    #   view :by_time, type: :flex, key: :time, extend_results: ResultsExt
+    #   view :by_custom_time, type: :flex,
+    #     reduce: '_sum'
+    #     map: <<~JS
+    #       function(doc) {
+    #         emit(doc.time, 1);
+    #       }
+    #     JS
+    # end
+    #
+    # usage:
+    # irb> result = db.view Thing.by_time
+    # irb> result.raw # raw CouchDB results
+    # irb> result.ids # ids of rows
+    # irb> result.keys # keys emitted in map function
+    # irb> result.values # values emitted in map function
+    # irb> result.average_time # custom method from ResultsExt module
+    # irb> db.view(Thing.by_time(include_docs: true)).docs # documents
+    # irb> db.view(Thing.by_time(reduce: true)).reduce_value # value of first row, i.e. result of the reduce function (without grouping)
+    class FlexViewSpec
+      attr_reader :klass
+
+      class Results
+        attr_accessor :database # set by database
+
+        def initialize(raw_results)
+          @raw_results = raw_results
+        end
+
+        def raw
+          @raw_results
+        end
+
+        def ids
+          rows.map { |row| row['id'] }
+        end
+
+        def keys
+          rows.map { |row| row['key'] }
+        end
+
+        def values
+          rows.map { |row| row['value'] }
+        end
+
+        def reduce_value
+          rows.dig(0, 'value')
+        end
+
+        # returns a count from a CouchDB reduce. returns 0 when the result
+        # set is empty (which would result in `nil` when calling #reduce_value).
+        # you still have to pass reduce=true to the view call.
+        def reduce_count
+          reduce_value || 0
+        end
+
+        def docs
+          rows.map do |row|
+            doc = row['doc']
+            doc.database = database if doc.respond_to?(:database=)
+            doc
+          end
+        end
+
+        def rows
+          @raw_results['rows']
+        end
+      end
+
+      def initialize(klass, view_name, options, view_parameters)
+        @extend_results_module = options[:extend_results]
+        @klass = klass
+        @view_name = view_name
+        @options = options.except(:extend_results)
+        @view_parameters = view_parameters
+      end
+
+      delegate :view_name, :view_parameters, :design_document, :map_function,
+               :reduce_function, :list_name, :lib, :language, to: :view_spec_delegate
+
+      def process_results(results)
+        results = Results.new(results)
+        results.extend @extend_results_module if @extend_results_module
+        results
+      end
+
+      private
+
+      def view_spec_delegate
+        unless @view_spec_delegate
+          view_spec_class = @options[:map] ? RawViewSpec : ModelViewSpec
+          @view_spec_delegate = view_spec_class.new(
+            @klass, @view_name, @options,
+            ViewParameters
+              .normalize_view_parameters(@view_parameters)
+              .reverse_merge(reduce: false, include_docs: false)
+          )
+        end
+        @view_spec_delegate
+      end
+    end
+  end
+end

data/lib/couch_potato/view/view_parameters.rb

@@ -0,0 +1,34 @@
+module CouchPotato
+  module View
+    module ViewParameters
+      module_function
+
+      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
+
+    end
+  end
+end

data/lib/couch_potato.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'couchrest'
 require 'json'
 
@@ -8,15 +10,30 @@ CouchRest.decode_json_objects = true
 
 module CouchPotato
   Config = Struct.new(:database_host, :database_name, :digest_view_names,
-    :split_design_documents_per_view, :default_language).new
+                      :split_design_documents_per_view, :default_language, :additional_databases).new
   Config.split_design_documents_per_view = false
   Config.digest_view_names = false
   Config.default_language = :javascript
   Config.database_host = 'http://127.0.0.1:5984'
+  Config.additional_databases = {}
 
   class NotFound < StandardError; end
   class Conflict < StandardError; end
 
+  def self.configure(config)
+    if config.is_a?(String)
+      Config.database_name = config
+    else
+      config = config.stringify_keys
+      Config.database_name = config['database']
+      Config.database_host = config['database_host'] if config['database_host']
+      Config.additional_databases = config['additional_databases'].stringify_keys if config['additional_databases']
+      Config.split_design_documents_per_view = config['split_design_documents_per_view'] if config['split_design_documents_per_view']
+      Config.digest_view_names = config['digest_view_names'] if config['digest_view_names']
+      Config.default_language = config['default_language'] if config['default_language']
+    end
+  end
+
   # returns all the classes that include the CouchPotato::Persistence module
   def self.models
     @models ||= []
@@ -35,12 +52,17 @@ module CouchPotato
 
   # Returns a specific database instance
   def self.use(database_name)
+    resolved_database_name = resolve_database_name(database_name)
     Thread.current[:__couch_potato_databases] ||= {}
-    Thread.current[:__couch_potato_databases][database_name] = Database.new(couchrest_database_for_name!(database_name)) unless Thread.current[:__couch_potato_databases][database_name]
-    Thread.current[:__couch_potato_databases][database_name]
+    Thread.current[:__couch_potato_databases][resolved_database_name] ||= Database.new(couchrest_database_for_name!(resolved_database_name), name: database_name)
   end
 
-  # Executes a block of code and yields a datbase with the given name.
+  # resolves a name to a database name/full url configured under additional databases
+  def self.resolve_database_name(database_name)
+    Config.additional_databases[database_name] || database_name
+  end
+
+  # Executes a block of code and yields a database with the given name.
   #
   # example:
   #  CouchPotato.with_database('couch_customer') do |couch|
@@ -48,23 +70,24 @@ module CouchPotato
   #  end
   #
   def self.with_database(database_name)
-    Thread.current[:__couch_potato_databases] ||= {}
-    Thread.current[:__couch_potato_databases][database_name] = Database.new(couchrest_database_for_name(database_name)) unless Thread.current[:__couch_potato_databases][database_name]
-    yield Thread.current[:__couch_potato_databases][database_name]
+    yield use(database_name)
   end
 
   # Returns a CouchRest-Database for directly accessing that functionality.
   def self.couchrest_database_for_name(database_name)
-    CouchRest.database(full_url_to_database(database_name, CouchPotato::Config.database_host))
+    Thread.current[:__couchrest_databases] ||= {}
+    Thread.current[:__couchrest_databases][database_name] ||= CouchRest.database(full_url_to_database(database_name, CouchPotato::Config.database_host))
   end
 
   # Creates a CouchRest-Database for directly accessing that functionality.
   def self.couchrest_database_for_name!(database_name)
-    CouchRest.database!(full_url_to_database(database_name))
+    Thread.current[:__couchrest_databases] ||= {}
+    Thread.current[:__couchrest_databases][database_name] ||= CouchRest.database!(full_url_to_database(database_name))
   end
 
   def self.full_url_to_database(database_name = CouchPotato::Config.database_name, database_host = CouchPotato::Config.database_host)
     raise('No Database configured. Set CouchPotato::Config.database_name') unless database_name
+
     if database_name.match(%r{https?://})
       database_name
     else

data/spec/callbacks_spec.rb

@@ -382,13 +382,13 @@ describe "validation callbacks and filter halt" do
 
     property :name
     before_validation :check_name
-    before_validation_on_update :return_false_from_callback
+    before_validation_on_update :abort_callback
 
     def check_name
       errors.add(:name, 'should be Paul') unless name == "Paul"
     end
 
-    def return_false_from_callback
+    def abort_callback
       false
     end
   end
@@ -398,14 +398,14 @@ describe "validation callbacks and filter halt" do
 
     property :name
     before_validation :check_name
-    before_validation_on_save :return_false_from_callback
-    before_validation_on_create :return_false_from_callback
+    before_validation_on_save :abort_callback
+    before_validation_on_create :abort_callback
 
     def check_name
       errors.add(:name, 'should be Paul') unless name == "Paul"
     end
 
-    def return_false_from_callback
+    def abort_callback
       false
     end
   end
@@ -414,9 +414,9 @@ describe "validation callbacks and filter halt" do
     include CouchPotato::Persistence
 
     property :name
-    before_update :return_false_from_callback
+    before_update :abort_callback
 
-    def return_false_from_callback
+    def abort_callback
       false
     end
   end
@@ -425,10 +425,10 @@ describe "validation callbacks and filter halt" do
     include CouchPotato::Persistence
 
     property :name
-    before_save :return_false_from_callback
-    before_create :return_false_from_callback
+    before_save :abort_callback
+    before_create :abort_callback
 
-    def return_false_from_callback
+    def abort_callback
       false
     end
   end
@@ -450,16 +450,42 @@ describe "validation callbacks and filter halt" do
     expect(@db.save_document(@user)).to eq(false)
   end
 
-  it "should return false on saving a document when a before update filter returned false" do
-    @user = FilterSaveUpdateUser.new(:name => "Paul")
-    expect(@db.save_document(@user)).to eq(true)
-    @user.name = 'Bert'
-    expect(@db.save_document(@user)).to eq(false)
-  end
+  if ActiveModel.version.segments.first < 5
+    it "should return false on saving a document when a before update filter returned false" do
+      @user = FilterSaveUpdateUser.new(:name => "Paul")
+      expect(@db.save_document(@user)).to eq(true)
+      @user.name = 'Bert'
+      expect(@db.save_document(@user)).to eq(false)
+    end
 
-  it "should return false on saving a document when a before save or before create filter returned false" do
-    @user = FilterSaveCreateUser.new(:name => "Bert")
-    expect(@db.save_document(@user)).to eq(false)
+    it "should return false on saving a document when a before save or before create filter returned false" do
+      @user = FilterSaveCreateUser.new(:name => "Bert")
+      expect(@db.save_document(@user)).to eq(false)
+    end
+  else
+    class FilterSaveCreateUser5 < FilterSaveCreateUser
+      def abort_callback
+        throw :abort
+      end
+    end
+
+    class FilterSaveUpdateUser5 < FilterSaveUpdateUser
+      def abort_callback
+        throw :abort
+      end
+    end
+
+    it "returns false on saving a document when a before update filter throws :abort" do
+      @user = FilterSaveUpdateUser5.new(:name => "Paul")
+      expect(@db.save_document(@user)).to eq(true)
+      @user.name = 'Bert'
+      expect(@db.save_document(@user)).to eq(false)
+    end
+
+    it "returns false on saving a document when a before save or before create filter throws :abort" do
+      @user = FilterSaveCreateUser5.new(:name => "Bert")
+      expect(@db.save_document(@user)).to eq(false)
+    end
   end
 
 end

data/spec/conflict_handling_spec.rb

@@ -14,7 +14,6 @@ describe 'conflict handling' do
 
     db.couchrest_database.save_doc measurement.reload._document.merge('value' => 2)
 
-    measurement.is_dirty
     db.save measurement do |m|
       m.value += 1
     end

data/spec/property_spec.rb

@@ -93,10 +93,10 @@ describe 'properties' do
 
   it "should persist a big decimal" do
     require 'bigdecimal'
-    c = BigDecimalContainer.new :number => BigDecimal.new( '42.42' )
+    c = BigDecimalContainer.new :number => BigDecimal( '42.42' )
     CouchPotato.database.save_document! c
     c = CouchPotato.database.load_document c.id
-    expect(c.number).to eq(BigDecimal.new( '42.42' ))
+    expect(c.number).to eq(BigDecimal( '42.42' ))
   end
 
   it "should persist a hash" do

data/spec/railtie_spec.rb

@@ -83,6 +83,16 @@ describe "railtie" do
     end
   end
 
+  context 'yaml file contains additional_databases' do
+    it 'assigns additional_databases to config' do
+      allow(File).to receive_messages(:read => "test:\n  database: test\n  additional_databases:\n    db2: test2")
+
+      expect(CouchPotato::Config).to receive(:additional_databases=).with('db2' => 'test2')
+
+      CouchPotato.rails_init
+    end
+  end
+
   it "should process the yml file with erb" do
     allow(File).to receive_messages(:read => "test: \n  database: <%= 'db' %>")
 

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rspec'
 require 'time'
 require 'active_support'
 require 'timecop'
 
-$:.unshift(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'couch_potato'
 
@@ -13,7 +15,7 @@ CouchPotato::Config.database_name = ENV['DATABASE'] || 'couch_potato_test'
 # silence deprecation warnings from ActiveModel as the Spec uses Errors#on
 begin
   ActiveSupport::Deprecation.silenced = true
-rescue
+rescue StandardError
   # ignore errors, ActiveSupport is probably not installed
 end
 
@@ -64,5 +66,4 @@ RSpec::Matchers.define :eql_ignoring_indentation do |expected|
   def strip_indentation(string)
     string.gsub(/^\s+/m, '')
   end
-
 end

data/spec/unit/active_model_compliance_spec.rb

@@ -12,8 +12,12 @@ begin
       end
     end
 
-    def assert_equal(one, other)
-      expect(one).to equal(other)
+    def assert_equal(one, other, _message = nil)
+      expect(one).to eq(other)
+    end
+
+    def assert_respond_to(receiver, method)
+      expect(receiver).to respond_to(method)
     end
 
     class ActiveComment
@@ -62,7 +66,7 @@ begin
     describe "#errors" do
       it "should return a single error as array" do
         @model.valid?
-        expect(@model.errors[:name]).to be_kind_of(Array)
+        expect(@model.errors[:name]).to eq(["can't be blank"])
       end
 
       it "should return multiple errors as array" do

data/spec/unit/attributes_spec.rb

@@ -11,7 +11,7 @@ class Plant
   property :leaf_count
   property :typed_leaf_count, type: Fixnum
   property :integer_something, type: Integer
-  property :typed_leaf_size,  type: Float
+  property :typed_leaf_size, type: Float
   property :branch, type: Branch
 end
 

data/spec/unit/caching_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'database caching' do
+  let(:couchrest_db) do
+    double(:couchrest_db, info: double(:info),
+    root: '', get: double.as_null_object)
+  end
+
+  let(:db) do
+    CouchPotato::Database.new(couchrest_db).tap do |db|
+      db.cache = cache
+    end
+  end
+
+  let(:cache) do
+    {}
+  end
+
+  it 'gets an object from the cache the 2nd time via #load_documemt' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(1).times
+
+    db.load_document '1'
+    db.load_document '1'
+  end
+
+  it 'gets an object from the cache the 2nd time via #load' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(1).times
+
+    db.load '1'
+    db.load '1'
+  end
+
+  it 'gets an object from the cache the 2nd time via #load!' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(1).times
+
+    db.load! '1'
+    db.load! '1'
+  end
+
+  it 'returns the correct object' do
+    doc = double(:doc, 'database=': nil)
+    allow(couchrest_db).to receive_messages(get: doc)
+
+    db.load_document '1'
+    expect(db.load_document('1')).to eql(doc)
+  end
+
+  it 'does not cache bulk loads' do
+    allow(couchrest_db).to receive_messages(bulk_load: {'rows' => []})
+    expect(couchrest_db).to receive(:bulk_load).with(['1']).exactly(2).times
+
+    db.load_document ['1']
+    db.load_document ['1']
+  end
+
+  it 'clears the cache when destroying a document via #destroy_document' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.destroy_document double.as_null_object
+    db.load_document '1'
+  end
+
+  it 'clears the cache when destroying a document via #destroy' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.destroy double.as_null_object
+    db.load_document '1'
+  end
+
+  it 'clears the cache when updating a document via #save_document' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.save_document double.as_null_object
+    db.load_document '1'
+  end
+
+  it 'clears the cache when updating a document via #save_document!' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.save_document! double.as_null_object
+    db.load_document '1'
+  end
+
+  it 'clears the cache when updating a document via #save' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.save double.as_null_object
+    db.load_document '1'
+  end
+
+  it 'clears the cache when updating a document via #save!' do
+    expect(couchrest_db).to receive(:get).with('1').exactly(2).times
+
+    db.load_document '1'
+    db.save! double.as_null_object
+    db.load_document '1'
+  end
+end