passive_columns 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a9d9611e28f0d1a9a3bcb4c048158d3757294c0e13e2b3cf17f1912c62bf0886
+  data.tar.gz: 7650f8e0c2da1e72d9ddeb29b3be36c900ce2e3b887a59affcb13b6da531a270
+SHA512:
+  metadata.gz: 103734dbe62aad0bf4a956c9fafa6ac69d0f92f4f57f673b3cff7329f6b854a02d69d561442b5a812d2c2416b426f2f5a8bd072f590b52a70b0a8b4023dc86bf
+  data.tar.gz: d7c56d6635c3537c472cd5286a29735c9b6e0ccd06d515a68de64367e16a58ee24c32f540e2f76635c17091a990c08ca8a3f46c9b49b3bfb888385876eb69877

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Dmitry Golovin
+
+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,28 @@
+# PASSIVE_COLUMNS
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "passive_columns"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install passive_columns
+```
+
+## Contributing
+Contribution directions go here.
+
+## 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 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]

data/lib/passive_columns/active_record_association_builder_extension.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PassiveColumns
+  # This module is used to extend the ActiveRecord::Associations::Builder::Association class
+  # to add a proc with default scope to the association if there is no proc defined.
+  module ActiveRecordAssociationBuilderExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def create_reflection(*)
+        super.tap do |res|
+          next if res.polymorphic?
+          next unless _klass_has_passive_columns(res) && res.scope.nil?
+
+          default_relation = -> { unscoped }
+          res.instance_variable_set(:@scope, proc { instance_exec(&default_relation) })
+        end
+      end
+
+      # Check if the association class has passive columns
+      # @param [ActiveRecord::Reflection::AssociationReflection] res
+      def _klass_has_passive_columns(res)
+        res.klass.respond_to?(:_passive_columns)
+      rescue NameError
+        # If +config.eager_load!+ is disabled, an association class may not be loaded yet
+        # so we can't constantize to check if the class has passive columns.
+        # In this case, we assume the class has passive columns.
+        true
+      end
+    end
+  end
+end

data/lib/passive_columns/active_record_relation_extension.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PassiveColumns
+  # ActiveRecordRelationExtension is a module that extends ActiveRecord::Relation
+  # to automatically select all columns except passive columns if no columns are selected.
+  module ActiveRecordRelationExtension
+    def exec_main_query(**args)
+      _set_columns_except_passive_if_nothing_selected
+      super
+    end
+
+    def to_sql
+      _set_columns_except_passive_if_nothing_selected
+      super
+    end
+
+    def _set_columns_except_passive_if_nothing_selected
+      return nil if klass.try(:_passive_columns).blank? || select_values.any?
+
+      self.select_values = klass.column_names - klass._passive_columns
+    end
+  end
+end

data/lib/passive_columns/loader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# @!attribute [r] lazy_columns
+# @return [Array<Symbol>]
+# @!attribute [r] model
+# @return [LazyColumns]
+module PassiveColumns
+  # Loader is a class helper that loads a column value from the database if it is not loaded yet.
+  class Loader
+    attr_reader :passive_columns, :model
+
+    # @param [LazyColumns] model
+    # @param [Array<Symbol>] passive_columns
+    def initialize(model, passive_columns)
+      @model = model
+      @passive_columns = passive_columns
+    end
+
+    # @param [Symbol, String] column
+    # @param [Boolean] force
+    # @return [any]
+    def load(column, force: false)
+      return yield if block_given?
+
+      model.send(column)
+    rescue ActiveModel::MissingAttributeError
+      allowed_columns = (force ? [column] : passive_columns).map(&:to_s)
+      raise if allowed_columns.exclude?(column.to_s) || identity_constraints.value?(nil)
+
+      value = pick_value(column)
+      model[column] = value
+      model.send(:clear_attribute_change, column)
+      value
+    end
+
+    private
+
+    def pick_value(column)
+      model.class.unscoped.where(identity_constraints).pick(column)
+    end
+
+    def identity_constraints
+      @identity_constraints ||= model.send(:_query_constraints_hash)
+    end
+  end
+end

data/lib/passive_columns/railtie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# require 'passive_columns/active_record_relation_extension'
+
+# module PassiveColumns # :nodoc:
+#   class Railtie < Rails::Railtie # :nodoc:
+#     config.to_prepare do |_app|
+#       ActiveSupport.on_load(:active_record) do
+#         ActiveRecord::Relation.prepend(ActiveRecordRelationExtension)
+#       end
+#     end
+#   end
+# end
+
+require 'passive_columns/active_record_relation_extension'
+require 'passive_columns/active_record_association_builder_extension'
+
+module PassiveColumns # :nodoc:
+  class Railtie < Rails::Railtie # :nodoc:
+    config.to_prepare do |_app|
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Relation.prepend ActiveRecordRelationExtension
+        ActiveRecord::Associations::Builder::Association.prepend ActiveRecordAssociationBuilderExtension
+      end
+    end
+  end
+end

data/lib/passive_columns/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PassiveColumns
+  VERSION = '0.1.2'
+end

data/lib/passive_columns.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'passive_columns/railtie' if defined?(Rails::Railtie)
+require 'passive_columns/loader'
+
+# PassiveColumns module is the module
+# that allows you to skip retrieving the column values from the database by default.
+# The columns are retrieved only when they are called.
+# This module is useful when you have a model with a lot of columns
+# and you don't want to retrieve all of them at once.
+#
+#  class Page < ApplicationRecord
+#    include PassiveColumns
+#    passive_columns :huge_article
+#  end
+#
+# By default it retrieves all the columns except the passive ones.
+#
+#  article = Page.where(status: :active).to_a
+#  # => SELECT "pages"."id", "pages"."status", "pages"."title" FROM "pages" WHERE "pages"."status" = 'active'
+#
+# If you specify the columns via select it retrieves only the specified columns and nothing more.
+#
+#  page = Page.select(:id, :title).take # => #<Page id: 1, title: "Some title">
+#  page.to_json # => {"id": 1, "title": "Some title"}
+#
+# But you still has an ability to retrieve the passive column on demand
+#
+#  page.huge_article
+#  # => SELECT "pages"."huge_article" WHERE "pages"."id" = 1 LIMIT 1
+#  # => 'Some huge article...'
+#  page.to_json # => {"id": 1, "title": "Some title", "huge_article": "Some huge article..."}
+#
+# The next time you call the passive column it won't hit the database as it is already loaded.
+#  page.huge_article # => 'Some huge article...'
+module PassiveColumns
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_passive_columns, default: []
+  end
+
+  class_methods do
+    # Specify column names for on-demand loading.
+    # While the columns aren't actively loading, they are still responsive and load when called upon.
+    #  passive_columns :huge_article, :settings
+    # @param [Array<Symbol>] columns
+    # @return [void]
+    def passive_columns(*columns)
+      self._passive_columns = columns.map(&:to_s)
+      columns.each do |column|
+        define_method(column) { _passive_column_loader.load(column) { super() } }
+        define_method(:"#{column}=") do |value|
+          _passive_column_loader.load(column)
+          super(value)
+        end
+      end
+    end
+
+    # Each validation rule directly associated with a passive column
+    # has an "if: -> {..}" added by default to skip validation if the column is not set.
+    #  passive_columns :huge_article
+    #  validates :huge_article, presence: true
+    #
+    # The above code converts the validation rule into a rule with IF under the hood.
+    # and will be equivalent:
+    #  passive_columns :huge_article
+    #  validates :huge_article, presence: true, if: -> { attributes.key?('huge_article') }
+    #
+    # Another example with a condition:
+    #  passive_columns :huge_article
+    #  validates :huge_article, presence: true, if: -> { status == 'active' }
+    #
+    # The above code will be equivalent to the below under the hood:
+    #  passive_columns :huge_article
+    #  validates :huge_article, presence: true, if: -> { attributes.key?('huge_article') && status == 'active' }
+    #
+    # !! A validation rule will not be converted if the rule has been set for many attributes.
+    #  passive_columns :huge_article
+    #  validates :huge_article, :settings, presence: true
+    # The code above won't be transformed under the hood and the "if" condition won't be added.
+    # It is important to set the validation rule for each "passive column" separately.
+    # Otherwise, the passive column will be retrieved from DB before validation itself.
+    def set_callback(name, *filter_list, &block)
+      opts = filter_list.extract_options!
+      if name == :validate && opts[:attributes]&.one?
+        passive_column = opts[:attributes].map(&:to_s) & _passive_columns
+        opts[:if] = ([-> { attributes.key?(passive_column) }] + Array(opts[:if])) if passive_column.present?
+      end
+      super(name, *filter_list, opts, &block)
+    end
+  end
+
+  # This method loads a column value, if not already loaded, from the database
+  # regardless of whether the column is added to "passive_columns" or not.
+  #
+  # It uses the Rails' ".pick" method to get the value of the column under the hood
+  #  user = User.select('id').take!
+  #  user.load_column(:name) # => SELECT "name" FROM "users" WHERE "id" = ? LIMIT ?
+  #  'John'
+  #  user.load_column(:name)
+  #  'John'
+  # @param [Symbol, String] column
+  # @return [any]
+  def load_column(column)
+    _passive_column_loader.load(column, force: true)
+  end
+
+  def _passive_column_loader
+    @_passive_column_loader ||= PassiveColumns::Loader.new(self, _passive_columns)
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: passive_columns
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Dmitry Golovin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: A gem that allows you to exclude some columns from a SELECT query by
+  default and load them only on demand
+email: headman.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/passive_columns.rb
+- lib/passive_columns/active_record_association_builder_extension.rb
+- lib/passive_columns/active_record_relation_extension.rb
+- lib/passive_columns/loader.rb
+- lib/passive_columns/railtie.rb
+- lib/passive_columns/version.rb
+homepage: https://github.com/headmandev/passive_columns
+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.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: A gem that extends Active Record to retrieve columns from a db on demand
+test_files: []