puppetfile-resolver 0.1.0

data/lib/puppetfile-resolver/models.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/models/module_specification'
+require 'puppetfile-resolver/models/missing_module_specification'
+require 'puppetfile-resolver/models/module_dependency'
+require 'puppetfile-resolver/models/puppet_specification'
+require 'puppetfile-resolver/models/puppet_dependency'
+require 'puppetfile-resolver/models/puppetfile_dependency'

data/lib/puppetfile-resolver/models/missing_module_specification.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/models/module_specification'
+
+module PuppetfileResolver
+  module Models
+    class MissingModuleSpecification < ModuleSpecification
+      def initialize(options = {})
+        super
+        @origin = :missing
+      end
+
+      def to_s
+        "Missing #{name}"
+      end
+
+      def metadata(*_)
+        nil
+      end
+
+      def dependencies(*_)
+        # Modules that are missing can not depend on anything, even Puppet
+        []
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/models/module_dependency.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Models
+    class ModuleDependency
+      attr_accessor :name
+      attr_accessor :owner
+      attr_accessor :version_requirement
+
+      def initialize(options = {})
+        # Munge the name
+        # "puppetlabs/stdlib"
+        # "puppetlabs-stdlib"
+        # "puppetlabs-stdlib-1.0.0  ??"
+        # "stdlib"
+        @name = options[:name]
+        result = @name.split('/', 2)
+        if result.count > 1
+          @owner = result[0]
+          @name = result[1]
+        else
+          result = @name.split('-')
+          if result.count > 1
+            @owner = result[0]
+            @name = result[1]
+          else
+            @owner = options[:owner]
+          end
+        end
+
+        @version_requirement = options[:version_requirement]
+      end
+
+      def to_s
+        "#{owner}-#{name} #{version_requirement}"
+      end
+
+      def satisified_by?(spec)
+        # Missing modules are special. They should always satisfy any version range because
+        # we don't know what version missing modules are!
+        return true if spec.is_a?(MissingModuleSpecification)
+        raise "Specification #{spec} does not have a version" if spec.version.nil?
+        semantic_requirement.include?(spec.version)
+      end
+
+      private
+
+      def semantic_requirement
+        require 'semantic_puppet'
+
+        @semantic_requirement ||= ::SemanticPuppet::VersionRange.parse(@version_requirement)
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/models/module_specification.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/models/module_dependency'
+require 'puppetfile-resolver/models/puppet_dependency'
+require 'puppetfile-resolver/puppetfile'
+
+module PuppetfileResolver
+  module Models
+    class ModuleSpecification
+      attr_accessor :name
+      attr_accessor :owner
+      attr_accessor :version
+      attr_accessor :origin # Same as R10K module :type
+      attr_accessor :resolver_flags
+
+      def initialize(options = {})
+        require 'semantic_puppet'
+
+        @name = options[:name]
+        @owner = options[:owner]
+        # Munge the name
+        # "puppetlabs/stdlib"
+        # "puppetlabs-stdlib"
+        # "puppetlabs-stdlib-1.0.0  ??"
+        # "stdlib"
+        unless @name.nil?
+          result = @name.split('/', 2)
+          if result.count > 1
+            @owner = result[0]
+            @name = result[1]
+          else
+            result = @name.split('-')
+            if result.count > 1
+              @owner = result[0]
+              @name = result[1]
+            end
+          end
+        end
+        @origin = options[:origin]
+        @dependencies = nil
+        @metadata = options[:metadata]
+        @resolver_flags = options[:resolver_flags].nil? ? [] : options[:resolver_flags]
+        @version = ::SemanticPuppet::Version.parse(options[:version]) unless options[:version].nil?
+      end
+
+      def to_s
+        prefix = case @origin
+                 when :forge
+                   'Forge'
+                 when :git
+                   'Git'
+                 when :local
+                   'Local'
+                 else
+                   'Unknown'
+                 end
+        "#{prefix} #{owner}-#{name}-#{version}"
+      end
+
+      def to_json(*args)
+        {
+          'name'    => name,
+          'owner'   => owner,
+          'origin'  => origin,
+          'version' => version.to_s
+        }.to_json(args)
+      end
+
+      def from_hash!(hash)
+        @name = hash['name']
+        @owner = hash['owner']
+        @origin = hash['origin']
+        @version = ::SemanticPuppet::Version.parse(hash['version']) unless hash['version'].nil?
+        self
+      end
+
+      def metadata(_cache, _resolver_ui)
+        # TODO: Later on we could resolve the metadata lazily, but for now, no need
+        @metadata
+      end
+
+      def dependencies(cache, resolver_ui)
+        return @dependencies unless @dependencies.nil?
+
+        return (@dependencies = []) if resolver_flags.include?(PuppetfileResolver::Puppetfile::DISABLE_ALL_DEPENDENCIES_FLAG)
+
+        meta = metadata(cache, resolver_ui)
+        @dependencies = []
+        unless meta[:dependencies].nil? || meta[:dependencies].empty?
+          @dependencies = meta[:dependencies].map do |dep|
+            ModuleDependency.new(
+              name: dep[:name],
+              version_requirement: dep[:version_requirement]
+            )
+          end
+        end
+
+        unless resolver_flags.include?(PuppetfileResolver::Puppetfile::DISABLE_PUPPET_DEPENDENCY_FLAG)
+          puppet_requirement = nil
+          unless meta[:requirements].nil? || meta[:requirements].empty? # rubocop:disable Style/IfUnlessModifier
+            puppet_requirement = meta[:requirements].find { |req| req[:name] == 'puppet' && !req[:version_requirement].nil? }
+          end
+          if puppet_requirement.nil?
+            @dependencies << PuppetDependency.new('>= 0')
+          else
+            @dependencies << PuppetDependency.new(puppet_requirement[:version_requirement])
+          end
+        end
+
+        @dependencies
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/models/puppet_dependency.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Models
+    class PuppetDependency
+      attr_reader :name
+      attr_accessor :version_requirement
+
+      def initialize(version_requirement)
+        @name = 'Puppet' # This name is special as modules cannot start with an uppercase letter
+
+        @version_requirement = version_requirement
+      end
+
+      def to_s
+        "#{name} #{version_requirement}"
+      end
+
+      def satisified_by?(spec)
+        # A Puppet spec with a nil version will always be satisified by a Puppet Dependency
+        return true if spec.version.nil?
+        semantic_requirement.include?(spec.version)
+      end
+
+      private
+
+      def semantic_requirement
+        require 'semantic_puppet'
+
+        @semantic_requirement ||= ::SemanticPuppet::VersionRange.parse(@version_requirement)
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/models/puppet_specification.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Models
+    class PuppetSpecification
+      attr_reader :name
+      attr_accessor :version
+
+      def initialize(version)
+        require 'semantic_puppet'
+
+        @name = 'Puppet'
+        @version = version.nil? ? nil : ::SemanticPuppet::Version.parse(version)
+      end
+
+      def to_s
+        @version.nil? ? name.to_s : "#{name}-#{version}"
+      end
+
+      def dependencies(*_)
+        []
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/models/puppetfile_dependency.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Models
+    class PuppetfileDependency < ModuleDependency
+      attr_reader :puppetfile_module
+
+      def initialize(options = {})
+        super(options)
+        @puppetfile_module = options[:puppetfile_module]
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/puppetfile.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Puppetfile
+    # Resolver Flags
+    #
+    # DISABLE_PUPPET_DEPENDENCY_FLAG - Instructs the resolver to not consider Puppet version in its dependency traversal. Useful for modules with outdated metadata.json information.
+    # DISABLE_ALL_DEPENDENCIES_FLAG - Instructs the resolver to ignore any dependencies in its dependency traversal. Useful for modules with outdated metadata.json information.
+    #
+    DISABLE_PUPPET_DEPENDENCY_FLAG = :disable_puppet_dependency
+    DISABLE_ALL_DEPENDENCIES_FLAG = :disable_all_dependencies
+  end
+end
+
+require 'puppetfile-resolver/puppetfile/document'
+require 'puppetfile-resolver/puppetfile/validation_errors'
+require 'puppetfile-resolver/puppetfile/base_module'
+require 'puppetfile-resolver/puppetfile/forge_module'
+require 'puppetfile-resolver/puppetfile/git_module'
+require 'puppetfile-resolver/puppetfile/invalid_module'
+require 'puppetfile-resolver/puppetfile/local_module'
+require 'puppetfile-resolver/puppetfile/svn_module'

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Puppetfile
+    FORGE_MODULE   = :forge
+    GIT_MODULE     = :git
+    INVALID_MODULE = :invalid
+    LOCAL_MODULE   = :local
+    SVN_MODULE     = :svn
+
+    class BaseModule
+      # The full title of the module
+      attr_accessor :title
+
+      # The owner of the module
+      attr_accessor :owner
+
+      # The name of the module
+      attr_accessor :name
+
+      # The version of the module
+      attr_accessor :version
+
+      # The location of the module instantiation in the Puppetfile document
+      # [DocumentLocation]
+      attr_accessor :location
+
+      attr_reader :module_type
+
+      # Array of flags that will instruct the resolver to change its default behaviour. Current flags are
+      # set out in the PuppetfileResolver::Puppetfile::..._FLAG constants
+      # @api private
+      # @return [Array[Symbol]] Array of flags that will instruct the resolver to change its default behaviour
+      attr_accessor :resolver_flags
+
+      def initialize(title)
+        @title = title
+        unless title.nil? # rubocop:disable Style/IfUnlessModifier
+          @owner, @name = parse_title(@title)
+        end
+        @location = DocumentLocation.new
+        @resolver_flags = []
+      end
+
+      def to_s
+        "#{self.class} #{title}-#{name}"
+      end
+
+      private
+
+      def 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

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/puppetfile/invalid_module'
+
+module PuppetfileResolver
+  module Puppetfile
+    class DocumentLocation
+      attr_accessor :start_line # Base 0
+      attr_accessor :start_char # Base 0
+      attr_accessor :end_line # Base 0
+      attr_accessor :end_char # Base 0
+    end
+
+    class Document
+      attr_accessor :forge_uri
+      attr_reader   :modules
+      attr_accessor :content
+
+      def initialize(puppetfile_content)
+        @content = puppetfile_content
+        @modules = []
+        @validation_errors = nil
+      end
+
+      def to_s
+        "PuppetfileResolver::Puppetfile::Document\n#{@content}"
+      end
+
+      def clear_modules
+        @modules = []
+      end
+
+      def add_module(puppet_module)
+        @modules << puppet_module
+      end
+
+      def valid?
+        validation_errors.empty?
+      end
+
+      def validation_errors
+        return @validation_errors unless @validation_errors.nil?
+
+        @validation_errors = []
+
+        # Check for invalid modules
+        modules.each do |mod|
+          next unless mod.is_a?(PuppetfileResolver::Puppetfile::InvalidModule)
+          @validation_errors << DocumentInvalidModuleError.new(mod.reason, mod)
+        end
+
+        # Check for duplicate module definitions
+        dupes = modules
+                .group_by { |mod| mod.name }
+                .select { |_, v| v.size > 1 }
+                .map(&:first)
+        dupes.each do |dupe_module_name|
+          duplicates = modules.select { |mod| mod.name == dupe_module_name }
+          @validation_errors << DocumentDuplicateModuleError.new(
+            "Duplicate module definition for '#{dupe_module_name}'",
+            duplicates[0],
+            duplicates.slice(1..-1)
+          )
+        end
+
+        @validation_errors
+      end
+
+      def resolution_validation_errors(resolution_result)
+        raise 'Validation can not be performed an an invalid document' unless valid?
+        @validation_errors = []
+
+        # Find modules which said latest but resolved to a specific version
+        modules.each do |mod|
+          next unless mod.version == :latest
+          resolved_module = resolution_result.specifications[mod.name]
+          next if resolved_module.nil? || resolved_module.is_a?(PuppetfileResolver::Models::MissingModuleSpecification)
+          @validation_errors << DocumentLatestVersionError.new(
+            "Latest version of #{mod.name} is #{resolved_module.version}",
+            mod,
+            resolved_module
+          )
+        end
+
+        # Find modules which could not be found (in the forge etc.)
+        modules.each do |mod|
+          resolved_module = resolution_result.specifications[mod.name]
+          next unless resolved_module.is_a?(PuppetfileResolver::Models::MissingModuleSpecification)
+
+          @validation_errors << DocumentMissingModuleError.new(
+            "Could not find module #{mod.title}",
+            mod,
+            resolved_module
+          )
+        end
+
+        # Find modules with missing dependencies
+        puppetfile_module_names = modules.map(&:name)
+        modules.each do |mod|
+          resolved_module = resolution_result.specifications[mod.name]
+          vertex = resolution_result.dependency_graph.vertex_named(mod.name)
+          next if vertex.nil? || vertex.payload.nil?
+          missing_successors = vertex.recursive_successors.select do |successor_vertex|
+            next if successor_vertex.nil?
+            next unless successor_vertex.payload.is_a?(PuppetfileResolver::Models::ModuleSpecification)
+            !puppetfile_module_names.include?(successor_vertex.payload.name)
+          end
+
+          next if missing_successors.empty?
+          missing_specs = missing_successors.map(&:payload)
+          missing_names = missing_specs.map { |spec| "#{spec.name}-#{spec.version}" }.join(', ')
+          plural = missing_successors.count == 1 ? '' : 's'
+          @validation_errors << DocumentMissingDependenciesError.new(
+            "Module #{mod.title} is missing dependent module#{plural}: #{missing_names}",
+            mod,
+            resolved_module,
+            missing_specs
+          )
+        end
+
+        @validation_errors
+      end
+    end
+  end
+end