bai-maruku 0.5.9

data/Rakefile

@@ -0,0 +1,102 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+require 'lib/maruku/version'
+spec = Gem::Specification.new do |s|
+  s.name = 'maruku'
+  s.version = MaRuKu::Version
+  s.summary = "Maruku is a Markdown-superset interpreter written in Ruby."
+  s.description = %{Maruku is a Markdown interpreter in Ruby.
+	It features native export to HTML and PDF (via Latex). The
+	output is really beautiful!
+	}
+  s.files = Dir['lib/**/*.rb'] + Dir['lib/*.rb'] + 
+	Dir['docs/*.md'] +	Dir['docs/*.html'] +
+	Dir['tests/**/*.md'] +
+          Dir['bin/*'] + Dir['*.sh'] + ['Rakefile', 'maruku.gemspec']
+
+  s.bindir = 'bin'
+  s.executables = ['maruku','marutex']
+
+  s.require_path = 'lib'
+  s.autorequire = 'maruku'
+
+  s.add_dependency('syntax', '>= 1.0.0')
+
+  s.author = "Andrea Censi"
+  s.email = "andrea@rubyforge.org"
+  s.homepage = "http://maruku.rubyforge.org"
+end
+
+task :default => [:package]
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+PKG_NAME = 'maruku'
+PKG_FILE_NAME = "#{PKG_NAME}-#{MaRuKu::Version}"
+RUBY_FORGE_PROJECT = PKG_NAME
+RUBY_FORGE_USER = 'andrea'
+
+RELEASE_NAME  = MaRuKu::Version
+RUBY_FORGE_GROUPID = '2795'
+RUBY_FORGE_PACKAGEID = '3292'
+
+desc "Publish the release files to RubyForge."
+task :release => [:gem, :package] do
+	system("rubyforge login --username #{RUBY_FORGE_USER}")
+
+	gem = "pkg/#{PKG_FILE_NAME}.gem"
+	# -n notes/#{Maruku::Version}.txt
+	cmd = "rubyforge  add_release %s %s \"%s\" %s" %
+		[RUBY_FORGE_GROUPID, RUBY_FORGE_PACKAGEID, RELEASE_NAME, gem]
+	
+	puts cmd
+	system(cmd)
+	
+	files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+	files.each do |file|
+#		system("rubyforge add_file %s %s %s %s" %
+#		[RUBY_FORGE_GROUPID, RUBY_FORGE_PACKAGEID, RELEASE_NAME, file])
+  end
+end
+
+task :test => [:markdown_span_tests, :markdown_block_tests]
+
+task :markdown_block_tests do
+	tests = Dir['tests/unittest/**/*.md'].join(' ')
+	puts "Executing tests #{tests}"
+#	ok = marutest(tests)
+	ok = system "ruby -Ilib bin/marutest #{tests}"
+	raise "Failed block unittest" if not ok
+end
+
+task :markdown_span_tests do
+	ok = system( "ruby -Ilib lib/maruku/tests/new_parser.rb v b")
+	raise "Failed span unittest" if not ok
+end
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+	files = [#'README', 'LICENSE', 'COPYING', 
+		'lib/**/*.rb', 
+		'rdoc/*.rdoc'#, 'test/*.rb'
+	]
+	rdoc.rdoc_files.add(files)
+	rdoc.main = "rdoc/main.rdoc" # page to start on
+	rdoc.title = "Maruku Documentation"
+	rdoc.template = "jamis.rb"
+	rdoc.rdoc_dir = 'doc' # rdoc output folder
+	rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+desc "Generate a gemspec file for GitHub"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/bin/marudown

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'maruku'
+
+	# If we are given filenames, convert each file 
+	if not ARGV.empty?
+		ARGV.each do |f|
+			puts "Opening #{f}"
+	
+			# read file content
+			input =  File.open(f,'r').read
+		
+			# create Maruku
+			doc = Maruku.new(input, {:on_error=>:warning})
+			# convert to a complete html document
+			output = doc.to_md
+	
+			# write to file
+			dir = File.dirname(f)
+			filename = File.basename(f, File.extname(f)) + ".txt"
+
+			output = File.join(dir, filename)	
+			File.open(output,'w') do |f| f.puts html end
+		end
+	else
+		# else, act as a filter
+		data = $stdin.read
+		puts Maruku.new(data, {:on_error=>:warning}).to_md
+	end

data/bin/maruku

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+require 'maruku'
+require 'optparse'
+
+
+def cli_puts(s)
+	$stderr.puts(s) if MaRuKu::Globals[:verbose]	
+end
+
+
+export = :html
+break_on_error = false
+using_math = false
+using_mathml = false
+output_file = nil
+
+opt = OptionParser.new do |opts|
+	opts.banner = "Usage: maruku [options] [file1.md [file2.md ..."
+
+	opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+		MaRuKu::Globals[:verbose] = v end
+	opts.on("-u", "--[no-]unsafe", "Use unsafe features") do |v|
+		MaRuKu::Globals[:unsafe_features] = v end
+
+	opts.on("-b", "Break on error") do |v|
+		break_on_error = true end
+
+
+	opts.on("-i", "--math-images ENGINE", "Uses ENGINE to render TeX to PNG.") do |s|
+		using_math = true
+		MaRuKu::Globals[:html_math_output_png] = true
+		MaRuKu::Globals[:html_math_output_mathml] = false
+		MaRuKu::Globals[:html_png_engine] = s
+		cli_puts "Using png engine #{s}."
+	end
+
+	opts.on("-m", "--math-engine ENGINE", "Uses ENGINE to render MathML") do |s|
+		MaRuKu::Globals[:html_math_output_png] = false
+		MaRuKu::Globals[:html_math_output_mathml] = true
+		using_math = true
+		using_mathml = true
+		MaRuKu::Globals[:html_math_engine] = s
+	end
+
+	opts.on("-o", "--output FILE", "Output filename") do |s|
+		output_file = s
+	end
+
+	opts.on_tail("--pdf",  "Write PDF","First writes LaTeX, then calls pdflatex." ) do export = :pdf  end
+	opts.on_tail("--s5", "Write S5 slideshow") do export = :s5 end
+	opts.on_tail("--html", "Write HTML") do export = :html end
+	opts.on_tail("--html-frag", "Write the contents of the BODY.") do export = :html_frag end
+	opts.on_tail("--tex",  "Write LaTeX" ) do export = :tex  end
+	opts.on_tail("--inspect",  "Shows the parsing result" ) do export = :inspect  end
+
+	opts.on_tail("--version", "Show version") do
+		puts "Maruku #{MaRuKu::Version}"; exit
+	end
+
+	opts.on_tail("--ext EXTENSIONS",  "Use maruku extensions (comma separated)" ) do |s|
+	  s.split(",").each do |e| require "maruku/ext/#{e}"; end
+	end
+
+	opts.on_tail("-h", "--help", "Show this message") do
+		puts opts
+		exit
+	end
+
+end
+
+begin 
+opt.parse!
+rescue OptionParser::InvalidOption=>e
+	$stderr.puts e
+	$stderr.puts opt
+	exit
+end
+
+
+if using_math
+	cli_puts "Using Math extensions."
+	require 'maruku/ext/math'
+end
+
+#p ARGV
+#p MaRuKu::Globals
+
+
+inputs =
+# If we are given filenames, convert each file 
+if not ARGV.empty?
+	ARGV.map do |f|
+		# read file content
+		cli_puts "Reading from file #{f.inspect}." 
+		[f, File.open(f,'r').read]
+	end
+else
+	export = :html_frag if export == :html
+	export = :tex_frag if export == :tex
+	
+	cli_puts  "Reading from standard input."
+	[[nil, $stdin.read]]
+end
+
+inputs.each do |f, input|
+	
+		# create Maruku
+		params = {}
+		params[:on_error] = break_on_error ? :raise : :warning
+
+		t = Time.now
+		doc = Maruku.new(input, params)
+
+		cli_puts ("Parsing in %.2f seconds." % (Time.now-t))
+
+		out=""; suffix = "?"
+		t = Time.now
+		case export
+		when :html 
+			suffix = using_mathml ? '.xhtml' : '.html'
+			out = doc.to_html_document( {:indent => -1})
+		when :html_frag 
+			suffix='.html_frag'
+			out = doc.to_html( {:indent => -1})
+		when :pdf, :tex
+			suffix='.tex'
+			out = doc.to_latex_document
+		when :tex_frag
+			suffix='.tex_frag'
+			out = doc.to_latex
+		when :inspect
+			suffix='.txt'
+			out = doc.inspect
+		when :markdown
+			suffix='.pretty_md'
+			out = doc.to_markdown
+		when :s5
+			suffix='_s5slides.html'
+			out = doc.to_s5({:content_only => false})
+		end
+
+		cli_puts("Rendering in %.2f seconds." % (Time.now-t))
+	
+		# write to file or stdout
+		if f
+			
+			if not output_file 
+				dir = File.dirname(f)
+				job = File.join(dir, File.basename(f, File.extname(f)))
+				output_file = job  + suffix
+			else
+				job = File.basename(output_file, File.extname(output_file))
+			end
+			
+			if output_file == "-"
+				cli_puts "Writing to standard output"
+				$stdout.puts out
+			else
+			
+				if not (export == :pdf)
+					cli_puts "Writing to #{output_file}"
+					File.open(output_file,'w') do |f| f.puts out end
+				else
+					cli_puts "Writing to #{job}.tex"
+					File.open("#{job}.tex",'w') do |f| f.puts out end
+					cmd = "pdflatex '#{job}.tex' -interaction=nonstopmode "+
+					      "'-output-directory=#{dir}' "
+					cli_puts "maruku: executing $ #{cmd}"
+					# run twice for cross references
+					system cmd 
+					system cmd
+				end
+			
+			end
+		else # write to stdout
+			cli_puts "Writing to standard output"
+			$stdout.puts out
+		end
+	end
+	

data/bin/marutest

@@ -0,0 +1,345 @@
+#!/usr/bin/env ruby
+
+require 'maruku'
+require 'maruku/textile2'
+
+$marutest_language = :markdown
+
+#MARKER = "\n***EOF***\n"
+SPLIT = %r{\n\*\*\*[^\*]+\*\*\*\n}m
+
+def marker(x)
+	"\n*** Output of #{x} ***\n"
+end
+
+def write_lines(i, j, lines, prefix, i_star)
+	i = [i, 0].max
+	j = [j, lines.size-1].min
+	for a in i..j
+		l = lines[a].gsub(/\t/,'  ')
+		puts( ("%s %3d" % [prefix, a]) + 
+			(a==i_star ? " -->" : "    ")+lines[a])
+	end
+end
+
+# a = expected   b = found 
+def equals(a, b)
+	a = a.split("\n")
+	b = b.split("\n")
+	
+	for i in 0..([a.size-1,b.size-1].max)
+		la = a[i]
+		lb = b[i]
+		if la != lb
+			puts "\n"
+			
+			
+			write_lines(i-3, i+3, a, "expected", i )
+			write_lines(i-3, i+3, b, "   found", i )
+			return false
+		end
+	end
+	return true
+end
+
+TOTEST = [:inspect,:to_html,:to_latex,:to_md,:to_s]
+
+def run_test(filename, its_ok, verbose=true)
+	# read file content
+	input =  (f=File.open(filename,'r')).read; f.close
+	
+	output_html = File.join(File.dirname(filename), 
+		File.basename(filename, File.extname(filename)) + ".html")	
+	
+	# split the input in sections
+	
+	stuff = input.split(SPLIT)
+	if stuff.size == 1
+		stuff[2] = stuff[0]
+		stuff[0] = "Write a comment here"
+		stuff[1] = "{} # params "
+	end
+
+	comment   = stuff.shift
+	params_s = stuff.shift
+	
+	params = eval(params_s||'{}')
+	if params == nil
+		raise "Null params? #{params_s.inspect}"
+	end
+	
+	markdown  = stuff.shift
+
+#	puts "comment: #{markdown.inspect}"	
+#	puts "markdown: #{markdown.inspect}"
+	
+	failed = []
+	relaxed = []
+	crashed = []
+	actual = {}
+	
+	doc = 
+		if $marutest_language == :markdown
+			Maruku.new(markdown, params)
+		else
+			MaRuKu.textile2(markdown, params)
+		end
+
+	for s in TOTEST
+		begin
+			if s==:to_html
+				actual[s] = doc.to_html
+			else
+				actual[s] = doc.send s
+				raise "Methods #{s} gave nil" if not actual[s]
+			end
+		rescue Exception => e
+			crashed << s
+			actual[s] = e.inspect+ "\n"+ e.backtrace.join("\n")
+			puts actual[s]
+		end
+	end
+
+	File.open(output_html, 'w') do |f|
+		f.write doc.to_html_document
+	end
+
+		begin
+			m = Maruku.new
+			d = m.instance_eval(actual[:inspect])
+		rescue Exception => e
+			s = e.inspect + e.backtrace.join("\n")
+			raise "Inspect is not correct:\n ========\n#{actual[:inspect]}"+
+			"============\n #{s}"
+		end
+
+	expected = {}
+	if (stuff.size < TOTEST.size)
+		$stdout.write " (first time!) "
+		TOTEST.each do |x| expected[x] = actual[x] end
+	else
+		TOTEST.each_index do |i|
+			symbol = TOTEST[i]
+			expected[symbol] = stuff[i]
+#			puts "symbol: #{symbol.inspect} = #{stuff[i].inspect}"
+		end
+	end
+
+	m = Maruku.new
+	
+	
+	if not its_ok.include? :inspect
+		begin
+			d = m.instance_eval(expected[:inspect])
+	#		puts "Eval: #{d.inspect}"
+			expected[:inspect] = d.inspect
+		rescue Exception => e
+			s = e.inspect + e.backtrace.join("\n")
+			raise "Cannot eval user-provided string:\n #{expected[:inspect].to_s}"+
+			"\n #{s}"
+		end
+	end
+
+#	 m.instance_eval(actual[:inspect]) != m.instance_eval(expected[:inspect])	
+
+#	actual[:inspect] = m.instance_eval(actual[:inspect]) 
+#	expected[:inspect] =  m.instance_eval(expected[:inspect])
+
+
+	TOTEST.each do |x|
+		expected[x].strip!
+		actual[x].strip!
+		if not equals(expected[x], actual[x])
+			if its_ok.include? x
+				expected[x] = actual[x]
+				$stdout.write " relax:#{x} "
+				relaxed << x
+			else
+				actual[x] = "-----| WARNING | -----\n" + actual[x].to_s
+				failed << x
+			end
+		end
+	end
+	
+	f = File.open(filename, 'w')
+	
+	f.write comment
+	f.write "\n*** Parameters: ***\n"
+	f.write params_s
+	f.write "\n*** Markdown input: ***\n"
+	f.write markdown
+
+	TOTEST.each do |x|
+		f.write marker(x) 
+		f.write expected[x]
+	end
+	f.write "\n*** EOF ***\n"
+	
+	if not failed.empty? or not crashed.empty? 
+		
+		f.puts "\n\n\n\nFailed tests:   #{failed.inspect} \n" 
+	
+		TOTEST.each do |x|
+			f.write marker(x) 
+			f.write actual[x]
+		end
+
+	else
+		f.puts "\n\n\n\tOK!\n\n\n"
+	end
+
+	
+	if false
+		md_pl = markdown_pl(markdown)
+		
+		f.write "\n*** Output of Markdown.pl ***\n" 
+		f.write md_pl
+	
+		f.write "\n*** Output of Markdown.pl (parsed) ***\n"
+		begin 
+			doc = REXML::Document.new("<div>#{md_pl}</div>",{
+				:compress_whitespace=>['div','p'],
+				:ignore_whitespace_nodes=>['div','p'],
+				:respect_whitespace=>['pre','code']
+			})
+			div = doc.root
+			xml =""
+			div.write_children(xml,indent=1,transitive=true,ie_hack=false)
+			f.write xml
+		rescue Exception=>e
+			f.puts "Error: #{e.inspect}"
+		end
+		f.close
+	else
+		f.write "\n*** Output of Markdown.pl ***\n" 
+		f.write "(not used anymore)"
+	
+		f.write "\n*** Output of Markdown.pl (parsed) ***\n"
+		f.write "(not used anymore)"		
+	end
+	
+	return failed, relaxed, crashed
+end
+
+def markdown_pl(markdown)
+	tmp1 = "/tmp/marutest1"
+	tmp2 = "/tmp/marutest2"
+	File.open(tmp1,'w') do |f| f.puts markdown end
+	system "Markdown.pl < #{tmp1} > #{tmp2}"
+	f = File.open(tmp2,'r')
+	s = f.read
+	f.close
+	s
+end
+
+def passed?(args, arg)
+	if args.include? arg
+		args.delete arg
+		true
+	else
+		false
+	end
+end
+
+def marutest(args)
+	dont_worry = []
+	TOTEST.each do |x|
+		arg = "ok:#{x}"
+	#	puts arg
+		if passed?(args, arg)
+			dont_worry << x
+		end
+	end
+	
+	if passed?(args, 'ok')
+		dont_worry = TOTEST.clone
+	end
+	
+	if dont_worry.size > 0
+		puts "Relaxed on #{dont_worry.inspect}"
+	end
+	
+
+	failed = {}
+	relaxed = {}
+	
+	args.each do |f|
+		$stdout.write  f + ' '*(50-f.size) + " "
+		$stdout.flush
+		tf, tr, tcrashed = run_test(f, dont_worry)
+		
+		tf = tf + tcrashed
+
+		
+		if tr.size > 0
+			$stdout.write " relax #{tr.inspect} "
+		end
+		
+		if tf.size>0
+			$stdout.write " failed on #{tf.inspect} "
+		else
+			$stdout.write " OK "
+		end
+
+		if tcrashed.size > 0
+			$stdout.write "    CRASHED on #{tcrashed.inspect}"
+		end
+
+			$stdout.write "\n"		
+			
+		failed[f]  = tf
+		relaxed[f]  = tr	
+	end
+	
+	num_failed = 0
+	failed_cat = {}
+
+	puts "\n\n\n**** FINAL REPORT ****\n\n"
+
+	
+	if failed.size > 0
+		failed.each do |file, fl|
+			num_failed += fl.size
+			if fl.size > 0
+				puts "\t#{file}\tfailed on #{fl.inspect}"
+			end
+			fl.each do |x|
+				failed_cat[x] = failed_cat[x] || 0
+				failed_cat[x] = failed_cat[x]  + 1
+			end
+		end
+	end
+
+	if dont_worry.size > 0
+		puts "Relaxed on #{dont_worry.inspect}"
+	end
+
+	if relaxed.size > 0
+		relaxed.each do |file, r|
+			if r.size > 0
+				puts "\t#{file}\t\trelaxed on #{r.inspect}"
+			end
+		end
+	end
+	
+	if failed_cat.size > 0
+		puts "\nCategories:\n"
+	
+		failed_cat.each do |x, num|
+			puts "\t#{x.inspect} \tfailed #{num}/#{args.size}"
+		end
+	end
+	
+	return num_failed == 0
+end
+
+if File.basename(__FILE__) == 'marutest'
+	if ARGV.empty?
+		puts "marutest is a tool for running Maruku's unittest."
+		exit 1
+	end
+	ok = marutest(ARGV.clone)
+	
+	exit ok ? 0 : -1 
+end
+