jenkins_pipeline_builder 0.5.2 → 0.6.0

data/lib/jenkins_pipeline_builder/cli/base.rb

@@ -31,7 +31,7 @@ module JenkinsPipelineBuilder
       class_option :server_ip, aliases:  '-s', desc:  'Jenkins server IP address'
       class_option :server_port, aliases:  '-o', desc:  'Jenkins port'
       class_option :creds_file, aliases:  '-c', desc:  'Credentials file for communicating with Jenkins server'
-      class_option :debug, type:  :boolean, aliases:  '-d', desc:  'Run in debug mode (no Jenkins changes)', default:  false
+      class_option :debug, type: :boolean, aliases: '-d', desc: 'Run in debug mode (no Jenkins changes)', default: false
 
       map '-v' => :version
 

data/lib/jenkins_pipeline_builder/cli/describe.rb

@@ -22,24 +22,28 @@
 
 module JenkinsPipelineBuilder
   module CLI
-    JenkinsPipelineBuilder.registry.entries.each do |entry, _path|
+    JenkinsPipelineBuilder.registry.entries.keys.each do |entry|
       klass_name = entry.to_s.classify
+      # rubocop:disable Style/AccessModifierIndentation
       klass = Class.new(Thor) do
 
-        modules =  JenkinsPipelineBuilder.registry.registered_modules[entry]
-        modules.each do |mod, values|
-          desc mod, "Details for #{mod}"
-          define_method(mod) do
-            display_module(mod, values)
+        extensions = JenkinsPipelineBuilder.registry.registry[:job][entry]
+        extensions.each do |key, exts|
+          # TODO: don't just take the first
+          ext = exts.first
+          desc key, "Details for #{ext.name}"
+          define_method(ext.name) do
+            display_module(ext)
           end
         end
 
         private
 
-        def display_module(mod, values)
-          puts "#{mod}: #{values[:description]}"
+        def display_module(ext)
+          puts "#{ext.name}: #{ext.description}"
         end
       end
+      # rubocop:enable Style/AccessModifierIndentation
       Module.const_set(klass_name, klass)
     end
     class Describe < Thor

data/lib/jenkins_pipeline_builder/cli/list.rb

@@ -23,24 +23,24 @@
 module JenkinsPipelineBuilder
   module CLI
     class List < Thor
-      JenkinsPipelineBuilder.registry.entries.each do |entry, _path|
+      JenkinsPipelineBuilder.registry.entries.keys.each do |entry|
         desc entry, "List all #{entry}"
         define_method(entry) do
-          modules =  JenkinsPipelineBuilder.registry.registered_modules[entry]
-          modules.each { |mod, values| display_module(mod, values) }
+          extensions =  JenkinsPipelineBuilder.registry.registry[:job][entry]
+          extensions.each { |name, ext| display_module(name, ext) }
         end
       end
 
       desc 'job_attributes', 'List all job attributes'
       def job_attributes
-        modules =  JenkinsPipelineBuilder.registry.registered_modules[:job_attributes]
-        modules.each { |mod, values| display_module(mod, values) }
+        extensions =  JenkinsPipelineBuilder.registry.registry[:job]
+        extensions.each { |name, ext| display_module(name, ext) }
       end
 
       private
 
-      def display_module(mod, values)
-        puts "#{mod}: Jenkins Name: #{values[:jenkins_name]}"
+      def display_module(name, ext)
+        puts "#{name}: Jenkins Name: #{ext.jenkins_name}"
       end
     end
   end

data/lib/jenkins_pipeline_builder/compiler.rb

@@ -48,69 +48,82 @@ module JenkinsPipelineBuilder
     def self.get_settings_bag(item_bag, settings_bag = {})
       item = item_bag[:value]
       bag = {}
-      return unless item.kind_of?(Hash)
+      return unless item.is_a?(Hash)
       item.keys.each do |k|
         val = item[k]
-        if val.kind_of? String
-          new_value = resolve_value(val, settings_bag, {})
-          return nil if new_value.nil?
-          bag[k] = new_value
-        end
+        next unless val.is_a? String
+        new_value = resolve_value(val, settings_bag, {})
+        return nil if new_value.nil?
+        bag[k] = new_value
       end
       my_settings_bag = settings_bag.clone
       my_settings_bag.merge(bag)
     end
 
     def self.compile(item, settings = {}, job_collection = {})
-      errors = {}
       case item
       when String
-        new_value = resolve_value(item, settings, job_collection)
-        errors[item] =  "Failed to resolve #{item}" if new_value.nil?
-        return false, errors unless errors.empty?
-        return true, new_value
+        return compile_string item, settings, job_collection
       when Hash
-        result = {}
-        item.each do |key, value|
-          if value.nil?
-            errors[key] = "key: #{key} has a nil value, this is likely a yaml syntax error. Skipping children and siblings"
-            break
-          end
-          success, payload = compile(value, settings, job_collection)
-          unless success
-            errors.merge!(payload)
-            next
-          end
-          if payload.nil?
-            errors[key] = "Failed to resolve:\n===>key: #{key}\n\n===>value: #{value}\n\n===>of: #{item}"
-            next
-          end
-          result[key] = payload
-        end
-        return false, errors unless errors.empty?
-        return true, result
+        return compile_hash item, settings, job_collection
       when Array
-        result = []
-        item.each do |value|
-          if value.nil?
-            errors[item] = "found a nil value when processing following array:\n #{item.inspect}"
-            break
-          end
-          success, payload = compile(value, settings, job_collection)
-          unless success
-            errors.merge!(payload)
-            next
-          end
-          if payload.nil?
-            errors[value] = "Failed to resolve:\n===>item #{value}\n\n===>of list: #{item}"
-            next
-          end
-          result << payload
-        end
-        return false, errors unless errors.empty?
-        return true, result
+        return compile_array item, settings, job_collection
       end
       [true, item]
     end
+
+    def self.compile_string(item, settings, job_collection)
+      errors = {}
+      new_value = resolve_value(item, settings, job_collection)
+      errors[item] =  "Failed to resolve #{item}" if new_value.nil?
+      return false, errors unless errors.empty?
+      [true, new_value]
+    end
+
+    def self.compile_array(item, settings, job_collection)
+      errors = {}
+      result = []
+      item.each do |value|
+        if value.nil?
+          errors[item] = "found a nil value when processing following array:\n #{item.inspect}"
+          break
+        end
+        success, payload = compile(value, settings, job_collection)
+        unless success
+          errors.merge!(payload)
+          next
+        end
+        if payload.nil?
+          errors[value] = "Failed to resolve:\n===>item #{value}\n\n===>of list: #{item}"
+          next
+        end
+        result << payload
+      end
+      return false, errors unless errors.empty?
+      [true, result]
+    end
+
+    def self.compile_hash(item, settings, job_collection)
+      errors = {}
+      result = {}
+      item.each do |key, value|
+        if value.nil?
+          errors[key] = "key: #{key} has a nil value, this is often a yaml syntax error. Skipping children and siblings"
+          break
+        end
+        success, payload = compile(value, settings, job_collection)
+        unless success
+          errors.merge!(payload)
+          next
+        end
+        if payload.nil?
+          errors[key] = "Failed to resolve:\n===>key: #{key}\n\n===>value: #{value}\n\n===>of: #{item}"
+          next
+        end
+        result[key] = payload
+      end
+      return false, errors unless errors.empty?
+      [true, result]
+    end
   end
 end

data/lib/jenkins_pipeline_builder/extensions.rb

@@ -0,0 +1,108 @@
+#
+# Copyright (c) 2014 Constant Contact
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+require 'jenkins_pipeline_builder'
+JenkinsPipelineBuilder.registry.entries.each do |type, path|
+  singular_type = type.to_s.singularize
+  define_method singular_type do |&block|
+    ext = JenkinsPipelineBuilder::Extension.new
+    ext.instance_eval(&block)
+    ext.path path
+    ext.type singular_type
+    unless ext.valid?
+      name = ext.name || 'A plugin with no name provided'
+      puts "Encountered errors while registering #{name}"
+      puts ext.errors.map { |k, v| "#{k}: #{v}" }.join(', ')
+      return false
+    end
+    JenkinsPipelineBuilder.registry.register([:job, type], ext)
+    puts "Successfully registered #{ext.name} for versions #{ext.min_version} and higher" if ext.announced
+  end
+end
+
+def job_attribute(&block)
+  ext = JenkinsPipelineBuilder::Extension.new
+  ext.instance_eval(&block)
+  ext.type :job_attribute
+  unless ext.valid?
+    name = ext.name || 'A plugin with no name provided'
+    puts "Encountered errors while registering #{name}"
+    puts ext.errors.map { |k, v| "#{k}: #{v}" }.join(', ')
+    return false
+  end
+  JenkinsPipelineBuilder.registry.register([:job], ext)
+  puts "Successfully registered #{ext.name} for versions #{ext.min_version} and higher" if ext.announced
+end
+
+module JenkinsPipelineBuilder
+  class Extension
+    DSL_METHODS = {
+      name: false,
+      plugin_id: false,
+      min_version: false,
+      jenkins_name: 'No jenkins display name set',
+      description: 'No description set',
+      path: false,
+      announced: true,
+      type: false
+    }
+    DSL_METHODS.keys.each do |method_name|
+      define_method method_name do |value = nil|
+        return instance_variable_get("@#{method_name}") if value.nil?
+        instance_variable_set("@#{method_name}", value)
+      end
+    end
+
+    def xml(path = false, &block)
+      @path = path if path
+      return @xml unless block
+      @xml = block
+    end
+
+    def after(&block)
+      return @after unless block
+      @after = block
+    end
+
+    def before(&block)
+      return @before unless block
+      @before = block
+    end
+
+    def initialize
+      DSL_METHODS.each do |key, value|
+        instance_variable_set("@#{key}", value) if value
+      end
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def errors
+      errors = {}
+      DSL_METHODS.keys.each do |name|
+        errors[name] = 'Must be set' if send(name).nil?
+      end
+      errors
+    end
+  end
+end

data/lib/jenkins_pipeline_builder/generator.rb

@@ -21,10 +21,12 @@
 #
 
 require 'yaml'
-require 'pp'
 
 module JenkinsPipelineBuilder
   class Generator
+    attr_reader :debug
+    attr_accessor :no_files, :job_templates, :job_collection, :logger, :module_registry, :remote_depends
+
     # Initialize a Client object with Jenkins Api Client
     #
     # @param args [Hash] Arguments to connect to Jenkins server
@@ -43,50 +45,19 @@ module JenkinsPipelineBuilder
       @module_registry = ModuleRegistry.new
     end
 
-    def load_extensions(path)
-      path = "#{path}/extensions"
-      path = File.expand_path(path, Dir.getwd)
-      if File.directory?(path)
-        @logger.info "Loading extensions from folder #{path}"
-        Dir[File.join(path, '/*.yaml'), File.join(path, '/*.yml')].each do |file|
-          @logger.info "Loading file #{file}"
-          yaml = YAML.load_file(file)
-          yaml.each do |ext|
-            Utils.symbolize_keys_deep!(ext)
-            ext = ext[:extension]
-            name = ext[:name]
-            type = ext[:type]
-            function = ext[:function]
-            fail "Duplicate extension with name '#{name}' was detected." if @extensions.key?(name)
-            @extensions[name.to_s] = { name: name.to_s, type: type, function: function }
-          end
-        end
-      end
-      @extensions.each_value do |ext|
-        name = ext[:name].to_sym
-        registry = @module_registry.registry[:job]
-        function = eval "Proc.new {|params,xml| #{ext[:function]} }"
-        type = ext[:type].downcase.pluralize.to_sym if ext[:type]
-        if type
-          registry[type][:registry][name] = function
-        else
-          registry[name] = function
-        end
-      end
-    end
-
     def debug=(value)
       @debug = value
-      @logger.level = (value) ? Logger::DEBUG : Logger::INFO
+      logger.level = (value) ? Logger::DEBUG : Logger::INFO
+    end
+
+    def logger
+      JenkinsPipelineBuilder.logger
     end
 
     def client
       JenkinsPipelineBuilder.client
     end
 
-    attr_reader :debug
-    attr_accessor :no_files, :job_collection, :logger, :module_registry
-
     # Creates an instance to the View class by passing a reference to self
     #
     # @return [JenkinsApi::Client::System] An object to System subclass
@@ -95,24 +66,128 @@ module JenkinsPipelineBuilder
       JenkinsPipelineBuilder::View.new(self)
     end
 
-    def load_collection_from_path(path, recursively = false, remote = false)
+    def bootstrap(path, project_name)
+      @logger.info "Bootstrapping pipeline from path #{path}"
+      load_collection_from_path(path)
+      # @logger.info @job_collection
+      cleanup_temp_remote
+      load_extensions(path)
+      errors = {}
+      # Publish all the jobs if the projects are not found
+      if projects.count == 0
+        errors = publish_jobs(jobs)
+      else
+        errors = publish_project(project_name)
+      end
+      errors.each do |k, v|
+        @logger.error "Encountered errors compiling: #{k}:"
+        @logger.error v
+      end
+      errors
+    end
+
+    def pull_request(path, project_name)
+      success = false
+      @logger.info "Pull Request Generator Running from path #{path}"
+      load_collection_from_path(path)
+      cleanup_temp_remote
+      load_extensions(path)
+      @logger.info "Project: #{projects}"
+      projects.each do |project|
+        next unless project[:name] == project_name || project_name.nil?
+        @logger.info "Using Project #{project}"
+        pull_job = find_pull_request_generator(project)
+        p_success, p_payload = compile_pull_request_generator(pull_job[:name], project)
+        next unless p_success
+        jobs = filter_pull_request_jobs(pull_job)
+        pull = JenkinsPipelineBuilder::PullRequestGenerator.new(project, jobs, p_payload)
+
+        @job_collection.merge! pull.jobs
+        success = create_pull_request_jobs(pull)
+        purge_pull_request_jobs(pull)
+      end
+      success
+    end
+
+    def dump(job_name)
+      @logger.info "Debug #{@debug}"
+      @logger.info "Dumping #{job_name} into #{job_name}.xml"
+      xml = client.job.get_config(job_name)
+      File.open(job_name + '.xml', 'w') { |f| f.write xml }
+    end
+
+    #
+    # BEGIN PRIVATE METHODS
+    #
+
+    private
+
+    def purge_pull_request_jobs(pull)
+      pull.purge.each do |purge_job|
+        jobs = client.job.list "#{purge_job}.*"
+        jobs.each do |job|
+          client.job.delete job
+        end
+      end
+    end
+
+    def create_pull_request_jobs(pull)
+      success = false
+      pull.create.each do |pull_project|
+        success, compiled_project = resolve_project(pull_project)
+        compiled_project[:value][:jobs].each do |i|
+          job = i[:result]
+          success, payload = compile_job_to_xml(job)
+          create_or_update(job, payload) if success
+        end
+      end
+      success
+    end
+
+    def find_pull_request_generator(project)
+      project_jobs = project[:value][:jobs] || []
+      pull_job = nil
+      project_jobs.each do |job|
+        job = job.keys.first if job.is_a? Hash
+        job = @job_collection[job.to_s]
+        pull_job = job if job[:value][:job_type] == 'pull_request_generator'
+      end
+      fail 'No Pull Request Found for Project' unless pull_job
+      pull_job
+    end
+
+    def filter_pull_request_jobs(pull_job)
+      jobs = {}
+      pull_jobs = pull_job[:value][:jobs] || []
+      pull_jobs.each do |job|
+        if job.is_a? String
+          jobs[job.to_s] = @job_collection[job.to_s]
+        else
+          jobs[job.keys.first.to_s] = @job_collection[job.keys.first.to_s]
+        end
+      end
+      fail 'No jobs found for pull request' if jobs.empty?
+      jobs
+    end
+
+    def compile_pull_request_generator(pull_job, project)
+      defaults = get_item('global')
+      settings = defaults.nil? ? {} : defaults[:value] || {}
+      settings = Compiler.get_settings_bag(project, settings)
+      resolve_job_by_name(pull_job, settings)
+    end
+
+    def load_collection_from_path(path, remote = false)
       path = File.expand_path(path, Dir.getwd)
       if File.directory?(path)
-        @logger.info "Generating from folder #{path}"
+        logger.info "Generating from folder #{path}"
         Dir[File.join(path, '/*.yaml'), File.join(path, '/*.yml')].each do |file|
-          if File.directory?(file) # TODO: This doesn't work unless the folder contains .yml or .yaml at the end
-            if recursively
-              load_collection_from_path(File.join(path, file), recursively)
-            else
-              next
-            end
-          end
-          @logger.info "Loading file #{file}"
+          logger.info "Loading file #{file}"
           yaml = YAML.load_file(file)
           load_job_collection(yaml, remote)
         end
       else
-        @logger.info "Loading file #{path}"
+        logger.info "Loading file #{path}"
         yaml = YAML.load_file(path)
         load_job_collection(yaml, remote)
       end
@@ -124,14 +199,14 @@ module JenkinsPipelineBuilder
         key = section.keys.first
         value = section[key]
         if key == :dependencies
-          @logger.info 'Resolving Dependencies for remote project'
+          logger.info 'Resolving Dependencies for remote project'
           load_remote_yaml(value)
           next
         end
         name = value[:name]
         if @job_collection.key?(name)
           if remote
-            @logger.info "Duplicate item with name '#{name}' was detected from the remote folder."
+            logger.info "Duplicate item with name '#{name}' was detected from the remote folder."
           else
             fail "Duplicate item with name '#{name}' was detected."
           end
@@ -145,6 +220,54 @@ module JenkinsPipelineBuilder
       @job_collection[name.to_s]
     end
 
+    def load_extensions(path)
+      path = "#{path}/extensions"
+      path = File.expand_path(path, Dir.getwd)
+      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|
+          logger.info "Loaded #{file}"
+          require file
+        end
+      end
+      match_extension_versions
+    end
+
+    def match_extension_versions
+      registry = @module_registry.registry[:job]
+      installed_plugins = @debug ? nil : list_plugins # Only get plugins if not in debug mode
+      @logger.debug 'Loading newest version of all plugins since we are in debug mode.'
+      registry.each do |registry_key, registry_value|
+        if registry_value.count > 1
+          registry_value.each_key do |extension_key|
+            registry[registry_key][extension_key] = newest_compatible(extension_key, installed_plugins, registry_key)
+          end
+        else
+          registry[registry_key] = newest_compatible(registry_key, installed_plugins)
+        end
+      end
+    end
+
+    def newest_compatible(extension, installed_plugins, key = nil)
+      # Fetch the registrered_modules for the extension
+      registry = @module_registry.registry[:job]
+      registry = registry[key] unless key.nil?
+      registry = registry[extension]
+      keep = nil
+      keep_version = ''
+      registry.each do |ex|
+        is_available = @debug ? true : ex.min_version.to_s <= installed_plugins[ex.plugin_id.to_s].to_s
+        is_newer = ex.min_version.to_s >= keep_version
+
+        next unless keep.nil? || (is_available && is_newer)
+
+        keep = ex
+        keep_version = ex.min_version
+      end
+      keep
+    end
+
     def load_template(path, template)
       # If we specify what folder the yaml is in, load that
       if template[:folder]
@@ -154,10 +277,7 @@ module JenkinsPipelineBuilder
         # If we are looking for the newest version or no version was set
         if (template[:version].nil? || template[:version] == 'newest') && File.directory?(path)
           folders = Dir.entries(path)
-          highest = '0' # Default to v1
-          folders.each do |f|
-            highest = f if f > highest # Note: to_i returns any integers in the folder name
-          end
+          highest = folders.max
           template[:version] = highest unless highest == 0
         end
         path = File.join(path, template[:version]) unless template[:version].nil?
@@ -165,8 +285,8 @@ module JenkinsPipelineBuilder
       end
 
       if File.directory?(path)
-        @logger.info "Loading from #{path}"
-        load_collection_from_path(path, false, true)
+        logger.info "Loading from #{path}"
+        load_collection_from_path(path, true)
         true
       else
         false
@@ -175,7 +295,7 @@ module JenkinsPipelineBuilder
 
     def download_yaml(url, file)
       @remote_depends[url] = file
-      @logger.info "Downloading #{url} to #{file}.tar"
+      logger.info "Downloading #{url} to #{file}.tar"
       open("#{file}.tar", 'w') do |local_file|
         open(url) do |remote_file|
           local_file.write(Zlib::GzipReader.new(remote_file).read)
@@ -183,7 +303,7 @@ module JenkinsPipelineBuilder
       end
 
       # Extract Tar.gz to 'remote' folder
-      @logger.info "Unpacking #{file}.tar to #{file} folder"
+      logger.info "Unpacking #{file}.tar to #{file} folder"
       Archive::Tar::Minitar.unpack("#{file}.tar", file)
     end
 
@@ -203,7 +323,7 @@ module JenkinsPipelineBuilder
         path = File.expand_path(file, Dir.getwd)
         # Load templates recursively
         unless source[:templates]
-          @logger.info 'No specific template specified'
+          logger.info 'No specific template specified'
           # Try to load the folder or the pipeline folder
           path = File.join(path, 'pipeline') if Dir.entries(path).include? 'pipeline'
           return load_collection_from_path(path)
@@ -216,12 +336,12 @@ module JenkinsPipelineBuilder
     def load_templates(path, templates)
       templates.each do |template|
         version = template[:version] || 'newest'
-        @logger.info "Loading #{template[:name]} at version #{version}"
+        logger.info "Loading #{template[:name]} at version #{version}"
         # Move into the remote folder and look for the template folder
         remote = Dir.entries(path)
         if remote.include? template[:name]
           # We found the template name, load this path
-          @logger.info 'We found the template!'
+          logger.info 'We found the template!'
           load_template(path, template)
         else
           # Many cases we must dig one layer deep
@@ -239,9 +359,13 @@ module JenkinsPipelineBuilder
       end
     end
 
+    def list_plugins
+      client.plugin.list_installed
+    end
+
     def prepare_jobs(jobs)
       jobs.map! do |job|
-        job.kind_of?(String) ? { job.to_sym => {} } : job
+        job.is_a?(String) ? { job.to_sym => {} } : job
       end
     end
 
@@ -249,6 +373,9 @@ module JenkinsPipelineBuilder
       jobs.each do |job|
         job_id = job.keys.first
         j = get_item(job_id)
+
+        next unless j
+
         Utils.hash_merge!(j, job[job_id])
         j[:value][:name] = j[:job_name] if j[:job_name]
       end
@@ -256,7 +383,7 @@ module JenkinsPipelineBuilder
 
     def process_views(views, project, errors = {})
       views.map! do |view|
-        view.kind_of?(String) ? { view.to_sym => {} } : view
+        view.is_a?(String) ? { view.to_sym => {} } : view
       end
       views.each do |view|
         view_id = view.keys.first
@@ -293,11 +420,10 @@ module JenkinsPipelineBuilder
       project_body = project[:value]
 
       jobs = prepare_jobs(project_body[:jobs]) if project_body[:jobs]
-      @logger.info project
+      logger.info project
       process_job_changes(jobs)
       errors = process_jobs(jobs, project)
       errors = process_views(project_body[:views], project,  errors) if project_body[:views]
-
       errors.each do |k, v|
         puts "Encountered errors processing: #{k}:"
         v.each do |key, error|
@@ -314,7 +440,7 @@ module JenkinsPipelineBuilder
       job = get_item(name)
       fail "Failed to locate job by name '#{name}'" if job.nil?
       job_value = job[:value]
-      @logger.debug "Compiling job #{name}"
+      logger.debug "Compiling job #{name}"
       success, payload = Compiler.compile(job_value, settings, @job_collection)
       [success, payload]
     end
@@ -340,21 +466,17 @@ module JenkinsPipelineBuilder
         next unless project_name.nil? || project[:name] == project_name
         success, payload = resolve_project(project)
         if success
-          puts 'successfully resolved project'
+          @logger.info 'successfully resolved project'
           compiled_project = payload
         else
-          puts payload
           return false
         end
 
-        if compiled_project[:value][:jobs]
-          errors = publish_jobs(compiled_project[:value][:jobs])
-        end
-        if compiled_project[:value][:views]
-          compiled_project[:value][:views].each do |v|
-            compiled_view = v[:result]
-            view.create(compiled_view)
-          end
+        errors = publish_jobs(compiled_project[:value][:jobs]) if compiled_project[:value][:jobs]
+        next unless compiled_project[:value][:views]
+        compiled_project[:value][:views].each do |v|
+          compiled_view = v[:result]
+          view.create(compiled_view)
         end
       end
       errors
@@ -362,7 +484,7 @@ module JenkinsPipelineBuilder
 
     def publish_jobs(jobs, errors = {})
       jobs.each do |i|
-        puts "Processing #{i}"
+        @logger.info "Processing #{i}"
         job = i[:result]
         fail "Result is empty for #{i}" if job.nil?
         success, payload = compile_job_to_xml(job)
@@ -375,86 +497,11 @@ module JenkinsPipelineBuilder
       errors
     end
 
-    def bootstrap(path, project_name)
-      @logger.info "Bootstrapping pipeline from path #{path}"
-      load_collection_from_path(path)
-      @logger.info @job_collection
-      cleanup_temp_remote
-      load_extensions(path)
-      errors = {}
-      # Publish all the jobs if the projects are not found
-      if projects.count == 0
-        errors = publish_jobs(jobs)
-      else
-        errors = publish_project(project_name)
-      end
-      errors.each do |k, v|
-        @logger.error "Encountered errors compiling: #{k}:"
-        @logger.error v
-      end
-    end
-
-    def pull_request(path, project_name)
-      @logger.info "Pull Request Generator Running from path #{path}"
-      load_collection_from_path(path)
-      cleanup_temp_remote
-      load_extensions(path)
-      jobs = {}
-      @logger.info "Project: #{projects}"
-      projects.each do |project|
-        if project[:name] == project_name || project_name.nil?
-          project_body = project[:value]
-          project_jobs = project_body[:jobs] || []
-          @logger.info "Using Project #{project}"
-          pull_job = nil
-          project_jobs.each do |job|
-            job = job.keys.first if job.is_a? Hash
-            job = @job_collection[job.to_s]
-            pull_job = job if job[:value][:job_type] == 'pull_request_generator'
-          end
-          fail 'No Pull Request Found for Project' unless pull_job
-          pull_jobs = pull_job[:value][:jobs] || []
-          pull_jobs.each do |job|
-            if job.is_a? String
-              jobs[job.to_s] = @job_collection[job.to_s]
-            else
-              jobs[job.keys.first.to_s] = @job_collection[job.keys.first.to_s]
-            end
-          end
-          pull = JenkinsPipelineBuilder::PullRequestGenerator.new(project, jobs, pull_job)
-          # Build the jobs
-          @job_collection.merge! pull.jobs
-          pull.create.each do |project|
-            success, compiled_project = resolve_project(project)
-            compiled_project[:value][:jobs].each do |i|
-              job = i[:result]
-              success, payload = compile_job_to_xml(job)
-              create_or_update(job, payload) if success
-            end
-          end
-          # Purge old jobs
-          pull.purge.each do |job|
-            jobs = @client.job.list "#{job}.*"
-            jobs.each do |job|
-              @client.job.delete job
-            end
-          end
-        end
-      end
-    end
-
-    def dump(job_name)
-      @logger.info "Debug #{@debug}"
-      @logger.info "Dumping #{job_name} into #{job_name}.xml"
-      xml = client.job.get_config(job_name)
-      File.open(job_name + '.xml', 'w') { |f| f.write xml }
-    end
-
     def create_or_update(job, xml)
       job_name = job[:name]
       if @debug
-        @logger.info "Will create job #{job}"
-        @logger.info "#{xml}"
+        logger.info "Will create job #{job}"
+        logger.info "#{xml}"
         File.open(job_name + '.xml', 'w') { |f| f.write xml }
         return
       end
@@ -469,7 +516,7 @@ module JenkinsPipelineBuilder
     def compile_job_to_xml(job)
       fail 'Job name is not specified' unless job[:name]
 
-      @logger.info "Creating Yaml Job #{job}"
+      logger.info "Creating Yaml Job #{job}"
       job[:job_type] = 'free_style' unless job[:job_type]
       case job[:job_type]
       when 'job_dsl'
@@ -511,7 +558,9 @@ module JenkinsPipelineBuilder
       xml   = client.job.build_freestyle_config(params)
       n_xml = Nokogiri::XML(xml)
 
+      logger.debug 'Loading the required modules'
       @module_registry.traverse_registry_path('job', params, n_xml)
+      logger.debug 'Module loading complete'
 
       n_xml.to_xml
     end
@@ -519,8 +568,8 @@ module JenkinsPipelineBuilder
     def add_job_dsl(job, xml)
       n_xml = Nokogiri::XML(xml)
       n_xml.root.name = 'com.cloudbees.plugins.flow.BuildFlow'
-      Nokogiri::XML::Builder.with(n_xml.root) do |xml|
-        xml.dsl job[:build_flow]
+      Nokogiri::XML::Builder.with(n_xml.root) do |b_xml|
+        b_xml.dsl job[:build_flow]
       end
       n_xml.to_xml
     end
@@ -529,14 +578,14 @@ module JenkinsPipelineBuilder
     def update_job_dsl(job, xml)
       n_xml      = Nokogiri::XML(xml)
       n_builders = n_xml.xpath('//builders').first
-      Nokogiri::XML::Builder.with(n_builders) do |xml|
-        build_job_dsl(job, xml)
+      Nokogiri::XML::Builder.with(n_builders) do |b_xml|
+        build_job_dsl(job, b_xml)
       end
       n_xml.to_xml
     end
 
     def generate_job_dsl_body(params)
-      @logger.info 'Generating pipeline'
+      logger.info 'Generating pipeline'
 
       xml = client.job.build_freestyle_config(params)