Refactoring

- Create a class per method
- Create a class per git strategy
- Extract USAGE into a file
- Refactor git and ftp/sftp methods

USAGE

@@ -0,0 +1,55 @@
+You should follow one of the four examples below to setup the deploy
+extension in config.rb.
+
+# To deploy the build directory to a remote host via rsync:
+activate :deploy do |deploy|
+  deploy.method = :rsync
+  # host and path *must* be set
+  deploy.host = "www.example.com"
+  deploy.path = "/srv/www/site"
+  # user is optional (no default)
+  deploy.user = "tvaughan"
+  # port is optional (default is 22)
+  deploy.port  = 5309
+  # clean is optional (default is false)
+  deploy.clean = true
+  # flags is optional (default is -avze)
+  deploy.flags = "-rltgoDvzO --no-p --del -e"
+end
+
+# To deploy to a remote branch via git (e.g. gh-pages on github):
+activate :deploy do |deploy|
+  deploy.method = :git
+  # remote is optional (default is "origin")
+  # run `git remote -v` to see a list of possible remotes
+  deploy.remote = "some-other-remote-name"
+
+  # branch is optional (default is "gh-pages")
+  # run `git branch -a` to see a list of possible branches
+  deploy.branch = "some-other-branch-name"
+
+  # strategy is optional (default is :force_push)
+  deploy.strategy = :submodule
+end
+
+# To deploy the build directory to a remote host via ftp:
+activate :deploy do |deploy|
+  deploy.method = :ftp
+  # host, user, passwword and path *must* be set
+  deploy.host = "ftp.example.com"
+  deploy.path = "/srv/www/site"
+  deploy.user = "tvaughan"
+  deploy.password = "secret"
+end
+
+# To deploy the build directory to a remote host via sftp:
+activate :deploy do |deploy|
+  deploy.method = :sftp
+  # host, user, passwword and path *must* be set
+  deploy.host = "sftp.example.com"
+  deploy.path = "/srv/www/site"
+  # user is optional (no default)
+  deploy.user = "tvaughan"
+  # password is optional (no default)
+  deploy.password = "secret"
+end

lib/middleman-deploy/commands.rb

@@ -1,6 +1,8 @@
 require "middleman-core/cli"
 
 require "middleman-deploy/extension"
+require "middleman-deploy/methods"
+require "middleman-deploy/strategies"
 require "middleman-deploy/pkg-info"
 
 module Middleman
@@ -24,301 +26,68 @@ module Middleman
         :type     => :boolean,
         :aliases  => "-b",
         :desc     => "Run `middleman build` before the deploy step"
-
       def deploy
-        if options.has_key? "build_before"
+        build_before(options)
-          build_before = options.build_before
+        process
-        else
-          build_before = self.deploy_options.build_before
-        end
-        if build_before
-          # http://forum.middlemanapp.com/t/problem-with-the-build-task-in-an-extension
-          run("middleman build") || exit(1)
-        end
-        send("deploy_#{self.deploy_options.method}")
       end
 
       protected
 
+      def build_before(options={})
+        build_enabled = options.fetch('build_before', self.deploy_options.build_before)
+
+        if build_enabled
+          # http://forum.middlemanapp.com/t/problem-with-the-build-task-in-an-extension
+          run('middleman build') || exit(1)
+        end
+      end
+
       def print_usage_and_die(message)
-        raise Error, "ERROR: " + message + "\n" + <<EOF
+        usage_path    = File.join(File.dirname(__FILE__), '..', '..', 'USAGE')
+        usage_message = File.read(usage_path)
 
-You should follow one of the four examples below to setup the deploy
+        raise Error, "ERROR: #{message}\n#{usage_message}"
-extension in config.rb.
-
-# To deploy the build directory to a remote host via rsync:
-activate :deploy do |deploy|
-  deploy.method = :rsync
-  # host and path *must* be set
-  deploy.host = "www.example.com"
-  deploy.path = "/srv/www/site"
-  # user is optional (no default)
-  deploy.user = "tvaughan"
-  # port is optional (default is 22)
-  deploy.port  = 5309
-  # clean is optional (default is false)
-  deploy.clean = true
-  # flags is optional (default is -avze)
-  deploy.flags = "-rltgoDvzO --no-p --del -e"
       end
 
-# To deploy to a remote branch via git (e.g. gh-pages on github):
+      def process
-activate :deploy do |deploy|
+        server_instance   = ::Middleman::Application.server.inst
-  deploy.method = :git
-  # remote is optional (default is "origin")
-  # run `git remote -v` to see a list of possible remotes
-  deploy.remote = "some-other-remote-name"
 
-  # branch is optional (default is "gh-pages")
+        camelized_method  = self.deploy_options.method.to_s.split('_').map { |word| word.capitalize}.join
-  # run `git branch -a` to see a list of possible branches
+        method_class_name = "Middleman::Deploy::Methods::#{camelized_method}"
-  deploy.branch = "some-other-branch-name"
+        method_instance   = method_class_name.constantize.new(server_instance, self.deploy_options)
 
-  # strategy is optional (default is :force_push)
+        method_instance.process
-  deploy.strategy = :submodule
-end
-
-# To deploy the build directory to a remote host via ftp:
-activate :deploy do |deploy|
-  deploy.method = :ftp
-  # host, user, passwword and path *must* be set
-  deploy.host = "ftp.example.com"
-  deploy.path = "/srv/www/site"
-  deploy.user = "tvaughan"
-  deploy.password = "secret"
-end
-
-# To deploy the build directory to a remote host via sftp:
-activate :deploy do |deploy|
-  deploy.method = :sftp
-  # host, user, passwword and path *must* be set
-  deploy.host = "sftp.example.com"
-  deploy.path = "/srv/www/site"
-  # user is optional (no default)
-  deploy.user = "tvaughan"
-  # password is optional (no default)
-  deploy.password = "secret"
-end
-EOF
-      end
-
-      def inst
-        ::Middleman::Application.server.inst
       end
 
       def deploy_options
         options = nil
 
         begin
-          options = inst.options
+          options = ::Middleman::Application.server.inst.options
         rescue NoMethodError
           print_usage_and_die "You need to activate the deploy extension in config.rb."
         end
 
-        if (!options.method)
+        unless options.method
           print_usage_and_die "The deploy extension requires you to set a method."
         end
 
         case options.method
         when :rsync, :sftp
-          if (!options.host || !options.path)
+          unless options.host && options.path
             print_usage_and_die "The #{options.method} method requires host and path to be set."
           end
         when :ftp
-          if (!options.host || !options.user || !options.password || !options.path)
+          unless options.host && options.user && options.password && options.path
             print_usage_and_die "The ftp deploy method requires host, path, user, and password to be set."
           end
         end
 
         options
       end
-
-      def deploy_rsync
-        host = self.deploy_options.host
-        port = self.deploy_options.port
-        path = self.deploy_options.path
-
-        # Append "@" to user if provided.
-        user = self.deploy_options.user
-        user = "#{user}@" if user && !user.empty?
-
-        dest_url = "#{user}#{host}:#{path}"
-
-        puts "## Deploying via rsync to #{dest_url} port=#{port}"
-
-        flags = !self.deploy_options.flags ? '-avze' : self.deploy_options.flags
-
-        command = "rsync " + flags + " '" + "ssh -p #{port}" + "' #{self.inst.build_dir}/ #{dest_url}"
-
-        if self.deploy_options.clean
-          command += " --delete"
-        end
-
-        run command
-      end
-
-      def deploy_git
-        remote    = self.deploy_options.remote
-        branch    = self.deploy_options.branch
-        strategy  = self.deploy_options.strategy
-
-        commit_signature  = "#{Middleman::Deploy::PACKAGE} #{Middleman::Deploy::VERSION}"
-        commit_time       = "#{Time.now.utc}"
-        push_options      = (strategy == :force_push ? ' -f' : nil)
-
-        puts "## Deploying via git to remote=\"#{remote}\" and branch=\"#{branch}\""
-
-        #check if remote is not a git url
-        unless remote =~ /\.git$/
-          remote = `git config --get remote.#{remote}.url`.chop
-        end
-
-        #if the remote name doesn't exist in the main repo
-        if remote == ''
-          puts "Can't deploy! Please add a remote with the name '#{self.deploy_options.remote}' to your repo."
-          exit
-        end
-
-        Dir.chdir(self.inst.build_dir) do
-          if strategy == :force_push
-            unless File.exists?('.git')
-              `git init`
-              `git remote add origin #{remote}`
-            else
-              #check if the remote repo has changed
-              unless remote == `git config --get remote.origin.url`.chop
-                `git remote rm origin`
-                `git remote add origin #{remote}`
-              end
-            end
-          end
-
-          #if there is a branch with that name, switch to it, otherwise create a new one and switch to it
-          if `git branch`.split("\n").any? { |b| b =~ /#{branch}/i }
-            `git checkout #{branch}`
-          else
-            `git checkout -b #{branch}`
-          end
-
-          if strategy == :submodule
-            `git fetch`
-            `git stash`
-            `git rebase #{self.deploy_options.remote}/#{branch}`
-            `git stash pop`
-
-            if $?.exitstatus == 1
-              puts "Can't deploy! Please resolve conflicts. Then process to manual commit and push on #{branch} branch."
-              exit
-            end
-          end
-
-          `git add -A`
-          `git commit --allow-empty -am "Automated commit at #{commit_time} by #{commit_signature}"`
-          `git push #{push_options} origin #{branch}`
-        end
-
-        if strategy == :submodule
-          current_branch = `git rev-parse --abbrev-ref HEAD`
-
-          `git add #{self.inst.build_dir}`
-          `git commit --allow-empty -m "Deployed at #{commit_time} by #{commit_signature}"`
-          `git push origin #{current_branch}`
-        end
-      end
-
-      def deploy_ftp
-        require 'net/ftp'
-        require 'ptools'
-
-        host = self.deploy_options.host
-        user = self.deploy_options.user
-        pass = self.deploy_options.password
-        path = self.deploy_options.path
-
-        puts "## Deploying via ftp to #{user}@#{host}:#{path}"
-
-        ftp = Net::FTP.new(host)
-        ftp.login(user, pass)
-        ftp.chdir(path)
-        ftp.passive = true
-
-        Dir.chdir(self.inst.build_dir) do
-          files = Dir.glob('**/*', File::FNM_DOTMATCH)
-          files.reject { |a| a =~ Regexp.new('\.$') }.each do |f|
-            if File.directory?(f)
-              begin
-                ftp.mkdir(f)
-                puts "Created directory #{f}"
-              rescue
-              end
-            else
-              begin
-                if File.binary?(f)
-                  ftp.putbinaryfile(f, f)
-                else
-                  ftp.puttextfile(f, f)
-                end
-              rescue Exception => e
-                reply = e.message
-                err_code = reply[0,3].to_i
-                if err_code == 550
-                  if File.binary?(f)
-                    ftp.putbinaryfile(f, f)
-                  else
-                    ftp.puttextfile(f, f)
-                  end
-                end
-              end
-              puts "Copied #{f}"
-            end
-          end
-        end
-        ftp.close
-      end
-
-      def deploy_sftp
-        require 'net/sftp'
-        require 'ptools'
-
-        host = self.deploy_options.host
-        user = self.deploy_options.user
-        pass = self.deploy_options.password
-        path = self.deploy_options.path
-
-        puts "## Deploying via sftp to #{user}@#{host}:#{path}"
-
-        # `nil` is a valid value for user and/or pass.
-        Net::SFTP.start(host, user, :password => pass) do |sftp|
-          sftp.mkdir(path)
-          Dir.chdir(self.inst.build_dir) do
-            files = Dir.glob('**/*', File::FNM_DOTMATCH)
-            files.reject { |a| a =~ Regexp.new('\.$') }.each do |f|
-              if File.directory?(f)
-                begin
-                  sftp.mkdir("#{path}/#{f}")
-                  puts "Created directory #{f}"
-                rescue
-                end
-              else
-                begin
-                  sftp.upload(f, "#{path}/#{f}")
-                rescue Exception => e
-                  reply = e.message
-                  err_code = reply[0,3].to_i
-                  if err_code == 550
-                    sftp.upload(f, "#{path}/#{f}")
-                  end
-                end
-                puts "Copied #{f}"
-              end
-            end
-          end
-        end
-      end
-
     end
 
     # Alias "d" to "deploy"
     Base.map({ "d" => "deploy" })
-
   end
 end

lib/middleman-deploy/methods.rb

@@ -0,0 +1,5 @@
+require 'middleman-deploy/methods/base'
+require 'middleman-deploy/methods/ftp'
+require 'middleman-deploy/methods/git'
+require 'middleman-deploy/methods/rsync'
+require 'middleman-deploy/methods/sftp'

lib/middleman-deploy/methods/base.rb

@@ -0,0 +1,19 @@
+module Middleman
+  module Deploy
+    module Methods
+      class Base
+        attr_reader :options, :server_instance
+
+        def initialize(server_instance, options={})
+          @options          = options
+          @server_instance  = server_instance
+        end
+
+        def process
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

lib/middleman-deploy/methods/ftp.rb

@@ -0,0 +1,101 @@
+require 'net/ftp'
+require 'ptools'
+
+module Middleman
+  module Deploy
+    module Methods
+      class Ftp < Base
+
+        attr_reader :host, :pass, :path,:user
+
+        def initialize(server_instance, options={})
+          super(server_instance, options)
+
+          @host = self.options.host
+          @user = self.options.user
+          @pass = self.options.password
+          @path = self.options.path
+        end
+
+        def process
+          puts "## Deploying via ftp to #{self.user}@#{self.host}:#{self.path}"
+
+          ftp = open_connection
+
+          Dir.chdir(self.server_instance.build_dir) do
+            filtered_files.each do |filename|
+              if File.directory?(filename)
+                upload_directory(ftp, filename)
+              elsif File.binary?(filename)
+                upload_binary(ftp, filename)
+              else
+                upload_file(ftp, filename)
+              end
+            end
+          end
+
+          ftp.close
+        end
+
+      protected
+
+        def filtered_files
+          files = Dir.glob('**/*', File::FNM_DOTMATCH)
+
+          files.reject { |filename| filename =~ Regexp.new('\.$') }
+        end
+
+        def handle_exception(exception, ftp, filename)
+          reply     = exception.message
+          err_code  = reply[0,3].to_i
+
+          if err_code == 550
+            if File.binary?(filename)
+              ftp.putbinaryfile(filename, filename)
+            else
+              ftp.puttextfile(filename, filename)
+            end
+          end
+        end
+
+        def open_connection
+          ftp = Net::FTP.new(self.host)
+          ftp.login(self.user, self.pass)
+          ftp.chdir(self.path)
+          ftp.passive = true
+
+          ftp
+        end
+
+        def upload_binary(ftp, filename)
+          begin
+            ftp.putbinaryfile(filename, filename)
+          rescue Exception => exception
+            handle_exception(exception, ftp, filename)
+          end
+
+          puts "Copied #{filename}"
+        end
+
+        def upload_directory(ftp, filename)
+          begin
+            ftp.mkdir(filename)
+            puts "Created directory #{filename}"
+          rescue
+          end
+        end
+
+        def upload_file(ftp, filename)
+          begin
+            ftp.puttextfile(filename, filename)
+          rescue Exception => exception
+            handle_exception(exception, ftp, filename)
+          end
+
+          puts "Copied #{filename}"
+        end
+
+      end
+    end
+  end
+end

lib/middleman-deploy/methods/git.rb

@@ -0,0 +1,19 @@
+module Middleman
+  module Deploy
+    module Methods
+      class Git < Base
+
+        def process
+          puts "## Deploying via git to remote=\"#{self.options.remote}\" and branch=\"#{self.options.branch}\""
+
+          camelized_strategy  = self.options.strategy.to_s.split('_').map { |word| word.capitalize}.join
+          strategy_class_name = "Middleman::Deploy::Strategies::Git::#{camelized_strategy}"
+          strategy_instance   = strategy_class_name.constantize.new(self.server_instance.build_dir, self.options.remote, self.options.branch)
+
+          strategy_instance.process
+        end
+
+      end
+    end
+  end
+end

lib/middleman-deploy/methods/rsync.rb

@@ -0,0 +1,38 @@
+module Middleman
+  module Deploy
+    module Methods
+      class Rsync < Base
+
+        attr_reader :clean, :flags, :host, :path, :port, :user
+
+        def initialize(server_instance, options={})
+          super(server_instance, options)
+
+          @clean  = self.options.clean
+          @flags  = self.options.flags
+          @host   = self.options.host
+          @path   = self.options.path
+          @port   = self.options.port
+          @user   = self.options.user
+        end
+
+        def process
+          # Append "@" to user if provided.
+          user      = "#{self.user}@" if self.user && !self.user.empty?
+
+          dest_url  = "#{user}#{self.host}:#{self.path}"
+          flags     = self.flags || '-avze'
+          command   = "rsync #{flags} 'ssh -p #{self.port}' #{self.server_instance.build_dir}/ #{dest_url}"
+
+          if self.clean
+            command += " --delete"
+          end
+
+          puts "## Deploying via rsync to #{dest_url} port=#{self.port}"
+          run command
+        end
+
+      end
+    end
+  end
+end

lib/middleman-deploy/methods/sftp.rb

@@ -0,0 +1,65 @@
+require 'net/sftp'
+require 'ptools'
+
+module Middleman
+  module Deploy
+    module Methods
+      class Sftp < Ftp
+
+        def process
+          puts "## Deploying via sftp to #{self.user}@#{self.host}:#{path}"
+
+          # `nil` is a valid value for user and/or pass.
+          Net::SFTP.start(self.host, self.user, :password => self.pass) do |sftp|
+            sftp.mkdir(self.path)
+
+            Dir.chdir(self.server_instance.build_dir) do
+              filtered_files.each do |filename|
+                if File.directory?(filename)
+                  upload_directory(sftp, filename)
+                else
+                  upload_file(sftp, filename)
+                end
+              end
+            end
+          end
+        end
+
+      protected
+
+        def handle_exception(exception)
+          reply     = exception.message
+          err_code  = reply[0,3].to_i
+
+          if err_code == 550
+            sftp.upload(filename, file_path)
+          end
+        end
+
+        def upload_directory(sftp, filename)
+          file_path = "#{self.path}/#{filename}"
+
+          begin
+            sftp.mkdir(file_path)
+            puts "Created directory #{filename}"
+          rescue
+          end
+        end
+
+        def upload_file(sftp, filename)
+          file_path = "#{self.path}/#{filename}"
+
+          begin
+            sftp.upload(filename, file_path)
+          rescue Exception => exception
+            handle_exception(exception, file_path)
+          end
+
+          puts "Copied #{filename}"
+        end
+
+      end
+    end
+  end
+end
+

lib/middleman-deploy/strategies.rb

@@ -0,0 +1,3 @@
+require 'middleman-deploy/strategies/git/base'
+require 'middleman-deploy/strategies/git/force_push'
+require 'middleman-deploy/strategies/git/submodule'

lib/middleman-deploy/strategies/git/base.rb

@@ -0,0 +1,48 @@
+module Middleman
+  module Deploy
+    module Strategies
+      module Git
+        class Base
+          attr_accessor :branch, :build_dir, :remote
+
+          def initialize(build_dir, remote, branch)
+            self.branch     = branch
+            self.build_dir  = build_dir
+            self.remote     = remote
+          end
+
+          def process
+            raise NotImplementedError
+          end
+
+        protected
+
+          def add_signature_to_commit_message(base_message)
+            signature = "#{Middleman::Deploy::PACKAGE} #{Middleman::Deploy::VERSION}"
+            time      = "#{Time.now.utc}"
+
+            "#{base_message} at #{time} by #{signature}"
+          end
+
+          def checkout_branch
+            # if there is a branch with that name, switch to it, otherwise create a new one and switch to it
+            if `git branch`.split("\n").any? { |b| b =~ /#{self.branch}/i }
+              `git checkout #{self.branch}`
+            else
+              `git checkout -b #{self.branch}`
+            end
+          end
+
+          def commit_branch(options='')
+            message = add_signature_to_commit_message('Automated commit')
+
+            `git add -A`
+            `git commit --allow-empty -am "#{message}"`
+            `git push #{options} origin #{self.branch}`
+          end
+
+        end
+      end
+    end
+  end
+end

lib/middleman-deploy/strategies/git/force_push.rb

@@ -0,0 +1,54 @@
+module Middleman
+  module Deploy
+    module Strategies
+      module Git
+        class ForcePush < Base
+
+          def process
+            Dir.chdir(self.build_dir) do
+              add_remote_url
+              checkout_branch
+              commit_branch('-f')
+            end
+          end
+
+        private
+
+          def add_remote_url
+            url = get_remote_url
+
+            unless File.exists?('.git')
+              `git init`
+              `git remote add origin #{url}`
+            else
+              # check if the remote repo has changed
+              unless url == `git config --get remote.origin.url`.chop
+                `git remote rm origin`
+                `git remote add origin #{url}`
+              end
+            end
+          end
+
+          def get_remote_url
+            remote  = self.remote
+            url     = remote
+
+            # check if remote is not a git url
+            unless remote =~ /\.git$/
+              url = `git config --get remote.#{url}.url`.chop
+            end
+
+            # if the remote name doesn't exist in the main repo
+            if url == ''
+              puts "Can't deploy! Please add a remote with the name '#{remote}' to your repo."
+              exit
+            end
+
+            url
+          end
+
+        end
+      end
+    end
+  end
+end

lib/middleman-deploy/strategies/git/submodule.rb

@@ -0,0 +1,44 @@
+module Middleman
+  module Deploy
+    module Strategies
+      module Git
+        class Submodule < Base
+
+          def process
+            Dir.chdir(self.build_dir) do
+              checkout_branch
+              pull_submodule
+              commit_branch
+            end
+
+            commit_submodule
+          end
+
+        private
+
+          def commit_submodule
+            current_branch  = `git rev-parse --abbrev-ref HEAD`
+            message         = add_signature_to_commit_message('Deployed')
+
+            `git add #{self.build_dir}`
+            `git commit --allow-empty -m "#{message}"`
+            `git push origin #{current_branch}`
+          end
+
+          def pull_submodule
+            `git fetch`
+            `git stash`
+            `git rebase #{self.remote}/#{self.branch}`
+            `git stash pop`
+
+            if $?.exitstatus == 1
+              puts "Can't deploy! Please resolve conflicts. Then process to manual commit and push on #{self.branch} branch."
+              exit
+            end
+          end
+
+        end
+      end
+    end
+  end
+end