Module: Zena::Use::ZafuTemplates::Common

Included in:
TextDocument::AssetHelper
Defined in:
lib/zena/use/zafu_templates.rb

Constant Summary collapse

DEFAULT_PATH = 
%r{^\/?\$([\+\-\w\/]+)}
DEFAULT_TEMPLATES_PATH = 
"#{Zena::ROOT}/app/views/zafu"

Instance Method Summary collapse

Instance Method Details

#default_template_url(opts = {}) ⇒ Object

Default template content for a specified mode



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/zena/use/zafu_templates.rb', line 170

def default_template_url(opts = {})
  if opts[:format] && opts[:format] != 'html'
    raise ActiveRecord::RecordNotFound
  elsif %w{+login +index +adminLayout +popupLayout +notFound admin}.include?(opts[:mode])
    zafu_url =['$default', "Node-#{opts[:mode]}"].map(&:to_filename).join('/')
  elsif opts[:mode]
    raise ActiveRecord::RecordNotFound
  else
    zafu_url =['$default', 'Node'].map(&:to_filename).join('/')
  end

  # File path:
  rel_path  = current_site.zafu_path + "/#{zafu_url}/#{lang_path}/_main.erb"
  path      = SITES_ROOT + rel_path

  if !File.exists?(path)
    rebuild_template(nil, opts.merge(:zafu_url => zafu_url, :rel_path => rel_path, :dev_mode => (dev_mode? && opts[:mode] != '+popupLayout')))
  end

  rel_path
end

#find_document_for_template(src, section_id = nil) ⇒ Object

Return a document for a given path and current directory. This method also returns a new current_directory built from ‘/[skin name]/dirname/in/skin’ Search order for documents depends on the leading ‘/’. With a leading slash “/joy/special/Node”:

  1. Search for a Document with fullpath [joy skin fullpath]/special/Node

  2. Search anywhere in the skin for a document named “Node”

Without a leading slash “special/Node”

  1. Search for a Document with fullpath [current directory]/special/Node

  2. Search anywhere in the master skin for a document named ‘Node’



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/zena/use/zafu_templates.rb', line 202

def find_document_for_template(src, section_id = nil)
  src = src.split('/') unless src.kind_of?(Array)

  if src[0] == ''
    # Starts with '/' : first part of the path is a Skin
    section_id = nil
    # remove blank
    src.shift
    # get skin
    return nil unless skin = get_skin(src.shift)
    section_id = skin.id
  elsif section_id.nil? && @skin
    section_id = @skin.id
    # does not start with '/' : look in current directory
  end

  self.asset_cache.cache_with_path(section_id, src) do
    unless document = secure(Document) { Document.find_by_path(src, section_id) }
      # find anywhere in Skin
      document = secure(Document) { Document.find_by_title(src.last, :conditions => ['section_id = ?', section_id]) }
    end
    document
  end
end

#fullpath_from_template_url(template_url = ) ⇒ Object

Return the full path from a template’s url. The expected url is of the form ‘/skin/Klass-mode/partial’



151
152
153
 
# File 'lib/zena/use/zafu_templates.rb', line 151

def fullpath_from_template_url(template_url=params[:t_url])
  "#{SITES_ROOT}#{template_path_from_template_url(template_url)}"
end

#get_template_text(path, section_id = nil) ⇒ Object

Return a template’s content from an url. If the url does not start with a ‘/’, we try by replacing the first element with the current skin_name and if it does not work, we try with the full url. If the url start with a ‘/’ we use the full url directly.



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/zena/use/zafu_templates.rb', line 47

def get_template_text(path, section_id = nil)
  if path =~ DEFAULT_PATH
    filepath = File.join(DEFAULT_TEMPLATES_PATH, "#{$1}.zafu")
    text = File.exist?(filepath) ? File.read(filepath) : nil
    return text, path, nil
  elsif @skin.nil? && path == 'Node'
    filepath = File.join(DEFAULT_TEMPLATES_PATH, "default/#{path}.zafu")
    text = File.exist?(filepath) ? File.read(filepath) : nil
    return text, path, nil
  else
    path = path.split('/').map {|s| String.from_filename(s) }
    if doc = find_document_for_template(path, section_id)
      # text, fullpath (for recursion testing), base_path
      return (doc.text || ''), doc.fullpath, doc.section_id, doc
    else
      nil
    end
  end
end

#save_erb_to_url(template, template_url) ⇒ Object

Callback to save an write an Ajax template to file.



141
142
143
144
145
146
147
 
# File 'lib/zena/use/zafu_templates.rb', line 141

def save_erb_to_url(template, template_url)
  path = fullpath_from_template_url(template_url)
  path += ".erb" unless path =~ /\.\w+\Z/
  FileUtils.mkpath(File.dirname(path)) unless File.exists?(File.dirname(path))
  File.open(path, "wb") { |f| f.syswrite(template) }
  ""
end

#template_url_for_asset(opts) ⇒ Object

Return the zen_path (‘/en/image34.png’) for an asset given its (urlencoded) path (‘img/footer.png’). The rule is not the same whether we are rendering a template and find <img/> <link rel=‘stylesheet’/> tags or if we are parsing assets in a CSS file.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/zena/use/zafu_templates.rb', line 71

def template_url_for_asset(opts)
  source = opts[:src]
  if source =~ /\A(.*)\.(\w+)\Z/
    source, format = $1, $2
  end

  if opts[:parse_assets]
    parent_id = opts[:parent].id

    if source =~ /\A(.*)_(\w+)\Z/
      # if the element was not found, maybe it was not a name with underscore but it was an image mode
      src2, mode2 = $1, $2
    end

    paths = []
    if source[0..0] == '/'
      # ignore parent
      parent_id = current_site.root_id
      paths << source[1..-1]
      paths << src2[1..-1] if src2
    else
      paths << source
      paths << src2 if src2
    end

    # Retrieve titles from urlencoding
    paths.map! do |path|
      res    = nil
      par_id = parent_id
      path.split('/').each do |e|
        if e == '..'
          # forces absolute path
          par_id = current_site.root_id
          res ||= opts[:parent].fullpath_as_title
          res.pop
        else
          res ||= []
          res << String.from_filename(e)
        end
      end
      [res, par_id]
    end

    if asset = secure(Document) { Document.find_by_path(*paths[0]) }
    elsif src2 && (asset = secure(Document) { Document.find_by_path(*paths[1]) })
      mode = mode2
    else
      return nil
    end
  else
    src2 = source.split('/').map {|s| String.from_filename(s) }

    if source =~ /\A(.*)_(\w+)\Z/
      source, mode = $1, $2
    end

    source = source.split('/').map {|f| String.from_filename(f) }

    unless asset = find_document_for_template(source, opts[:base_path])
      # '_...' did not mean mode but was an old name.
      mode = nil
      return nil unless asset = find_document_for_template(src2, opts[:base_path])
    end

  end

  data_path(asset, :mode => mode)
end

#valid_template?(content, opts) ⇒ Boolean

Make sure some vital templates never get broken

Returns:

  • (Boolean) 


156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/zena/use/zafu_templates.rb', line 156

def valid_template?(content, opts)
  #puts content
  mode = opts[:mode]
  case mode
  when '+login'
    content =~ %r{<form[^>]* action\s*=\s*./session}
  when '+adminLayout'
    content =~ %r{<%= content_for_layout %>} && %r{show_link(:admin_links)}
  else
    true
  end
end

#zafu_node(name, klass) ⇒ Object 



227
228
229
 
# File 'lib/zena/use/zafu_templates.rb', line 227

def zafu_node(name, klass)
  zafu_context[:node] = Zena::Use::NodeContext.new(name, klass)
end