extract-curves 0.1.1

data/ruby_libs/pav/attr_cache.t1.rb

@@ -0,0 +1,32 @@
+require 'pav/attr_cache'
+
+class C
+	include AttrCache
+	
+	def f(x)
+		x
+	end
+	
+	cache_attr! :f
+end
+
+a = C.new
+b = C.new
+p a.f("a")
+p b.f("b")
+c = C.new
+d = C.new
+p c.f("c")
+p a.f(1)
+p b.f(2)
+p c.f(3)
+p d.uncache_attr!(:f)
+a.uncache_attr!(:f)
+p a.f(0)
+p a.f(1)
+p a.cache_attr!(:f)
+p a.f(2)
+p a.f(3)
+p a.kill_attr_cache!(:f)
+p a.f(4)
+p a.f(5)

data/ruby_libs/pav/cache.rb

@@ -0,0 +1,31 @@
+#begin
+  require 'pav/pav'
+#rescue LoadError
+
+require 'weakref'
+
+class PCache
+	attr_reader :tbl, :args
+	
+	def initialize(*args)
+		@args = args
+		#@tbl = WeakRef.new(Hash.new(*@args))
+	end
+	
+	def method_missing(id, *args)
+		return @args[0]
+		gc_dis = GC.disable
+		unless @tbl.weakref_alive?
+			@tbl = WeakRef.new(Hash.new(*@args))
+		end
+		begin
+			res = @tbl.send(id, *args)
+		rescue WeakRef::RefError
+			res = @args[0]
+		end
+		GC.enable unless gc_dis
+		res
+	end
+end
+
+#end # require 'pav/pav'

data/ruby_libs/pav/collection/std.rb

@@ -0,0 +1,58 @@
+# Ensure Collection < Map < | Array
+#                           | Hash
+
+module Collection
+end
+
+module Map # (key, value) pairs
+	include Collection
+end
+
+module PCollEnumerable
+	def detect_value
+		self.each_value { |val|
+			if (res = yield(val))
+				return val
+			end
+		}
+		nil
+	end
+	
+	def detect_key
+		self.each_key { |key|
+			if (res = yield(key))
+				return key
+			end
+		}
+		nil
+	end
+	
+	alias_method :find_value, :detect_value
+	alias_method :find_key, :detect_key
+end
+
+class Array
+	include Map
+	include PCollEnumerable
+	
+	def each_key_value
+		self.each_with_index { |lm, i| yield(i, lm) }
+	end
+	
+	def keys_to_a
+		(0...self.length).to_a
+	end
+	
+	alias_method :each_value, :each
+	alias_method :each_key, :each_index
+	alias_method :delete_key, :delete_at
+end
+
+class Hash
+	include Map
+	include PCollEnumerable
+	
+	alias_method :each_key_value, :each_pair
+	alias_method :delete_key, :delete
+	alias_method :keys_to_a, :keys
+end

data/ruby_libs/pav/dbg_log.rb

@@ -0,0 +1,458 @@
+require 'logger'
+
+class PLogProgrBar
+	attr_reader :pdbglog, :progr_units, :total_progr_units, :show_as,
+		:fmt_str
+	
+	def initialize(pdbglog)
+		@pdbglog = pdbglog
+		@total_progr_units = nil
+		@progr_units = 0
+		@show_as = "%"
+	end
+	
+	def incr(progr_units=1)
+		@progr_units += progr_units
+		self.disp_progr(progr_units)
+	end
+	
+	def progr_units=(val)
+		change = val - @progr_units
+		@progr_units = val
+		self.disp_progr(change)
+	end
+	
+	def total_progr_units=(val)
+		@total_progr_units = val
+		@fmt_str = val > 0 ? "%.#{[Math.log10(val).ceil - 2, 0].max}f" :
+			"%f"
+	end
+	
+	def show_as=(spec)
+		if !["%", "/"].include?(spec[0,1])
+			raise ArgumentError, "spec start with \"%\" or \"/\""
+		end
+		@show_as = spec
+	end
+	
+	def finish
+	end
+end
+
+class PLogTextProgrBar < PLogProgrBar
+	ROT_LN_CHARS = ["-", "\\", "|", "/"]
+	BUBBLE_CHARS = [".", "o", "0", "O", "0", "o"]
+	attr_reader :progr_char_i, :bs_len
+	attr_accessor :progr_rot_chars, :progr_mark, :neg_progr_rot_chars,
+		:neg_progr_mark
+	
+	def initialize(pdbglog)
+		super(pdbglog)
+		@progr_char_i = 0
+		@progr_rot_chars = ROT_LN_CHARS
+		@neg_progr_rot_chars = BUBBLE_CHARS
+		@progr_mark = "."
+		@neg_progr_mark = "!"
+		@bs_len = 0
+	end
+	
+	def undisp_progr
+		self.pdbglog.print_progr(self.pdbglog.backspc * @bs_len, 2)
+		@bs_len = 0
+	end
+	
+	def disp_progr(progr_units_change)
+		if self.total_progr_units
+			if self.pdbglog.outp.tty? && self.pdbglog.had_progr
+				str = self.pdbglog.backspc * @bs_len
+			elsif self.pdbglog.had_progr
+				str = " "
+			else
+				str = ""
+			end
+			if self.show_as[0,1] == "%"
+				pct =  self.fmt_str % (100.0*self.progr_units /
+					self.total_progr_units)
+			else
+				pct = "#{self.progr_units}/#{
+					self.total_progr_units}"
+			end
+			pct += self.show_as[1, self.show_as.length-1]
+			@bs_len = pct.length
+			str += pct
+		elsif self.show_as == "%"
+			if progr_units_change > 0
+				chars = @progr_rot_chars; mark = @progr_mark
+			elsif progr_units_change < 0
+				chars = @neg_progr_rot_chars
+				mark = @neg_progr_mark
+			end
+			if self.pdbglog.outp.tty?
+				new_char_i = (@progr_char_i+progr_units_change)%
+					chars.length
+				if new_char_i == @progr_char_i
+					new_char_i = (new_char_i+1)%chars.length
+				end
+				if self.pdbglog.had_progr
+					str = self.pdbglog.backspc * @bs_len
+				else
+					str = ""
+				end
+				str += chars[new_char_i] +
+					self.show_as[1, self.show_as.length-1]
+				@progr_char_i = new_char_i
+				@bs_len = chars[new_char_i].length +
+					self.show_as.length-1
+			else
+				str = ""
+				str += mark*(progr_units_change/mark.length) +
+					mark[0, progr_units_change%mark.length]+
+					self.show_as[1, self.show_as.length-1]
+			end
+		else
+			if self.pdbglog.outp.tty? && self.pdbglog.had_progr
+				str = self.pdbglog.backspc * @bs_len
+			else
+				str = ""
+			end
+			pct = "#{self.progr_units}" +
+				self.show_as[1, self.show_as.length-1]
+			@bs_len = pct.length
+			str += pct
+		end
+		self.pdbglog.print_progr(str, 2)
+	end
+end
+
+class PDbgLog
+	PARSE_BT_PAT = Regexp.compile(
+		/^([^:]*):([0-9]*)(?:[:]in `([a-zA-Z0-9_!?=]*)'|)/)
+	
+	def self.parse_bt_lm(str)
+		m = PARSE_BT_PAT.match(str)
+		m ? m[1, m.length-1] : []
+	end
+	
+	attr_reader :outp, :indent, :trace, :had_lf, :traced_call_levs
+	attr_accessor :outp_ln_num, :msg_indent, :func_indent, :logger_severity,
+		:auto_lf, :class_pfx, :fmt_indent, :indent_omit_levs_cnt,
+		:fmt_func_pfx, :backspc, :progr_class, :progr_init_args,
+		:had_progr, :auto_had_progr
+	
+	def outp=(outp_spec)
+		if outp_spec.kind_of?(String)
+			@outp = open(outp_spec, "w")
+		else
+			@outp = outp_spec
+		end
+	end
+	
+	def initialize(outp_spec=$stderr, fmt_indent_func=nil, &fmt_func_pfx)
+		self.outp = outp_spec
+		if fmt_indent_func
+			@fmt_indent = fmt_indent_func
+		else
+			@fmt_indent = proc { |stack_lev|
+				if stack_lev < @indent_omit_levs_cnt
+					""
+				elsif stack_lev - @indent_omit_levs_cnt < 5
+					(@func_indent + @msg_indent) * 
+					  (stack_lev - @indent_omit_levs_cnt)
+				else
+					"  >lev %3d-- " % stack_lev
+				end
+			}
+		end
+		if block_given?
+			@fmt_func_pfx = fmt_func_pfx
+		else
+			@fmt_func_pfx = proc { |bt_lm, first_entry|
+				file, ln, meth = *PDbgLog.parse_bt_lm(bt_lm)
+				meth = "<unknown/main>" unless meth
+				if @outp_ln_num && ln
+					@class_pfx + meth + ":#{ln}: "
+				else
+					@class_pfx + meth + ": "
+				end
+			}
+		end
+		@outp_ln_num = outp_ln_num
+		@trace = false
+		@indent = true
+		@msg_indent = " "
+		@func_indent = "  "
+		@indent_omit_levs_cnt = 0
+		@call_lev = 0
+		@traced_call_levs = [nil]
+		@bt_skip_levs_stack = [[nil, 1], [nil, 1]]
+		@logger_severity = Logger::DEBUG
+		@msg = ""
+		@auto_lf = true
+		@had_lf = true
+		@class_pfx = ""
+		@class_pfx_stack = [""]
+		ObjectSpace.define_finalizer(self) {
+			self.print(@msg[-1,1]=="\n" ? "":"\n") if @msg.length>0
+		}
+		@reentry = false
+		@backspc = "\b"
+		@progr_levs = [[nil, nil]]
+		@had_progr = false
+		@auto_had_progr = true
+		@progr_class = PLogTextProgrBar
+		@progr_init_args = []
+	end
+	
+	def install_tracer
+		  set_trace_func(proc{|event, file, line, id, binding, klass, *|
+			if event == "call"
+				obj = ObjectSpace._id2ref(id)
+				@class_pfx = klass + (obj.kind_of?(Class) ||
+					obj.kind_of?(Module) ? "#" : ".")
+				if @bt_skip_levs_stack.last[1] != 1 ||
+				@bt_skip_levs_stack[-2][1] != 1
+					@bt_skip_levs_stack.push([@call_lev, 1])
+				end
+				@call_lev += 1
+			elsif event == "return"
+				obj = ObjectSpace._id2ref(id)
+				@class_pfx = klass + (obj.kind_of?(Class) ||
+					obj.kind_of?(Module) ? "#" : ".")
+				if @call_lev == @traced_call_levs.last
+					@traced_call_levs.pop
+					if @auto_lf && !@had_lf
+						@msg += "\n"; @had_lf = true
+					end
+					@reentry = true
+				end
+				if @bt_skip_levs_stack.last[0] == @call_lev
+					@bt_skip_levs_stack.pop
+				end
+				self.finish_progr
+				@call_lev -= 1
+			end
+		  })
+	end
+	
+	def indent=(flag)
+		return if flag == @indent
+		if flag
+			@call_lev = 0
+			self.install_tracer if @trace
+		else
+			set_trace_func(nil)
+		end
+		@indent = flag
+	end
+	
+	def trace=(flag)
+		return if flag == @trace
+		if flag
+			self.install_tracer if @indent
+		else
+			set_trace_func(nil)
+		end
+		@trace = flag
+	end
+	
+	def progr
+		@progr_levs.last[1]
+	end
+	
+	def write(str)
+		@msg += str
+		if @outp.kind_of?(IO)
+			@outp.write(@msg)
+			@had_lf = (@msg[-1,1] == "\n") if @msg.length > 0
+		elsif @outp.kind_of?(Logger)
+			@outp.add(@logger_severity, @msg)
+			@had_lf = true
+		end
+		@msg = ""
+	end
+	
+	def print(str)
+		@msg += str
+		if @outp.kind_of?(IO)
+			@outp.print(@msg)
+			@had_lf = (@msg[-1, 1] == "\n") if @msg.length > 0
+			@msg = ""
+		elsif @outp.kind_of?(Logger)
+			res_msg = ""
+			@had_lf = true
+			@msg.each_line { |ln|
+				if !ln[-1, 1] == "\n"
+					res_msg = ln
+					@had_lf = false
+					break
+				end
+				@outp.add(@logger_severity, ln.chop!)
+			}
+			@msg = res_msg
+		end
+	end
+	
+	def puts(str)
+		if @outp.kind_of?(IO)
+			@outp.puts(@msg + str)
+		elsif @outp.kind_of?(Logger)
+			(@msg + str + "\n").each_line { |ln|
+				@outp.add(@logger_severity, ln.chop!)
+			}
+		end
+		@msg = ""
+		@had_lf = true
+	end
+	
+	def mk_indent_str(call_bt_lm)
+		if @call_lev != @traced_call_levs.last
+			@traced_call_levs.push(@call_lev)
+			if @indent
+				@class_pfx = @class_pfx_stack.last unless @trace
+				@class_pfx = "" unless @class_pfx
+				indent_str = @fmt_indent.call(
+					@traced_call_levs.length - 1) +
+					@fmt_func_pfx.call(call_bt_lm, true)
+			else
+				indent_str = ""
+			end
+			if @auto_lf && !@had_lf
+				@msg += "\n"; @had_lf = true
+			end
+		else
+			if @indent
+				indent_str = @fmt_indent.call(
+					@traced_call_levs.length - 1) +
+					@msg_indent
+				if @reentry
+					@class_pfx=@class_pfx_stack.last unless
+						@trace
+					@class_pfx = "" unless @class_pfx
+					indent_str += @fmt_func_pfx.call(
+						call_bt_lm, false)
+				end
+			else
+				indent_str = ""
+			end
+		end
+		@reentry = false
+		indent_str
+	end
+	
+	def print_msg(str)
+		str = str.to_s unless str.kind_of?(String)
+		indent_str=self.mk_indent_str(caller(
+			@bt_skip_levs_stack[-2][1])[0])
+		if indent_str.length > 0
+			if !@had_lf
+				ind = ""
+				str.each_line { |ln| self.print(ind + ln)
+					ind = indent_str }
+			else
+				str.each_line {|ln| self.print(indent_str + ln)}
+			end
+		else
+			self.print(str)
+		end
+		@had_progr = false if @auto_had_progr
+	end
+	
+	def puts_msg(str)
+		str = str.to_s unless str.kind_of?(String)
+		indent_str=self.mk_indent_str(caller(
+			@bt_skip_levs_stack[-2][1])[0])
+		if indent_str.length > 0
+			if !@had_lf
+				ind = ""
+				(str + "\n").each_line { |ln|
+				 	self.print(ind + ln); ind = indent_str }
+			else
+				(str + "\n").each_line { |ln|
+					self.print(indent_str + ln) }
+			end
+		else
+			self.puts(str)
+		end
+		@had_progr = false if @auto_had_progr
+	end
+	
+	def print_progr(str, extra_bt_levs=1)
+		str = str.to_s unless str.kind_of?(String)
+		indent_str=self.mk_indent_str(caller(
+			@bt_skip_levs_stack[-2][1] + extra_bt_levs)[0])
+		if indent_str.length > 0
+			if !@had_lf
+				ind = ""
+				str.each_line { |ln| self.print(ind + ln)
+					ind = indent_str }
+			else
+				str.each_line {|ln| self.print(indent_str + ln)}
+			end
+		else
+			self.print(str)
+		end
+		@had_progr = true if @auto_had_progr
+	end
+	
+	def sig_wrapped_call
+		@bt_skip_levs_stack.last[1] += 1
+	end
+	
+	def sig_wrapped_return
+		@bt_skip_levs_stack.last[1] -= 1 if
+			@bt_skip_levs_stack.last[1] > 1
+	end
+	
+	def sig_call(class_pfx="")
+		return if @trace && @indent
+		if class_pfx.kind_of?(String)
+			@class_pfx = class_pfx
+		elsif class_pfx.kind_of?(Class) || class_pfx.kind_of?(Module)
+			@class_pfx = class_pfx.name + "#"
+		else
+			@class_pfx = class_pfx.class.name + "."
+		end
+		@class_pfx_stack.push(@class_pfx)
+		@call_lev += 1
+		if @bt_skip_levs_stack.last[1] != 1 ||
+		@bt_skip_levs_stack[-2][1] != 1
+			@bt_skip_levs_stack.push([@call_lev, 1])
+		end
+	end
+	
+	def sig_return(msg="")
+		if (msg = msg.to_s).length > 0
+			@bt_skip_levs_stack[-2][1] += 1
+			self.print_msg(msg)
+			@bt_skip_levs_stack[-2][1] -= 1
+		end
+		return if @trace && @indent
+		if @call_lev == @traced_call_levs.last
+			@traced_call_levs.pop
+			if @auto_lf && !@had_lf
+				@msg += "\n"; @had_lf = true
+			end
+			@reentry = true
+		end
+		if @bt_skip_levs_stack.last[0] == @call_lev
+			@bt_skip_levs_stack.pop
+		end
+		self.finish_progr 
+		@class_pfx_stack.pop
+		@call_lev -= 1
+	end
+	
+	def new_progr
+		@progr_levs.push([@call_lev,
+			@progr_class.new(*[self].concat(@progr_init_args))])
+	end
+	
+	def finish_progr
+		if @call_lev == @progr_levs.last[0]
+			@progr_levs.pop[1].finish
+			@had_progr = false if @auto_had_progr
+		end
+	end
+end
+
+$PDbgLog = PDbgLog.new