glyph 0.2.0 → 0.3.0

data/lib/glyph/config.rb

@@ -77,9 +77,9 @@ module Glyph
 		# @raise [ArgumentError] if the setting refers to an invalid namespace
 		# @example
 		# 	cfg = Glyph::Config.new
-		# 	cfg.set "quiet", true 								# Sets :quiet => true
+		# 	cfg.set "system.quiet", true 								# Sets "system.quiet" => true
 		# 	cfg.set "test.test_value", "[1,2,3]" # Sets :test => {:test_value => [1,2,3]}
-		# 	cfg.sef :quiet, "false" 							# Sets :quiet => false
+		# 	cfg.set "system.quiet", "false" 							# Sets "system.quiet" => false
 		def set(setting, value)
 			raise RuntimeError, "Configuration cannot be changed" unless @options[:mutable]
 			if value.is_a?(String) && value.match(/^(["'].*["']|:.+|\[.*\]|\{.*\}|true|false|nil)$/) then
@@ -122,7 +122,7 @@ module Glyph
 		# @see Glyph::Config#set
 		# @example
 		# 	cfg = Glyph::Config.new
-		# 	cfg.get :quiet							# true
+		# 	cfg.get "system.quiet"							# true
 		# 	cfg.get "test.test_value"	# [1,2,3]
 		def get(setting)
 			@data.instance_eval "self#{setting.to_s.split(".").map{|key| "[:#{key}]" }.join}" rescue nil

data/lib/glyph/document.rb

@@ -6,7 +6,7 @@ module Glyph
 	# currently being interpreted.
 	#
 	# It is responsible of analyzing (evaluating) the syntax tree and return the corresponding output
-	# as well as evaluating placeholders.
+	# as well as replacing placeholders.
 	class Document
 
 		ESCAPES = [
@@ -40,7 +40,7 @@ module Glyph
 		# @raise [RuntimeError] unless the document has been analized
 		def structure
 			raise RuntimeError, "Document has not been analyzed" unless analyzed? || finalized?
-			@tree.data
+			@tree
 		end
 
 		# Copies bookmarks, headers, todos and placeholders from another Glyph::Document
@@ -99,7 +99,7 @@ module Glyph
 		def analyze
 			raise RuntimeError, "Document is #{@state}" if analyzed? || finalized?
 			@context[:document] = self
-			@output = @tree.evaluate @context, nil
+			@output = @tree.evaluate @context
 			@state = :analyzed
 		end
 
@@ -114,12 +114,18 @@ module Glyph
 			raise RuntimeError, "Document cannot be finalized due to previous errors" unless @context[:document].errors.blank?
 			# Substitute placeholders
 			ESCAPES.each{|e| @output.gsub! e[0], e[1]}
-			@placeholders.each_pair do |key, value| 
-				begin
-					@output.gsub! key.to_s, value.call(self).to_s
-				rescue Exception => e
-					Glyph.warning e.message
+			begin
+				@placeholders.each_pair do |key, value| 
+					begin
+						@output.gsub! key.to_s, value.call(self).to_s
+					rescue Glyph::MacroError => e
+						e.macro.macro_warning e.message, e
+					rescue Exception => e
+						puts e.class
+						Glyph.warning e.message
+					end
 				end
+			rescue Exception => e
 			end
 			@state = :finalized
 		end

data/lib/glyph/interpreter.rb

@@ -1,74 +1,24 @@
-# @private
-class GlyphSyntaxNode < Treetop::Runtime::SyntaxNode 
-
-	attr_reader :data
-
-	def evaluate(context, current=nil)
-		current ||= context.to_node
-		@data ||= current.to_node
-		elements.map { |e| e.evaluate(context, current) if e.respond_to? :evaluate }.join 
-	end
-
-end
-
-# @private
-class MacroNode < GlyphSyntaxNode
-
-	def evaluate(context, current)
-		name = macro_name.text_value.to_sym
-		raise Glyph::SyntaxError, "Undefined macro '#{name}'\n -> source: #{current[:source]}" unless Glyph::MACROS.include? name
-		@data = {:macro => name, :source => context[:source], :document => context[:document]}.to_node
-		@data[:escape] = true if is_a? EscapingMacroNode
-		current << @data
-		@data[:value] = super(context, @data).strip
-		Glyph::Macro.new(@data).execute
-	end
-
-end
-
-# @private
-class EscapingMacroNode < MacroNode; end
-
-# @private
-class TextNode < GlyphSyntaxNode	
-
-	def evaluate(context, current=nil)
-		text_value
-	end
-
-end
-
-
 module Glyph
-
+	
 	# A Glyph::Interpreter object perform the following actions:
 	# * Parses a string of text containing Glyph macros
 	# * Creates a document based on the parsed syntax tree
 	# * Analyzes and finalizes the document
 	class Interpreter
 
-		PARSER = GlyphLanguageParser.new
-
 		# Creates a new Glyph::Interpreter object.
 		# @param [String] text the string to interpret
-		# @param [Hash] context the context to pass along when evaluating macros
-		def initialize(text, context=nil)
-			context ||= {:source => '--'}
-			@raw = PARSER.parse text
+		# @param [Hash] context the context to pass along when expanding macros
+		def initialize(text, context={})
 			@context = context
-			tf = PARSER.terminal_failures
-			if !@raw.respond_to?(:evaluate) then
-				reason = "Incorrect macro syntax"
-				err = "#{reason}\n -> #{@context[:source]} [Line #{PARSER.failure_line}, Column #{PARSER.failure_column}]"
-				@context[:document].errors << err if @context[:document] && !@context[:embedded]
-				raise Glyph::SyntaxError, err
-			end
-			@document = Glyph::Document.new @raw, @context
-			@document.inherit_from @context[:document] if @context[:document]
+			@context[:source] ||= {:name => "--"}
+			@text = text
+			@parser = Glyph::Parser.new text, @context[:source][:name]
 		end
 
 		# @see Glyph::Document#analyze
 		def process
+			parse unless @tree
 			@document.analyze
 		end
 
@@ -80,15 +30,25 @@ module Glyph
 		# Returns the finalized @document (calls self#process and self#postprocess if necessary)
 		# @return [Glyph::Document] the finalized document
 		def document
+			parse unless @tree
 			return @document if @document.finalized?
 			process if @document.new?
 			postprocess if @document.analyzed?
 			@document
 		end
 
+		# Parses the string provided during initialization
+		# @return [Glyph::SyntaxNode] the Abstract Syntax Tree generated from the string
+		# @since 0.3.0
+		def parse
+			Glyph.info "Parsing: #{@context[:source][:name]}" if Glyph.debug? && @context[:info] && @context[:source][:name]
+			@tree = @parser.parse
+			@document = Glyph::Document.new @tree, @context
+			@document.inherit_from @context[:document] if @context[:document]
+			@tree
+		end
 	
 	end
-
 end
 
 

data/lib/glyph/macro.rb

@@ -9,41 +9,153 @@ module Glyph
 
 		include Validators
 
+		attr_reader :node, :source
+
 		# Creates a new macro instance from a Node
 		# @param [Node] node a node populated with macro data
 		def initialize(node)
 			@node = node
-			@name = @node[:macro]
-			@value = @node[:value]
-			@source = @node[:source]
-			@escaped_pipe = '‡‡‡‡‡ESCAPED¤PIPE‡‡‡‡‡'
+			@name = @node[:name]
+			@updated_source = nil
+			@source = @node[:source][:name] rescue "--"
 		end
 
-		# Parses the macro parameters (stripping values)
-		# @return [Array] the macro parameters
-		def params
-			return @params if @params
-			@params = @value.gsub(/\\\|/, @escaped_pipe).split('|').map{|p| p.strip.gsub @escaped_pipe, "\\|"}
+		# Resets the name of the updated source (call before calling 
+		# Macro#interpret)
+		# @param [String] name the source name
+		def update_source(name)
+			@updated_source = {:node => @node, :name => name}
+		end
+		
+		# Returns a Glyph code representation of the specified parameter
+		# @param [Fixnum] n the index of the parameter
+		# @return [String, nil] the string representation of the parameter
+		# @since 0.3.0
+		def raw_parameter(n)
+			@node.parameter(n).contents.to_s rescue nil
+		end
+
+		# Returns a Glyph code representation of the specified attribute
+		# @param [String, Symbol] name the name of the attribute
+		# @return [String, nil] the string representation of the attribute
+		# @since 0.3.0
+		def raw_attribute(name)
+			@node.attribute(name).contents.to_s rescue nil
+		end
+
+		# Returns an evaluated macro attribute by name
+		# @param [String, Symbol] name the name of the attribute
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :strip whether the value is stripped or not
+		# @return [String, nil] the value of the attribute
+		# @since 0.3.0
+		def attribute(name, options={:strip => true})
+			return @attributes[name.to_sym] if @attributes && @attributes[name.to_sym]
+			return nil unless @node.attribute(name)
+			@attributes = {} unless @attributes
+			@attributes[name] = @node.attribute(name).evaluate(@node, :attrs => true).to_s
+			@attributes[name].strip! if options[:strip]
+			@attributes[name]
+		end
+
+		# Returns an evaluated macro parameter by index
+		# @param [Fixnum] n the index of the parameter
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :strip whether the value is stripped or not
+		# @return [String, nil] the value of the parameter
+		# @since 0.3.0
+		def parameter(n, options={:strip => true})
+			return @parameters[n] if @parameters && @parameters[n]
+			return nil unless @node.parameter(n)
+			@parameters = Array.new(@node.parameters.length) unless @parameters
+			@parameters[n] = @node.parameter(n).evaluate(@node, :params => true).to_s
+			@parameters[n].strip! if options[:strip]
+			@parameters[n]
 		end
 
-		# Parses the macro parameters (without stripping values)
+		# Returns a hash containing all evaluated macro attributes
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :strip whether the value is stripped or not
+		# @return [Hash] the macro attributes
+		# @since 0.3.0
+		def attributes(options={:strip => true})
+			return @attributes if @attributes
+			@attributes = {}
+			@node.attributes.each do |value|
+				@attributes[value[:name]] = value.evaluate(@node, :attrs => true)
+				@attributes[value[:name]].strip! if options[:strip]
+			end
+			@attributes
+		end
+
+		# Returns an array containing all evaluated macro parameters
+		# @param [Hash] options a hash of options
+		# @option options [Boolean] :strip whether the value is stripped or not
 		# @return [Array] the macro parameters
-		def raw_params
-			return @raw_params if @raw_params
-			@params = @value.gsub(/\\\|/, @escaped_pipe).split('|').map{|p| p.gsub @escaped_pipe, "\\|"}
+		# @since 0.3.0
+		def parameters(options={:strip => true})
+			return @parameters if @parameters
+			@parameters = []
+			@node.parameters.each do |value|
+				@parameters << value.evaluate(@node, :params => true)
+				@parameters.last.strip! if options[:strip]
+			end
+			@parameters
+		end
+
+		alias params parameters
+		alias param parameter
+		alias attrs attributes
+		alias attr attribute
+		alias raw_param raw_parameter
+		alias raw_attr raw_attribute
+
+		# Equivalent to Glyph::Macro#parameter(0).
+		# @since 0.3.0
+		def value
+			parameter(0)
+		end
+
+		# Equivalent to Glyph::Macro#raw_parameter(0).
+		# @since 0.3.0
+		def raw_value
+			raw_parameter(0)
 		end
 
 		# Returns the "path" to the macro within the syntax tree.
 		# @return [String] the macro path
+		# @since 0.3.0
 		def path
 			macros = []
-			@node.ascend {|n| macros << n[:macro].to_s if n[:macro] }
-			macros.reverse.join('/')
+			@node.ascend do |n|
+				case 
+				when n.is_a?(Glyph::MacroNode) then
+					if n[:name] == :"|xml|" then
+						name = "xml[#{n[:element]}]"
+					else
+						break if n[:name] == :include
+						name = n[:name].to_s
+					end
+				when n.is_a?(Glyph::ParameterNode) then
+					if n.parent.parameters.length == 1 then
+						name = nil
+					else
+						name = n[:name].to_s
+					end
+				when n.is_a?(Glyph::AttributeNode) then
+					name = "@#{n[:name]}"
+				else
+					name = nil
+				end
+				macros << name
+			end
+			macros.reverse.compact.join('/')
 		end
 		
 		# Returns a todo message to include in the document in case of errors.
 		# @param [String] message the message to include in the document
 		# @return [String] the resulting todo message
+		# @since 0.2.0
 		def macro_todo(message)
 			draft = Glyph['document.draft']
 			Glyph['document.draft'] = true unless draft
@@ -56,57 +168,49 @@ module Glyph
 		# @param [String] msg the message to print
 		# @raise [Glyph::MacroError]
 		def macro_error(msg, klass=Glyph::MacroError)
-			src = @node[:source_name]
-			src ||= @node[:source]
-			src ||= "--"
-			message = "#{msg}\n -> source: #{src}\n -> path: #{path}"
-			@node[:document].errors << message
-			message += "\n -> value:\n#{"-"*54}\n#{@value}\n#{"-"*54}" if Glyph.debug?
-			raise klass, message
+			@node[:document].errors << msg if @node[:document]
+			raise klass.new(msg, self)
 		end
 
-		# Raises a macro error
+		# Prints a macro earning
 		# @param [String] msg the message to print
-		# @raise [Glyph::MacroError]
-		def macro_warning(message)
-			src = @node[:source_name]
-			src ||= @node[:source]
-			src ||= "--"
-			Glyph.warning "#{message}\n -> source: #{src}\n -> path: #{path}"
-			message += %{\n -> value:\n#{"-"*54}\n#{@value}\n#{"-"*54}} if Glyph.debug?
+		# @param [Exception] e the exception raised
+		# @since 0.2.0
+		def macro_warning(msg, e=nil)
+			if e.is_a?(Glyph::MacroError) then
+				e.display 
+			else
+				message = "#{msg}\n    source: #{@source}\n    path: #{path}"
+				if Glyph.debug? then
+					message << %{\n#{"-"*54}\n#{@node.to_s.gsub(/\t/, ' ')}\n#{"-"*54}} 
+					if e then
+						message << "\n"+"-"*20+"[ Backtrace: ]"+"-"*20
+						message << "\n"+e.backtrace.join("\n")
+						message << "\n"+"-"*54
+					end
+				end
+				Glyph.warning message
+			end
 		end
 
 		# Instantiates a Glyph::Interpreter and interprets a string
 		# @param [String] string the string to interpret
 		# @return [String] the interpreted output
-		# @raise [Glyph::MacroError] in case of mutual macro inclusion (snippet, include macros)
 		def interpret(string)
-			@node[:source] = "#@name[#@value]"
-			@node[:source_name] = "#{@name}[...]"
-			macro_error "Mutual inclusion", Glyph::MutualInclusionError if @node.find_parent {|n| n[:source] == @node[:source] }
 			if @node[:escape] then
 				result = string 
 			else
-				@node[:embedded] = true
-			 	result = Glyph::Interpreter.new(string, @node).document.output
+				context = {}
+				context[:source] = @updated_source || @node[:source]
+				context[:embedded] = true
+				context[:document] = @node[:document]
+				interpreter = Glyph::Interpreter.new string, context
+				subtree = interpreter.parse
+				@node << subtree
+				result = interpreter.document.output
 			end
 			result.gsub(/\\*([\[\]])/){"\\#$1"}
-		end
-
-		# Encodes all macros in a string so that it can be encoded
-		# (and interpreted) later on
-		# @param [String] string the string to encode
-		# @return [String] the encoded string
-		def encode(string)
-			string.gsub(/([\[\]\|])/) { "‡‡¤#{$1.bytes.to_a[0]}¤‡‡" }
-		end
-
-		# Decodes a previously encoded string 
-		# so that it can be interpreted
-		# @param [String] string the string to decode
-		# @return [String] the decoded string
-		def decode(string)
-			string.gsub(/‡‡¤(91|93|124)¤‡‡/) { $1.to_i.chr }
+			result
 		end
 
 		# @see Glyph::Document#placeholder
@@ -135,12 +239,13 @@ module Glyph
 		end
 
 		# Executes a macro definition in the context of self
-		def execute
-			res = instance_exec(@node, &Glyph::MACROS[@name]).to_s
+		def expand
+			block = Glyph::MACROS[@name]
+			macro_error "Undefined macro '#@name'}" unless block
+			res = instance_exec(@node, &block).to_s
 			res.gsub!(/\\*([\[\]\|])/){"\\#$1"} 
 			res
 		end
 
 	end
-
 end