librarian-puppet-maestrodev 0.9.7

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)
+          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,61 @@
+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(name, version, dependencies)
+        manifest = Manifest.new(self, name)
+        manifest.version = version
+        manifest.dependencies = dependencies
+        manifest
+      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

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

@@ -0,0 +1,74 @@
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Path
+
+      include Local
+
+      class << self
+
+        LOCK_NAME = 'PATH'
+
+        def lock_name
+          LOCK_NAME
+        end
+
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
+        end
+
+        def from_spec_args(environment, path, options)
+          recognized_options = []
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, path, options)
+        end
+
+      end
+
+      attr_accessor :environment
+      private :environment=
+      attr_reader :path
+
+      def initialize(environment, path, options)
+        self.environment = environment
+        @path = path
+      end
+
+      def to_s
+        path.to_s
+      end
+
+      def ==(other)
+        other &&
+        self.class  == other.class &&
+        self.path   == other.path
+      end
+
+      def to_spec_args
+        [path.to_s, {}]
+      end
+
+      def to_lock_options
+        {:remote => path}
+      end
+
+      def pinned?
+        false
+      end
+
+      def unpin!
+      end
+
+      def cache!
+      end
+
+      def filesystem_path
+        @filesystem_path ||= Pathname.new(path).expand_path(environment.project_path)
+      end
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/spec.rb

@@ -0,0 +1,13 @@
+module Librarian
+  class Spec
+
+    attr_accessor :source, :dependencies
+    private :source=, :dependencies=
+
+    def initialize(source, dependencies)
+      self.source = source
+      self.dependencies = dependencies
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/spec_change_set.rb

@@ -0,0 +1,173 @@
+require 'librarian/helpers'
+
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+require 'librarian/spec'
+
+module Librarian
+  class SpecChangeSet
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :spec, :lock
+
+    def initialize(environment, spec, lock)
+      self.environment = environment
+      raise TypeError, "can't convert #{spec.class} into #{Spec}" unless Spec === spec
+      raise TypeError, "can't convert #{lock.class} into #{Resolution}" unless Resolution === lock
+      @spec, @lock = spec, lock
+    end
+
+    def same?
+      @same ||= spec.dependencies.sort_by{|d| d.name} == lock.dependencies.sort_by{|d| d.name}
+    end
+
+    def changed?
+      !same?
+    end
+
+    def spec_dependencies
+      @spec_dependencies ||= spec.dependencies
+    end
+    def spec_dependency_names
+      @spec_dependency_names ||= Set.new(spec_dependencies.map{|d| d.name})
+    end
+    def spec_dependency_index
+      @spec_dependency_index ||= Hash[spec_dependencies.map{|d| [d.name, d]}]
+    end
+
+    def lock_dependencies
+      @lock_dependencies ||= lock.dependencies
+    end
+    def lock_dependency_names
+      @lock_dependency_names ||= Set.new(lock_dependencies.map{|d| d.name})
+    end
+    def lock_dependency_index
+      @lock_dependency_index ||= Hash[lock_dependencies.map{|d| [d.name, d]}]
+    end
+
+    def lock_manifests
+      @lock_manifests ||= lock.manifests
+    end
+    def lock_manifests_index
+      @lock_manifests_index ||= ManifestSet.new(lock_manifests).to_hash
+    end
+
+    def removed_dependency_names
+      @removed_dependency_names ||= lock_dependency_names - spec_dependency_names
+    end
+
+    # A dependency which is deleted from the specfile will, in the general case,
+    #   be removed conservatively. This means it might not actually be removed.
+    #   But if the dependency originally declared a source which is now non-
+    #   default, it must be removed, even if another dependency has a transitive
+    #   dependency on the one that was removed (which is the scenario in which
+    #   a conservative removal would not remove it). In this case, we must also
+    #   remove it explicitly so that it can be re-resolved from the default
+    #   source.
+    def explicit_removed_dependency_names
+      @explicit_removed_dependency_names ||= removed_dependency_names.reject do |name|
+        lock_manifest = lock_manifests_index[name]
+        lock_manifest.source == spec.source
+      end.to_set
+    end
+
+    def added_dependency_names
+      @added_dependency_names ||= spec_dependency_names - lock_dependency_names
+    end
+
+    def nonmatching_added_dependency_names
+      @nonmatching_added_dependency_names ||= added_dependency_names.reject do |name|
+        spec_dependency = spec_dependency_index[name]
+        lock_manifest = lock_manifests_index[name]
+        if lock_manifest
+          matching = true
+          matching &&= spec_dependency.satisfied_by?(lock_manifest)
+          matching &&= spec_dependency.source == lock_manifest.source
+          matching
+        else
+          false
+        end
+      end.to_set
+    end
+
+    def common_dependency_names
+      @common_dependency_names ||= lock_dependency_names & spec_dependency_names
+    end
+
+    def changed_dependency_names
+      @changed_dependency_names ||= common_dependency_names.reject do |name|
+        spec_dependency = spec_dependency_index[name]
+        lock_dependency = lock_dependency_index[name]
+        lock_manifest = lock_manifests_index[name]
+        same = true
+        same &&= spec_dependency.satisfied_by?(lock_manifest)
+        same &&= spec_dependency.source == lock_dependency.source
+        same
+      end.to_set
+    end
+
+    def deep_keep_manifest_names
+      @deep_keep_manifest_names ||= begin
+        lock_dependency_names - (
+          removed_dependency_names +
+          changed_dependency_names +
+          nonmatching_added_dependency_names
+        )
+      end
+    end
+
+    def shallow_strip_manifest_names
+      @shallow_strip_manifest_names ||= begin
+        explicit_removed_dependency_names + changed_dependency_names
+      end
+    end
+
+    def inspect
+      Helpers.strip_heredoc(<<-INSPECT)
+        <##{self.class.name}:
+          Removed: #{removed_dependency_names.to_a.join(", ")}
+          ExplicitRemoved: #{explicit_removed_dependency_names.to_a.join(", ")}
+          Added: #{added_dependency_names.to_a.join(", ")}
+          NonMatchingAdded: #{nonmatching_added_dependency_names.to_a.join(", ")}
+          Changed: #{changed_dependency_names.to_a.join(", ")}
+          DeepKeep: #{deep_keep_manifest_names.to_a.join(", ")}
+          ShallowStrip: #{shallow_strip_manifest_names.to_a.join(", ")}
+        >
+      INSPECT
+    end
+
+    # Returns an array of those manifests from the previous spec which should be kept,
+    #   based on inspecting the new spec against the locked resolution from the previous spec.
+    def analyze
+      @analyze ||= begin
+        debug { "Analyzing spec and lock:" }
+
+        if same?
+          debug { "  Same!" }
+          return lock.manifests
+        end
+
+        debug { "  Removed:" } ; removed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  ExplicitRemoved:" } ; explicit_removed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  Added:" } ; added_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  NonMatchingAdded:" } ; nonmatching_added_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  Changed:" } ; changed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  DeepKeep:" } ; deep_keep_manifest_names.each { |name| debug { "    #{name}" } }
+        debug { "  ShallowStrip:" } ; shallow_strip_manifest_names.each { |name| debug { "    #{name}" } }
+
+        manifests = ManifestSet.new(lock_manifests)
+        manifests.deep_keep!(deep_keep_manifest_names)
+        manifests.shallow_strip!(shallow_strip_manifest_names)
+        manifests.to_a
+      end
+    end
+
+  private
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+  end
+end