deep_pluck 1.0.3 → 1.1.0

data/README.md

@@ -48,6 +48,11 @@ User.deep_pluck(:name, :posts => :title)
 #  {'name' => 'Jeremy', :posts => [{'title' => 'post3'}]}
 # ]
 ```
+### Support plucking at active models
+```rb
+user = User.find_by(name: 'David').deep_pluck(:name, :posts => :title)
+# => {'name' => 'David' , :posts => [{'title' => 'post1'}, {'title' => 'post2'}]}
+```
 
 ### DRY up Rails/ActiveRecord includes when using as_json
 

data/lib/deep_pluck.rb

@@ -13,4 +13,12 @@ class ActiveRecord::Base
   def self.deep_pluck(*args)
     self.where('').deep_pluck(*args)
   end
+
+  def deep_pluck(*args)
+    hash_args = args.select{|s| s.is_a?(Hash) }
+    other_args = args.select{|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)
+    return model.add(*hash_args).load_all.first
+  end
 end

data/lib/deep_pluck/data_combiner.rb

@@ -8,20 +8,23 @@ module DeepPluck
         assign_values_to_parent(collection, target, data_hash, column_name, foreign_key, reverse: reverse)
         return children
       end
-    private
+
+      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
+          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{|s|
+        parent.each do |s|
           next if (id = s[foreign_key]) == nil
           left   =  reverse ? children_hash[id] : s
           right  = !reverse ? children_hash[id] : s
@@ -30,7 +33,7 @@ module DeepPluck
           else
             left[column_name] = right
           end
-        }
+        end
       end
     end
   end

data/lib/deep_pluck/model.rb

@@ -1,61 +1,77 @@
+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)
+    # ----------------------------------------------------------------
+    # ● Initialize
+    # ----------------------------------------------------------------
+    def initialize(relation, parent_association_key = nil, parent_model = nil, preloaded_model: nil)
       @relation = relation
+      @preloaded_model = preloaded_model
       @parent_association_key = parent_association_key
       @parent_model = parent_model
       @need_columns = []
       @associations = {}
     end
-  #---------------------------------------
-  #  Reader
-  #---------------------------------------
+
+    # ----------------------------------------------------------------
+    # ● Reader
+    # ----------------------------------------------------------------
     def get_reflect(association_key)
-      @relation.klass.reflect_on_association(association_key.to_sym) || #add to_sym since rails 3 only support symbol
-        raise(ActiveRecord::ConfigurationError, "ActiveRecord::ConfigurationError: Association named '#{association_key}' was not found on #{@relation.klass.name}; perhaps you misspelled it?")
+      @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)
-      return reflect.options[:through] if reflect.options[:through]
-      return (reflect.options[:join_table] || reflect.send(:derive_join_table)) if reflect.macro == :has_and_belongs_to_many
+      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
+      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
+      return key.to_s # key may be symbol if specify foreign_key in association options
     end
-  #---------------------------------------
-  #  Contruction OPs
-  #---------------------------------------
-  private
+
+    # ----------------------------------------------------------------
+    # ● 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))
         model.add(value)
       end
     end
-  public
+
+    public
+
     def add(args)
       return self if args == nil
       args = [args] if not args.is_a?(Array)
@@ -67,10 +83,12 @@ module DeepPluck
       end
       return self
     end
-  #---------------------------------------
-  #  Load
-  #---------------------------------------
-  private
+
+    # ----------------------------------------------------------------
+    # ● 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)
@@ -82,48 +100,70 @@ module DeepPluck
       query[reflect.type] = reflect.active_record.to_s if reflect.type
       return relation.joins(get_join_table(reflect)).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?)
+      # 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
-  public
-    def load_data
-      prev_need_columns = @parent_model.get_foreign_key(@parent_model.get_reflect(@parent_association_key), reverse: true, with_table_name: true) if @parent_model
+
+    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
-      all_need_columns = [*prev_need_columns, *next_need_columns, *@need_columns].uniq(&Helper::TO_KEY_PROC)
+      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 = @relation.pluck_all(*all_need_columns)
+      @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 = all_need_columns.map(&Helper::TO_KEY_PROC) - @need_columns.map(&Helper::TO_KEY_PROC)
+        # 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
-  #---------------------------------------
+
+    # ----------------------------------------------------------------
+    # ● 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
+      def self.column_to_key(key) # user_achievements.user_id => user_id
         key = key[/(\w+)[^\w]*\z/]
         key.gsub!(/[^\w]+/, '')
         return key

data/lib/deep_pluck/preloaded_model.rb

@@ -0,0 +1,12 @@
+module DeepPluck
+  class PreloadedModel
+    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

@@ -1,3 +1,3 @@
 module DeepPluck
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_pluck
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - khiav reoy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-30 00:00:00.000000000 Z
+date: 2018-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,6 +104,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -119,6 +120,7 @@ files:
 - 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/khiav223577/deep_pluck
 licenses:
@@ -140,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Use deep_pluck as a shortcut to select one or more attributes and include