vanagon 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02183e0db1fb5c4fa7a207d9a24c9c3f2e9c95c6
-  data.tar.gz: 948b629fcfbf13083f409eacc6681fe7004eee29
+  metadata.gz: 9b41f01dda75f8d40767ea3c7e290cf11462ff94
+  data.tar.gz: 7c9b7ce98ff34e60371dbf087366cb0fd488c53d
 SHA512:
-  metadata.gz: e283e4e4ae27a37619e59aa43c50037e2daae3263143e740885c247e10cb8fae7452f57132edb21b6fc718cc0172ceb02c718807767079618e343205afbdb208
-  data.tar.gz: dd1da7f1081686fd628e518c258189239335c78f86cf8daf7ac50ad4e944135e6661f4faa61296435cc5efcc39b1625e3d8ce4223b2ea4811569779fadcf499a
+  metadata.gz: 5dda1a3fde0dfb600e38da84061bfd3f006b4f8a199e04900d067a4a96408affb102e916622d88b8fa0e04f6773f686bf5e2ef13aef108c5560d2c42e009df54
+  data.tar.gz: 4263fedb95452fefc118f7a199d70756455cb02c0fadd1c36b9ad630cdfd8d67d647c7a358c683295ca5cc0d2c53f2eca1a5a1ee4efde71b9d91f02a864118f5

data/lib/git/basic_submodules.rb

@@ -0,0 +1,53 @@
+require 'git'
+
+module BasicSubmodulePrimitives
+  # Extend Git::Lib to support shotgunning submodules. This command
+  # is not smart, and it has very poor support for submodule options.
+  # For example, you can't pass any arguments to the handful of submodule
+  # options that accept them (like --depth). We may extend it later,
+  # but for rev. 0001, simply initializing them will suffice
+  def update_submodules(**options)
+    arr_opts = ['update']
+    options.each_pair do |k, v|
+      arr_opts << "--#{k}" if v
+    end
+    Dir.chdir(@git_work_dir) do
+      command('submodule', arr_opts)
+    end
+  end
+end
+
+module BasicSubmodules
+  # @example Initialize all git submodules
+  #   >> repo = Git.clone("git@github.com:puppetlabs/facter.git", "facter", path: Dir.mktmpdir)
+  #   => <Git::Base>
+  #   >> repo.checkout "3.1.3
+  #   => <String>
+  #   >> repo.update_submodules(init: true)
+  #   => <String>
+  # @param [Hash] options any options to pass to `git submodule update`
+  # @option options [Boolean] :init whether to initialize submodules when updating them
+  # @option options [Boolean] :use the submodule's remote-tracking branch instead of superproject's SHA1 sum
+  # @option options [Boolean] :no-fetch don't fetch new objects from the remote site.
+  # @option options [Boolean] :force remove submodule's working tree even if modified
+  # @option options [Boolean] :checkout checkout submodules in detached HEAD state
+  # @option options [Boolean] :merge merge recorded commit for submodule into the current branch of the submodule
+  # @option options [Boolean] :rebase rebase current branch of submodule onto the commit recorded in the superproject
+  # @option options [Boolean] :recursive recurse into nested submodules
+  # @return options [String] any output produced by `git` when submodules are initialized
+  def update_submodules(**options)
+    self.lib.update_submodules(options)
+  end
+end
+
+module Git
+  class Lib
+    include BasicSubmodulePrimitives
+  end
+end
+
+module Git
+  class Base
+    include BasicSubmodules
+  end
+end

data/lib/vanagon/component.rb

@@ -105,17 +105,20 @@ class Vanagon
     # makefile template
     #
     # @param workdir [String] working directory to put the source into
-    def get_source(workdir)
-      if @url
-        @source = Vanagon::Component::Source.source(@url, @options, workdir)
-        @source.fetch
-        @source.verify
-        @extract_with = @source.respond_to?(:extract) ? @source.extract(@platform.tar) : ':'
-        @cleanup_source = @source.cleanup if @source.respond_to?(:cleanup)
-        @dirname = @source.dirname
+    def get_source(workdir) # rubocop:disable Metrics/AbcSize
+      opts = options.merge({ workdir: workdir })
+      if url
+        @source = Vanagon::Component::Source.source(url, opts)
+        source.fetch
+        source.verify
+        @extract_with = source.respond_to?(:extract) ? source.extract(platform.tar) : ':'
+        @cleanup_source = source.cleanup if source.respond_to?(:cleanup)
+        @dirname = source.dirname
 
         # Git based sources probably won't set the version, so we load it if it hasn't been already set
-        @version ||= @source.version
+        if source.respond_to?(:version)
+          @version ||= source.version
+        end
       else
         warn "No source given for component '#{@name}'"
 
@@ -140,10 +143,13 @@ class Vanagon
     #
     # @param workdir [String] working directory to put the source into
     def get_sources(workdir)
-      @sources.each do |source|
-        cur_source = Vanagon::Component::Source.source(source.url, { :ref => source.ref, :sum => source.sum }, workdir)
-        cur_source.fetch
-        cur_source.verify
+      sources.each do |source|
+        src = Vanagon::Component::Source.source source.url,
+                                                workdir: workdir,
+                                                ref: source.ref,
+                                                sum: source.sum
+        src.fetch
+        src.verify
       end
     end
 

data/lib/vanagon/component/dsl.rb

@@ -310,11 +310,12 @@ class Vanagon
 
       # This will add a source to the project and put it in the workdir alongside the other sources
       #
-      # @param url [String] url of the source
-      # @param ref [String] Used for git sources, must be a git ref of some sort
-      # @param sum [String] sum used to validate http and file sources
-      def add_source(url, ref: nil, sum: nil)
-        @component.sources << OpenStruct.new(:url => url, :ref => ref, :sum => sum)
+      # @param uri [String] uri of the source
+      # @param [Hash] options optional keyword arguments used to instatiate a new source
+      #   @option opts [String] :sum
+      #   @option opts [String] :ref
+      def add_source(uri, **options)
+        @component.sources << OpenStruct.new(options.merge({ url: uri }))
       end
 
       # Adds a directory to the list of directories provided by the project, to be included in any packages of the project

data/lib/vanagon/component/source.rb

@@ -1,3 +1,4 @@
+require 'fustigit'
 require 'vanagon/component/source/http'
 require 'vanagon/component/source/git'
 require 'vanagon/component/source/local'
@@ -5,74 +6,100 @@ require 'vanagon/component/source/local'
 class Vanagon
   class Component
     class Source
-      SUPPORTED_PROTOCOLS = ['file', 'http', 'git'].freeze
-      @@rewrite_rule = {}
+      SUPPORTED_PROTOCOLS = %w(file http https git).freeze
+      @rewrite_rules = {}
 
-      def self.register_rewrite_rule(protocol, rule)
-        if rule.is_a?(String) or rule.is_a?(Proc)
-          if SUPPORTED_PROTOCOLS.include?(protocol)
-            @@rewrite_rule[protocol] = rule
+      class << self
+        attr_reader :rewrite_rules
+
+        def register_rewrite_rule(protocol, rule)
+          if rule.is_a?(String) || rule.is_a?(Proc)
+            if SUPPORTED_PROTOCOLS.include?(protocol)
+              @rewrite_rules[protocol] = rule
+            else
+              raise Vanagon::Error, "#{protocol} is not a supported protocol for rewriting"
+            end
           else
-            raise Vanagon::Error, "#{protocol} is not a supported protocol for rewriting"
+            raise Vanagon::Error, "String or Proc is required as a rewrite_rule."
           end
-        else
-          raise Vanagon::Error, "String or Proc is required as a rewrite_rule."
         end
-      end
 
-      def self.rewrite(url, protocol)
-        rule = @@rewrite_rule[protocol]
+        def rewrite(url, protocol)
+          # Vanagon did not originally distinguish between http and https
+          # when looking up rewrite rules; this is no longer true, but it
+          # means that we should try to preserve old, dumb behavior until
+          # the rewrite engine is removed.
+          return rewrite(url, "http") if protocol == "https"
 
-        if rule
-          if rule.is_a?(Proc)
-            return proc_rewrite(rule, url)
-          elsif rule.is_a?(String)
-            return string_rewrite(rule, url)
+          rule = @rewrite_rules[protocol]
+          if rule
+            if rule.is_a?(Proc)
+              return proc_rewrite(rule, url)
+            elsif rule.is_a?(String)
+              return string_rewrite(rule, url)
+            end
           end
+
+          return url
         end
 
-        return url
-      end
+        def proc_rewrite(rule, url)
+          if rule.arity == 1
+            rule.call(url)
+          else
+            raise Vanagon::Error, "Unable to use provided rewrite rule. Expected Proc with one argument, Proc has #{rule.arity} arguments"
+          end
+        end
 
-      def self.proc_rewrite(rule, url)
-        if rule.arity == 1
-          rule.call(url)
-        else
-          raise Vanagon::Error, "Unable to use provided rewrite rule. Expected Proc with one argument, Proc has #{rule.arity} arguments"
+        def string_rewrite(rule, original_url)
+          url = original_url.to_s
+          target_match = url.match(/.*\/([^\/]*)$/)
+          if target_match
+            target = target_match[1]
+            return File.join(rule, target)
+          else
+            raise Vanagon::Error, "Unable to apply url rewrite to '#{url}', expected to find at least one '/' in the url."
+          end
         end
-      end
 
-      def self.string_rewrite(rule, url)
-        target_match = url.match(/.*\/([^\/]*)$/)
-        if target_match
-          target = target_match[1]
-          return File.join(rule, target)
-        else
-          raise Vanagon::Error, "Unable to apply url rewrite to '#{url}', expected to find at least one '/' in the url."
+        def parse_and_rewrite(uri)
+          url = URI.parse(uri)
+          return url unless url.scheme
+          rewrite(url.to_s, url.scheme)
         end
-      end
 
-      # Basic factory to hand back the correct {Vanagon::Component::Source} subtype to the component
-      #
-      # @param url [String] URL to the source (includes git@... style links)
-      # @param options [Hash] hash of the options needed for the subtype
-      # @param workdir [String] working directory to fetch the source into
-      # @return [Vanagon::Component::Source] the correct subtype for the given source
-      def self.source(url, options, workdir)
-        url_match = url.match(/^(.*)(@|:\/\/)(.*)$/)
-        uri_scheme = url_match[1] if url_match
-        local_source =  case uri_scheme
-                        when /^http/
-                          Vanagon::Component::Source::Http.new(self.rewrite(url, 'http'), options[:sum], workdir)
-                        when /^file/
-                          Vanagon::Component::Source::Local.new(self.rewrite(url, 'file'), workdir)
-                        when /^git/
-                          Vanagon::Component::Source::Git.new(self.rewrite(url, 'git'), options[:ref], workdir)
-                        else
-                          fail "Don't know how to handle source of type '#{uri_scheme}' from url: '#{url}'"
-                        end
+        # Basic factory to hand back the correct {Vanagon::Component::Source} subtype to the component
+        #
+        # @param url [String] URI of the source file (includes git@... style links)
+        # @param options [Hash] hash of the options needed for the subtype
+        # @param workdir [String] working directory to fetch the source into
+        # @return [Vanagon::Component::Source] the correct subtype for the given source
+        def source(uri, **options) # rubocop:disable Metrics/AbcSize
+          # First we try git
+          if Vanagon::Component::Source::Git.valid_remote?(parse_and_rewrite(uri))
+            return Vanagon::Component::Source::Git.new parse_and_rewrite(uri),
+              sum: options[:sum],
+              ref: options[:ref],
+              workdir: options[:workdir]
+          end
+
+          # Then we try HTTP
+          if Vanagon::Component::Source::Http.valid_url?(parse_and_rewrite(uri))
+            return Vanagon::Component::Source::Http.new parse_and_rewrite(uri),
+              sum: options[:sum],
+              workdir: options[:workdir]
+          end
+
+          # Then we try local
+          if Vanagon::Component::Source::Local.valid_file?(uri)
+            return Vanagon::Component::Source::Local.new uri,
+              workdir: options[:workdir]
+          end
 
-        return local_source
+          # Failing all of that, we give up
+          raise Vanagon::Error,
+            "Unknown file type: '#{uri}'; cannot continue"
+        end
       end
     end
   end

data/lib/vanagon/component/source/git.rb

@@ -1,39 +1,69 @@
 require 'vanagon/utilities'
+require 'vanagon/errors'
+# This stupid library requires a capital 'E' in its name
+# but it provides a wealth of useful constants
+require 'English'
+require 'fustigit'
+require 'git/basic_submodules'
+require 'logger'
 
 class Vanagon
   class Component
     class Source
       class Git
-        include Vanagon::Utilities
-        attr_accessor :url, :ref, :workdir, :version, :cleanup
+        attr_accessor :url, :ref, :workdir
+        attr_reader :version, :default_options, :repo
+
+        class << self
+          # Attempt to connect to whatever URL is provided and
+          # return True or False depending on whether or not
+          # `git` thinks it's a valid Git repo.
+          #
+          # @return [Boolean] whether #url is a valid Git repo or not
+          def valid_remote?(url)
+            !!::Git.ls_remote(url)
+          rescue ::Git::GitExecuteError
+            false
+          end
+        end
+
+        # Default options used when cloning; this may expand
+        # or change over time.
+        def default_options
+          @default_options ||= { ref: "refs/heads/master" }
+        end
+        private :default_options
 
         # Constructor for the Git source type
         #
         # @param url [String] url of git repo to use as source
         # @param ref [String] ref to checkout from git repo
         # @param workdir [String] working directory to clone into
-        def initialize(url, ref, workdir)
-          unless ref
-            fail "ref parameter is required for the git source"
-          end
-          @url = url
-          @ref = ref
+        def initialize(url, workdir:, **options)
+          opts = default_options.merge(options)
+
+          # Ensure that #url returns a URI object
+          @url = URI.parse(url.to_s)
+          @ref = opts[:ref]
           @workdir = workdir
+          @ref_name, @ref_type, = @ref.split('/', 3).reverse
+
+          # We can test for Repo existence without cloning
+          raise Vanagon::InvalidRepo, "#{url} not a valid Git repo" unless valid_remote?
         end
 
         # Fetch the source. In this case, clone the repository into the workdir
         # and check out the ref. Also sets the version if there is a git tag as
         # a side effect.
         def fetch
-          puts "Cloning ref '#{@ref}' from url '#{@url}'"
-          Dir.chdir(@workdir) do
-            git("clone #{@url}", true)
-            Dir.chdir(dirname) do
-              git("checkout #{@ref}", true)
-              git("submodule update --init --recursive", true)
-              @version = git_version
-            end
-          end
+          clone!
+          checkout!
+          version
+          update_submodules
+        end
+
+        def ref
+          @ref_name || @ref
         end
 
         # Return the correct incantation to cleanup the source directory for a given source
@@ -43,18 +73,97 @@ class Vanagon
           "rm -rf #{dirname}"
         end
 
-        # There is no md5 to manually verify here, so it is a noop.
+        # There is no md5 to manually verify here, so this is a noop.
         def verify
-          # nothing to do here, so just return
+          # nothing to do here, so just tell users that and return
+          puts "Nothing to verify for '#{dirname}' (using Git reference '#{ref}')"
         end
 
         # The dirname to reference when building from the repo
         #
         # @return [String] the directory where the repo was cloned
         def dirname
-          File.basename(@url).sub(/\.git/, '')
+          File.basename(url.path, ".git")
+        end
+
+        # Use `git describe` to lazy-load a version for this component
+        def version
+          @version ||= describe
+        end
+
+        # Perform a git clone of @url as a lazy-loaded
+        # accessor for @clone
+        def clone
+          @clone ||= ::Git.clone(url, dirname, path: workdir)
+        end
+
+        # Attempt to connect to whatever URL is provided and
+        # return True or False depending on whether or not
+        # `git` thinks it's a valid Git repo.
+        #
+        # @return [Boolean] whether #url is a valid Git repo or not
+        def valid_remote?
+          self.class.valid_remote? url
+        end
+        private :valid_remote?
+
+        # Provide a list of remote refs (branches and tags)
+        def remote_refs
+          (remote['tags'].keys + remote['branches'].keys).uniq
+        end
+        private :remote_refs
+
+        # Provide a list of local refs (branches and tags)
+        def refs
+          (clone.tags.map(&:name) + clone.branches.map(&:name)).uniq
+        end
+        private :refs
+
+        # Clone a remote repo, make noise about it, and fail entirely
+        # if we're unable to retrieve the remote repo
+        def clone!
+          puts "Cloning Git repo '#{url}'"
+          puts "Successfully cloned '#{dirname}'" if clone
+        rescue Git::GitExecuteError
+          raise Vanagon::InvalidRepo, "Unable to clone from '#{url}'"
         end
+        private :clone!
+
+        # Checkout desired ref/sha, make noise about it, and fail
+        # entirely if we're unable to checkout that given ref/sha
+        def checkout!
+          puts "Checking out '#{ref}'' from Git repo '#{dirname}'"
+          clone.checkout(ref)
+        rescue ::Git::GitExecuteError
+          raise Vanagon::CheckoutFailed, "unable to checkout #{ref} from '#{url}'"
+        end
+        private :checkout!
+
+        # Attempt to update submodules, and do not panic
+        # if there are no submodules to initialize
+        def update_submodules
+          puts "Attempting to update submodules for repo '#{dirname}'"
+          clone.update_submodules(init: true)
+        end
+        private :update_submodules
+
+        # Determines a version for the given directory based on the git describe
+        # for the repository
+        #
+        # @return [String] The version of the directory according to git describe
+        def describe
+          clone.describe(ref, tags: true)
+        rescue ::Git::GitExecuteError
+          warn "Directory '#{dirname}' cannot be versioned by Git. Maybe it hasn't been tagged yet?"
+        end
+        private :describe
       end
     end
   end
+
+  class GitError < Error; end
+  # Raised when a URI is not a valid Source Control repo
+  class InvalidRepo < GitError; end
+  # Raised when checking out a given ref from a Git Repo fails
+  class CheckoutFailed < GitError; end
 end