dandelion 0.1.4 → 0.1.5

data/README.md

@@ -13,26 +13,42 @@ Alternatively, you can build the gem yourself:
     $ cd dandelion
     $ rake install
     
-Usage
------
-Deployment options are specified in a YAML file.  By default, Dandelion looks for
-one named `dandelion.yml`, however, this can be overridden by passing a path as an
-argument.
+Config
+------
+Configuration options are specified in a YAML file (Dandelion looks for a file
+named `dandelion.yml` by default):
 
+    # Required
     scheme: sftp
     host: example.com
     username: user
     password: pass
     path: path/to/deployment
     
+    # Optional
     exclude:
-      - .gitignore
-      - dandelion.yml
-      
-To deploy the HEAD revision, ensure you are in the root of the repository and run:
+        - .gitignore
+        - dandelion.yml
+    
+Usage
+-----
+From the root directory of a Git repository, run:
 
     $ dandelion
     
-If the repository has previously been deployed then only the files that have
-changed since the last deployment will be transferred.  All files (except those
-excluded) will be transferred on first deployment.
+Or:
+
+    $ dandelion path/to/config.yml
+    
+This will deploy the local `HEAD` revision to the server specified in the config
+file.  Dandelion keeps track of the most recently deployed revision so that only
+files which have changed since the last deployment need to be transferred.
+
+For a more complete summary of usage options, run:
+
+    $ dandelion -h
+    Usage: dandelion [options] [config_file]
+        -f, --force                      Force deployment
+        -s, --status                     Display revision status
+        -v, --version                    Display the current version
+        -h, --help                       Display this screen

data/bin/dandelion

@@ -2,6 +2,6 @@
 
 $:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
 
-require 'dandelion'
+require 'dandelion/cli'
 
-Dandelion.run
+Dandelion::Cli::Main.execute(ARGV.dup)

data/lib/dandelion.rb

@@ -1,60 +1,18 @@
-require 'dandelion/deployment'
-require 'dandelion/service'
-require 'yaml'
-
 module Dandelion
   class << self
-    def run
-      unless File.exists? '.git'
-        puts 'Not a git repository: .git'
-        exit
-      end
-      
-      if ARGV[0]
-        config_file = ARGV[0].strip
-      else
-        config_file = 'dandelion.yml'
-      end
-
-      unless File.exists? config_file
-        puts "Could not find file: #{config_file}"
-        exit
-      end
-
-      config = YAML.load_file config_file
-
-      if config['scheme'] == 'sftp'
-        service = Service::SFTP.new(config['host'], config['username'], config['password'], config['path'])
-      else
-        puts "Unsupported scheme: #{config['scheme']}"
-        exit
-      end
-
-      puts "Connecting to:    #{service.uri}"
-
-      begin
-        begin
-          # Deploy changes since remote revision
-          deployment = Deployment::DiffDeployment.new('.', service, config['exclude'])
-
-          puts "Remote revision:  #{deployment.remote_revision}"
-          puts "Local revision:   #{deployment.local_revision}"
-
-          deployment.deploy
-        rescue Service::RemoteRevisionError
-          # No remote revision, deploy everything
-          deployment = Deployment::FullDeployment.new('.', service, config['exclude'])
-
-          puts "Remote revision:  ---"
-          puts "Local revision:   #{deployment.local_revision}"
-
-          deployment.deploy
-        end
-        
-        puts "Deployment complete"
-      rescue Git::DiffError
-        puts "Failed to deploy"
-        puts "Try merging remote changes before deploying again"
+    def logger
+      return @log if @log
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::INFO
+      @log.formatter = formatter
+      @log
+    end
+    
+    private
+    
+    def formatter
+      proc do |severity, datetime, progname, msg| 
+        "#{msg}\n"
       end
     end
   end

data/lib/dandelion/cli.rb

@@ -0,0 +1,150 @@
+require 'dandelion'
+require 'dandelion/deployment'
+require 'dandelion/git'
+require 'dandelion/service'
+require 'dandelion/version'
+require 'optparse'
+require 'yaml'
+
+module Dandelion
+  module Cli
+    class UnsupportedSchemeError < StandardError; end
+    
+    class Options
+      def initialize
+        @options = {}
+        @optparse = OptionParser.new do |opts|
+          opts.banner = 'Usage: dandelion [options] [config_file]'
+
+          @options[:force] = false
+          opts.on('-f', '--force', 'Force deployment') do
+            @options[:force] = true
+          end
+
+          @options[:status] = false
+          opts.on('-s', '--status', 'Display revision status') do
+            @options[:status] = true;
+          end
+
+          opts.on('-v', '--version', 'Display the current version') do
+            puts "Dandelion v#{Dandelion::VERSION}"
+            exit
+          end
+
+          opts.on('-h', '--help', 'Display this screen') do
+            puts opts
+            exit
+          end
+        end
+      end
+      
+      def parse!(args)
+        @args = args
+        @optparse.parse!(@args)
+      end
+      
+      def config_file
+        if @args[0]
+          @args[0].strip
+        else
+          'dandelion.yml'
+        end
+      end
+      
+      def [](key)
+        @options[key]
+      end
+
+      def []=(key, value)
+        @options[key] = value
+      end
+    end
+    
+    class Main
+      class << self
+        def execute(args)
+          new(args).execute!
+        end
+      end
+      
+      def initialize(args)
+        @options = Options.new
+        @options.parse!(args)
+      end
+      
+      def log
+        Dandelion.logger
+      end
+      
+      def check_files!
+        unless File.exists? '.git'
+          log.fatal('Not a git repository: .git')
+          exit
+        end
+        unless File.exists? @options.config_file
+          log.fatal("Could not find file: #{@options.config_file}")
+          exit
+        end
+      end
+
+      def service(config)
+        if config['scheme'] == 'sftp'
+          Service::SFTP.new(config['host'], config['username'], config['password'], config['path'])
+        else
+          raise UnsupportedSchemeError
+        end
+      end
+      
+      def execute!
+        check_files!
+        config = YAML.load_file @options.config_file
+
+        begin
+          service = service config
+        rescue UnsupportedSchemeError
+          log.fatal("Unsupported scheme: #{config['scheme']}")
+          exit
+        end
+
+        log.info("Connecting to:    #{service.uri}")
+        repo = Git::Repo.new('.')
+
+        begin
+          deployment = Deployment::DiffDeployment.new(repo, service, config['exclude'])
+        rescue Deployment::RemoteRevisionError
+          deployment = Deployment::FullDeployment.new(repo, service, config['exclude'])
+        rescue Git::DiffError
+          log.fatal('Error: could not generate diff')
+          log.fatal('Try merging remote changes before running dandelion again')
+          exit
+        end
+        
+        begin
+          repo.remote_list.each do |remote|
+            deployment.validate_state(remote)
+          end
+        rescue Deployment::FastForwardError
+          if !@options[:force] and !@options[:status]
+            log.warn('Warning: you are trying to deploy unpushed commits')
+            log.warn('This could potentially prevent others from being able to deploy')
+            log.warn('If you are sure you want to this, use the -f option to force deployment')
+            exit
+          end
+        end
+
+        remote_revision = deployment.remote_revision || '---'
+        local_revision = deployment.local_revision
+
+        log.info("Remote revision:  #{remote_revision}")
+        log.info("Local revision:   #{local_revision}")
+
+        if @options[:status]
+          exit
+        end
+
+        deployment.deploy
+        log.info("Deployment complete")
+      end
+    end
+  end
+end

data/lib/dandelion/deployment.rb

@@ -1,100 +1,126 @@
 require 'dandelion/git'
 
-module Deployment
-  class Deployment
-    def initialize(dir, service, exclude = nil, revision = 'HEAD')
-      @service = service
-      @exclude = exclude || []
-      @tree = Git::Tree.new(dir, revision)
-    end
+module Dandelion
+  module Deployment
+    class RemoteRevisionError < StandardError; end
+    class FastForwardError < StandardError; end
+  
+    class Deployment
+      def initialize(repo, service, exclude = nil, revision = 'HEAD')
+        @repo = repo
+        @service = service
+        @exclude = exclude || []
+        @tree = Git::Tree.new(@repo, revision)
+      end
     
-    def local_revision
-      @tree.revision
-    end
+      def local_revision
+        @tree.revision
+      end
     
-    def remote_uri
-      @service.uri
-    end
+      def remote_revision
+        nil
+      end
     
-    def write_revision
-      @service.write('.revision', local_revision)
-    end
+      def remote_uri
+        @service.uri
+      end
     
-    protected
+      def write_revision
+        @service.write('.revision', local_revision)
+      end
+      
+      def validate_state(remote = nil)
+        if remote and @repo.git.native(:remote, {:raise => true}, 'show', remote) =~ /fast-forward/i
+          raise FastForwardError
+        end
+      end
+      
+      def log
+        Dandelion.logger
+      end
     
-    def exclude_file?(file)
-      return @exclude.map { |e| file.start_with?(e) }.any?
-    end
-  end
-  
-  class DiffDeployment < Deployment
-    def initialize(dir, service, exclude = nil, revision = 'HEAD')
-      super(dir, service, exclude, revision)
-      @diff = Git::Diff.new(dir, read_revision)
-    end
+      protected
     
-    def remote_revision
-      @diff.revision
+      def exclude_file?(file)
+        return @exclude.map { |e| file.start_with?(e) }.any?
+      end
     end
+  
+    class DiffDeployment < Deployment
+      def initialize(repo, service, exclude = nil, revision = 'HEAD')
+        super(repo, service, exclude, revision)
+        @diff = Git::Diff.new(@repo, read_remote_revision, revision)
+      end
     
-    def deploy
-      if !revisions_match? && any?
-        deploy_changed
-        deploy_deleted
-      else
-        puts "Nothing to deploy"
-      end
-      unless revisions_match?
-        write_revision
+      def remote_revision
+        @diff.from_revision
       end
-    end
     
-    def deploy_changed
-      @diff.changed.each do |file|
-        if exclude_file?(file)
-          puts "Skipping file: #{file}"
+      def deploy
+        if !revisions_match? && any?
+          deploy_changed
+          deploy_deleted
         else
-          puts "Uploading file: #{file}"
-          @service.write(file, @tree.show(file))
+          log.info("Nothing to deploy")
+        end
+        unless revisions_match?
+          write_revision
         end
       end
-    end
     
-    def deploy_deleted
-      @diff.deleted.each do |file|
-        if exclude_file?(file)
-          puts "Skipping file: #{file}"
-        else
-          puts "Deleting file: #{file}"
-          @service.delete(file)
+      def deploy_changed
+        @diff.changed.each do |file|
+          if exclude_file?(file)
+            log.info("Skipping file: #{file}")
+          else
+            log.info("Uploading file: #{file}")
+            @service.write(file, @tree.show(file))
+          end
         end
       end
-    end
     
-    def any?
-      @diff.changed.any? || @diff.deleted.any?
-    end
+      def deploy_deleted
+        @diff.deleted.each do |file|
+          if exclude_file?(file)
+            log.info("Skipping file: #{file}")
+          else
+            log.info("Deleting file: #{file}")
+            @service.delete(file)
+          end
+        end
+      end
     
-    def revisions_match?
-      remote_revision == local_revision
-    end
+      def any?
+        @diff.changed.any? || @diff.deleted.any?
+      end
+    
+      def revisions_match?
+        remote_revision == local_revision
+      end
     
-    private
+      private
     
-    def read_revision
-      @service.read('.revision').chomp
+      def read_remote_revision
+        begin
+          @service.read('.revision').chomp
+        rescue Service::MissingFileError
+          raise RemoteRevisionError
+        end
+      end
     end
-  end
   
-  class FullDeployment < Deployment
-    def deploy
-      @tree.files.each do |file|
-        unless exclude_file?(file)
-          puts "Uploading file: #{file}"
-          @service.write(file, @tree.show(file))
+    class FullDeployment < Deployment
+      def deploy
+        @tree.files.each do |file|
+          if exclude_file?(file)
+            log.info("Skipping file: #{file}")
+          else
+            log.info("Uploading file: #{file}")
+            @service.write(file, @tree.show(file))
+          end
         end
+        write_revision
       end
-      write_revision
     end
   end
 end

data/lib/dandelion/git.rb

@@ -1,60 +1,69 @@
 require 'grit'
 
-module Git
-  class DiffError < StandardError; end
+module Dandelion
+  module Git
+    class DiffError < StandardError; end
   
-  class Diff
-    attr_reader :revision
-  
-    def initialize(dir, revision)
-      @revision = revision
-      @raw = `cd #{dir}; git diff --name-status #{@revision} HEAD`
-      check_state!
-    end
-
-    def changed
-      files_flagged ['A', 'C', 'M']
-    end
-
-    def deleted
-      files_flagged ['D']
+    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)
+        @repo = repo
+        @from_revision = from_revision
+        @to_revision = to_revision
+        begin
+          @files = parse_diff @repo.git.native(:diff, {:name_status => true, :raise => true}, from_revision, to_revision)
+        rescue Grit::Git::CommandFailed
+          raise DiffError
+        end
+      end
 
-    private
+      def changed
+        @files.select { |file, status| ['A', 'C', 'M'].include?(status) }.keys
+      end
 
-    def files_flagged(statuses)
-      items = []
-      @raw.split("\n").each do |line|
-        status, file = line.split("\t")
-        items << file if statuses.include? status
+      def deleted
+        @files.select { |file, status| 'D' == status }.keys
       end
-      items
-    end
+
+      private
     
-    def check_state!
-      if $?.exitstatus != 0
-        raise DiffError
+      def parse_diff(diff)
+        files = {}
+        diff.split("\n").each do |line|
+          status, file = line.split("\t")
+          files[file] = status
+        end
+        files
       end
     end
-  end
 
-  class Tree
-    def initialize(dir, revision)
-      @dir = dir
-      @commit = Grit::Repo.new(dir).commit(revision)
-      @tree = @commit.tree
-    end
+    class Tree
+      def initialize(repo, revision)
+        @repo = repo
+        @commit = @repo.commit(revision)
+        @tree = @commit.tree
+      end
     
-    def files
-      `cd #{@dir}; git ls-tree --name-only -r #{revision}`.split("\n")
-    end
+      def files
+        @repo.git.native(:ls_tree, {:name_only => true}, revision).split("\n")
+      end
 
-    def show(file)
-      (@tree / file).data
-    end
+      def show(file)
+        (@tree / file).data
+      end
   
-    def revision
-      @commit.sha
+      def revision
+        @commit.sha
+      end
     end
   end
 end

data/lib/dandelion/service.rb

@@ -1,89 +1,91 @@
 require 'net/sftp'
 require 'tempfile'
 
-module Service
-  class RemoteRevisionError < StandardError; end
+module Dandelion
+  module Service
+    class MissingFileError < StandardError; end
   
-  class Service
-    def initialize(host, username, path)
-      @host = host
-      @username = username
-      @path = path
-    end
+    class Service
+      def initialize(host, username, path)
+        @host = host
+        @username = username
+        @path = path
+      end
     
-    def uri
-      "#{@scheme}://#{@username}@#{@host}/#{@path}"
+      def uri
+        "#{@scheme}://#{@username}@#{@host}/#{@path}"
+      end
     end
-  end
   
-  class SFTP < Service
-    def initialize(host, username, password, path)
-      super(host, username, path)
-      @scheme = 'sftp'
-      @sftp = Net::SFTP.start(host, username, :password => password)
-    end
+    class SFTP < Service
+      def initialize(host, username, password, path)
+        super(host, username, path)
+        @scheme = 'sftp'
+        @sftp = Net::SFTP.start(host, username, :password => password)
+      end
     
-    def read(file)
-      begin
-        @sftp.file.open(File.join(@path, file), 'r') do |f|
-          f.gets
+      def read(file)
+        begin
+          @sftp.file.open(File.join(@path, file), 'r') do |f|
+            f.gets
+          end
+        rescue Net::SFTP::StatusException => e
+          raise unless e.code == 2
+          raise MissingFileError
         end
-      rescue Net::SFTP::StatusException => e
-        raise unless e.code == 2
-        raise RemoteRevisionError
       end
-    end
     
-    def write(file, data)
-      path = File.join(@path, file)
-      begin
-        dir = File.dirname(path)
-        @sftp.stat!(dir)
-      rescue Net::SFTP::StatusException => e
-        raise unless e.code == 2
-        mkdir_p(dir)
+      def write(file, data)
+        path = File.join(@path, file)
+        begin
+          dir = File.dirname(path)
+          @sftp.stat!(dir)
+        rescue Net::SFTP::StatusException => e
+          raise unless e.code == 2
+          mkdir_p(dir)
+        end
+        tmp = Tempfile.new(file.gsub('/', '.'))
+        tmp << data
+        tmp.flush
+        @sftp.upload!(tmp.path, path)
+        tmp.close
       end
-      tmp = Tempfile.new(file.gsub('/', '.'))
-      tmp << data
-      tmp.flush
-      @sftp.upload!(tmp.path, path)
-      tmp.close
-    end
     
-    def delete(file)
-      begin
-        path = File.join(@path, file)
-        @sftp.remove!(path)
-        cleanup(File.dirname(path))
-      rescue Net::SFTP::StatusException => e
-        raise unless e.code == 2
+      def delete(file)
+        begin
+          path = File.join(@path, file)
+          @sftp.remove!(path)
+          cleanup(File.dirname(path))
+        rescue Net::SFTP::StatusException => e
+          raise unless e.code == 2
+        end
       end
-    end
     
-    private
+      private
     
-    def cleanup(dir)
-      unless File.identical?(dir, @path)
-        if empty?(dir)
-          @sftp.rmdir!(dir)
-          cleanup(File.dirname(dir))
+      def cleanup(dir)
+        unless File.identical?(dir, @path)
+          if empty?(dir)
+            @sftp.rmdir!(dir)
+            cleanup(File.dirname(dir))
+          end
         end
       end
-    end
     
-    def empty?(dir)
-      @sftp.dir.entries(dir).map do |entry|
-        entry.name unless entry.name == '.' or entry.name == '..'
-      end.compact.empty?
-    end
+      def empty?(dir)
+        @sftp.dir.entries(dir).map do |entry|
+          entry.name unless entry.name == '.' or entry.name == '..'
+        end.compact.empty?
+      end
     
-    def mkdir_p(dir)
-      begin
-        @sftp.mkdir!(dir)
-      rescue Net::SFTP::StatusException => e
-        raise unless e.code == 2
-        mkdir_p(File.dirname(dir))
-        mkdir_p(dir)
+      def mkdir_p(dir)
+        begin
+          @sftp.mkdir!(dir)
+        rescue Net::SFTP::StatusException => e
+          raise unless e.code == 2
+          mkdir_p(File.dirname(dir))
+          mkdir_p(dir)
+        end
       end
     end
   end

data/lib/dandelion/version.rb

@@ -1,3 +1,3 @@
 module Dandelion
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

metadata

@@ -2,7 +2,7 @@
 name: dandelion
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Scott Nelson
@@ -52,6 +52,7 @@ files:
 - bin/dandelion
 - dandelion.gemspec
 - lib/dandelion.rb
+- lib/dandelion/cli.rb
 - lib/dandelion/deployment.rb
 - lib/dandelion/git.rb
 - lib/dandelion/service.rb
@@ -83,6 +84,6 @@ rubyforge_project:
 rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
-summary: dandelion-0.1.4
+summary: dandelion-0.1.5
 test_files: []