Class: DeepPluck::Model

Inherits:
Object
  • Object
show all
Defined in:
lib/deep_pluck/model.rb

Defined Under Namespace

Modules: Helper

Instance Method Summary collapse

Constructor Details

#initialize(relation, parent_association_key = nil, parent_model = nil, need_columns: []) ⇒ Model

● Initialize



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/deep_pluck/model.rb', line 11

def initialize(relation, parent_association_key = nil, parent_model = nil, need_columns: [])
  if relation.is_a?(ActiveRecord::Base)
    @model = relation
    @relation = nil
    @klass = @model.class
  else
    @model = nil
    @relation = relation
    @klass = @relation.klass
  end

  @column_names = @klass.column_names
  @parent_association_key = parent_association_key
  @parent_model = parent_model
  @need_columns = []
  @need_methods = []
  @associations = {}
  need_columns.each { |column| add_need_column(column) }
end

Instance Method Details

#add(args) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/deep_pluck/model.rb', line 100

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

#delete_extra_column_data! ⇒ Object 



235
236
237
238
239
 
# File 'lib/deep_pluck/model.rb', line 235

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

#get_association_scope(reflect) ⇒ Object 



71
72
73
 
# File 'lib/deep_pluck/model.rb', line 71

def get_association_scope(reflect)
  RailsCompatibility.unscope_where(reflect.association_class.new({}, reflect).send(:association_scope))
end

#get_foreign_key(reflect, reverse: false, with_table_name: false) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/deep_pluck/model.rb', line 59

def get_foreign_key(reflect, reverse: false, with_table_name: false)
  reflect = reflect.chain.last
  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

#get_join_table(reflect) ⇒ Object 



48
49
50
51
52
53
 
# File 'lib/deep_pluck/model.rb', line 48

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

#get_primary_key(reflect) ⇒ Object 



55
56
57
 
# File 'lib/deep_pluck/model.rb', line 55

def get_primary_key(reflect)
  return (reflect.belongs_to? ? reflect.klass : reflect.active_record).primary_key
end

#get_reflect(association_key) ⇒ Object

● Reader



34
35
36
37
38
39
 
# File 'lib/deep_pluck/model.rb', line 34

def get_reflect(association_key)
  @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 #{@klass.name}; perhaps you misspelled it?"
    )
end

#load_all ⇒ Object 



229
230
231
232
233
 
# File 'lib/deep_pluck/model.rb', line 229

def load_all
  load_data
  delete_extra_column_data!
  return @data
end

#load_data ⇒ Object 



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/deep_pluck/model.rb', line 213

def load_data
  columns = get_query_columns
  key_columns = columns.map(&Helper::TO_KEY_PROC)
  @relation = yield(@relation) if block_given?
  # binding.pry
  @data = loaded_models ? loaded_models.as_json(root: false, only: key_columns, methods: @need_methods) : pluck_values(columns, @need_methods)
  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

#use_association_to_query?(reflect) ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
 
# File 'lib/deep_pluck/model.rb', line 75

def use_association_to_query?(reflect)
  reflect.through_reflection && reflect.chain.first.macro == :has_one
end

#with_conditions(reflect, relation) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/deep_pluck/model.rb', line 41

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