glyph 0.2.0 → 0.3.0

data/lib/glyph/syntax_node.rb

@@ -0,0 +1,225 @@
+module Glyph
+
+	# A subclass of Glyph::SyntaxNode is instantiated by Glyph::Parser whenever a known
+	# text element is parsed.
+	# @since 0.3.0
+	class SyntaxNode < Node
+
+		# @return [String] an empty string 
+		# @since 0.3.0
+		def to_s
+			""
+		end
+
+		# @return [String] the value of the :value key
+		# @since 0.3.0
+		def evaluate(context, options={})
+			self[:value]
+		end
+
+		# @return [Glyph::MacroNode] the first Glyph::MacroNode ancestor
+		# @since 0.3.0
+		def parent_macro
+			find_parent{|n| n.is_a?(MacroNode)}
+		end
+
+	end
+
+	# The root element of any Glyph Abstract Syntax Tree
+	# @since 0.3.0
+	class DocumentNode < SyntaxNode
+
+		# @return [String] the value of the children node
+		# @since 0.3.0
+		def evaluate(context)
+			self[:value] = ""
+			self.children.each {|c| self[:value] << c.evaluate(context) }
+			self[:value]
+		end
+			
+	end
+
+	# A Glyph macro in Glyph Abstract Syntax Tree
+	# @since 0.3.0 
+	class MacroNode < SyntaxNode
+
+		# @return [String] a textual representation of the macro
+		# @since 0.3.0
+		def to_s
+			e = self[:escape] ? "=" : ""
+			"#{self[:name]}["+e+attributes.join+parameters.join("|")+e+"]"
+		end
+
+		# Expands the macro
+		# @return [String] the value of the macro
+		# @since 0.3.0
+		def evaluate(context, options={})
+			self[:value] = expand(context)
+		end
+
+		# @return [Array<Glyph::ParameterNode>] an array of the child parameter nodes
+		# @since 0.3.0
+		def parameters
+			children.select{|n| n.is_a? ParameterNode }
+		end
+
+		# 
+		# Returns the parameter syntax node at the specified index
+		# @param [Fixnum] n the index of the parameter 
+		# @return [Glyph::ParameterNode, nil] a parameter node
+		# @since 0.3.0
+		def parameter(n)
+			parameters[n]
+		end
+
+		# Equivalent to Glyph::MacroNode#parameter(0).
+		# @since 0.3.0
+		def value
+			parameter(0)
+		end
+
+		# @return [Array<Glyph::AttributeNode>] an array of the child attribute nodes
+		# @since 0.3.0 
+		def attributes
+			children.select{|n| n.is_a? AttributeNode }
+		end
+
+		# Returns the attribute syntax node with the specified name  
+		# @param [Symbol] name the name of the attribute
+		# @return [Glyph::AttributeNode, nil] an attribute node
+		# @since 0.3.0
+		def attribute(name)
+			attributes.select{|n| n[:name] == name}[0]
+		end
+
+		alias attr attribute
+		alias param parameter
+		alias attrs attributes
+		alias params parameters
+
+		# Expands the macro corresponding to self[:name]
+		# @param [Glyph::MacroNode] context the context of the macro
+		# @return [String] the value of the macro
+		# @since 0.3.0 
+		def expand(context)
+			xml_element(context)	
+			self.merge!({
+				:source => context[:source], 
+				:document => context[:document], 
+				:info => context[:info],
+				:value => ""
+			})
+			Glyph::Macro.new(self).expand
+		end
+
+		protected
+
+		def xml_element(context)
+			known_macro = Glyph::MACROS.include? self[:name]
+			name = self[:name].to_s
+			if !known_macro && name.match(/^=(.+)/) then
+				# Force tag name override if macro starts with a '='
+				name.gsub! /^=(.+)/, '\1' 
+			end
+			case
+				# Use XML syntax
+			when Glyph['language.set'] == 'xml' then
+				self[:element] = name
+				self[:name] = :"|xml|" 
+				# Fallback to XML syntax
+			when Glyph['language.options.xml_fallback'] then
+				unless known_macro then
+					self[:element] = name
+					self[:fallback] = true
+					self[:name] = :"|xml|" 
+				end
+			else
+				# Unknown macro
+				raise RuntimeError, "Undefined macro '#{name}'\n -> source: #{context[:source][:name]}" unless known_macro
+			end
+		end
+
+	end
+
+	# A piece of text in Glyph Abstract Syntax Tree
+	# @since 0.3.0 
+	class TextNode < SyntaxNode
+
+		# @return [String] the text itself
+		def to_s
+			self[:value]
+		end
+
+	end
+
+	# A Glyph macro parameter in Glyph Abstract Syntax Tree
+	# @since 0.3.0 
+	class ParameterNode < SyntaxNode
+
+		# @return [String] a textual representation of the parameter node
+		# @since 0.3.0 
+		def to_s
+			children.join
+		end
+
+		# @return [String] a textual representation of the parameter contents
+		# @since 0.3.0 
+		def contents
+			parent[:escape] ? ".[=#{children.join}=]" : children.join
+		end
+
+		# @param [Glyph::MacroNode] context the context of the macro
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :params whether to evaluate child nodes or not
+		# @return [String] the evaluated child nodes
+		# @since 0.3.0 
+		def evaluate(context, options={:params => false})
+			self[:value] = ""
+			self.children.each {|c| self[:value] << c.evaluate(context) } if options[:params]
+			self[:value]
+		end
+
+	end
+
+	# A Glyph macro attribute in Glyph Abstract Syntax Tree
+	# @since 0.3.0 
+	class AttributeNode < SyntaxNode
+
+		# @return [String] a textual representation of the attribute node
+		# @since 0.3.0 
+		def to_s
+			e = self[:escape] ? "=" : ""
+			"@#{self[:name]}["+e+children.join+e+"]"
+		end
+
+		# @return [String] a textual representation of the attribute contents
+		# @since 0.3.0 
+		def contents
+			self[:escape] ? ".[=#{children.join}=]" : children.join
+		end
+
+		# @param [Glyph::MacroNode] context the context of the macro
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :attrs whether to evaluate child nodes or not
+		# @return [String] the evaluated child nodes
+		# @since 0.3.0 
+		def evaluate(context, options={:attrs => false})
+			self[:value] = ""
+			self.children.each {|c| self[:value] << c.evaluate(context) } if options[:attrs]
+			self[:value]
+		end
+
+	end
+
+	# Some escaped text within Glyph Abstract Syntax Tree
+	# @since 0.3.0
+	class EscapeNode < SyntaxNode
+
+		# Returns the escaped value
+		def to_s
+			self[:value]
+		end
+
+	end
+
+end

data/macros/core.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+
+macro :snippet do
+	no_mutual_inclusion_in 0	
+	ident = value.to_sym
+	if Glyph::SNIPPETS.has_key? ident then
+		begin
+			update_source "snippet[#{ident}]"
+			interpret Glyph::SNIPPETS[ident] 
+		rescue Exception => e
+			case 
+			when e.is_a?(Glyph::MutualInclusionError) then
+				raise
+			when e.is_a?(Glyph::MacroError) then
+				macro_warning e.message, e
+			else
+				macro_warning e.message, e
+			end
+			macro_todo "Correct errors in snippet '#{ident}'"
+		end
+	else
+		macro_warning "Snippet '#{ident}' does not exist"
+		"[SNIPPET '#{ident}' NOT PROCESSED]"
+	end
+end
+
+macro "snippet:" do
+	exact_parameters 2
+	ident = param(0)
+	text = param(1)
+	Glyph::SNIPPETS[ident.to_sym] = text
+	""
+end
+
+macro "macro:" do
+	safety_check
+	exact_parameters 2
+	ident = param(0)
+	code = param(1)
+	Glyph.macro(ident) do
+		instance_eval code
+	end
+	""
+end
+
+macro :include do
+	safety_check
+	exact_parameters 1
+	no_mutual_inclusion_in 0
+	v = value
+	v += ".glyph" unless v.match(/\..+$/)
+	ext = v.match(/\.(.*)$/)[1] 
+	if Glyph.lite? then
+		file = Pathname.new(v)
+	else
+		if ext == 'rb' then
+			file = Glyph::PROJECT/"lib/#{v}"
+		else
+			file = Glyph::PROJECT/"text/#{v}"
+		end	
+	end
+	if file.exist? then
+		contents = file_load file
+		if ext == "rb" then
+			begin
+				Glyph.instance_eval contents
+				""
+			rescue Exception => e
+				macro_warning e.message, e
+			end
+		else
+			if Glyph["filters.by_file_extension"] && !ext.in?(['rb','glyph']) then
+				if Glyph::MACROS.include?(ext.to_sym) then
+					contents = "#{ext}[#{contents}]"
+				else 
+					macro_warning "Filter macro '#{ext}' not available"
+				end
+			end
+			begin 
+				update_source v
+				interpret contents
+			rescue Glyph::MutualInclusionError => e
+				raise
+			rescue Glyph::MacroError => e
+				macro_warning e.message, e
+				macro_todo "Correct errors in file '#{value}'"
+			rescue Exception => e
+				macro_warning e.message, e
+				macro_todo "Correct errors in file '#{value}'"
+			end
+		end
+	else
+		macro_warning "File '#{value}' no found."
+		"[FILE '#{value}' NOT FOUND]"
+	end
+end
+
+macro :ruby do
+	safety_check
+	max_parameters 1
+	res = Glyph.instance_eval(value.gsub(/\\*([\[\]\|])/){$1})
+	res.is_a?(Proc) ? "" : res
+end
+
+macro :config do
+	Glyph[value]
+end
+
+macro "config:" do
+	safety_check
+	max_parameters 2
+	setting = param(0)
+	v = param(1) rescue nil
+	if setting.match /^system\..+/ then
+		macro_warning "Cannot reset '#{setting}' setting (system use only)."
+	else
+		Glyph[setting] = v
+	end
+	nil
+end
+
+macro :comment do
+	""
+end
+
+macro :escape do
+	value
+end
+
+macro :condition do
+	min_parameters 1
+	max_parameters 2
+	res = param(0)
+	(res.blank? || res == "false") ? "" : param(1).to_s
+end
+
+macro :eq do
+	min_parameters 1
+	max_parameters 2
+	(param(0).to_s == param(1).to_s)	? true : nil
+end
+
+macro :not do
+	max_parameters 1
+	v = param(0).to_s
+	(v.blank? || v == "false") ? true : nil 
+end
+
+macro :and do
+	min_parameters 1
+	max_parameters 2
+	res_a = !param(0).blank?
+	res_b = !param(1).blank?
+	(res_a && res_b) ? true : nil
+end
+
+macro :or do
+	min_parameters 1
+	max_parameters 2
+	res_a = !param(0).blank?
+	res_b = !param(1).blank?
+	(res_a || res_b) ? true : nil
+end
+
+macro :match do
+	exact_parameters 2
+	val = param(0).to_s
+	regexp = param(1).to_s
+	macro_error "Invalid regular expression: #{regexp}" unless regexp.match /^\/.*\/[a-z]?$/
+	val.match(instance_eval(regexp)) ? true : nil
+end
+
+macro "alias:" do
+	exact_parameters 2
+	Glyph.macro_alias param(0) => param(1)
+end
+
+macro "rewrite:" do
+	safety_check
+	exact_parameters 2
+	macro_name = param(0).to_sym
+	@node.param(1).descend do |n, level|
+		if n[:name] == macro_name then
+			macro_error "Macro '#{macro_name}' cannot be defined by itself"
+		end
+	end
+	string = raw_param(1)
+	Glyph.macro macro_name do
+		s = string.dup
+		# Parameters
+		s.gsub!(/\{\{(\d+)\}\}/) do
+			raw_param($1.to_i).strip
+		end
+		# Attributes
+		s.gsub!(/\{\{([^\[\]\|\\\s]+)\}\}/) do
+			raw_attr($1.to_sym).strip
+		end
+		interpret s
+	end
+	nil
+end
+
+macro_alias '--' => :comment
+macro_alias '&' => :snippet
+macro_alias '&:' => 'snippet:'
+macro_alias '%:' => 'macro:'
+macro_alias '%' => :ruby
+macro_alias '$' => :config
+macro_alias '$:' => 'config:'
+macro_alias '.' => :escape
+macro_alias '?' => :condition
+macro_alias 'rw:' => 'rewrite:'

data/macros/filters.rb

@@ -1,13 +1,13 @@
 #!/usr/bin/env ruby
 
 macro :textile do
-	exact_parameters 1, :level => :warning
+	exact_parameters 1
 	rc = nil
 	begin
 		require 'RedCloth'
-		rc = RedCloth.new @value, Glyph::CONFIG.get("filters.redcloth.restrictions")
+		rc = RedCloth.new value, Glyph::CONFIG.get("filters.redcloth.restrictions")
 	rescue Exception
-		macro_error "RedCloth gem not installed. Please run: gem insall RedCloth"
+		macro_error "RedCloth gem not installed. Please run: gem install RedCloth"
 	end
 	target = Glyph["filters.target"]
 	case target.to_sym
@@ -24,7 +24,10 @@ macro :markdown do
 	exact_parameters 1, :level => :warning
 	md = nil
 	markdown_converter = Glyph["filters.markdown_converter"].to_sym rescue nil
-	if !markdown_converter then
+	begin
+		raise LoadError unless markdown_converter
+		require markdown_converter.to_s
+	rescue LoadError
 		begin
 			require 'bluecloth'
 			markdown_converter = :bluecloth
@@ -41,28 +44,24 @@ macro :markdown do
 						require 'kramdown'
 						markdown_converter = :kramdown
 					rescue LoadError
-						macro_error "No MarkDown converter installed. Please run: gem install bluecloth"
+						macro_error "No supported MarkDown converter installed. Please run: gem install bluecloth"
 					end
 				end
 			end
 		end
-		Glyph["filters.markdown_converter"] = markdown_converter
 	end
+	Glyph["filters.markdown_converter"] = markdown_converter
 	case markdown_converter
 	when :bluecloth
-		require 'bluecloth'
-		md = BlueCloth.new @value
+		md = BlueCloth.new value
 	when :rdiscount
-		require 'rdiscount'
-		md = RDiscount.new @value
+		md = RDiscount.new value
 	when :maruku
-		require 'maruku'
-		md = Maruku.new @value
+		md = Maruku.new value
 	when :kramdown
-		require 'kramdown'
-		md = Kramdown::Document.new @value
+		md = Kramdown::Document.new value
 	else
-	 macro_error "No MarkDown converter installed. Please run: gem insall bluecloth"
+	 macro_error "No supported MarkDown converter installed. Please run: gem install bluecloth"
 	end
 	target = Glyph["filters.target"]
 	if target.to_sym == :html then
@@ -72,4 +71,56 @@ macro :markdown do
 	end
 end
 
+macro :highlight do
+	exact_parameters 2  
+	lang = param(0)
+	text = param(1)
+	text.gsub!(/\\(.)/){$1}
+	highlighter = Glyph["filters.highlighter"].to_sym rescue nil
+	begin
+		raise LoadError unless highlighter
+		if highlighter.to_s.match(/^(uv|ultraviolet)$/) then
+			require 'uv'
+		else
+			require highlighter.to_s
+		end
+	rescue LoadError
+		begin
+			require 'coderay'
+			highlighter = :coderay
+		rescue LoadError
+			begin 
+				require 'uv'
+				highlighter = :ultraviolet
+			rescue LoadError
+				macro_error "No supported highlighter installed. Please run: gem install coderay"
+			end
+		end
+	end
+	Glyph["highlighter.current"] = highlighter
+	target = Glyph["filters.target"]
+	result = ""
+	case highlighter.to_sym
+	when :coderay
+		begin
+			result = CodeRay.scan(text, lang).div(Glyph["filters.coderay"])
+		rescue Exception => e
+			macro_error e.message
+		end
+	when :ultraviolet
+		begin
+			target = 'xhtml' if target.to_s == 'html'
+			result = Uv.parse(text.to_s, target.to_s, lang.to_s, 
+							 Glyph["filters.ultraviolet.line_numbers"], 
+							 Glyph["filters.ultraviolet.theme"].to_s)
+		rescue Exception => e
+			macro_error e.message
+		end
+	else
+		macro_error "No supported highlighter installed. Please run: gem install coderay"
+	end
+	result
+end
+
 macro_alias :md => :markdown
+macro_alias :txt => :textile