hudson 0.5.0 → 0.6.0

data/lib/hudson/cli/formatting.rb

@@ -1,53 +0,0 @@
-require 'term/ansicolor'
-
-module Hudson
-  class CLI < Thor
-    module Formatting
-      module ClassMethods
-        def task_help(shell, task_name)
-          meth = normalize_task_name(task_name)
-          task = all_tasks[meth]
-          handle_no_task_error(meth) unless task
-
-          shell.say "usage: #{banner(task)}"
-          shell.say
-          class_options_help(shell, nil => task.options.map { |_, o| o })
-          # shell.say task.description
-          # shell.say
-        end
-
-
-        def print_options(shell, options, grp = nil)
-          return if options.empty?
-          table = options.map do |option|
-            prototype = if option.default
-              " [#{option.default}]"
-            elsif option.boolean?
-              ""
-            elsif option.required?
-              " #{option.banner}"
-            else
-              " [#{option.banner}]"
-            end
-            aliases = option.aliases.empty? ? "" : option.aliases.join(" ") + ","
-            [aliases, "--#{option.name}#{prototype}", "\t",option.description]
-          end
-          shell.print_table(table, :ident => 2)
-          shell.say
-        end
-      end
-
-      module InstanceMethods
-        def c
-          Term::ANSIColor
-        end
-      end
-
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
-      end
-    end
-  end
-end
-

data/lib/hudson/config.rb

@@ -1,27 +0,0 @@
-module Hudson
-  module Config
-    extend self
-    
-    def [](key)
-      config[key]
-    end
-    
-    def config
-      @config ||= if File.exist?(config_file)
-        JSON.parse(File.read(config_file))
-      else
-        {}
-      end
-    end
-    
-    def store!
-      @config ||= {}
-      FileUtils.mkdir_p(File.dirname(config_file))
-      File.open(config_file, "w") { |file| file << @config.to_json }
-    end
-    
-    def config_file
-      @config_file ||= "#{ENV['HOME']}/.hudson/hudsonrb-config.json"
-    end
-  end
-end

data/lib/hudson/core_ext/hash.rb

@@ -1,9 +0,0 @@
-class Hash
-  def with_clean_keys
-    self.inject({}) do |mem, (key, value)|
-      clean_key = key.to_s.gsub(/-/,"_").to_sym
-      mem[clean_key] = value
-      mem
-    end
-  end
-end

data/lib/hudson/core_ext/object/blank.rb

@@ -1,77 +0,0 @@
-# Vendored from activesupport 3.0.1
-class Object
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are blank.
-  #
-  # This simplifies:
-  #
-  #   if !address.nil? && !address.empty?
-  #
-  # ...to:
-  #
-  #   if !address.blank?
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-
-  # An object is present if it's not blank.
-  def present?
-    !blank?
-  end
-
-  # Returns object if it's #present? otherwise returns nil.
-  # object.presence is equivalent to object.present? ? object : nil.
-  #
-  # This is handy for any representation of objects where blank is the same
-  # as not present at all.  For example, this simplifies a common check for
-  # HTTP POST/query parameters:
-  #
-  #   state   = params[:state]   if params[:state].present?
-  #   country = params[:country] if params[:country].present?
-  #   region  = state || country || 'US'
-  #
-  # ...becomes:
-  #
-  #   region = params[:state].presence || params[:country].presence || 'US'
-  def presence
-    self if present?
-  end
-end
-
-class NilClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class FalseClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class TrueClass #:nodoc:
-  def blank?
-    false
-  end
-end
-
-class Array #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class Hash #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class String #:nodoc:
-  def blank?
-    self !~ /\S/
-  end
-end
-
-class Numeric #:nodoc:
-  def blank?
-    false
-  end
-end

data/lib/hudson/installation.rb

@@ -1,136 +0,0 @@
-module Hudson
-  class Installation
-    attr_reader :directory
-
-    def initialize(shell, opts = {})
-      @shell = shell
-      @options = opts
-      @serverhome = File.expand_path(@options[:home])
-      @warfile = File.join(File.dirname(@serverhome), "hudson.war")
-      @versionfile = "#{@serverhome}/version.txt"
-      @control_port = opts[:control]
-    end
-
-    def launch!
-      unless warfile?
-        @shell.say "no server currently installed."
-        upgrade!
-      end
-      javatmp = File.join(@serverhome, "javatmp")
-      FileUtils.mkdir_p javatmp
-      ENV['HUDSON_HOME'] = @serverhome
-      cmd = ["java", "-Djava.io.tmpdir=#{javatmp}", "-jar", @warfile]
-      cmd << "--daemon" if @options[:daemon]
-      cmd << "--logfile=#{File.expand_path(@options[:logfile])}" if @options[:logfile]
-      cmd << "--httpPort=#{@options[:port]}"
-      cmd << "--controlPort=#{@control_port}"
-      @shell.say cmd.join(" ")
-      exec(*cmd)
-    end
-
-    def kill!
-      require 'socket'
-      TCPSocket.open("localhost", @control_port) do |sock|
-        sock.write("0")
-      end
-      exit
-    end
-
-    def upgrade!
-      FileUtils.mkdir_p @serverhome
-      hudson_stock ? upgrade_from_fixture_stock : upgrade_from_network_stock
-    end
-    
-    def hudson_stock
-      ENV['HUDSON_STOCK']
-    end
-
-    private
-
-    def warfile?
-      File.exists?(@warfile) && system("unzip -l #{@warfile} > /dev/null 2>/dev/null")
-    end
-    
-    def upgrade_from_fixture_stock
-      FileUtils.cp File.join(hudson_stock, "hudson.war"), @warfile
-      FileUtils.cp_r File.join(hudson_stock, "plugins"), @serverhome
-    end
-
-    def upgrade_from_network_stock
-      require 'ostruct'
-      progress = Progress.new
-      latest = progress.means "grabbing the latest metadata from hudson-ci.org" do |step|
-        JSON.parse(HTTParty.get("http://hudson-ci.org/update-center.json").lines.to_a[1..-2].join("\n"))
-      end
-      progress.means "downloading hudson server" do |step|
-        latest_version = latest["core"]["version"]
-        if latest_version > current_server_version
-          puts
-          `curl -L --progress-bar #{latest["core"]["url"]} -o #{@warfile}`
-          self.current_server_version = latest_version
-          step.ok("#{current_server_version} -> #{latest_version}")
-        else
-          step.ok("Up-to-date at #{current_server_version}")
-        end
-      end
-      
-      plugins_dir = File.join(@serverhome, 'plugins')
-      plugins = if File.exists?(plugins_dir)
-        Dir.chdir(plugins_dir) do
-          Dir['*.hpi'].map {|entry| File.basename(entry,".hpi")}
-        end
-      else
-        %w(envfile git github greenballs rake ruby)
-      end
-      FileUtils.mkdir_p(plugins_dir)
-      for plugin in plugins do
-        metadata = OpenStruct.new(latest['plugins'][plugin])
-        progress.means "downloading #{plugin} plugin" do |step|
-          system("curl -L --silent #{metadata.url} > #{plugins_dir}/#{plugin}.hpi")
-          step.ok(metadata.version)
-        end
-      end unless progress.aborted
-    end
-
-    def current_server_version
-      File.exists?(@versionfile) ? File.read(@versionfile) : "0"
-    end
-    
-    def current_server_version=(version)
-      File.open(@versionfile, "w") do |f|
-        f.write(version)
-      end
-    end
-
-    class Progress
-      attr_reader :aborted
-      def initialize
-        @shell = Thor::Shell::Color.new
-        @aborted = false
-      end
-
-      def means(step)
-        return if @aborted
-        begin
-          @shell.say(step + "... ")
-          yield(self).tap do
-            @shell.say("[OK]", :green)
-          end
-        rescue Ok => ok
-          @shell.say("[OK#{ok.message ? " - #{ok.message}" : ''}]", :green)
-        rescue StandardError => e
-          @shell.say("[FAIL - #{e.message}]", :red)
-          @aborted = true
-          false
-        end
-      end
-
-      def ok(msg = nil)
-        raise Ok.new(msg)
-      end
-      
-      class Ok < StandardError
-      end
-    end
-  end
-end

data/lib/hudson/job_config_builder.rb

@@ -1,287 +0,0 @@
-require "builder"
-
-module Hudson
-  class JobConfigBuilder
-    attr_accessor :job_type
-    attr_accessor :steps, :rubies
-    attr_accessor :scm, :public_scm, :scm_branches
-    attr_accessor :scm, :public_scm, :git_branches
-    attr_accessor :assigned_node, :node_labels # TODO just one of these
-    attr_accessor :envfile
-    
-    InvalidTemplate = Class.new(StandardError)
-    
-    VALID_JOB_TEMPLATES = %w[none rails rails3 ruby rubygem]
-    
-    # +job_type+ - template of default steps to create with the job
-    # +steps+ - array of [:method, cmd], e.g. [:build_shell_step, "bundle initial"]
-    #   - Default is based on +job_type+.
-    # +scm+           - URL to the repository. Currently only support git URLs.
-    # +public_scm+    - convert the +scm+ URL to a publicly accessible URL for the Hudson job config.
-    # +scm_branches+  - array of branches to run builds. Default: ['master']
-    # +rubies+        - list of RVM rubies to run tests (via Hudson Axes).
-    # +assigned_node+ - restrict this job to running on slaves with these labels (space separated)
-    def initialize(job_type = :ruby, &block)
-      self.job_type = job_type.to_s if job_type
-      
-      yield self
-
-      self.scm_branches ||= ["master"]
-      raise InvalidTemplate unless VALID_JOB_TEMPLATES.include?(job_type.to_s)
-    end
-  
-    def builder
-      b = Builder::XmlMarkup.new :indent => 2
-      b.instruct!
-      b.tag!(matrix_project? ? "matrix-project" : "project") do
-        b.actions
-        b.description
-        b.keepDependencies false
-        b.properties
-        build_scm b
-        b.assignedNode assigned_node if assigned_node
-        b.canRoam !assigned_node
-        b.disabled false
-        b.blockBuildWhenUpstreamBuilding false
-        b.triggers :class => "vector"
-        b.concurrentBuild false
-        build_axes b if matrix_project?
-        build_steps b
-        b.publishers
-        build_wrappers b
-        b.runSequentially false if matrix_project?
-      end
-    end
-  
-    def to_xml
-      builder.to_s
-    end
-  
-    protected
-    
-    # <scm class="hudson.plugins.git.GitSCM"> ... </scm>
-    def build_scm(b)
-      if scm && scm =~ /git/
-        scm_url = public_scm ? public_only_git_scm(scm) : scm
-        b.scm :class => "hudson.plugins.git.GitSCM" do
-          b.configVersion 1
-          b.remoteRepositories do
-            b.tag! "org.spearce.jgit.transport.RemoteConfig" do
-              b.string "origin"
-              b.int 5
-              b.string "fetch"
-              b.string "+refs/heads/*:refs/remotes/origin/*"
-              b.string "receivepack"
-              b.string "git-upload-pack"
-              b.string "uploadpack"
-              b.string "git-upload-pack"
-              b.string "url"
-              b.string scm_url
-              b.string "tagopt"
-              b.string
-            end
-          end
-        
-          if scm_branches
-            b.branches do
-              scm_branches.each do |branch|
-                b.tag! "hudson.plugins.git.BranchSpec" do
-                  b.name branch
-                end
-              end
-            end
-          end
-        
-          b.localBranch
-          b.mergeOptions
-          b.recursiveSubmodules false
-          b.doGenerateSubmoduleConfigurations false
-          b.authorOrCommitter false
-          b.clean false
-          b.wipeOutWorkspace false
-          b.buildChooser :class => "hudson.plugins.git.util.DefaultBuildChooser"
-          b.gitTool "Default"
-          b.submoduleCfg :class => "list"
-          b.relativeTargetDir
-          b.excludedRegions
-          b.excludedUsers
-        end
-      end
-    end
-
-    def matrix_project?
-      !(rubies.blank? && node_labels.blank?)
-    end
-  
-    # <hudson.matrix.TextAxis>
-    #   <name>RUBY_VERSION</name>
-    #   <values>
-    #     <string>1.8.7</string>
-    #     <string>1.9.2</string>
-    #     <string>rbx-head</string>
-    #     <string>jruby</string>
-    #   </values>
-    # </hudson.matrix.TextAxis>
-    # <hudson.matrix.LabelAxis>
-    #   <name>label</name>
-    #   <values>
-    #     <string>1.8.7</string>
-    #     <string>ubuntu</string>
-    #   </values>
-    # </hudson.matrix.LabelAxis>
-    def build_axes(b)
-      b.axes do
-        unless rubies.blank?
-          b.tag! "hudson.matrix.TextAxis" do
-            b.name "RUBY_VERSION"
-            b.values do
-              rubies.each do |rvm_name|
-                b.string rvm_name
-              end
-            end
-          end
-        end
-        unless node_labels.blank?
-          b.tag! "hudson.matrix.LabelAxis" do
-            b.name "label"
-            b.values do
-              node_labels.each do |label|
-                b.string label
-              end
-            end
-          end
-        end
-      end
-    end
-    
-    # Example:
-    # <buildWrappers>
-    #   <hudson.plugins.envfile.EnvFileBuildWrapper>
-    #     <filePath>/path/to/env/file</filePath>
-    #   </hudson.plugins.envfile.EnvFileBuildWrapper>
-    # </buildWrappers>
-    def build_wrappers(b)
-      if envfile
-        b.buildWrappers do
-          self.envfile = [envfile] unless envfile.is_a?(Array)
-          b.tag! "hudson.plugins.envfile.EnvFileBuildWrapper" do
-            envfile.each do |file|
-              b.filePath file
-            end
-          end
-        end
-      else
-        b.buildWrappers
-      end
-    end
-    
-    # The important sequence of steps that are run to process a job build.
-    # Can be defaulted by the +job_type+ using +default_steps(job_type)+,
-    # or customized via +steps+ array.
-    def build_steps(b)
-      b.builders do
-        self.steps ||= default_steps(job_type)
-        steps.each do |step|
-          method, cmd = step
-          send(method.to_sym, b, cmd) # e.g. build_shell_step(b, "bundle install")
-        end
-      end
-    end
-    
-    def default_steps(job_type)
-      steps = case job_type.to_sym
-      when :rails, :rails3
-        [
-          [:build_shell_step, "bundle install"],
-          [:build_ruby_step, <<-RUBY.gsub(/^            /, '')],
-            unless File.exist?("config/database.yml")
-              require 'fileutils'
-              example = Dir["config/database*"].first
-              puts "Using \#{example} for config/database.yml"
-              FileUtils.cp example, "config/database.yml"
-            end
-            RUBY
-          [:build_shell_step, "bundle exec rake db:create:all"],
-          [:build_shell_step, <<-RUBY.gsub(/^            /, '')],
-            if [ -f db/schema.rb ]; then
-              bundle exec rake db:schema:load
-            else
-              bundle exec rake db:migrate
-            fi
-            RUBY
-          [:build_shell_step, "bundle exec rake"]
-        ]
-      when :ruby, :rubygems
-        [
-          [:build_shell_step, "bundle install"],
-          [:build_shell_step, "bundle exec rake"]
-        ]
-      else
-        [ [:build_shell_step, 'echo "THERE ARE NO STEPS! Except this one..."'] ]
-      end
-      rubies.blank? ? steps : default_rvm_steps + steps
-    end
-    
-    def default_rvm_steps
-      [
-        [:build_shell_step, "rvm $RUBY_VERSION"],
-        [:build_shell_step, "rvm gemset create ruby-$RUBY_VERSION && rvm gemset use ruby-$RUBY_VERSION"]
-      ]
-    end
-    
-    # <hudson.tasks.Shell>
-    #   <command>echo &apos;THERE ARE NO STEPS! Except this one...&apos;</command>
-    # </hudson.tasks.Shell>
-    def build_shell_step(b, command)
-      b.tag! "hudson.tasks.Shell" do
-        b.command command.to_xs.gsub("&amp;", '&') #.gsub(%r{"}, '&quot;').gsub(%r{'}, '&apos;')
-      end
-    end
-
-    # <hudson.plugins.ruby.Ruby>
-    #   <command>unless File.exist?(&quot;config/database.yml&quot;)
-    #   require &apos;fileutils&apos;
-    #   example = Dir[&quot;config/database*&quot;].first
-    #   puts &quot;Using #{example} for config/database.yml&quot;
-    #   FileUtils.cp example, &quot;config/database.yml&quot;
-    # end</command>
-    # </hudson.plugins.ruby.Ruby>
-    def build_ruby_step(b, command)
-      b.tag! "hudson.plugins.ruby.Ruby" do
-        b.command do
-          b << command.to_xs.gsub(%r{"}, '&quot;').gsub(%r{'}, '&apos;')
-        end
-      end
-    end
-  
-    # Usage: build_ruby_step b, "db:schema:load"
-    #
-    # <hudson.plugins.rake.Rake>
-    #   <rakeInstallation>(Default)</rakeInstallation>
-    #   <rakeFile></rakeFile>
-    #   <rakeLibDir></rakeLibDir>
-    #   <rakeWorkingDir></rakeWorkingDir>
-    #   <tasks>db:schema:load</tasks>
-    #   <silent>false</silent>
-    # </hudson.plugins.rake.Rake>
-    def build_rake_step(b, tasks)
-      b.tag! "hudson.plugins.rake.Rake" do
-        b.rakeInstallation "(Default)"
-        b.rakeFile
-        b.rakeLibDir
-        b.rakeWorkingDir
-        b.tasks tasks
-        b.silent false
-      end
-    end
-    
-    # Converts git@github.com:drnic/newgem.git into git://github.com/drnic/newgem.git
-    def public_only_git_scm(scm_url)
-      if scm_url =~ /git@([\w\-_.]+):(.+)\.git/
-        "git://#{$1}/#{$2}.git"
-      else
-        scm_url
-      end
-    end
-  end
-end