Class: Brick::Config

Inherits:
Object show all
Includes:
Singleton
Defined in:
lib/brick/config.rb

Overview

Global configuration affecting all threads. Some thread-specific configuration can be found in ‘brick.rb`, others in `controller.rb`.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Config

Returns a new instance of Config.



14
15
16
17
18
19
20
21
 
# File 'lib/brick/config.rb', line 14

def initialize
  # Variables which affect all threads, whose access is synchronized.
  @mutex = Mutex.new
  @enabled = true

  # Variables which affect all threads, whose access is *not* synchronized.
  @serializer = Brick::Serializers::YAML
end

Instance Attribute Details

#association_reify_error_behaviour ⇒ Object

Returns the value of attribute association_reify_error_behaviour.



11
12
13
 
# File 'lib/brick/config.rb', line 11

def association_reify_error_behaviour
  @association_reify_error_behaviour
end

#object_changes_adapter ⇒ Object

Returns the value of attribute object_changes_adapter.



11
12
13
 
# File 'lib/brick/config.rb', line 11

def object_changes_adapter
  @object_changes_adapter
end

#root_model ⇒ Object

Returns the value of attribute root_model.



11
12
13
 
# File 'lib/brick/config.rb', line 11

def root_model
  @root_model
end

#serializer ⇒ Object

Returns the value of attribute serializer.



11
12
13
 
# File 'lib/brick/config.rb', line 11

def serializer
  @serializer
end

#version_limit ⇒ Object

Returns the value of attribute version_limit.



11
12
13
 
# File 'lib/brick/config.rb', line 11

def version_limit
  @version_limit
end

Instance Method Details

#add_orphans ⇒ Object

Add a special page to show references to non-existent records (“orphans”)



303
304
305
 
# File 'lib/brick/config.rb', line 303

def add_orphans
  true
end

#add_status ⇒ Object

Add status page showing all resources and what files have been built out for them



298
299
300
 
# File 'lib/brick/config.rb', line 298

def add_status
  true
end

#additional_references ⇒ Object

Additional table associations to use (Think of these as virtual foreign keys perhaps)



115
116
117
 
# File 'lib/brick/config.rb', line 115

def additional_references
  @mutex.synchronize { @additional_references }
end

#additional_references=(references) ⇒ Object 



119
120
121
 
# File 'lib/brick/config.rb', line 119

def additional_references=(references)
  @mutex.synchronize { @additional_references = references }
end

#api_root ⇒ Object 



97
98
99
100
 
# File 'lib/brick/config.rb', line 97

def api_root
  ver = api_version
  @mutex.synchronize { @api_root || "/api/#{ver}/" }
end

#api_root=(path) ⇒ Object 



102
103
104
 
# File 'lib/brick/config.rb', line 102

def api_root=(path)
  @mutex.synchronize { @api_root = path }
end

#api_version ⇒ Object 



106
107
108
 
# File 'lib/brick/config.rb', line 106

def api_version
  @mutex.synchronize { @api_version || 'v1' }
end

#api_version=(ver) ⇒ Object 



110
111
112
 
# File 'lib/brick/config.rb', line 110

def api_version=(ver)
  @mutex.synchronize { @api_version = ver }
end

#custom_columns ⇒ Object

Custom columns to add to a table, minimally defined with a name and DSL string



124
125
126
 
# File 'lib/brick/config.rb', line 124

def custom_columns
  @mutex.synchronize { @custom_columns }
end

#custom_columns=(cust_cols) ⇒ Object 



128
129
130
 
# File 'lib/brick/config.rb', line 128

def custom_columns=(cust_cols)
  @mutex.synchronize { @custom_columns = cust_cols }
end

#default_route_fallback ⇒ Object 



217
218
219
 
# File 'lib/brick/config.rb', line 217

def default_route_fallback
  @mutex.synchronize { @default_route_fallback }
end

#default_route_fallback=(resource_name) ⇒ Object 



221
222
223
 
# File 'lib/brick/config.rb', line 221

def default_route_fallback=(resource_name)
  @mutex.synchronize { @default_route_fallback = resource_name }
end

#enable_api ⇒ Object 



89
90
91
 
# File 'lib/brick/config.rb', line 89

def enable_api
  @mutex.synchronize { @enable_api }
end

#enable_api=(enable) ⇒ Object 



93
94
95
 
# File 'lib/brick/config.rb', line 93

def enable_api=(enable)
  @mutex.synchronize { @enable_api = enable }
end

#enable_controllers ⇒ Object

Indicates whether Brick controllers are on or off. Default: true.



60
61
62
63
 
# File 'lib/brick/config.rb', line 60

def enable_controllers
  brick_mode = mode
  @mutex.synchronize { brick_mode == :on && (@enable_controllers.nil? || @enable_controllers) }
end

#enable_controllers=(enable) ⇒ Object 



65
66
67
 
# File 'lib/brick/config.rb', line 65

def enable_controllers=(enable)
  @mutex.synchronize { @enable_controllers = enable }
end

#enable_models ⇒ Object

Indicates whether Brick models are on or off. Default: true.



50
51
52
53
 
# File 'lib/brick/config.rb', line 50

def enable_models
  brick_mode = mode
  @mutex.synchronize { brick_mode == :on && (@enable_models.nil? || @enable_models) }
end

#enable_models=(enable) ⇒ Object 



55
56
57
 
# File 'lib/brick/config.rb', line 55

def enable_models=(enable)
  @mutex.synchronize { @enable_models = enable }
end

#enable_routes ⇒ Object

Indicates whether Brick routes are on or off. Default: true.



80
81
82
83
 
# File 'lib/brick/config.rb', line 80

def enable_routes
  brick_mode = mode
  @mutex.synchronize { brick_mode == :on && (@enable_routes.nil? || @enable_routes) }
end

#enable_routes=(enable) ⇒ Object 



85
86
87
 
# File 'lib/brick/config.rb', line 85

def enable_routes=(enable)
  @mutex.synchronize { @enable_routes = enable }
end

#enable_views ⇒ Object

Indicates whether Brick views are on or off. Default: true.



70
71
72
73
 
# File 'lib/brick/config.rb', line 70

def enable_views
  brick_mode = mode
  @mutex.synchronize { brick_mode == :on && (@enable_views.nil? || @enable_views) }
end

#enable_views=(enable) ⇒ Object 



75
76
77
 
# File 'lib/brick/config.rb', line 75

def enable_views=(enable)
  @mutex.synchronize { @enable_views = enable }
end

#exclude_hms ⇒ Object

Skip creating a has_many association for these



133
134
135
 
# File 'lib/brick/config.rb', line 133

def exclude_hms
  @mutex.synchronize { @exclude_hms }
end

#exclude_hms=(skips) ⇒ Object 



137
138
139
 
# File 'lib/brick/config.rb', line 137

def exclude_hms=(skips)
  @mutex.synchronize { @exclude_hms = skips }
end

#exclude_tables ⇒ Object 



233
234
235
 
# File 'lib/brick/config.rb', line 233

def exclude_tables
  @mutex.synchronize { @exclude_tables || [] }
end

#exclude_tables=(value) ⇒ Object 



237
238
239
 
# File 'lib/brick/config.rb', line 237

def exclude_tables=(value)
  @mutex.synchronize { @exclude_tables = value }
end

#has_ones ⇒ Object

Associations to treat as a has_one



156
157
158
 
# File 'lib/brick/config.rb', line 156

def has_ones
  @mutex.synchronize { @has_ones }
end

#has_ones=(hos) ⇒ Object 



160
161
162
 
# File 'lib/brick/config.rb', line 160

def has_ones=(hos)
  @mutex.synchronize { @has_ones = hos }
end

#license ⇒ Object 



307
308
309
 
# File 'lib/brick/config.rb', line 307

def license
  @mutex.synchronize { @license }
end

#license=(key) ⇒ Object 



311
312
313
 
# File 'lib/brick/config.rb', line 311

def license=(key)
  @mutex.synchronize { @license = key }
end

#metadata_columns ⇒ Object 



281
282
283
 
# File 'lib/brick/config.rb', line 281

def metadata_columns
  @mutex.synchronize { @metadata_columns }
end

#metadata_columns=(columns) ⇒ Object 



285
286
287
 
# File 'lib/brick/config.rb', line 285

def metadata_columns=(columns)
  @mutex.synchronize { @metadata_columns = columns }
end

#mode ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/brick/config.rb', line 23

def mode
  @mutex.synchronize do
    case @brick_mode
    when nil, :development
      (::Rails.env == 'development' || ENV.key?('BRICK')) ? :on : nil
    when :diag_env
      ENV.key?('BRICK') ? :on : nil
    else
      @brick_mode
    end
  end
end

#mode=(setting) ⇒ Object 



36
37
38
 
# File 'lib/brick/config.rb', line 36

def mode=(setting)
  @mutex.synchronize { @brick_mode = setting unless @brick_mode == :on }
end

#model_descrips ⇒ Object 



173
174
175
 
# File 'lib/brick/config.rb', line 173

def model_descrips
  @mutex.synchronize { @model_descrips ||= {} }
end

#model_descrips=(descrips) ⇒ Object 



177
178
179
 
# File 'lib/brick/config.rb', line 177

def model_descrips=(descrips)
  @mutex.synchronize { @model_descrips = descrips }
end

#models_inherit_from ⇒ Object 



241
242
243
 
# File 'lib/brick/config.rb', line 241

def models_inherit_from
  @mutex.synchronize { @models_inherit_from }
end

#models_inherit_from=(value) ⇒ Object 



245
246
247
 
# File 'lib/brick/config.rb', line 245

def models_inherit_from=(value)
  @mutex.synchronize { @models_inherit_from = value }
end

#not_nullables ⇒ Object 



289
290
291
 
# File 'lib/brick/config.rb', line 289

def not_nullables
  @mutex.synchronize { @not_nullables }
end

#not_nullables=(columns) ⇒ Object 



293
294
295
 
# File 'lib/brick/config.rb', line 293

def not_nullables=(columns)
  @mutex.synchronize { @not_nullables = columns }
end

#order ⇒ Object 



257
258
259
 
# File 'lib/brick/config.rb', line 257

def order
  @mutex.synchronize { @order || {} }
end

#order=(orders) ⇒ Object

Get something like: Override how code sorts with:

{ 'on_call_list' => { code: "ORDER BY STRING_TO_ARRAY(code, '.')::int[]" } }

Specify default thing to order_by with:

{ 'on_call_list' => { _brick_default: [:last_name, :first_name] } }
{ 'on_call_list' => { _brick_default: :sequence } }



267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/brick/config.rb', line 267

def order=(orders)
  @mutex.synchronize do
    case (brick_default = orders.fetch(:_brick_default, nil))
    when NilClass
      orders[:_brick_default] = orders.keys.reject { |k| k == :_brick_default }.first
    when String
      orders[:_brick_default] = [brick_default.to_sym]
    when Symbol
      orders[:_brick_default] = [brick_default]
    end
    @order = orders
  end
end

#path_prefix ⇒ Object

Any path prefixing to apply to all auto-generated Brick routes



41
42
43
 
# File 'lib/brick/config.rb', line 41

def path_prefix
  @mutex.synchronize { @path_prefix }
end

#path_prefix=(path) ⇒ Object 



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

def path_prefix=(path)
  @mutex.synchronize { @path_prefix = path }
end

#polymorphics ⇒ Object

Polymorphic associations



165
166
167
 
# File 'lib/brick/config.rb', line 165

def polymorphics
  @mutex.synchronize { @polymorphics }
end

#polymorphics=(polys) ⇒ Object 



169
170
171
 
# File 'lib/brick/config.rb', line 169

def polymorphics=(polys)
  @mutex.synchronize { @polymorphics = polys }
end

#schema_behavior ⇒ Object 



189
190
191
 
# File 'lib/brick/config.rb', line 189

def schema_behavior
  @mutex.synchronize { @schema_behavior ||= {} }
end

#schema_behavior=(schema) ⇒ Object 



193
194
195
 
# File 'lib/brick/config.rb', line 193

def schema_behavior=(schema)
  @mutex.synchronize { @schema_behavior = schema }
end

#skip_database_views ⇒ Object 



225
226
227
 
# File 'lib/brick/config.rb', line 225

def skip_database_views
  @mutex.synchronize { @skip_database_views }
end

#skip_database_views=(disable) ⇒ Object 



229
230
231
 
# File 'lib/brick/config.rb', line 229

def skip_database_views=(disable)
  @mutex.synchronize { @skip_database_views = disable }
end

#skip_index_hms ⇒ Object

Skip showing counts for these specific has_many associations when building auto-generated #index views



142
143
144
 
# File 'lib/brick/config.rb', line 142

def skip_index_hms
  @mutex.synchronize { @skip_index_hms || {} }
end

#skip_index_hms=(skips) ⇒ Object 



146
147
148
149
150
151
152
153
 
# File 'lib/brick/config.rb', line 146

def skip_index_hms=(skips)
  @mutex.synchronize do
    @skip_index_hms ||= skips.each_with_object({}) do |v, s|
                          class_name, assoc_name = v.split('.')
                          (s[class_name] ||= {})[assoc_name.to_sym] = nil
                        end
  end
end

#sti_namespace_prefixes ⇒ Object 



181
182
183
 
# File 'lib/brick/config.rb', line 181

def sti_namespace_prefixes
  @mutex.synchronize { @sti_namespace_prefixes ||= {} }
end

#sti_namespace_prefixes=(prefixes) ⇒ Object 



185
186
187
 
# File 'lib/brick/config.rb', line 185

def sti_namespace_prefixes=(prefixes)
  @mutex.synchronize { @sti_namespace_prefixes = prefixes }
end

#sti_type_column ⇒ Object 



197
198
199
 
# File 'lib/brick/config.rb', line 197

def sti_type_column
  @mutex.synchronize { @sti_type_column ||= {} }
end

#sti_type_column=(type_col) ⇒ Object 



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/brick/config.rb', line 201

def sti_type_column=(type_col)
  @mutex.synchronize do
    (@sti_type_column = type_col).each_with_object({}) do |v, s|
      if v.last.nil?
        # Set an STI type column generally
        ActiveRecord::Base.inheritance_column = v.first
      else
        # Custom STI type columns for models built from specific tables
        (v.last.is_a?(Array) ? v.last : [v.last]).each do |table|
          ::Brick.relations[table][:sti_col] = v.first
        end
      end
    end
  end
end

#table_name_prefixes ⇒ Object 



249
250
251
 
# File 'lib/brick/config.rb', line 249

def table_name_prefixes
  @mutex.synchronize { @table_name_prefixes }
end

#table_name_prefixes=(value) ⇒ Object 



253
254
255
 
# File 'lib/brick/config.rb', line 253

def table_name_prefixes=(value)
  @mutex.synchronize { @table_name_prefixes = value }
end