librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

@@ -1,217 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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