librarian-puppet-lmco 0.9.8.2

data/vendor/librarian/lib/librarian/source.rb

@@ -0,0 +1,2 @@
+require 'librarian/source/git'
+require 'librarian/source/path'

data/vendor/librarian/lib/librarian/source/basic_api.rb

@@ -0,0 +1,45 @@
+module Librarian
+  module Source
+    module BasicApi
+
+      def self.included(base)
+        base.extend ClassMethods
+        class << base
+          def lock_name(name)
+            def_sclass_prop(:lock_name, name)
+          end
+
+          def spec_options(keys)
+            def_sclass_prop(:spec_options, keys)
+          end
+
+        private
+
+          def def_sclass_prop(name, arg)
+            sclass = class << self ; self ; end
+            sclass.module_exec do
+              remove_method(name)
+              define_method(name) { arg }
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
+        end
+
+        def from_spec_args(environment, param, options)
+          recognized_options = spec_options
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error,
+            "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, param, options)
+        end
+      end
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/source/git.rb

@@ -0,0 +1,134 @@
+require 'fileutils'
+require 'pathname'
+require 'digest'
+
+require 'librarian/source/basic_api'
+require 'librarian/source/git/repository'
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Git
+      include BasicApi
+      include Local
+
+      lock_name 'GIT'
+      spec_options [:ref, :path]
+
+      DEFAULTS = {
+        :ref => 'master'
+      }
+
+      attr_accessor :environment
+      private :environment=
+
+      attr_accessor :uri, :ref, :sha, :path
+      private :uri=, :ref=, :sha=, :path=
+
+      def initialize(environment, uri, options)
+        self.environment = environment
+        self.uri = uri
+        self.ref = options[:ref] || DEFAULTS[:ref]
+        self.sha = options[:sha]
+        self.path = options[:path]
+
+        @repository = nil
+        @repository_cache_path = nil
+
+        ref.kind_of?(String) or raise TypeError, "ref must be a String"
+      end
+
+      def to_s
+        path ? "#{uri}##{ref}(#{path})" : "#{uri}##{ref}"
+      end
+
+      def ==(other)
+        other &&
+        self.class  == other.class  &&
+        self.uri    == other.uri    &&
+        self.ref    == other.ref    &&
+        self.path   == other.path   &&
+        (self.sha.nil? || other.sha.nil? || self.sha == other.sha)
+      end
+
+      def to_spec_args
+        options = {}
+        options.merge!(:ref => ref) if ref != DEFAULTS[:ref]
+        options.merge!(:path => path) if path
+        [uri, options]
+      end
+
+      def to_lock_options
+        options = {:remote => uri, :ref => ref, :sha => sha}
+        options.merge!(:path => path) if path
+        options
+      end
+
+      def pinned?
+        !!sha
+      end
+
+      def unpin!
+        @sha = nil
+      end
+
+      def cache!
+        repository_cached? and return or repository_cached!
+
+        unless repository.git?
+          repository.path.rmtree if repository.path.exist?
+          repository.path.mkpath
+          repository.clone!(uri)
+        end
+        repository.reset_hard!
+        repository.clean!
+        unless repository.checked_out?(sha)
+          remote = repository.default_remote
+          repository.fetch!(remote)
+          repository.fetch!(remote, :tags => true)
+
+          self.sha = repository.hash_from(remote, ref) unless sha
+          repository.checkout!(sha) unless repository.checked_out?(sha)
+
+          raise Error, "failed to checkout #{sha}" unless repository.checked_out?(sha)
+        end
+      end
+
+    private
+
+      attr_accessor :repository_cached
+      alias repository_cached? repository_cached
+
+      def repository_cached!
+        self.repository_cached = true
+      end
+
+      def repository_cache_path
+        @repository_cache_path ||= begin
+          environment.cache_path.join("source/git/#{cache_key}")
+        end
+      end
+
+      def repository
+        @repository ||= begin
+          Repository.new(environment, repository_cache_path)
+        end
+      end
+
+      def filesystem_path
+        @filesystem_path ||= path ? repository.path.join(path) : repository.path
+      end
+
+      def cache_key
+        @cache_key ||= begin
+          uri_part = uri
+          path_part = "/#{path}" if path
+          ref_part = "##{ref}"
+          key_source = [uri_part, path_part, ref_part].join
+          Digest::MD5.hexdigest(key_source)
+        end
+      end
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/source/git/repository.rb

@@ -0,0 +1,217 @@
+require 'open3'
+
+module Librarian
+  module Source
+    class Git
+      class Repository
+
+        class << self
+          def clone!(environment, path, repository_url)
+            path = Pathname.new(path)
+            path.mkpath
+            git = new(environment, path)
+            git.clone!(repository_url)
+            git
+          end
+
+          def bin
+            @bin ||= which("git") or raise Error, "cannot find git"
+          end
+
+          private
+
+          # Cross-platform way of finding an executable in the $PATH.
+          #
+          #   which('ruby') #=> /usr/bin/ruby
+          #
+          # From:
+          #   https://github.com/defunkt/hub/commit/353031307e704d860826fc756ff0070be5e1b430#L2R173
+          def which(cmd)
+            exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+            ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+              path = File.expand_path(path)
+              exts.each do |ext|
+                exe = File.join(path, cmd + ext)
+                return exe if File.file?(exe) && File.executable?(exe)
+              end
+            end
+            nil
+          end
+        end
+
+        attr_accessor :environment, :path
+        private :environment=, :path=
+
+        def initialize(environment, path)
+          self.environment = environment
+          self.path = Pathname.new(path)
+        end
+
+        def git?
+          path.join('.git').exist?
+        end
+
+        def default_remote
+          "origin"
+        end
+
+        def version(options = { })
+          version!(options).strip
+        end
+
+        def version!(options = { })
+          silent = options.delete(:silent)
+
+          command = %w(--version)
+          run!(command, :silent => silent)
+        end
+
+        def clone!(repository_url)
+          command = %W(clone #{repository_url} . --quiet)
+          run!(command, :chdir => true)
+        end
+
+        def checkout!(reference, options ={ })
+          command = %W(checkout #{reference} --quiet)
+          command << "--force" if options[:force]
+          run!(command, :chdir => true)
+        end
+
+        def fetch!(remote, options = { })
+          command = %W(fetch #{remote} --quiet)
+          command << "--tags" if options[:tags]
+          run!(command, :chdir => true)
+        end
+
+        def reset_hard!
+          command = %W(reset --hard --quiet)
+          run!(command, :chdir => true)
+        end
+
+        def clean!
+          command = %w(clean -x -d --force --force)
+          run!(command, :chdir => true)
+        end
+
+        def checked_out?(sha)
+          current_commit_hash == sha
+        end
+
+        def remote_names
+          command = %W(remote)
+          run!(command, :chdir => true).strip.lines.map(&:strip)
+        end
+
+        def remote_branch_names
+          remotes = remote_names.sort_by(&:length).reverse
+
+          command = %W(branch -r --no-color)
+          names = run!(command, :chdir => true).strip.lines.map(&:strip).to_a
+          names.each{|n| n.gsub!(/\s*->.*$/, "")}
+          names.reject!{|n| n =~ /\/HEAD$/}
+          Hash[remotes.map do |r|
+            matching_names = names.select{|n| n.start_with?("#{r}/")}
+            matching_names.each{|n| names.delete(n)}
+            matching_names.each{|n| n.slice!(0, r.size + 1)}
+            [r, matching_names]
+          end]
+        end
+
+        def hash_from(remote, reference)
+          branch_names = remote_branch_names[remote]
+          if branch_names.include?(reference)
+            reference = "#{remote}/#{reference}"
+          end
+
+          command = %W(rev-list #{reference} -1)
+          run!(command, :chdir => true).strip
+        end
+
+        def current_commit_hash
+          command = %W(rev-parse HEAD --quiet)
+          run!(command, :chdir => true).strip!
+        end
+
+      private
+
+        def bin
+          self.class.bin
+        end
+
+        def run!(args, options = { })
+          chdir = options.delete(:chdir)
+          chdir = path.to_s if chdir == true
+
+          silent = options.delete(:silent)
+
+          command = [bin]
+          command.concat(args)
+
+          maybe_within(chdir) do
+            logging_command(command, :silent => silent) do
+              run_command_internal(command)
+            end
+          end
+        end
+
+        def maybe_within(path)
+          if path
+            Dir.chdir(path) { with_env_var("GIT_DIR", nil) { yield } }
+          else
+            yield
+          end
+        end
+
+        def with_env_var(name, value)
+          original_value = ENV[name]
+          begin
+            ENV[name] = value
+            yield
+          ensure
+            ENV[name] = original_value
+          end
+        end
+
+        def logging_command(command, options)
+          silent = options.delete(:silent)
+
+          pwd = Dir.pwd
+
+          unless silent
+            debug { "Running `#{command.join(' ')}` in #{relative_path_to(pwd)}" }
+          end
+
+          out = yield
+
+          unless silent
+            if out.size > 0
+              out.lines.each do |line|
+                debug { "    --> #{line}" }
+              end
+            else
+              debug { "    --- No output" }
+            end
+          end
+
+          out
+        end
+
+        def run_command_internal(command)
+          Open3.popen3(*command) do |i, o, e, t|
+            raise StandardError, e.read unless (t ? t.value : $?).success?
+            o.read
+          end
+        end
+
+        def debug(*args, &block)
+          environment.logger.debug(*args, &block)
+        end
+
+        def relative_path_to(path)
+          environment.logger.relative_path_to(path)
+        end
+
+      end
+    end
+  end
+end

data/vendor/librarian/lib/librarian/source/local.rb

@@ -0,0 +1,54 @@
+require 'librarian/support/abstract_method'
+
+module Librarian
+  module Source
+    # Requires that the including source class have methods:
+    #   #path
+    #   #environment
+    module Local
+
+      include Support::AbstractMethod
+
+      abstract_method :path, :fetch_version, :fetch_dependencies
+
+      def manifests(name)
+        manifest = Manifest.new(self, name)
+        [manifest].compact
+      end
+
+      def manifest_search_paths(name)
+        @manifest_search_paths ||= { }
+        @manifest_search_paths[name] ||= begin
+          cache!
+          paths = [filesystem_path, filesystem_path.join(name)]
+          paths.select{|s| s.exist?}
+        end
+      end
+
+      def found_path(name)
+        @_found_paths ||= { }
+        @_found_paths[name] ||= begin
+          paths = manifest_search_paths(name)
+          paths.find{|p| manifest?(name, p)}
+        end
+      end
+
+    private
+
+      abstract_method :manifest? # (name, path) -> boolean
+
+      def info(*args, &block)
+        environment.logger.info(*args, &block)
+      end
+
+      def debug(*args, &block)
+        environment.logger.debug(*args, &block)
+      end
+
+      def relative_path_to(path)
+        environment.logger.relative_path_to(path)
+      end
+
+    end
+  end
+end