better_pluck 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab797655791d6f81727b4da00bd628a89da68b10343f9c50303b39f1651b6592
+  data.tar.gz: 274e7f8dca7d9b9ae5c5e1b0590d1399b9e6144a81e2b8ceaac5d0ec45d91603
+SHA512:
+  metadata.gz: a1a031b47a3322543f3534e6afffcb2a9c1e2f8e05b80dab5cbbd7572e9e9edfcb8fec66a081ca9436029fd3111674ab142e0fe3bcb4f2940d84abf310f2f311
+  data.tar.gz: 9b66b44a7c09a438a57d33e7afc7f1170d5c453d1b0031943fcc7641d388d8a8602ccd9ef35130369eb52089491d7bc0e22bfab2625324d0619e527d5396f7af

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+*.rbc
+pkg/
+spec/reports/
+test/tmp/
+test/version_tmp/
+tmp/
+.bundle/
+Gemfile.lock
+.DS_Store

data/Gemfile

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

data/README.md

@@ -0,0 +1,74 @@
+# BetterPluck
+
+`BetterPluck` adds `pluck_with_methods` and `pluck_with_display_name` to ActiveRecord. These methods allow you to pluck not only database columns but also virtual methods and association data, returning lightweight `Struct` objects instead of heavy ActiveRecord instances.
+
+This approach can reduce memory usage by up to 3-20x compared to loading full ActiveRecord objects.
+
+Primary purpose: to be used in huge form dropdowns for select inputs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'better_pluck', github: "NazarK/better_pluck"
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+### Basic usage
+
+You can pluck database columns and instance methods:
+
+```ruby
+# Assuming Article has a method :name_on_site
+articles = Article.pluck_with_methods(:id, :name, :email, :name_on_site)
+
+articles.first.id           # => 1
+articles.first.name_on_site  # => "My Article" (virtual method)
+```
+
+### Associations
+
+You can also pluck data from nested associations:
+
+```ruby
+articles = Article.pluck_with_methods(
+  :id,
+  :name,
+  author: [:name, :email, :display_name]
+)
+
+articles.first.author.email        # => "author@example.com"
+articles.first.author.display_name # => "John Doe"
+```
+
+### Pluck with Display Name
+
+A convenience method specifically for dropdown lists and collections:
+
+```ruby
+# Automatically includes :display_name for the model and associations
+articles = Article.pluck_with_display_name(:id, :name, author: [:name, :email])
+
+articles.first.display_name         # => "Article Name"
+articles.first.author.display_name # => "Author Name <author@example.com>"
+```
+
+## How it works
+
+1.  **Parsing**: It parses the requested fields to distinguish between database columns, methods, and associations.
+2.  **Joining**: It automatically applies `left_joins` for requested associations.
+3.  **Plucking**: It uses the standard ActiveRecord `pluck` to fetch only the required database columns.
+4.  **Struct Generation**: It creates a `Struct` class (cached for performance) and injects the source code of requested instance methods into it.
+5.  **Instantiation**: It maps the raw data into these `Struct` objects.
+
+## Requirements
+
+*   ActiveRecord >= 6.0
+*   method_source
+*   concurrent-ruby

data/better_pluck.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "better_pluck/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "better_pluck"
+  spec.version       = BetterPluck::VERSION
+  spec.authors       = ["NazarK"]
+  spec.email         = ["nazar.kuliev@gmail.com"]
+
+  spec.summary       = "Pluck with methods for ActiveRecord"
+  spec.description   = "Convert arrays of AR objects to Struct objects including virtual methods."
+  spec.homepage      = "https://github.com/NazarK/better_pluck"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.add_dependency "activerecord", ">= 6.0", "< 9.0"
+  spec.add_dependency "activesupport", ">= 6.0", "< 9.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_dependency "method_source", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

data/lib/better_pluck/pluck_with_methods.rb

@@ -0,0 +1,186 @@
+# this module is supposed to be included in ActiveRecord descendants
+# to reduce ram usage by converting arrays of AR objects to Struct objects
+# in particular for dropdown lists (in f.input collection: Article.pluck_with_display_name(:id,:name,:email), as: :select)
+# also takes associations display_name from their ActiveRecord class
+# usage: zones = Zone.pluck_with_display_name(:id,:name, partner: [:имя,:email], location: [:name])
+# zones.first.display_name, zones.first.partner.display_name
+
+#pluck_with_methods method also available where you can list any fields and methods
+#example: articles = Article.pluck_with_methods(:id, :name, :email, :name_on_site, author: [:name, :email,:display_name])
+#
+#in returned result you can use:
+#article.first.name_on_site, article.first.author.email, articles.first.author.display_name etc.
+#
+#returned structure is much cheaper (in terms of memory usage) than ActiveRecord objects, about 3 times less memory usage
+
+#NK 2026-10-13, done with Gemini AI
+
+module BetterPluck::PluckWithMethods
+  extend ActiveSupport::Concern
+
+  # Use Concurrent::Map for thread-safe caching across multiple Puma threads
+  STRUCT_CLASSES = Concurrent::Map.new
+
+  class_methods do
+
+    # usage: zones = Zone.pluck_with_methods(:id, :name, :display_name, partner: [:имя, :email, :display_name], location: [:name, :display_name])
+    def pluck_with_methods(*fields_and_methods)
+      require "method_source" unless defined?(MethodSource)
+
+      metadata = _pluck_methods_parse_fields(self, fields_and_methods)
+      pluck_columns = []
+      _pluck_methods_build_columns(self, metadata, pluck_columns, self.table_name)
+
+      joins_arg = _pluck_methods_build_joins(metadata)
+
+      query = joins_arg.present? ? left_joins(joins_arg) : all
+      raw_rows = query.pluck(*pluck_columns)
+
+      # Root struct class
+      root_struct_klass = _pluck_methods_get_struct(metadata)
+
+      raw_rows.map do |row|
+        row_data = row.is_a?(Array) ? row.dup : [row]
+        _pluck_methods_instantiate(root_struct_klass, metadata, row_data)
+      end
+    end
+
+    # usage: articles = Article.pluck_with_display_name(:id,:name, author: [:name,:email])
+    # articles.first.display_name, articles.first.author.display_name
+    def pluck_with_display_name(*fields_and_methods)
+      fields_and_methods << :display_name unless fields_and_methods.include?(:display_name)
+
+      processed_params = fields_and_methods.map do |arg|
+        if arg.is_a?(Hash)
+          arg.each_with_object({}) do |(assoc, fields), hash|
+            fields = Array(fields).dup
+            fields << :display_name unless fields.include?(:display_name)
+            hash[assoc] = fields
+          end
+        else
+          arg
+        end
+      end
+
+      pluck_with_methods(*processed_params)
+    end
+
+    private
+
+    def _pluck_methods_parse_fields(klass, fields)
+      db_columns = []
+      methods = {}
+      associations = {}
+      all_fields = []
+
+      available_columns = klass.column_names.map(&:to_sym) rescue []
+
+      # Sort fields to ensure deterministic cache key and struct structure
+      # Symbols first, then hashes (associations) sorted by their first key
+      sorted_fields = Array(fields).sort_by { |f| f.is_a?(Hash) ? [1, f.keys.first.to_s] : [0, f.to_s] }
+
+      sorted_fields.each do |item|
+        if item.is_a?(Hash)
+          # Sort association keys within the hash
+          item.keys.sort_by(&:to_s).each do |assoc_name|
+            assoc_fields = item[assoc_name]
+            assoc_reflection = klass.reflect_on_association(assoc_name)
+            if assoc_reflection
+              associations[assoc_name.to_sym] = _pluck_methods_parse_fields(assoc_reflection.klass, Array(assoc_fields))
+              all_fields << assoc_name.to_sym
+            end
+          end
+        else
+          name = item.to_sym
+          all_fields << name
+          if available_columns.include?(name)
+            db_columns << name
+          else
+            begin
+              source = klass.instance_method(name).source
+              methods[name] = source
+            rescue
+              # Treat as db column if not a method or source not found
+              db_columns << name
+            end
+          end
+        end
+      end
+
+      {
+        klass_name: klass.name,
+        db_columns: db_columns,
+        methods: methods,
+        associations: associations,
+        all_fields: all_fields,
+        total_db_columns: db_columns.size + associations.values.sum { |a| a[:total_db_columns] }
+      }
+    end
+
+    def _pluck_methods_build_columns(klass, metadata, list, table_alias)
+      metadata[:db_columns].each do |col|
+        list << Arel.sql("#{klass.connection.quote_table_name(table_alias)}.\#{col}")
+      end
+
+      metadata[:associations].each do |assoc_name, sub_metadata|
+        assoc_reflection = klass.reflect_on_association(assoc_name)
+        # ARs left_joins usually uses the table name for the join alias unless there is a collision
+        _pluck_methods_build_columns(assoc_reflection.klass, sub_metadata, list, assoc_reflection.table_name)
+      end
+    end
+
+    def _pluck_methods_build_joins(metadata)
+      return nil if metadata[:associations].empty?
+
+      joins = metadata[:associations].map do |assoc_name, sub_metadata|
+        sub_joins = _pluck_methods_build_joins(sub_metadata)
+        if sub_joins
+          { assoc_name => sub_joins }
+        else
+          assoc_name
+        end
+      end
+
+      joins.size == 1 ? joins.first : joins
+    end
+
+    def _pluck_methods_get_struct(metadata)
+      metadata[:struct_klass] ||= begin
+        # 1st list: database fields and associations
+        # 2nd list: virtual methods (copied from ActiveRecord)
+        db_and_assoc = metadata[:all_fields] - metadata[:methods].keys
+        cache_key = [metadata[:klass_name], db_and_assoc, metadata[:methods].keys]
+
+        STRUCT_CLASSES.compute_if_absent(cache_key) do
+          struct_klass = Struct.new(*metadata[:all_fields])
+          metadata[:methods].each do |name, source|
+            struct_klass.class_eval(source)
+          end
+          struct_klass
+        end
+      end
+    end
+
+    def _pluck_methods_instantiate(struct_klass, metadata, row_data)
+      args = metadata[:all_fields].map do |field|
+        if metadata[:db_columns].include?(field)
+          row_data.shift
+        elsif (sub_metadata = metadata[:associations][field])
+          sub_struct_klass = _pluck_methods_get_struct(sub_metadata)
+          sub_col_count = sub_metadata[:total_db_columns]
+
+          if row_data[0...sub_col_count].all?(&:nil?)
+            row_data.shift(sub_col_count)
+            nil
+          else
+            _pluck_methods_instantiate(sub_struct_klass, sub_metadata, row_data)
+          end
+        else
+          nil # Method field
+        end
+      end
+      struct_klass.new(*args)
+    end
+
+  end
+end

data/lib/better_pluck/version.rb

@@ -0,0 +1,3 @@
+module BetterPluck
+  VERSION = "0.8.0"
+end

data/lib/better_pluck.rb

@@ -0,0 +1,9 @@
+require "better_pluck/version"
+require "better_pluck/pluck_with_methods"
+
+module BetterPluck
+end
+
+ActiveSupport.on_load(:active_record) do
+  include BetterPluck::PluckWithMethods
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: better_pluck
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- NazarK
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Convert arrays of AR objects to Struct objects including virtual methods.
+email:
+- nazar.kuliev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- better_pluck.gemspec
+- lib/better_pluck.rb
+- lib/better_pluck/pluck_with_methods.rb
+- lib/better_pluck/version.rb
+homepage: https://github.com/NazarK/better_pluck
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Pluck with methods for ActiveRecord
+test_files: []