Class: Card::Format

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

Defined Under Namespace

Modules: Location

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



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

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 



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

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.



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

def card
  @card
end

#error_status ⇒ Object

Returns the value of attribute error_status.



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

def error_status
  @error_status
end

#form ⇒ Object

Returns the value of attribute form.



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

def form
  @form
end

#inclusion_opts ⇒ Object

Returns the value of attribute inclusion_opts.



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

def inclusion_opts
  @inclusion_opts
end

#main_opts ⇒ Object (readonly)

Returns the value of attribute main_opts.



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

def main_opts
  @main_opts
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



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

def parent
  @parent
end

#root ⇒ Object (readonly)

Returns the value of attribute root.



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

def root
  @root
end

Class Method Details

.extract_class_vars(view, opts) ⇒ Object 



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

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 



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

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

.format_class_name(format) ⇒ Object 



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

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 



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

def max_depth
  Card.config.max_depth
end

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



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

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 



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

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

.tagged(view, tag) ⇒ Object 



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

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 —————



520
521
522
 
# File 'lib/card/format.rb', line 520

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

#add_name_context(name = nil) ⇒ Object 



572
573
574
575
576
 
# File 'lib/card/format.rb', line 572

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

#canonicalize_view(view) ⇒ Object 



382
383
384
385
386
387
 
# File 'lib/card/format.rb', line 382

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 



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

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

#default_item_view ⇒ Object 



511
512
513
 
# File 'lib/card/format.rb', line 511

def default_item_view
  :name
end

#default_render_args(view, a = nil) ⇒ Object 



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

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 



288
289
290
 
# File 'lib/card/format.rb', line 288

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

#expand_main(opts) ⇒ Object 



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

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 



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

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) 


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

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 



563
564
565
566
567
568
569
570
 
# File 'lib/card/format.rb', line 563

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 



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

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 



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

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 



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

def get_inclusion_defaults nested_card
  { :view => :name }
end

#hide_views(args) ⇒ Object 



242
243
244
 
# File 'lib/card/format.rb', line 242

def hide_views args
  parse_view_visibility args[:hide]
end

#include_set_format_modules ⇒ Object 



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

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 



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

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 



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

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) 


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

def main?
  @depth == 0
end

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



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
483
484
 
# File 'lib/card/format.rb', line 447

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) 


370
371
372
373
374
375
 
# File 'lib/card/format.rb', line 370

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 



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

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 



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

def params
  Env.params
end

#parse_view_visibility(val) ⇒ Object 



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

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 



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

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 



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

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 



313
314
315
 
# File 'lib/card/format.rb', line 313

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

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



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

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 



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

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.with_logging :view, :message=>view, :context=>card.name, :details=>args do
        Card::ViewCache.fetch(self, view, args) do
          send "_view_#{ view }", args
        end
      end
    end
  end
rescue => e
  rescue_view e, view
end

#rendering_error(exception, view) ⇒ Object 



296
297
298
 
# File 'lib/card/format.rb', line 296

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

#rescue_view(e, view) ⇒ Object 



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

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 



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

def session
  Env.session
end

#show_view?(view, args) ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



238
239
240
 
# File 'lib/card/format.rb', line 238

def show_views args
  parse_view_visibility args[:show]
end

#showname(title = nil) ⇒ Object 



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

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 ————



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

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 



350
351
352
 
# File 'lib/card/format.rb', line 350

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

#template ⇒ Object 



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

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 



559
560
561
 
# File 'lib/card/format.rb', line 559

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

#unsupported_view(view) ⇒ Object 



292
293
294
 
# File 'lib/card/format.rb', line 292

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

#view_for_unknown(view, args) ⇒ Object 



377
378
379
380
 
# File 'lib/card/format.rb', line 377

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

#with_inclusion_mode(mode) ⇒ Object 



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

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 



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

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 



443
444
445
 
# File 'lib/card/format.rb', line 443

def wrap_main content
  content  #no wrapping in base format
end