dandelion 0.3.15 → 0.4.0.beta2

data/lib/dandelion/{backend → adapter}/sftp.rb

@@ -1,20 +1,21 @@
-require 'dandelion/backend'
 require 'pathname'
+require 'dandelion/utils'
 
 module Dandelion
-  module Backend
-    class SFTP < Backend::Base
-      scheme 'sftp'
-      gems 'net-sftp'
+  module Adapter
+    class SFTP < Adapter::Base
+      include ::Dandelion::Utils
+
+      adapter 'sftp'
+      requires_gems 'net-sftp'
       
       def initialize(config)
         require 'net/sftp'
-        @config = { 'preserve_permissions' => true }.merge(config)
-        options = {
-          :password => @config['password'],
-          :port => @config['port'] || Net::SSH::Transport::Session::DEFAULT_PORT,
-        }
-        @sftp = Net::SFTP.start(@config['host'], @config['username'], options)
+
+        @config = config
+        @config.defaults(preserve_permissions: true)
+
+        @sftp = sftp_client
       end
 
       def read(file)
@@ -24,7 +25,7 @@ module Dandelion
           end
         rescue Net::SFTP::StatusException => e
           raise unless e.code == 2
-          raise MissingFileError
+          nil
         end
       end
 
@@ -38,9 +39,10 @@ module Dandelion
             @sftp.upload!(temp, path(file))
           end
         end
-        if @config['preserve_permissions']
+
+        if @config[:preserve_permissions]
           mode = get_mode(file)
-          @sftp.setstat!(path(file), :permissions => mode) if mode
+          @sftp.setstat!(path(file), permissions: mode) if mode
         end
       end
 
@@ -59,6 +61,15 @@ module Dandelion
 
       private
 
+      def sftp_client
+        options = {
+          password: @config['password'],
+          port: @config['port'] || Net::SSH::Transport::Session::DEFAULT_PORT,
+        }
+
+        Net::SFTP.start(@config['host'], @config['username'], options)
+      end
+
       def get_mode(file)
         stat = File.stat(file) if File.exists?(file)
         stat.mode if stat
@@ -78,7 +89,9 @@ module Dandelion
       end
       
       def empty?(dir)
-        @sftp.dir.entries(dir).delete_if { |file| file.name == '.' or file.name == '..' }.empty?
+        @sftp.dir.entries(dir).delete_if do |file|
+          file.name == '.' or file.name == '..'
+        end.empty?
       end
 
       def mkdir_p(dir)
@@ -100,4 +113,4 @@ module Dandelion
       end
     end
   end
-end
+end

data/lib/dandelion/change.rb

@@ -0,0 +1,11 @@
+module Dandelion
+  class Change
+    attr_reader :path, :type, :data
+    
+    def initialize(path, type, data = nil)
+      @path = path
+      @type = type
+      @data = data
+    end
+  end
+end

data/lib/dandelion/changeset.rb

@@ -0,0 +1,49 @@
+module Dandelion
+  class Changeset
+    include Enumerable
+    
+    def initialize(tree, commit, options = {})
+      @tree = tree
+      @commit = commit
+      @options = options
+    end
+
+    def diff
+      Diff.new(@commit, @tree.commit)
+    end
+
+    def empty?
+      diff.empty?
+    end
+
+    def each
+      diff.each do |change|
+        if applicable?(change.path)
+          path = transform_path(change.path)
+
+          if change.type == :delete
+            yield Change.new(path, change.type)
+          else
+            yield Change.new(path, change.type, @tree.data(change.path))
+          end
+        end
+      end
+    end
+
+  private
+
+    def local_path
+      @options[:local_path] || ''
+    end
+
+    def applicable?(path)
+      path.start_with?(local_path)
+    end
+
+    def transform_path(path)
+      trimmed = path[local_path.length..-1]
+      trimmed = trimmed[1..-1] if trimmed[0] == File::SEPARATOR
+      trimmed
+    end
+  end
+end

data/lib/dandelion/cli.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+
+module Dandelion
+  class CLI
+    def initialize(args)
+      @args = args
+      @options = {}
+      @parser = Command::Base.parser(@options)
+    end
+
+    def config
+      @config ||= Config.new(path: config_path).tap do |config|
+        config[:adapter] ||= config[:scheme] # backward compat
+      end
+    end
+
+    def adapter
+      @adapter ||= Adapter::Base.create_adapter(config[:adapter], config)
+    rescue Adapter::InvalidAdapterError => e
+      log.fatal("Unsupported adapter: #{config[:adapter]}")
+      exit 1
+    rescue Adapter::MissingDependencyError => e
+      log.fatal("The #{config[:adapter]} adapter requires additional gems:")
+      log.fatal(e.gems.map { |name| "    #{name}"}.join("\n"))
+      log.fatal("Please install the gems first: gem install #{e.gems.join(' ')}")
+      exit 1
+    end
+
+    def repo
+      @repo ||= Rugged::Repository.new(repo_path)
+    end
+
+    def workspace
+      @workspace ||= Workspace.new(repo, adapter, config)
+    end
+
+    def command_class
+      @command_class ||= Command::Base.lookup(@args.shift.to_sym)
+    rescue Command::InvalidCommandError => e
+      log.fatal("Invalid command: #{e}")
+      display_help
+      exit 1
+    end
+
+    def execute!
+      parse!(@parser)
+
+      if @options[:help]
+        display_help
+        exit
+      end
+
+      if @options[:version]
+        log.info("Dandelion #{Dandelion::VERSION}")
+        exit
+      end
+
+      validate!
+
+      parse!(command_class.parser(@options))
+
+      command = command_class.new(workspace, config, @options)
+      command.setup(@args)
+
+      begin
+        command.execute!
+      rescue RevisionError => e
+        log.fatal("Invalid revision: #{e}")
+        exit 1
+      end
+    end
+
+  private
+
+    def config_path
+      @options[:config] || File.join(repo_path, 'dandelion.yml')
+    end
+
+    def repo_path
+      if @options[:repo]
+        File.expand_path(@options[:repo])
+      else
+        closest_repo(File.expand_path('.'))
+      end
+    end
+
+    def validate!
+      unless File.exists?(File.join(repo_path, '.git'))
+        log.fatal("Not a git repository: #{repo_path}")
+        exit 1
+      end
+
+      unless File.exists?(config_path)
+        log.fatal("Missing config file: #{config_path}")
+        exit 1
+      end
+    end
+
+    def parse!(parser)
+      begin
+        parser.order!(@args)
+      rescue OptionParser::InvalidOption => e
+        log.fatal(e.to_s.capitalize)
+        display_help
+        exit 1
+      end
+    end
+
+    def closest_repo(dir)
+      if File.exists?(File.join(dir, '.git'))
+        dir
+      else
+        File.dirname(dir) != dir && closest_repo(File.dirname(dir)) || File.expand_path('.')
+      end
+    end
+
+    def display_help
+      log.info(@parser.help)
+      log.info("Available commands:")
+      log.info(Command::Base.commands.map { |c| "    #{c}"}.join("\n"))
+    end
+
+    def log
+      Dandelion.logger
+    end
+  end
+end

data/lib/dandelion/command.rb

@@ -1,10 +1,4 @@
-require 'dandelion'
-require 'dandelion/backend'
-require 'dandelion/deployment'
-require 'dandelion/git'
-require 'dandelion/version'
 require 'optparse'
-require 'yaml'
 
 module Dandelion
   module Command
@@ -18,123 +12,63 @@ module Dandelion
           @@commands[name] = self
         end
 
-        def create(name)
-          require_commands
-          raise InvalidCommandError unless @@commands.include?(name)
-          @@commands[name]
-        end
-
         def commands
           @@commands.keys
         end
 
-        def require_commands
-          Dir.glob(File.join(File.dirname(__FILE__), 'command', '*.rb')) { |file| require file }
+        def lookup(name)
+          raise InvalidCommandError.new(name) unless @@commands[name]
+          @@commands[name]
         end
 
         def parser(options)
           OptionParser.new do |opts|
             opts.banner = 'Usage: dandelion [options] <command> [<args>]'
 
-            opts.on('-v', '--version', 'Display the current version') do
-              puts "Dandelion #{Dandelion::VERSION}"
-              exit
+            options[:version] = false
+            opts.on('-v', '--version', 'Dispay the current version') do
+              options[:version] = true
             end
 
-            opts.on('-h', '--help', 'Display this screen') do
-              require_commands
-              puts opts
-              puts "\nAvailable commands:"
-              puts commands.map { |name| "    #{name}" }.join("\n")
-              exit
+            options[:help] = false
+            opts.on('-h', '--help', 'Display this help info') do
+              options[:help] = true
             end
 
-            opts.on('--log=[level]', 'Use the given log level (fatal, error, warn, info, debug)') do |level|
-              levels = {
-                :fatal => Logger::FATAL,
-                :error => Logger::ERROR,
-                :warn => Logger::WARN,
-                :info => Logger::INFO,
-                :debug => Logger::DEBUG
-              }
-
-              Dandelion.logger.level = levels[level.to_sym]
-            end
-
-            options[:repo] = closest_repo(File.expand_path('.'))
+            options[:repo] = nil
             opts.on('--repo=[REPO]', 'Use the given repository') do |repo|
-              options[:repo] = File.expand_path(repo)
+              options[:repo] = repo
             end
 
             options[:config] = nil
-            opts.on('--config=[CONFIG]', 'Use the given configuration file') do |config|
-              options[:config] = File.expand_path(config)
+            opts.on('--config=[CONFIG]', 'Use the given config file') do |config|
+              options[:config] = config
             end
           end
         end
-
-        private
-
-        def closest_repo(dir)
-          if File.exists?(File.join(dir, '.git'))
-            dir
-          else
-            File.dirname(dir) != dir && closest_repo(File.dirname(dir)) || File.expand_path('.')
-          end
-        end
       end
 
-      def initialize(options)
-        @options = options
-        @config = YAML.load_file(@options[:config])
-        @repo = Git::Repo.new(@options[:repo])
+      attr_reader :workspace, :config, :options
 
-        yield(self) if block_given?
+      def initialize(workspace, config, options = {})
+        @workspace = workspace
+        @config = config
+        @options = options
       end
 
-      protected
-
-      def log
-        Dandelion.logger
+      def setup(args)
       end
 
-      def backend
-        begin
-          backend = Backend::Base.create(@config)
-          log.info("Connecting to #{backend}")
-          backend
-        rescue Backend::MissingDependencyError => e
-          log.fatal("The '#{@config['scheme']}' scheme requires additional gems:")
-          log.fatal(e.gems.map { |name| "    #{name}" }.join("\n"))
-          log.fatal("Please install the gems: gem install #{e.gems.join(' ')}")
-          exit 1
-        rescue Backend::UnsupportedSchemeError
-          log.fatal("Unsupported scheme: #{@config['scheme']}")
-          exit 1
-        end
+      def adapter
+        workspace.adapter
       end
 
-      def deployment(revision, backend = nil)
-        begin
-          backend ||= backend()
-          revision_file = @config['revision_file'].nil? ? '.revision' : @config['revision_file']
-          local_path = @config['local_path'].nil? ? '' : @config['local_path']
-          options = {
-            :dry => @options[:dry],
-            :exclude => @config['exclude'],
-            :additional => @config['additional'],
-            :revision => revision,
-            :revision_file => revision_file,
-            :local_path => local_path
-          }
-
-          Deployment::Deployment.create(@repo, backend, options)
-        rescue Git::DiffError
-          log.fatal('Error: could not generate diff')
-          log.fatal('Try merging remote changes before running dandelion again')
-          exit 1
-        end
+      def log
+        Dandelion.logger
       end
     end
   end
 end
+
+require 'dandelion/command/deploy'
+require 'dandelion/command/status'

data/lib/dandelion/command/deploy.rb

@@ -1,54 +1,67 @@
 module Dandelion
   module Command
     class Deploy < Command::Base
-      command 'deploy'
-  
-      class << self
-        def parser(options)
-          OptionParser.new do |opts|
-            opts.banner = 'Usage: deploy [options] [<revision>]'
-      
-            options[:force] = false
-            opts.on('-f', '--force', 'Force deployment') do
-              options[:force] = true
-            end
-            
-            options[:dry] = false
-            opts.on('--dry-run', 'Show what would have been deployed') do
-              options[:dry] = true
-            end
+      command :deploy
+
+      def self.parser(options)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: dandelion deploy [options] [<revision>]'
+
+          options[:dry] = false
+          opts.on('--dry-run', 'Show what would have been deployed') do
+            options[:dry] = true
           end
         end
       end
-      
+
       def setup(args)
-        @revision = args.shift || 'HEAD'
+        config[:revision] = args.shift || nil
       end
-  
-      def execute
-        begin
-          @deployment = deployment(@revision)
-        rescue Git::RevisionError
-          log.fatal("Invalid revision: #{@revision}")
-          exit 1
-        end
-        
-        log.info("Remote revision:      #{@deployment.remote_revision || '---'}")
-        log.info("Deploying revision:   #{@deployment.local_revision}")
+
+      def execute!
+        log.info("Connecting to #{adapter.to_s}")
+
+        local_commit = workspace.local_commit
+        remote_commit = workspace.remote_commit
         
-        begin
-          @deployment.validate
-        rescue Deployment::FastForwardError
-          if !@options[:force]
-            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 do this, use the -f option to force deployment')
-            exit 1
-          end
+        log.info("Remote revision:    #{remote_commit ? remote_commit.oid : '---'}")
+        log.info("Deploying revision: #{local_commit.oid}")
+
+        deploy_changeset!
+        deploy_additional_files!        
+      end
+
+      def deployer_adapter
+        if options[:dry]
+          Adapter::NoOpAdapter.new(config)
+        else
+          adapter
+        end
+      end
+
+      def deployer
+        @deployer ||= Deployer.new(deployer_adapter, config)
+      end
+
+    private
+
+      def deploy_changeset!
+        changeset = workspace.changeset
+
+        if changeset.empty?
+          log.info("No changes to deploy")
+        else
+          log.info("Deploying changes...")
+          deployer.deploy_changeset!(workspace.changeset)
+          workspace.remote_commit = workspace.local_commit unless options[:dry]
+        end
+      end
+
+      def deploy_additional_files!
+        if config[:additional] && config[:additional].length > 0
+          log.info("Deploying additional files...")
+          deployer.deploy_files!(config[:additional])
         end
-        
-        @deployment.deploy
-        log.info("Deployment complete")
       end
     end
   end