puppetfile-resolver 0.1.0

data/lib/puppetfile-resolver/puppetfile/parser/r10k_eval/puppet_module.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/module/invalid'
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/module/forge'
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/module/git'
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/module/local'
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval/module/svn'
+
+module PuppetfileResolver
+  module Puppetfile
+    module Parser
+      module R10KEval
+        module PuppetModule
+          def self.from_puppetfile(title, args)
+            return Module::Git.to_document_module(title, args) if Module::Git.implements?(title, args)
+            return Module::Svn.to_document_module(title, args) if Module::Svn.implements?(title, args)
+            return Module::Local.to_document_module(title, args) if Module::Local.implements?(title, args)
+            return Module::Forge.to_document_module(title, args) if Module::Forge.implements?(title, args)
+
+            Module::Invalid.to_document_module(title, args)
+          end
+
+          def self.parse_title(title)
+            if (match = title.match(/\A(\w+)\Z/))
+              [nil, match[1]]
+            elsif (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
+              [match[1], match[2]]
+            else
+              raise ArgumentError, format("Module name (%<title>s) must match either 'modulename' or 'owner/modulename'", title: title)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/svn_module.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/base_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class SvnModule < BaseModule
+      attr_accessor :remote
+
+      def initialize(title)
+        super
+        @module_type = SVN_MODULE
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile/validation_errors.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Puppetfile
+    class DocumentValidationErrorBase
+      attr_accessor :message
+      attr_accessor :puppet_module
+
+      def initialize(message, puppet_module)
+        @message = message
+        @puppet_module = puppet_module
+      end
+
+      def to_s
+        "#{puppet_module.name}: #{message}"
+      end
+    end
+
+    # Validation Error classes for parsing Puppetfiles
+    class DocumentInvalidModuleError < DocumentValidationErrorBase
+    end
+
+    class DocumentDuplicateModuleError < DocumentValidationErrorBase
+      attr_accessor :duplicates
+
+      def initialize(message, puppet_module, duplicates)
+        super(message, puppet_module)
+        @duplicates = duplicates
+      end
+    end
+
+    # Terminal Errors during resolution
+    class DocumentResolveError < StandardError
+      attr_reader :molinillo_error
+
+      def initialize(message, molinillo_error)
+        @molinillo_error = molinillo_error
+        super(message)
+      end
+    end
+
+    class DocumentCircularDependencyError < DocumentResolveError
+      def initialize(puppetfile_document, molinillo_error)
+        @puppetfile_document = puppetfile_document
+        super(molinillo_error.message, molinillo_error)
+      end
+
+      def puppetfile_modules
+        module_names = @molinillo_error.dependencies.map(&:name)
+        @puppetfile_document.modules.select { |mod| module_names.include?(mod.name) }
+      end
+    end
+
+    class DocumentVersionConflictError < DocumentResolveError
+      def initialize(molinillo_error)
+        super(molinillo_error.message_with_trees(solver_name: 'Puppetfile Resolver'), molinillo_error)
+      end
+
+      def puppetfile_modules
+        puppetfile_modules = []
+        molinillo_error.conflicts.reduce(''.dup) do |_o, (_name, conflict)|
+          # We don't actually care about the dependency tree,
+          # only the leaves within. So just grab all of leaves and
+          # find all of the modules in the Puppetfile document
+          conflict
+            .requirement_trees
+            .flatten
+            .uniq
+            .select { |req| req.is_a?(PuppetfileResolver::Models::PuppetfileDependency) }
+            .each do |req|
+              puppetfile_modules << req.puppetfile_module unless puppetfile_modules.include?(req.puppetfile_module)
+            end
+        end
+
+        puppetfile_modules
+      end
+    end
+
+    # Resolution Validation Error classes for validating
+    # a valid Puppetfile against a dependency resolution
+    class DocumentResolutionErrorBase < DocumentValidationErrorBase
+      attr_accessor :puppet_module
+      attr_accessor :module_specification
+
+      def initialize(message, puppet_module, module_specification)
+        super(message, puppet_module)
+        @module_specification = module_specification
+      end
+    end
+
+    class DocumentLatestVersionError < DocumentResolutionErrorBase
+    end
+
+    class DocumentMissingModuleError < DocumentResolutionErrorBase
+    end
+
+    class DocumentMissingDependenciesError < DocumentResolutionErrorBase
+      attr_accessor :missing_specifications
+
+      def initialize(message, puppet_module, module_specification, missing_specifications)
+        super(message, puppet_module, module_specification)
+        @missing_specifications = missing_specifications
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/resolution_provider.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'molinillo'
+require 'puppetfile-resolver/cache/base'
+require 'puppetfile-resolver/spec_searchers/forge'
+require 'puppetfile-resolver/spec_searchers/git'
+require 'puppetfile-resolver/spec_searchers/local'
+
+module PuppetfileResolver
+  class ResolutionProvider
+    include Molinillo::SpecificationProvider
+
+    # options
+    #   module_paths : Array of paths
+    #   strict_mode  : [Boolean] Whether missing dependencies throw an error (default: false)
+    def initialize(puppetfile_document, puppet_version, resolver_ui, options = {})
+      require 'semantic_puppet'
+
+      @puppetfile_document = puppetfile_document
+      raise 'The UI object must be of type Molinillo::UI' if resolver_ui.nil? || !resolver_ui.is_a?(Molinillo::UI)
+      @resolver_ui = resolver_ui
+      # TODO: This default crap should move to the resolve class and we just validate (and raise) here
+      @puppet_module_paths = options[:module_paths].nil? ? [] : options[:module_paths]
+      @allow_missing_modules = options[:allow_missing_modules].nil? ? true : options[:allow_missing_modules] == true
+      # There can be only one puppet specification in existance so we pre-load here.
+      @puppet_specification = Models::PuppetSpecification.new(puppet_version)
+      @module_info = {}
+      @cache = options[:cache].nil? ? Cache::Base.new : options[:cache]
+    end
+
+    # Search for the specifications that match the given dependency.
+    # The specifications in the returned array will be considered in reverse
+    # order, so the latest version ought to be last.
+    # @note This method should be 'pure', i.e. the return value should depend
+    #   only on the `dependency` parameter.
+    #
+    # @param [Object] dependency
+    # @return [Array<Object>] the specifications that satisfy the given
+    #   `dependency`.
+    def search_for(dependency)
+      case dependency
+      when Models::PuppetDependency
+        result = find_puppet_specifications(dependency)
+      when Models::ModuleDependency
+        result = find_all_module_specifications(dependency).select do |spec|
+          dependency.satisified_by?(spec)
+        end
+      else
+        # No idea how we got here?!?!
+        raise ArgumentError, "Unknown Dependency type #{dependency.class}"
+      end
+
+      return result if result.empty? || result.count == 1
+      # Reverse sort by version
+      result.sort! { |a, b| a.version > b.version ? 1 : -1 }
+    end
+
+    def find_puppet_specifications(dependency)
+      # Puppet specifications are a bit special as there can be only one (Highlander style)
+      dependency.satisified_by?(@puppet_specification) ? [@puppet_specification] : []
+    end
+
+    # Returns the dependencies of `specification`.
+    # @note This method should be 'pure', i.e. the return value should depend
+    #   only on the `specification` parameter.
+    #
+    # @param [Object] specification
+    # @return [Array<Object>] the dependencies that are required by the given
+    #   `specification`.
+    def dependencies_for(specification)
+      specification.dependencies(@cache, @resolver_ui)
+    end
+
+    # Returns the name for the given `dependency`.
+    # @note This method should be 'pure', i.e. the return value should depend
+    #   only on the `dependency` parameter.
+    #
+    # @param [Object] dependency
+    # @return [String] the name for the given `dependency`.
+    def name_for(dependency)
+      dependency.name
+    end
+
+    # Determines whether the given `requirement` is satisfied by the given
+    # `spec`, in the context of the current `activated` dependency graph.
+    #
+    # @param [Object] requirement
+    # @param [DependencyGraph] activated the current dependency graph in the
+    #   resolution process.
+    # @param [Object] spec
+    # @return [Boolean] whether `requirement` is satisfied by `spec` in the
+    #   context of the current `activated` dependency graph.
+    def requirement_satisfied_by?(requirement, _activated, spec)
+      requirement.satisified_by?(spec)
+    end
+
+    def name_for_explicit_dependency_source
+      'Puppetfile'
+    end
+
+    def name_for_locking_dependency_source
+      'Puppetfile'
+    end
+
+    def sort_dependencies(dependencies, activated, conflicts) # rubocop:disable Lint/UnusedMethodArgument You're drunk rubocop
+      dependencies.sort_by do |dependency|
+        name = name_for(dependency)
+        [
+          activated.vertex_named(name).payload ? 0 : 1,
+          conflicts[name] ? 0 : 1
+        ]
+      end
+    end
+
+    # Returns whether this dependency, which has no possible matching
+    # specifications, can safely be ignored.
+    #
+    # @param [Object] dependency
+    # @return [Boolean] whether this dependency can safely be skipped.
+    def allow_missing?(dependency)
+      # Puppet dependencies must _always_ be resolvable
+      return false if dependency.is_a?(Models::PuppetDependency)
+      # Explicit Puppetfile dependencies must _always_ be resolvable
+      return false if dependency.is_a?(Models::PuppetfileDependency)
+      @allow_missing_modules
+    end
+
+    private
+
+    def find_all_module_specifications(dependency)
+      return @module_info[dependency.name] unless @module_info[dependency.name].nil?
+
+      @module_info[dependency.name] = []
+
+      # Find the module as specified in the Puppetfile?
+      mod = @puppetfile_document.modules.find { |item| item.name == dependency.name }
+      unless mod.nil?
+        case mod.module_type
+        when Puppetfile::FORGE_MODULE
+          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui) }
+        when Puppetfile::GIT_MODULE
+          @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Git.find_all(mod, dependency, @cache, @resolver_ui) }
+        else # rubocop:disable Style/EmptyElse
+          # Errr.... Nothing
+        end
+      end
+      return @module_info[dependency.name] unless @module_info[dependency.name].empty?
+
+      # It's not in the Puppetfile, so perhaps it's in our modulepath?
+      @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Local.find_all(mod, @puppet_module_paths, dependency, @cache, @resolver_ui) }
+      return @module_info[dependency.name] unless @module_info[dependency.name].empty?
+
+      # It's not in the Puppetfile and not on disk, so perhaps it's on the Forge?
+      # The forge needs an owner and name to be able to resolve
+      if dependency.name && dependency.owner # rubocop:disable Style/IfUnlessModifier
+        @module_info[dependency.name] = safe_spec_search(dependency) { SpecSearchers::Forge.find_all(dependency, @cache, @resolver_ui) }
+      end
+
+      # If we can't find any specifications for the module and we're allowing missing modules
+      # then create a MissingModuleSpecification for the purposes of the dependency graph
+      if @allow_missing_modules && @module_info[dependency.name].empty? # rubocop:disable Style/IfUnlessModifier
+        @module_info[dependency.name] << Models::MissingModuleSpecification.new(name: dependency.name)
+      end
+      @module_info[dependency.name]
+    end
+
+    def safe_spec_search(dependency)
+      results = yield
+      # The PuppetfileDependency has the resolver flags, so we need to inject them into the specifications
+      return results unless dependency.is_a?(PuppetfileResolver::Models::PuppetfileDependency) || results.empty?
+      results.each { |spec| spec.resolver_flags = dependency.puppetfile_module.resolver_flags }
+
+      results
+    rescue StandardError => e
+      if @allow_missing_modules
+        @resolver_ui.debug { "Error while querying a specification searcher #{e.inspect}" }
+        return []
+      end
+      raise
+    end
+  end
+end

data/lib/puppetfile-resolver/resolution_result.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'molinillo'
+
+module PuppetfileResolver
+  class ResolutionResult
+    attr_reader :dependency_graph
+
+    def initialize(dependency_graph, puppetfile_document)
+      raise "Expected Molinillo::DependencyGraph but got #{dependency_graph.class}" unless dependency_graph.is_a?(Molinillo::DependencyGraph)
+      @dependency_graph = dependency_graph
+      @puppetfile_document = puppetfile_document
+    end
+
+    def specifications
+      # Note - Later rubies have `.transform_values` however we support old Ruby versions
+      result = {}
+      @dependency_graph.vertices.each { |key, vertex| result[key] = vertex.payload }
+      result
+    end
+
+    def to_dot
+      @dependency_graph.to_dot
+    end
+
+    def validation_errors
+      @puppetfile_document.resolution_validation_errors(self)
+    end
+  end
+end

data/lib/puppetfile-resolver/resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'molinillo'
+require 'puppetfile-resolver/resolution_provider'
+require 'puppetfile-resolver/resolution_result'
+require 'puppetfile-resolver/models'
+
+module PuppetfileResolver
+  class Resolver
+    attr_reader :puppetfile
+    attr_reader :dependencies_to_resolve
+
+    def initialize(puppetfile_document, puppet_version = nil)
+      @puppetfile = puppetfile_document
+      raise 'Puppetfile is not valid' unless @puppetfile.valid?
+      @puppet_version = puppet_version
+
+      @dependencies_to_resolve = dependencies_from_puppetfile
+    end
+
+    # options
+    #   :cache => Cache Object
+    #   :module_paths => Array[String]
+    def resolve(options = {})
+      if options[:ui]
+        raise 'The UI object must be of type Molinillo::UI' unless options[:ui].is_a?(Molinillo::UI)
+        ui = options[:ui]
+      else
+        require 'puppetfile-resolver/ui/null_ui'
+        ui = PuppetfileResolver::UI::NullUI.new
+      end
+      provider = ResolutionProvider.new(@puppetfile, @puppet_version, ui, options)
+
+      resolver = Molinillo::Resolver.new(provider, ui)
+      begin
+        result = resolver.resolve(dependencies_to_resolve)
+      rescue Molinillo::VersionConflict => e
+        # Wrap the Molinillo error
+        new_e = PuppetfileResolver::Puppetfile::DocumentVersionConflictError.new(e)
+        raise new_e, new_e.message, e.backtrace
+      rescue Molinillo::CircularDependencyError => e
+        # Wrap the Molinillo error
+        new_e = PuppetfileResolver::Puppetfile::DocumentCircularDependencyError.new(@puppetfile, e)
+        raise new_e, new_e.message, e.backtrace
+      end
+      ResolutionResult.new(result, @puppetfile)
+    end
+
+    private
+
+    def dependencies_from_puppetfile
+      result = []
+      @puppetfile.modules.each do |mod|
+        # Use an open version unless we get a valid version number
+        if mod.version.nil? || mod.version == :latest
+          version = '>= 0' # Note the `>=` is important. Don't use `>`
+        else
+          version = "=#{mod.version}"
+        end
+
+        result << Models::PuppetfileDependency.new(
+          name: mod.title,
+          version_requirement: version,
+          puppetfile_module: mod
+        )
+      end
+      # We also depend on Puppet, so add an open ended requirement if no version
+      # was specified or add a strict version requirement
+      if @puppet_version.nil?
+        result << Models::PuppetDependency.new('>= 0')
+      else
+        result << Models::PuppetDependency.new(@puppet_version.to_s)
+      end
+      result
+    end
+  end
+end