Class: ClosureTree::Support

Inherits:
Object
  • Object
show all
Includes:
ActiveRecordSupport, HashTreeSupport, SupportAttributes, SupportFlags
Defined in:
lib/closure_tree/support.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from HashTreeSupport

#build_hash_tree, #default_tree_scope, #hash_tree

Methods included from ActiveRecordSupport

#ensure_fixed_table_name, #quote, #remove_prefix_and_suffix

Methods included from SupportAttributes

#advisory_lock_name, #hierarchy_class_name, #name_column, #name_sym, #nulls_last_order_by, #order_by, #order_by_order, #order_column, #order_column_sym, #parent_column_name, #parent_column_sym, #primary_key_column, #primary_key_type, #quoted_hierarchy_table_name, #quoted_id_column_name, #quoted_name_column, #quoted_order_column, #quoted_parent_column_name, #quoted_table_name, #quoted_value, #require_order_column, #short_hierarchy_class_name

Methods included from SupportFlags

#has_inheritance_column?, #has_name?, #include_forbidden_attributes_protection?, #order_is_numeric?, #order_option?, #subclass?, #use_attr_accessible?

Constructor Details

#initialize(model_class, options) ⇒ Support

Returns a new instance of Support.

Raises:

  • (ArgumentError) 


19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/closure_tree/support.rb', line 19

def initialize(model_class, options)
  @model_class = model_class
  @options = {
    :parent_column_name => 'parent_id',
    :dependent => :nullify, # or :destroy or :delete_all -- see the README
    :name_column => 'name',
    :with_advisory_lock => true
  }.merge(options)
  raise ArgumentError, "name_column can't be 'path'" if options[:name_column] == 'path'
  if order_is_numeric?
    extend NumericOrderSupport.adapter_for_connection(connection)
  end
end

Instance Attribute Details

#model_class ⇒ Object (readonly)

Returns the value of attribute model_class.



16
17
18
 
# File 'lib/closure_tree/support.rb', line 16

def model_class
  @model_class
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



17
18
19
 
# File 'lib/closure_tree/support.rb', line 17

def options
  @options
end

Instance Method Details

#belongs_to_with_optional_option(opts) ⇒ Object 



79
80
81
 
# File 'lib/closure_tree/support.rb', line 79

def belongs_to_with_optional_option(opts)
  [ActiveRecord::VERSION::MAJOR < 5 ? opts.except(:optional) : opts]
end

#build_ancestry_attr_path(path, attributes) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/closure_tree/support.rb', line 115

def build_ancestry_attr_path(path, attributes)
  path = path.is_a?(Array) ? path.dup : [path]
  unless path.first.is_a?(Hash)
    if subclass? && has_inheritance_column?
      attributes = attributes.with_indifferent_access
      attributes[inheritance_column] ||= self.sti_name
    end
    path = path.map { |ea| attributes.merge(name_column => ea) }
  end
  path
end

#create(model_class, attributes) ⇒ Object 



160
161
162
 
# File 'lib/closure_tree/support.rb', line 160

def create(model_class, attributes)
  creator_class(model_class, attributes.with_indifferent_access[inheritance_column]).new(attributes)
end

#create!(model_class, attributes) ⇒ Object 



164
165
166
 
# File 'lib/closure_tree/support.rb', line 164

def create!(model_class, attributes)
  create(model_class, attributes).tap { |ea| ea.save! }
end

#creator_class(model_class, sti_class) ⇒ Object 



152
153
154
155
156
157
158
 
# File 'lib/closure_tree/support.rb', line 152

def creator_class(model_class, sti_class)
  if sti_class.present?
    base_class.send(:find_sti_class, sti_class)
  else
    model_class
  end
end

#find_by_large_path(path, attributes = {}, parent_id = nil) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
 
# File 'lib/closure_tree/support.rb', line 141

def find_by_large_path(path, attributes = {}, parent_id = nil)
  next_parent_id = parent_id
  child = nil
  path.in_groups(max_join_tables, false).each do |subpath|
    child = model_class.find_by_path(subpath, attributes, next_parent_id)
    return nil if child.nil?
    next_parent_id = child._ct_id
  end
  child
end

#has_many_with_order_option(opts) ⇒ Object 



88
89
90
91
 
# File 'lib/closure_tree/support.rb', line 88

def has_many_with_order_option(opts)
  order_options = [opts[:order], order_by].compact
  [lambda { order(order_options) }, opts.except(:order)]
end

#has_many_without_order_option(opts) ⇒ Object

lambda-ize the order, but don’t apply the default order_option



84
85
86
 
# File 'lib/closure_tree/support.rb', line 84

def has_many_without_order_option(opts)
    [lambda { order(opts[:order]) }, opts.except(:order)]
end

#hierarchy_class_for_model ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/closure_tree/support.rb', line 33

def hierarchy_class_for_model
  hierarchy_class = model_class.parent.const_set(short_hierarchy_class_name, Class.new(ActiveRecord::Base))
  use_attr_accessible = use_attr_accessible?
  include_forbidden_attributes_protection = include_forbidden_attributes_protection?
  hierarchy_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
    include ActiveModel::ForbiddenAttributesProtection if include_forbidden_attributes_protection
    belongs_to :ancestor, :class_name => "#{model_class}"
    belongs_to :descendant, :class_name => "#{model_class}"
    attr_accessible :ancestor, :descendant, :generations if use_attr_accessible
    def ==(other)
      self.class == other.class && ancestor_id == other.ancestor_id && descendant_id == other.descendant_id
    end
    alias :eql? :==
    def hash
      ancestor_id.hash << 31 ^ descendant_id.hash
    end
  RUBY
  hierarchy_class.table_name = hierarchy_table_name
  hierarchy_class
end

#hierarchy_table_name ⇒ Object 



54
55
56
57
58
59
60
61
62
 
# File 'lib/closure_tree/support.rb', line 54

def hierarchy_table_name
  # We need to use the table_name, not something like ct_class.to_s.demodulize + "_hierarchies",
  # because they may have overridden the table name, which is what we want to be consistent with
  # in order for the schema to make sense.
  tablename = options[:hierarchy_table_name] ||
    remove_prefix_and_suffix(table_name).singularize + "_hierarchies"

  ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
end

#ids_from(scope) ⇒ Object 



93
94
95
 
# File 'lib/closure_tree/support.rb', line 93

def ids_from(scope)
  scope.pluck(model_class.primary_key)
end

#max_join_tables ⇒ Object 



136
137
138
139
 
# File 'lib/closure_tree/support.rb', line 136

def max_join_tables
  # MySQL doesn't support more than 61 joined tables (!!):
  50
end

#scope_with_order(scope, additional_order_by = nil) ⇒ Object 



71
72
73
74
75
76
77
 
# File 'lib/closure_tree/support.rb', line 71

def scope_with_order(scope, additional_order_by = nil)
  if order_option?
    scope.order(*([additional_order_by, order_by].compact))
  else
    additional_order_by ? scope.order(additional_order_by) : scope
  end
end

#scoped_attributes(scope, attributes, target_table = model_class.table_name) ⇒ Object 



127
128
129
130
131
132
133
134
 
# File 'lib/closure_tree/support.rb', line 127

def scoped_attributes(scope, attributes, target_table = model_class.table_name)
  table_prefixed_attributes = Hash[
    attributes.map do |column_name, column_value|
      ["#{target_table}.#{column_name}", column_value]
    end
  ]
  scope.where(table_prefixed_attributes)
end

#where_eq(column_name, value) ⇒ Object 



97
98
99
100
101
102
103
 
# File 'lib/closure_tree/support.rb', line 97

def where_eq(column_name, value)
  if value.nil?
    "#{connection.quote_column_name(column_name)} IS NULL"
  else
    "#{connection.quote_column_name(column_name)} = #{quoted_value(value)}"
  end
end

#with_advisory_lock(&block) ⇒ Object 



105
106
107
108
109
110
111
112
113
 
# File 'lib/closure_tree/support.rb', line 105

def with_advisory_lock(&block)
  if options[:with_advisory_lock]
    model_class.with_advisory_lock(advisory_lock_name) do
      transaction { yield }
    end
  else
    yield
  end
end

#with_order_option(opts) ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/closure_tree/support.rb', line 64

def with_order_option(opts)
  if order_option?
    opts[:order] = [opts[:order], order_by].compact.join(",")
  end
  opts
end