glyph 0.2.0 → 0.3.0

data/macros/xml.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+macro "|xml|" do
+	begin
+		valid_xml_element
+		max_parameters 1
+	rescue Exception => e
+		if @node[:fallback] then
+			macro_error "Unknown macro '#{@node[:element]}'"
+		else
+			raise
+		end
+	end
+	name = @node[:element]
+ 	if name.to_s.in? Glyph['language.options.xml_blacklist'] then
+		""
+	else
+		attributes # evaluate attributes
+		xml_attributes = @node.children.select{|node| node.is_a?(Glyph::AttributeNode)}.
+			map do |e| 
+			if valid_xml_attribute(e[:name]) then
+				%|#{e[:name]}="#{e[:value]}"|
+			else
+				nil
+			end
+			end.compact.join(" ")
+			xml_attributes = " "+xml_attributes unless xml_attributes.blank?
+			end_first_tag = param(0) ? ">" : ""
+			end_tag = param(0) ? "</#{name}>" : " />"
+			contents = (@node.param(0)&0) && (@node.param(0)&0)[:element] ? "\n#{param(0)}\n" : param(0)
+			%{<#{name}#{xml_attributes}#{end_first_tag}#{contents}#{end_tag}}
+	end
+end

data/spec/files/container.textile

@@ -1,5 +1,5 @@
 section[
-header[Container section]
+	@title[Container section]
 This is a test.
-@[included.textile]
+	include[a/b/c/included.textile]
 ]

data/spec/files/document.glyph

@@ -1,2 +1,2 @@
-@[container.textile]
-@[markdown.markdown]
+include[container.textile]
+include[a/b/c/markdown.markdown]

data/spec/files/document_with_toc.glyph

@@ -1,3 +1,3 @@
-toc[]
-@[container.textile]
-@[markdown.markdown]
+toc[1]
+include[container.textile]
+include[a/b/c/markdown.markdown]

data/spec/files/included.textile

@@ -1,4 +1,4 @@
 section[
-header[Test Section]
+@title[Test Section]
 ...
 ]

data/spec/files/markdown.markdown

@@ -1,5 +1,6 @@
 section[
-	header[Markdown|md]
+	@title[Markdown]
+	@id[md]
 This contains markdown text.
 
 - item 1

data/spec/lib/commands_spec.rb

@@ -9,7 +9,7 @@ describe "glyph" do
 	end
 
 	after do
-		Glyph.lite_mode = false
+		reset_quiet
 		delete_project
 	end
 
@@ -45,6 +45,13 @@ describe "glyph" do
 		(Glyph::SPEC_DIR/'.glyphrc').unlink
 	end
 
+	it "[config] should not overwrite system settings" do
+		create_project
+		Glyph['system.test_setting'] = false
+		run_command(["config", "system.test_setting", true]).match(/warning.+\(system use only\)/m).should_not == nil
+		Glyph['system.test_setting'].should == false
+	end
+
 	it "[add] should create a new text file" do
 		create_project
 		run_command_successfully(["add", "test.textile"]).should == true
@@ -60,7 +67,7 @@ describe "glyph" do
 	it "[compile] should support a custom source file" do
 		create_project
 		file_copy Glyph::PROJECT/'document.glyph', Glyph::PROJECT/'custom.glyph'
-		run_command(["compile", "-s", "custom.glyph"]).match(/custom\.glyph/m).should_not == nil
+		run_command(["-d", "compile", "-s", "custom.glyph"]).match(/custom\.glyph/m).should_not == nil
 		(Glyph::PROJECT/'output/html/test_project.html').exist?.should == true
 	end
 
@@ -160,7 +167,7 @@ describe "glyph" do
 
 	it "[compile] should finalize the document in case of errors in included files" do
 		create_project
-		file_write Glyph::PROJECT/'document.glyph', "section[header[Test]\n@[errors.glyph]\n@[syntax_error.glyph]]"
+		file_write Glyph::PROJECT/'document.glyph', "section[@title[Test]\ninclude[errors.glyph]\ninclude[syntax_error.glyph]]"
 		file_write Glyph::PROJECT/'text/errors.glyph', "not[a|b]"
 		file_write Glyph::PROJECT/'text/syntax_error.glyph', "$[a"
 		err = "Document cannot be finalized due to previous errors"
@@ -175,4 +182,40 @@ describe "glyph" do
 		res.match("error: #{err}").should == nil
 	end
 
+	it "[outline] should display the document outline" do
+		create_project
+		start = %{=====================================
+test_project - Outline
+=====================================}
+		c_file = "=== container.textile"
+		i_file = "=== a/b/c/included.textile"
+		m_file = "=== a/b/c/markdown.markdown"
+		c_title = "- Container section "
+		i_title = "- Test Section "
+		m_title = "- Markdown "
+		c_id = "[#h_1]"
+		i_id = "[#h_2]"
+		m_id = "[#md]"
+		file_write Glyph::PROJECT/'document.glyph', "document[#{file_load(Glyph::PROJECT/'document.glyph')}]"
+		run_command(["outline"]).should == %{#{start}
+  #{c_title}
+    #{i_title}
+  #{m_title}
+}
+		reset_quiet
+		run_command(["outline", "-l", "1"]).should == %{#{start}
+  #{c_title}
+  #{m_title}
+}
+		reset_quiet
+		run_command(["outline", "-ift"]).should == %{#{start}
+#{c_file}
+  #{c_title}#{c_id}
+#{i_file}
+    #{i_title}#{i_id}
+#{m_file}
+  #{m_title}#{m_id}
+}
+	end
+
 end

data/spec/lib/document_spec.rb

@@ -7,7 +7,7 @@ describe Glyph::Document do
 
 	before do
 		Glyph.macro :test do |node|
-			"Test: #{node[:value]}"
+			"Test: #{value}"
 		end
 		create_tree = lambda {|text| }
 		create_doc = lambda {|tree| }
@@ -72,7 +72,7 @@ describe Glyph::Document do
 			n = placeholder do |document|
 				count = 0
 				document.structure.descend do |node, level|
-					count +=1 if node[:macro] == :test
+					count +=1 if node[:name] == :test
 				end
 				count
 			end
@@ -99,10 +99,10 @@ describe Glyph::Document do
 	it "should substitute escaped pipes only when finalizing the document" do
 		define_em_macro
 		define_ref_macro
-		text = %{em[ref[link with ref[fake \\| parameter]]]}
+		text = %{em[ref[link with ref[fake \\| parameter|.]|.]]}
 		# Nevermind the absurdity. It's just to test that the escaped pipes 
 		# are handled properly.
-		result = %{<em><a href="link with <a href="fake | parameter"></a>"></a></em>}
+		result = %{<em><a href="link with <a href="fake | parameter">.</a>">.</a></em>}
 		tree = create_tree text
 		doc = create_doc tree
 		doc.analyze

data/spec/lib/glyph_spec.rb

@@ -7,6 +7,10 @@ describe Glyph do
 		Glyph.enable 'project:create'
 	end
 
+	after do
+		delete_project
+	end
+
 	it "should initialize a rake app and tasks" do
 		Rake.application.tasks.length.should > 0
 	end
@@ -31,66 +35,22 @@ describe Glyph do
 
 	it "should support macro aliases" do
 		define_ref_macro
+		define_em_macro
 		lambda { Glyph.macro_alias("->" => :ref)}.should_not raise_error
 		Glyph::MACROS[:"->"].should == Glyph::MACROS[:ref]
 		Glyph.macro_alias :em => :ref
 		Glyph::MACROS[:em].should_not == Glyph::MACROS[:ref]
 	end
 
-	it "should provide a set of default macros and aliases" do
-		delete_project
-		create_project
-		Glyph.run! 'load:macros'
-		macros = [:anchor, :link, :codeph, :fmi, :note, :box, :code, :title, :subtitle,
-		:img, :fig, :author, :pubdate, :table, :td, :tr, :th, :comment, :todo, :snippet, "snippet:",
-		:include, :config, "config:", :ruby, :escape, :textile, :markdown, :div, :header, :document, :body,
-		:head, :style, :toc, :section, :condition, :eq, :and, :or, :not, :match, :highlight, "macro:", 
-		:encode, :decode, :draftcomment]
-		aliases = [	
-			[[:bookmark, "#"], :anchor],
-			[["=>"], :link],
-			[[:important, :caution, :tip], :note],
-			[["@"], :include],
-			[["&"], :snippet],
-			[["&:"], "snippet:"],
-			[["%:"], "macro:"],
-			[["?"], "condition"],
-			[["$"], :config],
-			[["$:"], "config:"],
-			[["%"], :ruby],
-			[["."], :escape],
-			[["--"], :comment],
-			[[:dc], :draftcomment],
-			[["!"], :todo],
-			[["*"], :encode],
-			[["**"], :decode],
-			[[:md], :markdown],
-			[[:frontcover, :titlepage, :halftitlepage, :frontmatter, :bodymatter, :backmatter, :backcover], :div]]
-		total = 0
-		macros.each { |v| total+=1; Glyph::MACROS[v.to_sym].should_not == nil }
-		check_aliases = lambda do |arr, target|
-			arr.each {|v| total += 1; Glyph::MACROS[v.to_sym].should == Glyph::MACROS[target.to_sym]}
-		end
-		aliases.each { |v| check_aliases.call v[0], v[1] }
-		check_aliases.call Glyph['structure.frontmatter'], :div
-		check_aliases.call Glyph['structure.bodymatter'], :div
-		check_aliases.call Glyph['structure.backmatter'], :div
-		Glyph['structure.frontmatter'].length.should == 8
-		Glyph['structure.bodymatter'].length.should == 4
-		Glyph['structure.backmatter'].length.should == 13
-		#puts Glyph::MACROS.keys.map{|i| i.to_s}.sort.to_yaml
-		total.should == Glyph::MACROS.length
-	end
-
 	it "should provide a filter method to convert raw text into HTML" do
 		Glyph['document.title'] = "Test"
 		Glyph.filter("title[]").gsub(/\n|\t/, '').should == "<h1>Test</h1>"
 	end
 
 	it "should provide a compile method to compile files in lite mode" do
+		reset_quiet
 		file_copy Glyph::PROJECT/'../files/article.glyph', Glyph::PROJECT/'article.glyph'
 		lambda { Glyph.compile Glyph::PROJECT/'article.glyph' }.should_not raise_error
-		reset_quiet
 		(Glyph::PROJECT/'article.html').exist?.should == true
 	end
 
@@ -102,4 +62,15 @@ describe Glyph do
 		Glyph['test_setting'].should == nil
 	end
 
+	it "should not allow certain macros to be expanded in safe mode" do
+		create_project
+		Glyph.run! "load:all"
+		Glyph.safe_mode = true
+		lambda { output_for("include[test.glyph]")}.should raise_error Glyph::MacroError
+		lambda {output_for("config:[test|true]")}.should raise_error Glyph::MacroError
+		lambda { output_for("ruby[Time.now]")}.should raise_error Glyph::MacroError
+		lambda { output_for("rw:[a|section[{{0}}]]")}.should raise_error Glyph::MacroError
+		Glyph.safe_mode = false
+	end
+
 end

data/spec/lib/interpreter_spec.rb

@@ -11,17 +11,16 @@ describe Glyph::Interpreter do
 
 
 	after do
+		reset_quiet
 		delete_project
 	end
 
 	it "should process text and run simple macros" do
 		define_em_macro
 		text = "This is a em[test]. It em[should] work."
-		interpret text
-		@p.document.output.should == "This is a <em>test</em>. It <em>should</em> work."
+		output_for(text).should == "This is a <em>test</em>. It <em>should</em> work."
 		text2 = "This is pointless, but valid: em[]. This em[will] though."
-		interpret text2
-		@p.document.output.should == "This is pointless, but valid: <em></em>. This <em>will</em> though."
+		output_for(text2).should == "This is pointless, but valid: <em></em>. This <em>will</em> though."
 	end
 
 	it "should process and run complex macros" do
@@ -62,35 +61,17 @@ describe Glyph::Interpreter do
 	it "should store syntax node information in context" do
 		define_em_macro
 		define_ref_macro
-		count = 0
 		Glyph.macro :test_node do |node|
-			node.ascend do |n| 
-				count+=1
-			end
-			node.parent[:macro]
+			node.parent_macro[:name]
 		end
 		text = %{Test em[test_node[em[test_node[---]]]].}
 		interpret text
 		@p.document.output.should == "Test <em>em</em>."
-		count.should == 8
 	end
 
-	it "should process document.glyph" do
-		interpret file_load(Glyph::PROJECT/'document.glyph')
-		macros = []
-		@p.document.structure.descend do |n, level|
-			macros << {n[:macro] => level} if n[:macro]
-		end
-		macros.should == [{:"@" => 1},{:textile => 2},{:section => 3}, {:header => 4}, 
-			{:"@" => 4}, {:textile => 5}, {:section => 6}, {:header => 7}, 
-			{:"@" => 1}, {:markdown => 2},{:section => 3}, {:header => 4}]
-	end
-
-
 	it "should provide diagnostic information on errors" do
-		failure = "Incorrect macro syntax\n -> -- [Line 1, Column 13]"
-		# This is probably the only type of error recognized which can occur at parser level
-		lambda { interpret "section[em[]" }.should raise_error(Glyph::SyntaxError, failure)
+		failure = "-- [1, 12] Macro 'section' not closed"
+		lambda { interpret("section[em[]").document }.should raise_error(Glyph::SyntaxError, failure)
 	end
 
 end

data/spec/lib/macro_spec.rb

@@ -5,14 +5,16 @@ describe Glyph::Macro do
 
 	before do
 		Glyph.macro :test do
-			"Test: #{@value}"
+			"Test: #{value}"
 		end
 		create_tree = lambda {|text| }
 		create_doc = lambda {|tree| }
 		@text = "test[section[header[Test!|test]]]"
 		@tree = create_tree @text 
 		@doc = create_doc @tree
-		@node = {:macro => :test, :value => "Testing...", :source => "--", :document => @doc}.to_node
+		@node = Glyph::MacroNode.new.from({:name => :test, :source => {:name => "--"}, :document => @doc})
+		@node << Glyph::ParameterNode.new.from({:name => :"0"})
+		(@node&0) << Glyph::TextNode.new.from({:value => "Testing..."})
 		@macro = Glyph::Macro.new @node
 	end
 
@@ -26,10 +28,10 @@ describe Glyph::Macro do
 
 	it "should not interpret escaped macros" do
 		Glyph.macro :int_1 do
-			"->#{interpret(@value)}<-"
+			"->#{interpret(value)}<-"
 		end
 		Glyph.macro :int_2 do
-			"=>#{interpret(@value)}<="
+			"=>#{interpret(value)}<="
 		end
 		text1 = "int_1[int_2[Test]]"
 		text2 = "int_1[=int_2[Test]=]"
@@ -60,49 +62,145 @@ describe Glyph::Macro do
 		@doc.placeholders.length.should == 1
 	end
 
-	it "should execute" do
-		@macro.execute.should == "Test: Testing..."
+	it "should expand" do
+		@macro.expand.should == "Test: Testing..."
 	end
 
-	it "should detect mutual inclusion" do
-		delete_project
-		create_project
-		Glyph.run! 'load:macros'
-		Glyph::SNIPPETS[:inc] = "Test &[inc]"
-		lambda {interpret("&[inc] test").document}.should raise_error(Glyph::MutualInclusionError)
+	it "should support rewriting" do
+		test = 0
+		Glyph.macro :test do
+			interpret "#{@node.value}-#{test+=1}"
+		end
+		Glyph.macro :release do
+			interpret "Release\n#{@node.value}"
+		end
+		Glyph.macro :features do
+			interpret "\n\ntest[Features: \n#{@node.value}]"
+		end
+		Glyph.macro :feature do
+			interpret "test[#{@node.value}]\n"
+		end
+		text = %{
+			release[
+				features[
+					feature[a]
+					feature[b]
+					feature[c]
+				]
+			]
+		}
+		output_for(text).gsub(/\n|\t/, '').should == 
+			"ReleaseFeatures: a-2b-3c-4-1"
+		test = 0
+		Glyph.macro :test do
+			interpret "#{value}-#{test+=1}"
+		end
+		Glyph.macro :release do
+			interpret "Release\n#{value}"
+		end
+		Glyph.macro :features do
+			interpret "\n\ntest[Features: \n#{value}]"
+		end
+		Glyph.macro :feature do
+			interpret "test[#{value}]\n"
+		end
+		output_for(text).gsub(/\n|\t/, '').should == 
+			"ReleaseFeatures: a-1b-2c-3-4"
+	end
+
+	it "should support access to parameters and attributes" do
+		Glyph.macro :test do
+			"test: #{value}"
+		end
+		Glyph.macro :test1 do
+			"test1: #{value}"
+		end
+		node = Glyph::Parser.new("test[@a[test1[...]]test1[...]|test1[---]]").parse
+		m = Glyph::Macro.new(node&0)
+		m.parameters.should == ["test1: ...", "test1: ---"]
+		m.attributes.should == {:a => "test1: ..."}
+		m.parameter(0).should == "test1: ..."
+		m.parameter(1).should == "test1: ---"
+		m.parameter(2).should == nil
+		m.attribute(:a).should == "test1: ..."
+		m.attribute(:b).should == nil
+	end
+
+	it "should not evaluate attributes unless specifically requested" do
+		define_em_macro
+		node = Glyph::Parser.new("par0[em[...]|em[---]]").parse
+		m = Glyph::Macro.new(node&0)
+		syntaxnode = lambda do |hash|
+			Glyph::SyntaxNode.new.from hash
+		end
+		p0 = p_node 0
+		p0 << macro_node(:em, :escape => false)
+		p00 = p_node 0
+		(p0&0) << p00
+		p00 << text_node("...")
+		p1 = p_node 1
+		p1 << macro_node(:em, :escape => false)
+		p10 = p_node 0
+		(p1&0) << p10
+		p10 << text_node("---")
+		m.node.parameters.should == [p0, p1]
+		m.node.parameters[0][:value].should == nil
+		m.node.parameters[1][:value].should == nil
+		m.parameter(0).should == "<em>...</em>"
+		m.node.parameters[0][:value].should == "<em>...</em>"
+		m.node.parameters[1][:value].should == nil
 	end
 
-	it "should encode and decode text" do
-		Glyph.run! "load:all"
-		Glyph.macro :sec_1 do
-			res = decode "section[header[Test1]\n#{@value}]"
-			interpret res
-		end
-		Glyph.macro :sec_2 do
-			encode "section[section[header[Test2]\n#@value]]"
-		end
-		text1 = %{sec_1[sec_2[Test]]}
-		interpret text1
-		res1 = @p.document.output.gsub(/\t/, '')
-		text2 = %{section[header[Test1]
-			section[section[header[Test2]
-			Test]]]}
-		interpret text2
-		res2 = @p.document.output.gsub(/\t/, '')
-		result = "<div class=\"section\">
-				<h2 id=\"h_1\">Test1</h2>
-				<div class=\"section\">
-					<div class=\"section\">
-						<h4 id=\"h_2\">Test2</h4>
-						Test
-
-					</div>
-
-				</div>
-
-			</div>".gsub(/\t/, '')
-		res1.should == result
-		res2.should == result
+	it "should not evaluate parameters unless specifically requested" do
+		define_em_macro
+		node = Glyph::Parser.new("par0[@a[em[...]]@b[em[---]]]").parse
+		m = Glyph::Macro.new(node&0)
+		syntaxnode = lambda do |hash|
+			Glyph::SyntaxNode.new.from hash
+		end
+		p0 = a_node :a, :escape => false
+		p0 << macro_node(:em, :escape => false)
+		p00 = p_node 0
+		(p0&0) << p00
+		p00 << text_node("...")
+		p1 = a_node :b, :escape => false
+		p1 << macro_node(:em, :escape => false)
+		p10 = p_node 0
+		(p1&0) << p10
+		p10 << text_node("---")
+		m.node.attributes.should == [p0, p1]
+		m.node.attribute(:a)[:value].should == nil
+		m.node.attribute(:b)[:value].should == nil
+		m.attribute(:a).should == "<em>...</em>"
+		m.node.attribute(:a)[:value].should == "<em>...</em>"
+		m.node.attribute(:b)[:value].should == nil
+	end
+
+	it "should expose a path method to determine its location" do
+		tree = Glyph::Parser.new(%{
+		test1[
+			a[...]|
+			b[
+				test2[@a[x[]]]
+			]
+		]}).parse
+		node = tree&1&1&1&0&1&0&0
+		m = Glyph::Macro.new(node)
+		m.path.should == "test1/1/b/test2/@a/x"
+	end
+
+	it "should substitute bracket escapes properly" do
+		define_em_macro
+		Glyph.macro :test_int do
+			interpret "- #{value} -"
+		end
+		text1 = %{em[test\\\\\.\\[...\\\\\.\\]]} # test\\\.\[\\\.\]
+		text2 = %{em[=test\\\\\\.[...\\\\\\.]=]}  # test\\\.[\\\.]
+		text3 = %{test_int[em[=test\\\\\.[...\\\\\.]=]]}
+		out = "<em>test\\[...\\]</em>"
+		output_for(text1).should == out
+		output_for(text2).should == out
+		output_for(text3).should == "- #{out} -"
 	end
 
 end