extract-curves 0.1.1-i586-linux

data/ruby_libs/pav/string/ext.rb

@@ -0,0 +1,58 @@
+class String
+	def starts_with(str)
+		self[0, str.length] == str
+	end
+	
+	def ends_with(str)
+		self[-str.length, str.length] == str
+	end
+	
+	def expand_tabs(tab_stop=8)
+		self.gsub(/([^\t]{#{tab_stop}})|([^\t]*)\t/n) {
+			[$+].pack("A#{tab_stop}") }
+	end
+	
+	def expand_tabs!(tab_stop=8)
+		self.gsub!(/([^\t]{#{tab_stop}})|([^\t]*)\t/n) {
+			[$+].pack("A#{tab_stop}") }
+	end
+	
+	def eval_backspace(bs="\b")
+		self.gsub(/([^#{bs}]*)(#{bs}+)/n) { $1[0, $1.length-$2.length] }
+	end
+	
+	def eval_backspace!(bs="\b")
+		self.gsub!(/([^#{bs}]*)(#{bs}+)/n){ $1[0, $1.length-$2.length] }
+	end
+	
+	def cap_first
+		return "" if self.length < 1
+		self[0,1].upcase + self[1, self.length-1]
+	end
+	
+	def downcase_first
+		return "" if self.length < 1
+		self[0,1].downcase + self[1, self.length-1]
+	end
+	
+	def ^(other)
+		res = self.dup
+		0.upto([self.length, other.length].min - 1) { |i|
+			res[i] ^= other[i]
+		}
+		res
+	end
+	
+	def xor!(mask_str)
+		0.upto([self.length, mask_str.length].min - 1) { |i|
+			self[i] ^= mask_str[i]
+		}
+		self
+	end
+	
+	def bits_to_i
+		res = 0
+		self.each_byte { |b| res = (res << 8) + b }
+		res
+	end
+end

data/ruby_libs/pav/string/observable.rb

@@ -0,0 +1,155 @@
+require 'observer'
+#require 'irb/frame'
+
+class PMethName
+
+# Is +name+ the name of a method that usually changes the object?
+def self.obj_changer?(name)
+	name[-1,1] == "!" ||
+	(name.length > 1 && name[-1,1] == "=" &&
+		!["=", ">", "<", "+", "-", "*", "/"].member?(name[-2,1])) ||
+	name == "<<"
+end
+
+end
+
+# If the only way to change a string is through the built-in string changing
+# functions, we don't need to be so dynamic.
+
+class String
+	include Observable
+	
+	alias_method :__add_observer_o__, :add_observer
+	
+	def wrap_changer_meth(id)
+		# if method wrapped in self's anonymous class:
+		if self.respond_to?("__pso_#{id.to_i}_o__")
+			return
+		end
+		eval <<-"end_eval"
+			class <<self
+				def #{id.id2name}(*args, &block)
+					tc = Thread::critical=(true)
+					begin
+						res= super(*args,&block)
+					ensure
+						Thread::critical = tc
+					end
+					self.changed(true)
+					self.notify_observers(self,
+					  #{id.id2name.inspect}, args,
+					  block)
+					res
+				end
+			end
+		end_eval
+	end
+	
+	def add_observer(obj)
+		tc = Thread::critical=(true)
+		if !self.respond_to?(:__add_observer_o__)
+			Thread::critical = tc
+			return self.add_observer(obj)
+		end
+		class <<self
+			@@__pso_adding_meth__ = false
+			alias_method :add_observer, :__add_observer_o__
+			private :__add_observer_o__
+#			if self.public_instance_methods.member? "extend_object"
+#				alias_method :__pso_extend_object_o__,
+#					:extend_object unless
+#					respond_to? :__pso_extend_object_o__
+#				def self.extend_object(id)
+#					Thread::critical =
+#						(tc = Thread::critical) || true
+#					if PMethName::obj_changer?(id.id2name)&&
+#					!@@__pso_adding_meth__
+#					  @@__pso_adding_meth__ = true
+#					  module_eval <<-"end_eval"
+#					    alias_method :__pso_#{id.to_i}_o__,
+#					    	#{id.inspect}
+#					    def #{id.id2name}(*args, &block)
+#						Thread::critical =
+#						 (tc = Thread::critical) || true
+#						begin
+#						  res = __pso_#{id.to_i}_o__(
+#						  	*args, &block)
+#						ensure
+#							Thread::critical = tc
+#						end
+#						self.changed(true)
+#						self.notify_observers(self,
+#							#{id.id2name.inspect},
+#							args, block)
+#						res
+#					    end
+#					  end_eval
+#					  @@__pso_adding_meth__ = false
+#					end
+#					Thread::critical = tc
+#					__pso_method_added_o__(id)
+#				end
+#			else
+#				def self.extend_object(id)
+#					Thread::critical =
+#						(tc = Thread::critical) || true
+#					if PMethName::obj_changer?(id.id2name)&&
+#					!@@__pso_adding_meth__
+#					  @@__pso_adding_meth__ = true
+#					  module_eval <<-"end_eval"
+#					    alias_method :__pso_#{id.to_i}_o__,
+#					    	#{id.inspect}
+#					    def #{id.id2name}(*args, &block)
+#						Thread::critical =
+#						 (tc = Thread::critical) || true
+#						begin
+#						  res = __pso_#{id.to_i}_o__(
+#						  	*args, &block)
+#						ensure
+#							Thread::critical = tc
+#						end
+#						self.changed(true)
+#						self.notify_observers(self,
+#							#{id.id2name.inspect},
+#							args, block)
+#						res
+#					    end
+#					  end_eval
+#					  @@__pso_adding_meth__ = false
+#					end
+#					Thread::critical = tc
+#				end
+#			end
+		end
+		for m in self.methods.delete_if{|m| !PMethName::obj_changer?(m)}
+			self.wrap_changer_meth(m.to_sym)
+		end
+		Thread::critical = tc
+		self.add_observer(obj)
+	end
+	
+#	if respond_to? :method_added
+#		alias_method :__pso_m_method_added_o__, :method_added unless
+#			respond_to? :__pso_m_method_added_o__
+#		def self.method_added(id)
+#			if PMethName.obj_changer?(id.id2name)
+#				ObjectSpace.each_object(self) { |o|
+#					if !o.respond_to? :__add_observer_o__
+#						o.wrap_changer_meth(id)
+#					end
+#				}
+#			end
+#			self.__pso_m_method_added_o__(id)
+#		end
+#	else
+#		def self.method_added(id)
+#			if PMethName.obj_changer?(id.id2name)
+#				ObjectSpace.each_object(self) { |o|
+#					if !o.respond_to? :__add_observer_o__
+#						o.wrap_changer_meth(id)
+#					end
+#				}
+#			end
+#		end
+#	end
+end

data/ruby_libs/pav/string/text.rb

@@ -0,0 +1,79 @@
+require 'pav/string/ext'
+require 'pav/string/observable'
+
+class StringLns
+	attr_reader :ln_start_idxs, :str
+	
+	include Enumerable
+	
+	def initialize(str)
+		@str = str
+		@ln_start_idxs = []
+		i = 0
+		str.each_line { |ln|
+			@ln_start_idxs << i
+			i += ln.length
+		}
+		@ln_start_idxs << i
+	end
+	
+	def [](*args)
+		if args.length == 1
+			is = args
+		elsif args.length == 2
+			is = args[0]..args[0]+args[1]-1
+		else
+			raise ArgumentError, "Unknown number of arguments"
+		end
+		res = is.collect{ |i|
+			if i < 0
+				if i <= -@ln_start_idxs.length
+					nil
+				else
+					@str[@ln_start_idxs[i-1]...
+						@ln_start_idxs[i]]
+				end
+			else
+				if i+1 >= @ln_start_idxs.length
+					nil
+				else
+					@str[@ln_start_idxs[i]...
+						@ln_start_idxs[i+1]]
+				end
+			end
+		}
+		if args.length == 1 && args[0].kind_of?(Numeric) then res[0]
+		else res end
+	end
+	
+	def each
+		[0..@ln_start_idxs-1].each { |i|
+			yield @str[@ln_start_idxs[i]..@ln_start_idxs[i+1]]
+		}
+	end
+	
+	def length
+		@ln_start_idxs.length - 1
+	end
+end
+
+class StringLnsObserver
+	def self.update(str, meth, args, block)
+		str.kill_lns
+	end
+end
+
+class String
+	def lns
+		self.add_observer(StringLnsObserver)
+		def lns
+			@lns = StringLns.new(self) unless @lns
+			@lns
+		end
+		self.lns
+	end
+	
+	def kill_lns
+		@lns = nil
+	end
+end

data/ruby_libs/pav/string/words.rb

@@ -0,0 +1,42 @@
+require 'pav/string/ext'
+
+class String
+	PLURAL_ES = %w[tomatoes potatoes branches ses zes xes]
+	PLURAL_EN = %w[oxen]
+	PLURAL_VES_F = %w[dwarves shelves elves]
+	PLURAL_VES_FE = %w[lives knives]
+	PLURAL_ICES_EX = %w[indices vertices vortices]
+	
+	PLURAL_TRANSFORMS = self.constants.find_all { |c|
+	  c.starts_with("PLURAL_") }.collect { |c|
+		to, from = *c["PLURAL_".length...c.length].split("_")
+		to.downcase!
+		if from then from.downcase! else from = ""; end
+		[to, from, self.const_get(c)]
+	  }
+	SINGULAR_TRANSFORMS = PLURAL_TRANSFORMS.collect { |pl_t|
+	  [pl_t[1], pl_t[0], pl_t[2].collect{|w| w[0,w.length-pl_t[0].length].
+	  	concat(pl_t[1])}]
+	}
+	
+	def singular
+		dn_case = self.downcase
+		PLURAL_TRANSFORMS.each { |t| t[2].each { |word|
+			return self[0, self.length-t[0].length].concat(t[1]) if
+				dn_case.ends_with(word)
+		}}
+		if dn_case.ends_with("s")
+			return self[0, self.length-1]
+		end
+		self.dup
+	end
+	
+	def plural
+		dn_case = self.downcase
+		SINGULAR_TRANSFORMS.each { |t| t[2].each { |word|
+			return self[0, self.length-t[0].length].concat(t[1]) if
+				dn_case.ends_with(word)
+		}}
+		self + "s"
+	end
+end

data/ruby_libs/pav/sub_arr.rb

@@ -0,0 +1,56 @@
+require 'pav/dbg_log'
+require 'pav/numeric/ext'
+require 'pav/rand_accessible'
+
+class SubArr
+	include RandomlyReadable
+	include Enumerable
+	
+	attr_reader :arr
+	attr_accessor :start_i, :end_i
+	
+	def initialize(arr, start_i=0, end_i=nil)
+		@arr = arr
+		@start_i = start_i
+		@end_i = end_i ? end_i : @arr.length
+	end
+	
+	def at(i)
+		i = self.length + i if i < 0
+		i += @start_i
+		return nil if i < @start_i || i >= @end_i
+		@arr.at(i % @arr.length)
+	end
+	
+	def length
+		end_i - start_i
+	end
+	
+	def empty?
+		self.length < 1
+	end
+	
+	def first
+		self.at(0)
+	end
+	
+	def each
+		return if @arr.empty?
+		for i in @start_i...@end_i
+			yield(@arr.at(i % @arr.length))
+		end
+	end
+	
+	def to_a
+		res = Array.new(self.length)
+		self.each_with_index { |lm, i| res[i] = lm }
+		res
+	end
+	
+	def to_s(expand_arr=false)
+		"<#{self.class.name}:#{self.object_id.mem_hex} @start_i=#{
+		  @start_i}, @end_i=#{end_i} @arr: #{expand_arr&&expand_arr!=0 ?
+		  @arr.inspect : @arr.length.to_s + " element" +
+		  (@arr.length==1 ? "" : "s")}>"
+	end
+end

data/ruby_libs/pav/traced_obj.rb

@@ -0,0 +1,79 @@
+require 'pav/dbg_log'
+
+class TracedObj
+	attr_reader :__to_filters__, :__to_obj__
+	attr_accessor :__to_processor__
+	
+	def initialize(obj, excl_meths=[])
+		@__to_obj__ = obj
+		if excl_meths && !excl_meths.empty?
+			@__to_filters__ = [ proc { |obj, id, args, block|
+				!excl_meths.include?(id) } ]
+		else
+			@__to_filters__ = []
+		end
+		@__to_processor__ = proc { |obj, id, args, block|
+			$PDbgLog.sig_call(self)
+			$PDbgLog.puts_msg "#{obj.class.name}#{(
+			   obj.kind_of?(Class) || obj.kind_of?(Module)) ? "#" :
+			   "."}#{id}(#{args.collect {|a| a.inspect}.join(", ")
+			   }) #{caller(2).join("\n")}"
+			res = obj.send(id, *args, &block)
+			$PDbgLog.sig_return(res.inspect)
+			res
+		}
+	end
+	
+	def method_missing(id, *args, &block)
+		for filt in @__to_filters__
+			return @__to_obj__.send(id, *args, &block) unless
+				filt.call(@__to_obj__, id, args, block)
+		end
+		@__to_processor__.call(@__to_obj__, id, args, block)
+	end
+	
+	def __to_add_filter__(block=Proc.new)
+		if block
+			@__to_filters__.push(block)
+			@__to_filters__.length-1
+		else
+			nil
+		end
+	end
+	
+	def to_s(*args, &block)
+		id = "to_s"
+		for filt in @__to_filters__
+			return @__to_obj__.send(id, *args, &block) unless
+				filt.call(@__to_obj__, id, args, block)
+		end
+		@__to_processor__.call(@__to_obj__, id, args, block)
+	end
+	
+	def to_a(*args, &block)
+		id = "to_a"
+		for filt in @__to_filters__
+			return @__to_obj__.send(id, *args, &block) unless
+				filt.call(@__to_obj__, id, args, block)
+		end
+		@__to_processor__.call(@__to_obj__, id, args, block)
+	end
+	
+	def inspect(*args, &block)
+		id = "inspect"
+		for filt in @__to_filters__
+			return @__to_obj__.send(id, *args, &block) unless
+				filt.call(@__to_obj__, id, args, block)
+		end
+		@__to_processor__.call(@__to_obj__, id, args, block)
+	end
+	
+	def hash(*args, &block)
+		id = "hash"
+		for filt in @__to_filters__
+			return @__to_obj__.send(id, *args, &block) unless
+				filt.call(@__to_obj__, id, args, block)
+		end
+		@__to_processor__.call(@__to_obj__, id, args, block)
+	end
+end