dandelion 0.3.15 → 0.4.0.beta2

data/lib/dandelion/backend.rb

@@ -1,54 +0,0 @@
-require 'tempfile'
-
-module Dandelion
-  module Backend
-    class MissingFileError < StandardError; end
-    class UnsupportedSchemeError < StandardError; end
-    
-    class MissingDependencyError < StandardError
-      attr_reader :gems
-      
-      def initialize(gems)
-        @gems = gems
-      end
-    end
-
-    class Base
-      class << self
-        @@backends = {}
-        
-        def create(config)
-          Dir.glob(File.join(File.dirname(__FILE__), 'backend', '*.rb')) { |file| require file }
-          raise UnsupportedSchemeError unless @@backends.include?(config['scheme'])
-          begin
-            @@backends[config['scheme']].new(config)
-          rescue LoadError
-            raise MissingDependencyError.new(@@backends[config['scheme']].gem_list)
-          end
-        end
-        
-        def scheme(scheme)
-          @@backends[scheme] = self
-        end
-        
-        def gems(*gems)
-          @gems = gems
-        end
-        
-        def gem_list
-          @gems
-        end
-      end
-
-      protected
-
-      def temp(file, data)
-        tmp = Tempfile.new(file.gsub('/', '.'))
-        tmp << data
-        tmp.flush
-        yield(tmp.path)
-        tmp.close
-      end
-    end
-  end
-end

data/lib/dandelion/deployment.rb

@@ -1,173 +0,0 @@
-require 'dandelion/git'
-
-module Dandelion
-  module Deployment
-    class RemoteRevisionError < StandardError; end
-    class FastForwardError < StandardError; end
-
-    class Deployment
-      class << self
-        def create(repo, backend, options)
-          begin
-            DiffDeployment.new(repo, backend, options)
-          rescue RemoteRevisionError
-            FullDeployment.new(repo, backend, options)
-          end
-        end
-      end
-
-      def initialize(repo, backend, options = {})
-        @repo = repo
-        @backend = backend
-        @options = { :exclude => [], :additional => [], :revision => 'HEAD', :revision_file => '.revision', :local_path => '' }.merge(options)
-        @tree = Git::Tree.new(@repo, @options[:revision], @options[:local_path])
-
-        if @options[:dry]
-          # Stub out the destructive backend methods
-          def @backend.write(file, data); end
-          def @backend.delete(file); end
-        end
-      end
-
-      def local_revision
-        @tree.revision
-      end
-
-      def remote_revision
-        nil
-      end
-
-      def write_revision
-        @backend.write(@options[:revision_file], local_revision)
-      end
-
-      def validate
-        begin
-          raise FastForwardError if fast_forwardable
-        rescue Grit::Git::CommandFailed
-        end
-      end
-
-      def log
-        Dandelion.logger
-      end
-
-      def deploy_additional
-        if @options[:additional].nil? || @options[:additional].empty?
-          log.debug("No additional files to deploy")
-          return
-        end
-
-        @options[:additional].each do |file|
-          local_path = file
-          remote_path = file
-
-          if file.is_a?(Hash)
-            local_path, remote_path = file.first
-          end
-
-          log.debug("Uploading additional file: #{local_path} -> #{remote_path}")
-          @backend.write(remote_path, IO.read(local_path))
-        end
-      end
-
-      protected
-
-      def exclude_file?(file)
-        @options[:exclude].map { |e| file.start_with?(e) }.any? unless @options[:exclude].nil?
-      end
-
-      private
-
-      def fast_forwardable
-        !@repo.git.native(:cherry, {:raise => true, :timeout => false}).empty?
-      end
-    end
-
-    class DiffDeployment < Deployment
-      def initialize(repo, backend, options = {})
-        super(repo, backend, options)
-        @diff = Git::Diff.new(@repo, read_remote_revision, @options[:revision], @options[:local_path])
-      end
-
-      def remote_revision
-        @diff.from_revision
-      end
-
-      def deploy
-        if !revisions_match? && any?
-          deploy_changed
-          deploy_deleted
-        else
-          log.debug("No changes to deploy")
-        end
-
-        deploy_additional
-
-        unless revisions_match?
-          write_revision
-        end
-      end
-
-      def deploy_changed
-        @diff.changed.each do |file|
-          if exclude_file?(file)
-            log.debug("Skipping file: #{file}")
-          else
-            if data = @tree.show(file)
-              log.debug("Uploading file: #{file}")
-              @backend.write(file, data)
-            end
-          end
-        end
-      end
-
-      def deploy_deleted
-        @diff.deleted.each do |file|
-          if exclude_file?(file)
-            log.debug("Skipping file: #{file}")
-          else
-            log.debug("Deleting file: #{file}")
-            @backend.delete(file)
-          end
-        end
-      end
-
-      def any?
-        @diff.changed.any? || @diff.deleted.any?
-      end
-
-      def revisions_match?
-        remote_revision == local_revision
-      end
-
-      private
-
-      def read_remote_revision
-        begin
-          @backend.read(@options[:revision_file]).chomp
-        rescue Backend::MissingFileError
-          raise RemoteRevisionError
-        end
-      end
-    end
-
-    class FullDeployment < Deployment
-      def deploy
-        @tree.files.each do |file|
-          if exclude_file?(file)
-            log.debug("Skipping file: #{file}")
-          else
-            if data = @tree.show(file)
-              log.debug("Uploading file: #{file}")
-              @backend.write(file, data)
-            end
-          end
-        end
-
-        deploy_additional
-        write_revision
-      end
-    end
-  end
-end

data/lib/dandelion/git.rb

@@ -1,123 +0,0 @@
-require 'grit'
-
-module Dandelion
-  module Git
-    class DiffError < StandardError; end
-    class RevisionError < StandardError; end
-
-    class Repo < Grit::Repo
-      def initialize(dir)
-        super(dir)
-      end
-    end
-
-    class Diff
-      attr_reader :from_revision, :to_revision
-
-      @files = nil
-
-      def initialize(repo, from_revision, to_revision, local_path)
-        @repo = repo
-        @local_path = local_path
-        @from_revision = revision_string(from_revision)
-        @to_revision = revision_string(to_revision)
-
-        begin
-          @files = parse(diff)
-        rescue Grit::Git::CommandFailed
-          raise DiffError
-        end
-      end
-
-      def changed
-        @files.to_a.select { |f| ['A', 'C', 'M'].include?(f.last) }.map { |f| f.first }
-      end
-
-      def deleted
-        @files.to_a.select { |f| 'D' == f.last }.map { |f| f.first }
-      end
-
-      private
-
-      def diff
-        @repo.git.native(:diff, { :name_status => true, :raise => true }, @from_revision, @to_revision)
-      end
-
-      def parse(diff)
-        files = {}
-        diff.split("\n").each do |line|
-          status, file = line.split("\t")
-          files[file] = status
-        end
-        files
-      end
-
-      def revision_string(revision)
-        if @local_path.nil? || @local_path.empty?
-          revision
-        else
-          "#{revision}:#{@local_path}"
-        end
-      end
-    end
-
-    class Tree
-      def initialize(repo, revision, local_path)
-        @repo = repo
-        @commit = @repo.commit(revision)
-        @revision = revision
-        @local_path = local_path
-        raise RevisionError if @commit.nil?
-        @tree = @commit.tree
-      end
-
-      def files
-        @repo.git.native(:ls_tree, { :name_only => true, :full_tree => true, :r => true }, revision_string).split("\n")
-      end
-
-      def show(file)
-        blob = @tree / file_path(file)
-        if blob.is_a?(Grit::Submodule)
-          puts "#{file} is a submodule, ignoring."
-        else
-          blob.data
-        end
-      end
-
-      def revision
-        @commit.sha
-      end
-
-      private
-
-      def file_path(file)
-        if local_path?
-          File.join(@local_path, file)
-        else
-          file
-        end
-      end
-
-      def revision_string
-        if local_path?
-          "#{@revision}:#{@local_path}"
-        else
-          @revision
-        end
-      end
-
-      def local_path?
-        !@local_path.nil? && !@local_path.empty?
-      end
-    end
-  end
-end
-
-# Grit does not support Ruby 2.0 right now
-class String
-  if ((defined? RUBY_VERSION) && (RUBY_VERSION[0..2] == "1.9" || RUBY_VERSION[0].to_i >= 2))
-    def getord(offset); self[offset].ord; end
-  else
-    alias :getord :[]
-  end
-end

data/test/fixtures/diff

@@ -1,3 +0,0 @@
-M	baz/foo
-A	foo
-D	foobar

data/test/fixtures/ls_tree

@@ -1,5 +0,0 @@
-bar
-baz/bar
-baz/foo
-baz/foo/bar
-foo

data/test/test_diff_deployment.rb

@@ -1,122 +0,0 @@
-require 'dandelion'
-require 'dandelion/deployment'
-require 'test/unit'
-
-def fixture(name)
-  File.read(File.join(File.dirname(__FILE__), 'fixtures', name))
-end
-
-# Mock classes
-
-class MockGit
-  def native(cmd, options = {}, *args, &block)
-    if cmd == :ls_tree
-      fixture('ls_tree')
-    elsif cmd == :diff
-      fixture('diff')
-    end
-  end
-end
-
-class MockFile
-  attr_reader :data
-
-  def initialize(data)
-    @data = data
-  end
-end
-
-class MockTree
-  def /(file)
-    MockFile.new('bar')
-  end
-end
-
-class MockCommit
-  def initialize(revision)
-    @revision = revision
-  end
-
-  def tree
-    MockTree.new
-  end
-
-  def sha
-    @revision
-  end
-end
-
-class MockRepo
-  def commit(revision)
-    MockCommit.new(revision)
-  end
-
-  def git
-    MockGit.new
-  end
-end
-
-class MockBackend
-  attr_reader :reads, :writes, :deletes
-
-  def initialize(remote_revision)
-    @reads = {'.revision' => remote_revision}
-    @writes = {}
-    @deletes = []
-  end
-
-  def read(file)
-    @reads[file]
-  end
-
-  def write(file, data)
-    @writes[file] = data
-  end
-
-  def delete(file)
-    @deletes << file
-  end
-end
-
-# Tests
-
-class TestDiffDeployment < Test::Unit::TestCase
-  def setup
-    Dandelion.logger.level = Logger::FATAL
-    @head_revision = '0ca605e9f0f1d42ce8193ac36db11ec3cc9efc08'
-    @remote_revision = 'ff1f1d4bd0c99e1c9cca047c46b2194accf89504'
-    @repo = MockRepo.new
-    @backend = MockBackend.new(@remote_revision)
-    @diff_deployment = Dandelion::Deployment::DiffDeployment.new(@repo, @backend, :revision => @head_revision)
-  end
-
-  def test_diff_deployment_local_revision
-    assert_equal @head_revision, @diff_deployment.local_revision
-  end
-
-  def test_diff_deployment_remote_revision
-    assert_equal @remote_revision, @diff_deployment.remote_revision
-  end
-
-  def test_diff_deployment_write_revision
-    @diff_deployment.write_revision
-    assert_equal @head_revision, @backend.writes['.revision']
-  end
-
-  def test_diff_deployment_revisions_match
-    assert !@diff_deployment.revisions_match?
-  end
-
-  def test_diff_deployment_any
-    assert @diff_deployment.any?
-  end
-
-  def test_diff_deployment_deploy
-    @diff_deployment.deploy
-    assert_equal 3, @backend.writes.length
-    assert_equal 'bar', @backend.writes['foo']
-    assert_equal 'bar', @backend.writes['baz/foo']
-    assert_equal @head_revision, @backend.writes['.revision']
-    assert_equal ['foobar'], @backend.deletes
-  end
-end