Class: ActiveRecord::Base

Inherits:
Object show all
Extended by:
ClassMethods
Includes:
InstanceMethods
Defined in:
lib/active_record_base.rb,
lib/reactive_record/permissions.rb,
lib/reactive_record/active_record/base.rb,
lib/reactive_record/active_record/aggregations.rb,
lib/reactive_record/active_record/associations.rb,
lib/reactive_record/active_record/public_columns_hash.rb

Overview

adds method to get the HyperMesh public column types for now we are just getting all models column types, but we should look through the public folder, and just get those models. this works because the public folder is currently required to be eaer loaded.

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes included from InstanceMethods

#backing_record

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ClassMethods

_react_param_conversion, abstract_class=, abstract_class?, base_class, column_names, columns_hash, composed_of, define_attribute_methods, enum, find, find_by, inheritance_column, inheritance_column=, model_name, primary_key, primary_key=, server_methods

Methods included from InstanceMethods

#==, #attributes, #changed?, #destroy, #destroyed?, #dup, #errors, #id, #id=, #initialize, #itself, #load, #method_missing_warning, #model_name, #new?, #primary_key, #revert, #save, #saving?, #type, #type=

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object 



53
54
55
56
57
58
59
60
 
# File 'lib/active_record_base.rb', line 53

def method_missing(name, *args, &block)
  #return get_by_index(*args).first if name == "[]"
  return all.send(name, *args, &block) if [].respond_to?(name)
  if name =~ /\!$/
    return send(name.gsub(/\!$/,''), *args, &block).send(:reload_from_db) rescue nil
  end
  pre_synchromesh_method_missing(name, *args, &block)
end

Class Attribute Details

.reactive_record_association_keys ⇒ Object (readonly)

Returns the value of attribute reactive_record_association_keys.



82
83
84
 
# File 'lib/reactive_record/permissions.rb', line 82

def reactive_record_association_keys
  @reactive_record_association_keys
end

Instance Attribute Details

#acting_user ⇒ Object

Returns the value of attribute acting_user.



34
35
36
 
# File 'lib/reactive_record/permissions.rb', line 34

def acting_user
  @acting_user
end

Class Method Details

._synchromesh_scope_args_check(args) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/active_record_base.rb', line 9

def _synchromesh_scope_args_check(args)
  opts = if args.count == 2 && args[1].is_a?(Hash)
           args[1].merge(server: args[0])
         elsif args[0].is_a? Hash
           args[0]
         else
           { server: args[0] }
         end
  return opts if opts.is_a?(Hash) && opts[:server].respond_to?(:call)
  raise 'must provide either a proc as the first arg or by the '\
        '`:server` option to scope and default_scope methods'
end

.belongs_to(attr_name, scope = nil, options = {}) ⇒ Object 



98
99
100
101
102
103
 
# File 'lib/reactive_record/permissions.rb', line 98

def belongs_to(attr_name, scope = nil, options = {})
  define_method "#{attr_name}_is?".to_sym do |model|
    send(options[:foreign_key] || "#{attr_name}_id") == model.id
  end
  belongs_to_without_reactive_record_add_is_method(attr_name, scope, options)
end

.belongs_to_without_reactive_record_add_is_method ⇒ Object 



96
 
# File 'lib/reactive_record/permissions.rb', line 96

alias belongs_to_without_reactive_record_add_is_method belongs_to

.do_not_synchronize ⇒ Object 



25
26
27
 
# File 'lib/active_record_base.rb', line 25

def do_not_synchronize
  @do_not_synchronize = true
end

.do_not_synchronize? ⇒ Boolean

Returns:

  • (Boolean) 


29
30
31
 
# File 'lib/active_record_base.rb', line 29

def do_not_synchronize?
  @do_not_synchronize
end

.pre_synchromesh_default_scope ⇒ Object 



23
 
# File 'lib/active_record_base.rb', line 23

alias pre_synchromesh_default_scope default_scope

.pre_synchromesh_scope ⇒ Object 



22
 
# File 'lib/active_record_base.rb', line 22

alias pre_synchromesh_scope scope

.public_columns_hash ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/reactive_record/active_record/public_columns_hash.rb', line 7

def self.public_columns_hash
  return @public_columns_hash if @public_columns_hash
  Dir.glob(Rails.root.join('app/models/public/*.rb')).each do |file|
    require_dependency(file)
  end
  @public_columns_hash = {}
  descendants.each do |model|
    @public_columns_hash[model.name] = model.columns_hash rescue nil
  end
  @public_columns_hash
end

.reflect_on_aggregation(attribute) ⇒ Object 



9
10
11
 
# File 'lib/reactive_record/active_record/aggregations.rb', line 9

def self.reflect_on_aggregation(attribute)
  reflect_on_all_aggregations.detect { |aggregation| aggregation.attribute == attribute }
end

.reflect_on_all_aggregations ⇒ Object 



5
6
7
 
# File 'lib/reactive_record/active_record/aggregations.rb', line 5

def self.reflect_on_all_aggregations
  base_class.instance_eval { @aggregations ||= [] }
end

.reflect_on_all_associations ⇒ Object 



5
6
7
 
# File 'lib/reactive_record/active_record/associations.rb', line 5

def self.reflect_on_all_associations
  base_class.instance_eval { @associations ||= superclass.instance_eval { (@associations && @associations.dup) || [] } }
end

.reflect_on_association(attribute) ⇒ Object 



9
10
11
12
13
14
15
16
17
 
# File 'lib/reactive_record/active_record/associations.rb', line 9

def self.reflect_on_association(attribute)
  if found = reflect_on_all_associations.detect { |association| association.attribute == attribute and association.owner_class == self }
    found
  elsif superclass == Base
    nil
  else
    superclass.reflect_on_association(attribute)
  end
end

Instance Method Details

#<=>(other) ⇒ Object 



148
149
150
 
# File 'lib/active_record_base.rb', line 148

def <=>(other)
  id.to_i <=> other.id.to_i
end

#all ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/active_record_base.rb', line 84

def all
  ReactiveRecord::Base.default_scope[self] ||=
    if @_default_scopes
      root = ReactiveRecord::Collection
             .new(self, nil, nil, self, 'all')
             .extend(ReactiveRecord::UnscopedCollection)
      @_default_scopes.inject(root) do |scope, opts|
        scope.build_child_scope(ReactiveRecord::ScopeDescription.new(self, :all, opts))
      end
    end || unscoped
end

#all=(_collection) ⇒ Object 



96
97
98
 
# File 'lib/active_record_base.rb', line 96

def all=(_collection)
  raise "NO LONGER IMPLEMENTED DOESNT PLAY WELL WITH SYNCHROMESH"
end

#all_changed?(*attributes) ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
76
77
78
 
# File 'lib/reactive_record/permissions.rb', line 73

def all_changed?(*attributes)
  attributes.each do |key|
    return false unless self.send("#{key}_changed?")
  end
  true
end

#any_changed?(*attributes) ⇒ Boolean

Returns:

  • (Boolean) 


66
67
68
69
70
71
 
# File 'lib/reactive_record/permissions.rb', line 66

def any_changed?(*attributes)
  attributes.each do |key|
    return true if self.send("#{key}_changed?")
  end
  false
end

#check_permission_with_acting_user(user, permission, *args) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/reactive_record/permissions.rb', line 107

def check_permission_with_acting_user(user, permission, *args)
  old = acting_user
  self.acting_user = user
  if self.send(permission, *args)
    self.acting_user = old
    self
  else
    raise ReactiveRecord::AccessViolation, "for #{permission}(#{args})"
  end
end

#create(*args, &block) ⇒ Object 



62
63
64
 
# File 'lib/active_record_base.rb', line 62

def create(*args, &block)
  new(*args).save(&block)
end

#create_permitted? ⇒ Boolean

Returns:

  • (Boolean) 


40
41
42
 
# File 'lib/reactive_record/permissions.rb', line 40

def create_permitted?
  false
end

#default_scope(*args, &block) ⇒ Object 



40
41
42
43
 
# File 'lib/active_record_base.rb', line 40

def default_scope(*args, &block)
  opts = _synchromesh_scope_args_check([*block, *args])
  pre_synchromesh_default_scope(opts[:server], &block)
end

#destroy_permitted? ⇒ Boolean

Returns:

  • (Boolean) 


48
49
50
 
# File 'lib/reactive_record/permissions.rb', line 48

def destroy_permitted?
  false
end

#do_not_synchronize? ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/active_record_base.rb', line 111

def do_not_synchronize?
  self.class.do_not_synchronize?
end

#none_changed?(*attributes) ⇒ Boolean

Returns:

  • (Boolean) 


59
60
61
62
63
64
 
# File 'lib/reactive_record/permissions.rb', line 59

def none_changed?(*attributes)
  attributes.each do |key|
    return false if self.send("#{key}_changed?")
  end
  true
end

#only_changed?(*attributes) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
55
56
57
 
# File 'lib/reactive_record/permissions.rb', line 52

def only_changed?(*attributes)
  (self.attributes.keys + self.class.reactive_record_association_keys).each do |key|
    return false if self.send("#{key}_changed?") and !attributes.include? key
  end
  true
end

#pre_synchromesh_method_missing ⇒ Object 



51
 
# File 'lib/active_record_base.rb', line 51

alias pre_synchromesh_method_missing method_missing

#scope(name, *args) ⇒ Object 



35
36
37
38
 
# File 'lib/active_record_base.rb', line 35

def scope(name, *args, &block)
  opts = _synchromesh_scope_args_check(args)
  pre_synchromesh_scope(name, opts[:server], &block)
end

#server_method(name, opts = {}, &block) ⇒ Object 



45
46
47
 
# File 'lib/active_record_base.rb', line 45

def server_method(name, opts = {}, &block)
  define_method name, &block
end

#synchromesh_after_change ⇒ Object 



124
125
126
127
 
# File 'lib/active_record_base.rb', line 124

def synchromesh_after_change
  return if do_not_synchronize? || previous_changes.empty?
  HyperMesh.after_commit :change, self
end

#synchromesh_after_create ⇒ Object 



119
120
121
122
 
# File 'lib/active_record_base.rb', line 119

def synchromesh_after_create
  return if do_not_synchronize? #|| previous_changes.empty?
  HyperMesh.after_commit :create, self
end

#synchromesh_after_destroy ⇒ Object 



129
130
131
132
 
# File 'lib/active_record_base.rb', line 129

def synchromesh_after_destroy
  return if do_not_synchronize?
  HyperMesh.after_commit :destroy, self
end

#unscoped ⇒ Object 



100
101
102
103
104
105
 
# File 'lib/active_record_base.rb', line 100

def unscoped
  ReactiveRecord::Base.unscoped[self] ||=
    ReactiveRecord::Collection
    .new(self, nil, nil, self, 'unscoped')
    .extend(ReactiveRecord::UnscopedCollection)
end

#update(attrs = {}, &block) ⇒ Object 



143
144
145
146
 
# File 'lib/active_record_base.rb', line 143

def update(attrs = {}, &block)
  attrs.each { |attr, value| send("#{attr}=", value) }
  save(&block)
end

#update_attribute(attr, value, &block) ⇒ Object 



138
139
140
141
 
# File 'lib/active_record_base.rb', line 138

def update_attribute(attr, value, &block)
  send("#{attr}=", value)
  save(validate: false, &block)
end

#update_permitted? ⇒ Boolean

Returns:

  • (Boolean) 


44
45
46
 
# File 'lib/reactive_record/permissions.rb', line 44

def update_permitted?
  false
end

#view_permitted?(attribute) ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/reactive_record/permissions.rb', line 36

def view_permitted?(attribute)
  HyperMesh::InternalPolicy.accessible_attributes_for(self, acting_user).include? attribute.to_sym
end