glyph 0.1.0 → 0.2.0

data/lib/glyph/commands.rb

@@ -21,24 +21,92 @@ command :add do |c|
 end
 
 GLI.desc 'Compile the project'
-arg_name "[output_target]"
+arg_name "[source_file]"
+arg_name "[destination_file]"
 command :compile do |c|
 	c.desc "Specify a glyph file to compile (default: document.glyph)"
 	c.flag [:s, :source]
 	c.desc "Specify the format of the output file (default: html)"
 	c.flag [:f, :format]
+	c.desc "Auto-regenerate output on file changes"
+	c.switch :auto
 	c.action do |global_options, options, args|
-		Glyph.run 'load:config'
+		raise ArgumentError, "Too many arguments" if args.length > 2
+		Glyph.lite_mode = true unless args.blank? 
+		Glyph.run! 'load:config'
+		original_config = Glyph::CONFIG.dup
 		output_targets = Glyph::CONFIG.get('document.output_targets')
 		target = nil
-		Glyph.config_override('document.output', options[:f]) if options[:f]
-		target = cfg('document.output')
+		Glyph['document.output'] = options[:f] if options[:f]
+		target = Glyph['document.output']
 		target = nil if target.blank?
-		target ||= cfg('filters.target')
-		Glyph.config_override('document.source', options[:s]) if options[:s]
+		target ||= Glyph['filters.target']
+		Glyph['document.source'] = options[:s] if options[:s]
 		raise ArgumentError, "Output target not specified" unless target
 		raise ArgumentError, "Unknown output target '#{target}'" unless output_targets.include? target.to_sym
-		Glyph.run "generate:#{target}"
+
+		# Lite mode
+		if Glyph.lite? then
+			source_file  = Pathname.new args[0]
+			filename = source_file.basename(source_file.extname).to_s
+			destination_file = Pathname.new(args[1]) rescue nil
+			src_extension = Regexp.escape(source_file.extname) 
+			dst_extension = ".#{Glyph['document.output']}"
+			destination_file ||= Pathname.new(source_file.to_s.gsub(/#{src_extension}$/, dst_extension))
+			raise ArgumentError, "Source file '#{source_file}' does not exist" unless source_file.exist? 
+			raise ArgumentError, "Source and destination file are the same" if source_file.to_s == destination_file.to_s
+			Glyph['document.filename'] = filename
+			Glyph['document.source'] = source_file.to_s
+			Glyph['document.output_dir'] = destination_file.parent.to_s # System use only
+			Glyph['document.output_file'] = destination_file.basename.to_s # System use only
+		end
+		begin
+			Glyph.run "generate:#{target}"
+		rescue Exception => e
+			message = e.message
+			if Glyph.debug? then
+				message << "\n"+"-"*20+"[ Backtrace: ]"+"-"*20
+				message << "\n"+e.backtrace.join("\n")
+				message << "\n"+"-"*54
+			end
+			raise RuntimeError, message if Glyph.library?
+			Glyph.error message
+		end
+
+		# Auto-regeneration
+		if options[:auto] && !Glyph.lite? then
+			Glyph.lite_mode = false
+			begin
+				require 'directory_watcher'
+			rescue LoadError
+				raise RuntimeError, "DirectoryWatcher is not available. Install it with: gem install directory_watcher"
+			end
+			Glyph.info 'Auto-regeneration enabled'
+			Glyph.info 'Use ^C to interrupt'
+			glob = ['*.glyph', 'config.yml', 'images/**/*', 'lib/**/*', 'snippets.yml', 'styles/**/*', 'text/**/*']
+			dw = DirectoryWatcher.new(Glyph::PROJECT, :glob => glob, :interval => 1, :pre_load => true)
+			dw.add_observer do |*args|
+				puts "="*50
+				Glyph.info "Regeneration started: #{args.size} files changed"
+				Glyph.reset
+				begin
+					Glyph.run! "generate:#{target}"
+				rescue Exception => e
+					Glyph.error e.message
+					if Glyph.debug? then
+						puts "-"*20+"[ Backtrace: ]"+"-"*20
+						puts e.backtrace
+						pits "-"*54
+					end
+				end
+			end
+			dw.start
+			begin
+				sleep
+			rescue Interrupt
+			end
+			dw.stop
+		end
 	end
 end
 
@@ -46,13 +114,13 @@ GLI.desc 'Display all project TODO items'
 command :todo do |c|
 	c.action do |global_options, options, args|
 		Glyph.run "generate:document"
-		unless Glyph::TODOS.blank?
-			info "*** TODOs: ***"
-			Glyph::TODOS.each do |t|
-				info t
+		unless Glyph.document.todos.blank?
+			Glyph.info "*** TODOs: ***"
+			Glyph.document.todos.each do |t|
+				Glyph.info t
 			end
 		else
-			info "Nothing left to do."
+			Glyph.info "Nothing left to do."
 		end
 	end
 end
@@ -65,20 +133,27 @@ command :config do |c|
 	c.action do |global_options,options,args|
 		Glyph.run 'load:config'
 		if options[:g] then
-			cfg = Glyph::GLOBAL_CONFIG
+			config = Glyph::GLOBAL_CONFIG
 		else
-			cfg = Glyph::PROJECT_CONFIG
+			config = Glyph::PROJECT_CONFIG
 		end
 		case args.length
 		when 0 then
 			raise ArgumentError, "Too few arguments."
 		when 1 then # read current config
-			setting = cfg(args[0])
+			setting = Glyph[args[0]]
 			raise RuntimeError, "Unknown setting '#{args[0]}'" if setting.blank?
-			info Glyph::CONFIG.get(args[0])
+			Glyph.info setting
 		when 2 then
-			cfg.set args[0], args[1]
-			Glyph.reset_config
+			# Remove all overrides
+			Glyph.config_reset
+			# Reload current project config
+			config.read 
+			config.set args[0], args[1]
+			# Write changes to file
+			config.write
+			# Refresh configuration
+			Glyph.config_refresh
 		else
 			raise ArgumentError, "Too many arguments."
 		end
@@ -90,7 +165,7 @@ pre do |global,command,options,args|
 	# Return true to proceed; false to abourt and not call the
 	# chosen command
 	if global[:d] then
-		Glyph::DEBUG = true
+		Glyph.debug_mode = true
 	end
 	if !command || command.name == :help then
 		puts "====================================="
@@ -105,17 +180,17 @@ post do |global,command,options,args|
 end
 
 on_error do |exception|
-	if exception.is_a? MacroError then
-		#warning exception.message
-		puts exception.message
+	if exception.is_a? Glyph::MacroError then
+		Glyph.warning exception.message
 		false
 	else
-		if Glyph.const_defined? :DEBUG then
+		if Glyph.debug? then
 			puts "Exception: #{exception.message}"
 			puts "Backtrace:"
 			exception.backtrace.each do |b|
 				puts b
 			end
+			Glyph.debug_mode = false
 		end
 		true
 	end

data/lib/glyph/document.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Glyph
 
 	# The Glyph::Document class stores information about a document or a chunk of text
@@ -16,19 +18,20 @@ module Glyph
 			['\\|', '|']
 		]
 
-		attr_reader :bookmarks, :placeholders, :headers, :context
+		attr_reader :bookmarks, :placeholders, :headers, :context, :errors, :todos
 
 		# Creates a new document
 		# @param [GlyphSyntaxNode] tree the syntax tree to be evaluate
 		# @param [Glyph::Node] context the context associated with the tree
 		# @raise [RuntimeError] unless tree responds to :evaluate
 		def initialize(tree, context)
-			raise RuntimeError, "Document contains syntax errors." unless tree.respond_to? :evaluate
 			@tree = tree
 			@context = context
 			@bookmarks = {}
 			@placeholders = {}
 			@headers = []
+			@errors = []
+			@todos = []
 			@state = :new
 		end
 
@@ -40,11 +43,12 @@ module Glyph
 			@tree.data
 		end
 
-		# Copies bookmarks, headers and placeholders from another Glyph::Document
+		# Copies bookmarks, headers, todos and placeholders from another Glyph::Document
 		# @param [Glyph::Document] document a valid Glyph::Document
 		def inherit_from(document)
 			@bookmarks = document.bookmarks
 			@headers = document.headers
+			@todos = document.todos
 			@placeholders = document.placeholders
 		end
 
@@ -101,18 +105,20 @@ module Glyph
 
 		# Finalizes the document by evaluating its @placeholders
 		# @return [:finalized]
-		# @raise [RuntimeError] unless the document the document is analyzed or
-		# 	if it is already finalized
+		# @raise [RuntimeError] if the document the document has not been analyzed,
+		# 	if it is already finalized or if errors occurred during analysis
 		def finalize
 			raise RuntimeError, "Document has not been analyzed" unless analyzed?
 			raise RuntimeError, "Document has already been finalized" if finalized?
-			return (@state = :finalized) if @context[:analyze_only]
+			return (@state = :finalized) if @context[:embedded]
+			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
-					warning e.message
+					Glyph.warning e.message
 				end
 			end
 			@state = :finalized

data/lib/glyph/glyph_language.rb

@@ -49,6 +49,7 @@ module GlyphLanguage
     r0
   end
 
+	# @private
   module EscapingMacro0
     def macro_name
       elements[0]
@@ -96,7 +97,7 @@ module GlyphLanguage
       end
     end
     if s0.last
-      r0 = instantiate_node(MacroNode,input, i0...index, s0)
+      r0 = instantiate_node(EscapingMacroNode,input, i0...index, s0)
       r0.extend(EscapingMacro0)
     else
       @index = i0
@@ -108,6 +109,7 @@ module GlyphLanguage
     r0
   end
 
+	# @private
   module Macro0
     def macro_name
       elements[0]
@@ -167,9 +169,11 @@ module GlyphLanguage
     r0
   end
 
+	# @private
   module EscapedText0
   end
 
+	# @private
   module EscapedText1
     def macro_name
       elements[0]
@@ -177,6 +181,7 @@ module GlyphLanguage
 
   end
 
+	# @private
   module EscapedText2
   end
 
@@ -345,9 +350,11 @@ module GlyphLanguage
     r0
   end
 
+	# @private
   module Text0
   end
 
+	# @private
   module Text1
     def macro_name
       elements[0]
@@ -355,6 +362,7 @@ module GlyphLanguage
 
   end
 
+	# @private
   module Text2
   end
 

data/lib/glyph/glyph_language.treetop

@@ -5,7 +5,7 @@ grammar GlyphLanguage
 	end	
 
 	rule escaping_macro
-		macro_name '[=' text '=]' <MacroNode> 
+		macro_name '[=' text '=]' <EscapingMacroNode> 
 	end
 
 	rule macro

data/lib/glyph/interpreter.rb

@@ -6,27 +6,29 @@ class GlyphSyntaxNode < Treetop::Runtime::SyntaxNode
 	def evaluate(context, current=nil)
 		current ||= context.to_node
 		@data ||= current.to_node
-		value = elements.map { |e| e.evaluate(context, current) if e.respond_to? :evaluate }.join 
-		value
+		elements.map { |e| e.evaluate(context, current) if e.respond_to? :evaluate }.join 
 	end
 
-end 
+end
 
 # @private
 class MacroNode < GlyphSyntaxNode
 
-	def evaluate(context, current=nil)
+	def evaluate(context, current)
 		name = macro_name.text_value.to_sym
-		raise RuntimeError, "Undefined macro '#{name}'" unless Glyph::MACROS.include? name
+		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
-		value = super(context, @data).strip 
-		@data[:value] = value
+		@data[:value] = super(context, @data).strip
 		Glyph::Macro.new(@data).execute
 	end
 
 end
 
+# @private
+class EscapingMacroNode < MacroNode; end
+
 # @private
 class TextNode < GlyphSyntaxNode	
 
@@ -45,14 +47,22 @@ module Glyph
 	# * 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 => '--'}
-			@parser = GlyphLanguageParser.new
-			@raw = @parser.parse text
+			@raw = PARSER.parse text
 			@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]
 		end

data/lib/glyph/macro.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Glyph
 
 	# A Macro object is instantiated by a Glyph::Interpreter whenever a macro is found in the parsed text.
@@ -5,6 +7,8 @@ module Glyph
 	# useful methods to be used in macro definitions.
 	class Macro
 
+		include Validators
+
 		# Creates a new macro instance from a Node
 		# @param [Node] node a node populated with macro data
 		def initialize(node)
@@ -12,26 +16,97 @@ module Glyph
 			@name = @node[:macro]
 			@value = @node[:value]
 			@source = @node[:source]
-			esc = '‡‡‡‡‡ESCAPED¤PIPE‡‡‡‡‡'
-			@params = @value.gsub(/\\\|/, esc).split('|').map{|p| p.strip.gsub esc, '|'}
+			@escaped_pipe = '‡‡‡‡‡ESCAPED¤PIPE‡‡‡‡‡'
+		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, "\\|"}
+		end
+
+		# Parses the macro parameters (without stripping values)
+		# @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, "\\|"}
+		end
+
+		# Returns the "path" to the macro within the syntax tree.
+		# @return [String] the macro path
+		def path
+			macros = []
+			@node.ascend {|n| macros << n[:macro].to_s if n[:macro] }
+			macros.reverse.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
+		def macro_todo(message)
+			draft = Glyph['document.draft']
+			Glyph['document.draft'] = true unless draft
+			res = interpret "![#{message}]"
+			Glyph['document.draft'] = false unless draft
+			res
+		end
+
+		# Raises a macro error (preventing document post-processing)
+		# @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
 		end
 
 		# Raises a macro error
 		# @param [String] msg the message to print
-		# @raise [MacroError]
-		def macro_error(msg)
-			raise MacroError.new @node, msg
+		# @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?
 		end
 
 		# Instantiates a Glyph::Interpreter and interprets a string
 		# @param [String] string the string to interpret
 		# @return [String] the interpreted output
-		# @raise [MacroError] in case of mutual macro inclusion (snippet, include macros)
+		# @raise [Glyph::MacroError] in case of mutual macro inclusion (snippet, include macros)
 		def interpret(string)
-			@node[:source] = "#{@name}: #{@value}"
-			@node[:analyze_only] = true
-			macro_error "Mutual inclusion" if @node.find_parent {|n| n[:source] == @node[:source] }
-			Glyph::Interpreter.new(string, @node).document.output
+			@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
+			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 }
 		end
 
 		# @see Glyph::Document#placeholder
@@ -61,7 +136,9 @@ module Glyph
 
 		# Executes a macro definition in the context of self
 		def execute
-			instance_exec(@node, &Glyph::MACROS[@name]).to_s
+			res = instance_exec(@node, &Glyph::MACROS[@name]).to_s
+			res.gsub!(/\\*([\[\]\|])/){"\\#$1"} 
+			res
 		end
 
 	end