400 lines
8.3 KiB
Ruby
Executable File
400 lines
8.3 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
|
|
Main = self
|
|
public
|
|
|
|
require 'Paludis'
|
|
require 'getoptlong'
|
|
require 'pathname'
|
|
require 'shellwords'
|
|
require 'readline'
|
|
begin
|
|
require 'irb-pager'
|
|
rescue LoadError
|
|
STDERR.puts <<EOF
|
|
Loading IRB::Pager failed. Please install it first:
|
|
sudo gem install irb-pager
|
|
EOF
|
|
raise
|
|
end
|
|
|
|
include Paludis
|
|
|
|
class Object
|
|
def with &block
|
|
yield self
|
|
end
|
|
def self.with &block
|
|
yield self
|
|
end
|
|
end
|
|
|
|
def path_cmd cmd
|
|
ENV['PATH'].split( ':').each do |dir|
|
|
dir = Pathname.new dir
|
|
next unless dir.directory?
|
|
dir.each_child {|f| return f if cmd == f.basename.to_s and f.file? }
|
|
end
|
|
nil
|
|
end
|
|
|
|
def system *a
|
|
Kernel.system *a.map(&:to_s)
|
|
end
|
|
|
|
class UsageError <Exception
|
|
end
|
|
|
|
class NoSelection <UsageError
|
|
def initialize x = nil
|
|
super( x || 'Select a file first.')
|
|
end
|
|
end
|
|
|
|
if cmd = ENV['ECLECTIC_CONFIG_DIFF_COMMAND']
|
|
def diff( f1, f2) system "#{cmd} #{Shellwords.escape f1} #{Shellwords.escape f2}" end
|
|
elsif path_cmd 'git'
|
|
def diff( f1, f2) system *%w[git --no-pager --git-dir=: diff --color-words], f1, f2 end
|
|
elsif path_cmd 'colordiff'
|
|
def diff( f1, f2) system 'colordiff', f1, f2 end
|
|
else
|
|
def diff( f1, f2) system 'diff', f1, f2 end
|
|
end
|
|
|
|
Log.instance.with do |nst|
|
|
nst.log_level = LogLevel::Warning
|
|
nst.program_name = $0
|
|
end
|
|
|
|
env = EnvironmentFactory.instance.create ''
|
|
dirs = Pathname.new( env.fetch_repository( 'installed')['location'].parse_value).join( '.cache', 'all_CONFIG_PROTECT').each_line.map {|l| Pathname.new l.chomp }
|
|
|
|
def find_cfgs dirs, &exe
|
|
block_given? or return to_enum( __method__, dirs)
|
|
dirs.each do |dir|
|
|
dir.find do |e|
|
|
yield e if /^\._cfg...._/ =~ e.basename.to_s and e.file?
|
|
end if dir.exist?
|
|
end
|
|
end
|
|
|
|
def accept_cfg config, update
|
|
now = Time.now
|
|
now = Time.at now+1 while (backup = config.dirname + "._cfg_backuped_#{now.strftime '%FT%T'}_#{config.basename}").exist?
|
|
puts "#{config}: backup to [#{backup}]"
|
|
config.rename backup
|
|
puts "#{config}: accept [#{update}]"
|
|
update.rename config
|
|
end
|
|
|
|
def reject_cfg config, update
|
|
now = Time.now
|
|
now = Time.at now+1 while (backup = config.dirname + "._cfg_rejected_#{now.strftime '%FT%T'}_#{config.basename}").exist?
|
|
puts "#{config}: reject [#{update}] backup to [#{backup}]"
|
|
update.rename backup
|
|
end
|
|
|
|
def list_keys cmds
|
|
len = cmds.keys.map do |cmd|
|
|
cmd.map {|c| c.sub( /(?<!\\)\\/, '').gsub "\\\\", "\\" }.join( ', ').length
|
|
end.max+2
|
|
cmds.each do |cmd, text|
|
|
l = cmd.map {|c| c.sub( /(?<!\\)\\/, '').gsub "\\\\", "\\" }.join( ', ').length
|
|
cmd = cmd.map do |c|
|
|
c.sub( /(?<!\\)\\([^\\])/, "\e[1m\\1\e[0m").gsub "\\\\", "\\"
|
|
end.join ', '
|
|
printf " [%s]%s%s\n", cmd, ' '*(len-l), text
|
|
end
|
|
end
|
|
|
|
def list_cfgs selected, list
|
|
keys = {}
|
|
list.keys.sort.map do |i|
|
|
file = list[i]
|
|
keys[["\\#{i}"]] = (selected == file ? '* ' : '')+file.to_s
|
|
end
|
|
list_keys keys
|
|
end
|
|
|
|
class Commands < Hash
|
|
class Builder
|
|
def initialize cmds
|
|
@cmds = cmds
|
|
end
|
|
|
|
def self.build cmds, &run
|
|
r = new cmds
|
|
r.instance_eval &run
|
|
r
|
|
end
|
|
|
|
def help text = nil
|
|
@help = text
|
|
end
|
|
|
|
def on *names, &run
|
|
options = names.last.is_a?( Hash) ? names.pop.dup : {}
|
|
names = names.flatten.compact
|
|
if names.empty?
|
|
@fallback_cmd = Cmd.new nil, @help, run
|
|
else
|
|
cmd = Cmd.new names, @help, &run
|
|
names.each do |name|
|
|
name = name.to_s
|
|
if /\\(.)/ =~ name
|
|
@cmds[$1.to_sym] = cmd
|
|
name = name.gsub /\\/, ''
|
|
end
|
|
@cmds[name.to_sym] = cmd
|
|
end
|
|
end
|
|
ensure
|
|
@help = nil
|
|
end
|
|
end
|
|
|
|
class Cmd <Proc
|
|
attr_reader :names, :help
|
|
|
|
def initialize names, help, &exe
|
|
@names, @help = names, help
|
|
super &exe
|
|
end
|
|
end
|
|
|
|
class CommandError < Exception
|
|
end
|
|
class ExpectingCommandError < CommandError
|
|
def initialize *args
|
|
args = ['Command expected'] if args.empty?
|
|
super *args
|
|
end
|
|
end
|
|
class UnknownCommandError < CommandError
|
|
def initialize *args
|
|
args = ['This Command i do not know'] if args.empty?
|
|
super *args
|
|
end
|
|
end
|
|
|
|
attr_accessor :fallback_cmd
|
|
|
|
def self.new &builder
|
|
r = super()
|
|
Builder.build r, &builder
|
|
r
|
|
end
|
|
|
|
def === x
|
|
include?( x.to_sym) or super
|
|
end
|
|
|
|
def list_keys
|
|
h = {}
|
|
self.values.map {|c| h[c.names] = c.help }
|
|
Main::list_keys( h)
|
|
end
|
|
end
|
|
|
|
class FileList
|
|
attr_reader :found
|
|
def initialize found
|
|
@found = found
|
|
end
|
|
|
|
def list
|
|
return @list if @list
|
|
list = {}
|
|
found.each_with_index do |(file, cfgs), i|
|
|
i += 1
|
|
list[i] = file
|
|
cfgs.sort!
|
|
end
|
|
@list = list
|
|
end
|
|
end
|
|
|
|
class UI
|
|
attr_accessor :need_to_print
|
|
attr_reader :selected, :cmds, :list, :found, :dirs, :ignore_list
|
|
def selected= x
|
|
@selected, @need_to_print = x, !!x
|
|
end
|
|
|
|
def initialize cmds, dirs
|
|
@ignore_list = []
|
|
@cmds, @dirs = cmds, dirs
|
|
end
|
|
|
|
def prepare
|
|
@need_to_print = false
|
|
@found = Hash.new {|h,k| h[k] = [] }
|
|
@list = {}
|
|
find_cfgs( dirs).each do |cfg|
|
|
conf = cfg.dirname + cfg.basename.to_s.sub( /^\._cfg...._/, '')
|
|
next if ignore_list.include? conf
|
|
found[conf] += [cfg]
|
|
end
|
|
if found.empty?
|
|
puts "No files to update."
|
|
exit 0
|
|
end
|
|
found.each_with_index do |(file, cfgs), i|
|
|
i += 1
|
|
list[i] = file
|
|
cfgs.sort!
|
|
end
|
|
self.selected = nil unless found.has_key? selected
|
|
end
|
|
|
|
def run
|
|
prepare
|
|
prompt.chomp.split( /\s+/).each &method( :execute)
|
|
instance_eval &cmds[:diff] if need_to_print
|
|
rescue Interrupt
|
|
rescue UsageError
|
|
puts $!.message
|
|
end
|
|
|
|
def prompt
|
|
prompt =
|
|
if selected
|
|
"(cfg:\e[1m#{selected}\e[0m)# "
|
|
else
|
|
puts
|
|
list_cfgs selected, list
|
|
puts
|
|
"(select?)# "
|
|
end
|
|
Readline.completion_proc = lambda do |str|
|
|
reg = /^#{Regexp.quote str}/
|
|
list.keys.select {|i| reg =~ i.to_s } +
|
|
found.keys.grep( reg) +
|
|
cmds.keys.grep( reg) +
|
|
found.keys.select {|f| reg =~ f.basename.to_s }
|
|
end
|
|
line = Readline.readline( prompt, true) or exit
|
|
Readline::HISTORY.pop if /^\s*$/ =~ line or (Readline::HISTORY.length >= 2 && Readline::HISTORY[-2] == line)
|
|
line
|
|
end
|
|
|
|
def execute x
|
|
case x
|
|
when /^\d+$/
|
|
m = list[x.to_i]
|
|
raise UsageError, "Unknown index #{x}" unless m
|
|
self.selected = m
|
|
when cmds
|
|
instance_eval &cmds[x.to_sym]
|
|
else
|
|
m = Pathname.new x
|
|
unless (f = found[m]).empty?
|
|
self.selected = m
|
|
else
|
|
raise UsageError, "Unknown command #{x}"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
auto_action_file = Pathname.new '/etc/paludis/configs_auto_action'
|
|
|
|
cmds = Commands.new do
|
|
help 'Help'
|
|
on %w[\help \?] do
|
|
puts
|
|
cmds.list_keys
|
|
puts
|
|
end
|
|
|
|
help 'Displays difference of selected file'
|
|
on '\diff' do
|
|
raise NoSelection unless selected
|
|
puts
|
|
IRB::Pager::pager( pager: 'less -R') { diff selected, found[selected][0] }
|
|
puts
|
|
self.need_to_print = false
|
|
end
|
|
|
|
help 'List all files need updates'
|
|
on '\list' do
|
|
list_cfgs selected, list if selected
|
|
end
|
|
|
|
help 'Accepts selected file'
|
|
on %w[\accept \yes] do
|
|
raise NoSelection unless selected
|
|
accept_cfg selected, found[selected][0]
|
|
selected = nil
|
|
end
|
|
|
|
help 'Rejects selected file'
|
|
on %w[\reject \no] do
|
|
raise NoSelection unless selected
|
|
reject_cfg selected, found[selected][0]
|
|
selected = nil
|
|
end
|
|
|
|
help 'Ignore selected file for this session (do not anything with this file)'
|
|
on %w[\later \ignore] do
|
|
raise NoSelection unless selected
|
|
ignore_list.push selected
|
|
self.need_to_print = false
|
|
self.selected = nil
|
|
end
|
|
|
|
help 'Quit'
|
|
on %w[\quit \exit] do
|
|
exit 0
|
|
end
|
|
|
|
on 'auto-action' do
|
|
unless auto_action_file.exist?
|
|
raise UsageError, "No config for auto-action found: #{auto_action_file}"
|
|
end
|
|
auto_action_file.each_line do |line|
|
|
next if /^\s*#/ =~ line
|
|
action, file = line.chomp!.split( "\t", 2)
|
|
file = Pathname.new file
|
|
if found.has_key? file
|
|
case action
|
|
when *%w[a accept]
|
|
accept_cfg file, found[file][-1]
|
|
found[file][0...-1].each {|f| reject_cfg file, f }
|
|
when *%w[r reject]
|
|
found[file].each {|f| reject_cfg file, f }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
ui = UI.new cmds, dirs
|
|
|
|
opts = GetoptLong.new(
|
|
[ '-h', '--help', GetoptLong::NO_ARGUMENT ],
|
|
[ '-A', '--auto-action', GetoptLong::OPTIONAL_ARGUMENT ]
|
|
)
|
|
opts.ordering = GetoptLong::REQUIRE_ORDER
|
|
opts.each do |opt, arg|
|
|
case opt
|
|
when '-h'
|
|
puts <<EOF
|
|
Usage: #{ENV['cave']||'cave'} #{File.basename $0} [-h] [-A]
|
|
|
|
Without options, interactive user interface will be started
|
|
Options:
|
|
-A, --auto-action[=file] runs automatical actions from file or #{auto_action_file}
|
|
|
|
EOF
|
|
exit
|
|
when '-A'
|
|
auto_action_file = Pathname.new arg if arg and not arg.empty?
|
|
ui.prepare
|
|
ui.execute 'auto-action'
|
|
exit
|
|
end
|
|
end
|
|
|
|
loop { ui.run }
|