roger 1.1.3 → 1.2.1

data/lib/roger/release/cleaner.rb

@@ -1,16 +1,18 @@
 module Roger
+  # The cleaner safely cleans up paths
   class Release::Cleaner
     def initialize(pattern)
       @pattern = [pattern].flatten
     end
-    
-    def call(release, options = {})
-      # We switch to the build path and append the globbed files for safety, so even if you manage to sneak in a
-      # pattern like "/**/*" it won't do you any good as it will be reappended to the path
+
+    # We switch to the build path and append the globbed files for safety, so even if you manage
+    # to sneak in a pattern like "/**/*" it won't do you any good as it will be reappended
+    # to the path
+    def call(release, _options = {})
       Dir.chdir(release.build_path.to_s) do
         @pattern.each do |pattern|
           Dir.glob(pattern).each do |file|
-            self.clean_path(release, file)
+            clean_path(release, file)
           end
         end
       end
@@ -18,7 +20,7 @@ module Roger
 
     def clean_path(release, file)
       path = File.join(release.build_path.to_s, file)
-      if is_inside_build_path(release.build_path, path)
+      if inside_build_path?(release.build_path, path)
         release.log(self, "Cleaning up \"#{path}\" in build")
         rm_rf(path)
         true
@@ -30,12 +32,11 @@ module Roger
 
     protected
 
-    def is_inside_build_path(build_path, path)     
-      
-      begin 
+    def inside_build_path?(build_path, path)
+      begin
         build_path = Pathname.new(build_path).realpath.to_s
         path = Pathname.new(path)
-        if(path.absolute?)
+        if path.absolute?
           path = path.realpath.to_s
         else
           path = Pathname.new(File.join(build_path.to_s, path)).realpath.to_s
@@ -44,12 +45,12 @@ module Roger
         # Real path does not exist
         return false
       end
-      
+
       if path[build_path]
         return true
       else
-        raise RuntimeError, "Cleaning pattern is not inside build directory"
+        fail "Cleaning pattern is not inside build directory"
       end
     end
   end
-end
+end

data/lib/roger/release/finalizers.rb

@@ -1,30 +1,30 @@
+# The Finalizers will finalize the release. Finalizers can be used to
+# copy the release, zip the release or upload the release
 module Roger::Release::Finalizers
-  class Base    
-    
+  # Abstract base finalizer
+  class Base
     def initialize(options = {})
       @options = {}
       @options.update(options) if options
     end
-    
-    def call(release, options = {})
-      raise ArgumentError, "Implement in subclass"
+
+    def call(_release, _options = {})
+      fail ArgumentError, "Implement in subclass"
     end
   end
 
   def self.register(name, finalizer)
-    raise ArgumentError, "Another finalizer has already claimed the name #{name.inspect}" if self.map.has_key?(name)
-    raise ArgumentError, "Name must be a symbol" unless name.kind_of?(Symbol)
-    self.map[name] = finalizer
+    fail ArgumentError, "Finalizer name '#{name.inspect}' already in use" if map.key?(name)
+    fail ArgumentError, "Name must be a symbol" unless name.is_a?(Symbol)
+    map[name] = finalizer
   end
 
   def self.map
     @_map ||= {}
   end
-
 end
 
 require File.dirname(__FILE__) + "/finalizers/zip"
 require File.dirname(__FILE__) + "/finalizers/dir"
 require File.dirname(__FILE__) + "/finalizers/rsync"
 require File.dirname(__FILE__) + "/finalizers/git_branch"
-

data/lib/roger/release/finalizers/dir.rb

@@ -1,31 +1,29 @@
-require 'fileutils'
+require "fileutils"
 
 module Roger::Release::Finalizers
-  
   # Finalizes the release into a directory in target_path
-  # 
+  #
   # The directory name will have the format PREFIX-VERSION
-  #  
-  class Dir < Base    
+  #
+  class Dir < Base
     # @option options :prefix Prefix to put before the version (default = "html")
     def call(release, options = {})
-      if options
-        options = @options.dup.update(options)
-      else
-        options = @options
-      end
+      options = {}.update(@options)
+      options.update(options) if options
+
+      name = [(options[:prefix] || "html"), release.scm.version].join("-")
+      target_path = release.target_path + name
 
-      name = [(options[:prefix] || "html"), release.scm.version].join("-")      
-      release.log(self, "Finalizing release to #{release.target_path + name}")
-      
-      if File.exist?(release.target_path + name)
-        release.log(self, "Removing existing target #{release.target_path + name}")
-        FileUtils.rm_rf(release.target_path + name)
+      release.log(self, "Finalizing release to #{target_path}")
+
+      if File.exist?(target_path)
+        release.log(self, "Removing existing target #{target_path}")
+        FileUtils.rm_rf(target_path)
       end
-      
-      FileUtils.cp_r release.build_path, release.target_path + name
+
+      FileUtils.cp_r release.build_path, target_path
     end
   end
 end
 
-Roger::Release::Finalizers.register(:dir, Roger::Release::Finalizers::Dir)
+Roger::Release::Finalizers.register(:dir, Roger::Release::Finalizers::Dir)

data/lib/roger/release/finalizers/git_branch.rb

@@ -23,81 +23,119 @@ module Roger::Release::Finalizers
     def call(release, options = {})
       @options = @options.dup.update(options)
       remote = find_git_remote
-
-      # 0. Get remote
-      unless remote
-        raise "No remote found for origin"
-      end
-
-      e_remote = Shellwords.escape(remote)
-      e_branch = Shellwords.escape(@options[:branch])
+      branch = @options[:branch]
 
       tmp_dir = Pathname.new(::Dir.mktmpdir)
       clone_dir = tmp_dir + "clone"
 
       # Check if remote already has branch
-      if `git ls-remote --heads #{e_remote} refs/heads/#{e_branch}` == ""
-        release.log(self, "Creating empty branch")
-        # Branch does not exist yet
-        FileUtils.mkdir(clone_dir)
-        ::Dir.chdir(clone_dir) do
-          `git init`
-          `git remote add origin #{e_remote}`
-          `git checkout -b #{e_branch}`
-        end
-      else
+      if remote_has_branch?(remote, branch)
         release.log(self, "Cloning existing repo")
-        clone_options = "--branch #{e_branch} --single-branch #{clone_dir}"
-        # 1. Clone into different directory
-        `git clone #{e_remote} #{clone_options}`
+        clone_branch(clone_dir, remote, branch)
+      else
+        release.log(self, "Creating empty branch")
+        create_empty_branch(clone_dir, remote, branch)
       end
 
       release.log(self, "Working git magic in #{clone_dir}")
+
+      commit_and_push_release(clone_dir, release, @options)
+
+      if @options[:cleanup]
+        FileUtils.rm_rf(tmp_dir)
+      else
+        tmp_dir
+      end
+    end
+
+    protected
+
+    def commit_and_push_release(clone_dir, release, options)
       ::Dir.chdir(clone_dir) do
         # 3. Copy changes
         FileUtils.rm_rf("*")
         FileUtils.cp_r release.build_path.to_s + "/.", clone_dir.to_s
 
-        # 4. Add all files
-        `git add .`
+        commands = [
+          %w(git add .), # 4. Add all files
+          %w(git commit -a -m) << "Release #{release.scm.version}" # 5. Commit
+        ]
 
-        # 5. Commit
-        `git commit -a -m "Release #{release.scm.version}"`
+        # 6. Git push if in options
+        commands << (%w(git push origin) << branch) if options[:push]
 
-        # 6. Git push
-        if @options[:push]
-          `git push origin #{e_branch}`
+        commands.each do |command|
+          `#{Shellwords.join(command)}`
         end
       end
+    end
 
-      if @options[:cleanup]
-        FileUtils.rm_rf(tmp_dir)
-      else
-        tmp_dir
+    # Check if remote already has branch
+    def remote_has_branch?(remote, branch)
+      command = Shellwords.join([
+        "git",
+        "ls-remote",
+        "--heads",
+        remote,
+        "refs/heads/#{branch}"
+      ])
+      `#{command}` != ""
+    end
+
+    def create_empty_branch(clone_dir, remote, branch)
+      commands = [
+        %w(git init),
+        %w(git remote add origin) << remote,
+        %w(git checkout -b) << branch
+      ]
+
+      # Branch does not exist yet
+      FileUtils.mkdir(clone_dir)
+      ::Dir.chdir(clone_dir) do
+        commands.each do |command|
+          `#{Shellwords.join(command)}`
+        end
       end
     end
 
-    protected
+    def clone_branch(clone_dir, remote, branch)
+      command = Shellwords.join([
+        "git",
+        "clone",
+        remote,
+        "--branch",
+        branch,
+        "--single-branch",
+        clone_dir
+      ])
+      `#{command}`
+    end
 
     # Find the git dir
-    # TODO this is just a copy from release/scm/git.rb
+    # TODO: this is just a copy from release/scm/git.rb
     def find_git_dir(path)
       path = Pathname.new(path).realpath
       while path.parent != path && !(path + ".git").directory?
         path = path.parent
       end
 
-      path = path + ".git"
+      path += ".git"
 
-      raise "Could not find suitable .git dir in #{path}" if !path.directory?
+      fail "Could not find suitable .git dir in #{path}" unless path.directory?
 
       path
     end
 
     def find_git_remote
-      (@options[:remote] ||
+      remote =
+        @options[:remote] ||
         `git --git-dir=#{find_git_dir} config --get remote.origin.url`
-      ).strip
+
+      remote.strip!
+
+      fail "No remote found for origin" if remote.nil? || remote.empty?
+
+      remote
     end
   end
 end

data/lib/roger/release/finalizers/rsync.rb

@@ -1,13 +1,11 @@
-require 'shellwords'
+require "shellwords"
 
 module Roger::Release::Finalizers
-  
   # Finalizes the release by uploading your mockup with rsync to a remote server
-  # 
+  #
   # @see RsyncFinalizer#initialize for options
   #
   class Rsync < Base
-  
     # @param Hash options The options
     #
     # @option options String :rsync The Rsync command to run (default is "rsync")
@@ -17,63 +15,76 @@ module Roger::Release::Finalizers
     # @option options Boolean :ask Prompt the user before uploading (default is true)
     def initialize(options = {})
       @options = {
-        :rsync => "rsync",
-        :remote_path => "",
-        :host => "",
-        :username  => "",
-        :ask => true
+        rsync: "rsync",
+        remote_path: "",
+        host: "",
+        username: "",
+        ask: true
       }.update(options)
     end
-  
+
     def call(release, options = {})
       options = @options.dup.update(options)
-    
+
       # Validate options
       validate_options!(release, options)
-      
-      if !options[:ask] || (prompt("Do you wish to upload to #{options[:host]}? [y/N]: ")) =~ /\Ay(es)?\Z/
-        begin
-          `#{@options[:rsync]} --version`
-        rescue Errno::ENOENT
-          raise RuntimeError, "Could not find rsync in #{@options[:rsync].inspect}"
-        end
-        
-        local_path = release.build_path.to_s
-        remote_path = options[:remote_path]
-        
-        local_path += "/" unless local_path =~ /\/\Z/
-        remote_path += "/" unless remote_path =~ /\/\Z/
-        
-        release.log(self, "Starting upload of #{(release.build_path + "*")} to #{options[:host]}")
-      
-        command = "#{options[:rsync]} -az #{Shellwords.escape(local_path)} #{Shellwords.escape(options[:username])}@#{Shellwords.escape(options[:host])}:#{Shellwords.escape(remote_path)}"
-        
-        # Run r.js optimizer
-        output = `#{command}`
-        
-        # Check if r.js succeeded
-        unless $?.success?
-          raise RuntimeError, "Rsync failed.\noutput:\n #{output}"
-        end
-      end
+
+      return unless prompt_for_upload(options)
+
+      check_rsync_command(options[:rsync])
+
+      local_path = release.build_path.to_s
+      remote_path = options[:remote_path]
+
+      local_path += "/" unless local_path =~ %r{/\Z}
+      remote_path += "/" unless remote_path =~ %r{/\Z}
+
+      release.log(self, "Starting upload of #{(release.build_path + '*')} to #{options[:host]}")
+      rsync(options[:rsync], local_path, remote_path, options)
     end
-    
+
     protected
-    
+
+    def check_rsync_command(command)
+      `#{command} --version`
+    rescue Errno::ENOENT
+      raise "Could not find rsync in #{command.inspect}"
+    end
+
+    def rsync(command, local_path, remote_path, options = {})
+      target_path = "#{options[:username]}@#{options[:host]}:#{remote_path}"
+
+      command = [
+        options[:rsync],
+        "-az",
+        Shellwords.escape(local_path),
+        Shellwords.escape(target_path)
+      ]
+
+      # Run rsync
+      output = `#{command.join(" ")}`
+
+      # Check if rsync succeeded
+      fail "Rsync failed.\noutput:\n #{output}" unless $CHILD_STATUS.success?
+    end
+
+    def prompt_for_upload(options)
+      !options[:ask] ||
+        (prompt("Do you wish to upload to #{options[:host]}? [y/N]: ")) =~ /\Ay(es)?\Z/
+    end
+
     def validate_options!(release, options)
       must_have_keys = [:remote_path, :host, :username]
-      if (options.keys & must_have_keys).size != must_have_keys.size
-        release.log(self, "You must specify these options: #{(must_have_keys - options.keys).inspect}")
-        raise "Missing keys: #{(must_have_keys - options.keys).inspect}"
-      end
+      return if (options.keys & must_have_keys).size == must_have_keys.size
+
+      release.log(self, "Missing options: #{(must_have_keys - options.keys).inspect}")
+      fail "Missing keys: #{(must_have_keys - options.keys).inspect}"
     end
-    
-    def prompt(question = 'Do you wish to continue?')
+
+    def prompt(question = "Do you wish to continue?")
       print(question)
-      return $stdin.gets.strip
+      $stdin.gets.strip
     end
-  
   end
 end
-
-Roger::Release::Finalizers.register(:rsync, Roger::Release::Finalizers::Rsync)
+Roger::Release::Finalizers.register(:rsync, Roger::Release::Finalizers::Rsync)