jenkins_pipeline_builder 0.10.16 → 0.11.0

data/lib/jenkins_pipeline_builder/extensions/triggers.rb

@@ -76,27 +76,13 @@ trigger do
   announced false
 
   xml do |params|
-    case params[:status]
-    when 'unstable'
-      name = 'UNSTABLE'
-      ordinal = '1'
-      color = 'yellow'
-    when 'failed'
-      name = 'FAILURE'
-      ordinal = '2'
-      color = 'RED'
-    else
-      name = 'SUCCESS'
-      ordinal = '0'
-      color = 'BLUE'
-    end
     send('jenkins.triggers.ReverseBuildTrigger') do
       spec
       upstreamProjects params[:projects]
       send('threshold') do
-        name name
-        ordinal ordinal
-        color color
+        name params.name
+        ordinal params.ordinal
+        color params.color
         completeBuild true
       end
     end

data/lib/jenkins_pipeline_builder/extensions/wrappers.rb

@@ -92,11 +92,11 @@ wrapper do
 
   xml do |wrapper|
     EnvInjectPasswordWrapper do
-      if wrapper.is_a? Array
-        passwords = wrapper
-      else
+      if wrapper.respond_to? :keys
         injectGlobalPasswords wrapper[:inject_global_passwords]
         passwords = wrapper[:passwords]
+      else
+        passwords = wrapper
       end
       break unless passwords
       passwordEntries do

data/lib/jenkins_pipeline_builder/generator.rb

@@ -69,13 +69,7 @@ module JenkinsPipelineBuilder
       errors = {}
       job_collection.projects.each do |project|
         next unless project[:name] == project_name || project_name.nil?
-        logger.info "Using Project #{project}"
-
-        pull_request_generator = JenkinsPipelineBuilder::PullRequestGenerator.new project, self
-
-        unless pull_request_generator.valid?
-          errors[pull_request_generator.pull_generator[:name]] = pull_request_generator.errors
-        end
+        errors.merge! process_pull_request_project project
 
       end
       errors.each do |k, v|
@@ -132,12 +126,17 @@ module JenkinsPipelineBuilder
       [true, project]
     end
 
-    #
-    # BEGIN PRIVATE METHODS
-    #
-
     private
 
+    def process_pull_request_project(project)
+      logger.info "Using Project #{project}"
+
+      pull_request_generator = JenkinsPipelineBuilder::PullRequestGenerator.new project, self
+
+      return {} if pull_request_generator.valid?
+      { pull_request_generator.pull_generator[:name] => pull_request_generator.errors }
+    end
+
     def prepare_jobs(jobs)
       jobs.map! do |job|
         job.is_a?(String) ? { job.to_sym => {} } : job

data/lib/jenkins_pipeline_builder/job.rb

@@ -18,13 +18,7 @@ module JenkinsPipelineBuilder
       success, payload = to_xml
       return success, payload unless success
       xml = payload
-      if JenkinsPipelineBuilder.debug || JenkinsPipelineBuilder.file_mode
-        logger.info "Will create job #{job}"
-        logger.info "#{xml}" if @debug
-        FileUtils.mkdir_p(out_dir) unless File.exist?(out_dir)
-        File.open("#{out_dir}/#{name}.xml", 'w') { |f| f.write xml }
-        return [true, nil]
-      end
+      return local_output(xml) if JenkinsPipelineBuilder.debug || JenkinsPipelineBuilder.file_mode
 
       if JenkinsPipelineBuilder.client.job.exists?(name)
         JenkinsPipelineBuilder.client.job.update(name, xml)
@@ -39,28 +33,38 @@ module JenkinsPipelineBuilder
 
       logger.info "Creating Yaml Job #{job}"
       job[:job_type] = 'free_style' unless job[:job_type]
-      case job[:job_type]
-      when 'job_dsl'
-        @xml = setup_freestyle_base(job)
-        payload = update_job_dsl
-      when 'multi_project'
-        # TODO: Add multi_job as another, more logically named option
-        @xml = setup_freestyle_base(job)
-        payload = adjust_multi_project
-      when 'build_flow'
-        @xml = setup_freestyle_base(job)
-        payload = add_job_dsl
-      when 'free_style', 'pull_request_generator'
-        payload = setup_freestyle_base job
-      else
-        return false, "Job type: #{job[:job_type]} is not one of job_dsl, multi_project, build_flow or free_style"
-      end
+      type = job[:job_type]
+      return false, "Job type: #{type} is not one of #{job_methods.join(', ')}" unless known_type? type
+      @xml = setup_freestyle_base(job)
+      payload = send("update_#{type}")
 
       [true, payload]
     end
 
     private
 
+    [:free_style, :pull_request_generator].each do |method_name|
+      define_method "update_#{method_name}" do
+        @xml
+      end
+    end
+
+    def known_type?(type)
+      job_methods.include? type
+    end
+
+    def job_methods
+      %w(job_dsl multi_project build_flow free_style pull_request_generator)
+    end
+
+    def local_output(xml)
+      logger.info "Will create job #{job}"
+      logger.info "#{xml}" if @debug
+      FileUtils.mkdir_p(out_dir) unless File.exist?(out_dir)
+      File.open("#{out_dir}/#{name}.xml", 'w') { |f| f.write xml }
+      [true, nil]
+    end
+
     def out_dir
       'out/xml'
     end
@@ -88,14 +92,14 @@ module JenkinsPipelineBuilder
       end
     end
 
-    def adjust_multi_project
+    def update_multi_project
       n_xml = Nokogiri::XML(@xml)
       root = n_xml.root
       root.name = 'com.tikal.jenkins.plugins.multijob.MultiJobProject'
       n_xml.to_xml
     end
 
-    def add_job_dsl
+    def update_build_flow
       n_xml = Nokogiri::XML(@xml)
       n_xml.root.name = 'com.cloudbees.plugins.flow.BuildFlow'
       Nokogiri::XML::Builder.with(n_xml.root) do |b_xml|

data/lib/jenkins_pipeline_builder/job_collection.rb

@@ -74,29 +74,39 @@ module JenkinsPipelineBuilder
       end
       logger.info "Loading file #{path}"
       hash.each do |section|
-        Utils.symbolize_keys_deep!(section)
-        key = section.keys.first
-        value = section[key]
-        if key == :dependencies
-          logger.info 'Resolving Dependencies for remote project'
-          remote_dependencies.load value
-          next
-        end
-        name = value[:name]
-        if collection.key?(name)
-          existing_remote = collection[name.to_s][:remote]
-          # skip if the existing item is local and the new item is remote
-          if remote && !existing_remote
-            next
+        load_section section, remote
+      end
+    end
+
+    def load_section(section, remote)
+      Utils.symbolize_keys_deep!(section)
+      key = section.keys.first
+      value = section[key]
+      if key == :dependencies
+        logger.info 'Resolving Dependencies for remote project'
+        remote_dependencies.load value
+        return
+      end
+      name = value[:name]
+      process_collection! name, key, value, remote
+    end
+
+    # TODO: This should be cleaned up a bit. I'm sure we can get rid of
+    # the elsif and we should be more clear on the order of loading of things
+    def process_collection!(name, key, value, remote)
+      if collection.key?(name)
+        existing_remote = collection[name.to_s][:remote]
+        # skip if the existing item is local and the new item is remote
+        if remote && !existing_remote
+          return
           # override if the existing item is remote and the new is local
-          elsif existing_remote && !remote
-            logger.info "Duplicate item with name '#{name}' was detected from the remote folder."
-          else
-            fail "Duplicate item with name '#{name}' was detected."
-          end
+        elsif existing_remote && !remote
+          logger.info "Duplicate item with name '#{name}' was detected from the remote folder."
+        else
+          fail "Duplicate item with name '#{name}' was detected."
         end
-        collection[name.to_s] = { name: name.to_s, type: key, value: value, remote: remote }
       end
+      collection[name.to_s] = { name: name.to_s, type: key, value: value, remote: remote }
     end
 
     def load_extensions(path)
@@ -105,7 +115,7 @@ module JenkinsPipelineBuilder
       return unless File.directory?(path)
       logger.info "Loading extensions from folder #{path}"
       logger.info Dir.glob("#{path}/*.rb").inspect
-      Dir.glob("#{path}/*.rb").each do |file|
+      Dir.glob("#{path}/**/*.rb").each do |file|
         logger.info "Loaded #{file}"
         require file
       end

data/lib/jenkins_pipeline_builder/module_registry.rb

@@ -33,8 +33,12 @@ module JenkinsPipelineBuilder
       @versions ||= JenkinsPipelineBuilder.client.plugin.list_installed
     end
 
-    def clear_versions
+    def clear_versions(sets = registry.values)
       @versions = nil
+      sets.each do |entry|
+        entry.clear_installed_version if entry.is_a? ExtensionSet
+        clear_versions entry.values if entry.respond_to? :values
+      end
     end
 
     def logger

data/lib/jenkins_pipeline_builder/project.rb

@@ -0,0 +1,28 @@
+module JenkinsPipelineBuilder
+  class Project
+    attr_reader :input
+    attr_accessor :errors
+    def initialize(name, input)
+      @name = name
+      @input = input
+      @errors = {}
+    end
+
+    def publish
+      success, payload = resolve_project(input)
+      if success
+        logger.info 'successfully resolved project'
+        compiled_project = payload
+      else
+        return { project_name: 'Failed to resolve' }
+      end
+
+      self.errors = publish_jobs(compiled_project[:value][:jobs]) if compiled_project[:value][:jobs]
+      return unless compiled_project[:value][:views]
+      compiled_project[:value][:views].each do |v|
+        compiled_view = v[:result]
+        view.create(compiled_view)
+      end
+    end
+  end
+end

data/lib/jenkins_pipeline_builder/pull_request_generator.rb

@@ -29,17 +29,13 @@ module JenkinsPipelineBuilder
     def initialize(project, generator)
       @project = project
       @generator = generator
-
       @purge = []
       @create = []
-
       @errors = {}
+
       @pull_generator = find
-      success, payload = compile_generator
-      unless success
-        @errors[@pull_generator[:name]] = payload
-        return false
-      end
+      payload = compile_generator
+      return unless payload
       @jobs = filter_jobs
 
       # old init
@@ -113,7 +109,11 @@ module JenkinsPipelineBuilder
       settings = defaults.nil? ? {} : defaults[:value] || {}
       compiler = Compiler.new generator
       settings = compiler.get_settings_bag(project, settings)
-      generator.resolve_job_by_name(pull_generator[:name], settings)
+      success, payload = generator.resolve_job_by_name(pull_generator[:name], settings)
+      return payload if success
+
+      @errors[@pull_generator[:name]] = payload
+      false
     end
 
     def find

data/lib/jenkins_pipeline_builder/version.rb

@@ -21,5 +21,5 @@
 #
 
 module JenkinsPipelineBuilder
-  VERSION = '0.10.16'
+  VERSION = '0.11.0'
 end

data/spec/lib/jenkins_pipeline_builder/extension_dsl_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe 'extension dsl' do
+  before :all do
+    JenkinsPipelineBuilder.credentials = {
+      server_ip: '127.0.0.1',
+      server_port: 8080,
+      username: 'username',
+      password: 'password',
+      log_location: '/dev/null'
+    }
+  end
+
+  after :each do
+    JenkinsPipelineBuilder.registry.clear_versions
+  end
+
+  it 'overrides included extensions with local ones' do
+    builder do
+      name :shell_command
+      plugin_id 'builtin'
+      description 'Lets you run shell commands as a build step.'
+      jenkins_name 'Execute shell'
+      announced false
+
+      xml do |param|
+        newShell do
+          command param
+        end
+      end
+    end
+
+    allow(JenkinsPipelineBuilder.client).to receive(:plugin).and_return double(
+      list_installed: { 'parameterized-trigger' => '20.0' })
+
+    @n_xml = Nokogiri::XML::Builder.new { |xml| xml.builders }.doc
+    params = { builders: { shell_command: 'asdf' } }
+    JenkinsPipelineBuilder.registry.traverse_registry_path('job', params, @n_xml)
+
+    builder = @n_xml.root.children.first
+    expect(builder.name).to match 'newShell'
+  end
+end

data/spec/lib/jenkins_pipeline_builder/extension_set_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe JenkinsPipelineBuilder::ExtensionSet do
+  subject(:set) { JenkinsPipelineBuilder::ExtensionSet.new('foo') {} }
+
+  before :each do
+    set.name 'example'
+  end
+
+  context 'xml' do
+    it 'returns the block for the correct version'
+    it 'sets the min_version if a parameter is provided' do
+      set.xml version: '0.2' do
+        true
+      end
+      expect(set.blocks).to have_key '0.2'
+    end
+    it 'uses the path if provided' do
+      set.xml path: 'foo' do
+        true
+      end
+      expect(set.blocks['0'][:path]).to eq 'foo'
+    end
+  end
+
+  context '#installed_version' do
+    it 'parses three digits' do
+      set.installed_version = '0.1.2'
+      expect(set.installed_version.version).to eq '0.1.2'
+    end
+
+    it 'parses only two digits' do
+      set.installed_version = '0.1'
+      expect(set.installed_version.version).to eq '0.1'
+    end
+  end
+
+  context '#extension' do
+    def new_ext(version = '0.0')
+      ext = JenkinsPipelineBuilder::Extension.new
+      ext.name 'foo'
+      ext.plugin_id 'foo'
+      ext.min_version version
+      ext.xml -> { true }
+      ext.type 'foo'
+      ext.path 'foo'
+      ext
+    end
+
+    def ext_versions(versions)
+      versions.each do |v|
+        ext = new_ext(v)
+        expect(ext).to be_valid
+        set.extensions << ext
+      end
+
+      expect(set).to be_valid
+      expect(set.extensions.size).to eq versions.size
+    end
+
+    it 'returns an extension' do
+      ext_versions ['0.0']
+      set.installed_version = '0.1'
+      expect(set.extension).to be_kind_of JenkinsPipelineBuilder::Extension
+    end
+
+    it 'returns the highest that is lower than the installed version' do
+      ext_versions ['0.0', '0.2']
+
+      set.installed_version = '0.1'
+
+      expect(set.extension.min_version).to eq '0.0'
+    end
+
+    it 'returns highest available if the installed version is higher' do
+      ext_versions ['0.0', '0.2']
+
+      set.installed_version = '0.3'
+
+      expect(set.extension.min_version).to eq '0.2'
+    end
+
+    it 'works for complicated version comparions' do
+      ext_versions ['10.5', '9.2', '100.4']
+
+      set.installed_version = '11.3'
+
+      expect(set.extension.min_version).to eq '10.5'
+    end
+
+    it 'raises an error if the registered versions are too high' do
+      ext_versions ['10.5', '9.2']
+
+      set.installed_version = '1.3'
+
+      expect { set.extension.min_version }.to raise_error
+    end
+
+    it 'works for snapshot/beta stuff' do
+      ext_versions ['1.9', '2.3']
+
+      set.installed_version = '2.0-SNAPSHOT (private-06/06/2014 09:51-bgaulin)'
+      # Other examples
+      # set.installed_version = '2.0-beta-1'
+      # set.installed_version = '2.0+build.93'
+      # set.installed_version = '2.0.8'
+      expect(set.extension.min_version).to eq '1.9'
+    end
+  end
+end