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 



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/card/format.rb', line 170

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



503
504
505
 
# File 'lib/card/format.rb', line 503

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

#add_name_context(name = nil) ⇒ Object 



555
556
557
558
559
 
# File 'lib/card/format.rb', line 555

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

#canonicalize_view(view) ⇒ Object 



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

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 



494
495
496
 
# File 'lib/card/format.rb', line 494

def default_item_view
  :name
end

#default_render_args(view, a = nil) ⇒ Object 



246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/card/format.rb', line 246

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 



274
275
276
 
# File 'lib/card/format.rb', line 274

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

#expand_main(opts) ⇒ Object 



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

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

#focal? ⇒ Boolean

meaning the current card is the requested card

Returns:

  • (Boolean) 


153
154
155
156
157
158
159
 
# File 'lib/card/format.rb', line 153

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 



546
547
548
549
550
551
552
553
 
# File 'lib/card/format.rb', line 546

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 



469
470
471
472
473
474
475
476
477
478
 
# File 'lib/card/format.rb', line 469

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 



232
233
234
 
# File 'lib/card/format.rb', line 232

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 



417
418
419
420
421
422
423
424
425
 
# File 'lib/card/format.rb', line 417

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) 


149
150
151
 
# File 'lib/card/format.rb', line 149

def main?
  @depth == 0
end

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



431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/card/format.rb', line 431

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.render view, opts
  #end
end

#new_inclusion_card_args(options) ⇒ Object 



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

def new_inclusion_card_args 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
  args
end

#ok?(task) ⇒ Boolean

Returns:

  • (Boolean) 


356
357
358
359
360
361
 
# File 'lib/card/format.rb', line 356

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 



314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/card/format.rb', line 314

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 



236
237
238
239
240
241
242
243
 
# File 'lib/card/format.rb', line 236

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 



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/card/format.rb', line 340

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 



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

def prepare_nest opts
  @char_count ||= 0

  opts ||= {}
  case
  when opts.has_key?( :comment )                            ; opts[:comment]   # as in commented code
  when @mode == :closed && @char_count > Card.config.max_char_count   ; ''     # already out of view
  when opts[:inc_name]=='_main' && !Env.ajax? && @depth==0  ; expand_main opts
  else
    nested_card = Card.fetch opts[:inc_name], :new=>new_inclusion_card_args(opts)
    result = nest nested_card, opts
    @char_count += result.length if @mode == :closed && result
    result
  end
end

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



299
300
301
 
# File 'lib/card/format.rb', line 299

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

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



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

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 



194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/card/format.rb', line 194

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
        send "_view_#{ view }", args
      end
    end
  end
rescue => e
  rescue_view e, view
end

#rendering_error(exception, view) ⇒ Object 



282
283
284
 
# File 'lib/card/format.rb', line 282

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

#rescue_view(e, view) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
 
# File 'lib/card/format.rb', line 263

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
    rendering_error e, view
  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) 


209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/card/format.rb', line 209

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 



228
229
230
 
# File 'lib/card/format.rb', line 228

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



290
291
292
293
294
295
296
 
# File 'lib/card/format.rb', line 290

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 



336
337
338
 
# File 'lib/card/format.rb', line 336

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

#template ⇒ Object 



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

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 



542
543
544
 
# File 'lib/card/format.rb', line 542

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

#unsupported_view(view) ⇒ Object 



278
279
280
 
# File 'lib/card/format.rb', line 278

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

#view_for_unknown(view, args) ⇒ Object 



363
364
365
366
 
# File 'lib/card/format.rb', line 363

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

#with_inclusion_mode(mode) ⇒ Object 



375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'lib/card/format.rb', line 375

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

#wrap_main(content) ⇒ Object 



427
428
429
 
# File 'lib/card/format.rb', line 427

def wrap_main content
  content  #no wrapping in base format
end