Class: Card::Content

Inherits:
SimpleDelegator
  • Object
show all
Extended by:
Clean, Truncate
Defined in:
lib/card/content.rb,
lib/card/content/diff.rb,
lib/card/content/chunk.rb,
lib/card/content/clean.rb,
lib/card/content/parser.rb,
lib/card/content/truncate.rb,
lib/card/content/diff/l_c_s.rb,
lib/card/content/diff/result.rb,
lib/card/content/chunk/abstract.rb,
lib/card/content/diff/l_c_s/processor.rb,
mod/core/chunk/link.rb,
mod/core/chunk/nest.rb,
mod/core/chunk/literal.rb,
mod/core/chunk/reference.rb,
mod/core/chunk/view_stub.rb,
mod/core/chunk/query_reference.rb

Overview

Content objects support the parsing of content strings into arrays that contain semantically meaningful "chunks" like nests, links, urls, etc.

Each chunk has an object whose class inherits from Chunk::Abstract

Defined Under Namespace

Modules: Chunk, Clean, Truncate Classes: Diff, Parser

Constant Summary

Constants included from Clean

Clean::ALLOWED_TAGS, Clean::ATTR_VALUE_RE

Constants included from Truncate

Truncate::ELLIPSES_HTML

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Clean

clean!, clean_with_space_last!, process_attribute, process_attribute_match

Methods included from Truncate

smart_truncate

Constructor Details

#initialize(content, format_or_card, opts = {}) ⇒ Content

initialization parses String, detects chunks classes to be used in parsing

Parameters:

  • content (String)
  • format_or_card (Card::Format or Card)
  • opts (Hash) (defaults to: {})

Options Hash (opts):

  • :chunk_list (Symbol) —
    • name of registered list of chunk


23
24
25
26
27
28
29
 
# File 'lib/card/content.rb', line 23

def initialize content, format_or_card, opts={}
  @format = resolve_format format_or_card
  opts ||= {}
  chunk_list = opts[:chunk_list] || @format.chunk_list
  @chunks = Parser.new(chunk_list, self).parse(content)
  super(@chunks.any? ? @chunks : content)
end

Instance Attribute Details

#chunks ⇒ Object (readonly)

Returns the value of attribute chunks.



15
16
17
 
# File 'lib/card/content.rb', line 15

def chunks
  @chunks
end

#format ⇒ Object (readonly)

Returns the value of attribute format.



15
16
17
 
# File 'lib/card/content.rb', line 15

def format
  @format
end

#opts ⇒ Object (readonly)

Returns the value of attribute opts.



15
16
17
 
# File 'lib/card/content.rb', line 15

def opts
  @opts
end

#revision ⇒ Object (readonly)

Returns the value of attribute revision.



15
16
17
 
# File 'lib/card/content.rb', line 15

def revision
  @revision
end

Instance Method Details

#card ⇒ Card

Content must be associated with a Format object, which in turn must be associated with a Card

Returns:



34
35
36
 
# File 'lib/card/content.rb', line 34

def card
  @format.card
end

#custom_process_chunks ⇒ Object 



56
57
58
59
60
 
# File 'lib/card/content.rb', line 56

def custom_process_chunks
  each_chunk do |chunk|
    chunk.burn_after_reading yield(chunk)
  end
end

#each_chunk ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/card/content.rb', line 66

def each_chunk
  return enum_for(:each_chunk) unless block_given?

  iterator =
    case __getobj__
    when Hash   then :each_value
    when Array  then :each
    when String then return # no chunks
    else
      Rails.logger.warn "unrecognized type for #each_chunk: " \
                        " #{self.class} #{__getobj__.class}"
      return
    end
  send(iterator) { |item| yield item if item.is_a?(Chunk::Abstract) }
end

#find_chunks(chunk_type) ⇒ Array of Chunk instances

Find all chunks of a given type

Parameters:

  • chunk_type (Chunk Class)

Returns:

  • (Array of Chunk instances) 


41
42
43
 
# File 'lib/card/content.rb', line 41

def find_chunks chunk_type
  each_chunk.select { |chunk| chunk.is_a?(chunk_type) }
end

#has_chunk?(chunk_type) ⇒ Boolean

Returns:

  • (Boolean) 


45
46
47
 
# File 'lib/card/content.rb', line 45

def has_chunk? chunk_type
  each_chunk.any { |chunk| chunk.is_a?(chunk_type) }
end

#inspect ⇒ Object 



97
98
99
 
# File 'lib/card/content.rb', line 97

def inspect
  "<#{__getobj__.class}:#{card}:#{self}>"
end

#pieces ⇒ Object 



62
63
64
 
# File 'lib/card/content.rb', line 62

def pieces
  Array.wrap(__getobj__)
end

#process_chunks(&block) ⇒ Object

sends &block to #process_chunk on each Chunk object



50
51
52
53
54
 
# File 'lib/card/content.rb', line 50

def process_chunks &block
  return custom_process_chunks(&block) if block_given?

  each_chunk(&:process_chunk)
end

#to_s ⇒ Object

convert content to String. the common cases here are that either

  • (a) content is already a String, or
  • (b) it's an Array that needs to be iterated over and converted into a a string by running to_s on each item.


88
89
90
91
92
93
94
95
 
# File 'lib/card/content.rb', line 88

def to_s
  case __getobj__
  when Array    then map(&:to_s) * ""
  when String   then __getobj__
  when NilClass then "" # raise "Nil Card::Content"
  else               __getobj__.to_s
  end
end

#without_chunks(*chunk_classes) ⇒ Object 



113
114
115
116
117
118
 
# File 'lib/card/content.rb', line 113

def without_chunks *chunk_classes
  chunk_classes = ::Set.new Array.wrap(chunk_classes)
  stash = stash_chunks chunk_classes
  processed = yield to_s
  unstash_chunks processed, stash
end

#without_nests ⇒ Object 



101
102
103
104
105
 
# File 'lib/card/content.rb', line 101

def without_nests
  without_chunks Chunk::Nest do |content|
    yield content
  end
end

#without_references ⇒ Object 



107
108
109
110
111
 
# File 'lib/card/content.rb', line 107

def without_references
  without_chunks Chunk::Nest, Chunk::Link do |content|
    yield content
  end
end