YkLib 0.1.0

data/lib/YkLib/Yk/clambda.rb

@@ -0,0 +1,309 @@
+#!/usr/bin/env ruby
+
+
+require 'Yk/misc_tz'
+
+
+module TZLambda
+
+	class Base
+	    instance_methods.each { |m|
+			if m.to_s !~ /^__/ && m.to_s != "object_id"
+		        undef_method m
+			end
+	    }
+		def __l_to_lambda__
+			self
+		end
+	    def method_missing (name, *args, &bl)
+	    	MethodElem.new nil, self, name, *args, &bl
+		end
+		def hasTheme?
+			false
+		end
+		def call *cargs
+			if !hasTeme?
+				__call nil, *cargs
+			else
+				__call *cargs
+			end
+		end
+	end
+
+	class PlaceHolder < Base
+	    def initialize pos
+	    	@pos = pos
+	    end
+		def __call *cargs
+			cargs[@pos]
+		end
+		def coerce a
+			[self, a]
+		end
+		def hasTheme?
+			@pos == 0
+		end
+	end
+
+
+	class MethodElem < Base
+		def initialize bnd, target, name, *args, &bl
+			@binding = bnd
+			@target = target.__l_to_lambda__
+			@args = []
+			args.each do |a|
+				@args.push a.__l_to_lambda__
+			end
+			@block = bl
+			@name = name
+		end
+		def __call *cargs
+			args = @args.map{ |e| e.__call(*cargs)}
+			if !@binding
+				t = @target.__call(*cargs)
+				m = t.__send__(@name, *args, &bl)
+			else
+				args = args.map{|e| "ObjectSpace._id2ref(#{e.__id__})"}
+				if @block
+					args.push "&ObjectSpace._id2ref(#{@block.__id__})"
+				end
+				@binding.eval("#{@name} #{args.join(', ')}")
+			end
+		end
+		def hasTheme?
+			return true if @target.hasTheme?
+			@args.each do |a|
+				return true if a.hasTheme?
+			end
+		end
+		def to_proc
+			Proc.new do |*args|
+				__call nil, *args
+			end
+		end
+	end
+
+
+	class FixedElem < Base
+		def initialize obj
+			@obj = obj
+		end
+		def __call *cargs
+			return @obj
+		end
+	end
+
+
+	class NullElem
+	    instance_methods.each { |m|
+			if m.to_s !~ /^__/ && m.to_s != "object_id"
+		        undef_method m
+			end
+	    }
+		def initialize bnd
+			@binding = bnd
+		end
+	    def method_missing (name, *args, &bl)
+    		MethodElem.new @binding, nil, name, *args, &bl
+		end
+	end
+
+	PlaceHolder0 = PlaceHolder.new 0
+	PlaceHolder1 = PlaceHolder.new 1
+	PlaceHolder2 = PlaceHolder.new 2
+	PlaceHolder3 = PlaceHolder.new 3
+	PlaceHolder4 = PlaceHolder.new 4
+	PlaceHolder5 = PlaceHolder.new 5
+	PlaceHolder6 = PlaceHolder.new 6
+	PlaceHolder7 = PlaceHolder.new 7
+	PlaceHolder8 = PlaceHolder.new 8
+	PlaceHolder9 = PlaceHolder.new 9
+	PlaceHolder10 = PlaceHolder.new 10
+	PlaceHolder11 = PlaceHolder.new 11
+	PlaceHolder12 = PlaceHolder.new 12
+	PlaceHolder13 = PlaceHolder.new 13
+	PlaceHolder14 = PlaceHolder.new 14
+	PlaceHolder15 = PlaceHolder.new 15
+	PlaceHolder16 = PlaceHolder.new 16
+	PlaceHolder17 = PlaceHolder.new 17
+	PlaceHolder18 = PlaceHolder.new 18
+	PlaceHolder19 = PlaceHolder.new 19
+	PlaceHolder20 = PlaceHolder.new 20
+
+	class MethodCall
+	    instance_methods.each { |m|
+			if m.to_s !~ /^__/ && m.to_s != "object_id"
+		        undef_method m
+			end
+	    }
+	    def initialize bnd, obj, mode
+	    	@binding = bnd
+	    	@mode = mode
+	    	@obj = obj
+	    end
+		def method_missing name, *args, &bl
+			name = @mode + name.to_s
+			@binding.eval(name).__send__(:__call, @obj, *args, &bl)
+		end
+	end
+
+	class CallBlock
+	    instance_methods.each { |m|
+			if m.to_s !~ /^__/ && m.to_s != "object_id"
+		        undef_method m
+			end
+	    }
+	    def initialize bnd, obj, rflag = false
+	    	@binding = bnd
+	    	@obj = obj
+	    	@rflag = rflag
+	    end
+		def method_missing name, *args
+			bl = args.pop
+			if @obj
+				res = @obj.__send__(name, *args, &bl)
+				if @rflag
+					@obj.replace res
+				else
+					res
+				end
+			else
+				args._!.map{|e| "ObjectSpace._id2ref(#{e.__id__})"}
+				args.push "&ObjectSpace._id2ref(#{bl.to_proc.__id__})"
+				res = @binding.eval("#{name} #{args.join(', ')}")
+				if @rflag
+					@binding.eval("replace ObjectSpace._id2ref(#{res.__id__})")
+				else
+					res
+				end
+			end
+		end
+	end
+	class SetTheme
+		def initialize obj, *lexprs
+			@lexprs = lexprs
+			@obj = obj
+		end
+		def call *cargs
+			ret = @lexprs.map{|e| e.__call @obj, *cargs}
+			if ret.size == 1
+				ret[0]
+			else
+				ret
+			end
+		end
+	end
+
+end
+
+
+def __ *args
+	case args.size
+	when 0
+		return unless bnd = caller_binding
+		TZLambda::NullElem.new bnd
+	when 1
+		args[0].__l_to_lambda__
+	else
+		args = args.map do |a|
+			a.__l_to_lambda__
+		end
+		args.__l_to_lambda__
+	end
+end
+
+
+
+class Object
+	def __l_to_lambda__
+		TZLambda::FixedElem.new self
+	end
+	def _I *lexprs
+		return unless bnd = caller_binding
+		obj = bnd.eval("self") == self ? nil : self
+		if lexprs.size == 0
+			TZLambda::MethodCall.new bnd, obj, ""
+		else
+			TZLambda::SetTheme.new obj, *lexprs
+		end
+	end
+	[[:a, ?@], [:d, ?$]].each do |s, m|
+		class_eval %{
+			def _I#{s.to_s}
+				return unless bnd = caller_binding
+				obj = bnd.eval("self") == self ? nil : self
+				TZLambda::MethodCall.new bnd, obj, #{m.inspect}.chr
+			end
+		}
+	end
+	[["!", ", :replace"], ["", ""]].each do |s, f|
+		class_eval %{
+			def _L#{s}
+				return unless bnd = caller_binding
+				obj = bnd.eval("self") == self ? nil : self
+				TZLambda::CallBlock.new bnd, obj#{f}
+			end
+		}
+	end
+end
+
+
+0.upto 20 do |i|
+	eval %{
+		def _#{i}
+			return TZLambda::PlaceHolder#{i}
+		end
+	}
+end
+
+
+class String
+	alias :__plus__ :+
+	def + (other)
+		return __(self) + other if other.is_a?(TZLambda::Base)
+		__plus__ other
+ 	end
+end
+
+
+if $0 == __FILE__
+	def fold &m
+		[100, 200, 300].inject{|a, e| m.call(a, e) }
+	end
+	def test a, b
+		[a + 1, b + 1]
+	end
+	require 'Yk/path_aux'
+	require 'Yk/debug2'
+	p 3
+	p
+	a = "#{ENV['HOME']}/.console_files"
+	p
+	b = __1 * __1 * __2
+	p
+	p __I.b 2, 3
+	p "Q"._?._e?.inspect
+	p "asdf"._e?
+	clause __.a + __0 + __1._?._e?.__it.to_s do |c|
+		p "test"._I(c, c).call "asdf"
+	end
+	e = __FILE__
+	clause _0.expand_path.write_la _1.ln do |c|
+		p c
+		"~/.command_arg_files.test"._I.c e
+		if e._d? || e._!.dirname._d?
+			"~/.command_arg_dirs.test"._I.c e
+		end
+	end
+	a = [1, 2, 3]
+	p a
+	a._L!.map(100 + _1)
+	p a
+	p _L.fold(:+)
+	a = __.test __1, __2
+	p _I.a 5, 6
+	p _I(a, a).call 7, 8
+	p [?a, ?b, ?c]._L!.map("Z" + _1)
+end
+
+

data/lib/YkLib/Yk/confLine.rb

@@ -0,0 +1,423 @@
+
+	class ConfLine < String
+		class Error < Exception
+		end
+		@@definitions = Hash.new { |h, k| h[k] = Hash.new }
+		def resolvIt (arg, parent)
+			ret = []
+			mode = true
+			wd = ""
+			addByte = Proc.new do |c|
+				wd += c.chr
+			end
+			checkWord = Proc.new do
+				if mode
+					while wd =~ (/\$(\{|)([A-Za-z_]\w*)(\1)/)
+						pre = $`
+						if pre && pre != ""
+							ret += pre.split_chunk(/[\,\s]+/)
+						end
+						post = $'
+						val = $2
+						if tmp = resolvDef(val)
+							if tmp =~ /\%\d+/
+								args = getArguments(post)
+								if args
+									tmp = tmp.setArgs(args)
+								end
+							end
+						end
+						ret.push tmp
+						wd = post
+					end
+				end
+				ret += wd.split_chunk(/[\,\s]+/)
+				wd = ""
+			end
+			catch :brkr do
+				curPos = 0
+				g = Object.new
+				g.__defun__ :+@ do
+					arg[curPos]
+				end
+				g.__defun__ :inc do
+					curPos += 1
+					if curPos == arg.size
+						throw :brkr
+					end
+				end
+				g.__defun__ :next do
+					arg[curPos + 1]
+				end
+				def g.loop (&bl)
+					while true
+						yield
+						inc
+					end
+				end
+				g.loop do
+					case +g
+					when ?\"
+						mode = true
+						g.inc
+						begin
+							if +g == ?\\
+								g.inc
+								case +g
+								when ?\\
+									addByte.call ?\\
+								when ?n
+									addByte.call ?\n
+								when ?t
+									addByte.call ?\t
+								else
+									addByte.call +g
+								end
+								next
+							end
+							addByte.call +g
+							g.inc
+						end while +g != ?\"
+						checkWord.call
+					when ?\'
+						mode = false
+						g.inc
+						begin
+							if +g == ?\\
+								g.inc
+								case +g
+								when ?'
+									addByte.call "'"
+								else
+									addByte.call ?\\
+									addByte.call +g
+								end
+								next
+							end
+							addByte.call +g
+							g.inc
+						end while +g != ?\'
+						checkWord.call
+					else
+						mode = true
+						begin
+							addByte.call +g
+							g.inc
+						end while g.next != ?\" && g.next != ?\'
+						checkWord.call
+					end
+				end
+			end
+			checkWord.call
+			ConfLine.new(ret, parent)
+		end
+		def getArguments (str, parent)
+			ret = []
+			i = 0
+			cnt1 = 0
+			cnt2 = 0
+			cnt3 = 0
+			pth = nil
+			if str[0] != ?(
+				return nil
+			end
+			while i < str.size
+				case pth
+				when nil
+					case str[i]
+					when ?(
+						cnt1 += 1
+						if cnt1 == 1
+							start = i + 1
+						end
+					when ?)
+						cnt1 -= 1
+						if cnt1 == 0
+							ret.push resolvIt(str[start .. i - 1].strip, parent)
+							start = nil
+							str[0 .. i] = ""
+							break
+						end
+					when ?{
+						cnt2 += 1
+					when ?}
+						cnt2 -= 1
+					when ?[
+						cnt3 += 1
+					when ?]
+						cnt3 -= 1
+					when ?"
+						pth = ?\"
+					when ?'
+						pth = ?\'
+					when ?,
+						if cnt1 == 1 && cnt2 == 0 && cnt3 == 0
+							ret.push resolvIt(str[start .. i - 1].strip, parent)
+							start = i + 1
+						end
+						start = i + 1
+					end
+				when "\\\'"
+					pth = ?\'
+				when "\\\""
+					pth = ?\"
+				when ?\'
+					case str[i]
+					when ?\'
+						pth = nil
+					when ?\\
+						pth = "\\\'"
+					end
+				when ?\"
+					case str[i]
+					when ?\"
+						pth = nil
+					when ?\\
+						pth = "\\\""
+					end
+				end
+				i += 1
+			end
+			return ret
+		end
+		def getChunk (i)
+			self[@chunks[i]]
+		end
+		def chunks (arg = nil)
+			if arg.is_a? Range
+				res = ""
+				(tmp = @chunks[arg]).each_index do |i|
+					e = tmp[i]
+					if i != 0 && res.respond_to?(:prefix)
+						res += e.prefix
+					end
+					res += e
+					if i != tmp.size - 1 && res.respond_to?(:postfix)
+						res += e.postfix
+					end
+				end
+				res
+			elsif arg != nil
+				@chunks[arg]
+			else
+				@chunks
+			end
+		end
+		def resolvDef (arg)
+			@definitionFiles.each do |f|
+				if @@definitions.key?(f)
+					if tmp = @@definitions[f][arg]
+						return tmp
+					end
+				end
+			end
+			nil
+		end
+		def registerDefFile (defFile)
+			if defFile && defFile.readable_file? && !@@definitions.key?(defFile)
+				defFile.read_each_line do |ln2|
+					ConfLine.new(ln2, defFile, nil)
+				end
+				if @@definitions.key? defFile
+					@definitionFiles.push defFile
+				end
+			end
+		end
+		attr :definitionFiles
+		attr :scope
+		def setArgs (args, parent)
+			arr = []
+			chunks.each do |e|
+				if e =~ /\%\d+/
+#					if e.respond_to? :chunks
+#						arr.push e.setArgs(args, parent)
+#					else
+						while e =~ /\%(\d+)/
+							pre, hit, id, post = $`, $&, $1.to_i - 1, $'
+							if pre && pre != ""
+								arr += pre.split_chunk(/[\,\s]+/)
+							end
+							if tmp = args[id]
+								arr.push tmp
+							else
+								arr.push hit
+							end
+							e = post
+						end
+						if e && e != ""
+							arr.push e
+						end
+#					end
+				else
+					arr.push e
+				end
+			end
+			ConfLine.new(arr.join.split_chunk(/[\,\s]+/), parent)
+		end
+		def initialize (ln, sc, incFiles = nil, noDef = false)
+			super()
+			if !ln.is_a? Array
+				@scope = sc
+				@definitionFiles = [@scope]
+				if incFiles.is_a? Array
+					incFiles.each do |e|
+						registerDefFile e
+					end
+				else
+					registerDefFile e
+				end
+				@definitionFiles.push nil
+				tmp = ""
+				ln.each_line do |l|
+					l.sub!(/\#.*$/, "")
+					l.strip!
+					tmp += l.ln!
+				end
+				if !noDef && ln =~ /([A-Za-z_]\w*)\s*\=\s*(.*)/m
+					m1, m2 = $1, $2.strip
+					@@definitions[@scope][m1] = ConfLine.new(m2, @scope, incFiles, true)
+					replace("")
+				else
+					res = ln
+					arr = []
+					while res =~ (/\$(\{|)([A-Za-z_]\w*)(\1)/)
+						pre = $`
+						post = $'
+						val = $2
+						if pre && pre != ""
+							arr.push *pre.split_chunk(/[\,\s]+/)
+						end
+						if tmp = resolvDef(val)
+							if tmp =~ /\%\d+/
+								args = getArguments(post, self)
+								tmp = tmp.setArgs(args, self)
+							end
+							arr.push tmp
+						else
+							arr.push "$" + val
+						end
+						res = post
+					end
+					arr.push *res.split_chunk(/[\,\s]+/)
+					@chunks = arr
+					replace(arr.join)
+				end
+				if block_given? && self != ""
+					yield self
+				end
+			else
+				arr, parent = ln, sc
+				@chunks = arr
+				@scope = parent.scope
+				@definitionFiles = parent.definitionFiles
+				replace(arr.join)
+			end
+		end
+	end
+
+
+	module ConfFile
+		module_function
+		def getSection_l (f, sec, scope = nil, preLoad = [], preParser = nil, &bl)
+			getSection_(true, f, sec, scope, preLoad, preParser, &bl)
+		end
+		def getSection (f, sec, scope = nil, preLoad = [], preParser = nil, &bl)
+			getSection_(nil, f, sec, scope, preLoad, preParser, &bl)
+		end
+		def getSection_ (lck, f, sec, scope = nil, preLoad = [], preParser = nil)
+#			if !scope
+#				scope = f
+#			end
+			@cList ||= Hash.new
+			@cList[f] ||= splitSection_(lck, f)
+			res = nil
+			notFound = Proc.new do
+				if ((tmp = @cList[f].keys).size == 1 && tmp[0] == nil)
+					@cList[f][nil]
+				elsif tmp.size == 0
+					""
+				else
+					nil
+				end
+			end
+			if sec.is_a? Regexp
+				ret = nil
+				@cList[f].keys.select{ |e| e =~ sec}.each do |k|
+					if !ret
+						ret = ""
+					end
+					ret += @cList[f][k]
+				end
+				if !ret
+					notFound.call
+				else
+					res = ret
+				end
+			else
+				if !@cList[f].key?(sec)
+					notFound.call
+				else
+					res = @cList[f][sec]
+				end
+			end
+			i = 0
+			if res
+				res = res.lines
+				pobj = preParser.new if preParser
+				while i < res.size
+					ln = res[i]
+					while ln[-2] == ?\\
+						ln = ln.chomp.chop.ln
+						if i == res.size - 1
+							break
+						end
+						i += 1
+						ln += res[i]
+					end
+					if pobj
+						pobj.call ln do |ln2|
+							cl = ConfLine.new(ln2, scope, preLoad)
+							if ln2.respond_to? :extra_properties
+								ln2.extra_properties.each do |l|
+									cl.__defun__ l, ln2.method(l).call
+								end
+							end
+							yield cl
+						end
+					else
+						yield ConfLine.new(ln, scope, preLoad)
+					end
+					i += 1
+				end
+			end
+		end
+		def splitSection_ (lck, f)
+			secs = Hash.new { |h, k| h[k] = "".clone }
+			sec = nil
+			if lck
+				f.read_each_line_l do |ln|
+					if ln =~ /^\s*\[([^\]\#]+)\]/
+						sec = $1.strip
+						ln = $'
+					end
+					secs[sec] += ln
+				end
+			else
+				f.read_each_line do |ln|
+					if ln =~ /^\s*\[([^\]\#]+)\]/
+						sec = $1.strip
+						ln = $'
+					end
+					secs[sec] += ln
+				end
+			end
+			secs
+		end
+		def splitSection (f)
+			splitSection_(nil, f)
+		end
+		def splitSection_l (f)
+			splitSection_(true, f)
+		end
+	end
+