YkLib 0.1.0

data/lib/YkLib/Yk/indenter/each_token.rb

@@ -0,0 +1,671 @@
+
+class Token
+
+	Starters = %i{
+		begin
+		def
+		class
+		module
+		if
+		unless
+		loop_for
+
+		ensure
+		rescue
+		when
+		free_in
+		free_for
+		free_when
+	}
+	StartersMayBrace = %i{
+	}
+
+	def closeBeginner pi
+		""
+	end
+
+	Modules :Begin, :Def, :Class, :Module, :If, :Unless, :LoopFor do
+		def closeBeginner pi
+			ins = (requireArg? ? 
+				(closeSentence(pi); argEnd = pi; ?;) 
+				: ' ') + "end"
+		end
+	end
+
+	class ForWithoutIn < Exception
+		def initialize
+			super "new line or semicolon is not allowed after 'for' arguments"
+		end
+	end
+
+	class WhenWithoutArg < Exception
+		def initialize (k)
+			super "new line or semicolon is not allowed after '#{k}' arguments"
+		end
+	end
+
+	class CaseWithoutArg < Exception
+		def initialize
+			super "missing argment for 'case'"
+		end
+	end
+
+	module OnSemicolon
+		def onClassify
+			case parent.kind
+			when :on_lbrace
+				parent.kind = :lbrace_clause
+			end
+		end
+	end
+
+	module OnNl
+		def closeBeginner pi
+			c = iteratorMethod
+			addModPrev, "do"
+			c.trySetupIterator(:preset, self) || "end"
+		end
+	end
+
+	def checkRequireArgStarterWithoutArg
+		case parent.kind
+		when *%i{if elsif unless while until on_tlambda post_test_while post_test_until \\ =}
+			raise Error.new("missing argument for '#{parent.str}'")
+		when :for
+			if parent.in
+				raise Error.new("missing argument for 'in'")
+			end
+			raise WhenWithoutArg.new(parent.str)
+		when :when
+			raise WhenWithoutArg.new(parent.str)
+		when :in
+			raise Error.new("missing argument for 'in'")
+		end
+	end
+
+	def checkRequireArgStarterWithArg
+		case parent.kind
+		when :for
+			if !parent.in?
+				raise ForWithoutIn.new
+			end
+		when :on_tlambda
+			if !defined?(Endless) || kind == :on_semicolon
+				raise Error.new("new line or semicolon is not allowed after '->' arguments")
+			end
+		when :"=" # for one line method
+			spop
+		when :post_test_while, :post_test_until
+			postTestFinalize self
+		end
+	end
+
+	Modules :OnSemicolon, :OnNl do
+		MethodChain.override do
+			def onClassify
+				t.parent.closeSentence self
+				t.parent.iteratorCand = nil
+				begin
+					super #raise ForWithoutIn
+					if parent.requireArg? # including for, in
+						if !parent.argStart
+							if defined?(Endless) || kind == :on_semicolon
+								checkRequireArgStarterWithoutArg
+							end
+						else
+							checkRequireArgStarterWithArg
+						end
+					end
+				ensure
+					parent.argEnd = self # :rescue is unconditionally close argument
+				end
+			end
+		end
+	end
+
+	attr_accessor :firstRightAssign
+	attr_accessor_predicate :maybeRightMatch
+	def addComma t
+		(@commas ||= []).push t
+	end
+	module OnComma
+		def onClassify
+			if idx = [:on_lbrace, :on_lparen].find_index(parent.kind)
+				if !parent.iteratorCand
+					parent.addComma self
+				end
+				if idx == 0
+					if parent.firstRightAssign # '=>' as in '{ foo => ...'
+						parent.maybeRightMatch = true
+					end
+				end
+			end
+			# seup hash
+			if parent.kind == :on_lbrace && parent.interatorCand == nil && parent.next.kind == :on_label
+				parent.kind = :hash_beg
+			end
+		end
+	end
+
+
+	def ambiguousPeriodTheme?
+		found = false
+		eachParent do |t|
+			case t.kind
+			when :on_period, :"&."
+				if (tmp = s.prev).kind == :on_rparen && tmp.beginner.isOperand? && tmp.beginner.multiArgument?
+					return true
+				end
+				found ? return(true) : found = true
+			when :on_lbrace
+				if t.inserted?
+					found ? return(true) : found = true
+				end
+			end
+		end
+		return false
+	end
+
+	def implementOpener
+		.....
+	end
+
+	module RightAssignOpn
+		::Token.registerModule self, :'=>'
+		def onClassify
+			# seup hash
+			if parent.kind == :on_lbrace && parent.iteratorCand == nil
+				if parent.firstRightAssign
+					parent.kind = :hash_beg
+				else
+					parent.firstRightAssign = t
+				end
+				parent.kind = :hash_beg
+			end
+		end
+	end
+
+	module VerticalBarOp
+		::Token.registerModule self, :|
+		def onClassify
+			if [:do, :on_lbrace].include?(prev) && parent == prev
+				if parent == :on_lbrace
+					parent = :lbrace_clause
+				end
+				implementOpener
+				reserve_spush
+			elsif parent.kind == :|
+				reserve_spop
+			else
+				raise Error.new("unclosed iterator arguments")
+			end
+		end
+	end
+
+	attr_accessor :body
+	module OnLambeg
+		def onClassify
+			if parent.kind == :on_tlambda && !parent.body
+				parent.body = self
+			end
+		end
+	end
+
+	Modules :OnLparen, :OnLbracket,
+		:OnRegexpBeg, :OnBacktick, :OnEmbexprBeg,
+		:OnTstringBeg, :OnQwordsBeg,:OnWordsBeg, :OnSymbeg, :OnQsymbolsBeg, :OnSymbolsBeg do
+		def onClassify
+			reserve_spush
+		end
+	end
+	Modules :OnRparen, :OnRbracket, :OnRbrace, :OnEmbexprEnd do
+		def onClassify
+			first = true
+			if !parent.opponent?(self)
+				toInsert = ""
+				while parent.isStarter?
+					toInsert = (!parent.requireArg? ? ' ' : ?;) + "end" + toInsert
+					reserve_spop
+				end
+				if !parent.opponent?(self)
+					raise Error.new("#{parent.str} is not closed")
+				end
+				if !toInsert.empty?
+					@expr[range] = toInsert + @expr[range]
+					raise Restart.new
+				end
+			end
+			reserve_spop
+			case @kind
+			when :on_rparen, :on_rbracket
+				beginner.checkAndOp
+			when :on_rbrace
+				if @@cur.parStack.size == 0 && RBRACE_MODE.include?(@@ebmode)
+					if @@ebmode == :bare
+						if AdhocLiterals[:url]
+							checkUrl first do |led|
+								yield first, :url #back track
+							end
+						end
+						if AdhocLiterals[:email]
+							checkEmail first do |led|
+								yield first, :email #back track
+							end
+						end
+						if AdhocLiterals[:path]
+							checkPath first do |led, pstack|
+								yield first, :path, led, pstack #back track
+							end
+						end
+					else
+						yield first, @@emode
+					end
+					# do not return : raise Restart.new
+				else
+					if beginner.kind == :hash_beg
+						beginner.addModPrev, " ("
+						addModAfter, ")"
+					elsif [:on_lbrace, :lbrace_clause].include? beginner.kind # check iterator
+						if [:"&.", :on_period, :"::"].include?((tbp = beginner.prev).kind)
+							tbp.closeBeginner self
+						else
+							case (tt = beginner.prev).kind
+							when :on_rparen
+								case (ttt = tt.beginner.prev).kind
+								when :"&.", :on_period  # foo&.(...){...}, foo.(...){...}
+									######## (Table1, Table2)::{....}
+									beginner.iterator_method = ttt
+									# &.(...){...} -> NG
+									# .(...){...} -> OK
+								when :"::" #foo::(...){...}
+									raise Error.new("foo::(...){...} is not implemented")
+								else 
+									unless beginner.iterator_method = ttt.trySetupIterator(:back, beginner.argEnd, self) # foo:label(...){...}
+										raise Error.new("cannot find iterator method like 'foo' in 'foo(...){...}'") # foo(...){...}
+									end
+								end
+								# foo'(...){...}
+								# foo"(...){...}
+								# foo."(...)(...){...}
+								# .(...){...}
+							when :on_rbracket
+								beginner.iterator_method = tt.beginner # a[...]{...} ':[]' is iterator method
+							else
+								beginner.iterator_method = tt.trySetupIterator(:back, beginner.argEnd, self) # foo:label{...}
+									raise Error.new("cannot find iterator method like 'foo' in 'foo{...}'") # foo {...}
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+	module OnHeredocEnd
+		def onClassify
+			reserve_spop
+		end
+	end
+	SET_LINE = ".__set_line_num__()"
+	module OnTstringEnd
+		def onClassify
+			case parent.kind
+			when :on_tstring_beg
+				addModAfter SET_LINE
+				reserve_spop
+			when :on_qwords_beg, :on_words_beg, :on_symbeg, :on_qsymbols_beg, :on_symbols_beg, :on_backtick
+				reserve_spop
+			else
+				raise Error.new("ERROR: String content closing at #{t.pos} is missing beginning\n")
+			end
+			if cur.parStack.size == 0 && mode.to_s =~ /_quote$/
+				yield first # do not return : raise Retart.new
+			end
+		end
+	end
+	module OnLabelEnd
+		def onClassify
+			if parent.kind == :on_tstring_beg
+				reserve_spop
+			else
+				raise Error.new("ERROR: String content closing at #{t.pos} is missing beginning\n")
+			end
+		end
+	end
+	module OnRegexpEnd
+		def onClassify
+			if parent.kind == :on_regexp_beg
+				reserve_spop
+			else
+				raise Error.new("ERROR: Reglar expression closing at #{t.pos} is missing beginning\n")
+			end
+		end
+	end
+
+	module BackSlashOp
+		::Token.registerModule self, :"\\" 
+		def closeBeginner pi
+			c = iteratorMethod
+			barg_op = argRange ? "|" : ""
+			addModReplace "do #{barg_op}"
+			argEnd.addModPrev barg_op
+			if c
+				ins = c.trySetupIterator(:preset, self) || "end"
+			else
+				addModReplace " ::Kernel::proc do #{barg_op}\n"
+				argEnd.addModPrev barg_op
+				ins = "end"
+				if isSentenceHead?
+					if !argRange
+						ins += ".call"
+					else
+						raise Error.new("orphan proc with argumnents")
+					end
+				end
+			end
+			ins
+		end
+		def checkStarter
+			if prev.continues? || isSentenceHead?
+				reserve_spush # without method
+			else
+				if (iteratorMethod = parent&.iteratorCand)&.setupIteratorLabel
+					parent.iteratorCand = nil
+					reserve_spush
+				else
+					raise Error.new("cannot find iterator method")
+				end
+			end
+		end
+	end
+
+	module OnPeriod
+		::Token.registerModule self, :"&.", :"::"
+		def themeExpr tk
+			case tk
+			when :"&."
+				"___theme_period"
+			when :"::"
+				"___theme_double_colon"
+			when :on_period
+				"___theme_period"
+			end
+		end
+		private :themeExpr
+		def closeBeginner pi
+			bOpener, bCloser = if pi.kind != :on_rbrace
+				"{", "}"
+			else
+				"", ""
+			end
+			if prev.kind == :on_rparen && prev.beginner.isOperand?
+				if kind == :"&." &&  prev.beginner.multiArgument?
+					raise Error.new("multiple theme for &. is not allowed")
+				end
+				# (Table1, Table2)::\n ... -> ____theme_double_colon___(Table1, Table2){ ... }
+				prev.beginner.addModPrev themeExpr(kind)
+				addModReplace bOpener
+			else # a::\n ...  -> a::____theme_double_colon___{ ... }
+				addModAfter, themeExpr(kind) + bOpener
+			end
+			############ implement ".",  "@foo", "&&"
+			ins = bCloser
+		end
+	end
+
+	module OnTlambda
+		def onClassify
+			reserve_spush
+		end
+		def closeBeginner pi
+			case @body
+			when :on_lambeg
+				"}"
+			when :do
+				"end"
+			when nil
+				if argEnd != :on_nl
+					raise Error.new("descrepant -> args")
+				end
+				argEnd.addModAfter "{"
+				ins = "}"
+			end
+		end
+	end
+
+	module Do
+		def onClassify
+			if !isOperand?
+				t = self
+				@parent.instance_eval do
+					case @kind
+					when :while, :until, :for_in
+						if !@do && @argStart
+							@do = t
+							@argEnd ||= t
+							return
+						end
+					when :on_tlambda
+						if !@body
+							@body = t
+							return
+						end
+					end
+				end
+				@iteratorMethod = parent.iteratorCand
+			end
+			reserve_spush
+		end
+		def setPostTest t
+			@wrapped.changeEntity t
+			kind = :post_test_do
+			t.kind = ("post_test_" + t.kind.to_s).intern
+		end
+		def closeBeginner pi
+			if c = iteratorMethod
+				if parent.iteratorCand == c
+					parent.iteratorCand = nil
+				end
+				c.setupIteratorLabel
+				c.trySetupIterator(:preset, self, pi) || "end"
+			else
+				k = (lop = prev).kind
+				if k == :on_rbracket && lop.beginner.prev.terminal? # foo [...] do
+					@iteratorMethod = lop.beginner
+					"end"
+				elsif k == :on_rparen && (tt = lop.beginner.prev).invoker? # foo:label(...), (foo)":label(...), foo'(...)
+					tt.trySetupIterator(:back, self, pi) || "end" #tt.dprev = label of foo:label(...)
+				else
+					ins = "end"
+				end
+			end
+		end
+	end
+
+	Modules :While, :Until do
+		def closeBeginner pi
+			trySetupIterator(:forward, self, pi) || "end"
+		end
+	end
+
+
+	def thenRelated? t
+		if [:if, :elsif, :rescue, :unless, :when, :in].include?(@kind)
+			if @argStarted
+				(!@argEnd || @argEnd == t && t.kind == :on_semicolon || @argEnd.kind == :on_nl && @argEnd.prev == t)
+			end
+		end
+	end
+	def setThen t
+		if @then
+			raise Error.new("duplicated then")
+		end
+		@then = t
+		@argEnd ||= t
+	end
+	class OrphanContClause < ::Exception
+		def initialize msg
+			super "orphan #{msg}"
+		end
+	end
+	module Then
+		def onClassify
+			if parent.thenRelated?(prev_non_sp) # prev_non_sp : ';' or '\n'
+				parent.setThen self
+			else
+				raise OrphanContCause.new(str)
+			end
+		end
+	end
+
+	def clauseCont t
+		if requireArg?
+			raise Error.new("#{t.str} cluase without '#{@kind}' arguments or semicolon, new line")
+		end
+		@wrapped.changeEntity t
+	end
+	[:Else, :Elsif].each do |mod|
+		%{
+			module #{mod}
+				def onClassify
+					if continuedClause?
+						parent.clauseCont self
+					else
+						raise OrphanContClause.new(str)
+					end
+				end
+			end
+		}
+	end
+
+	Modules :If, :Unless, :Case, :Module, :Begin, :For, :Def do
+		def onClassify
+			reserve_spush
+		end
+	end
+
+	module Class
+		def onClassify
+			mth = findParent{%i{module class def origin}.include? _1.kind}
+			if defined?(Endless)
+				n = self.next
+			else
+				n = next_non_sp
+			end
+			if (if mth.kind == :def
+					n.kind == :<<
+				else
+					%i{<< on_const ::}.include? n.kind
+				end)
+			then
+				reserve_spush # singleton class
+			else # self.class
+				kind = :on_ident
+				addModPrev "self."
+			end
+		end
+	end
+
+	class ForWhen < Exception
+		def initialize arg
+			@whenOrIn = arg
+			super "'#{arg.str}' is directly placed after 'for'"
+		end
+	end
+
+	module In
+		def onClassify
+			if continuedClause?
+				t = self
+				@parent.instance_eval do
+					case @kind
+					when :in
+						if !@argEnd
+							raise Error.new("'in' clause started inside previous 'in' clause without arguments or semicolon, new line")
+						end
+					when :case
+						@kind = :non_free_case
+						if !@argStart
+							raise Error.new("'in' clause started inside previous 'case' clause without arguments or semicolon, new line")
+						end
+						@argEnd ||= t
+					end
+					@wrapped.changeEntity t
+				end
+			elsif parent.kind == :for && cur.idtStack.last == parent
+				if parent.argStart
+					parent.argEnd = self
+					parent.in = self
+					parent.kind = :loop_for
+					parent.wrapped.changeEntity self
+					@kind = :loop_for_in
+				else # for in ....
+					raise ForWhen.new(self)
+				end
+			else
+				raise OrphanContClause.new(str)
+			end
+		end
+	end
+
+	module When
+		def onClassify
+			if continuedClause?
+				t = self
+				@parent.instance_eval do
+					case @kind
+					when :when
+						if !@argEnd
+							raise Error.new("'when' clause started inside previous 'when' clause without arguments or semicolon, new line")
+						end
+					when :case
+						@kind = :non_free_case
+						if !@argStart
+							raise Error.new("'when' clause started inside previous 'case' clause without arguments or semicolon, new line")
+						end
+						@argEnd ||= t
+					end
+					@wrapped.changeEntity t
+				end
+			elsif parent.kind == :for && cur.idtStack.last == parent && !parent.argStart # for when ....
+				raise ForWhen.new(self)
+			else
+				raise OrphanContClause.new(str)
+			end	
+		end
+	end
+
+	Modules :Rescue, :Ensure do
+		def onClassify
+			if continuedClause?
+				t = self
+				@parent.instance_eval do
+					case @kind
+					when :def, :class, :module, :rescue
+						if !@argEnd
+							raise Error.new("else cluase without '#{@kind}' arguments or semicolon, new line")
+						end
+					when :begin
+					end
+					@wrapped.changeEntity t
+				end
+			else #independent rescue
+				raise OrphanContClause.new(str)
+			end
+		end
+	end
+
+	module NonFreeCase
+		def closeBeginner pi
+			"end"
+		end
+	end
+
+	module Case
+		def closeBeginner pi
+			raise ArgumentError.new("'case' missing 'when' or 'in'")
+		end
+	end
+
+end
+