munkey 0.4.0

data/README.rdoc

@@ -0,0 +1,28 @@
+= Munkey
+
+Uses git to mirror an ftp server and track local changes. These can then be
+pushed back up to the ftp server or additional changes pulled down from the
+ftp server.
+
+Solves my problem of working on a website locally but needing to interact
+with other developers editing directly the server via ftp.
+
+This is not very efficient yet since it downloads all the (non-.gitignore'd) 
+files each time.
+
+Note: Depends on net-ftp-list gem so be sure to install that as well
+
+== Usage
+
+munkey clone [--ignore=ignoresfile] ftp://usr:pwd@host/dir [dst]
+
+munkey pull [--no-merge] [--full-download] - pulls in new changes from ftp
+
+munkey push - pushes changes back into ftp server. Important to have pulled
+              recent changes from ftp since munkey will overwrite locally
+              modified files.
+
+== Caveats
+
+* Gitignore support doesn't understand inverse (!...) lines -- patches welcome
+* Probably doesn't work on Windows (or any non-unix platform)

data/bin/munkey

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'munkey'
+
+class MunkeyBin
+  def initialize(args)
+    @options = {}
+    @options[:verbose] = args.delete('--quiet') ? false : true
+  end
+  
+  def clone(args)
+    ignores = read_ignores(args.shift) if /^--ignore=/ =~ args.first
+    src = args.shift
+    dst = args.shift
+    dst ||= join_to_pwd(src.split('/').last) if src
+    dst = join_to_pwd(dst) unless dst.slice(0, 1) == '/'
+    show_help unless src && dst
+    Munkey::clone src, dst, @options.merge(:ignores => ignores)
+  end
+  
+  def pull(args)
+    merge = args.delete('--no-merge') ? false : true
+    quick = args.delete('--full-download') ? false : true
+    Munkey.new(Dir.pwd, @options).pull(:merge => merge, :quick => quick)
+  end
+  
+  def push(args)
+    dryrun = args.delete('--dry-run') ? true : false
+    Munkey.new(Dir.pwd, @options).push(dryrun)
+  end
+  
+  def show_help
+    puts "Usage: munkey <command> [options] [args]"
+    puts
+    puts "munkey clone [--quiet] [--ignore=ignoresfile] ftp://usr:pwd@host/dir [dst]"
+    puts "\t- Clone from FTP source"
+    puts "munkey pull [--quiet] [--no-merge] [--full-download]"
+    puts "\t- Pull in changes from FTP source"
+    puts "munkey push [--quiet]  [--dry-run]"
+    puts "\t- Push your changes back to FTP source"
+    exit
+  end
+  
+  protected
+    def join_to_pwd(path)
+      /^\// =~ path ? path : File.join(Dir.pwd, path)
+    end
+    
+    def read_ignores(arg)
+      ignore_file = arg.gsub(/^--ignore=/, '')
+      File.read join_to_pwd(ignore_file)
+    end
+end
+
+munkey = MunkeyBin.new(ARGV)
+if !ARGV.empty? and munkey.respond_to?(cmd = ARGV.shift)
+  begin
+    munkey.send cmd, ARGV
+  rescue NoMethodError
+    puts "WARNING: Invalid FTP Source"
+  end
+else
+  munkey.show_help
+end

data/lib/gitignore_parser.rb

@@ -0,0 +1,48 @@
+class GitignoreParser
+  DEFAULT_IGNORES = ".git\n"
+  
+  class << self
+    def parse(gitpath)
+      new(gitpath)
+    end
+  end
+
+  def initialize(gitpath)
+    @gitpath = gitpath
+    
+    ignore_file = File.join(@gitpath, '.gitignore')
+    gitignore = DEFAULT_IGNORES
+    gitignore += File.read(ignore_file) if File.exist?(ignore_file)
+    
+    @globs = []
+    rx = gitignore.split("\n").map do |i|
+      i.strip!
+      if i == '' or i.slice(0,1) == '#'
+        nil
+      elsif not i.include?('*')
+        if i.slice(-1,1) == '/'
+          i
+        else
+          "^#{i}|\/#{i}"
+        end
+      else
+        @globs << i
+        nil
+      end
+    end.compact.join("|")
+    @regex = (rx == '' ? nil : Regexp.new(rx))
+  end
+  
+  def ignore?(path)
+    raise NotAbsolutePathError unless path.slice(0, 1) == '/'
+    relpath = path.gsub %r{^#{Regexp.escape(@gitpath)}\/}, ''
+    @regex =~ relpath || @globs.any? {|g| File.fnmatch(g, relpath) }
+  end
+
+end
+
+class NotAbsolutePathError < StandardError
+  def initialize
+    super("Supplied path is not an absolute path")
+  end  
+end

data/lib/munkey.rb

@@ -0,0 +1,179 @@
+require 'rubygems'
+require 'uri'
+require 'ftp_sync'
+require 'yaml'
+require 'gitignore_parser'
+require 'fileutils'
+
+class Munkey
+  DEFAULT_BRANCH = 'munkey'
+  
+  class << self
+    def clone(ftpsrc, repo_path, options = {})
+      src = URI::parse(ftpsrc)
+      raise InvalidSource unless src.is_a?(URI::FTP)
+      
+      repo = create_repo(repo_path, options)
+      repo.save_ftp_details(src)
+      repo.pull_ftp_files
+      repo.commit_changes
+      repo.create_branch
+      repo
+    end
+    
+    private
+      def create_repo(repo_path, options = {})
+        return false unless system("git init #{repo_path}")
+        if options[:ignores]
+          File.open(File.join(repo_path, '.gitignore'), 'w') do |f|
+            f.write options[:ignores]
+          end
+          system("cd #{repo_path} && git add .gitignore")
+        end
+        new(repo_path, options)
+      end
+  end
+  
+  def initialize(gitpath, options)
+    @gitpath = gitpath
+    munkey_file = File.join(gitpath, '.git', 'munkey.yml')
+    @ftpdetails = YAML.load_file(munkey_file) if File.exist?(munkey_file)
+    @verbose = options[:verbose] || false
+  end
+  
+  def pull(options = {})
+    default_options = { :merge => true, :quick => false }
+    default_options.merge! options
+    
+    tmp_repo = clone_to_tmp
+    pull_ftp_files(tmp_repo, default_options[:quick])
+    commit_changes(tmp_repo)
+    push_into_base_repo(tmp_repo)
+    FileUtils.rm_rf(tmp_repo)
+    merge_foreign_changes if default_options[:merge]
+  end
+  
+  def push(dryrun = false)
+    changes = files_changed_between_branches
+    
+    list_ftp_changes(changes) && return if dryrun
+    
+    update_ftp_server(changes)
+    tmp_repo = clone_to_tmp
+    merge_pushed_changes(tmp_repo)
+    push_into_base_repo(tmp_repo)
+    FileUtils.rm_rf(tmp_repo)
+  end
+  
+  def save_ftp_details(ftp_uri)
+    @ftpdetails = { :host => ftp_uri.host, :path => "/#{ftp_uri.path}", :user => ftp_uri.user, :password => ftp_uri.password }
+    File.open File.join(@gitpath, '.git', 'munkey.yml'), 'w' do |f|
+      f.write @ftpdetails.to_yaml
+    end
+  end
+  
+  def pull_ftp_files(dst = nil, quick = false)
+    if quick
+      since = last_pull_date
+    end
+    
+    dst ||= @gitpath
+    gitignore = GitignoreParser.parse(dst)
+    ftp = FtpSync.new(@ftpdetails[:host], @ftpdetails[:user], @ftpdetails[:password], :ignore => gitignore, :verbose => @verbose)
+    ftp.pull_dir(dst, @ftpdetails[:path], { :delete => true, :since => (since || nil) }) do |p|
+      Dir.chdir(dst) do
+        relpath = p.gsub %r{^#{Regexp.escape(dst)}\/}, ''
+        system("git rm -r#{git_quiet} '#{relpath}'")
+      end
+    end  
+  end
+  
+  def commit_changes(dst = nil)
+    Dir.chdir(dst || @gitpath) do
+      system("git add .") && system("git commit -m 'Pull from ftp://#{@ftpdetails[:host]}#{@ftpdetails[:path]} at #{Time.now.to_s}'")
+    end
+  end
+  
+  def create_branch(branch_name = DEFAULT_BRANCH)
+    Dir.chdir(@gitpath) do
+      system("git branch #{branch_name}")
+    end
+  end
+  
+  def clone_to_tmp(branch = DEFAULT_BRANCH)
+    tmp_repo = File.join ENV['TMPDIR'], create_tmpname
+    system("git clone#{git_quiet} -b #{branch} #{@gitpath} #{tmp_repo}")
+    tmp_repo
+  end
+  
+  def push_into_base_repo(tmp_repo, branch = DEFAULT_BRANCH)
+    Dir.chdir(tmp_repo) do
+      system("git push#{git_quiet} origin #{branch}:#{branch}")
+    end
+  end
+  
+  def merge_foreign_changes(branch = DEFAULT_BRANCH)
+    Dir.chdir(@gitpath) do
+      system("git merge #{branch}")
+    end
+  end
+  
+  def merge_pushed_changes(tmp_repo)
+    Dir.chdir(tmp_repo) do
+      system("git pull#{git_quiet} origin master")
+    end
+  end
+  
+  def files_changed_between_branches(branch = DEFAULT_BRANCH)
+    changes = { :changed => [], :removed => [] }
+    Dir.chdir(@gitpath) do
+      `git diff --name-status #{branch} master`.strip.split("\n").each do |f|
+        status, name = f.split(/\s+/, 2)
+        if status == "D"
+          changes[:removed] << name
+        else
+          changes[:changed] << name unless name == '.gitignore'
+        end
+      end
+    end
+    
+    changes
+  end
+  
+  def update_ftp_server(changes)
+    ftp = FtpSync.new(@ftpdetails[:host], @ftpdetails[:user], @ftpdetails[:password], :verbose => @verbose)
+
+    unless changes[:changed].size == 0
+      ftp.push_files @gitpath, @ftpdetails[:path], changes[:changed]
+    end
+    
+    unless changes[:removed].size == 0
+      ftp.remove_files @ftpdetails[:path], changes[:removed]
+    end
+  end
+  
+  def list_ftp_changes(changes)
+    changes[:changed].each {|f| puts "WILL UPLOAD #{f}" }
+    changes[:removed].each {|f| puts "WILL REMOVE #{f}" }
+  end
+  
+  def last_pull_date(branch = DEFAULT_BRANCH)
+    Dir.chdir(@gitpath) do
+      commits = `git log --format=oneline #{branch}`.strip.split("\n")
+      commits.find {|c| c =~ /^[a-f\d]{40} Pull from ftp:\/\/.* at ([\w +:]+)$/ } ? Time.parse($1) : nil      
+    end
+  end
+  
+  private
+  
+    def git_quiet
+      @verbose ? '' : ' -q'
+    end
+  
+    def create_tmpname
+      tmpname = ''
+      char_list = ("a".."z").to_a + ("0".."9").to_a
+			1.upto(20) { |i| tmpname << char_list[rand(char_list.size)] }
+			return tmpname
+    end
+end

data/test/gitignore_test.rb

@@ -0,0 +1,116 @@
+test_path = File.expand_path(File.dirname(__FILE__))
+lib_path = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+
+$:.unshift test_path unless $:.include?(test_path)
+$:.unshift lib_path unless $:.include?(lib_path)
+
+require 'test/unit'
+require 'gitignore_parser'
+require 'tmpdir'
+
+class GitignoreTest < Test::Unit::TestCase
+  
+  def setup
+    @gitdir = File.join Dir.tmpdir, create_tmpname
+    FileUtils.mkdir_p @gitdir
+  end
+  
+  def teardown
+    FileUtils.rm_rf @gitdir
+  end
+    
+  def test_skips_blank_lines_in_gitignore
+    create_git_ignore "\nfoo.txt\n\n"
+    assert GitignoreParser::parse(@gitdir).ignore?(File.join(@gitdir, 'foo.txt'))
+  end
+  
+  def test_skips_commented_lines_in_gitignore
+    create_git_ignore "foo.txt\n#bar.txt\n"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, 'foo.txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'bar.txt'))
+  end
+  
+  def test_filename_ignore
+    create_git_ignore 'foo.txt'
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, 'foo.txt'))
+    assert gitignore.ignore?(File.join(@gitdir, 'foo/foo.txt'))
+    assert gitignore.ignore?(File.join(@gitdir, 'foo/bar/foo.txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'bar.txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'foo/bar.txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'barfoo.txt'))
+  end
+  
+  def test_simple_ignore
+    create_git_ignore "*.txt\n"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, 'foo.txt'))
+    assert gitignore.ignore?(File.join(@gitdir, 'nested/foo.txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'foo.jpg'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'foo_txt'))
+    assert !gitignore.ignore?(File.join(@gitdir, 'foo.txt.jpg'))
+  end
+  
+  def test_combined_ignore
+    create_git_ignore "*.txt\n*.jpg\n"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, "foo.txt"))
+    assert gitignore.ignore?(File.join(@gitdir, "foo.jpg"))
+    assert gitignore.ignore?(File.join(@gitdir, "foo.jpg.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "foo.doc"))
+  end
+  
+  def test_path_only_ignore
+    create_git_ignore "doc/"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, "doc/foo.txt"))
+    assert gitignore.ignore?(File.join(@gitdir, "src/doc/foo.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "src/foo.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "doc"))
+  end
+  
+  def test_simple_glob_ignore
+    create_git_ignore "doc/*.txt"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, "doc/foo.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "src/doc/foo.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "src/foo.txt"))
+  end
+  
+  def test_path_only_glob_ignore
+    create_git_ignore "doc/*"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, "doc/html/index.html"))
+    assert gitignore.ignore?(File.join(@gitdir, "doc/html"))
+    assert gitignore.ignore?(File.join(@gitdir, "doc/pdf"))
+    assert gitignore.ignore?(File.join(@gitdir, "doc/pdf/index.pdf"))
+    assert gitignore.ignore?(File.join(@gitdir, "doc/index.html"))
+    assert !gitignore.ignore?(File.join(@gitdir, "src/index.html"))
+    assert !gitignore.ignore?(File.join(@gitdir, "src/doc/index.html"))
+  end
+  
+  def test_path_and_file_glob
+    create_git_ignore "foo/**/*.txt"
+    gitignore = GitignoreParser::parse(@gitdir)
+    assert gitignore.ignore?(File.join(@gitdir, "foo/bar/hello.txt"))
+    assert !gitignore.ignore?(File.join(@gitdir, "foo/bar/hello.html"))
+    assert !gitignore.ignore?(File.join(@gitdir, "foo/bar"))
+  end
+  
+  protected
+
+   def create_tmpname
+      tmpname = ''
+      char_list = ("a".."z").to_a + ("0".."9").to_a
+			1.upto(20) { |i| tmpname << char_list[rand(char_list.size)] }
+			return tmpname
+    end
+  
+    def create_git_ignore(ignore_content)
+      File.open File.join(@gitdir, '.gitignore'), 'w' do |f|
+        f.write ignore_content
+      end
+    end
+  
+end

data/test/munkey_test.rb

@@ -0,0 +1,286 @@
+test_path = File.expand_path(File.dirname(__FILE__))
+lib_path = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+
+$:.unshift test_path unless $:.include?(test_path)
+$:.unshift lib_path unless $:.include?(lib_path)
+
+require 'test/unit'
+require 'tmpdir'
+require 'net/ftp'
+require 'munkey'
+require 'fileutils'
+
+class MunkeyTest < Test::Unit::TestCase
+  
+  def setup
+    Net::FTP.create_ftp_src
+    Net::FTP.listing_overrides = {}
+    @gitdir = File.join Dir.tmpdir, create_tmpname
+  end
+  
+  def teardown
+    FileUtils.rm_rf @gitdir
+    FileUtils.rm_rf Net::FTP.ftp_src
+    FileUtils.rm_rf Net::FTP.ftp_dst if File.exist?(Net::FTP.ftp_dst)
+  end
+  
+  def test_clone_creates_supplied_target_dir
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    assert File.exist?(@gitdir)
+  end
+  
+  def test_clone_initialises_git_in_target_dir
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    assert File.exist?(File.join(@gitdir, '.git'))
+  end
+  
+  def test_clone_creates_git_ignore_with_supplied_ignores
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir, :ignores => '*.txt')
+    assert File.exist?(File.join(@gitdir, '.gitignore'))
+    assert_equal "*.txt", File.read(File.join(@gitdir, '.gitignore'))
+  end
+  
+  def test_clone_saves_ftp_details
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    assert File.exist?(File.join(@gitdir, '.git', 'munkey.yml'))
+    ftp_details = YAML.load(File.read(File.join(@gitdir, '.git', 'munkey.yml')))
+    assert_equal 'test.server', ftp_details[:host]
+    assert_equal 'user', ftp_details[:user]
+    assert_equal 'pass', ftp_details[:password]
+    assert_equal '/', ftp_details[:path]
+  end
+  
+  def test_clone_pulls_in_files_from_ftp
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    assert File.exist?(File.join(@gitdir, 'README'))
+    assert File.exist?(File.join(@gitdir, 'dirA'))
+    assert File.exist?(File.join(@gitdir, 'dirA', 'fileAA'))
+  end
+  
+  def test_clone_adds_files_to_git
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    Dir.chdir(@gitdir) do
+      status = `git status`
+      assert_no_match /untracked files present/, status
+    end
+  end
+  
+  def test_clone_creates_a_munkey_branch
+    Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    Dir.chdir(@gitdir) do
+      branches = `git branch`.split("\n").map {|b| b.gsub(/^\*/, '').strip }
+      assert branches.include?('master')
+      assert branches.include?('munkey')
+    end
+  end
+  
+  def test_pull_adds_new_files
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    FileUtils.touch File.join(Net::FTP.ftp_src, 'missing')
+    assert !File.exist?(File.join(@gitdir, 'missing'))
+    munkey.pull
+    assert File.exist?(File.join(@gitdir, 'missing'))
+  end
+  
+  def test_pull_removes_missing_files
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.unlink File.join(Net::FTP.ftp_src, 'README')
+    assert File.exist?(File.join(@gitdir, 'README'))
+    munkey.pull
+    assert !File.exist?(File.join(@gitdir, 'README'))
+  end
+  
+  def test_pull_doesnt_change_locally_removed_files
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    readme = File.join(@gitdir, 'README')
+    File.unlink(readme)
+    assert !File.exist?(readme)
+    munkey.pull
+    assert !File.exist?(readme)
+  end
+  
+  def test_pull_adds_a_commit
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    FileUtils.touch File.join(Net::FTP.ftp_src, 'missing')
+    munkey.pull
+    Dir.chdir(@gitdir) do
+      commits = `git log --format=oneline`.strip.split("\n")
+      assert_equal 2, commits.size
+    end
+  end
+  
+  def test_pull_with_no_merge_commits_to_munkey_branch_but_not_master
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    Dir.chdir(@gitdir) do
+      munkey_commits = `git log --format=oneline munkey`.strip.split("\n").size
+      master_commits = `git log --format=oneline master`.strip.split("\n").size
+      FileUtils.touch File.join(Net::FTP.ftp_src, 'missing')
+      munkey.pull(:merge => false)
+      assert_equal munkey_commits + 1, `git log --format=oneline munkey`.strip.split("\n").size
+      assert_equal master_commits, `git log --format=oneline master`.strip.split("\n").size
+    end    
+  end
+  
+  def test_quick_pull_includes_changed_files
+    Net::FTP.listing_overrides['/'] = ["-rw-r--r--   1 root     other          0 #{(Time.now + 90).strftime('%b %d %H:%M')} README"]
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.open(File.join(Net::FTP.ftp_src, 'README'), 'w') {|f| f.write 'quicktest' }
+    Dir.chdir(@gitdir) do
+      munkey.pull(:quick => true)
+      assert_equal 2, `git log --format=oneline munkey`.strip.split("\n").size
+    end
+  end
+  
+  def test_quick_pull_excludes_unmodified_files
+    Net::FTP.listing_overrides['/'] = ["-rw-r--r--   1 root     other          0 #{(Time.now - 90).strftime('%b %d %H:%M')} README"]
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.open(File.join(Net::FTP.ftp_src, 'README'), 'w') {|f| f.write 'quicktest' }
+    Dir.chdir(@gitdir) do
+      munkey.pull(:quick => true)
+      assert_equal 1, `git log --format=oneline munkey`.strip.split("\n").size
+    end
+  end  
+  
+  def test_push_includes_newly_added_files
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git 'newfile'
+    munkey.push
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'newfile'))
+  end
+  
+  def test_push_includes_files_from_multiple_commits
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git('newfile')
+    add_file_to_git('secondfile')
+    munkey.push
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'newfile'))
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'secondfile'))
+  end
+  
+  def test_push_excludes_remote_added_files
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    FileUtils.touch File.join(Net::FTP.ftp_src, 'another')
+    munkey.pull
+    munkey.push
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, 'another'))
+  end
+  
+  def test_push_excludes_existing_files
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git 'newfile'
+    munkey.push
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'newfile'))
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+  end
+  
+  def test_push_excludes_gitignore
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git '.gitignore'
+    munkey.push
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, '.gitignore'))
+  end
+  
+  def test_push_includes_files_changed_on_both_local_and_remote
+    Net::FTP.create_ftp_dst
+    File.open(File.join(Net::FTP.ftp_src, 'README'), 'w') do |f| 
+      f.write "line 1\nline 2\nline 3\nline 4\n"
+    end
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.open(File.join(Net::FTP.ftp_src, 'README'), 'w') do |f| 
+      f.write "line 1\nline 2\nline 3\nline 4\nline 5\n"
+    end
+    File.open(File.join(@gitdir, 'README'), 'w') do |f|
+      f.write "line 1\nline two\nline 3\nline 4\n"
+    end
+    munkey.pull
+    munkey.push
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+  end
+  
+  def test_push_removes_locally_removed_files
+    FileUtils.cp_r Net::FTP.ftp_src, Net::FTP.ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    Dir.chdir(@gitdir) do
+      system("git rm README && git commit -m 'removed README'")
+    end
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+    munkey.push
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+  end
+  
+  def test_push_excludes_remotely_removed_files
+    FileUtils.cp_r Net::FTP.ftp_src, Net::FTP.ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.unlink File.join(Net::FTP.ftp_src, 'README')
+    munkey.pull
+    munkey.push
+    assert File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+  end
+  
+  def test_push_excludes_files_with_same_change_local_and_remote
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    File.open(File.join(Net::FTP.ftp_src, 'README'), 'w') {|f| f.write 'munkey' }
+    Dir.chdir(@gitdir) do
+      File.open('README', 'w') {|f| f.write 'munkey' }
+      system("git add . && git commit -m 'add README CHANGES'")
+    end
+    munkey.pull
+    munkey.push
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, 'README'))
+  end
+  
+  def test_push_adds_a_commit_to_the_munkey_branch
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git('newfile')
+    add_file_to_git('secondfile')
+    munkey.push
+    Dir.chdir(@gitdir) do
+      commits = `git log --format=oneline munkey`.strip.split("\n")
+      assert_equal 3, commits.size
+    end
+  end
+  
+  def test_dryrun_push_doesnt_create_commit_in_munkey_branch
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    last_commit = File.read File.join(@gitdir, '.git', 'refs', 'heads', 'munkey')
+    add_file_to_git 'newfile'
+    munkey.push(true)
+    assert_equal last_commit, File.read(File.join(@gitdir, '.git', 'refs', 'heads', 'munkey'))
+  end
+  
+  def test_dryrun_push_doesnt_upload_files
+    Net::FTP.create_ftp_dst
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    add_file_to_git 'newfile'
+    munkey.push(true)
+    assert !File.exist?(File.join(Net::FTP.ftp_dst, 'newfile'))
+  end
+  
+  def test_last_pull_date
+    munkey = Munkey.clone('ftp://user:pass@test.server/', @gitdir)
+    assert_equal Time.now.to_s, munkey.last_pull_date.to_s
+  end
+  
+  protected
+   def create_tmpname
+    tmpname = ''
+    char_list = ("a".."z").to_a + ("0".."9").to_a
+		1.upto(20) { |i| tmpname << char_list[rand(char_list.size)] }
+		return tmpname
+  end
+  
+  def add_file_to_git(filename, content = nil)
+    Dir.chdir(@gitdir) do
+      File.open(filename, 'a') {|f| f.write content }      
+      system("git add . && git commit -m 'Added file #{filename}'")
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: munkey
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- jebw
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-12 00:00:00 +01:00
+default_executable: munkey
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ftp_sync
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 4
+        - 1
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id001
+description: Tool for using git to push and pull from ftp servers
+email: jeb@jdwilkins.co.uk
+executables: 
+- munkey
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/gitignore_parser.rb
+- lib/munkey.rb
+- bin/munkey
+- README.rdoc
+- test/gitignore_test.rb
+- test/munkey_test.rb
+has_rdoc: true
+homepage: http://github.com/jebw/munkey
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --title
+- Tool for using git to push and pull from ftp servers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Tool for using git to push and pull from ftp servers
+test_files: 
+- test/gitignore_test.rb
+- test/munkey_test.rb