Class: Inversion::Template::Tag

Inherits:
Node
  • Object
show all
Extended by:
MethodUtilities, Loggability
Includes:
AbstractClass
Defined in:
lib/inversion/template/tag.rb

Overview

Inversion template tag node base class. Represents a directive in a template that defines behavior and/or state.

This class supports the RubyGems plugin API: to provide one or more Inversion tags in a gem of your own, put them into a directory named ‘inversion/template’ and name the files <tagname>tag.rb and the classes <tagname.capitalize>Tag.

Constant Summary collapse

TAG_PLUGIN_PATTERN =

The glob pattern for matching template tag plugins

'inversion/template/*tag.rb'

Instance Attribute Summary collapse

Attributes inherited from Node

#colnum, #linenum

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MethodUtilities

singleton_attr_accessor, singleton_attr_reader, singleton_attr_writer

Methods included from AbstractClass

included

Methods included from AbstractClass::ClassMethods

#inherited, #pure_virtual

Methods inherited from Node

#after_appending, #after_rendering, #before_appending, #before_rendering, #is_container?, #location, #render

Constructor Details

#initialize(body, linenum = nil, colnum = nil) ⇒ Tag

Create a new Inversion::Template::Tag with the specified ‘body`.



140
141
142
143
 
# File 'lib/inversion/template/tag.rb', line 140

def initialize( body, linenum=nil, colnum=nil )
	super
	@body = body.to_s.strip
end

Instance Attribute Details

#body ⇒ Object (readonly)

the body of the tag



151
152
153
 
# File 'lib/inversion/template/tag.rb', line 151

def body
  @body
end

Class Method Details

.create(tagname, body, linenum = nil, colnum = nil) ⇒ Object

Create a new Inversion::Template::Tag from the specified ‘tagname` and `body`.



121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/inversion/template/tag.rb', line 121

def self::create( tagname, body, linenum=nil, colnum=nil )
	tagname =~ /^(\w+)$/i or raise ArgumentError, "invalid tag name %p" % [ tagname ]
	tagtype = $1.downcase

	unless tagclass = self.types[ tagtype.to_sym ]
		Inversion.log.warn "Unknown tag type %p; registered: %p" %
			[ tagtype, self.types.keys ]
		return nil
	end

	return tagclass.new( body, linenum, colnum )
end

.inherited(subclass) ⇒ Object

Inheritance hook – keep track of loaded derivatives.



48
49
50
51
52
53
 
# File 'lib/inversion/template/tag.rb', line 48

def self::inherited( subclass )
	# Inversion.log.debug "%p inherited from %p" % [ subclass, self ]
	Inversion::Template::Tag.derivatives << subclass
	Inversion.log.debug "Loaded tag type %p" % [ subclass ]
	super
end

.load(tagfile) ⇒ Object

Safely load the specified ‘tagfile`.



108
109
110
111
112
113
114
115
116
117
 
# File 'lib/inversion/template/tag.rb', line 108

def self::load( tagfile )
	tagrequire = tagfile[ %r{inversion/template/\w+tag} ] or
		raise "tag file %p doesn't look like a tag plugin" % [ tagfile ]
	require( tagrequire )
rescue => err
	Inversion.log.error "%s while loading tag plugin %p: %s" %
		[ err.class.name, tagfile, err.message ]
	Inversion.log.debug "  " + err.backtrace.join( "\n  " )
	return false
end

.load_all ⇒ Object

Load all available template tags and return them as a Hash keyed by their name.



64
65
66
67
68
69
70
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
 
# File 'lib/inversion/template/tag.rb', line 64

def self::load_all
	tags = {}

	Gem.find_files( TAG_PLUGIN_PATTERN ).each do |tagfile|
		tagname = tagfile[ %r{/(\w+?)_?tag\.rb$}, 1 ]
		next unless tagname

		self.load( tagfile )

		# Inversion.log.debug "Looking for class for %p tag" % [ tagname ]
		tagclass = self.derivatives.find do |derivclass|
			if derivclass.name.nil? || derivclass.name.empty?
				# Inversion.log.debug "  skipping anonymous class %p" % [ derivclass ]
				nil
			elsif !derivclass.respond_to?( :new )
				# Inversion.log.debug "  skipping abstract class %p" % [ derivclass ]
				nil
			else
				derivclass.name.downcase =~ /\b#{tagname.gsub('_', '')}tag$/
			end
		end

		unless tagclass
			Inversion.log.debug "  no class found for %p tag" % [ tagname ]
			next
		end

		Inversion.log.debug "  found: %p" % [ tagclass ]
		snakecase_name = tagclass.name.sub( /^.*\b(\w+)Tag$/i, '\1' )
		snakecase_name = snakecase_name.gsub( /([a-z])([A-Z])/, '\1_\2' ).downcase
		Inversion.log.debug "  mapping %p to names: %p"  % [ tagclass, snakecase_name ]

		tags[ snakecase_name.to_sym ] = tagclass
		tags[ snakecase_name.gsub('_', '').to_sym ] = tagclass
	end

	@types ||= {}
	@types.merge!( tags )

	return @types
end

.types ⇒ Object

Return a Hash of all loaded tag types, loading them if they haven’t been loaded already.



57
58
59
60
 
# File 'lib/inversion/template/tag.rb', line 57

def self::types
       self.load_all unless @types
       return @types
end

Instance Method Details

#as_comment_body ⇒ Object

Render the tag as the body of a comment, suitable for template debugging.



155
156
157
 
# File 'lib/inversion/template/tag.rb', line 155

def as_comment_body
	return "%s %s at %s" % [ self.tagname, self.body.to_s.dump, self.location ]
end

#derivatives ⇒ Object

The Array of subclasses of this class



44
 
# File 'lib/inversion/template/tag.rb', line 44

singleton_attr_reader :derivatives

#tagname ⇒ Object

Return the human-readable name of the tag class



161
162
163
 
# File 'lib/inversion/template/tag.rb', line 161

def tagname
	return self.class.name.sub(/Tag$/, '').sub( /^.*::/, '' )
end

#types ⇒ Object

The hash of loaded tag types, keyed by the tag name as a Symbol



40
 
# File 'lib/inversion/template/tag.rb', line 40

singleton_attr_reader :types