YkLib 0.1.0

data/lib/YkLib/Yk/__hook__.rb

@@ -0,0 +1,244 @@
+#
+
+
+require 'Yk/misc_tz'
+
+
+class Object
+	def __reraise_method_missing (name)
+		ex = NameError.new("undefined local variable or method `#{name}' for #{self}")
+		begin
+			raise ex
+		rescue NameError => e
+			bt = e.backtrace
+			bt.each_index do |i|
+				i = bt.size - i - 1
+				if bt[i] =~ /in \`method_missing\'/
+					bt.slice!(0..i)
+					break
+				end
+			end
+			raise
+		end
+	end
+end
+
+
+class Hook
+	class EachHook
+		instance_methods.each do |e|
+			if !["__id__", "__send__", "object_id"].include? e.to_s
+				undef_method e
+			end
+		end
+		def initialize (hook, c)
+			@hook = hook
+			@closure = c
+			(class << self; self; end).class_eval %{
+				#undef_method :initialize
+				def #{c.label} (*args, **opts, &bl)
+					newClosure = Hook::Closure.new(@closure.obj, :#{c.label}, bl, args, opts)
+					if @hook
+						@hook.call EachHook.new(@hook.prev, newClosure)
+					else
+						newClosure.call_org
+					end
+				end
+				def method_missing (name, *args, **opts, &bl)
+					obj.instance_eval do
+						__send__(name, *args, **opts, &bl)
+					end
+				end
+			}
+		end
+		def call
+			if @hook
+				@hook.call EachHook.new(@hook.prev, @closure)
+			else
+				@closure.call_org
+			end
+		end
+		def args
+			@closure.args
+		end
+		def args= (ags)
+			@closure.args = (ags)
+		end
+		def obj
+			@closure.obj
+		end
+		def obj= (o)
+			@closure.obj = o
+		end
+		def label
+			@closure.label
+		end
+		def label= (l)
+			@closure.label = l
+		end
+		def block
+			@closure.block
+		end
+		def block= (b)
+			@closure.block = b
+		end
+		def opts
+			@closure.opts
+		end
+		def opts= (o)
+			@closure.opts = o
+		end
+	end
+	attr_reader :body
+	attr :nxt, true
+	attr :prev, true
+	attr :label
+	HookList = Hash.new { |h, k| h[k] = Hash.new }
+	def initialize (obj, label, *largs, **lopts, &bd)
+		if [:initialize, :__hook__, :call, :args, :block, :obj, :opts, :label].find { |e| e.to_s == label.to_s || "#{e.to_s}=" == label.to_s }
+			raise ArgumentError.new("cannot hook `initialize', `hook', `call', `args', `obj', `label'")
+		end
+		@obj = obj
+		@label = label
+		@body = bd
+		@local_args = largs
+		@local_opts = lopts
+		if !HookList[obj].key? label
+			(class << obj; self; end).class_eval do
+				if method_defined? label
+					alias_method "__hk_org_#{label.to_s.underscore_escape}", label
+				else
+					if label != :method_missing
+						eval %{
+							def __hk_org_#{label.to_s.underscore_escape} (*args, **opts, &bl)
+							end
+						}
+					else
+						eval %{
+							def __hk_org_#{label.to_s.underscore_escape} (*args, **opts, &bl)
+								#__reraise_method_missing args[0]
+								#self.class.superclass.instance_method(label).bind(self).call(*args, **opts, &bl)
+								super
+							end
+						}
+					end
+				end
+				eval %{
+					def #{label} (*args, **opts, &bl)
+						if tmp = HookList[self][:#{label}]
+							tmp.createEachHook(self, :#{label}, bl, args, opts).call
+						else
+							#if :#{label} == :read and args[-1].is_a?(Hash)
+							#		__hk_org_#{label.to_s.underscore_escape}(*args[0..-2], **args[-1], &bl)
+							#else
+								__hk_org_#{label.to_s.underscore_escape}(*args, **opts, &bl)
+							#end
+						end
+					end
+				}
+			end
+		end
+		@prev = HookList[obj][label]
+		HookList[obj][label] = self
+		if @prev
+			@prev.nxt = self
+		end
+	end
+	def remove
+		@prev.nxt = @next if @prev
+		@nxt.prev = @prev if @nxt
+		if HookList[@obj][@label] == self
+			HookList[@obj][@label] = @prev
+		end
+		@nxt = nil
+		@prev = nil
+	end
+	def call (prevEachHook)
+		@body.call prevEachHook, *@local_args, **@local_opts
+	end
+	class Closure
+		attr_accessor :obj, :label, :block, :args, :opts
+		def initialize (o, l, b, a, op)
+			@obj, @label, @block, @args, @opts = o, l, b, a, op
+		end
+		def call
+			@obj.method(@label).call(*@args, **@opts, &@block)
+		end
+		def call_org
+			@obj.method("__hk_org_#{@label.to_s.underscore_escape}").call(*@args, **@opts, &@block)
+		end
+	end
+	def createEachHook *all_args
+		if all_args[0].is_a? Closure
+			c = all_args[0]
+		else
+			c = Closure.new(*all_args)
+		end
+		EachHook.new(self, c)
+	end
+	class OrgProxy
+		instance_methods.each do |e|
+			if !["__id__", "__send__", "object_id"].include? e.to_s
+				undef_method e
+			end
+		end
+		def initialize (o)
+			@obj = o
+			(class << self; self; end).class_eval do
+				#undef_method :initialize
+			end
+		end
+	end
+	def self.createOrgProxy (*objs)
+		proxyList = []
+		objs.each do |obj|
+			proxy = OrgProxy.new(obj)
+			HookList[self].each_value do |hook|
+				lb = hook.label.to_s.underscore_escape
+				proxy.__defun__ "__org_hook_#{lb}", hook
+				(class << proxy; self; end).class_eval %{
+					def #{hook.label} (*args, **opts, &bl)
+						hk = __org_hook_#{lb}.createEachHook(@obj, :#{hook.label}, bl, args, opts)
+						hk.call
+					end
+				}
+			end
+			(class << proxy; self; end).class_eval %{
+				def method_missing (name, *args, **opts, &bl)
+					@obj.instance_eval do
+						if respond_to?(tmp = "__hk_org_" +name.to_s.underscore_escape)
+							method(tmp).call(*args, **opts, &bl)
+						else
+							method(name).call(*args, **opts, &bl)
+						end
+					end
+				end
+			}
+			proxyList.push proxy
+		end
+		proxyList
+	end
+end
+
+
+class Object
+	def __hook__ (label, *local_args, **local_opts, &bd)
+		Hook.new(self, label, *local_args, **local_opts, &bd)
+	end
+	def __hook_group (*objList)
+		if objList.size == 0
+			ret = *Hook.createOrgProxy(self)
+		else
+			ret = *Hook.createOrgProxy(*objList)
+		end
+		if block_given?
+			yield ret
+		else
+			ret
+		end
+	end
+end
+
+
+
+

data/lib/YkLib/Yk/__minmax__.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+
+require 'delegate'
+
+class MaxMin
+	def initialize (item = nil)
+		@item = item
+	end
+	def min= (item)
+		if item != nil
+			if @item != nil
+				if @item > item
+					@item = item
+				end
+			else
+				@item = item
+			end
+		end
+	end
+	def max= (item)
+		if item != nil
+			if @item != nil
+				if @item < item
+					@item = item
+				end
+			else
+				@item = item
+			end
+		end
+	end
+	def min
+		@item
+	end
+	def max
+		@item
+	end
+	def self.[] (a, b)
+		if a < b
+			[b, a]
+		else
+			[a, b]
+		end
+	end
+end
+
+
+class MinMax < MaxMin
+	def self.[] (a, b)
+		if a > b
+			[b, a]
+		else
+			[a, b]
+		end
+	end
+end
+
+class MinMax__ < Delegator
+	def initialize (arg = nil)
+		if arg != nil
+			super arg
+			@__inited__ = true
+			__setobj__(arg)
+		else
+			@__inited__ = false
+		end
+	end
+	def __getobj__
+		@__obj__
+	end
+	def __setobj__ (arg)
+		@__obj__ = arg
+	end
+	def __min__= (arg)
+		if arg == nil
+			return self
+		end
+		if !@__inited__
+			initialize(arg)
+		elsif arg < self
+			__setobj__(arg)
+		end
+		self
+	end
+	def __max__= (arg)
+		if arg == nil
+			return self
+		end
+		if !@__inited__
+			initialize(arg)
+		elsif arg > self
+			__setobj__(arg)
+		end
+		self
+	end
+	def __min__
+		@__obj__
+	end
+	def __max__
+		@__obj__
+	end
+	def __obj__
+		@__obj__
+	end
+	def coerce (other)
+		[other, @__obj__]
+	end
+end
+
+
+if __FILE__ == $PROGRAM_NAME
+	t = MinMax__.new
+	t.__min__ = 1
+	t.__min__ = -1
+	p t
+	t2 = MinMax__.new
+	t2.__max__ = "abc"
+	t2.__max__ = "a"
+	t2.__max__ = "z"
+	p t2
+end
+
+

data/lib/YkLib/Yk/__stdlog.rb

@@ -0,0 +1,329 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+require 'syslog'
+require 'Yk/file_aux'
+require 'Yk/__defun__'
+
+
+module Syslog
+	alias :org_open :open
+	def open
+		if !Syslog.opened?
+			Syslog.org_open
+		end
+	end
+	module_function :open, :org_open
+end
+
+
+Syslog.open
+
+
+
+class Stdlog
+	stdoutLog = true
+	stdoutDrt = true
+	UseConsole = !ENV['STDLOG_NO_CONSOLE']
+	if ENV['STDLOG_STDOUT_NOT_TTY'] || !STDOUT.tty?
+		ENV['STDLOG_STDOUT_NOT_TTY'] = "1"
+		if ENV['STDLOG_NO_CONSOLE']
+			stdoutLog = true
+			stdoutDrt = false
+		else
+			stdoutLog = false
+			stdoutDrt = true
+		end
+	end
+	StdoutLog = stdoutLog
+	StdoutDrt = stdoutDrt
+	def Stdlog.stdlogFunc
+		ENV["STDLOG_FUNC"]
+	end
+	def Stdlog.errlogFunc
+		ENV["ERRLOG_FUNC"]
+	end
+	class Piper
+		attr :fw
+		def initialize (&bl)
+			@fr, @fw = IO.pipe
+			init_pid = $$.to_s
+			@fr.sync = true
+			closed = false
+			r = rand.to_s[2..-1]
+			t = Thread.new do
+				Thread.pass
+				@fr.each_line do |ln|
+					if ln != "#{r}\n"
+						bl.call ln
+					else
+						@fr.close
+						break
+					end
+				end
+			end
+			@finalizer = Proc.new do |mode|
+				if init_pid == $$.to_s && !closed
+					closed = true
+					@fw.write "#{r}\n"
+					if mode != true
+						@fr.each_line do |ln|
+							if ln == "#{r}\n"
+								break
+							end
+							bl.call ln
+						end
+					end
+				end
+			end
+			ObjectSpace.define_finalizer t, @finalizer
+		end
+		
+		
+		def close
+			@finalizer.call true
+			@fw.close
+		end
+
+	end
+	
+	class Pipeback < Piper
+		attr :org
+		def initialize (fd, drt = nil)
+			drt ||= fd.dup
+			@org = fd.dup
+			prc = Proc.new do |ln|
+				yield ln, drt
+			end
+			super &prc
+			fd.reopen fw
+			fd.__defun__ :direct do
+				drt
+			end
+			fd.__defun__ :restore do
+				fd.reopen @org
+			end
+			@org
+		end
+	end
+
+	class Bypass < Piper
+		def initialize (evsym, out)
+			prc = Proc.new do |ln|
+				out.write ln
+			end
+			super &prc
+			ENV[evsym] = fw.fileno.to_s
+		end
+	end
+	
+	def Stdlog.prefix (prog = "", str = "")
+		require 'Yk/misc_tz'
+		progStr = (@@prefixProgs + [prog]).cond_join(":", "(parent = {})")
+		nameStr = (@@prefixNames + [str]).prefix_cond_join(":")
+		[progStr, nameStr].prefix_cond_join(" ")
+	end
+
+	def Stdlog.logerr (arg)
+		arg = arg.chomp
+		arg = arg.gsub /\n/, " "
+		arg = arg.gsub /\t/, " "
+		if errlogFunc
+			i = 0
+			cur = arg[i ... i + 80]
+			while true
+				if i != 0
+					body = "(__debug__errlog__) " + cur
+				else
+					body = "(__debug__errlog__) (__d_first)" + cur
+				end
+				i += 80
+				cur = arg[i ... i + 80]
+				if cur
+					tail = "(__d_cont)\n"
+					Syslog.err body + tail
+				else
+					tail = "\n"
+					Syslog.err body + tail
+					break
+				end
+			end
+		else
+			Syslog.err arg
+		end
+	end
+
+	def Stdlog.main
+		psf, psf = "", ""
+		if ENV['STDLOG_PARENT'] != nil && ENV['STDLOG_PARENT'] =~ /::/
+			pre = $`
+			post = $'
+			if pre && pre != ""
+				@@prefixNames = pre.split /:/
+			else
+				@@prefixNames = []
+			end
+			if post && post != ""
+				@@prefixProgs = post.split /:/
+			else
+				@@prefixProgs = []
+			end
+		else
+			@@prefixNames = []
+			@@prefixProgs = []
+		end
+		if ENV['RUBYOPT'] == nil || ENV['RUBYOPT'] !~ /(^|\s)\-rtz\/__stdlog\.rb\b/
+			ENV['RUBYOPT'] = (ENV['RUBYOPT'] || "") + " -rtz/__stdlog.rb "
+			Pipeback.new STDOUT do |ln1, direct1|
+				direct1.write ln1 if StdoutDrt
+				Syslog.info prefix + ln1 if StdoutLog && stdlogFunc
+			end
+			@@stdoutm = Bypass.new('STDLOG_STDOUT_DIRECT', STDOUT.direct).fw
+			Pipeback.new STDERR do |ln2, direct2|
+				direct2.write ln2 if UseConsole
+				logerr prefix + ln2
+			end
+			@@stderrm = Bypass.new('STDLOG_STDERR_DIRECT', STDERR.direct).fw
+		else
+			if !defined? @@stdoutm
+				@@stdoutm = (IO.open(ENV['STDLOG_STDOUT_DIRECT'].to_i) rescue return)
+			end
+			if !defined? @@stderrm
+				@@stderrm = (IO.open(ENV['STDLOG_STDERR_DIRECT'].to_i) rescue return)
+			end
+			Pipeback.new STDOUT, @@stdoutm do |ln3, direct3|
+				direct3.write ln3 if StdoutDrt
+				Syslog.info prefix + ln3 if StdoutLog && stdlogFunc
+			end
+			Pipeback.new STDERR, @@stderrm do |ln4, direct4|
+				direct4.write ln4 if UseConsole
+				logerr prefix + ln4
+			end
+		end
+
+	end
+end
+
+Stdlog.main
+
+alias :org_fork :fork
+alias :org_exec :exec
+
+def ___setParent (prc, prefix = nil)
+	if ENV['STDLOG_PARENT'] && ENV['STDLOG_PARENT'] =~ /::/
+		pre, post = $`, $'
+		parents =  (post != "" && post != nil) ? post.split(/:/) : []
+		prefixes = (pre != "" && pre != nil) ? pre.split(/:/) : []
+	else
+		prefixes = []
+		parents = []
+	end
+	parents.push "#{$0}[#{prc.to_s}]"
+	if prefix != nil && prefix.strip != ""
+		prefixes.unshift prefix
+	end
+	ENV['STDLOG_PARENT'] = prefixes.join(":") + "::" + parents.join(":")
+end
+
+def fork
+	parent = $$.to_s
+	if block_given?
+		ret = org_fork do
+			___setParent parent
+			Stdlog.main
+			yield
+		end
+		ret
+	else
+		ret = org_fork
+		if ret == nil
+			___setParent parent
+			Stdlog.main
+		end
+		ret
+	end
+end
+
+alias :system_org :system
+def system (*args)
+	all_prefix = ""
+	apx = ""
+	if String === args[0]
+		if args[0] =~ /^prefix:/
+			all_prefix = $'.strip
+			apx = all_prefix + ": "
+			args.shift
+		end
+	end
+	child_prefix = nil
+	piper1 = Stdlog::Piper.new do |ln|
+		while child_prefix == nil
+			sleep 0.1
+		end
+		STDOUT.direct.write ln if Stdlog::StdoutDrt
+		Syslog.info Stdlog.prefix + child_prefix + apx + ln if Stdlog::StdoutLog&& Stdlog::stdlogFunc
+	end
+	piper2 = Stdlog::Piper.new do |ln|
+		while child_prefix == nil
+			sleep 0.1
+		end
+		STDERR.direct.write ln if Stdlog::UseConsole
+		Stdlog.logerr(Stdlog.prefix + child_prefix + apx + ln)
+	end
+	parent = $$.to_s
+	pid = org_fork do
+		STDOUT.reopen piper1.fw
+		STDERR.reopen piper2.fw
+		___setParent parent, all_prefix
+		if !exec *args
+			exit 1
+		end
+	end
+	if Array === args[0]
+		child_prefix = args[0][0] + "[#{pid}]: "
+	else
+		child_prefix = args[0].strip.split(/\s+/)[0] + "[#{pid}]: "
+	end
+	ret = Process.waitpid2(pid)[1].exitstatus == 0
+	piper1.close
+	piper2.close
+	ret
+end
+
+
+def exec (*args)
+	STDERR.flush
+	STDOUT.flush
+	if STDERR.respond_to? :restore
+		STDERR.restore
+	end
+	if STDOUT.respond_to? :restore
+		STDOUT.restore
+	end
+	org_exec *args
+end
+
+
+if File.basename($0) == File.basename(__FILE__)
+	2.times do
+		STDERR.write "err\n"
+	end
+	2.times do
+		STDOUT.write "out\n"
+	end
+	p "aa"
+	system "prefix: test", "ruby -e 'STDOUT.write(\"testout\\n\"); STDERR.write(\"testerr\\n\");'"
+	system "prefix: test2", "echo stdout; echo $RUBYOPT >&2"
+
+	def pp
+
+		sdddfags
+	end
+	def xd
+		pp
+	end
+	xd
+	sleep 10
+end
+
+