Module: Brief::Model::ClassMethods

Defined in:
lib/brief/model.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

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



381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/brief/model.rb', line 381

def method_missing(meth, *args, &block)
  # these methods have a special effect on the behavior of the
  # model definition.  we need to make sure we call finalize after
  # them
  if %w(meta content template example actions helpers).include?(meth.to_s)
    definition.send(meth, *args, &block)
    finalize
  elsif %w(defined_helper_methods defined_actions).include?(meth.to_s)
    definition.send(meth)
  elsif meth.to_s.match(/^on_(.*)_change$/)
    create_change_handler(Regexp.last_match[1], *args, &block)
  else
    super
  end
end

Instance Attribute Details

#name ⇒ Object 



287
288
289
 
# File 'lib/brief/model.rb', line 287

def name
  @name || to_s.split('::').last.underscore.gsub('_', ' ').titlecase
end

#type_alias ⇒ Object 



293
294
295
 
# File 'lib/brief/model.rb', line 293

def type_alias
  @type_alias || name.parameterize.gsub(/-/, '_')
end

Instance Method Details

#==(other) ⇒ Object 



139
140
141
 
# File 'lib/brief/model.rb', line 139

def ==(other)
  type_alias && type_alias == other.type_alias
end

#accessor_property_names ⇒ Object 



143
144
145
 
# File 'lib/brief/model.rb', line 143

def accessor_property_names
  (definition.content_schema.attributes.keys + definition.metadata_schema.keys).uniq
end

#after_initialize(&block) ⇒ Object 



281
282
283
 
# File 'lib/brief/model.rb', line 281

def after_initialize(&block)
  (self.after_initialization_hooks ||= []).push(block)
end

#attribute_names ⇒ Object 



325
326
327
 
# File 'lib/brief/model.rb', line 325

def attribute_names
  attribute_set.map(&:name)
end

#content_schema_summary ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/brief/model.rb', line 172

def content_schema_summary
  base = definition.content_schema.attributes

  base.keys.inject({}) do |memo, key|
    val = base[key]
    args = Array(val[:args])
    first = args.first
    memo[key] = first if first
    memo
  end
end

#create_change_handler(_attribute, *_args, &block) ⇒ Object 



397
398
399
 
# File 'lib/brief/model.rb', line 397

def create_change_handler(_attribute, *_args, &block)
  block.call(self)
end

#defined_actions ⇒ Object 



250
251
252
 
# File 'lib/brief/model.rb', line 250

def defined_actions
  definition.defined_actions ||= []
end

#defined_in(*args) ⇒ Object 



362
363
364
 
# File 'lib/brief/model.rb', line 362

def defined_in(*args)
  definition.send(:defined_in, *args)
end

#definition ⇒ Object 



297
298
299
 
# File 'lib/brief/model.rb', line 297

def definition
  @definition ||= Brief::Model::Definition.new(name, type_alias: type_alias, model_class: self)
end

#definition=(_value) ⇒ Object 



301
302
303
 
# File 'lib/brief/model.rb', line 301

def definition=(_value)
  @definition
end

#documentation(*args) ⇒ Object 



358
359
360
 
# File 'lib/brief/model.rb', line 358

def documentation(*args)
  definition.send(:documentation, *args)
end

#documentation_content ⇒ Object 



218
219
220
221
222
 
# File 'lib/brief/model.rb', line 218

def documentation_content
  if documentation_path && documentation_path.exist?
    return documentation_path.read.to_s
  end
end

#documentation_path(*args) ⇒ Object 



376
377
378
379
 
# File 'lib/brief/model.rb', line 376

def documentation_path(*args)
  definition.send(:documentation_path=, *args) unless args.empty?
  definition.send(:documentation_path)
end

#each(*args, &block) ⇒ Object 



277
278
279
 
# File 'lib/brief/model.rb', line 277

def each(*args, &block)
  Array(models).send(:each, *args, &block)
end

#example_body(*args) ⇒ Object 



334
335
336
 
# File 'lib/brief/model.rb', line 334

def example_body(*args)
  definition.send(:example_body, *args).to_s.strip
end

#example_content ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/brief/model.rb', line 202

def example_content
  if example_path && example_path.exist?
    return example_path.read.to_s
  end

  definition.example_body.to_s
end

#example_path(*args) ⇒ Object 



371
372
373
374
 
# File 'lib/brief/model.rb', line 371

def example_path(*args)
  definition.send(:example_path=, *args) unless args.empty?
  definition.send(:example_path)
end

#finalize ⇒ Object 



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/brief/model.rb', line 254

def finalize
  klass = self

  klass.name ||= klass.to_s.split('::').last.humanize
  klass.type_alias ||= klass.name.parameterize.gsub(/-/, '_')

  klass.attribute_set.map(&:name).each do |attr|
    unless klass.method_defined?("find_by_#{ attr }")
      klass.define_singleton_method("find_by_#{ attr }") do |value|
        where(attr => value).first
      end
    end
  end

  klass.definition.apply_config

  Brief::Repository.define_document_finder_methods
end

#generate_template_content_from(object = {}, include_frontmatter = true) ⇒ Object 



313
314
315
316
317
318
319
320
321
322
323
 
# File 'lib/brief/model.rb', line 313

def generate_template_content_from(object={}, include_frontmatter = true)
  @erb ||= ERB.new(template_body)
  content = @erb.result(binding)
  frontmatter = object.slice(*attribute_names)

  base = ''
  base += frontmatter.to_hash.to_yaml + "---\n" if include_frontmatter
  base += content

  base
end

#has_actions? ⇒ Boolean

Returns:

  • (Boolean) 


246
247
248
 
# File 'lib/brief/model.rb', line 246

def has_actions?
  definition.has_actions?
end

#metadata_schema_summary ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/brief/model.rb', line 184

def metadata_schema_summary
  base = definition.metadata_schema

  base.keys.inject({}) do |memo, key|
    val = base[key]
    args = Array(val[:args])
    first = args.first.to_s

    if args.length == 1 && first == key.to_s
      memo[key] = "string"
    elsif args.length >= 2
      memo[key] = args.last
    end

    memo
  end
end

#new_doc_name(&block) ⇒ Object 



348
349
350
351
352
353
354
355
356
 
# File 'lib/brief/model.rb', line 348

def new_doc_name(&block)
  if block
    definition.new_doc_name_block = block
  elsif definition.new_doc_name_block
    definition.new_doc_name_block.call
  else
    "#{ self.type_alias }-#{ DateTime.now.strftime("%Y-%m-%d") }.md"
  end
end

#new_doc_template(&block) ⇒ Object 



338
339
340
341
342
343
344
345
346
 
# File 'lib/brief/model.rb', line 338

def new_doc_template(&block)
  if block
    definition.new_doc_template_block = block
  elsif definition.new_doc_template_block
    definition.new_doc_template_block.call
  else
    example_content
  end
end

#section_mapping(*args) ⇒ Object 



305
306
307
 
# File 'lib/brief/model.rb', line 305

def section_mapping(*args)
  definition.send(:section_mapping, *args)
end

#section_mappings(*args) ⇒ Object 



309
310
311
 
# File 'lib/brief/model.rb', line 309

def section_mappings(*args)
  definition.send(:section_mappings, *args)
end

#template_body(*args) ⇒ Object 



329
330
331
332
 
# File 'lib/brief/model.rb', line 329

def template_body(*args)
  res = definition.send(:template_body, *args)
  res.to_s.length == 0 ? example_body : res.to_s.strip
end

#template_content ⇒ Object 



210
211
212
213
214
215
216
 
# File 'lib/brief/model.rb', line 210

def template_content
  if template_path && template_path.exist?
    return template_path.read.to_s
  end

  definition.template_body.to_s
end

#template_path(*args) ⇒ Object 



366
367
368
369
 
# File 'lib/brief/model.rb', line 366

def template_path(*args)
  definition.send(:template_path=, *args) unless args.empty?
  definition.send(:template_path)
end

#to_documentation ⇒ Object

Looks to see if there is a documentation markdown file for the model and if so, will return the documentation info as a Hash



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/brief/model.rb', line 149

def to_documentation
  docs = definition.documentation

  path = if docs.markdown
           Pathname(docs.markdown)
         elsif defined_in
           basename = defined_in.basename.to_s.gsub(/.rb/,'')
           defined_in.parent.join('..','documentation',"#{basename}.md")
         end

  if path
    model_doc = Brief::Briefcase::Documentation::ModelDoc.new(path)

    {
      content: model_doc.content,
      rendered: model_doc.rendered,
      path: path
    }
  else
    { }
  end
end

#to_schema ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/brief/model.rb', line 224

def to_schema
  {
    schema: {
      content: content_schema_summary,
      metadata: metadata_schema_summary,
    },
    documentation: to_documentation,
    defined_in: defined_in,
    class_name: to_s,
    type_alias: type_alias,
    name: name,
    group: name.to_s.pluralize,
    actions: defined_actions,
    example: example_content,
    template: template_content,
    urls: {
      browse_url: "browse/#{ type_alias.to_s.pluralize }",
      schema_url: "schema/#{ type_alias }"
    }
  }
end

#where(*args, &_block) ⇒ Object 



273
274
275
 
# File 'lib/brief/model.rb', line 273

def where(*args, &_block)
  Brief::DocumentMapper::Query.new(self).send(:where, *args)
end