Class: PostJson::Base

Inherits:
ActiveRecord::Base
  • Object
show all
Includes:
DynamicIndexMethods, SettingsMethods
Defined in:
lib/post_json/base.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Base

Returns a new instance of Base.



13
14
15
16
17
18
19
 
# File 'lib/post_json/base.rb', line 13

def initialize(*args)
  __local__primary_key = self.class.primary_key
  __local__attrs = (args[0] || {}).with_indifferent_access
  __local__attrs[__local__primary_key] = __local__attrs[__local__primary_key].to_s if __local__attrs.has_key?(__local__primary_key)
  args[0] = {__local__primary_key => __local__attrs[__local__primary_key], '__doc__body' => __local__attrs}.with_indifferent_access
  super
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

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



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/post_json/base.rb', line 130

def method_missing(method_symbol, *args, &block)
  method_name = method_symbol.to_s
  attribute_name =  if method_name.end_with?("_changed?")
                      method_name[0..-10]
                    elsif method_name.end_with?("_was")
                      method_name[0..-5]
                    elsif method_name.end_with?("=")
                      method_name[0..-2]
                    elsif method_name.end_with?("_change")
                      method_name[0..-8]
                    else
                      method_name
                    end

  if attribute_name.in?(attribute_names) == false
    self.class.define_attribute_accessor(attribute_name)
    send(method_symbol, *args)
  else
    super
  end
end

Class Method Details

.collection_name ⇒ Object

Raises:

  • (ArgumentError) 


172
173
174
175
176
177
178
179
 
# File 'lib/post_json/base.rb', line 172

def collection_name
  message = "You need to assign a collection name to class \"#{name}\":
class #{name}
  self.collection_name = \"people\"
end"
  raise ArgumentError, message unless @collection_name.present?
  @collection_name
end

.collection_name=(name) ⇒ Object

Raises:

  • (ArgumentError) 


181
182
183
184
185
186
 
# File 'lib/post_json/base.rb', line 181

def collection_name=(name)
  raise ArgumentError, "Collection name must be present" unless name.present?
  @collection_name = name.to_s.strip
  reload_settings!
  @collection_name
end

.default_scopes ⇒ Object 



164
165
166
167
168
169
170
 
# File 'lib/post_json/base.rb', line 164

def default_scopes
  # query = original_all.where("\"#{table_name}\".__doc__model_settings_id = ?", settings_id)
  model_settings = ModelSettings.table_name
  query = original_all.joins("INNER JOIN \"#{model_settings}\" ON lower(\"#{model_settings}\".collection_name) = '#{collection_name.downcase}'")
  query = query.where("\"#{table_name}\".__doc__model_settings_id = \"#{model_settings}\".id")
  super + [Proc.new { query }]
end

.define_attribute_accessor(attribute_name) ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/post_json/base.rb', line 197

def define_attribute_accessor(attribute_name)
  class_eval <<-RUBY
    def #{attribute_name}
      __doc__body_read_attribute('#{attribute_name}')
    end

    def #{attribute_name}=(value)
      __doc__body_write_attribute('#{attribute_name}', value)
    end

    def #{attribute_name}_changed?
      __doc__body_attribute_changed?('#{attribute_name}')
    end

    def #{attribute_name}_was
      __doc__body_attribute_was('#{attribute_name}')
    end

    def #{attribute_name}_change
      __doc__body_attribute_change('#{attribute_name}')
    end
  RUBY
end

.page(*args) ⇒ Object 



160
161
162
 
# File 'lib/post_json/base.rb', line 160

def page(*args)
  all.page(*args)
end

.post_json_all ⇒ Object Also known as: all 



153
154
155
 
# File 'lib/post_json/base.rb', line 153

def post_json_all
  QueryTranslator.new(original_all)
end

.rename_collection(new_name) ⇒ Object 



188
189
190
191
192
193
194
195
 
# File 'lib/post_json/base.rb', line 188

def rename_collection(new_name)
  new_name = new_name.to_s.strip
  if settings.persisted?
    settings.collection_name = new_name
    settings.save!
  end
  @collection_name = new_name
end

Instance Method Details

#[](attribute_name) ⇒ Object 



102
103
104
 
# File 'lib/post_json/base.rb', line 102

def [](attribute_name)
  self.__doc__body_read_attribute(attribute_name)
end

#[]=(attribute_name, value) ⇒ Object 



106
107
108
 
# File 'lib/post_json/base.rb', line 106

def []=(attribute_name, value)
  self.__doc__body_write_attribute(attribute_name, value)
end

#__doc__body_attribute_change(attribute_name) ⇒ Object 



75
76
77
78
79
80
81
82
 
# File 'lib/post_json/base.rb', line 75

def __doc__body_attribute_change(attribute_name)
  __local__change = [__doc__body_attribute_was(attribute_name), __doc__body_read_attribute(attribute_name)]
  if __local__change[0] == __local__change[1]
    nil
  else
    __local__change
  end
end

#__doc__body_attribute_changed?(attribute_name) ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
 
# File 'lib/post_json/base.rb', line 71

def __doc__body_attribute_changed?(attribute_name)
  (self.__doc__body == nil ? nil : self.__doc__body.with_indifferent_access[attribute_name]) != self.__doc__body_attribute_was(attribute_name)
end

#__doc__body_attribute_was(attribute_name) ⇒ Object 



67
68
69
 
# File 'lib/post_json/base.rb', line 67

def __doc__body_attribute_was(attribute_name)
  self.__doc__body_was == nil ? nil : self.__doc__body_was.with_indifferent_access[attribute_name]
end

#__doc__body_convert_attribute_type(attribute_name, value) ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/post_json/base.rb', line 84

def __doc__body_convert_attribute_type(attribute_name, value)
  case value
  when /^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9]\.[0-9]{3}Z$/
    Time.parse(value).in_time_zone
  when Hash
    value.inject(HashWithIndifferentAccess.new) do |result, (key, value)|
      result[key] = convert_document_attribute_type("#{attribute_name}.#{key}", value)
      result
    end
  when Array
    value.map.with_index do |array_value, index|
      convert_document_attribute_type("#{attribute_name}[#{index}]", array_value)
    end
  else
    value
  end
end

#__doc__body_read_attribute(attribute_name) ⇒ Object 



57
58
59
60
 
# File 'lib/post_json/base.rb', line 57

def __doc__body_read_attribute(attribute_name)
  __local__value = self.__doc__body[attribute_name.to_s] if self.__doc__body
  __doc__body_convert_attribute_type(attribute_name, __local__value)
end

#__doc__body_write_attribute(attribute_name, value) ⇒ Object 



62
63
64
65
 
# File 'lib/post_json/base.rb', line 62

def __doc__body_write_attribute(attribute_name, value)
  self.__doc__body = HashWithIndifferentAccess.new(self.__doc__body).merge(attribute_name.to_s => value)
  value
end

#attribute_changed?(attribute_name) ⇒ Boolean

Returns:

  • (Boolean) 


48
49
50
51
52
53
54
55
 
# File 'lib/post_json/base.rb', line 48

def attribute_changed?(attribute_name)
  attribute_name = attribute_name.to_s
  if attribute_name.in?(attribute_names)
    super
  else
    __doc__body_attribute_changed?(attribute_name)
  end
end

#attributes ⇒ Object 



27
28
29
 
# File 'lib/post_json/base.rb', line 27

def attributes
  read_attribute('__doc__body').try(:with_indifferent_access) || HashWithIndifferentAccess.new
end

#cache_key ⇒ Object 



21
22
23
24
25
 
# File 'lib/post_json/base.rb', line 21

def cache_key
  @dashed_name ||= self.class.name.underscore.dasherize
  __local__unique_version = __doc__version || Digest::MD5.hexdigest(attributes.inspect)
  "#{@dashed_name}-#{id}-version-#{__local__unique_version}"
end

#respond_to?(method_symbol, include_all = false) ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/post_json/base.rb', line 110

def respond_to?(method_symbol, include_all = false)
  if super
    true
  else
    method_name = method_symbol.to_s
    attribute_name =  if method_name.end_with?("_changed?")
                        method_name[0..-10]
                      elsif method_name.end_with?("_was")
                        method_name[0..-5]
                      elsif method_name.end_with?("=")
                        method_name[0..-2]
                      elsif method_name.end_with?("_change")
                        method_name[0..-8]
                      else
                        method_name
                      end
    attributes.has_key?(attribute_name)
  end
end

#to_h ⇒ Object 



31
32
33
 
# File 'lib/post_json/base.rb', line 31

def to_h
  attributes.deep_dup
end

#write_attribute(attribute_name, value) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/post_json/base.rb', line 35

def write_attribute(attribute_name, value)
  attribute_name = attribute_name.to_s
  if attribute_name == '__doc__body'
    value = value.try(:with_indifferent_access)
    self.__doc__body_will_change! unless self.__doc__body.try(:with_indifferent_access) == value
    super('__doc__body', value)
  elsif attribute_name.in?(attribute_names)
    super
  else
    __doc__body_write_attribute(attribute_name, value)
  end
end