scope_sql_counter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fae64a9faf210fc38ef1a60f4c51af02f0c953a968e2e2b125caeac3af5bb617
+  data.tar.gz: 823287434bc42de868d69ece9f6ab3302fba14acb2ffc96715e6782757b758af
+SHA512:
+  metadata.gz: 5d1c3562435a050ad97d63854a63d91eabdf58464039e842aaa1477c00a800fceb40d9056c788d598903102f4de26197210f5aad56aac039aeb9e463481f6e6e
+  data.tar.gz: 3e440d456f3f0710a1eff8087dc6f0479db14e36766a3756230d8750ade5d451e54edcb9d609db7b4e05969d4c57ca958c8fd79ef9274c79fdd15851096ec4b6

data/.gitignore

@@ -0,0 +1,51 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore Byebug command history file.
+.byebug_history
+
+.rvmrc
+.rbenv*
+.ruby-version
+.ruby-gemset
+.vimrc
+.powrc
+.DS_Store
+/config/database.yml
+/config/secrets.yml
+/public/uploads/
+/public/system/
+/public/assets/
+
+dump.rdb
+/public/packs
+/public/packs-test
+/node_modules
+yarn-debug.log*
+.yarn-integrity
+
+# Ignore local configuration
+/config/local.rb
+
+# Ignore editor-specific configuration
+/.vscode
+
+# Ignore uploaded files in development.
+/storage/*
+!/storage/.keep
+
+# Ignore master key for decrypting credentials and more.
+/config/master.key
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    scope_sql_counter (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    rake (12.3.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 5.2.3)
+  bundler (~> 2.0.2)
+  rake (~> 12.3.3)
+  rspec (~> 3.8.0)
+  scope_sql_counter!
+
+BUNDLED WITH
+   2.0.2

data/README.md

@@ -0,0 +1,122 @@
+# Scope SQL Counter
+An ActiveRecord extension that helps you count association using SQL.
+
+Since the association counting was computed within a single query, it's at least better
+than doing n+1 queries. The main idea is that you don't need to use counter cache library
+that migrate new columns, use 3rd party app and stuff.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scope_sql_counter'
+```
+
+## Usage
+Unfortunately, this gem heavily relies on ActiveRecord. Well, since most
+rails app use it, you are probably safe? Also, please make sure that all your
+associations have indices in order to maximize the speed of your query.
+
+### Add the scopes
+So let's say your User model have a `has_many :blogs` association.
+Use the ActiveRecord extension method to generate the scope:
+```ruby
+class User < ActiveRecord::Base
+  has_many :blogs, dependent: :destroy
+
+                    # scope name      # association name
+  scope_sql_counter :with_blog_count, :blogs
+end
+```
+
+This will create a scope `User.with_blog_count` on your model. And if you call it:
+```ruby
+irb: User.with_blog_count
+=> User Load (0.8ms)
+   SELECT  users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id ) AS blogs_count
+     FROM "users" ORDER BY "users"."id" ASC LIMIT $1  [["LIMIT", 1]]
+```
+
+As you can see, when the query executes, it sets an alias `AS blogs_count`.
+This alias should be available as a readonly attribute on your
+ActiveRecord model instance. For example:
+
+```ruby
+users = User.with_blog_count
+user = users.first
+
+user.blogs_count # => 8
+```
+
+## Multiple scopes
+There are times you may want to fetch multiple counter on your associations.
+You can achieve this by doing:
+```ruby
+class User < ActiveRecord::Base
+  has_many :blogs
+  has_many :comments
+
+  scope :with_multiple_count, -> {
+    select(ScopeSqlCounter.new(context: self, association_key: :blogs).call)
+      .select(ScopeSqlCounter.new(context: self, association_key: :comments).call)
+  }
+end
+
+# But.. it doesn't look good? Don't worry! We can make it cleaner:
+
+class User < ActiveRecord::Base
+ scope_sql_counter :with_blog_count, :blogs
+ scope_sql_counter :with_comment_count, :comments
+
+ scope :with_multiple_count, -> { with_blog_count.with_comment_count }
+end
+```
+
+### Additional configurations
+`count_alias`: Sets the alias name for the counter instead of the default
+
+`conditions`: Adds more condition on your scope counter instead of plain association call
+
+1. `count_alias` . For example:
+```ruby
+scope_sql_counter :with_blog_count, :blogs, count_alias: :posts_count
+```
+```ruby
+irb: users = User.with_blog_count
+=> User Load (0.8ms)
+   SELECT  users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id ) AS posts_count
+     FROM "users" ORDER BY "users"."id" ASC LIMIT $1  [["LIMIT", 1]]
+
+irb: users.first.posts_count # => 0
+```
+
+2. `conditions` . For example:
+```ruby
+scope_sql_counter :with_published_blog_count, :blogs,
+                  conditions: 'blogs.published_at IS NOT NULL',
+                  count_alias: :published_blog_count
+```
+```ruby
+irb: users = User.with_blog_count
+=> User Load (0.8ms)
+   SELECT  users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id
+                        AND blogs.published_at IS NOT NULL) AS published_blog_count
+     FROM "users" ORDER BY "users"."id" ASC LIMIT $1  [["LIMIT", 1]]
+
+irb: users.first.published_blog_count # => 0
+```
+
+### has_many :through and has_and_belongs_to_many
+Dont' worry! It fully supports many to many relationships just fine!
+
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Add unit test
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+
+## MIT
+**scope_sql_counter** © 2019+, Harvey Ico. Released under the [MIT](http://mit-license.org/) License.

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'irb'
+require 'logger'
+require 'active_record'
+require 'scope_sql_counter'
+
+class SimpleFormatter < Logger::Formatter
+  # This method is invoked when a log event occurs
+  def call(severity, timestamp, progname, msg)
+    "#{String === msg ? msg : msg.inspect}\n"
+  end
+end
+
+ActiveRecord::Base.logger ||= Logger.new(STDOUT, formatter: SimpleFormatter.new)
+
+IRB.start

data/lib/scope_sql_counter.rb

@@ -0,0 +1,13 @@
+require 'scope_sql_counter/syntax'
+require 'scope_sql_counter/orm/active_record'
+
+unless defined?(ActiveRecord)
+  class ActiveRecordDoesNotExist < StandardError; end
+
+  raise ActiveRecordDoesNotExist.new('Sorry, this gem only supports active record right now.')
+end
+
+module ScopeSqlCounter
+end
+
+ActiveRecord::Base.extend(ScopeSqlCounter::Orm::ActiveRecord)

data/lib/scope_sql_counter/orm/active_record.rb

@@ -0,0 +1,18 @@
+module ScopeSqlCounter
+  module Orm
+    module ActiveRecord
+      def scope_sql_counter(scope_name, association_key, conditions: nil, count_alias: nil)
+        scope scope_name, -> {
+          syntax = ScopeSqlCounter::Syntax.new(
+            context: self,
+            association_key: association_key,
+            conditions: conditions,
+            count_alias: count_alias
+          )
+
+          select(syntax.call)
+        }
+      end
+    end
+  end
+end

data/lib/scope_sql_counter/syntax.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ScopeSqlCounter
+  class Syntax
+    COUNTER_SQL_QUERY = <<-SQL
+      (
+        SELECT COUNT(:target.id)
+        FROM :target
+        WHERE :target.:foreign_key = :context.id
+        :conditions
+      ) AS :alias
+    SQL
+
+    attr_reader :context, :association_key, :conditions, :count_alias
+
+    def initialize(context:, association_key:, conditions: nil, count_alias: nil)
+      @context = context
+      @association_key = association_key
+      @conditions = conditions
+      @count_alias = count_alias
+    end
+
+    def call
+      if !context.respond_to?(:select_values) || context.select_values.blank?
+        ["#{context.table_name}.*", query].join(', ')
+      else
+        query
+      end
+    end
+
+    private
+
+    def association
+      reflection = context.reflect_on_association(association_key)
+
+      reflection.through_reflection || reflection
+    end
+
+    def association_table_name
+      if association.macro == :has_and_belongs_to_many
+        association.join_table
+      else
+        association.table_name
+      end
+    end
+
+    def query
+      COUNTER_SQL_QUERY.gsub(':target', association_table_name)
+                       .gsub(':foreign_key', association.foreign_key)
+                       .gsub(':context', context.table_name)
+                       .gsub(':conditions', conditions_sql)
+                       .gsub(':alias', count_alias_sql)
+                       .squish
+    end
+
+    def count_alias_sql
+      count_alias.to_s.presence || "#{association_key}_count"
+    end
+
+    def conditions_sql
+      String.new.tap do |str|
+        if conditions.present?
+          str << "AND #{conditions}"
+        end
+      end
+    end
+  end
+end

data/lib/scope_sql_counter/version.rb

@@ -0,0 +1,3 @@
+module ScopeSqlCounter
+  VERSION = '0.0.1'
+end

data/scope_sql_counter.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'scope_sql_counter/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'scope_sql_counter'
+  s.version     = ScopeSqlCounter::VERSION
+  s.date        = '2019-08-02'
+  s.summary     = 'Don\'t want to use counter cache anymore? Achieve it with plain SQL query instead!'
+  s.description = <<-DESC
+    A gem that provides helper to achieve association counting without hassle.
+    It provides you readonly data inside your ActiveRecord model without executing n+1 queries!
+  DESC
+  s.authors     = ['Harvey Ico']
+  s.email       = 'godstrikerharvey@gmail.com'
+  s.files       = `git ls-files`.split($/)
+  s.homepage    = 'https://github.com/harveyico/scope_sql_counter'
+  s.license     = 'MIT'
+
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_development_dependency 'activerecord', '~> 5.2.3'
+  s.add_development_dependency 'bundler', '~> 2.0.2'
+  s.add_development_dependency 'rake', '~> 12.3.3'
+  s.add_development_dependency 'rspec', '~> 3.8.0'
+end

data/spec/lib/syntax_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'support/test_models'
+
+describe ScopeSqlCounter::Syntax do
+  let!(:count_alias) { nil }
+  let!(:conditions) { nil }
+  let!(:arguments) do
+    {
+      context: UserTest,
+      association_key: :blogs,
+      count_alias: count_alias,
+      conditions: conditions
+    }
+  end
+
+  let!(:sql) do
+    ScopeSqlCounter::Syntax.new(arguments)
+  end
+
+  describe '#call' do
+    context 'when model has no selected_values' do
+      it 'returns all current table attributes and add the SQL counter' do
+        expect(sql.call).to eq('users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id ) AS blogs_count')
+      end
+    end
+
+    context 'when model has select_values' do
+      before do
+        allow(UserTest).to receive(:select_values).and_return('users.*')
+      end
+
+      it 'only returns the SQL counter' do
+        expect(sql.call).to eq('( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id ) AS blogs_count')
+      end
+    end
+
+    context 'if count_alias is passed' do
+      let!(:count_alias) { 'random_count' }
+
+      it 'sets the alias based on the text' do
+        expect(sql.call).to eq('users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id ) AS random_count')
+      end
+    end
+
+    context 'if conditions is passed' do
+      let!(:conditions) { 'blogs.created_at IS NULL' }
+
+      it 'adds the condition on your scope counter' do
+        expect(sql.call).to eq('users.*, ( SELECT COUNT(blogs.id) FROM blogs WHERE blogs.user_id = users.id AND blogs.created_at IS NULL ) AS blogs_count')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'active_record'
+require 'scope_sql_counter'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/support/test_models.rb

@@ -0,0 +1,34 @@
+class BlogTest
+  class << self
+    def table_name
+      'blogs'
+    end
+
+    def foreign_key
+      'user_id'
+    end
+
+    def macro
+      :has_many
+    end
+
+    def through_reflection
+    end
+  end
+end
+
+class UserTest
+  class << self
+    def table_name
+      'users'
+    end
+
+    def reflect_on_association(key)
+      "#{key.to_s.singularize.capitalize}Test".constantize
+    end
+
+    def select_values
+      []
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: scope_sql_counter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Harvey Ico
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+description: |2
+      A gem that provides helper to achieve association counting without hassle.
+      It provides you readonly data inside your ActiveRecord model without executing n+1 queries!
+email: godstrikerharvey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/console
+- lib/scope_sql_counter.rb
+- lib/scope_sql_counter/orm/active_record.rb
+- lib/scope_sql_counter/syntax.rb
+- lib/scope_sql_counter/version.rb
+- scope_sql_counter.gemspec
+- spec/lib/syntax_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_models.rb
+homepage: https://github.com/harveyico/scope_sql_counter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Don't want to use counter cache anymore? Achieve it with plain SQL query
+  instead!
+test_files: []