counter_one 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e507eac4fc8bc71388c8ee667c96a0d0595ef15778702af8290e889f507abeb0
+  data.tar.gz: 3e72f346a0b0fa66ff5c9e18b2717275be8435b80775a8c033c1544af085b56c
+SHA512:
+  metadata.gz: e0b73fea1fadcbc87f516f16046b8f01e6739182850c2c3fb4efad0edddd5d94125d4722d6ded491cdeeb0d9780c740fb7cf1f92eef4f2c28137613043e80e82
+  data.tar.gz: 05e948b8b604653c5bd2949913163fce58e2e5d69f65539b3d02342ef3844123edd66b947e9bc4f90b847bb10e69e7208eab236277091f2ff0741d150fb8f796

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-07-19
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in counter_one.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    counter_one (0.1.0)
+      activerecord (>= 4.2)
+      activesupport (>= 4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activerecord (7.0.3.1)
+      activemodel (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activesupport (7.0.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.16.2)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    sqlite3 (1.4.4)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  counter_one!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  sqlite3
+
+BUNDLED WITH
+   2.2.26

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Nikolay Seskin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# CounterOne
+
+Improved counter cache for Rails app with support various relationships and conditions.
+
+## Features
+- Updates the counter cache for create, destroy, and update actions, as well as any single action
+- Counter caches for multi levels and has_one/has_many through relations
+- Conditions for counter caches
+- Recalculating counter caches with conditions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'counter_one'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install counter_one
+
+## Usage
+
+### Counter cache for simple relation
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+  counter_one :user
+end
+```
+
+It will be keep up to date products_count for users when product is created or destroyed.
+
+### Counter cache for multi levels relation
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :product
+  counter_one [:product, :user]
+end
+```
+
+It will be keep up to date comments_count for users when comment is created or destroyed.
+
+### Counter cache for has_one through relation
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :product
+  has_one :user, through: :product
+
+  counter_one :user
+end
+```
+
+### Counter cache with custom counter field
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+  counter_one :user, column: :custom_counter
+end
+```
+
+### Counter cache with conditions
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+  counter_one :user, column: :active_products, only: ->(product) { product.active? }
+end
+```
+
+### Counter cache only for deleted records
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :user
+  counter_one :user, column: :deleted_products, on: [:destroy]
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/counter_one/counter.rb

@@ -0,0 +1,74 @@
+module CounterOne
+  class Counter
+
+    attr_reader :model, :relation, :options
+
+    def initialize(model, relation, options)
+      @model = model
+      @relation = [relation].flatten
+      @options = options
+    end
+
+    def update_counter(record, operator, changed_record = nil)
+      counter_record = record
+      klass = model
+
+      relation.each do |rel|
+        unless klass.reflect_on_association(rel)
+          raise "Can't find relation #{rel} for #{klass.to_s}"
+        end
+
+        counter_record = counter_record.send(rel)
+        klass = counter_record.class
+
+        return unless counter_record
+      end
+
+      if options[:only]
+        unless options[:only].is_a?(Proc)
+          raise ArgumentError.new(":only must be a Proc with conditions")
+        end
+
+        return unless options[:only].call(record)
+      end
+
+      if changed_record
+        return if options[:only] ? condition_not_changed?(record, changed_record) : relation_id_not_changed?(record)
+      end
+
+      if counter_record
+        column = options[:column] || "#{record.class.to_s.tableize}_count"
+
+        if counter_record.is_a?(ActiveRecord::Associations::CollectionProxy)
+          counter_record.each { |r| r.send(operator, column) }
+        else
+          counter_record.send(operator, column)
+        end
+      end
+    end
+
+    def recalculate_scope
+      options[:recalculate_scope]
+    end
+
+    def relation_chain
+      klass = model
+
+      relation.each_with_object([]) { |rel, chain|
+        chain << klass.reflect_on_association(rel).chain.map(&:name).reverse
+        klass = rel.to_s.classify.constantize
+      }.flatten
+    end
+
+    private
+
+    def condition_not_changed?(record, changed_record)
+      options[:only].call(record) == options[:only].call(changed_record)
+    end
+
+    def relation_id_not_changed?(record)
+      relation_fk = model.reflect_on_association(relation_chain.first).foreign_key
+      record.saved_changes[relation_fk].blank?
+    end
+  end
+end

data/lib/counter_one/extensions.rb

@@ -0,0 +1,79 @@
+module CounterOne
+  module Extensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      attr_reader :counter_one_cache
+
+      def counter_one(relation, options = {})
+        @counter_one_cache ||= []
+
+        @counter_one_cache << Counter.new(self, relation, options)
+
+        on = [options[:on]].flatten.compact
+
+        after_create  :increment_counters if on.empty? || on.include?(:create)
+        after_destroy :decrement_counters if on.empty? || on.include?(:destroy)
+        after_update  :update_counters if on.empty? || on.include?(:update)
+      end
+
+      def counter_one_recalculate(relation = nil)
+        counters = relation ? counter_one_cache.select { |counter| counter.relation == [relation].flatten } : counter_one_cache
+        counters.each { |counter| recalculate_counters(counter) }
+      end
+
+      private
+
+      def recalculate_counters(counter)
+        counter_relation_chain = counter.relation_chain
+
+        joins_chain = counter_relation_chain.reverse.inject() { |value, key| { key => value } }
+        counter_relation_table_name = counter_relation_chain.last.to_s.classify.constantize.table_name
+        
+        result = self
+                  .joins(joins_chain)
+                  .then { |scope| counter.recalculate_scope ? scope.merge(counter.recalculate_scope) : scope }
+                  .group("#{counter_relation_table_name}.id")
+                  .count
+
+        result.each do |key, value|
+          column = counter.options[:column] || "#{self.to_s.tableize}_count"
+          counter.relation_chain.last.to_s.classify.constantize.find(key).update(column => value)
+        end
+      end
+
+    end
+
+    private
+
+    def increment_counters
+      self.class.counter_one_cache.each do |counter|
+        counter.update_counter(self, :increment!)
+      end
+    end
+
+    def decrement_counters
+      self.class.counter_one_cache.each do |counter|
+        counter.update_counter(self, :decrement!)
+      end
+    end
+
+    def update_counters
+      self.class.counter_one_cache.each do |counter|
+        counter.update_counter(record_before_save, :decrement!, self)
+        counter.update_counter(self, :increment!, record_before_save)
+      end
+    end
+
+    def record_before_save
+      record = self.dup
+
+      self.saved_changes.each do |key, value|
+        record.assign_attributes(key => value.first)
+      end
+
+      record
+    end
+  end
+end

data/lib/counter_one/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CounterOne
+  VERSION = "0.1.0"
+end

data/lib/counter_one.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'active_support/concern'
+require 'active_support/lazy_load_hooks'
+
+require_relative "counter_one/version"
+require 'counter_one/extensions'
+require 'counter_one/counter'
+
+module CounterOne
+  class Error < StandardError; end
+  
+  # def self.config
+  #   yield(self) if block_given?
+  #   self
+  # end
+end
+
+# extend ActiveRecord with our own code here
+ActiveSupport.on_load(:active_record) do
+  include CounterOne::Extensions
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: counter_one
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikolay Seskin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CounterOne provides improved counter cache for Rails app with support
+  various relationships and conditions.
+email:
+- nseskin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/counter_one.rb
+- lib/counter_one/counter.rb
+- lib/counter_one/extensions.rb
+- lib/counter_one/version.rb
+homepage: https://github.com/finist/counter_one
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/finist/counter_one
+  source_code_uri: https://github.com/finist/counter_one
+  changelog_uri: https://github.com/finist/counter_one/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Improved counter cache for Rails app.
+test_files: []