ra10ke 1.2.0 → 3.0.0

data/lib/ra10ke/dependencies.rb

@@ -1,37 +1,146 @@
+require 'semverse'
+require 'r10k/puppetfile'
+require 'puppet_forge'
+require 'table_print'
+require 'git'
+
 module Ra10ke::Dependencies
-  @@version_formats = {}
+  GOOD_EMOJI = ENV['GOOD_EMOJI'] || '👍'
+  BAD_EMOJI = ENV['BAD_EMOJI'] || '😨'
 
-  # Registers a block that finds the latest version.
-  # The block will be called with a list of tags.
-  # If the block returns nil the next format will be tried.
-  def self.register_version_format(name, &block)
-    @@version_formats[name] = block
-  end
+  class Verification
+    def self.version_formats
+      @version_formats ||= {}
+    end
 
-  # semver is the default version format.
-  register_version_format(:semver) do |tags|
-    latest_tag = tags.map do |tag|
-      begin
+    # Registers a block that finds the latest version.
+    # The block will be called with a list of tags.
+    # If the block returns nil the next format will be tried.
+    def self.register_version_format(name, &block)
+      version_formats[name] = block
+    end
+
+    Ra10ke::Dependencies::Verification.register_version_format(:semver) do |tags|
+      latest_tag = tags.map do |tag|
         Semverse::Version.new tag[/\Av?(.*)\Z/, 1]
       rescue Semverse::InvalidVersionFormat
         # ignore tags that do not comply to semver
         nil
+      end.select { |tag| !tag.nil? }.sort.last.to_s.downcase
+      latest_ref = tags.detect { |tag| tag[/\Av?(.*)\Z/, 1] == latest_tag }
+    end
+    attr_reader :puppetfile
+
+    def initialize(pfile)
+      @puppetfile = pfile
+      # semver is the default version format.
+
+      puppetfile.load!
+    end
+
+    def get_latest_ref(remote_refs)
+      tags = remote_refs['tags'].keys
+      latest_ref = nil
+      self.class.version_formats.detect { |_, block| latest_ref = block.call(tags) }
+      latest_ref = 'undef (tags do not follow any known pattern)' if latest_ref.nil?
+      latest_ref
+    end
+
+    def ignored_modules
+      # ignore file allows for "don't tell me about this"
+      @ignored_modules ||= begin
+        File.readlines('.r10kignore').each { |l| l.chomp! } if File.exist?('.r10kignore')
+      end || []
+    end
+
+    # @summary creates an array of module hashes with version info
+    # @param {Object} supplied_puppetfile - the parsed puppetfile object
+    # @returns {Array} array of version info for each module
+    # @note does not include ignored modules or modules up2date
+    def processed_modules(supplied_puppetfile = puppetfile)
+      threads = []
+      threads = supplied_puppetfile.modules.map do |puppet_module|
+        Thread.new do
+          next if ignored_modules.include? puppet_module.title
+
+          if puppet_module.instance_of?(::R10K::Module::Forge)
+            module_name = puppet_module.title.tr('/', '-')
+            forge_version = ::PuppetForge::Module.find(module_name).current_release.version
+            installed_version = puppet_module.expected_version
+            {
+              name: puppet_module.title,
+              installed: installed_version,
+              latest: forge_version,
+              type: 'forge',
+              message: (installed_version == forge_version) ? :current : :outdated,
+            }
+
+          elsif puppet_module.instance_of?(R10K::Module::Git)
+            # use helper; avoid `desired_ref`
+            # we do not want to deal with `:control_branch`
+            ref = puppet_module.version
+            next unless ref
+
+            remote = puppet_module.instance_variable_get(:@remote)
+            remote_refs = Git.ls_remote(remote)
+
+            # skip if ref is a branch
+            next if remote_refs['branches'].key?(ref)
+
+            if remote_refs['tags'].key?(ref)
+              # there are too many possible versioning conventions
+              # we have to be be opinionated here
+              # so semantic versioning (vX.Y.Z) it is for us
+              # as well as support for skipping the leading v letter
+              #
+              # register own version formats with
+              # Ra10ke::Dependencies.register_version_format(:name, &block)
+              latest_ref = get_latest_ref(remote_refs)
+            elsif /^[a-z0-9]{40}$/.match?(ref)
+              ref = ref.slice(0, 8)
+              # for sha just assume head should be tracked
+              latest_ref = remote_refs['head'][:sha].slice(0, 8)
+            else
+              raise "Unable to determine ref type for #{puppet_module.title}"
+            end
+            {
+              name: puppet_module.title,
+              installed: ref,
+              latest: latest_ref,
+              type: 'git',
+              message: (ref == latest_ref) ? :current : :outdated,
+            }
+
+          end
+        rescue R10K::Util::Subprocess::SubprocessError => e
+          {
+            name: puppet_module.title,
+            installed: nil,
+            latest: nil,
+            type: :error,
+            message: e.message,
+          }
+        end
       end
-    end.select { |tag| !tag.nil? }.sort.last.to_s.downcase
-    latest_ref = tags.detect { |tag| tag[/\Av?(.*)\Z/, 1] == latest_tag }
-  end
+      threads.map { |th| th.join.value }.compact
+    end
 
-  def get_latest_ref(remote_refs)
-    tags = remote_refs['tags'].keys
-    latest_ref = nil
-    @@version_formats.detect { |_, block| latest_ref = block.call(tags) }
-    latest_ref = 'undef (tags do not follow any known pattern)' if latest_ref.nil?
-    latest_ref
+    def outdated(_supplied_puppetfile = puppetfile)
+      processed_modules.find_all do |mod|
+        mod[:message] == :outdated
+      end
+    end
+
+    def print_table(mods)
+      puts
+      tp mods, { name: { width: 50 } }, :installed, :latest, :type, :message
+    end
   end
 
-  def define_task_dependencies(*_args)
-    desc "Print outdated forge modules"
-    task :dependencies do
+  def define_task_print_git_conversion(*_args)
+    desc 'Convert and print forge modules to git format'
+    task :print_git_conversion do
+      require 'ra10ke/git_repo'
       require 'r10k/puppetfile'
       require 'puppet_forge'
 
@@ -42,51 +151,48 @@ module Ra10ke::Dependencies
 
       # ignore file allows for "don't tell me about this"
       ignore_modules = []
-      if File.exist?('.r10kignore')
-        ignore_modules = File.readlines('.r10kignore').each {|l| l.chomp!}
+      ignore_modules = File.readlines('.r10kignore').each { |l| l.chomp! } if File.exist?('.r10kignore')
+      forge_mods = puppetfile.modules.find_all do |mod|
+        mod.instance_of?(R10K::Module::Forge) && mod.v3_module.homepage_url?
       end
 
-      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.gsub('/', '-')
-          forge_version = PuppetForge::Module.find(module_name).current_release.version
-          installed_version = puppet_module.expected_version
-          if installed_version != forge_version
-            puts "#{puppet_module.title} is OUTDATED: #{installed_version} vs #{forge_version}"
+      threads = forge_mods.map do |mod|
+        Thread.new do
+          source_url = mod.v3_module.attributes.dig(:current_release, :metadata, :source) || mod.v3_module.homepage_url
+          # git:// does not work with ls-remote command, convert to https
+          source_url = source_url.gsub('git://', 'https://')
+          source_url = source_url.gsub(/\Agit@(.*):(.*)/) do
+            "https://#{::Regexp.last_match(1)}/#{::Regexp.last_match(2)}"
           end
+          repo = ::Ra10ke::GitRepo.new(source_url)
+          ref = repo.get_ref_like(mod.expected_version)
+          ref_name = ref ? ref[:name] : "bad url or tag #{mod.expected_version} is missing"
+          <<~EOF
+            mod '#{mod.name}',
+              :git => '#{source_url}',
+              :ref => '#{ref_name}'
+
+          EOF
         end
+      end
+      output = threads.map { |th| th.join.value }
+      puts output
+    end
+  end
 
-        if puppet_module.class == R10K::Module::Git
-          # use helper; avoid `desired_ref`
-          # we do not want to deal with `:control_branch`
-          ref = puppet_module.version
-          next unless ref
-
-          remote = puppet_module.instance_variable_get(:@remote)
-          remote_refs = Git.ls_remote(remote)
-
-          # skip if ref is a branch
-          next if remote_refs['branches'].key?(ref)
-
-          if remote_refs['tags'].key?(ref)
-            # there are too many possible versioning conventions
-            # we have to be be opinionated here
-            # so semantic versioning (vX.Y.Z) it is for us
-            # as well as support for skipping the leading v letter
-            #
-            # register own version formats with
-            # Ra10ke::Dependencies.register_version_format(:name, &block)
-            latest_ref = get_latest_ref(remote_refs)
-          elsif ref.match(/^[a-z0-9]{40}$/)
-            # for sha just assume head should be tracked
-            latest_ref = remote_refs['head'][:sha]
-          else
-            raise "Unable to determine ref type for #{puppet_module.title}"
-          end
+  def define_task_dependencies(*_args)
+    desc 'Print outdated forge modules'
+    task :dependencies do
+      PuppetForge.user_agent = "ra10ke/#{Ra10ke::VERSION}"
+      puppetfile = get_puppetfile
+      PuppetForge.host = puppetfile.forge if /^http/.match?(puppetfile.forge)
+      dependencies = Ra10ke::Dependencies::Verification.new(puppetfile)
+      dependencies.print_table(dependencies.outdated)
 
-          puts "#{puppet_module.title} is OUTDATED: #{ref} vs #{latest_ref}" if ref != latest_ref
-        end
+      if dependencies.outdated.any?
+        abort(BAD_EMOJI + '  Not all modules in the Puppetfile are up2date. '.red + BAD_EMOJI)
+      else
+        puts(GOOD_EMOJI + '  All modules in the Puppetfile are up2date. '.green + GOOD_EMOJI)
       end
     end
   end

data/lib/ra10ke/duplicates.rb

@@ -5,7 +5,7 @@ require 'ra10ke/puppetfile_parser'
 
 module Ra10ke::Duplicates
   def define_task_duplicates(*_args)
-    desc "Check Puppetfile for duplicates"
+    desc 'Check Puppetfile for duplicates'
     task :duplicates do
       duplicates = Ra10ke::Duplicates::Verification.new(get_puppetfile.puppetfile_path).duplicates
       exit_code = 0

data/lib/ra10ke/git_repo.rb

@@ -82,20 +82,31 @@ module Ra10ke
     #     :sha=>"fcc0532bbc5a5b65f3941738339e9cc7e3d767ce", :ref=>"refs/pull/249/head", :type=>:pull, :subtype=>:head, :name=>"249"},
     #     :sha=>"8d54891fa5df75890ee15d53080c2a81b4960f92", :ref=>"refs/pull/267/head", :type=>:pull, :subtype=>:head, :name=>"267"}]
     def all_refs
-      @all_refs ||= begin
-        remote_refs.each_with_object([]) do |line, refs|
-          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: sha, ref: ref.chomp, type: type, subtype: subtype, name: name }
-        end
+      @all_refs ||= remote_refs.each_with_object([]) do |line, refs|
+        sha, ref = line.split("\t")
+        next refs if line.include?('redirecting')
+        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: sha, ref: ref.chomp, type: type, subtype: subtype, name: name }
+      end
+    end
+
+    # @summary searches all the refs for a ref similar to the name provided
+    #          This is useful when looking for tags if a v or not a v
+    # @param ref_name [String]
+    # @return [String] the matching ref_name or nil
+    def get_ref_like(ref_name)
+      return nil unless valid_url?
+
+      all_refs.find do |ref|
+        ref[:name].include?(ref_name)
       end
     end
 

data/lib/ra10ke/install.rb

@@ -1,27 +1,27 @@
 module Ra10ke::Install
   def define_task_install(*_args)
-    desc "Install modules specified in Puppetfile"
+    desc 'Install modules specified in Puppetfile'
     task :install do
       require 'r10k/puppetfile'
 
       puppetfile = get_puppetfile
       puppetfile.load!
 
-      puts "Processing Puppetfile for fixtures"
+      puts 'Processing Puppetfile for fixtures'
       puppetfile.modules.each do |mod|
         if mod.status == :insync
           puts "Skipping #{mod.name} (#{mod.version}) already in sync"
         else
-          if mod.status == :absent
-            msg = "installed #{mod.name}"
-          else
-            msg = "updated #{mod.name} from #{mod.version} to"
-          end
+          msg = if mod.status == :absent
+                  "installed #{mod.name}"
+                else
+                  "updated #{mod.name} from #{mod.version} to"
+                end
           mod.sync
-          if mod.status != :insync
-            puts "Failed to sync #{mod.name}".red
-          else
+          if mod.status == :insync
             puts "Successfully #{msg} #{mod.version}".green
+          else
+            puts "Failed to sync #{mod.name}".red
           end
         end
       end

data/lib/ra10ke/monkey_patches.rb

@@ -18,7 +18,7 @@ class String
     colorize(33)
   end
 
-  # removes specified markes from string. 
+  # removes specified markes from string.
   # @return [String] - the string with markers removed
   def strip_comment(markers = ['#', "\n"])
     re = Regexp.union(markers)

data/lib/ra10ke/puppetfile_parser.rb

@@ -1,90 +1,90 @@
-# it might be desirable to parse the Puppetfile as a string instead of evaling it. 
+# it might be desirable to parse the Puppetfile as a string instead of evaling it.
 # this module allows you to do just that.
 require 'ra10ke/monkey_patches'
 
 module Ra10ke
-    module PuppetfileParser
-
-      # @return [Array] - returns a array of hashes that contain modules with a git source
-      def git_modules(file = puppetfile)
-        modules(file).find_all do |mod|
-          mod[:args].key?(:git)
-        end
+  module PuppetfileParser
+    # @return [Array] - returns a array of hashes that contain modules with a git source
+    def git_modules(file = puppetfile)
+      modules(file).find_all do |mod|
+        mod[:args].key?(:git)
       end
+    end
 
-      # @return [Array] - returns a array of hashes that contain modules from the Forge
-      def forge_modules(file = puppetfile)
-        modules(file).reject do |mod|
-          mod[:args].key?(:git)
-        end
+    # @return [Array] - returns a array of hashes that contain modules from the Forge
+    def forge_modules(file = puppetfile)
+      modules(file).reject do |mod|
+        mod[:args].key?(:git)
       end
+    end
 
-      # @param puppetfile [String] - the absolute path to the puppetfile
-      # @return [Array] - returns an array of module hashes that represent the puppetfile
-      # @example
-      # [{:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]},
-      # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}]
-      def modules(puppetfile)
-        @modules ||= begin
-          return [] unless File.exist?(puppetfile)
+    # @param puppetfile [String] - the absolute path to the puppetfile
+    # @return [Array] - returns an array of module hashes that represent the puppetfile
+    # @example
+    # [{:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]},
+    # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}]
+    def modules(puppetfile)
+      @modules ||= begin
+        return [] unless File.exist?(puppetfile)
 
-          all_lines = File.read(puppetfile).lines.map(&:strip_comment)
-          # remove comments from all the lines
-          lines_without_comments = all_lines.reject { |line| line.match(/#.*\n/) }.join("\n")
-          lines_without_comments.split(/^mod/).map do |line|
-            next nil if line =~ /^forge/
-            next nil if line.empty?
+        all_lines = File.read(puppetfile).lines.map(&:strip_comment)
+        # remove comments from all the lines
+        lines_without_comments = all_lines.reject { |line| line.match(/#.*\n/) || line.empty? }.join("\n")
+        lines_without_comments.split(/^mod/).map do |line|
+          next nil if /^forge/.match?(line)
+          next nil if line.empty?
 
-            parse_module_args(line)
-          end.compact.uniq
-        end
+          parse_module_args(line)
+        end.compact.uniq
       end
+    end
 
-      # @param data [String] - the string to parse the puppetfile args out of
-      # @return [Array] -  an array of arguments in hash form
-      # @example
-      # {:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]}
-      # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}
-      def parse_module_args(data)
-        return {} if data.empty?
-        args = data.split(',').map(&:strip)
-        # we can't guarantee that there will be a namespace when git is used
-        # remove quotes and dash and slash
-        namespace, name = args.shift.gsub(/'|"/, '').split(%r{-|/})
-        name ||= namespace
-        namespace = nil if namespace == name
-        {
-          namespace: namespace,
-          name: name,
-          args: process_args(args)
-        }
-      end
+    # @param data [String] - the string to parse the puppetfile args out of
+    # @return [Array] -  an array of arguments in hash form
+    # @example
+    # {:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]}
+    # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}
+    def parse_module_args(data)
+      return {} if data.empty?
+
+      args = data.split(',').map(&:strip)
+      # we can't guarantee that there will be a namespace when git is used
+      # remove quotes and dash and slash
+      namespace, name = args.shift.gsub(/'|"/, '').split(%r{-|/})
+      name ||= namespace
+      namespace = nil if namespace == name
+      {
+        namespace: namespace,
+        name: name,
+        args: process_args(args),
+      }
+    end
 
-      # @return [Array] - returns an array of hashes with the args in key value pairs
-      # @param [Array] - the arguments processed from each entry in the puppetfile
-      # @example
-      # [{:args=>[], :name=>"razor", :namespace=>"puppetlabs"},
-      #  {:args=>[{:version=>"0.0.3"}], :name=>"ntp", :namespace=>"puppetlabs"},
-      #  {:args=>[], :name=>"inifile", :namespace=>"puppetlabs"},
-      #  {:args=>
-      #    [{:git=>"https://github.com/nwops/reportslack.git"}, {:ref=>"1.0.20"}],
-      #   :name=>"reportslack",
-      #   :namespace=>"nwops"},
-      #  {:args=>{:git=>"git://github.com/puppetlabs/puppetlabs-apt.git"},
-      #   :name=>"apt",
-      #   :namespace=>nil}
-      # ]
-      def process_args(args)
-        results = {}
-        args.each do |arg|
-          a = arg.gsub(/'|"/, '').split(/\A\:|\:\s|\=\>/).map(&:strip).reject(&:empty?)
-          if a.count < 2
-            results[:version] = a.first
-          else
-            results[a.first.to_sym] = a.last
-          end
+    # @return [Array] - returns an array of hashes with the args in key value pairs
+    # @param [Array] - the arguments processed from each entry in the puppetfile
+    # @example
+    # [{:args=>[], :name=>"razor", :namespace=>"puppetlabs"},
+    #  {:args=>[{:version=>"0.0.3"}], :name=>"ntp", :namespace=>"puppetlabs"},
+    #  {:args=>[], :name=>"inifile", :namespace=>"puppetlabs"},
+    #  {:args=>
+    #    [{:git=>"https://github.com/nwops/reportslack.git"}, {:ref=>"1.0.20"}],
+    #   :name=>"reportslack",
+    #   :namespace=>"nwops"},
+    #  {:args=>{:git=>"git://github.com/puppetlabs/puppetlabs-apt.git"},
+    #   :name=>"apt",
+    #   :namespace=>nil}
+    # ]
+    def process_args(args)
+      results = {}
+      args.each do |arg|
+        a = arg.gsub(/'|"/, '').split(/\A:|:\s|=>/).map(&:strip).reject(&:empty?)
+        if a.count < 2
+          results[:version] = a.first
+        else
+          results[a.first.to_sym] = a.last
         end
-        results
       end
+      results
     end
+  end
 end

data/lib/ra10ke/solve.rb

@@ -6,6 +6,7 @@ require 'set'
 require 'solve'
 require 'yaml/store'
 require 'semverse/version'
+require 'fileutils'
 
 # How many versions to fetch from the Forge, at most
 FETCH_LIMIT = 3
@@ -26,15 +27,16 @@ module Ra10ke::Solve
       PuppetForge.user_agent = "ra10ke/#{Ra10ke::VERSION}"
       puppetfile = get_puppetfile
       puppetfile.load!
-      PuppetForge.host = puppetfile.forge if puppetfile.forge =~ /^http/
+      PuppetForge.host = puppetfile.forge if /^http/.match?(puppetfile.forge)
 
       # ignore file allows for "don't tell me about this"
       ignore_modules = []
-      if File.exist?('.r10kignore')
-        ignore_modules = File.readlines('.r10kignore').each(&:chomp!)
-      end
+      ignore_modules = File.readlines('.r10kignore').each(&:chomp!) if File.exist?('.r10kignore')
       # Actual new logic begins here:
       cache = (ENV['XDG_CACHE_DIR'] || File.expand_path('~/.cache'))
+
+      FileUtils.mkdir_p(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
@@ -50,7 +52,8 @@ module Ra10ke::Solve
 
       puppetfile.modules.each do |puppet_module|
         next if ignore_modules.include? puppet_module.title
-        if puppet_module.class == R10K::Module::Forge
+
+        if puppet_module.instance_of?(R10K::Module::Forge)
           module_name = puppet_module.title.tr('/', '-')
           installed_version = puppet_module.expected_version
           puts "Processing Forge module #{module_name}-#{installed_version}"
@@ -77,7 +80,8 @@ module Ra10ke::Solve
           add_reqs_to_graph(mod, meta)
         end
 
-        next unless puppet_module.class == R10K::Module::Git
+        next unless puppet_module.instance_of?(R10K::Module::Git)
+
         # This downloads the git module to modules/modulename
         meta = fetch_git_metadata(puppet_module)
         version = get_key_or_sym(meta, :version)
@@ -93,9 +97,7 @@ module Ra10ke::Solve
       end
       puts
       puts 'Resolving dependencies...'
-      if allow_major_bump
-        puts 'WARNING:  Potentially breaking updates are allowed for this resolution'
-      end
+      puts 'WARNING:  Potentially breaking updates are allowed for this resolution' if allow_major_bump
       result = Solve.it!(@graph, @demands, sorted: true)
       puts
       print_module_diff(@current_modules, result)
@@ -126,7 +128,7 @@ module Ra10ke::Solve
       return {
         version: '0.0.0',
         name: puppet_module.title,
-        dependencies: []
+        dependencies: [],
       }
     end
     metadata = R10K::Module::MetadataFile.new(metadata_path)
@@ -134,7 +136,7 @@ module Ra10ke::Solve
     {
       version: metadata.version,
       name: metadata.name,
-      dependencies: metadata.dependencies
+      dependencies: metadata.dependencies,
     }
   end
 
@@ -146,7 +148,7 @@ module Ra10ke::Solve
   # 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 ||= get_key_or_sym(dep, :version_range)
     req
   end
 
@@ -182,17 +184,14 @@ module Ra10ke::Solve
       # 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|
+      ver ||= '>=0.0.0'
+      ver.split(/(?=<)/).each do |bound|
         bound.strip!
         v = begin
-              Semverse::Constraint.new(bound)
-            rescue
-              nil
-            end
+          Semverse::Constraint.new(bound)
+        rescue StandardError
+          nil
+        end
         if v
           artifact.depends(name, v.to_s)
         else
@@ -202,14 +201,16 @@ module Ra10ke::Solve
       # 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
+        PuppetForge::Module.find(name)
+      rescue StandardError
+        # 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)