jenkins_pipeline_builder 0.5.2 → 0.6.0

data/lib/jenkins_pipeline_builder/job_builder.rb

@@ -20,137 +20,206 @@
 # THE SOFTWARE.
 #
 
-module JenkinsPipelineBuilder
-  class JobBuilder < Extendable
-    register :description do |description, n_xml|
-      desc = n_xml.xpath('//description').first
-      desc.content = "#{description}"
-    end
+job_attribute do
+  name :description
+  plugin_id 123
+  min_version 0
+  announced false
 
-    register :scm_params do |params, n_xml|
-      XmlHelper.update_node_text(n_xml, '//scm/localBranch', params[:local_branch]) if params[:local_branch]
-      XmlHelper.update_node_text(n_xml, '//scm/recursiveSubmodules', params[:recursive_update]) if params[:recursive_update]
-      XmlHelper.update_node_text(n_xml, '//scm/wipeOutWorkspace', params[:wipe_workspace]) if params[:wipe_workspace]
-      XmlHelper.update_node_text(n_xml, '//scm/excludedUsers', params[:excluded_users]) if params[:excluded_users]
-      XmlHelper.update_node_text(n_xml, '//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/name', params[:remote_name]) if params[:remote_name]
-      XmlHelper.update_node_text(n_xml, '//scm/skipTag', params[:skip_tag]) if params[:skip_tag]
-      XmlHelper.update_node_text(n_xml, '//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/refspec', params[:refspec]) if params[:refspec]
-      XmlHelper.update_node_text(n_xml, '//scm/excludedRegions', params[:excluded_regions]) if params[:excluded_regions]
-      XmlHelper.update_node_text(n_xml, '//scm/includedRegions', params[:included_regions]) if params[:included_regions]
-    end
+  before do
+    xpath('//project/description').remove
+  end
+
+  xml('//project') do |description|
+    description "#{description}"
+  end
+end
 
-    register :hipchat do |params, n_xml|
-      fail 'No HipChat room specified' unless params[:room]
+job_attribute do
+  name :scm_params
+  plugin_id 123
+  min_version 0
+  announced false
 
-      properties = n_xml.xpath('//properties').first
-      Nokogiri::XML::Builder.with(properties) do |xml|
-        xml.send('jenkins.plugins.hipchat.HipChatNotifier_-HipChatJobProperty') do
-          xml.room params[:room]
-          xml.startNotification params[:'start-notify'] || false
+  # XML preprocessing
+  # TODO: Actually figure out how to merge using the builder DSL
+  # This delete the things we are going to add later is pretty crappy
+  # Alternately don't use/tweak the xml the api client generates
+  # (which is where I assume this is coming from)
+  before do |params|
+    xpath('//scm/localBranch').remove if params[:local_branch]
+    xpath('//scm/recursiveSubmodules').remove if params[:recursive_update]
+    xpath('//scm/wipeOutWorkspace').remove if params[:wipe_workspace]
+    xpath('//scm/excludedUsers').remove if params[:excluded_users]
+    xpath('//scm/userRemoteConfigs').remove if params[:remote_name] || params[:refspec]
+    xpath('//scm/skipTag').remove if params[:skip_tag]
+    xpath('//scm/excludedRegions').remove if params[:excluded_regions]
+    xpath('//scm/includedRegions').remove if params[:included_regions]
+
+  end
+
+  xml '//scm' do |params|
+    localBranch params[:local_branch] if params[:local_branch]
+    recursiveSubmodules params[:recursive_update] if params[:recursive_update]
+    wipeOutWorkspace params[:wipe_workspace] if params[:wipe_workspace]
+    excludedUsers params[:excluded_users] if params[:excluded_users]
+    if params[:remote_name]
+      userRemoteConfigs do
+        send('hudson.plugins.git.UserRemoteConfig') do
+          name params[:remote_name]
         end
       end
     end
-
-    register :priority do |params, n_xml|
-      n_builders = n_xml.xpath('//properties').first
-      Nokogiri::XML::Builder.with(n_builders) do |xml|
-        xml.send('jenkins.advancedqueue.AdvancedQueueSorterJobProperty', 'plugin' => 'PrioritySorter') do
-          xml.useJobPriority params[:use_priority]
-          xml.priority params[:job_priority] || -1
+    skipTag params[:skip_tag] if params[:skip_tag]
+    if params[:refspec]
+      userRemoteConfigs do
+        send 'hudson.plugins.git.UserRemoteConfig' do
+          refspec params[:refspec]
         end
       end
     end
+    excludedRegions params[:excluded_regions] if params[:excluded_regions]
+    includedRegions params[:included_regions] if params[:included_regions]
+  end
+end
+
+job_attribute do
+  name :hipchat
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml '//properties' do |params|
+    fail 'No HipChat room specified' unless params[:room]
+
+    send('jenkins.plugins.hipchat.HipChatNotifier_-HipChatJobProperty') do
+      room params[:room]
+      startNotification params[:'start-notify'] || false
+    end
+  end
+end
+
+job_attribute do
+  name :priority
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml '//properties' do |params|
+    send('jenkins.advancedqueue.AdvancedQueueSorterJobProperty', 'plugin' => 'PrioritySorter') do
+      useJobPriority params[:use_priority]
+      priority params[:job_priority] || -1
+    end
+  end
+end
+
+job_attribute do
+  name :parameters
+  plugin_id 123
+  min_version 0
+  announced false
 
-    register :parameters do |params, n_xml|
-      n_builders = n_xml.xpath('//properties').first
-      Nokogiri::XML::Builder.with(n_builders) do |xml|
-        xml.send('hudson.model.ParametersDefinitionProperty') do
-          xml.parameterDefinitions do
-            param_proc = lambda do |xml, params, type|
-              xml.send(type) do
-                xml.name params[:name]
-                xml.description params[:description]
-                xml.defaultValue params[:default]
-                if params[:type] == 'choice'
-                  xml.choices('class' => 'java.util.Arrays$ArrayList') do
-                    xml.a('class' => 'string-array') do
-                      params[:values].each do |value|
-                        xml.string value
-                      end
-                    end
+  xml '//properties' do |params|
+    send('hudson.model.ParametersDefinitionProperty') do
+      parameterDefinitions do
+        params.each do |param|
+          case param[:type]
+          when 'string'
+            paramType = 'hudson.model.StringParameterDefinition'
+          when 'bool'
+            paramType = 'hudson.model.BooleanParameterDefinition'
+          when 'text'
+            paramType = 'hudson.model.TextParameterDefinition'
+          when 'password'
+            paramType = 'hudson.model.PasswordParameterDefinition'
+          when 'choice'
+            paramType = 'hudson.model.ChoiceParameterDefinition'
+          else
+            paramType = 'hudson.model.StringParameterDefinition'
+          end
+
+          send(paramType) do
+            name param[:name]
+            description param[:description]
+            defaultValue param[:default]
+            if param[:type] == 'choice'
+              choices('class' => 'java.util.Arrays$ArrayList') do
+                a('class' => 'string-array') do
+                  param[:values].each do |value|
+                    string value
                   end
                 end
               end
             end
-            params.each do |param|
-              case param[:type]
-              when 'string'
-                paramType = 'hudson.model.StringParameterDefinition'
-              when 'bool'
-                paramType = 'hudson.model.BooleanParameterDefinition'
-              when 'text'
-                paramType = 'hudson.model.TextParameterDefinition'
-              when 'password'
-                paramType = 'hudson.model.PasswordParameterDefinition'
-              when 'choice'
-                paramType = 'hudson.model.ChoiceParameterDefinition'
-              else
-                paramType = 'hudson.model.StringParameterDefinition'
-              end
-
-              param_proc.call xml, param, paramType
-            end
           end
         end
       end
     end
+  end
+end
 
-    register :discard_old do |params, n_xml|
-      properties = n_xml.child
-      Nokogiri::XML::Builder.with(properties) do |xml|
-        xml.send('logRotator', 'class' => 'hudson.tasks.LogRotator') do
-          xml.daysToKeep params[:days] if params[:days]
-          xml.numToKeep params[:number] || -1
-          xml.artifactDaysToKeep params[:artifact_days] || -1
-          xml.artifactNumToKeep params[:artifact_number] || -1
-        end
-      end
+job_attribute do
+  name :discard_old
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml '//project' do |params|
+    send('logRotator', 'class' => 'hudson.tasks.LogRotator') do
+      daysToKeep params[:days] if params[:days]
+      numToKeep params[:number] || -1
+      artifactDaysToKeep params[:artifact_days] || -1
+      artifactNumToKeep params[:artifact_number] || -1
     end
+  end
+end
 
-    register :throttle do |params, n_xml|
-      properties = n_xml.xpath('//properties').first
-      cat_set = params[:option] == 'category'
-      Nokogiri::XML::Builder.with(properties) do |xml|
-        xml.send('hudson.plugins.throttleconcurrents.ThrottleJobProperty', 'plugin' => 'throttle-concurrents') do
-          xml.maxConcurrentPerNode params[:max_per_node] || 0
-          xml.maxConcurrentTotal params[:max_total] || 0
-          xml.throttleEnabled true
-          xml.throttleOption params[:option] || 'alone'
-          xml.categories do
-            xml.string params[:category] if cat_set
-          end
-        end
+job_attribute do
+  name :throttle
+  plugin_id 100
+  min_version 0
+  announced false
+
+  xml '//properties' do |params|
+    cat_set = params[:option] == 'category'
+    send('hudson.plugins.throttleconcurrents.ThrottleJobProperty', 'plugin' => 'throttle-concurrents') do
+      maxConcurrentPerNode params[:max_per_node] || 0
+      maxConcurrentTotal params[:max_total] || 0
+      throttleEnabled true
+      throttleOption params[:option] || 'alone'
+      categories do
+        string params[:category] if cat_set
       end
     end
+  end
+end
 
-    register :prepare_environment do |params, n_xml|
-      properties = n_xml.xpath('//properties').first
-      Nokogiri::XML::Builder.with(properties) do |xml|
-        xml.send('EnvInjectJobProperty') do
-          xml.info do
-            xml.propertiesContent params[:properties_content] if params[:properties_content]
-            xml.loadFilesFromMaster params[:load_from_master] if params[:load_from_master]
-          end
-          xml.on true
-          xml.keepJenkinsSystemVariables params[:keep_environment] if params[:keep_environment]
-          xml.keepBuildVariables params[:keep_build] if params[:keep_build]
-        end
+job_attribute do
+  name :prepare_environment
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml '//properties' do |params|
+    send('EnvInjectJobProperty') do
+      info do
+        propertiesContent params[:properties_content] if params[:properties_content]
+        loadFilesFromMaster params[:load_from_master] if params[:load_from_master]
       end
+      on true
+      keepJenkinsSystemVariables params[:keep_environment] if params[:keep_environment]
+      keepBuildVariables params[:keep_build] if params[:keep_build]
     end
+  end
+end
 
-    register :concurrent_build do |params, n_xml|
-      concurrentBuild = n_xml.xpath('//concurrentBuild').first
-      concurrentBuild.content = (params == true) ? 'true' : 'false'
-    end
+job_attribute do
+  name :concurrent_build
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml '//concurrentBuild' do |params|
+    (params == true) ? 'true' : 'false'
   end
 end

data/lib/jenkins_pipeline_builder/module_registry.rb

@@ -23,49 +23,32 @@
 module JenkinsPipelineBuilder
   class ModuleRegistry
     attr_accessor :registry, :registered_modules
-    ENTRIES = {
-      builders: '//builders',
-      publishers: '//publishers',
-      wrappers: '//buildWrappers',
-      triggers: '//triggers'
-    }
-
-    # creates register_triggers and so on
-    # we declare job attribues below since it doesn't follow the pattern
-    ENTRIES.keys.each do |key|
-      # TODO: Too lazy to figure out a better way to do this
-      singular_key = key.to_s.singularize.to_sym
-      define_method "register_#{singular_key}" do |name, jenkins_name, description, &block|
-        @registered_modules[key][name] = {
-          jenkins_name: jenkins_name,
-          description: description
-        }
-        @registry[:job][key][:registry][name] = block
-      end
-    end
-
     def initialize
       @registry = { job: {} }
-      @registered_modules = { job_attributes: {} }
+    end
 
-      entries.each do |key, value|
-        @registered_modules[key] = {}
-        @registry[:job][key] = {}
-        @registry[:job][key][:registry] = {}
-        @registry[:job][key][:method] = ->(registry, params, n_xml) { run_registry_on_path(value, registry, params, n_xml) }
-      end
+    def logger
+      JenkinsPipelineBuilder.logger
     end
 
+    # Ideally refactor this out to be derived from the registry,
+    # but I'm lazy for now
     def entries
-      ENTRIES
+      {
+        builders: '//builders',
+        publishers: '//publishers',
+        wrappers: '//buildWrappers',
+        triggers: '//triggers'
+      }
     end
 
-    def register_job_attribute(name, jenkins_name, description, &block)
-      @registered_modules[:job_attributes][name] = {
-        jenkins_name: jenkins_name,
-        description: description
-      }
-      @registry[:job][name] = block
+    def register(prefix, extension)
+      name = prefix.pop
+      root = prefix.inject(@registry, :[])
+      root[name] = {} unless root[name]
+
+      root[name][extension.name] = [] unless root[name][extension.name]
+      root[name][extension.name] << extension
     end
 
     def get(path)
@@ -85,36 +68,37 @@ module JenkinsPipelineBuilder
       traverse_registry(registry, params, n_xml)
     end
 
-    def traverse_registry(registry, params, n_xml)
+    def traverse_registry(registry, params, n_xml, strict = false)
       params.each do |key, value|
-        execute_registry_item(registry, key, value, n_xml)
-      end
-    end
-
-    def traverse_registry_param_array(registry, params, n_xml)
-      params.each do |item|
-        key = item.keys.first
-        next if key.nil?
-        execute_registry_item(registry, key, item[key], n_xml)
-      end
-    end
-
-    def execute_registry_item(registry, key, value, n_xml)
-      registry_item = registry[key]
-      if registry_item.kind_of?(Hash)
-        sub_registry = registry_item[:registry]
-        method = registry_item[:method]
-        method.call(sub_registry, value, n_xml)
-      elsif registry_item.kind_of?(Method) || registry_item.kind_of?(Proc)
-        registry_item.call(value, n_xml) unless registry_item.nil?
+        next unless registry.is_a? Hash
+        unless registry.key? key
+          fail "!!!! could not find key #{key} !!!!" if strict
+          next
+        end
+        reg_value = registry[key]
+        if reg_value.is_a?(Array) && reg_value.first.is_a?(Extension)
+          next unless reg_value.select { |x| x.class == Extension }.size == reg_value.size
+          # TODO: Actually compare versions installed on box here
+          reg = reg_value.sort { |x, y| x.min_version <=> y.min_version }.last
+          logger.debug "Using #{reg.type} #{reg.name} version #{reg.min_version}"
+          execute_extension(reg, value, n_xml)
+        elsif value.is_a? Hash
+          traverse_registry reg_value, value, n_xml, true
+        elsif value.is_a? Array
+          value.each do |v|
+            traverse_registry reg_value, v, n_xml, true
+          end
+        end
       end
     end
 
-    def run_registry_on_path(path, registry, params, n_xml)
-      n_builders = n_xml.xpath(path).first
+    def execute_extension(extension, value, n_xml)
+      n_builders = n_xml.xpath(extension.path).first
+      n_builders.instance_exec(value, &extension.before) if extension.before
       Nokogiri::XML::Builder.with(n_builders) do |xml|
-        traverse_registry_param_array(registry, params, xml)
+        xml.instance_exec value, &extension.xml
       end
+      n_builders.instance_exec(value, &extension.after) if extension.after
     end
   end
 end

data/lib/jenkins_pipeline_builder/publishers.rb

@@ -18,135 +18,208 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
-#
 
-module JenkinsPipelineBuilder
-  class Publishers < Extendable
-    register :description_setter do |params, xml|
-      xml.send('hudson.plugins.descriptionsetter.DescriptionSetterPublisher') do
-        xml.regexp params[:regexp]
-        xml.regexpForFailed params[:regexp]
-        xml.description params[:description]
-        xml.descriptionForFailed params[:description]
-        xml.setForMatrix false
-      end
+publisher do
+  name :description_setter
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('hudson.plugins.descriptionsetter.DescriptionSetterPublisher') do
+      regexp params[:regexp]
+      regexpForFailed params[:regexp]
+      description params[:description]
+      descriptionForFailed params[:description]
+      setForMatrix false
     end
+  end
+end
 
-    register :downstream do |params, xml|
-      xml.send('hudson.plugins.parameterizedtrigger.BuildTrigger') do
-        xml.configs do
-          xml.send('hudson.plugins.parameterizedtrigger.BuildTriggerConfig') do
-            xml.configs do
-              params[:data] = [{ params: '' }] unless params[:data]
-              params[:data].each do |config|
-                if config[:params]
-                  xml.send('hudson.plugins.parameterizedtrigger.PredefinedBuildParameters') do
-                    xml.properties config[:params]
-                  end
+publisher do
+  name :downstream
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('hudson.plugins.parameterizedtrigger.BuildTrigger') do
+      configs do
+        send('hudson.plugins.parameterizedtrigger.BuildTriggerConfig') do
+          configs do
+            params[:data] = [{ params: '' }] unless params[:data]
+            params[:data].each do |config|
+              if config[:params]
+                send('hudson.plugins.parameterizedtrigger.PredefinedBuildParameters') do
+                  properties config[:params]
                 end
-                if config[:file]
-                  xml.send('hudson.plugins.parameterizedtrigger.FileBuildParameters') do
-                    xml.propertiesFile config[:file]
-                    xml.failTriggerOnMissing false
-                  end
+              end
+              if config[:file]
+                send('hudson.plugins.parameterizedtrigger.FileBuildParameters') do
+                  propertiesFile config[:file]
+                  failTriggerOnMissing false
                 end
               end
             end
-            xml.projects params[:project]
-            xml.condition params[:condition] || 'SUCCESS'
-            xml.triggerWithNoParameters params[:trigger_with_no_parameters] || false
           end
+          projects params[:project]
+          condition params[:condition] || 'SUCCESS'
+          triggerWithNoParameters params[:trigger_with_no_parameters] || false
         end
       end
     end
+  end
+end
 
-    register :hipchat do |params, xml|
-      params = {} if params == true
-      xml.send('jenkins.plugins.hipchat.HipChatNotifier') do
-        xml.jenkinsUrl params[:jenkinsUrl] || ''
-        xml.authToken params[:authToken] || ''
-        xml.room params[:room] || ''
-      end
+publisher do
+  name :hipchat
+  plugin_id 101
+  min_version 0
+  announced false
+
+  xml do |params|
+    params = {} if params == true
+    send('jenkins.plugins.hipchat.HipChatNotifier') do
+      jenkinsUrl params[:jenkinsUrl] || ''
+      authToken params[:authToken] || ''
+      room params[:room] || ''
     end
+  end
+end
 
-    register :git do |params, xml|
-      xml.send('hudson.plugins.git.GitPublisher') do
-        xml.configVersion params[:configVersion] || 2
-        xml.pushMerge params[:'push-merge'] || false
-        xml.pushOnlyIfSuccess params[:'push-only-if-success'] || false
-        xml.branchesToPush do
-          xml.send('hudson.plugins.git.GitPublisher_-BranchToPush') do
-            xml.targetRepoName params[:targetRepoName] || 'origin'
-            xml.branchName params[:branchName] || 'master'
-          end
+publisher do
+  name :git
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('hudson.plugins.git.GitPublisher') do
+      configVersion params[:configVersion] || 2
+      pushMerge params[:'push-merge'] || false
+      pushOnlyIfSuccess params[:'push-only-if-success'] || false
+      branchesToPush do
+        send('hudson.plugins.git.GitPublisher_-BranchToPush') do
+          targetRepoName params[:targetRepoName] || 'origin'
+          branchName params[:branchName] || 'master'
         end
       end
     end
+  end
+end
 
-    register :junit_result do |params, xml|
-      xml.send('hudson.tasks.junit.JUnitResultArchiver') do
-        xml.testResults params[:test_results] || ''
-        xml.keepLongStdio false
-        xml.testDataPublishers
-      end
+publisher do
+  name :junit_result
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('hudson.tasks.junit.JUnitResultArchiver') do
+      testResults params[:test_results] || ''
+      keepLongStdio false
+      testDataPublishers
     end
+  end
+end
+
+publisher do
+  name :coverage_result
+  plugin_id 123
+  min_version 0
+  announced false
 
-    register :coverage_result do |params, xml|
-      xml.send('hudson.plugins.rubyMetrics.rcov.RcovPublisher') do
-        xml.reportDir params[:report_dir]
-        xml.targets do
-          coverage_metric('TOTAL_COVERAGE', params[:total], xml)
-          coverage_metric('CODE_COVERAGE', params[:code], xml)
+  xml do |params|
+    send('hudson.plugins.rubyMetrics.rcov.RcovPublisher') do
+      reportDir params[:report_dir]
+      targets do
+        { 'TOTAL_COVERAGE' => params[:total], 'CODE_COVERAGE' => params[:code] }.each do |key, inner_params|
+          send('hudson.plugins.rubyMetrics.rcov.model.MetricTarget') do
+            metric key
+            healthy inner_params[:healthy]
+            unhealthy inner_params[:unhealthy]
+            unstable inner_params[:unstable]
+          end
         end
       end
     end
+  end
+end
 
-    register :post_build_script do |params, xml|
-      xml.send('org.jenkinsci.plugins.postbuildscript.PostBuildScript') do
-        xml.buildSteps do
-          if params[:shell_command]
-            xml.send('hudson.tasks.Shell') do
-              xml.command params[:shell_command]
-            end
+publisher do
+  name :post_build_script
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('org.jenkinsci.plugins.postbuildscript.PostBuildScript') do
+      buildSteps do
+        if params[:shell_command]
+          send('hudson.tasks.Shell') do
+            command params[:shell_command]
           end
         end
-        xml.scriptOnlyIfSuccess params[:on_success]
-        xml.scriptOnlyIfFailure params[:on_failure]
-        xml.executeOn params[:execute_on] || 'BOTH'
       end
+      scriptOnlyIfSuccess params[:on_success]
+      scriptOnlyIfFailure params[:on_failure]
+      executeOn params[:execute_on] || 'BOTH'
     end
+  end
+end
 
-    register :groovy_postbuild do |params, xml|
-      xml.send('org.jvnet.hudson.plugins.groovypostbuild.GroovyPostbuildRecorder', 'plugin' => 'groovy-postbuild') do
-        xml.groovyScript params[:groovy_script]
-        xml.behavior params[:behavior] || '0'
-        xml.runFormMatrixParent 'false'
-        if params[:additional_classpaths]
-          params[:additional_classpaths].each do |path|
-            xml.send('org.jvnet.hudson.plugins.groovypostbuild.GroovyScriptPath') do
-              xml.path path[:path] || '/'
-            end
+publisher do
+  name :groovy_postbuild
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('org.jvnet.hudson.plugins.groovypostbuild.GroovyPostbuildRecorder', 'plugin' => 'groovy-postbuild') do
+      groovyScript params[:groovy_script]
+      behavior params[:behavior] || '0'
+      runFormMatrixParent 'false'
+      if params[:additional_classpaths]
+        params[:additional_classpaths].each do |path|
+          send('org.jvnet.hudson.plugins.groovypostbuild.GroovyScriptPath') do
+            path path[:path] || '/'
           end
         end
       end
     end
+  end
+end
+
+publisher do
+  name :archive_artifact
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send('hudson.tasks.ArtifactArchiver') do
+      artifacts params[:artifacts]
+      excludes params[:excludes] if params[:excludes]
+      latestOnly params[:latest_only] || false
+      allowEmptyArchive params[:allow_empty] || false
 
-    register :archive_artifact do |params, xml|
-      xml.send('hudson.tasks.ArtifactArchiver') do
-        xml.artifacts params[:artifacts]
-        xml.excludes params[:excludes] if params[:excludes]
-        xml.latestOnly params[:latest_only] || false
-        xml.allowEmptyArchive params[:allow_empty] || false
-      end
     end
+  end
+end
 
-    def self.coverage_metric(name, params, xml)
-      xml.send('hudson.plugins.rubyMetrics.rcov.model.MetricTarget') do
-        xml.metric name
-        xml.healthy params[:healthy]
-        xml.unhealthy params[:unhealthy]
-        xml.unstable params[:unstable]
-      end
+publisher do
+  name :email_notifications
+  plugin_id 123
+  min_version 0
+  announced false
+
+  xml do |params|
+    send 'hudson.tasks.Mailer', 'plugin' => 'mailer' do
+      recipients params[:recipients] || ''
+      send_unstable = false
+      send_unstable = true if params[:send_if_unstable] == false
+      dontNotifyEveryUnstableBuild send_unstable
+      sendToIndividuals params[:send_to_individuals] if params[:send_to_individuals]
     end
   end
 end