glyph 0.1.0

data/lib/glyph/glyph_language.treetop

@@ -0,0 +1,27 @@
+grammar GlyphLanguage
+
+	rule expression
+		(escaping_macro / macro / escaped_text)* <GlyphSyntaxNode> 
+	end	
+
+	rule escaping_macro
+		macro_name '[=' text '=]' <MacroNode> 
+	end
+
+	rule macro
+		macro_name '[' expression ']' <MacroNode> 
+	end
+
+	rule escaped_text
+		(('\\' .) / !((macro_name ('[' / '[=')) / (']' / '=]')) .)+  <TextNode> 
+	end
+
+	rule text
+		(('\\' .) / !((macro_name '[=') / '=]') .)+ <TextNode> 	
+	end
+
+	rule macro_name
+		[^\[\]\|\\\s]+
+	end
+
+end

data/lib/glyph/interpreter.rb

@@ -0,0 +1,84 @@
+# @private
+class GlyphSyntaxNode < Treetop::Runtime::SyntaxNode 
+
+	attr_reader :data
+
+	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
+	end
+
+end 
+
+# @private
+class MacroNode < GlyphSyntaxNode
+
+	def evaluate(context, current=nil)
+		name = macro_name.text_value.to_sym
+		raise RuntimeError, "Undefined macro '#{name}'" unless Glyph::MACROS.include? name
+		@data = {:macro => name, :source => context[:source], :document => context[:document]}.to_node
+		current << @data
+		value = super(context, @data).strip 
+		@data[:value] = value
+		Glyph::Macro.new(@data).execute
+	end
+
+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
+
+		# 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
+			@context = context
+			@document = Glyph::Document.new @raw, @context
+			@document.inherit_from @context[:document] if @context[:document]
+		end
+
+		# @see Glyph::Document#analyze
+		def process
+			@document.analyze
+		end
+
+		# @see Glyph::Document#finalize
+		def postprocess
+			@document.finalize
+		end
+
+		# Returns the finalized @document (calls self#process and self#postprocess if necessary)
+		# @return [Glyph::Document] the finalized document
+		def document
+			return @document if @document.finalized?
+			process if @document.new?
+			postprocess if @document.analyzed?
+			@document
+		end
+
+	
+	end
+
+end
+
+

data/lib/glyph/macro.rb

@@ -0,0 +1,69 @@
+module Glyph
+
+	# A Macro object is instantiated by a Glyph::Interpreter whenever a macro is found in the parsed text.
+	# The Macro class contains shortcut methods to access the current node and document, as well as other
+	# useful methods to be used in macro definitions.
+	class Macro
+
+		# 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]
+			esc = '‡‡‡‡‡ESCAPED¤PIPE‡‡‡‡‡'
+			@params = @value.gsub(/\\\|/, esc).split('|').map{|p| p.strip.gsub esc, '|'}
+		end
+
+		# Raises a macro error
+		# @param [String] msg the message to print
+		# @raise [MacroError]
+		def macro_error(msg)
+			raise MacroError.new @node, msg
+		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)
+		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
+		end
+
+		# @see Glyph::Document#placeholder
+		def placeholder(&block)
+			@node[:document].placeholder &block
+		end			
+
+		# @see Glyph::Document#bookmark
+		def bookmark(hash)
+			@node[:document].bookmark hash
+		end
+
+		# @see Glyph::Document#bookmark?
+		def bookmark?(ident)
+			@node[:document].bookmark? ident
+		end
+
+		# @see Glyph::Document#header?
+		def header?(ident)
+			@node[:document].header? ident
+		end
+
+		# @see Glyph::Document#header
+		def header(hash)
+			@node[:document].header hash
+		end
+
+		# Executes a macro definition in the context of self
+		def execute
+			instance_exec(@node, &Glyph::MACROS[@name]).to_s
+		end
+
+	end
+
+end

data/lib/glyph/node.rb

@@ -0,0 +1,126 @@
+class Hash
+
+	# Converts self to a Node
+	# @return [Node] the converted Node
+	def to_node
+		Node.new.replace self
+	end
+
+end
+
+
+# A Node is a Hash with an array of children and a parent associated to it.
+class Node < Hash
+
+	attr_reader :children
+	attr_accessor :parent
+
+	# Creates a new Node
+	def initialize(*args)
+		super(*args)
+		@children = []
+	end
+
+	# @return [Node] Returns self
+	def to_node
+		self
+	end
+
+	# Clone another node (replaces all keys, parent and children)
+	# @param [#to_node] node the Node to clone
+	# @return [self]
+	def from(node)
+		n = node.to_node
+		replace node
+		@parent = n.parent
+		@children = n.children
+		self
+	end
+
+	# Clears all keys, parent and children
+	def clear
+		super
+		@children.clear
+		@parent = nil
+	end
+
+	# Adds a child node to self
+	# @param [Hash] hash the new child
+	# @return [Array] the node's children
+	# @raise [ArgumentError] unless a Hash is passed as parameter
+	def <<(hash)
+		raise ArgumentError, "#{hash} is not a Hash" unless hash.is_a? Hash
+		ht = hash.to_node
+		ht.parent = self
+		@children << ht
+	end
+
+	# Returns a child by its index
+	# @return [Node] the child node or nil
+	# @param [Integer] index the child index
+	def child(index)
+		@children[index]
+	end
+
+	alias >> child 
+
+	# Iterates through children
+	# @yieldparam [Node] c the child node
+	def each_child
+		@children.each {|c| yield c }
+	end
+
+
+	# Iterates through children recursively (including self)
+	# @param [Node, nil] element the node to process
+	# @yieldparam [Integer] level the initial tree depth
+	# @yieldparam [Node] element the current node
+	# @yieldparam [Integer] level the current tree depth
+	def descend(element=nil, level=0, &block)
+		element ||= self
+		yield element, level
+		element.each_child do |c| 
+			descend c, level+1, &block 
+		end
+	end
+
+	# Descend children until the block returns something. 
+	# 	Each child is passed to the block.
+	# @param [Proc] &block the block to call on each child
+	# @return [Node, nil] returns the child node if found, nil otherwise
+	def find_child(&block)
+		children.each do |c|
+			c.descend do |node, level|
+				return node if block.call(node)
+			end
+		end
+		nil
+	end
+
+	# Ascend parents until the block returns something. 
+	# 	Each parent is passed to the block.
+	# @param [Proc] &block the block to call on each parent
+	# @return [Node, nil] returns the parent node if found, nil otherwise
+	def find_parent(&block)
+		return nil unless parent
+		parent.ascend do |node|
+			return node if block.call(node)
+		end
+		nil
+	end
+
+	# Iterates through parents recursively (including self)
+	# @param [Node, nil] element the node to process
+	# @yieldparam [Node] element the current node
+	def ascend(element=nil, &block)
+		element ||= self
+		yield element
+		ascend(element.parent, &block) if element.parent
+	end
+
+	# @return [Node] Returns the root node
+	def root
+		ascend(parent) {|e| return e unless e.parent }
+	end
+
+end

data/lib/glyph/system_extensions.rb

@@ -0,0 +1,77 @@
+module Kernel
+
+	# Prints a message
+	# @param [#to_s] message the message to print
+	def info(message)
+		puts "#{message}" unless cfg :quiet
+	end
+
+	# Prints a warning
+	# @param [#to_s] message the message to print
+	def warning(message)
+		puts "warning: #{message}" unless cfg :quiet
+	end
+
+	# @see Glyph::Config#get
+	def cfg(setting)
+		Glyph::CONFIG.get(setting)
+	end
+
+	# Dumps and serialize an object to a YAML file
+	# @param [#to_s] file the file to write to
+	# @param [Object] obj the object to serialize
+	def yaml_dump(file, obj)
+		File.open(file.to_s, 'w+') {|f| f.write obj.to_yaml}
+	end
+
+	# Loads and deserialiaze the contents of a YAML file
+	# @param [#to_s] file the YAML file to load
+	# @return [Object] the contents of the YAML file, deserialized
+	def yaml_load(file)
+		YAML.load_file(file.to_s)
+	end
+
+	# Loads the contents of a file
+	# @param [#to_s] file the file to load
+	# @return [String] the contents of the file
+	def file_load(file)
+		result = ""
+		File.open(file.to_s, 'r') do |f|
+			while l = f.gets 
+				result << l
+			end
+		end
+		result
+	end
+
+	# Writes a string to a file
+	# @param [#to_s] file the file to write
+	# @param [String] contents the string to write
+	# @return [String] the string written to the file
+	def file_write(file, contents="")
+		File.open(file.to_s, 'w+') do |f|
+			f.print contents
+		end
+		contents
+	end
+
+	# An alias for FileUtils#cp
+	# @param [String] source the source file
+	# @param [String] dest the destination file or directory
+	# @param [Hash] options copy options
+	def file_copy(source, dest, options={})
+		FileUtils.cp source, dest, options
+	end
+
+end
+
+class MacroError < RuntimeError
+	attr_reader :node
+	def initialize(node, msg)
+		@node = node
+		source = @node[:source] || "--"
+		macros = []
+		@node.ascend {|n| macros << n[:macro].to_s if n[:macro] }
+		super("#{msg}\n -> source: #{source}\n -> path: #{macros.reverse.join('/')}")
+	end
+end

data/macros/common.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+
+macro :comment do
+	""
+end
+
+macro :todo do
+	todo = "[#{@source}] -- #{@value}"
+	Glyph::TODOS << todo unless Glyph::TODOS.include? todo
+	""
+end
+
+macro :snippet do
+	begin
+		ident = @params[0].to_sym
+		macro_error "Snippet '#{ident}' does not exist" unless Glyph::SNIPPETS.has_key? ident
+		interpret Glyph::SNIPPETS[ident]
+	rescue Exception => e
+		warning e.message
+		"[SNIPPET '#{@value}' NOT PROCESSED]"
+	end
+end
+
+macro :include do
+	begin
+		file = nil
+		(Glyph::PROJECT/"text").find do |f|
+			file = f if f.to_s.match /\/#{@value}$/
+		end	
+		macro_error "File '#{@value}' no found." unless file
+		contents = file_load file
+		if cfg("filters.by_file_extension") then
+			begin
+				ext = @value.match(/\.(.*)$/)[1]
+				macro_error "Filter macro '#{ext}' not found" unless Glyph::MACROS.include?(ext.to_sym)
+				contents = "#{ext}[#{contents}]"
+			rescue MacroError => e
+				warning e.message
+			end
+		end	
+		interpret contents
+	rescue MacroError => e
+		warning e
+		"[FILE '#{@value}' NOT FOUND]"
+	end
+end
+
+macro :ruby do
+	Kernel.instance_eval(@value)
+end
+
+macro :config do
+	cfg @value
+end
+
+macro :escape do
+	@value
+end
+
+macro_alias '--' => :comment
+macro_alias '&' => :snippet
+macro_alias '@' => :include
+macro_alias '%' => :ruby
+macro_alias '$' => :config
+macro_alias '.' => :escape