deep_pluck_with_authorization 1.1.2

data/gemfiles/5.2.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pluck_all.gemspec
+
+gem 'activerecord', '~> 5.2.0'
+gem 'pluck_all', '~> 1.2.2'
+
+group :test do
+  gem 'simplecov'
+end
+
+gemspec path: '../'

data/lib/deep_pluck.rb

@@ -0,0 +1,28 @@
+require 'deep_pluck/version'
+require 'deep_pluck/model'
+require 'active_record'
+require 'pluck_all'
+
+class ActiveRecord::Relation
+  def deep_pluck(*args)
+    DeepPluck::Model.new(self).add(args).load_all
+  end
+end
+
+class ActiveRecord::Base
+  def self.deep_pluck(*args)
+    where('').deep_pluck(*args)
+  end
+
+  def self.visible_for(*)
+    all
+  end
+
+  def deep_pluck(*args)
+    hash_args, other_args = args.partition{|s| s.is_a?(Hash) }
+    preloaded_model = DeepPluck::PreloadedModel.new(self, other_args)
+    model = DeepPluck::Model.new(self.class.where(id: id), preloaded_model: preloaded_model)
+    model.add(*hash_args) if hash_args.any?
+    return model.load_all.first
+  end
+end

data/lib/deep_pluck/data_combiner.rb

@@ -0,0 +1,40 @@
+module DeepPluck
+  module DataCombiner
+    class << self
+      def combine_data(parent, children, primary_key, column_name, foreign_key, reverse, collection)
+        source =  reverse ? parent : children
+        target = !reverse ? parent : children
+        data_hash = make_data_hash(collection, source, primary_key, column_name)
+        assign_values_to_parent(collection, target, data_hash, column_name, foreign_key, reverse: reverse)
+        return children
+      end
+
+      private
+
+      def make_data_hash(collection, parent, primary_key, column_name)
+        return parent.map{|s| [s[primary_key], s] }.to_h if !collection
+        hash = {}
+        parent.each do |model_hash|
+          key = model_hash[primary_key]
+          array = (hash[key] ? hash[key][column_name] : []) # share the children if id is duplicated
+          model_hash[column_name] = array
+          hash[key] = model_hash
+        end
+        return hash
+      end
+
+      def assign_values_to_parent(collection, parent, children_hash, column_name, foreign_key, reverse: false)
+        parent.each do |s|
+          next if (id = s[foreign_key]) == nil
+          left   =  reverse ? children_hash[id] : s
+          right  = !reverse ? children_hash[id] : s
+          if collection
+            left[column_name] << right
+          else
+            left[column_name] = right
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deep_pluck/model.rb

@@ -0,0 +1,174 @@
+require 'deep_pluck/preloaded_model'
+require 'deep_pluck/data_combiner'
+module DeepPluck
+  class Model
+    # ----------------------------------------------------------------
+    # ● Initialize
+    # ----------------------------------------------------------------
+    def initialize(relation, parent_association_key = nil, parent_model = nil, preloaded_model: nil, user: nil)
+      @relation = relation
+      @preloaded_model = preloaded_model
+      @parent_association_key = parent_association_key
+      @parent_model = parent_model
+      @need_columns = (preloaded_model ? preloaded_model.need_columns : [])
+      @associations = {}
+      @user = user
+    end
+
+    # ----------------------------------------------------------------
+    # ● Reader
+    # ----------------------------------------------------------------
+    def get_reflect(association_key)
+      @relation.klass.reflect_on_association(association_key.to_sym) || # add to_sym since rails 3 only support symbol
+        fail(ActiveRecord::ConfigurationError, "ActiveRecord::ConfigurationError: Association named \
+          '#{association_key}' was not found on #{@relation.klass.name}; perhaps you misspelled it?"
+      )
+    end
+
+    def with_conditions(reflect, relation)
+      options = reflect.options
+      relation = relation.instance_exec(&reflect.scope) if reflect.respond_to?(:scope) and reflect.scope
+      relation = relation.where(options[:conditions]) if options[:conditions]
+      return relation
+    end
+
+    def get_join_table(reflect)
+      options = reflect.options
+      return options[:through] if options[:through]
+      return (options[:join_table] || reflect.send(:derive_join_table)) if reflect.macro == :has_and_belongs_to_many
+      return nil
+    end
+
+    def get_primary_key(reflect)
+      return (reflect.belongs_to? ? reflect.klass : reflect.active_record).primary_key
+    end
+
+    def get_foreign_key(reflect, reverse: false, with_table_name: false)
+      if reverse and (table_name = get_join_table(reflect)) # reverse = parent
+        key = reflect.chain.last.foreign_key
+      else
+        key = (reflect.belongs_to? == reverse ? get_primary_key(reflect) : reflect.foreign_key)
+        table_name = (reverse ? reflect.klass : reflect.active_record).table_name
+      end
+      return "#{table_name}.#{key}" if with_table_name
+      return key.to_s # key may be symbol if specify foreign_key in association options
+    end
+
+    # ----------------------------------------------------------------
+    # ● Contruction OPs
+    # ----------------------------------------------------------------
+
+    private
+
+    def add_need_column(column)
+      @need_columns << column.to_s
+    end
+
+    def add_association(hash)
+      hash.each do |key, value|
+        model = (@associations[key] ||= Model.new(get_reflect(key).klass.where(''), key, self, user: @user))
+        model.add(value)
+      end
+    end
+
+    public
+
+    def add(args)
+      return self if args == nil
+      args = [args] if not args.is_a?(Array)
+      args.each do |arg|
+        case arg
+        when Hash ; add_association(arg)
+        else      ; add_need_column(arg)
+        end
+      end
+      return self
+    end
+
+    # ----------------------------------------------------------------
+    # ● Load
+    # ----------------------------------------------------------------
+    private
+
+    def do_query(parent, reflect, relation)
+      parent_key = get_foreign_key(reflect)
+      relation_key = get_foreign_key(reflect, reverse: true, with_table_name: true)
+      ids = parent.map{|s| s[parent_key] }
+      ids.uniq!
+      ids.compact!
+      relation = with_conditions(reflect, relation)
+      query = { relation_key => ids }
+      query[reflect.type] = reflect.active_record.to_s if reflect.type
+      return relation.joins(get_join_table(reflect)).visible_for(user: @user).where(query)
+    end
+
+    def set_includes_data(parent, column_name, model)
+      reflect = get_reflect(column_name)
+      reverse = !reflect.belongs_to?
+      foreign_key = get_foreign_key(reflect, reverse: reverse)
+      primary_key = get_primary_key(reflect)
+      children = model.load_data{|relation| do_query(parent, reflect, relation) }
+      # reverse = false: Child.where(:id => parent.pluck(:child_id))
+      # reverse = true : Child.where(:parent_id => parent.pluck(:id))
+      return DataCombiner.combine_data(
+        parent,
+        children,
+        primary_key,
+        column_name,
+        foreign_key,
+        reverse,
+        reflect.collection?,
+      )
+    end
+
+    def get_query_columns
+      if @parent_model
+        parent_reflect = @parent_model.get_reflect(@parent_association_key)
+        prev_need_columns = @parent_model.get_foreign_key(parent_reflect, reverse: true, with_table_name: true)
+      end
+      next_need_columns = @associations.map{|key, _| get_foreign_key(get_reflect(key), with_table_name: true) }.uniq
+      return [*prev_need_columns, *next_need_columns, *@need_columns].uniq(&Helper::TO_KEY_PROC)
+    end
+
+    public
+
+    def load_data
+      columns = get_query_columns
+      key_columns = columns.map(&Helper::TO_KEY_PROC)
+      @relation = yield(@relation) if block_given?
+      @data = @preloaded_model ? [@preloaded_model.get_hash_data(key_columns)] : @relation.pluck_all(*columns)
+      if @data.size != 0
+        # for delete_extra_column_data!
+        @extra_columns = key_columns - @need_columns.map(&Helper::TO_KEY_PROC)
+        @associations.each do |key, model|
+          set_includes_data(@data, key, model)
+        end
+      end
+      return @data
+    end
+
+    def load_all
+      load_data
+      delete_extra_column_data!
+      return @data
+    end
+
+    def delete_extra_column_data!
+      return if @data.blank?
+      @data.each{|s| s.except!(*@extra_columns) }
+      @associations.each{|_, model| model.delete_extra_column_data! }
+    end
+
+    # ----------------------------------------------------------------
+    # ● Helper methods
+    # ----------------------------------------------------------------
+    module Helper
+      TO_KEY_PROC = proc{|s| Helper.column_to_key(s) }
+      def self.column_to_key(key) # user_achievements.user_id => user_id
+        key = key[/(\w+)[^\w]*\z/]
+        key.gsub!(/[^\w]+/, '')
+        return key
+      end
+    end
+  end
+end

data/lib/deep_pluck/preloaded_model.rb

@@ -0,0 +1,14 @@
+module DeepPluck
+  class PreloadedModel
+    attr_reader :need_columns
+
+    def initialize(active_model, need_columns)
+      @active_model = active_model
+      @need_columns = need_columns
+    end
+
+    def get_hash_data(extra_columns)
+      @active_model.as_json(root: false, only: @need_columns + extra_columns)
+    end
+  end
+end

data/lib/deep_pluck/version.rb

@@ -0,0 +1,3 @@
+module DeepPluck
+  VERSION = '1.1.2'
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: deep_pluck_with_authorization
+version: !ruby/object:Gem::Version
+  version: 1.1.2
+platform: ruby
+authors:
+- Poilon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.x
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.x
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pluck_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+description: 'Use deep_pluck as a shortcut to select one or more attributes and include
+  associated models without loading a bunch of records. And DRY up your code when
+  using #as_json. Added a filter for graphql_rails_api gem'
+email:
+- poilon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- deep_pluck_with_authorization.gemspec
+- gemfiles/3.2.gemfile
+- gemfiles/4.2.gemfile
+- gemfiles/5.0.gemfile
+- gemfiles/5.1.gemfile
+- gemfiles/5.2.gemfile
+- lib/deep_pluck.rb
+- lib/deep_pluck/data_combiner.rb
+- lib/deep_pluck/model.rb
+- lib/deep_pluck/preloaded_model.rb
+- lib/deep_pluck/version.rb
+homepage: https://github.com/poilon/deep_pluck
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Use deep_pluck as a shortcut to select one or more attributes and include
+  associated models without loading a bunch of records. Added a filter for graphql_rails_api
+  gem.
+test_files: []