maruku 0.4.2.1 → 0.5.0

data/lib/maruku/ext/diagrams/inspect.rb

@@ -0,0 +1,11 @@
+module Diagrams
+	
+class Arrow
+	def inspect
+		"Arrow (#{(@cap1||?-).chr},#{(@cap2||?-).chr}) "+
+		"from #{@start_link.class} to #{@end_link.class} "+
+		" #{@start_pos.inspect} -> #{@end_pos.inspect}"
+	end
+end
+
+end

data/lib/maruku/ext/diagrams/layout.rb

@@ -0,0 +1,105 @@
+module Diagrams
+	
+	class Diagram
+		DIAG_TL = "tl"
+		DIAG_BR = "br"
+		
+		def do_layout(diag_id)
+			def margin_con() Spring.new(30,0,30,1,1000)   end
+			def arrow_con()  Spring.new(30,1,60,100,1000) end
+			def zero_con()   Spring.new(0,0,0,0,0)     end
+			def positive_con(pref)   Spring.new(0,1,pref,1000,1000)     end
+			
+			@diag_id = diag_id
+			assign_variables(diag_id)
+			
+			l = Layout.new
+			@boxes.each  do |b|
+				# size of the box is copied from b.hs and b.vs
+				l.add_con_h(b.v_tl, b.v_br, b.hs)
+				l.add_con_v(b.v_tl, b.v_br, b.vs)
+				# should not be outside of the diagram
+				l.add_con_h(DIAG_TL,  b.v_tl, margin_con)
+				l.add_con_h(b.v_br, DIAG_BR, margin_con)
+				l.add_con_v(DIAG_TL,  b.v_tl, margin_con)
+				l.add_con_v(b.v_br, DIAG_BR, margin_con)
+				# now, for each arrow 
+				b.links[:N].each{|a|
+					l.add_con_v(a.v_end, b.v_tl, zero_con)
+					l.add_con_h(b.v_tl, a.v_end, positive_con(b.hs.pref/2))
+					l.add_con_h(a.v_end, b.v_br, positive_con(b.hs.pref/2))
+				}
+				b.links[:S].each{|a|
+					l.add_con_v(b.v_br, a.v_start, zero_con)
+					l.add_con_h(b.v_tl, a.v_start, positive_con(b.hs.pref/2))
+					l.add_con_h(a.v_start, b.v_br, positive_con(b.hs.pref/2))
+				}
+				b.links[:W].each{|a|
+					l.add_con_h(a.v_end, b.v_tl, zero_con) 
+					l.add_con_v(b.v_tl, a.v_end, positive_con(b.vs.pref/2))
+					l.add_con_v(a.v_end, b.v_br, positive_con(b.vs.pref/2))
+				}
+				b.links[:E].each{|a|
+					l.add_con_h(b.v_br, a.v_start, zero_con)
+					l.add_con_v(b.v_tl, a.v_start, positive_con(b.vs.pref/2))
+					l.add_con_v(a.v_start, b.v_br, positive_con(b.vs.pref/2))
+				}
+				
+				b.aligned[:t].each do |b2| l.add_con_v(b2.v_tl, b.v_tl, zero_con) end
+				b.aligned[:b].each do |b2| l.add_con_v(b2.v_br, b.v_br, zero_con) end
+				b.aligned[:l].each do |b2| l.add_con_h(b2.v_tl, b.v_tl, zero_con) end
+				b.aligned[:r].each do |b2| l.add_con_h(b2.v_br, b.v_br, zero_con) end
+			end
+			
+			@points.each do |p|
+				# should not be outside of the diagram
+				l.add_con_h(DIAG_TL,  p.v_p, margin_con)
+				l.add_con_h(p.v_p, DIAG_BR, margin_con)
+				l.add_con_v(DIAG_TL,  p.v_p, margin_con)
+				l.add_con_v(p.v_p, DIAG_BR, margin_con)
+				# now, for each arrow 
+				p.links[:N].each{|a|
+					l.add_con_v(a.v_end, p.v_p, zero_con)
+						l.add_con_h(a.v_end, p.v_p, zero_con)
+				}
+				p.links[:S].each{|a|
+					l.add_con_v(p.v_p, a.v_start, zero_con)
+						l.add_con_h(p.v_p, a.v_start, zero_con)
+				}
+				p.links[:W].each{|a|
+					l.add_con_h(a.v_end, p.v_p, zero_con)
+						l.add_con_v(a.v_end, p.v_p, zero_con)
+				}
+				p.links[:E].each{|a|
+					l.add_con_h(p.v_p, a.v_start, zero_con)
+						l.add_con_v(p.v_p, a.v_start, zero_con)
+				}
+
+				p.aligned[:t].each do |p2| l.add_con_v(p2.v_p, p.v_p, zero_con) end
+				p.aligned[:l].each do |p2| l.add_con_h(p2.v_p, p.v_p, zero_con) end
+			end
+			
+			@arrows.each do |a|
+				if a.is_vert?
+					l.add_con_v(a.v_start, a.v_end, arrow_con)
+					l.add_con_h(a.v_start, a.v_end, zero_con)
+				else
+					l.add_con_h(a.v_start, a.v_end, arrow_con)
+					l.add_con_v(a.v_start, a.v_end, zero_con)
+				end
+			end
+
+			doth, dotv = l.to_dot
+			File.open("#{diag_id}_h.dot",'w') do |f| f.write doth end
+			File.open("#{diag_id}_v.dot",'w') do |f| f.write dotv end
+
+#			hs, vs = l.get_preferred(DIAG_TL, DIAG_BR)
+			
+#			puts "Preferred hs = #{hs.inspect}"
+#			puts "Preferred vs = #{vs.inspect}"
+		end
+		
+	end
+	
+	
+end

data/lib/maruku/ext/diagrams/parser.rb

@@ -0,0 +1,219 @@
+module Diagrams
+
+class Diagram
+	def create_grid_from_string(string)
+		lines = string.split("\n").map{|x| x.gsub(/\s*$/,'') }
+		
+		while lines.first && lines.first.strip.size == 0; lines.shift  end
+		while lines.last && lines.last.strip.size == 0; lines.pop  end
+		width = lines.map{|x| x.size}.max
+		height = lines.size
+
+		grid = Grid.new(width, height, 32)
+		for y in 0..height-1
+			for x in 0..width-1
+				grid.set(x, y, lines[y][x])
+			end
+		end	
+		grid
+	end
+
+	
+	def detect_points
+		[?+, ?*].each do |p|
+			for_each_to_process(p) do |x,y|
+				point = Point.new 
+				point.pos = [x, y]
+				point.char = p
+				@to_process.set(x,y,false)
+				@points.push point
+				@occup.set(x,y, point)
+			end
+		end	
+		
+		@points.each do |p1|
+			@points.each do |p2|
+				if p1 != p2
+					if p2.pos.x < p1.pos.x 
+						p1.aligned[:t].push(p2) if p2.pos.y == p1.pos.y
+					end
+					if p2.pos.y < p1.pos.y 
+						p1.aligned[:l].push(p2) if p2.pos.x == p1.pos.x
+					end
+				end
+			end
+		end
+	end
+
+	def detect_arrows
+		[	[?|, /^\|*$/, [?^, ?A], [?v, ?V],  0, 1, :S],
+			[?-, /^\-*$/, [?<], [?>],  1, 0, :E],
+			[?\\,/^\\*$/, [], [], 1, 1, :SE],
+			[?/, /^\/*$/, [], [], -1, 1, :SW] 
+		].each do |char, reg, cap1, cap2, inc_x, inc_y, ty|
+			for_each_to_process(char) do |x,y,e|
+				find_arrow(x, y, reg, cap1, cap2, inc_x, inc_y)
+			end
+		end
+	end
+	
+	
+	def find_arrow(x, y, reg, cap1, cap2, inc_x, inc_y)
+		inc = [inc_x, inc_y]
+		rinc = [-inc_x, -inc_y]
+		
+		a = Arrow.new
+		
+		if cap1.include?(c = @text.get(x-inc_x, y-inc_y))
+			a.cap1 = c
+			a.start_pos = [x-inc_x, y-inc_y]
+		else
+			a.cap1 = nil
+			a.start_pos = [x,y]
+		end
+		
+		s = match(x,y,reg,inc_x,inc_y)
+		len = s.size
+		
+		a.end_pos = [x+(len-1)*inc_x, y+(len-1)*inc_y]
+		maybe_cap = [x+(len)*inc_x, y+(len)*inc_y]
+		if cap2.include?(c=@text.get(*maybe_cap))
+			len +=1
+			a.end_pos = maybe_cap
+			a.cap2 = c	
+		else
+			a.cap2 = nil
+		end
+		
+		a.length = len
+		
+		before = [a.start_pos[0]-inc_x,a.start_pos[1]-inc_y]
+		if ob = @occup.get(*before)
+			impact = ob.link_direction(before, rinc)
+			ob.links[impact] << a
+			a.links[Reverse[impact]]<< ob
+			a.start_link = ob
+		else
+			puts "Nothing found at #{before.inspect} : #{
+			@text.get(*before)
+			} while #{@text.get(*a.start_pos).chr}"
+		end
+		after = [a.end_pos[0]+inc_x,a.end_pos[1]+inc_y]
+		if ob = @occup.get(*after)
+			impact = ob.link_direction(after, inc)
+			ob.links[impact] << a
+			a.links[Reverse[impact]] << ob
+			a.end_link = ob
+		else
+			puts "Nothing found at #{after.inspect} : #{
+			@text.get(*after)
+			} while #{@text.get(*a.end_pos).chr}"
+		end
+		
+		iterate(a.start_pos,a.end_pos) do |x,y|
+			@to_process.set(x,y,false)
+			@occup.set(x,y,a)
+		end
+		
+		@arrows.push a
+		p a
+	end
+	
+	def iterate(pos1,pos2)
+		inc_x = pos2[0]-pos1[0]
+		inc_y = pos2[1]-pos1[1]
+		len = [inc_x.abs,inc_y.abs].max + 1
+		if inc_x.abs > inc_y.abs
+			len = inc_x.abs + 1
+		else
+			len = inc_y.abs + 1
+		end
+		
+		inc_x  /= inc_x.abs if inc_x != 0
+		inc_y  /= inc_y.abs if inc_y != 0
+		
+#		raise "" if inc_x 
+		for i in 0..(len-1)
+			x, y = pos1[0]+i*inc_x,pos1[1]+i*inc_y
+			yield x,y
+		end
+	end
+	
+	def detect_boxes
+		for_each_to_process(?+) do |x,y,e|
+			find_box(x,y,/^\+[\-\+]+\+$/, /^\+[\|\+]+\+$/)
+		end
+		for_each_to_process(?/) do |x,y,e|
+			find_box(x,y,/^\/[\-\+]+\\$/, /^\/[\|\+]+\\$/)
+		end
+		
+		# find alignments
+		@boxes.each do |b1|
+			@boxes.each do |b2|
+				if b1 != b2
+					if (b2.y < b1.y)
+						b1.aligned[:l].push(b2) if (b1.x == b2.x)
+						b1.aligned[:r].push(b2) if (b1.x+b1.width == b2.x+b2.width)
+					end
+					if (b2.x < b1.x)
+						b1.aligned[:t].push(b2) if (b1.y == b2.y)
+						b1.aligned[:b].push(b2) if (b1.y+b1.height == b2.y+b2.height)
+					end
+				end
+			end
+		end
+	end
+	
+	def for_each_to_process(char) 
+		@text.each do |x,y,e|
+			if e === char && @to_process.get(x,y)
+				yield x, y, e
+			end
+		end
+	end
+	
+	def find_box(x,y,hmatch,vmatch)
+		horiz = match_horiz(x,y,hmatch)
+		vert  = match_vert(x,y,vmatch)
+		
+		return if not horiz or not vert
+		width, height = horiz.size, vert.size
+		if (width > 2) && (height > 2)
+			# mark the cell as processed
+			@to_process.set_area(x, y, horiz.size, vert.size, false)
+			box = Box.new(x,y,width,height)
+			box.content = @text.read_area(x+1,y+1,width-2,height-2)
+			box.content.gsub!(/\n/,' ')			
+			# mark the area as occupied by the box
+			@occup.set_area(x, y, horiz.size, vert.size, box)
+			@boxes.push box
+		end
+	end
+
+	def match(x,y,reg,inc_x,inc_y)
+		s = ""
+		best = nil
+		while x<@text.width && y < @text.height
+			s << @text.get(x,y).chr
+			break if not @to_process.get(x,y)
+			if s =~ reg
+				best = s.dup 
+			end
+			x += inc_x; y += inc_y
+		end
+		best
+	end
+	
+	def match_horiz(x,y,reg)
+		match(x,y,reg,1,0)
+	end
+	
+	def match_vert(x,y,reg)
+		match(x,y,reg,0,1)
+	end
+	
+	
+end
+
+
+end # moudle Diagram

data/lib/maruku/ext/diagrams/structures.rb

@@ -0,0 +1,168 @@
+class Array
+	def x() self[0] end
+	def y() self[1] end
+end
+
+module Diagrams	
+	
+class Spring
+	attr_accessor :min,:shrink,:pref,:stretch,:max
+	attr_accessor :weight  #not used yet		
+	attr_accessor :imposed
+	
+	def initialize(min,shrink,pref,stretch,max)
+		@min,@shrink,@pref,@stretch,@max = 
+		 min, shrink, pref, stretch, max
+	end
+	
+	def Spring.series(s1,s2)
+		Spring.new( 
+			s1.min+s2.min, 
+			s1.shrink+s2.shrink,
+			s1.pref+s2.pref,
+			s1.stretch+s2.stretch,
+			s1.max+s2.max
+			)
+	end
+	
+	def Spring.parallel(s1,s2)
+		pref = (s1.pref+s2.pref)*0.5
+		pref = [s1.min, pref].max
+		pref = [s1.max, pref].min
+		pref = [s2.min, pref].max
+		pref = [s2.max, pref].min
+		
+		Spring.new( 
+			[s1.min,s2.min].max, 
+			[s1.shrink,s2.shrink].min,
+			pref,
+			[s1.stretch,s2.stretch].min,
+			[s1.max,s2.max].min
+			)
+	end
+	
+	
+	def inspect
+		if @min == @max
+			"Fixed(#{@min})"
+		else
+			"S[%.1f(%.1f)%.1f(%.1f)%.1f]=%.1f" %
+			[ @min, @shrink, @pref, @stretch, @max, @imposed || -1]
+		end
+	end
+end
+
+Reverse = {:N=>:S,:S=>:N,:W=>:E,:E=>:W}
+
+class Sized
+	attr_accessor :hs, :vs # horizontal, vertical spring
+	attr_accessor :links #hash :N,:S,:W,:E
+	def initialize
+		@hs = Spring.new(1,0,1,0,1)
+		@vs = Spring.new(1,0,1,0,1)
+		@links = {:N=>[],:E=>[],:W=>[],:S=>[]}
+	end
+end
+
+class Arrow < Sized
+	attr_accessor :type # :S, :NW, :SE, :E
+	attr_accessor :cap1,:cap2 # either nil or the cap
+	attr_accessor :start_pos, :end_pos
+	attr_accessor :start_link, :end_link
+	attr_accessor :length
+	attr_accessor :object_start, :object_end
+
+
+	# variables for start and end
+	attr_accessor :v_start,:v_end
+	
+	def is_vert?
+		start_pos.x == end_pos.x
+	end
+	
+end
+
+
+class Box < Sized
+	attr_accessor :x,:y,:width,:height
+	attr_accessor :content
+
+	attr_accessor :aligned
+
+	# variables for top-left and bottom-right
+	attr_accessor :v_tl,:v_br
+
+	
+	def initialize(x,y,width,height)
+		super()
+		@x,@y,@width,@height = x,y,width,height
+		@aligned = {:l=>[],:t=>[],:b=>[],:r=>[]}
+	end
+
+	# pos: position touching this
+	# from: other
+	def link_direction(pos, inc)
+		if pos.x == @x then return :W end
+		if pos.x == @x+@width-1 then return :E end
+		if pos.y == @y then return :N end
+		if pos.y == @y+@height-1 then return :S end
+		raise "Strange #{pos.inspect}: "+self.inspect
+	end
+end
+
+class Point < Sized
+	attr_accessor :pos
+	attr_accessor :char
+
+	attr_accessor :aligned
+	
+	# variables for point position
+	attr_accessor :v_p
+	
+	def initialize
+		super()
+		@aligned = {:l=>[],:t=>[]}
+	end
+	
+	def link_direction(pos, inc)
+		if inc.x > 0 then return :W end
+		if inc.x < 0 then return :E end
+		if inc.y > 0 then return :N end
+		if inc.y < 0 then return :S end
+		raise "Strange #{inc.inspect}: "+self.inspect
+	end
+end
+
+
+class Diagram
+	attr_accessor :boxes, :points, :arrows
+	
+	attr_accessor :text, :occup, :to_process
+	
+	def initialize(s)
+		@text = create_grid_from_string(s)
+		@to_process = Grid.new(@text.width, @text.height, false)
+		@occup = Grid.new(@text.width, @text.height, nil)
+		@boxes = []
+		@points = []
+		@arrows = []
+		# mark cells to process
+		@text.each do |x,y,e| 
+			@to_process.set(x,y,true) if e != 32
+		end
+		@width, @height = @text.width,@text.height
+
+	#	p @to_process
+		
+		puts @text.inspect2(@to_process)
+		
+		detect_boxes
+		detect_points
+		detect_arrows
+
+		puts @text.inspect2(@to_process)
+	end
+end
+
+
+end