Class: Card::Format

Inherits:
Object show all
Includes:
Location
Defined in:
lib/card/format.rb

Constant Summary collapse

DEPRECATED_VIEWS = 
{ view: :open, card: :open, line: :closed, bare: :core, naked: :core }
INCLUSION_MODES = 
{ closed: :closed, closed_content: :closed, edit: :edit,
layout: :layout, new: :edit, setup: :edit, normal: :normal, template: :template }
@@registered = 
[]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Location

#card_path, #card_url, #page_path

Constructor Details

#initialize(card, opts = {}) ⇒ Format

~~~~~ INSTANCE METHODS



80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/card/format.rb', line 80

def initialize card, opts={}
  @card = card or raise Card::Error, "format initialized without card"
  opts.each do |key, value|
    instance_variable_set "@#{key}", value
  end

  @mode  ||= :normal
  @depth ||= 0
  @root  ||= self

  @context_names = get_context_names
  include_set_format_modules
  self
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *opts, &proc) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/card/format.rb', line 177

def method_missing method, *opts, &proc
  case method
  when /(_)?(optional_)?render(_(\w+))?/
    view = $3 ? $4 : opts.shift
    args = opts[0] ? opts.shift.clone : {}
    args.merge!( optional: true, default_visibility: opts.shift) if $2
    args[ :skip_permissions ] = true if $1
    render view, args
  when /^_view_(\w+)/
    view = @current_view || $1
    unsupported_view view
  else
    proc = proc { |*a| raw yield *a } if proc
    response = root.template.send method, *opts, &proc
    String===response ? root.template.raw( response ) : response
  end
end

Instance Attribute Details

#card ⇒ Object (readonly)

Returns the value of attribute card.



17
18
19
 
# File 'lib/card/format.rb', line 17

def card
  @card
end

#error_status ⇒ Object

Returns the value of attribute error_status.



18
19
20
 
# File 'lib/card/format.rb', line 18

def error_status
  @error_status
end

#form ⇒ Object

Returns the value of attribute form.



18
19
20
 
# File 'lib/card/format.rb', line 18

def form
  @form
end

#inclusion_opts ⇒ Object

Returns the value of attribute inclusion_opts.



18
19
20
 
# File 'lib/card/format.rb', line 18

def inclusion_opts
  @inclusion_opts
end

#main_opts ⇒ Object (readonly)

Returns the value of attribute main_opts.



17
18
19
 
# File 'lib/card/format.rb', line 17

def main_opts
  @main_opts
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



17
18
19
 
# File 'lib/card/format.rb', line 17

def parent
  @parent
end

#root ⇒ Object (readonly)

Returns the value of attribute root.



17
18
19
 
# File 'lib/card/format.rb', line 17

def root
  @root
end

Class Method Details

.extract_class_vars(view, opts) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/card/format.rb', line 34

def extract_class_vars view, opts
  return unless opts.present?
  perms[view]        = opts.delete(:perms)      if opts[:perms]
  error_codes[view]  = opts.delete(:error_code) if opts[:error_code]
  denial_views[view] = opts.delete(:denial)     if opts[:denial]
  closed_views[view] = opts.delete(:closed)     if opts[:closed]

  if tags = opts.delete(:tags)
    Array.wrap(tags).each do |tag|
      view_tags[view] ||= {}
      view_tags[view][tag] = true
    end
  end

end

.format_ancestry ⇒ Object 



64
65
66
67
68
69
70
 
# File 'lib/card/format.rb', line 64

def format_ancestry
  ancestry = [ self ]
  unless self == Card::Format
    ancestry = ancestry + superclass.format_ancestry
  end
  ancestry
end

.format_class_name(format) ⇒ Object 



27
28
29
30
31
32
 
# File 'lib/card/format.rb', line 27

def format_class_name format
  format = format.to_s
  format = '' if format == 'base'
  format = @@aliases[ format ] if @@aliases[ format ]
  "#{ format.camelize }Format"
end

.max_depth ⇒ Object 



72
73
74
 
# File 'lib/card/format.rb', line 72

def max_depth
  Card.config.max_depth
end

.new(card, opts = {}) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/card/format.rb', line 50

def new card, opts={}
  if self != Format
    super
  else
    klass = Card.const_get format_class_name( opts[:format] || :html )
    self == klass ? super : klass.new( card, opts )
  end
end

.register(format) ⇒ Object 



23
24
25
 
# File 'lib/card/format.rb', line 23

def register format
  @@registered << format.to_s
end

.tagged(view, tag) ⇒ Object 



59
60
61
 
# File 'lib/card/format.rb', line 59

def tagged view, tag
  view and tag and view_tags = @@view_tags[view.to_sym] and view_tags[tag.to_sym]
end

Instance Method Details

#add_class(options, klass) ⇒ Object

———— LINKS —————



518
519
520
 
# File 'lib/card/format.rb', line 518

def add_class options, klass
  options[:class] = [ options[:class], klass ].flatten.compact * ' '
end

#add_name_context(name = nil) ⇒ Object 



536
537
538
539
540
 
# File 'lib/card/format.rb', line 536

def add_name_context name=nil
  name ||= card.name
  @context_names += name.to_name.part_names
  @context_names.uniq!
end

#canonicalize_view(view) ⇒ Object 



380
381
382
383
384
385
 
# File 'lib/card/format.rb', line 380

def canonicalize_view view
  unless view.blank?
    view_key = view.to_viewname.key.to_sym
    DEPRECATED_VIEWS[view_key] || view_key
  end
end

#controller ⇒ Object 



132
133
134
 
# File 'lib/card/format.rb', line 132

def controller
  Env[:controller] ||= CardController.new
end

#default_item_view ⇒ Object 



509
510
511
 
# File 'lib/card/format.rb', line 509

def default_item_view
  :name
end

#default_render_args(view, a = nil) ⇒ Object 



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/card/format.rb', line 254

def default_render_args view, a=nil
  args = case a
  when nil   ; {}
  when Hash  ; a.clone
  when Array ; a[0].merge a[1]
  else       ; raise Card::Error, "bad render args: #{a}"
  end

  view_key = canonicalize_view view
  default_method = "default_#{ view }_args"
  if respond_to? default_method
    send default_method, args
  end
  args
end

#error_cardname ⇒ Object 



286
287
288
 
# File 'lib/card/format.rb', line 286

def error_cardname
  card && card.name.present? ? card.name : 'unknown card'
end

#expand_main(opts) ⇒ Object 



418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/card/format.rb', line 418

def expand_main opts
  opts.merge! root.main_opts if root.main_opts
  legacy_main_opts_tweaks! opts

  #opts[:view] ||= :open
  with_inclusion_mode :normal do
    @mainline = true
    result = wrap_main nest( root.card, opts )
    @mainline = false
    result
  end
end

#fetch_nested_card(options) ⇒ Object 



495
496
497
498
499
500
501
502
503
504
505
506
507
 
# File 'lib/card/format.rb', line 495

def fetch_nested_card options
  args = { name: options[:inc_name], type: options[:type], supercard: card }
  args.delete(:supercard) if options[:inc_name].strip.blank? # special case.  gets absolutized incorrectly. fix in smartname?
  if options[:inc_name] =~ /^_main\+/
    # FIXME this is a rather hacky (and untested) way to get @superleft to work on new cards named _main+whatever
    args[:name] = args[:name].gsub /^_main\+/, '+'
    args[:supercard] = root.card
  end
  if content=get_inclusion_content(options[:inc_name])
    args[:content]=content
  end
  Card.fetch options[:inc_name], new: args
end

#focal? ⇒ Boolean

meaning the current card is the requested card

Returns:

  • (Boolean) 


160
161
162
163
164
165
166
 
# File 'lib/card/format.rb', line 160

def focal? # meaning the current card is the requested card
  if Env.ajax?
    @depth == 0
  else
    main?
  end
end

#format_date(date, include_time = true) ⇒ Object 



527
528
529
530
531
532
533
534
 
# File 'lib/card/format.rb', line 527

def format_date date, include_time = true
  # Must use DateTime because Time doesn't support %e on at least some platforms
  if include_time
    DateTime.new(date.year, date.mon, date.day, date.hour, date.min, date.sec).strftime("%B %e, %Y %H:%M:%S")
  else
    DateTime.new(date.year, date.mon, date.day).strftime("%B %e, %Y")
  end
end

#get_context_names ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/card/format.rb', line 95

def get_context_names
  case
  when @context_names
    part_keys = @card.cardname.part_names.map &:key
    @context_names.reject { |n| !part_keys.include? n.key }
  when params[:slot]
    context_name_list = params[:slot][:name_context].to_s
    context_name_list.split(',').map &:to_name
  else
    []
  end
end

#get_inclusion_content(cardname) ⇒ Object 



484
485
486
487
488
489
490
491
492
493
 
# File 'lib/card/format.rb', line 484

def get_inclusion_content cardname
  content = params[cardname.to_s.gsub(/\+/,'_')]

  # CLEANME This is a hack to get it so plus cards re-populate on failed signups
  if p = params['subcards'] and card_params = p[cardname.to_s]
    content = card_params['content']
  end
  content if content.present?  # why is this necessary? - efm
                               # probably for blanks?  -- older/wiser efm
end

#get_inclusion_defaults(nested_card) ⇒ Object 



124
125
126
 
# File 'lib/card/format.rb', line 124

def get_inclusion_defaults nested_card
  { view: :name }
end

#hide_views(args) ⇒ Object 



240
241
242
 
# File 'lib/card/format.rb', line 240

def hide_views args
  parse_view_visibility args[:hide]
end

#include_set_format_modules ⇒ Object 



108
109
110
111
112
113
114
 
# File 'lib/card/format.rb', line 108

def include_set_format_modules
  self.class.format_ancestry.reverse.each do |klass|
    card.set_format_modules( klass ).each do |m|
      singleton_class.send :include, m
    end
  end
end

#inclusion_defaults(nested_card) ⇒ Object 



116
117
118
119
120
121
122
 
# File 'lib/card/format.rb', line 116

def inclusion_defaults nested_card
  @inclusion_defaults ||= begin
    defaults = get_inclusion_defaults(nested_card).clone
    defaults.merge! @inclusion_opts if @inclusion_opts
    defaults
  end
end

#legacy_main_opts_tweaks!(opts) ⇒ Object 



431
432
433
434
435
436
437
438
439
 
# File 'lib/card/format.rb', line 431

def legacy_main_opts_tweaks! opts
  if val=params[:size] and val.present?
    opts[:size] = val.to_sym
  end

  if val=params[:item] and val.present?
    opts[:items] = (opts[:items] || {}).reverse_merge view: val.to_sym
  end
end

#main? ⇒ Boolean

Returns:

  • (Boolean) 


156
157
158
 
# File 'lib/card/format.rb', line 156

def main?
  @depth == 0
end

#nest(nested_card, opts = {}) ⇒ Object 



445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
 
# File 'lib/card/format.rb', line 445

def nest nested_card, opts={}
  #ActiveSupport::Notifications.instrument('card', message: "nest: #{nested_card.name}, #{opts}") do
  opts.delete_if { |k,v| v.nil? }
  opts.reverse_merge! inclusion_defaults(nested_card)

  sub = nil
  if opts[:inc_name] =~ /^_(self)?$/
    sub = self
  else
    sub = subformat nested_card
    sub.inclusion_opts = opts[:items] ? opts[:items].clone : {}
  end


  view = canonicalize_view opts.delete :view
  opts[:home_view] = [:closed, :edit].member?(view) ? :open : view
  # FIXME: special views should be represented in view definitions

  view = case @mode
  when :edit
    not_ready_for_form = @@perms[view]==:none || nested_card.structure || nested_card.key.blank? # eg {{_self|type}} on new cards
    not_ready_for_form ? :blank : :edit_in_form
  when :template
    :template_rule
  when :closed
    case
    when @@closed_views[view] == true || @@error_codes[view] ; view
    when specified_view = @@closed_views[view]               ; specified_view
    when !nested_card.known?                                 ; :closed_missing
    else                                                     ; :closed_content
    end
  else
    view
  end

  sub.optional_render view, opts
  #end
end

#ok?(task) ⇒ Boolean

Returns:

  • (Boolean) 


368
369
370
371
372
373
 
# File 'lib/card/format.rb', line 368

def ok? task
  task = :create if task == :update && card.new_card?
  @ok ||= {}
  @ok[task] = card.ok? task if @ok[task].nil?
  @ok[task]
end

#ok_view(view, args = {}) ⇒ Object 



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/card/format.rb', line 326

def ok_view view, args={}
  return view if args.delete :skip_permissions
  approved_view = case
    when @depth >= Card.config.max_depth            # prevent recursion. @depth tracks subformats
      :too_deep
    when @@perms[view] == :none                     # permission skipping specified in view definition
      view
    when args.delete(:skip_permissions)             # permission skipping specified in args
      view
    when !card.known? && !tagged(view, :unknown_ok) # handle unknown cards (where view not exempt)
      view_for_unknown view, args
    else                                            # run explicit permission checks
      permitted_view view, args
    end

  args[:denied_view] = view if approved_view != view
  if focal? && error_code = @@error_codes[ approved_view ]
    root.error_status = error_code
  end
  approved_view
end

#params ⇒ Object 



128
129
130
 
# File 'lib/card/format.rb', line 128

def params
  Env.params
end

#parse_view_visibility(val) ⇒ Object 



244
245
246
247
248
249
250
251
 
# File 'lib/card/format.rb', line 244

def parse_view_visibility val
  case val
  when Array; val
  when String; val.split(/[\s,]+/)
  when NilClass; []
  else raise Card::Error, "bad show/hide argument: #{val}"
  end.map{ |view| canonicalize_view view }
end

#permitted_view(view, args) ⇒ Object 



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'lib/card/format.rb', line 352

def permitted_view view, args
  perms_required = @@perms[view] || :read
  args[:denied_task] =
    if Proc === perms_required
      :read if !(perms_required.call self)  # read isn't quite right
    else
      [perms_required].flatten.find { |task| !ok? task }
    end

  if args[:denied_task]
    @@denial_views[view] || :denial
  else
    view
  end
end

#prepare_nest(opts) ⇒ Object 



400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/card/format.rb', line 400

def prepare_nest opts
  @char_count ||= 0
  opts ||= {}

  case
  when opts.has_key?(:comment)                                       # commented nest
    opts[:comment]
  when @mode == :closed && @char_count > Card.config.max_char_count  # move on; content out of view
    ''
  when opts[:inc_name] == '_main' && show_layout? && @depth==0       # the main card within a layout
    expand_main opts
  else                                                               # standard nest
    result = nest fetch_nested_card(opts), opts
    @char_count += result.length if @mode == :closed && result
    result
  end
end

#process_content(content = nil, opts = {}) ⇒ Object 



311
312
313
 
# File 'lib/card/format.rb', line 311

def process_content content=nil, opts={}
  process_content_object(content, opts).to_s
end

#process_content_object(content = nil, opts = {}) ⇒ Object 



315
316
317
318
319
320
321
322
323
324
 
# File 'lib/card/format.rb', line 315

def process_content_object content=nil, opts={}
  return content unless card
  content = card.raw_content || '' if content.nil?

  obj_content = Card::Content===content ? content : Card::Content.new( content, format=self, opts.delete(:content_opts) )
  card.update_references( obj_content, refresh=true ) if card.references_expired  # I thik we need this generalized
  obj_content.process_content_object do |chunk_opts|
    prepare_nest chunk_opts.merge(opts) { yield }
  end
end

#render(view, args = {}) ⇒ Object 



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

def render view, args={}
  unless args.delete(:optional) && !show_view?( view, args )
    @current_view = view = ok_view canonicalize_view( view ), args
    args = default_render_args view, args
    with_inclusion_mode view do
      Card::ViewCache.fetch(self, view, args) do
        method = method "_view_#{ view }"
        method.arity == 0 ? method.call : method.call(args)
      end
    end
  end
rescue => e
  rescue_view e, view
end

#rendering_error(exception, view) ⇒ Object 



294
295
296
 
# File 'lib/card/format.rb', line 294

def rendering_error exception, view
  "Error rendering: #{error_cardname} (#{view} view)"
end

#rescue_view(e, view) ⇒ Object 



271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/card/format.rb', line 271

def rescue_view e, view
  if Rails.env =~ /^cucumber|test$/
    raise e
  else
    Rails.logger.info "\nError rendering #{error_cardname} / #{view}: #{e.class} : #{e.message}"
    Card::Error.current = e
    card.notable_exception_raised
    if (debug = Card[:debugger]) && debug.content == 'on'
      raise e
    else
      rendering_error e, view
    end
  end
end

#session ⇒ Object 



136
137
138
 
# File 'lib/card/format.rb', line 136

def session
  Env.session
end

#show_view?(view, args) ⇒ Boolean

Returns:

  • (Boolean) 


217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/card/format.rb', line 217

def show_view? view, args
  default = args.delete(:default_visibility) || :show #FIXME - ugly
  view_key = canonicalize_view view
  api_option = args["optional_#{ view_key }".to_sym]
  case
  # args remove option
  when api_option == :always                   ; true
  when api_option == :never                    ; false
  # wagneer's choice
  when show_views( args ).member?( view_key )  ; true
  when hide_views( args ).member?( view_key )  ; false
  # args override default
  when api_option == :show                     ; true
  when api_option == :hide                     ; false
  # default
  else                                         ; default==:show
  end
end

#show_views(args) ⇒ Object 



236
237
238
 
# File 'lib/card/format.rb', line 236

def show_views args
  parse_view_visibility args[:show]
end

#showname(title = nil) ⇒ Object 



140
141
142
143
144
145
146
 
# File 'lib/card/format.rb', line 140

def showname title=nil
  if title
    title.to_name.to_absolute_name(card.cardname).to_show *@context_names
  else
    @showname ||= card.cardname.to_show *@context_names
  end
end

#subformat(subcard) ⇒ Object

————- Sub Format and Inclusion Processing ————



302
303
304
305
306
307
308
 
# File 'lib/card/format.rb', line 302

def subformat subcard
  subcard = Card.fetch( subcard, new: {} ) if String===subcard
  sub = self.class.new subcard, parent: self, depth: @depth+1, root: @root,
    # FIXME - the following four should not be hard-coded here.  need a generalized mechanism
    # for attribute inheritance
    context_names: @context_names, mode: @mode, mainline: @mainline, form: @form
end

#tagged(view, tag) ⇒ Object 



348
349
350
 
# File 'lib/card/format.rb', line 348

def tagged view, tag
  self.class.tagged view, tag
end

#template ⇒ Object 



168
169
170
171
172
173
174
175
 
# File 'lib/card/format.rb', line 168

def template
  @template ||= begin
    c = controller
    t = ActionView::Base.new c.class.view_paths, {_routes: c._routes}, c
    t.extend c.class._helpers
    t
  end
end

#unique_id ⇒ Object 



523
524
525
 
# File 'lib/card/format.rb', line 523

def unique_id
  "#{card.key}-#{Time.now.to_i}-#{rand(3)}"
end

#unsupported_view(view) ⇒ Object 



290
291
292
 
# File 'lib/card/format.rb', line 290

def unsupported_view view
  "view (#{view}) not supported for #{error_cardname}"
end

#view_for_unknown(view, args) ⇒ Object 



375
376
377
378
 
# File 'lib/card/format.rb', line 375

def view_for_unknown view, args
  # note: overridden in HTML
  focal? ? :not_found : :missing
end

#with_inclusion_mode(mode) ⇒ Object 



387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/card/format.rb', line 387

def with_inclusion_mode mode
  if switch_mode = INCLUSION_MODES[ mode ] and @mode != switch_mode
    old_mode, @mode = @mode, switch_mode
    @inclusion_defaults = nil
  end
  result = yield
  if old_mode
    @inclusion_defaults = nil
    @mode = old_mode
  end
  result
end

#with_name_context(name) ⇒ Object 



148
149
150
151
152
153
154
 
# File 'lib/card/format.rb', line 148

def with_name_context name
  old_context = @context_names
  add_name_context name
  result = yield
  @context_names = old_context
  result
end

#wrap_main(content) ⇒ Object 



441
442
443
 
# File 'lib/card/format.rb', line 441

def wrap_main content
  content  #no wrapping in base format
end