Module: Malt

Extended by:
Kernel
Defined in:
lib/malt.rb,
lib/malt/config.rb,
lib/malt/kernel.rb,
lib/malt/markup.rb,
lib/malt/render.rb,
lib/malt/engines.rb,
lib/malt/formats.rb,
lib/malt/template.rb,
lib/malt/meta/data.rb,
lib/malt/engines/abstract.rb,
lib/malt/formats/abstract.rb,
lib/malt/formats/abstract_template.rb

Defined Under Namespace

Modules: Engine, Format, Kernel Classes: Config, Markup, Template

Constant Summary collapse

DIRECTORY = 
File.dirname(__FILE__)

Class Method Summary collapse

Class Method Details

.config ⇒ Object 



10
11
12
 
# File 'lib/malt/render.rb', line 10

def self.config
  @config ||= Config.new
end

.const_missing(name) ⇒ Object 



21
22
23
24
 
# File 'lib/malt/meta/data.rb', line 21

def self.const_missing(name)
  key = name.to_s.downcase
  package[key] || profile[key] || super(name)
end

.engine(type, engine = nil) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/malt/render.rb', line 50

def self.engine(type, engine=nil)
  type   = ext_to_type(type)
  engine = engine || config.engine[type]
  case engine
  when Class
    #raise unless Engine.registry[type].include?(engine)
    engine
  when String, Symbol
    match = engine.to_s.downcase
    Engine.registry[type].find{ |e| e.basename.downcase == match }
  else
    if Engine.registry[type]
      Engine.registry[type].first
    else
      nil
    end
  end
end

.file(file, options = {}) ⇒ Object 



34
35
36
37
38
39
40
 
# File 'lib/malt.rb', line 34

def self.file(file, options={})
  type = options[:type] || options[:format] || File.extname(file)
  type = ext_to_type(type)
  malt_class = registry[type]
  raise "unkown type -- #{type}" unless malt_class
  malt_class.new(options.merge(:file=>file,:type=>type))
end

.file_read(file) ⇒ Object

TODO: Handle File objects and URLs.



88
89
90
 
# File 'lib/malt/render.rb', line 88

def self.file_read(file)
  File.read(file)
end

.file_type(file, type = nil) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/malt/render.rb', line 70

def self.file_type(file, type=nil)
  ext = type || File.extname(file)
  ext = ext.to_s.downcase
  if ext.empty?
    nil
  elsif ext[0,1] == '.'
    ext[1..-1].to_sym
  else
    ext.to_sym
  end
end

.main(*args) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/malt.rb', line 64

def self.main(*args)
  require 'optparse'
  itype, otype = nil, nil
  OptionParser.new{|o|
    o.on('-t TYPE', 'input type'){  |t| itype  = t }
    o.on('-o TYPE', 'output type'){ |t| otype = t }
    o.on('--help', '-h'       , 'display this help message'){ puts o; exit }
  }.parse!
  db, files = *args.partition{ |x| x.index('=') }
  db = db.inject({}){ |h,kv| k,v = kv.split('='); h[k] = v; h}
  files.each do |file|
    puts Malt.render(:file=>file, :type=>itype, :format=>otype)
    #file = itype ? Malt.file(file, :type=>itype) : Malt.file(file)
    #if otype
    #  puts file.render(otype, db)
    #else
    #  puts file.render(db)
    #end
  end
end

.open(url, options = {}) ⇒ Object 



56
57
58
59
60
61
 
# File 'lib/malt.rb', line 56

def self.open(url, options={})
  require 'open-uri'
  text = open(url).read
  file = File.basename(url) # parse better with URI.parse
  text(text, :file=>file)
end

.package ⇒ Object 



7
8
9
10
11
12
 
# File 'lib/malt/meta/data.rb', line 7

def self.package
  @package ||= (
    require 'yaml'
    YAML.load(File.new(DIRECTORY + '/package'))
  )
end

.profile ⇒ Object 



14
15
16
17
18
19
 
# File 'lib/malt/meta/data.rb', line 14

def self.profile
  @profile ||= (
    require 'yaml'
    YAML.load(File.new(DIRECTORY + '/profile'))
  )
end

.register(malt_class, *exts) ⇒ Object 



11
12
13
14
15
16
 
# File 'lib/malt.rb', line 11

def self.register(malt_class, *exts)
  exts.each do |ext|
    type = ext_to_type(ext)
    registry[type] = malt_class
  end
end

.registry ⇒ Object 



19
20
21
 
# File 'lib/malt.rb', line 19

def self.registry
  @registry ||= {}
end

.render(parameters = {}, &body) ⇒ Object

Render template.

parameters - File name of template. Used to read text. parameters - Text of template document. parameters - File type/extension used to look up engine. parameters - If not a supported type return text rather than raise an error. parameters - Force the use of a this specific engine. parameters - Format to convert to (usual default is ‘html`).



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/malt/render.rb', line 23

def self.render(parameters={}, &body)
  type   = parameters[:type]
  file   = parameters[:file]
  text   = parameters[:text]
  engine = parameters[:engine]

  type   = file_type(file, type)
  text   = file_read(file) unless text

  engine_class = engine(type, engine)

  if engine_class
    parameters[:type] = type
    parameters[:text] = text

    engine = engine_class.new
    engine.render(parameters, &body)
  else
    if parameters[:pass]
      text
    else
      raise "no engine to handle `#{type}' format"      
    end
  end
end

.support?(ext) ⇒ Boolean

Returns:

  • (Boolean) 


24
25
26
27
28
29
30
31
 
# File 'lib/malt.rb', line 24

def self.support?(ext)
  ext  = ext.to_s
  type = ext.sub(/^\./, '').strip
  return false if type.empty?
  #@registry.key?(ext.to_sym)
  #Engine.registry[type.to_sym]
  Engine.registry.key?(type.to_sym)
end

.text(text, options = {}) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/malt.rb', line 43

def self.text(text, options={})
  if file = options[:file]
    ext = File.extname(file)
    ext = nil if ext.empty?
  end
  type = options[:type] || options[:format] || ext
  type = ext_to_type(type)
  malt_class = registry[type] || Format::Text
  #raise "unkown type -- #{type}" unless malt_class
  malt_class.new(options.merge(:text=>text,:file=>file,:type=>type))
end