root/lang/ruby/userscripts_org/trunk/bin/userjs @ 4445

#!/usr/bin/env ruby
# vim:ft=ruby:

require "optparse"
require "pathname"
require "userscripts_org"

class UserjsCommand
        VERSION = UserscriptsOrg::VERSION
        NAME    = "user.js"

        def self.run(argv)
                new(argv.dup).run
        end

        def initialize(argv)
                @argv = argv

                @subparsers = {
                        "help" => OptionParser.new { |opts|
                                opts.banner = <<-EOB.gsub(/^\t+/, "")
                                        Usage: #{NAME} help <subcommand>

                                        Show help of subcommand.
                                EOB
                        },

                        "list" => OptionParser.new { |opts|
                                opts.banner = <<-EOB.gsub(/^\t+/, "")
                                        Usage: #{NAME} list

                                        List your scripts.
                                EOB
                        },

                        "update" => OptionParser.new { |opts|
                                opts.banner = <<-EOB.gsub(/^\t+/, "")
                                        Usage: #{NAME} update <filename>

                                        Update <filename> script.
                                EOB
                        },

                        "create" => OptionParser.new { |opts|
                                opts.banner = <<-EOB.gsub(/^\t+/, "")
                                        Usage: #{NAME} create <filename>

                                        Create entry on userscripts.org with <filename> script.
                                EOB
                        },

                        "install" => OptionParser.new { |opts|
                                opts.banner = <<-EOB.gsub(/^\t+/, "")
                                        Usage: #{NAME} install [opts] <filename>

                                        Install <filename> script.
                                EOB

                                opts.separator ""

                                opts.separator "Options:"
                                opts.on('-l', '--symlink', "Replace installed file with symlink.") do
                                        @symlink = true
                                end
                        },

                }

                @parser = OptionParser.new do |parser|
                        parser.banner  = <<-EOB.gsub(/^\t+/, "")
                                Usage: #{NAME} <subcommand> <args>

                        EOB

                        parser.separator ""

                        parser.separator "Subcommands:"
                        @subparsers.keys.sort.each do |k|
                                parser.separator "#{parser.summary_indent}    #{k}"
                        end

                        parser.separator ""

                        parser.separator "Options:"
                        parser.on('--version', "Show version string `#{VERSION}'") do
                                puts VERSION
                                exit
                        end
                end
        end

        def run
                @parser.order!(@argv)
                if @argv.empty?
                        puts @parser.help
                        exit
                else
                        @subcommand = @argv.shift
                        method_name = "cmd_#{@subcommand}"
                        if self.respond_to?(method_name)
                                @subparsers[@subcommand].parse!(@argv)
                                self.send(method_name)
                        else
                                puts "Not implemented subcommand: `#{@subcommand}'."
                                puts
                                puts @parser.help
                        end
                end
        end

        def cmd_help
                subcommand, = @argv
                if subcommand
                        if @subparsers.key? subcommand
                                puts @subparsers[subcommand].help
                        else
                                puts "No such subcommand `#{subcommand}'"
                                puts @parser.help
                        end
                else
                        puts @parser.help
                end
        end

        def cmd_list
                usorg = login()
                usorg.list.each do |s|
                        puts "%8d: %s" % [s.uid, s.name]
                end
        end

        def cmd_update
                abort @subparsers[@subcommand].help if @argv.empty?
                content = File.read(@argv.first)
                name    = content[/@name\s+(.+)\s*/, 1]

                usorg = login()
                warn "Update..."
                usorg.update(name, content)
        end

        def cmd_create
                abort @subparsers[@subcommand].help if @argv.empty?
                content = File.read(@argv.first)

                usorg = login()
                warn "Update..."
                usorg.create(content)
        end

        def cmd_install
                abort @subparsers[@subcommand].help if @argv.empty?
                file = Pathname.new(@argv.first).realpath
                prev = scan
                install_userjs(file)
                return unless @symlink
                installed = catch(:break) {
                        loop do
                                scan.each do |f,time|
                                        if prev.key?(f)
                                                throw :break, f unless prev[f] == time 
                                        else
                                                throw :break, f
                                        end
                                end
                                sleep 1
                        end
                }
                puts "#{file} was installed as #{installed}."
                puts "#{installed} will be replaced with symlink to #{file}."

                FileUtils.symlink(file, installed, :force => true)
                puts "done"
        end


        private
        def login
                warn "Logging in..."
                UserscriptsOrg.new(Pit.get("userscripts.org", :require => {
                        "username" => "username",
                        "password" => "password"
                })).login
        end

        def profile_dir
                dir = nil
                case RUBY_PLATFORM
                when /darwin/
                        dir = "~/Library/Application Support/Firefox/Profiles"
                when /win/
                        dir = "~/Application Data/Mozilla/Firefox/Profiles"
                when
                        dir = "~/.mozilla/firefox"
                end
                Pathname.new(dir).expand_path
        end

        def scan
                Pathname.glob(profile_dir + "*/gm_scripts/**/*.user.js").inject({}) {|r,i|
                        r[i] = i.mtime
                        r
                }
        end

        def install_userjs(path)
                case RUBY_PLATFORM
                when /darwin/
                        system("open", "-a", "Firefox", path.to_s)
                when /win/
                        abort "Not supported OS #{RUBY_PLATFORM}"
                when
                        system("firefox", path.to_s)
                end
                puts "Complete the install on Firefox"
        end
end


UserjsCommand.run(ARGV)