gitbak 0.2.0 → 0.3.0

data/README.md

@@ -0,0 +1,77 @@
+<!-- \{{{1 -->
+
+    File        : README
+    Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+    Date        : 2012-12-29
+
+    Copyright   : Copyright (C) 2012  Felix C. Stegerman
+    Version     : v0.3.0
+
+<!-- }}}1 -->
+
+## Description
+<!-- \{{{1 -->
+
+  gitbak - bitbucket/github/gist backup
+
+  GitBak allows you to mirror Bitbucket/GitHub/Gist repositories
+  easily; you only need to specify paths, users, and authentication in
+  ~/.gitbak and it does the rest.
+
+<!-- }}}1 -->
+
+## Usage
+<!-- \{{{1 -->
+
+    $ gitbak --help                 # read documentation
+    $ vim ~/.gitbak                 # configure
+    $ gitbak -v                     # mirror
+
+<!-- }}}1 -->
+
+## Installing
+<!-- \{{{1 -->
+
+    $ gem install gitbak            # rubygems
+
+  Get it at https://github.com/obfusk/gitbak.  Depends: git, ruby.
+
+<!-- }}}1 -->
+
+## TODO
+<!-- \{{{1 -->
+
+  Some things that may be useful/implemented at some point.
+
+  * ask password again on typo (^D) or auth fail
+  * tests?
+  * better error handling?
+
+  * custom services (should be easy to add already)
+  * metadata (issues, wikis, ...)
+  * teams/organisations
+  * starred repos/gists
+  * filtering
+  * oauth?
+
+  * specify ssh key(s)?
+  * https clone auth?
+
+<!-- }}}1 -->
+
+## License
+<!-- \{{{1 -->
+
+  GPLv2 [1].
+
+<!-- }}}1 -->
+
+## References
+<!-- \{{{1 -->
+
+  [1] GNU General Public License, version 2
+  --- http://www.opensource.org/licenses/GPL-2.0
+
+<!-- }}}1 -->
+
+<!-- vim: set tw=70 sw=2 sts=2 et fdm=marker : -->

data/bin/gitbak

@@ -1,118 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'gitbak'
-require 'optparse'
+require 'gitbak/exec'
 
-# --
-
-usage = 'gitbak [<option(s)>]'
-
-info = <<-END.gsub(/^ {2}/, '')                                 # {{{1
-  gitbak - bitbucket/github/gist backup
-
-  === Example Configuration ===
-
-    $ cat >> ~/.gitbak
-    dir = '/path/to/mirrors/dir'
-
-    %w{ user1 user2 }.each do |u|
-      GitBak::Cfg.auth      :bitbucket, u
-      GitBak::Cfg.auth      :github   , u
-
-      GitBak::Cfg.bitbucket "\#{dir}/\#{u}/bitbucket", u, auth: true
-      GitBak::Cfg.github    "\#{dir}/\#{u}/github"   , u, auth: true
-      GitBak::Cfg.gist      "\#{dir}/\#{u}/gist"     , u, auth: true
-    end
-    ^D
-
-
-  === Configuration Methods ===
-
-    GitBak::Cfg.auth        service, user[, password]
-    GitBak::Cfg.<service>   dir, user[, options]
-
-    * password is optional; gitbak prompts for unspecified passwords.
-    * The services are: bitbucket, github, gist.
-    * Service options:
-        :auth is optional; can be true (same user) or 'username'.
-        :method is optional; defaults to :ssh.
-    * Each GitBak::Cfg.<service> call specifies a new configuration.
-END
-                                                                # }}}1
-
-options = { cfgfile: "#{Dir.home}/.gitbak", verbose: false }
-
-# --
-
-OptionParser.new do |opts|                                      # {{{1
-  opts.banner = usage
-
-  opts.on('-c', '--config-file FILE', 'Configuration file') do |f|
-    options[:cfgfile] = f
-  end
-
-  opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
-    options[:verbose] = v
-  end
-
-  opts.on_tail('-h', '--help', 'Show this message') do
-    puts opts, '', info
-    exit
-  end
-
-  opts.on_tail('--version', 'Show version') do
-    puts "gitbak v#{GitBak::VERSION}"
-    exit
-  end
-end.parse!                                                      # }}}1
-
-GitBak.die "usage: #{usage}" unless ARGV.length == 0
-
-# --
-
-module GitBak                                                   # {{{1
-  module Cfg
-    CFG__ = { bitbucket: [], github: [], gist: [], auth: {} }
-
-    def self.auth (service, user, pass = nil)
-      (CFG__[:auth][service] ||= {})[user] = \
-        { user: user, pass: pass }
-    end
-
-    def self._service (name)
-      meta = class << self; self; end
-      meta.send(:define_method, name) do |dir, user, opts = {}|
-        CFG__[name] << opts.merge(dir: dir, user: user)
-      end
-    end
-
-    SERVICES.each do |name|
-      _service name.downcase.to_sym
-    end
-  end
-end                                                             # }}}1
-
-# --
-
-GitBak.die "Configuration file (#{options[:cfgfile]}) not found." \
-  unless GitBak.exists? options[:cfgfile]
-
-load options[:cfgfile]
-
-# --
-
-GitBak::SERVICES.each do |name|                                 # {{{1
-  key = name.downcase.to_sym
-  GitBak::Cfg::CFG__[:auth].fetch(key, []).each do |k, v|
-    p = "#{name} password for #{v[:user]}: "
-    v[:pass] ||= GitBak.prompt p, true
-  end
-end                                                             # }}}1
-
-GitBak::Cfg::CFG__[:auth][:gist] ||= GitBak::Cfg::CFG__[:auth][:github]
-
-# --
-
-GitBak.main GitBak::Cfg::CFG__.merge(options)
+GitBak::Executable.main
 
 # vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/gitbak/config.rb

@@ -0,0 +1,139 @@
+require 'gitbak/eval'
+require 'gitbak/misc'
+require 'gitbak/services'
+
+# --
+
+# gitbak namespace
+module GitBak
+
+  # configuration
+  module Config                                                 # {{{1
+
+    # configuration error
+    class ConfigError < GitBak::Error; end
+
+    # --
+
+    # description
+    INFO = 'gitbak - bitbucket/github/gist backup'
+
+    # configuration example
+    CONFIG_EX = <<-END.gsub(/^ {6}/, '')                        # {{{2
+      === Example Configuration ===
+
+        $ cat >> ~/.gitbak
+        dir = '/path/to/mirrors/dir'
+
+        GitBak.configure do |auth, repos|
+          %w{ user1 user2 }.each do |u|
+            repos.bitbucket "\#{dir}/\#{u}/bitbucket", u, auth: true
+            repos.github    "\#{dir}/\#{u}/github"   , u, auth: true
+            repos.gist      "\#{dir}/\#{u}/gist"     , u, auth: true
+          end
+        end
+        ^D
+
+
+      === Configuration Methods ===
+
+        auth.<service>    user[, password]
+        repos.<service>   dir, user[, options]
+
+
+      The (default) services are: bitbucket, github, gist.
+      If a password is not specified, gitbak will prompt for it.
+
+
+      === Optional Repository Options ===
+
+        :auth     can be true (same user) or 'username'.
+        :method   defaults to :ssh.
+    END
+                                                                # }}}2
+
+    # --
+
+    # configuration base class
+    class ServiceCfg                                            # {{{2
+      # data
+      attr_reader :_data
+
+      # init
+      def initialize
+        @_data = {}
+      end
+
+      # pass on to _service or super
+      def method_missing (meth, *args, &block)
+        if GitBak::Services::SERVICES.include? meth
+          _service meth, *args
+        else
+          super
+        end
+      end
+    end                                                         # }}}2
+
+    # authentication configuration
+    class AuthCfg < ServiceCfg                                  # {{{2
+      # set service auth
+      def _service (name, user, pass = nil)
+        (@_data[name] ||= {})[user] = { user: user, pass: pass }
+      end
+    end                                                         # }}}2
+
+    # repository configuration
+    class ReposCfg < ServiceCfg                                 # {{{2
+      # set service repo
+      def _service (name, dir, user, opts = {})
+        c = opts.merge dir: dir, user: user
+        c[:auth] = c[:user] if c[:auth] == true
+        (@_data[name] ||= []) << c
+      end
+    end                                                         # }}}2
+
+    # authentication and repository configuration
+    class Cfg                                                   # {{{2
+      # data
+      attr_reader :auth, :repos
+
+      # init
+      def initialize
+        @auth   = AuthCfg.new
+        @repos  = ReposCfg.new
+      end
+
+      # get data
+      def data                                                  # {{{3
+        auth  = @auth._data
+        repos = @repos._data
+
+        { auth: auth, repos: repos }
+      end                                                       # }}}3
+    end                                                         # }}}2
+
+    # --
+
+    # load configuration file
+    def self.load (file)                                        # {{{2
+      cfg = eval File.read(file), GitBak::Eval.new.binding, file # ???
+
+      raise ConfigError,  "[#{file}] isn't a GitBak::Config::Cfg " \
+                          "(#{cfg.class} instead)." \
+        unless Cfg === cfg
+
+      cfg
+    end                                                         # }}}2
+
+  end                                                           # }}}1
+
+  # configure
+  def self.configure (&block)
+    cfg = Config::Cfg.new
+    block[cfg.auth, cfg.repos]
+    cfg
+  end
+
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/gitbak/eval.rb

@@ -0,0 +1,6 @@
+module GitBak
+  # evaluation wrapper
+  class Eval
+    public :binding
+  end
+end

data/lib/gitbak/exec.rb

@@ -0,0 +1,85 @@
+require 'gitbak'
+require 'gitbak/config'
+
+require 'optparse'
+
+# --
+
+# gitbak namespace
+module GitBak
+  # command-line executable
+  module Executable
+
+    # command-line usage
+    USAGE = 'gitbak [<option(s)>]'
+
+    # parse command line options; die on failure
+    def self.parse_options (args)                               # {{{1
+      args_   = args.dup
+      options = { cfgfile: "#{Dir.home}/.gitbak", verbose: false,
+                  noact: false }
+
+      op = OptionParser.new do |opts|                           # {{{2
+        opts.banner = USAGE
+
+        opts.on('-c', '--config-file FILE',
+                'Configuration file') do |x|
+          options[:cfgfile] = x
+        end
+
+        opts.on('-v', '--[no-]verbose', 'Run verbosely') do |x|
+          options[:verbose] = x
+        end
+
+        opts.on('-n', '--no-act', 'List w/o mirroring') do |x|
+          options[:noact] = !x
+        end
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts GitBak::Config::INFO, '', opts
+          exit
+        end
+
+        opts.on_tail('-e', '--example',
+                     'Show example configuration') do
+          puts GitBak::Config::CONFIG_EX
+          exit
+        end
+
+        opts.on_tail('--version', 'Show version') do
+          puts "gitbak v#{GitBak::VERSION}"
+          exit
+        end
+      end                                                       # }}}2
+
+      begin
+        op.parse! args_
+      rescue OptionParser::ParseError => e
+        GitBak::Misc.die! "#{e}\n\n#{op}"
+      end
+
+      GitBak::Misc.die! "usage: #{USAGE}" unless args_.length == 0
+
+      options
+    end                                                         # }}}1
+
+    # parse configuration file; die on failure
+    def self.parse_cfgfile (file)
+      GitBak::Misc.die! "configuration file (#{file}) not found" \
+        unless GitBak::Misc.exists? file
+
+      GitBak::Config.load file
+    end
+
+    # run!
+    def self.main (args = nil)
+      options = parse_options (args or ARGV)
+      cfg     = parse_cfgfile options[:cfgfile]
+
+      GitBak.main options[:verbose], options[:noact], cfg.data
+    end
+
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/gitbak/misc.rb

@@ -0,0 +1,60 @@
+require 'io/console'
+
+# --
+
+# gitbak namespace
+module GitBak
+
+  # base error class
+  class Error < RuntimeError; end
+
+  # miscellaneous
+  module Misc
+
+    # command execution failure
+    class SysError < GitBak::Error; end
+
+    # --
+
+    # deep copy using Marshal
+    def self.deepdup (obj)
+      Marshal.load(Marshal.dump obj)
+    end
+
+    # print msg to stderr and exit
+    def self.die! (msg)
+      STDERR.puts msg
+      exit 1
+    end
+
+    # does file/dir or symlink exists?
+    def self.exists? (path)
+      File.exists?(path) or File.symlink?(path)
+    end
+
+    # prompt for line; optionally hide input
+    def self.prompt (prompt, hide = false)                      # {{{1
+      STDOUT.print prompt
+      STDOUT.flush
+
+      if hide
+        line = STDIN.noecho { |i| i.gets }
+        STDOUT.puts
+      else
+        line = STDIN.gets
+      end
+
+      line and line.chomp
+    end                                                         # }}}1
+
+    # execute command; raises SysError on failure; optionally verbose
+    def self.sys (verbose, cmd, *args)
+      puts "$ #{ ([cmd] + args).join ' ' }" if verbose
+      system [cmd, cmd], *args or raise SysError,
+        "failed to run command #{ ([cmd] + args) } (#$?)"
+    end
+
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/gitbak/services.rb

@@ -0,0 +1,114 @@
+require 'gitbak/misc'
+
+require 'json'
+require 'open-uri'
+
+# --
+
+# gitbak namespace
+module GitBak
+  # git services
+  module Services
+
+    # authentication error
+    class AuthError < GitBak::Error; end
+
+    # --
+
+    # avaliable services
+    SERVICES = %w{ bitbucket github gist }.map(&:to_sym)
+
+    # use another service's authentication
+    USE_AUTH = { gist: :github }
+
+    # API urls
+    APIS = {
+      bitbucket:  ->(user) { "api.bitbucket.org/1.0/users/#{user}"  },
+      github:     ->(user) { "api.github.com/users/#{user}/repos"   },
+      gist:       ->(user) { "api.github.com/users/#{user}/gists"   },
+    }
+
+    # remote urls
+    REMOTES =                                                   # {{{1
+    {
+      bitbucket: {
+        ssh:    ->(u, r)  { "git@bitbucket.org:#{u}/#{r}.git"     },
+        https:  ->(u, r)  { "https://bitbucket.org/#{u}/#{r}.git" },
+      },
+      github: {
+        ssh:    ->(u, r)  { "git@github.com:#{u}/#{r}.git"        },
+        https:  ->(u, r)  { "https://github.com/#{u}/#{r}.git"    },
+      },
+      gist: {
+        ssh:    ->(id)    { "git@gist.github.com:#{id}.git"       },
+        https:  ->(id)    { "https://gist.github.com/#{id}.git"   },
+      },
+    }                                                           # }}}1
+
+    # long keyword^wsymbol ;-)
+    AUTH = :http_basic_authentication
+
+    # --
+
+    # get data from API
+    def self.api_get (service, user, auth)                      # {{{1
+      url   = "https://#{APIS[service][user]}"
+      opts  = auth ? { AUTH => [auth[:user], auth[:pass]] } : {}
+
+      begin
+        data = open url, opts
+      rescue OpenURI::HTTPError => e
+        if e.io.status[0] == '401'
+          raise AuthError,
+            "401 for #{auth[:user]} on #{service}/#{user}"
+        else
+          raise
+        end
+      end
+
+      data
+    end                                                         # }}}1
+
+    # get repositories from service; uses api_get if service in APIS,
+    # api_get_<service> otherwise
+    #   -> [{name:,remote:,description:},...]
+    def self.repositories (service, cfg, auth)
+      rem   = REMOTES[service][cfg.fetch(:method, :ssh).to_sym]
+      args  = [service, cfg[:user], auth]
+      data  = APIS[service] ? api_get(*args) :
+                send("api_get_#{service}", *args)
+      send service, cfg, data, rem
+    end
+
+    # --
+
+    # turn bitbucket API data into a list of repositories
+    def self.bitbucket (cfg, data, rem)
+      data_ = JSON.load data
+      repos = data_['repositories'].select { |r| r['scm'] == 'git' }
+      repos.map do |r|
+        { name: r['name'], remote: rem[cfg[:user], r['name']],
+          description: r['description'] }
+      end
+    end
+
+    # turn github API data into a list of repositories
+    def self.github (cfg, data, rem)
+      JSON.load(data).map do |r|
+        { name: r['name'], remote: rem[cfg[:user], r['name']],
+          description: r['description'] }
+      end
+    end
+
+    # turn gist API data into a list of repositories
+    def self.gist (cfg, data, rem)
+      JSON.load(data).map do |r|
+        { name: r['id'], remote: rem[r['id']],
+          description: r['description'] }
+      end
+    end
+
+ end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/gitbak/version.rb

@@ -1,4 +1,7 @@
 module GitBak
-  VERSION = '0.2.0'
-  DATE    = '2012-12-27'
+  # version and ...
+  VERSION = '0.3.0'
+
+  # ... date (for gemspec) ;-)
+  DATE = '2012-12-29'
 end

data/lib/gitbak.rb

@@ -1,173 +1,116 @@
+require 'gitbak/misc'
+require 'gitbak/services'
 require 'gitbak/version'
 
 require 'fileutils'
-require 'io/console'
-require 'json'
-require 'open-uri'
 
 # --
 
+# gitbak namespace
 module GitBak
 
-  SERVICES = %w{ Bitbucket GitHub Gist }
-
-  APIS = {
-    bitbucket:  ->(user) { "api.bitbucket.org/1.0/users/#{user}"  },
-    github:     ->(user) { "api.github.com/users/#{user}/repos"   },
-    gist:       ->(user) { "api.github.com/users/#{user}/gists"   },
-  }
-
-  REMOTES = {                                                   # {{{1
-    bitbucket: {
-      ssh:    ->(u, r)  { "git@bitbucket.org:#{u}/#{r}.git" },
-      https:  ->(u, r)  { "https://bitbucket.org/#{u}/#{r}.git" },
-    },
-    github: {
-      ssh:    ->(u, r)  { "git@github.com:#{u}/#{r}.git" },
-      https:  ->(u, r)  { "https://github.com/#{u}/#{r}.git" },
-    },
-    gist: {
-      ssh:    ->(id)    { "git@gist.github.com:#{id}.git" },
-      https:  ->(id)    { "https://gist.github.com/#{id}.git" },
-    },
-  }                                                             # }}}1
-
-  REMOTE = ->(s, x) { REMOTES[s][x.fetch(:method, :ssh).to_sym] }
-
-  class << self
-
-    def die (msg)
-      STDERR.puts msg
-      exit 1
-    end
-
-    def exists? (path)
-      File.exists?(path) or File.symlink?(path)
-    end
-
-    def sys (verbose, cmd, *args)
-      puts "  $ #{([cmd] + args).join ' '}" if verbose
-      system [cmd, cmd], *args or raise 'OOPS'                  # TODO
-    end
-
-    def prompt (prompt, hide = false)                           # {{{1
-      STDOUT.print prompt
-      STDOUT.flush
-
-      if hide
-        line = STDIN.noecho { |i| i.readline }
-        STDOUT.puts
-        line
-      else
-        STDIN.readline
-      end .chomp
-    end                                                         # }}}1
+  # extract name from remote; e.g. "git@server:foo/bar.git" and
+  # "https://server/foo/bar.git" become "bar"
+  def self.repo_name (remote)
+    remote.sub(%r!^.*[/:]!, '').sub(/\.git$/, '')
+  end
 
-    # --
+  # clone (from remote) or update repository (in dir); optionally
+  # verbose
+  def self.mirror_repo (verbose, remote, dir)                   # {{{1
+    name      = repo_name remote
+    name_     = name + '.git'
+    repo_dir  = "#{dir}/#{name_}"
 
-    def api_get (service, user, auth)
-      opts = auth ? { http_basic_authentication:
-                      [auth[:user], auth[:pass]] } : {}
+    FileUtils.mkdir_p dir
 
-      JSON.load open("https://#{APIS[service][user]}", opts)
+    if Misc.exists? repo_dir
+      puts "$ cd #{repo_dir}" if verbose
+      FileUtils.cd(repo_dir) do
+        Misc.sys verbose, *%w{ git remote update }
+      end
+    else
+      puts "$ cd #{dir}" if verbose
+      FileUtils.cd(dir) do
+        Misc.sys verbose,
+          *( %w{ git clone --mirror -n } + [remote, name_] )
+      end
     end
+  end                                                           # }}}1
 
-    def repo_name (remote)
-      remote.sub(%r!^.*[/:]!, '').sub(/\.git$/, '')
-    end
+  # --
 
-    def mirror (remote, dir, verbose)                           # {{{1
-      name      = repo_name remote
-      name_     = name + '.git'
-      repo_dir  = "#{dir}/#{name_}"
+  # check auth; ask passwords
+  def self.process_config (config)                              # {{{1
+    config_ = Misc.deepdup config
 
-      FileUtils.mkdir_p dir
+    config_[:repos].each do |service, cfgs|
+      auth = config_[:auth][service] ||= {}
+      cfgs.each do |cfg|
+        user = cfg[:auth]
+        auth[user] = { user: user, pass: nil } if user && !auth[user]
+      end
+    end
 
-      if exists? repo_dir
-        FileUtils.cd(repo_dir) do
-          sys verbose, *%w{ git remote update }
-        end
-      else
-        FileUtils.cd(dir) do
-          sys verbose,
-            *( %w{ git clone --mirror -n } + [remote, name_] )
-        end
+    config_[:auth].each do |service, auth|
+      next if GitBak::Services::USE_AUTH[service]
+      auth.each_value do |x|
+        p = "#{service} password for #{x[:user]}: "
+        x[:pass] ||= Misc.prompt p, true                        # TODO
       end
-    end                                                         # }}}1O
+    end
 
-    # --
+    [config_[:auth], config_[:repos]]
+  end                                                           # }}}1
 
-    def repos_bitbucket (x, auth)                               # {{{1
-      rem = REMOTE[:bitbucket, x]
+  # fetch repository lists; optionally verbose
+  def self.fetch (verbose, auth, repos)                         # {{{1
+    repos.map do |service, cfgs|
+      au = auth[Services::USE_AUTH.fetch service, service]
+      cfgs.map do |cfg|
+        puts "listing #{service}/#{cfg[:user]} ..." if verbose
 
-      api_get(:bitbucket, x[:user], auth)['repositories'] \
-        .select { |r| r['scm'] == 'git' } .map do |r|
-          { remote: rem[x[:user], r['name']],
-            description: r['description'], name: r['name'] }
+        begin
+          rs = Services.repositories service, cfg, au[cfg[:auth]]
+        rescue Services::AuthError => e
+          Misc.die! "authentication failure: #{e}"
         end
-    end                                                         # }}}1
-
-    def repos_github (x, auth)                                  # {{{1
-      rem = REMOTE[:github, x]
 
-      api_get(:github, x[:user], auth).map do |r|
-        { remote: rem[x[:user], r['name']],
-          description: r['description'], name: r['name'] }
+        [service, cfg[:user], cfg[:dir], rs]
       end
-    end                                                         # }}}1
-
-    def repos_gist (x, auth)                                    # {{{1
-      rem = REMOTE[:gist, x]
-
-      api_get(:gist, x[:user], auth).map do |r|
-        { remote: rem[r['id']],
-          description: r['description'], name: r['id'] }
-      end
-    end                                                         # }}}1
-
-    # --
-
-    def mirror_service (service, x, auth, verbose)              # {{{1
-      puts "#{service} for #{x[:user]} ..."
-
-      auth_ = x[:auth] && auth[x[ x[:auth] == true ? :user : :auth ]]
-      repos = send "repos_#{service}", x, auth_
-
-      repos.each do |r|
-        d = r[:description]
-        puts "==> #{service} | #{x[:user]} | #{r[:name]} | #{d} <==" \
-          if verbose
-        mirror r[:remote], x[:dir], verbose
+    end .flatten 1
+  end                                                           # }}}1
+
+  # mirror repositories; optionally verbose
+  def self.mirror verbose, repos                                # {{{1
+    repos.each do |s, usr, dir, rs|
+      rs.each do |r|
+        name, desc = r[:name], r[:description]
+        puts "==> #{s} | #{usr} | #{name} | #{desc} <==" if verbose
+        mirror_repo verbose, r[:remote], dir
         puts if verbose
       end
+    end
+  end                                                           # }}}1
+
+  # print summary
+  def self.summary repos                                        # {{{1
+    puts '', '=== Summary ===', ''
+    repos.each do |service, usr, dir, rs|
+      printf "  %-15s for %-20s: %10s repositories\n",
+        service, usr, rs.length
+    end
+    puts
+  end                                                           # }}}1
 
-      repos.length
-    end                                                         # }}}1
-
-    # --
-
-    def main (config)                                           # {{{1
-      sum = {}
-
-      SERVICES.map { |s| s.downcase.to_sym } .each do |s|
-        sum[s] = {}
-        config[s].each do |x|
-          sum[s][x[:user]] = mirror_service s, x,
-            config[:auth][s], config[:verbose]
-        end
-      end
-
-      if config[:verbose]
-        puts '', "=== Summary ===", ''
-        sum.each_pair do |s, x|
-          x.each_pair do |u, n|
-            printf "  %-15s for %-20s: %10s repositories\n", s, u, n
-          end
-        end
-        puts
-      end
-    end                                                         # }}}1
+  # --
 
+  # run!
+  def self.main (verbose, noact, config)
+    auth, repos   = process_config config
+    repositories  = fetch verbose, auth, repos
+    mirror verbose, repositories unless noact
+    summary repositories if verbose
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitbak
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-27 00:00:00.000000000 Z
+date: 2012-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &17892680 !ruby/object:Gem::Requirement
+  requirement: &9773800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +21,8 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *17892680
-description: ! 'GitBak allows you to mirror GitHub/Bitbucket/Gist repositories
+  version_requirements: *9773800
+description: ! 'GitBak allows you to mirror Bitbucket/GitHub/Gist repositories
 
   easily; you only need to specify paths, users, and authentication
 
@@ -36,9 +36,14 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- README
+- README.md
 - bin/gitbak
+- lib/gitbak/exec.rb
+- lib/gitbak/config.rb
 - lib/gitbak/version.rb
+- lib/gitbak/misc.rb
+- lib/gitbak/eval.rb
+- lib/gitbak/services.rb
 - lib/gitbak.rb
 homepage: https://github.com/obfusk/gitbak
 licenses:
@@ -66,3 +71,4 @@ signing_key:
 specification_version: 3
 summary: bitbucket/github/gist backup
 test_files: []
+has_rdoc: 

data/README

@@ -1,62 +0,0 @@
---                                                                {{{1
-
-File        : README
-Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-Date        : 2012-12-27
-
-Copyright   : Copyright (C) 2012  Felix C. Stegerman
-Version     : v0.2.0
-
---                                                                }}}1
-
-=== Description ===                                               {{{1
-
-  gitbak - bitbucket/github/gist backup
-
-  GitBak allows you to mirror GitHub/Bitbucket/Gist repositories
-  easily; you only need to specify paths, users, and authentication in
-  ~/.gitbak and it does the rest.
-                                                                  }}}1
-
-=== Usage ===                                                     {{{1
-
-  $ gitbak --help                 # read documentation
-  $ vim ~/.gitbak                 # configure
-  $ gitbak                        # mirror
-                                                                  }}}1
-
-=== Installing ===                                                {{{1
-
-  $ gem install gitbak            # rubygems
-
-  Get it at https://github.com/obfusk/gitbak.  Depends: git, ruby.
-                                                                  }}}1
-
-=== TODO ===                                                      {{{1
-
-  Some things that may be useful/implemented at some point.
-
-  * custom services (should be easy already)
-  * metadata (issues, wikis, ...)
-  * teams/organisations
-  * filtering
-  * starred repos/gists
-  * specify ssh key(s)
-  * oauth ?!
-  * https clone auth
-                                                                  }}}1
-
-=== License ===                                                   {{{1
-
-  GPLv2 [1].
-                                                                  }}}1
-
-=== References ===                                                {{{1
-
-  [1] GNU General Public License, version 2
-      http://www.opensource.org/licenses/GPL-2.0
-                                                                  }}}1
-
---
-
-vim: set tw=70 sw=2 sts=2 et fdm=marker :