passive_columns 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9d9611e28f0d1a9a3bcb4c048158d3757294c0e13e2b3cf17f1912c62bf0886
-  data.tar.gz: 7650f8e0c2da1e72d9ddeb29b3be36c900ce2e3b887a59affcb13b6da531a270
+  metadata.gz: 56f6f5fdf5c333ca2fe7ba55e3974b21b67662362a21848b1b31cf6216e080a1
+  data.tar.gz: adbcac3dfba991402e20dc7fc3d2a616498af1998ae4b0d5b4a1a9895254b2c4
 SHA512:
-  metadata.gz: 103734dbe62aad0bf4a956c9fafa6ac69d0f92f4f57f673b3cff7329f6b854a02d69d561442b5a812d2c2416b426f2f5a8bd072f590b52a70b0a8b4023dc86bf
-  data.tar.gz: d7c56d6635c3537c472cd5286a29735c9b6e0ccd06d515a68de64367e16a58ee24c32f540e2f76635c17091a990c08ca8a3f46c9b49b3bfb888385876eb69877
+  metadata.gz: 9ca11045bc3d47d290e6797c3b834eb4f1d8770ffd955c3be392b51c5d796bd2049c2ae7c849e85f189ce4e91524928cad8a5d55463fc36c082bc54c74c47aa8
+  data.tar.gz: df054d53f99a0e292292fe6935ba4dc3e2d707856372043468de0afc121065d9ca515ffb528d7292aba9a5b7f378114ac55b7d8b7e640268ceae897351c18cb1

data/README.md

@@ -1,11 +1,73 @@
-# PASSIVE_COLUMNS
-Short description and motivation.
+# Passive Columns
+A gem that extends `Active Record` to retrieve columns from DB on demand.<br>
+Works with `Rails` >= 7 and `Ruby` >= 2.7
 
 ## Usage
-How to use my plugin.
+
+```ruby 
+  class Page < ApplicationRecord
+    include PassiveColumns
+    passive_columns :huge_article
+  end
+```
+
+`ActiveRecord::Relation` now retrieves all the columns except the passive ones by default.
+```ruby
+  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.
+```ruby
+  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
+
+```ruby
+  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...'
+```
+
+---
+
+
+Another way to get columns on demand is to use the `load_column` method.
+
+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.
+
+```ruby 
+  class User < ActiveRecord::Base
+    include PassiveColumns
+  end
+```
+```ruby
+user = User.select('id').take!
+user.name # missing attribute 'name' for User (ActiveModel::MissingAttributeError)
+
+user.load_column(:name) # => SELECT "name" FROM "users" WHERE "id" = ? LIMIT ?
+'John'
+user.load_column(:name) # no additional query. It's already loaded
+'John'
+
+user.name
+'John'
+```
+
+By the way, it uses the Rails' `.pick` method to get the value of the column under the hood
+
 
 ## Installation
-Add this line to your application's Gemfile:
+Add this line to your Gemfile:
 
 ```ruby
 gem "passive_columns"
@@ -13,7 +75,7 @@ gem "passive_columns"
 
 And then execute:
 ```bash
-$ bundle
+$ bundle install
 ```
 
 Or install it yourself as:
@@ -21,8 +83,53 @@ Or install it yourself as:
 $ gem install passive_columns
 ```
 
-## Contributing
-Contribution directions go here.
+# Motivation
+
+There are situations when you have an `Active Record` model with columns
+that you don't want to fetch from a DB every time you manipulate the model.
+
+What options do you have?
+
+```ruby
+# You can declare a scope to exclude columns dynamically from the select settings.
+scope :skip_retrieving, ->(*v) { select(column_names.map(&:to_sym) - Array.wrap(v)) }
+# or you can select only the columns you need
+scope :only_main_columns, -> { select(%w[id name description uuid]) }
+
+# When it's really important to skip unnecessary columns, you can use the default scope.
+default_scope { :only_main_columns }
+```
+
+At first glance, it seems like a good solution.
+Until you realize that you cannot manipulate the model without the columns you skipped, as there are validation rules related to them.
+
+```ruby
+
+class Project < ActiveRecord::Base
+  scope :only_main_columns, -> { select(%w[id name description uuid]) }
+
+  validates :id, :name, presence: true
+  validates :settings, presence: true
+end
+
+
+p = Project.only_required_columns.take
+p.update!(name: 'New name') # missing attribute 'settings' for Project (ActiveModel::MissingAttributeError)
+
+```
+One way to avoid this is to check for the presence of the attribute before validating it.
+
+```ruby
+validates :huge_article, presence: true, if: -> { attributes.key?('huge_article') }
+```
+
+Unfortunately, boilerplate code is needed for such a simple task.
+You just wanted to exclude some columns and be able to manipulate a model without extra steps.
+
+`passive_columns` tries to solve this problem by allowing you to exclude columns from the selection 
+and also allows you to retrieve them on demand when needed.
+
+
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/passive_columns/active_record_relation_extension.rb

@@ -5,19 +5,23 @@ module PassiveColumns
   # 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
+      if klass.try(:_passive_columns).present? && select_values.blank?
+        self.select_values = klass.column_names - klass._passive_columns
+      end
       super
     end
 
     def to_sql
-      _set_columns_except_passive_if_nothing_selected
-      super
-    end
+      return @to_sql unless @to_sql.nil?
 
-    def _set_columns_except_passive_if_nothing_selected
-      return nil if klass.try(:_passive_columns).blank? || select_values.any?
+      # @see ActiveRecord::QueryMethods::assert_mutability!
+      return super if @loaded || (defined?(@arel) && @arel)
 
-      self.select_values = klass.column_names - klass._passive_columns
+      if klass.try(:_passive_columns).present? && select_values.blank?
+        self.select_values = klass.column_names - klass._passive_columns
+      end
+
+      super
     end
   end
 end

data/lib/passive_columns/loader.rb

@@ -1,9 +1,5 @@
 # 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

data/lib/passive_columns/railtie.rb

@@ -1,17 +1,5 @@
 # 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'
 

data/lib/passive_columns/version.rb

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

data/lib/passive_columns.rb

@@ -85,7 +85,7 @@ module PassiveColumns
       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?
+        opts[:if] = ([-> { attributes.key?(passive_column.first) }] + Array(opts[:if])) if passive_column.present?
       end
       super(name, *filter_list, opts, &block)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passive_columns
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Dmitry Golovin