ra10ke 0.5.0 → 0.6.0

data/lib/ra10ke/solve.rb

@@ -11,218 +11,214 @@ require 'semverse/version'
 FETCH_LIMIT = 3
 
 module Ra10ke::Solve
-  class RakeTask < ::Rake::TaskLib
-    def initialize(*_args)
-      namespace :r10k do
-        desc 'Find missing or outdated module dependencies'
-        task :solve_dependencies, [:allow_major_bump] do |_t, args|
-          require 'r10k/puppetfile'
-          require 'r10k/module/git'
-          require 'r10k/module/metadata_file'
-          require 'puppet_forge'
+  def define_task_solve_dependencies(*_args)
+    desc 'Find missing or outdated module dependencies'
+    task :solve_dependencies, [:allow_major_bump] do |_t, args|
+      require 'r10k/puppetfile'
+      require 'r10k/module/git'
+      require 'r10k/module/metadata_file'
+      require 'puppet_forge'
 
-          allow_major_bump = false
-          allow_major_bump = true if args[:allow_major_bump]
+      allow_major_bump = false
+      allow_major_bump = true if args[:allow_major_bump]
 
-          # Same as in the dependencies task, but oh well.
-          PuppetForge.user_agent = "ra10ke/#{Ra10ke::VERSION}"
-          puppetfile = R10K::Puppetfile.new(Dir.pwd)
-          puppetfile.load!
-          PuppetForge.host = puppetfile.forge if puppetfile.forge =~ /^http/
+      # Same as in the dependencies task, but oh well.
+      PuppetForge.user_agent = "ra10ke/#{Ra10ke::VERSION}"
+      puppetfile = get_puppetfile
+      puppetfile.load!
+      PuppetForge.host = puppetfile.forge if puppetfile.forge =~ /^http/
 
-          # ignore file allows for "don't tell me about this"
-          ignore_modules = []
-          if File.exist?('.r10kignore')
-            ignore_modules = File.readlines('.r10kignore').each(&:chomp!)
-          end
-          # Actual new logic begins here:
-          cache = (ENV['XDG_CACHE_DIR'] || File.expand_path('~/.cache'))
-          # Metadata cache, since the Forge is slow:
-          @metadata_cache = YAML::Store.new File.join(cache, 'ra10ke.metadata_cache')
-          # The graph of available module versions
-          @graph = Solve::Graph.new
-          # Set of modules that we have already added to the graph
-          @processed_modules = Set.new
-          # The set of "demands" we make of the solver. Will be a list of module names
-          # Could also demand certain version constraints to hold, but the code does not do it
-          # Can be either "module-name" or ["module-name", "version-constraint"]
-          @demands = Set.new
-          # List of modules we have in the Puppetfile, as [name, version] pairs
-          @current_modules = []
-
-          puppetfile.modules.each do |puppet_module|
-            next if ignore_modules.include? puppet_module.title
-            if puppet_module.class == R10K::Module::Forge
-              module_name = puppet_module.title.tr('/', '-')
-              installed_version = puppet_module.expected_version
-              puts "Processing Forge module #{module_name}-#{installed_version}"
-              @current_modules << [module_name, installed_version]
-              @graph.artifact(module_name, installed_version)
-              constraint = '>=0.0.0'
-              unless allow_major_bump
-                ver = Semverse::Version.new installed_version
-                if ver.major.zero?
-                  constraint = "~>#{installed_version}"
-                else
-                  nver = Semverse::Version.new([ver.major + 1, 0, 0])
-                  constraint = "<#{nver}"
-                end
-              end
-              puts "...Adding a demand: #{module_name} #{constraint}"
+      # ignore file allows for "don't tell me about this"
+      ignore_modules = []
+      if File.exist?('.r10kignore')
+        ignore_modules = File.readlines('.r10kignore').each(&:chomp!)
+      end
+      # Actual new logic begins here:
+      cache = (ENV['XDG_CACHE_DIR'] || File.expand_path('~/.cache'))
+      # Metadata cache, since the Forge is slow:
+      @metadata_cache = YAML::Store.new File.join(cache, 'ra10ke.metadata_cache')
+      # The graph of available module versions
+      @graph = Solve::Graph.new
+      # Set of modules that we have already added to the graph
+      @processed_modules = Set.new
+      # The set of "demands" we make of the solver. Will be a list of module names
+      # Could also demand certain version constraints to hold, but the code does not do it
+      # Can be either "module-name" or ["module-name", "version-constraint"]
+      @demands = Set.new
+      # List of modules we have in the Puppetfile, as [name, version] pairs
+      @current_modules = []
 
-              @demands.add([module_name, constraint])
-              puts '...Fetching latest release version information'
-              forge_rel = PuppetForge::Module.find(module_name).current_release
-              mod = @graph.artifact(module_name, forge_rel.version)
-              puts '...Adding its requirements to the graph'
-              meta = get_release_metadata(module_name, forge_rel)
-              add_reqs_to_graph(mod, meta)
+      puppetfile.modules.each do |puppet_module|
+        next if ignore_modules.include? puppet_module.title
+        if puppet_module.class == R10K::Module::Forge
+          module_name = puppet_module.title.tr('/', '-')
+          installed_version = puppet_module.expected_version
+          puts "Processing Forge module #{module_name}-#{installed_version}"
+          @current_modules << [module_name, installed_version]
+          @graph.artifact(module_name, installed_version)
+          constraint = '>=0.0.0'
+          unless allow_major_bump
+            ver = Semverse::Version.new installed_version
+            if ver.major.zero?
+              constraint = "~>#{installed_version}"
+            else
+              nver = Semverse::Version.new([ver.major + 1, 0, 0])
+              constraint = "<#{nver}"
             end
-
-            next unless puppet_module.class == R10K::Module::Git
-            # This downloads the git module to modules/modulename
-            meta = fetch_git_metadata(puppet_module)
-            version = get_key_or_sym(meta, :version)
-            module_name = puppet_module.title.tr('/', '-')
-            @current_modules << [module_name, version]
-            # We should add git modules with exact versions, or the system might recommend updating to a
-            # Forge version.
-            puts "Adding git module #{module_name} to the list of required modules with exact version: #{version}"
-            @demands.add([module_name, version])
-            mod = @graph.artifact(module_name, version)
-            puts "...Adding requirements for git module #{module_name}-#{version}"
-            add_reqs_to_graph(mod, meta)
           end
-          puts
-          puts 'Resolving dependencies...'
-          if allow_major_bump
-            puts 'WARNING:  Potentially breaking updates are allowed for this resolution'
-          end
-          result = Solve.it!(@graph, @demands, sorted: true)
-          puts
-          print_module_diff(@current_modules, result)
+          puts "...Adding a demand: #{module_name} #{constraint}"
+
+          @demands.add([module_name, constraint])
+          puts '...Fetching latest release version information'
+          forge_rel = PuppetForge::Module.find(module_name).current_release
+          mod = @graph.artifact(module_name, forge_rel.version)
+          puts '...Adding its requirements to the graph'
+          meta = get_release_metadata(module_name, forge_rel)
+          add_reqs_to_graph(mod, meta)
         end
+
+        next unless puppet_module.class == R10K::Module::Git
+        # This downloads the git module to modules/modulename
+        meta = fetch_git_metadata(puppet_module)
+        version = get_key_or_sym(meta, :version)
+        module_name = puppet_module.title.tr('/', '-')
+        @current_modules << [module_name, version]
+        # We should add git modules with exact versions, or the system might recommend updating to a
+        # Forge version.
+        puts "Adding git module #{module_name} to the list of required modules with exact version: #{version}"
+        @demands.add([module_name, version])
+        mod = @graph.artifact(module_name, version)
+        puts "...Adding requirements for git module #{module_name}-#{version}"
+        add_reqs_to_graph(mod, meta)
+      end
+      puts
+      puts 'Resolving dependencies...'
+      if allow_major_bump
+        puts 'WARNING:  Potentially breaking updates are allowed for this resolution'
       end
+      result = Solve.it!(@graph, @demands, sorted: true)
+      puts
+      print_module_diff(@current_modules, result)
     end
+  end
 
-    def get_release_metadata(name, release)
-      meta = nil
-      @metadata_cache.transaction do
-        meta = @metadata_cache["#{name}-#{release.version}"]
-        unless meta
-          meta = release.metadata
-          @metadata_cache["#{name}-#{release.version}"] = meta
-        end
+  private
+
+  def get_release_metadata(name, release)
+    meta = nil
+    @metadata_cache.transaction do
+      meta = @metadata_cache["#{name}-#{release.version}"]
+      unless meta
+        meta = release.metadata
+        @metadata_cache["#{name}-#{release.version}"] = meta
       end
-      meta
     end
+    meta
+  end
 
-    def fetch_git_metadata(puppet_module)
-      # No caching here. I don't think it's really possible to do in a sane way.
-      puts "Fetching git module #{puppet_module.title}, saving to modules/"
-      puppet_module.sync
-      metadata_path = Pathname.new(puppet_module.full_path) + 'metadata.json'
-      unless metadata_path.exist?
-        puts 'WARNING: metadata.json does not exist, assuming version 0.0.0 and no dependencies'
-        return {
-          version: '0.0.0',
-          name: puppet_module.title,
-          dependencies: []
-        }
-      end
-      metadata = R10K::Module::MetadataFile.new(metadata_path)
-      metadata = metadata.read
-      {
-        version: metadata.version,
-        name: metadata.name,
-        dependencies: metadata.dependencies
+  def fetch_git_metadata(puppet_module)
+    # No caching here. I don't think it's really possible to do in a sane way.
+    puts "Fetching git module #{puppet_module.title}, saving to modules/"
+    puppet_module.sync
+    metadata_path = Pathname.new(puppet_module.full_path) + 'metadata.json'
+    unless metadata_path.exist?
+      puts 'WARNING: metadata.json does not exist, assuming version 0.0.0 and no dependencies'
+      return {
+        version: '0.0.0',
+        name: puppet_module.title,
+        dependencies: []
       }
     end
+    metadata = R10K::Module::MetadataFile.new(metadata_path)
+    metadata = metadata.read
+    {
+      version: metadata.version,
+      name: metadata.name,
+      dependencies: metadata.dependencies
+    }
+  end
 
-    # Is there a better way? :(
-    def get_key_or_sym(hash, k)
-      hash.fetch(k.to_sym, hash.fetch(k.to_s, nil))
-    end
+  # Is there a better way? :(
+  def get_key_or_sym(hash, k)
+    hash.fetch(k.to_sym, hash.fetch(k.to_s, nil))
+  end
 
-    # At least puppet-extlib has malformed metadata
-    def get_version_req(dep)
-      req = get_key_or_sym(dep, :version_requirement)
-      req = get_key_or_sym(dep, :version_range) unless req
-      req
-    end
+  # At least puppet-extlib has malformed metadata
+  def get_version_req(dep)
+    req = get_key_or_sym(dep, :version_requirement)
+    req = get_key_or_sym(dep, :version_range) unless req
+    req
+  end
 
-    def print_module_diff(current, resolution)
-      current.sort!
-      resolution.sort!
-      outdated = []
-      missing = []
-      resolution.each do |mod|
-        cur_mod, cur_version = current.shift
-        mod, version = mod
-        if (cur_mod == mod) && cur_version && (cur_version != version)
-          outdated << [mod, cur_version, version]
-        elsif cur_mod != mod
-          missing << [mod, version]
-          current.unshift [cur_mod, cur_version]
-        end
-      end
-      missing.each do |m|
-        puts format('MISSING:  %-25s %s', *m)
-      end
-      outdated.each do |o|
-        puts format('OUTDATED: %-25s %s -> %s', *o)
+  def print_module_diff(current, resolution)
+    current.sort!
+    resolution.sort!
+    outdated = []
+    missing = []
+    resolution.each do |mod|
+      cur_mod, cur_version = current.shift
+      mod, version = mod
+      if (cur_mod == mod) && cur_version && (cur_version != version)
+        outdated << [mod, cur_version, version]
+      elsif cur_mod != mod
+        missing << [mod, version]
+        current.unshift [cur_mod, cur_version]
       end
     end
+    missing.each do |m|
+      puts format('MISSING:  %-25s %s', *m)
+    end
+    outdated.each do |o|
+      puts format('OUTDATED: %-25s %s -> %s', *o)
+    end
+  end
 
-    def add_reqs_to_graph(artifact, metadata, no_demands = nil)
-      deps = get_key_or_sym(metadata, :dependencies)
-      my_name = get_key_or_sym(metadata, :name)
-      deps.each do |dep|
-        name = get_key_or_sym(dep, :name).tr('/', '-')
-        # Add dependency to the global set of modules we want, so that we can
-        # actually ask the solver for the versioned thing
-        @demands.add(name) unless no_demands
-        ver = get_version_req(dep)
-        unless ver
-          # no version specified, so anything will do
-          ver = '>=0.0.0'
-        end
-        ver.split(/(?=[<])/).each do |bound|
-          bound.strip!
-          v = begin
-                Semverse::Constraint.new(bound)
-              rescue
-                nil
-              end
-          if v
-            artifact.depends(name, v.to_s)
-          else
-            puts "WARNING: Invalid version constraint: #{bound}"
-          end
-        end
-        # Find the dependency in the forge, unless it's already been processed
-        # and add its releases to the global graph
-        next unless @processed_modules.add?(name)
-        puts "Fetching module info for #{name}"
-        mod = begin
-                PuppetForge::Module.find(name)
-              rescue
-                # It's probably a git module
-                nil
-              end
-        next unless mod # Git module, or non-forge dependency. Skip to next for now.
-        # Fetching metadata for all releases takes ages (which is weird, since it's mostly static info)
-        mod.releases.take(FETCH_LIMIT).each do |rel|
-          meta = get_release_metadata(name, rel)
-          rel_artifact = @graph.artifact(name, rel.version)
-          puts "...Recursively adding requirements for dependency #{name} version #{rel.version}"
-          # We don't want to add the requirements to the list of demands for all versions,
-          # but we need them in the graph to be able to solve dependencies
-          add_reqs_to_graph(rel_artifact, meta, :no_demands)
+  def add_reqs_to_graph(artifact, metadata, no_demands = nil)
+    deps = get_key_or_sym(metadata, :dependencies)
+    my_name = get_key_or_sym(metadata, :name)
+    deps.each do |dep|
+      name = get_key_or_sym(dep, :name).tr('/', '-')
+      # Add dependency to the global set of modules we want, so that we can
+      # actually ask the solver for the versioned thing
+      @demands.add(name) unless no_demands
+      ver = get_version_req(dep)
+      unless ver
+        # no version specified, so anything will do
+        ver = '>=0.0.0'
+      end
+      ver.split(/(?=[<])/).each do |bound|
+        bound.strip!
+        v = begin
+              Semverse::Constraint.new(bound)
+            rescue
+              nil
+            end
+        if v
+          artifact.depends(name, v.to_s)
+        else
+          puts "WARNING: Invalid version constraint: #{bound}"
         end
       end
+      # Find the dependency in the forge, unless it's already been processed
+      # and add its releases to the global graph
+      next unless @processed_modules.add?(name)
+      puts "Fetching module info for #{name}"
+      mod = begin
+              PuppetForge::Module.find(name)
+            rescue
+              # It's probably a git module
+              nil
+            end
+      next unless mod # Git module, or non-forge dependency. Skip to next for now.
+      # Fetching metadata for all releases takes ages (which is weird, since it's mostly static info)
+      mod.releases.take(FETCH_LIMIT).each do |rel|
+        meta = get_release_metadata(name, rel)
+        rel_artifact = @graph.artifact(name, rel.version)
+        puts "...Recursively adding requirements for dependency #{name} version #{rel.version}"
+        # We don't want to add the requirements to the list of demands for all versions,
+        # but we need them in the graph to be able to solve dependencies
+        add_reqs_to_graph(rel_artifact, meta, :no_demands)
+      end
     end
   end
 end
-
-Ra10ke::Solve::RakeTask.new

data/lib/ra10ke/syntax.rb

@@ -0,0 +1,18 @@
+module Ra10ke::Syntax
+  def define_task_syntax(*_args)
+    desc "Syntax check Puppetfile"
+    task :syntax do
+      require 'r10k/action/puppetfile/check'
+
+      puppetfile = R10K::Action::Puppetfile::Check.new({
+        :root => @basedir,
+        :moduledir => @moduledir,
+        :puppetfile => @puppetfile_path
+      }, '')
+
+      unless puppetfile.call
+        abort("Puppetfile syntax check failed")
+      end
+    end
+  end
+end

data/lib/ra10ke/validate.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'ra10ke/monkey_patches'
+require 'tempfile'
+require 'table_print'
+require 'ra10ke/puppetfile_parser'
+require 'English'
+
+module Ra10ke
+  module Validate
+
+    GOOD_EMOJI = ENV['GOOD_EMOJI'] || '👍'
+    BAD_EMOJI = ENV['BAD_EMOJI'] || '😨'
+
+    # Validate the git urls and refs
+    def define_task_validate(*args)
+      desc 'Validate the git urls and branches, refs, or tags'
+      task :validate do
+        gitvalididation = Ra10ke::Validate::Validation.new(get_puppetfile.puppetfile_path)
+        exit_code = 0
+        if gitvalididation.bad_mods?
+          exit_code = 1
+          message = BAD_EMOJI + '  Not all modules in the Puppetfile are valid. '.red + BAD_EMOJI
+        else
+          message = GOOD_EMOJI + '  Puppetfile looks good. '.green + GOOD_EMOJI
+        end
+        tp gitvalididation.sorted_mods, :name, { url: { width: 50 } }, :ref, :status
+        abort(message) if exit_code.positive?
+        puts message
+      end
+    end
+
+    class Validation
+      include Ra10ke::PuppetfileParser
+      
+      attr_reader :puppetfile
+
+      def initialize(file)
+        file ||= './Puppetfile'
+        @puppetfile = File.expand_path(file)
+        abort("Puppetfile does not exist at #{puppetfile}") unless File.readable?(puppetfile)
+      end
+
+      # @return [Boolean] - return true if the ref is valid
+      # @param url [String] - the git string either https or ssh url
+      # @param ref [String] - the ref object, branch name, tag name, or commit sha, defaults to HEAD
+      def valid_ref?(url, ref = 'HEAD')
+        raise ArgumentError unless ref
+        found = all_refs(url).find do |sha, data | 
+          # we don't need to bother with these types
+          next if data[:type] == :pull || data[:type] == :merge_request     
+          # is the name equal to the tag or branch?  Is the commit sha equal?     
+          data[:name].eql?(ref) || sha.slice(0,8).eql?(ref.slice(0,8))
+        end
+        !found.nil?
+      end
+
+      # @return [Hash] - a hash of all the refs associated with the remote repository
+      # @param url [String] - the git string either https or ssh url
+      # @example
+      # {"0ec707e431367bbe2752966be8ab915b6f0da754"=>{:ref=>"refs/heads/74110ac", :type=>:branch, :subtype=>nil, :name=>"74110ac"},
+        # "07bb5d2d94db222dca5860eb29c184e8970f36f4"=>{:ref=>"refs/pull/74/head", :type=>:pull, :subtype=>:head, :name=>"74"},
+        # "156ca9a8ea69e056e86355b27d944e59d1b3a1e1"=>{:ref=>"refs/heads/master", :type=>:branch, :subtype=>nil, :name=>"master"},
+        # "fcc0532bbc5a5b65f3941738339e9cc7e3d767ce"=>{:ref=>"refs/pull/249/head", :type=>:pull, :subtype=>:head, :name=>"249"},
+        # "8d54891fa5df75890ee15d53080c2a81b4960f92"=>{:ref=>"refs/pull/267/head", :type=>:pull, :subtype=>:head, :name=>"267"} }
+      def all_refs(url)
+        data = `git ls-remote --symref #{url}`
+        raise "Error downloading #{url}" unless $CHILD_STATUS.success?
+        data.lines.reduce({}) do |refs, line|
+          sha, ref = line.split("\t")
+          next refs if sha.eql?('ref: refs/heads/master')
+          _, type, name, subtype = ref.chomp.split('/')
+          next refs unless name 
+          type = :tag if type.eql?('tags')
+          type = type.to_sym
+          subtype = subtype.to_sym if subtype
+          type = :branch if type.eql?(:heads)
+          refs[sha] = {ref: ref.chomp, type: type, subtype: subtype, name: name }
+          refs
+        end
+      end
+
+      # @return [Boolean] - return true if the commit sha is valid
+      # @param url [String] - the git string either https or ssh url
+      # @param ref [String] - the sha id
+      def valid_commit?(url, sha)
+        return false if sha.nil? || sha.empty?
+        return true if valid_ref?(url, sha)
+        Dir.mktmpdir do |dir|
+          `git clone --no-tags #{url} #{dir} 2>&1 > /dev/null`
+          Dir.chdir(dir) do
+            `git show #{sha} 2>&1 > /dev/null`
+            $CHILD_STATUS.success?
+          end
+        end
+      end
+
+      # @return [Array[Hash]] array of module information and git status
+      def all_modules
+        begin
+          git_modules(puppetfile).map do |mod|
+            ref = mod[:args][:ref] || mod[:args][:tag] || mod[:args][:branch]
+            valid_ref = valid_ref?(mod[:args][:git], ref) || valid_commit?(mod[:args][:git], mod[:args][:ref])
+            {
+              name: mod[:name],
+              url: mod[:args][:git],
+              ref: ref,
+              valid_ref?: valid_ref,
+              status: valid_ref ? Ra10ke::Validate::GOOD_EMOJI : Ra10ke::Validate::BAD_EMOJI
+            }
+          end
+        end
+      end
+
+      # @return [Boolean] - true if there are any bad mods
+      def bad_mods?
+        all_modules.find_all { |mod| !mod[:valid_ref?] }.count > 0
+      end
+
+      # @return [Hash] - sorts the mods based on good/bad
+      def sorted_mods
+        all_modules.sort_by { |a| a[:valid_ref?] ? 1 : 0 }
+      end
+    end
+  end
+end

data/lib/ra10ke/version.rb

@@ -1,3 +1,3 @@
 module Ra10ke
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end