git_helpers 0.1.0 → 0.2

data/lib/git_helpers/raw_helpers.rb

@@ -0,0 +1,105 @@
+
+module GitHelpers
+	#these raw helpers are not called since we usually use higher level
+	#commands that provide all infos at once
+	class GitDir
+		#are we in a git folder?
+		def raw_git?(quiet: false)
+			launch="git rev-parse"
+			launch=launch + " 2>/dev/null" if quiet
+			with_dir do
+				system launch
+				return DR::Bool.to_bool($?)
+			end
+		end
+
+		#are we in .git/?
+		def raw_gitdir?
+			with_dir do
+				return DR::Bool.to_bool(%x/git rev-parse --is-inside-git-dir/)
+			end
+		end
+		#are we in the worktree?
+		def raw_worktree?
+			with_dir do
+				return DR::Bool.to_bool(%x/git rev-parse --is-inside-work-tree/)
+			end
+		end
+		#are we in a bare repo?
+		def raw_bare?
+			with_dir do
+				return DR::Bool.to_bool(%x/git rev-parse --is-bare-repository/)
+			end
+		end
+		
+		#return the absolute path of the toplevel
+		def raw_toplevel
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-toplevel/.chomp)
+			end
+		end
+		#relative path from toplevel to @dir
+		def raw_prefix
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-prefix/.chomp)
+			end
+		end
+		#return the relative path from @dir to the toplevel
+		def raw_relative_toplevel
+			with_dir do
+				return Pathname.new(%x/git rev-parse --show-cdup/.chomp)
+			end
+		end
+		#get path to .git directory (can be relative or absolute)
+		def raw_gitdir
+			with_dir do
+				return Pathname.new(%x/git rev-parse --git-dir/.chomp)
+			end
+		end
+	end
+
+	class GitBranch
+		def raw_rebase?
+			@gitdir.with_dir do
+				rb=%x/git config --bool branch.#{@branch.shellescape}.rebase/.chomp!
+				rb||=%x/git config --bool pull.rebase/.chomp!
+				return rb=="true"
+			end
+		end
+
+		def raw_remote
+			@gitdir.with_dir do
+				rm=%x/git config --get branch.#{@branch.shellescape}.remote/.chomp!
+				rm||="origin"
+				return rm
+			end
+		end
+
+		def raw_push_remote
+			@gitdir.with_dir do
+				rm= %x/git config --get branch.#{@branch.shellescape}.pushRemote/.chomp! || 
+				%x/git config --get remote.pushDefault/.chomp! ||
+				remote
+				return rm
+			end
+		end
+
+		def raw_upstream
+			@gitdir.with_dir do
+				up=%x/git rev-parse --abbrev-ref #{@branch.shellescape}@{u}/.chomp!
+				return new_branch(up)
+			end
+		end
+
+		def raw_push
+			@gitdir.with_dir do
+				pu=%x/git rev-parse --abbrev-ref #{@branch.shellescape}@{push}/.chomp!
+				return new_branch(pu)
+			end
+		end
+
+		def raw_hash
+			@hash||=`git rev-parse #{@branch.shellescape}`.chomp!
+		end
+	end
+end

data/lib/git_helpers/stats.rb

@@ -0,0 +1,183 @@
+module GitHelpers
+	
+	module GitStats
+		#Note: stats-authors give the same result, should be faster, and handle mailcap
+		#inspired by git-mainline//git-rank-contributors
+		def stats_diff(logopts=nil)
+			lines = {}
+
+			with_dir do
+				author = nil
+				state = :pre_author
+				DR::Encoding.fix_utf8(`git log #{DefaultLogOptions} -p #{logopts}`).each_line do |l|
+					case
+					when (state == :pre_author || state == :post_author) && m=l[/Author: (.*)$/,1]
+						#TODO: using directly author=l[]... seems to only affect a block scoped author variable
+						author=m
+						state = :post_author
+						lines[author] ||= {added: 0, deleted: 0, all: 0}
+					when state == :post_author && l =~ /^\+\+\+\s/
+						state = :in_diff
+					when state == :in_diff && l =~ /^[\+\-]/
+						unless l=~ /^(\+\+\+|\-\-\-)\s/
+							lines[author][:all] += 1 
+							lines[author][:added] += 1	if l[0]=="+"
+							lines[author][:deleted] += 1 if l[0]=="-"
+						end
+					when state == :in_diff && l =~ /^commit /
+						state = :pre_author
+					end
+				end
+			end
+			lines
+		end
+
+		def output_stats_diff(logopts=nil)
+			lines=stats_diff(logopts)
+			lines.sort_by { |a, c| -c[:all] }.each do |a, c|
+				puts "#{a}: #{c[:all]} lines of diff (+#{c[:added]}/-#{c[:deleted]})"
+			end
+		end
+
+		# inspired by visionmedia//git-line-summary
+		def stats_lines(file)
+			out=""
+			with_dir do
+				out,_suc=SH.run_simple("git", "blame", "--line-porcelain", file, quiet: true)
+			end
+			r={}
+			begin
+			out.each_line do |l|
+					l.match(/^author (.*)/) do |m|
+						r[m[1]]||=0
+						r[m[1]]+=1
+					end
+				end
+			rescue => e
+				warn "Warning: #{e} on #{file}"
+			end
+			r
+		end
+
+		def stats_lines_all
+			r={}
+			all_files.select {|f| SH::Pathname.new(f).text? rescue false}.each do |f|
+				stats_lines(f).each do |k,v|
+					r[k]||=0
+					r[k]+=v
+				end
+			end
+			r
+		end
+
+		def output_stats_lines
+			stats=stats_lines_all
+			total=stats.values.sum
+			stats.sort_by{|k,v| -v}.each do |k,v|
+				puts "- #{k}: #{v} (#{"%2.1f%%" % (100*v/total.to_f)})"
+			end
+			puts "Total lines: #{total}"
+		end
+
+		#Inspired by https://github.com/esc/git-stats/blob/master/git-stats.sh
+		def stats_authors(logopts=nil, more: false)
+			require 'set'
+			#Exemple: --after=..., --before=...,
+			#  -w #word diff
+			#  -C --find-copies-harder; -M
+			authors={}
+			with_dir do
+				%x/git shortlog -sn #{logopts}/.each_line do |l|
+					commits, author=l.chomp.split(' ', 2)
+					authors[author]={commits: commits.to_i}
+				end
+
+				if more
+					authors.each_key do |a|
+						tot_a=0; tot_r=0; tot_rename=0; files=Set.new
+						%x/git log #{DefaultLogOptions} #{logopts} --numstat --format="%n" --author='#{a}'/.each_line do |l|
+							added, deleted, file=l.chomp.split(' ',3)
+							#puts "#{l} => #{added}, #{deleted}, #{rest}"
+							tot_a+=added.to_i; tot_r+=deleted.to_i
+							next if file.nil?
+							if file.include?(' => ')
+								tot_rename+=1
+							else
+								files.add(file) unless file.empty?
+							end
+						end
+						#rev-list should be faster, but I would need to use 
+						# `git rev-parse --revs-only --default HEAD #{logopts.shelljoin}`
+						# to be sure we default to HEAD, and 
+						# `git rev-parse --flags #{logopts.shelljoin}` to get the log flags...
+						#tot_merges=%x/git rev-list #{logopts} --merges --author='#{a}'/.each_line.count
+						tot_merges=%x/git log --pretty=oneline #{logopts} --merges --author='#{a}'/.each_line.count
+						authors[a].merge!({added: tot_a, deleted: tot_r, files: files.size, renames: tot_rename, merges: tot_merges})
+					end
+				end
+			end
+			authors
+		end
+
+		def output_stats_authors(logopts=nil)
+			authors=stats_authors(logopts, more: true)
+			authors.each do |a,v|
+				puts "- #{a}: #{v[:commits]} commits (+#{v[:added]}/-#{v[:deleted]}), #{v[:files]} files modified, #{v[:renames]} renames, #{v[:merges]} merges"
+			end
+		end
+
+		#inspired by visionmedia//git-infos
+		def infos
+			with_dir do
+				puts "## Remote URLs:"
+				puts
+				system("git --no-pager remote -v")
+				puts
+				
+				puts "## Remote Branches:"
+				puts
+				system("git --no-pager  branch -r")
+				puts
+				
+				puts "## Local Branches:"
+				puts
+				system("git --no-pager  branch")
+				puts
+				
+				puts "## Most Recent Commit:"
+				puts
+				system("git --no-pager log --max-count=1 --pretty=short")
+				puts
+			end
+		end
+
+		#inspired by visionmedia//git-summary
+		def summary(logopts=nil)
+			with_dir do
+				project=Pathname.new(%x/git rev-parse --show-toplevel/).basename
+				authors=stats_authors(logopts)
+				commits=authors.map {|a,v| v[:commits]}.sum
+				file_count=%x/git ls-files/.each_line.count
+				active_days=%x/git log --date=short --pretty='format: %ad' #{logopts}/.each_line.uniq.count
+				#This only give the rep age of the current branch; and is not
+				#efficient since we generate the first log
+				#A better way would be to get all the roots commits via
+				#    git rev-list --max-parents=0 HEAD
+				#and then look at their ages
+				repository_age=%x/git log --reverse --pretty=oneline --format="%ar" #{logopts}/.each_line.first.sub!('ago','')
+				#total= %x/git rev-list #{logopts}/.each_line.count
+				total=%x/git rev-list --count #{logopts.empty? ? "HEAD" : logopts.shelljoin}/.to_i
+
+				puts " project  : #{project}"
+				puts " repo age : #{repository_age}"
+				puts " active   : #{active_days} days"
+				puts " commits  : #{commits}"
+				puts " files    : #{file_count}"
+				puts " authors  : #{authors.keys.join(", ")} (Total: #{total})"
+				authors.each do |a,v|
+					puts " - #{a}: #{v[:commits]} (#{"%2.1f" % (100*v[:commits]/commits.to_f)}%)"
+				end
+			end
+		end
+	end
+end

data/lib/git_helpers/status.rb

@@ -0,0 +1,404 @@
+module GitHelpers
+	# status helper
+	module GitStatus
+
+		#get the stash commits
+		def stash
+			if run_success("git rev-parse --verify refs/stash", quiet: true)
+				return run_simple("git rev-list -g refs/stash")
+			else
+				return nil
+			end
+		end
+
+		def sequencer(extra_infos=true)
+			read_helper=lambda do |file, ref: false; u|
+				if file.readable?
+					u=file.read.chomp
+					u.sub!(/^refs\/heads\//,"") if ref
+				end
+				u
+			end
+			rb_helper=lambda do |dir; name, onto, rbname, extra|
+				name=read_helper[gitdir+"#{dir}/head-name", ref: true]
+				onto=read_helper[gitdir+"#{dir}/onto", ref: true]
+				onto=branch(onto).name(highlight_detached: "") if onto
+				rbname=""
+				rbname << name if name
+				rbname << "->#{onto}" if onto
+				if dir == "rebase-merge"
+					cur=read_helper[gitdir+"#{dir}/msgnum"]
+					last=read_helper[gitdir+"#{dir}/end"]
+				elsif dir == "rebase-merge"
+					cur=read_helper[gitdir+"#{dir}/next"]
+					last=read_helper[gitdir+"#{dir}/last"]
+				end
+				extra=[]; extra << rbname unless rbname.empty?;
+				extra << "#{cur}/#{last}" if cur and last
+				extra
+			end
+			r=[]; r_extra=[]
+			append=lambda do |seq, extra=""|
+				r << seq
+				if extra_infos
+					extra="" if extra.nil?
+					if extra.is_a?(Array)
+						extra=extra.join(":")
+					end
+					extra = extra.empty? ? "" : "(#{extra})"
+					r_extra << "#{seq}#{extra}"
+				end
+			end
+			rb_handler=lambda do |state, mode; extra|
+				if mode == :rbi
+					extra = rb_helper.call("rebase-merge") if extra_infos
+				elsif mode==:am
+					extra = rb_helper.call("rebase-apply") if extra_infos
+				end
+				append.call(state, extra)
+			end
+
+			gitdir=self.gitdir
+			if bare?
+				append.call 'bare'
+			else
+				append.call '.git' if gitdir?
+			end
+			if gitdir.to_s =~ /\/.git\/modules\//
+				append.call 'sub'
+			elsif gitdir.to_s =~ /\/.git\/worktrees\//
+				append.call 'wt'
+			end
+
+			return r unless gitdir
+			if (gitdir+"index.lock").file?
+				append.call "ci" #commit in progress
+			end
+			if (gitdir+"rebase-merge").directory?
+				state=
+				if (gitdir+"rebase-merge/interactive").file?
+					if (gitdir+"rebase-merge/rewritten").exist?
+						"rb-im" #REBASE-im $ rebase -p -i
+					else
+						"rb-i" #REBASE-i
+					end
+				else
+					"rb-m" #REBASE-m $ rebase -p
+				end
+				rb_handler.call(state, :rbi)
+			end
+			if (gitdir+"rebase-apply").directory?
+				state = 
+				if (gitdir+"rebase-apply/rebasing").file?
+					"rb" #RB
+				elsif (gitdir+"rebase-apply/applying").file?
+					"am" #AM
+				else
+					"am/rb" #AM/REBASE (should not happen)
+				end
+				rb_handler.call(state, :am)
+			end
+			if (gitdir+"MERGE_HEAD").file?
+				append.call "mg" #MERGING
+			end
+			if (gitdir+"CHERRY_PICK_HEAD").file?
+				state= "ch" #CHERRY-PICKING
+				name=read_helper[gitdir+"CHERRY_PICK_HEAD", ref: true]
+				name=branch(name).name(highlight_detached: "") if name
+				append.call state, name
+			end
+			if (gitdir+"REVERT_HEAD").file?
+				state=rv #REVERTING
+				name=read_helper[gitdir+"REVERT_HEAD", ref: true]
+				name=branch(name).name(highlight_detached: "") if name
+				append.call state, name
+			end
+			if (gitdir+"sequencer").directory?
+				append.call "seq" #when we have a multiple commits cherry-pick or revert
+				# TODO: read the 'todo' file to know if we are picking or reverting?
+			end
+			if (gitdir+"BISECT_LOG").file?
+				state="bi" #BISECTING
+				name=read_helper[gitdir+"BISECT_START", ref: true]
+				append.call state, name
+			end
+
+			if extra_infos == :both
+				return r, r_extra
+			elsif extra_infos
+				r_extra
+			else
+				r
+			end
+		end
+
+		def status(br='HEAD', ignored: nil, untracked: nil, branch: :full, files: true, sequencer: true, stash: true, detached_name: :detached_infos, **_opts)
+			l_branch={}
+			l_branch=self.branch(br).infos(detached_name: detached_name) if branch == :full
+			r={branch: l_branch}
+
+			if worktree?
+				paths={}
+				l_untracked=[]
+				l_ignored=[]
+				r.merge!({paths: paths, files_untracked: l_untracked, files_ignored: l_ignored})
+
+				staged=0
+				staged_sub=0
+				staged_nonsub=0
+				changed=0
+				changed_nonsub=0
+				changed_sub=0
+				subchanged=0
+				subcommited=0
+				conflicts=0
+
+				complete_infos=lambda do |infos; r|
+					r=[]
+					infos[:xy].each_char do |c|
+						case c
+						when '.'; r << :kept
+						when 'M'; r << :updated
+						when 'A'; r << :added
+						when 'D'; r << :deleted
+						when 'R'; r << :renamed
+						when 'C'; r << :copied
+						when 'U'; r << :unmerged
+						when 'T'; r << :type_change
+						end
+					end
+					infos[:index]=r[0]
+					infos[:worktree]=r[1]
+
+					sub=infos[:sub]
+					if sub[0]=="N"
+						infos[:submodule]=false
+					else
+						infos[:submodule]=true
+						infos[:sub_commited]=sub[1]=="C"
+						infos[:sub_modified]=sub[2]=="M"
+						infos[:sub_untracked]=sub[3]=="U"
+					end
+
+					unless r[0]==:kept or r[0]==:unmerged
+						staged +=1
+						infos[:submodule] ? staged_sub +=1 : staged_nonsub +=1
+					end
+
+					unless r[1]==:kept or r[1]==:unmerged
+						changed +=1
+						if infos[:submodule]
+							changed_sub +=1
+							subchanged +=1 if (infos[:sub_modified]||infos[:sub_untracked])
+							subcommited +=1 if infos[:sub_commited]
+							changed_nonsub +=1 unless (infos[:sub_modified]||infos[:sub_untracked]||infos[:sub_commited]) #for D or T
+
+						else
+							changed_nonsub +=1
+						end
+					end
+					conflicts+=1 if r[0]==:unmerged or r[1]==:unmerged
+
+					if (xscore=infos[:xscore])
+						if xscore[0]=="R"
+							infos[:rename]=true
+						elsif xscore[0]=="C"
+							infos[:copy]=true
+						end
+						infos[:score]=xscore[1..-1].to_i
+					end
+
+					infos
+				end
+
+				if files
+					call=%w(git status --porcelain=v2)
+					status_options=[]
+					status_options << "--branch" if branch and branch != :full
+					status_options << "--untracked-files" if untracked
+					status_options << "--untracked-files=no" if untracked==false
+					status_options << "--ignored" if ignored
+					status_options << "--ignored=no" if ignored==false
+					r[:status_options]=status_options + (branch == :full ? ['--branch'] : [])
+					out=run_simple((call+status_options).shelljoin, error: :quiet, chomp: :lines)
+					out.each do |l|
+						l.match(/# branch.oid\s+(.*)/) do |m|
+							l_branch[:oid]=m[1]
+						end
+						l.match(/# branch.head\s+(.*)/) do |m|
+							br_name=m[1]
+							if br_name=="(detached)" and detached_name
+								l_branch[:detached]=true
+								br_name=self.name_branch(method: detached_name, always: true)
+							else
+							end
+							l_branch[:name]=br_name
+						end
+						l.match(/# branch.upstream\s+(.*)/) do |m|
+							l_branch[:upstream]=m[1]
+						end
+						l.match(/# branch.ab\s+\+(\d*)\s+-(\d*)/) do |m|
+							l_branch[:upstream_ahead]=m[1].to_i
+							l_branch[:upstream_behind]=m[2].to_i
+						end
+
+						l.match(/1 (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (.*)/) do |m|
+							xy=m[1]; sub=m[2]; #modified data, submodule information
+							mH=m[3]; mI=m[4]; mW=m[5]; #file modes
+							hH=m[6]; hI=m[7]; #hash
+							path=m[8]
+							info={xy: xy, sub: sub, mH: mH, mI: mI, mW: mW, hH: hH, hI: hI}
+							paths[path]=complete_infos.call(info)
+						end
+
+						#rename copy
+						l.match(/2 (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (.*)\t(.*)/) do |m|
+							xy=m[1]; sub=m[2]; mH=m[3]; mI=m[4]; mW=m[5];
+							hH=m[6]; hI=m[7]; xscore=m[8]
+							path=m[9]; orig_path=m[10]
+							info={xy: xy, sub: sub, mH: mH, mI: mI, mW: mW, hH: hH, hI: hI,
+							xscore: xscore, orig_path: orig_path}
+							paths[path]=complete_infos.call(info)
+						end
+
+						# unmerged
+						l.match(/u (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (\S*) (.*)/) do |m|
+							xy=m[1]; sub=m[2]; #modified data, submodule information
+							m1=m[3]; m2=m[4]; m3=m[5]; mW=m[6] #file modes
+							h1=m[7]; h2=m[8]; h3=m[9] #hash
+							path=m[10]
+							info={xy: xy, sub: sub, m1: m1, m2: m2, m3: m3, mW: mW, h1: h1, h2: h2, h3: h3}
+							paths[path]=complete_infos.call(info)
+						end
+
+						l.match(/\? (.*)/) do |m|
+							l_untracked << m[1]
+						end
+						l.match(/! (.*)/) do |m|
+							l_ignored << m[1]
+						end
+					end
+					r[:conflicts]=conflicts
+					r[:staged]=staged
+					r[:staged_nonsub]=staged_nonsub
+					r[:staged_sub]=staged_sub
+					r[:changed]=changed
+					r[:changed_nonsub]=changed_nonsub
+					r[:changed_sub]=changed_sub
+					r[:subchanged]=subchanged
+					r[:subcommited]=subcommited
+					r[:untracked]=l_untracked.length
+					r[:ignored]=l_ignored.length
+				end
+			end
+
+			if branch
+				upstream=r.dig(:branch,'upstream')
+				push=r.dig(:branch,'push')
+				if upstream != push
+					r[:push_ahead]=r.dig(:branch,:push_ahead)
+					r[:push_behind]=r.dig(:branch,:push_behind)
+				end
+			end
+
+			if stash
+				r[:stash]=self.stash&.lines&.length
+			end
+			if sequencer
+				seq, seq_full=self.sequencer(:both) 
+				r[:sequencer]=seq
+				r[:full_sequencer]=seq_full
+			end
+			return r
+		end
+
+		#changed_submodule: do we show changed submodule apart?
+		def format_status(br='HEAD', status_infos=nil, changed_submodule: true, max_length: nil, **opts)
+			if status_infos.nil?
+				return "" unless git?
+				status_infos=self.status(br, **opts)
+			end
+			yield status_infos if block_given?
+			branch=status_infos.dig(:branch,:name) || ""
+			ahead=status_infos.dig(:branch,:upstream_ahead)||0
+			behind=status_infos.dig(:branch,:upstream_behind)||0
+			push_ahead=status_infos[:push_ahead]||0
+			push_behind=status_infos[:push_behind]||0
+			# detached=status_infos.dig(:branch,:detached) || false
+			allchanged=status_infos[:changed] ||0
+			if changed_submodule
+				changed=status_infos[:changed_nonsub] ||0
+				subchanged=status_infos[:subchanged] ||0
+				subcommited=status_infos[:subcommited] ||0
+			else
+				changed=status_infos[:changed] ||0
+			end
+			staged=status_infos[:staged] ||0
+			conflicts=status_infos[:conflicts] ||0
+			untracked=status_infos[:untracked] ||0
+			ignored=status_infos[:ignored] || 0
+			stash=status_infos[:stash]||0
+			clean=true
+			clean=false if staged != 0 || allchanged !=0 || untracked !=0 || conflicts !=0 || !worktree? || opts[:files]==false
+			sequencer=status_infos[:sequencer] || []
+			full_sequencer=status_infos[:full_sequencer] || []
+			if stash != 0
+				sequencer << "$#{stash}"
+				full_sequencer << "$#{stash}"
+			end
+
+			# "#{detached ? ":" : ""} # the ':' prefix is done by name now
+			left=
+			"#{branch}".color(:magenta,:bold) <<
+			(ahead==0 ? "" : "↑"<<ahead.to_s ) <<
+			(behind==0 ? "" : "↓"<<behind.to_s ) <<
+			(push_ahead==0 ? "" : "⇡"<<push_ahead.to_s) <<
+			(push_behind==0 ? "" : "⇣"<<push_behind.to_s)
+
+			files=
+			(staged==0 ? "" : "●"+staged.to_s).color(:red)  <<
+			(conflicts==0 ? "" : "✖"+conflicts.to_s).color(:red) <<
+			(changed==0 ? "" : "✚"+changed.to_s).color(:blue)  <<
+			(subcommited==0 ? "" : ("✦"+subcommited.to_s).color(:blue)) <<
+			(subchanged==0 ? "" : ("✧"+subchanged.to_s).color(:blue)) <<
+			(untracked==0 ? "" : "…" +
+			 (opts[:untracked].to_s=="full" ? untracked.to_s : "")
+			).color(:blue) <<
+			(ignored==0 ? "" : "ꜟ" + #❗
+			 (opts[:ignored].to_s=="full" ? ignored.to_s : "")
+			).color(:blue) <<
+			(clean ? "✔".color(:green,:bold) : "")
+
+			extra=full_sequencer.join(" ").color(:yellow)
+
+			length=lambda do
+				left.uncolor.size+files.uncolor.size+extra.uncolor.size
+			end
+			shortened=false
+			if max_length
+				if length.call > max_length
+					extra=sequencer.join(" ").color(:yellow)
+				end
+				if length.call > max_length
+					shortened=true unless extra.empty?
+					extra=""
+				end
+				if length.call > max_length
+					shortened=true unless files.empty?
+					files=""
+				end
+			end
+			right=files
+			unless extra.empty?
+				right << " " unless right.empty?
+				right << extra 
+			end
+
+			r="(" << left <<
+				(right.empty? ? "" : "|" ) << right <<
+				(shortened ? "⋯" : "") <<
+				")"
+			r
+		end
+	end
+end