librarian-puppet-maestrodev 0.9.7

data/vendor/librarian/lib/librarian/logger.rb

@@ -0,0 +1,46 @@
+module Librarian
+  class Logger
+
+    librarian_path = Pathname(__FILE__)
+    librarian_path = librarian_path.dirname until librarian_path.join("lib").directory?
+    LIBRARIAN_PATH = librarian_path
+
+    attr_accessor :environment
+    private :environment=
+
+    def initialize(environment)
+      self.environment = environment
+    end
+
+    def info(string = nil, &block)
+      return unless ui
+
+      ui.info(string || yield)
+    end
+
+    def debug(string = nil, &block)
+      return unless ui
+
+      if ui.respond_to?(:debug_line_numbers) && ui.debug_line_numbers
+        loc = caller.find{|l| !(l =~ /in `debug'$/)}
+        if loc =~ /^(.+):(\d+):in `(.+)'$/
+          loc = "#{Pathname.new($1).relative_path_from(LIBRARIAN_PATH)}:#{$2}:in `#{$3}'"
+        end
+        ui.debug { "[Librarian] #{string || yield} [#{loc}]" }
+      else
+        ui.debug { "[Librarian] #{string || yield}" }
+      end
+    end
+
+    def relative_path_to(path)
+      environment.project_relative_path_to(path)
+    end
+
+    private
+
+    def ui
+      environment.ui
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/manifest.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+
+module Librarian
+  class Manifest
+
+    class Version
+      include Comparable
+
+      def initialize(*args)
+        args = initialize_normalize_args(args)
+
+        self.backing = Gem::Version.new(*args)
+      end
+
+      def to_gem_version
+        backing
+      end
+
+      def <=>(other)
+        to_gem_version <=> other.to_gem_version
+      end
+
+      def to_s
+        to_gem_version.to_s
+      end
+
+      private
+
+      def initialize_normalize_args(args)
+        args.map do |arg|
+          arg = [arg] if self.class === arg
+          arg
+        end
+      end
+
+      attr_accessor :backing
+    end
+
+    attr_accessor :source, :name, :extra
+    private :source=, :name=, :extra=
+
+    def initialize(source, name, extra = nil)
+      assert_name_valid! name
+
+      self.source = source
+      self.name = name
+      self.extra = extra
+    end
+
+    def to_s
+      "#{name}/#{version} <#{source}>"
+    end
+
+    def version
+      defined_version || fetched_version
+    end
+
+    def version=(version)
+      self.defined_version = _normalize_version(version)
+    end
+
+    def version?
+      return unless defined_version
+
+      defined_version == fetched_version
+    end
+
+    def dependencies
+      defined_dependencies || fetched_dependencies
+    end
+
+    def dependencies=(dependencies)
+      self.defined_dependencies = _normalize_dependencies(dependencies)
+    end
+
+    def dependencies?
+      return unless defined_dependencies
+
+      defined_dependencies.zip(fetched_dependencies).all? do |(a, b)|
+        a.name == b.name && a.requirement == b.requirement
+      end
+    end
+
+    def satisfies?(dependency)
+      dependency.requirement.satisfied_by?(version)
+    end
+
+    def install!
+      source.install!(self)
+    end
+
+  private
+
+    attr_accessor :defined_version, :defined_dependencies
+
+    def environment
+      source.environment
+    end
+
+    def fetched_version
+      @fetched_version ||= _normalize_version(fetch_version!)
+    end
+
+    def fetched_dependencies
+      @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+    end
+
+    def fetch_version!
+      source.fetch_version(name, extra)
+    end
+
+    def fetch_dependencies!
+      source.fetch_dependencies(name, version, extra)
+    end
+
+    def _normalize_version(version)
+      Version.new(version)
+    end
+
+    def _normalize_dependencies(dependencies)
+      if Hash === dependencies
+        dependencies = dependencies.map{|k, v| Dependency.new(k, v, nil)}
+      end
+      dependencies.sort_by(&:name)
+    end
+
+    def assert_name_valid!(name)
+      raise ArgumentError, "name (#{name.inspect}) must be sensible" unless name =~ /\A\S(?:.*\S)?\z/
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/manifest_set.rb

@@ -0,0 +1,153 @@
+require 'set'
+require 'tsort'
+
+module Librarian
+  class ManifestSet
+
+    class GraphHash < Hash
+      include TSort
+      alias tsort_each_node each_key
+      def tsort_each_child(node, &block)
+        self[node].each(&block)
+      end
+    end
+
+    class << self
+      def shallow_strip(manifests, names)
+        new(manifests).shallow_strip!(names).send(method_for(manifests))
+      end
+      def deep_strip(manifests, names)
+        new(manifests).deep_strip!(names).send(method_for(manifests))
+      end
+      def shallow_keep(manifests, names)
+        new(manifests).shallow_keep!(names).send(method_for(manifests))
+      end
+      def deep_keep(manifests, names)
+        new(manifests).deep_keep!(names).send(method_for(manifests))
+      end
+      def sort(manifests)
+        manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
+        manifest_pairs = GraphHash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        manifest_names = manifest_pairs.tsort
+        manifest_names.map{|n| manifests[n]}
+      end
+    private
+      def method_for(manifests)
+        case manifests
+        when Hash
+          :to_hash
+        when Array
+          :to_a
+        end
+      end
+    end
+
+    def initialize(manifests)
+      self.index = Hash === manifests ? manifests.dup : Hash[manifests.map{|m| [m.name, m]}]
+    end
+
+    def to_a
+      index.values
+    end
+
+    def to_hash
+      index.dup
+    end
+
+    def dup
+      self.class.new(index)
+    end
+
+    def shallow_strip(names)
+      dup.shallow_strip!(names)
+    end
+
+    def shallow_strip!(names)
+      assert_strings!(names)
+
+      names.each do |name|
+        index.delete(name)
+      end
+      self
+    end
+
+    def deep_strip(names)
+      dup.deep_strip!(names)
+    end
+
+    def deep_strip!(names)
+      names = Array === names ? names.dup : names.to_a
+      assert_strings!(names)
+
+      strippables = dependencies_of(names)
+      shallow_strip!(strippables)
+
+      self
+    end
+
+    def shallow_keep(names)
+      dup.shallow_keep!(names)
+    end
+
+    def shallow_keep!(names)
+      assert_strings!(names)
+
+      names = Set.new(names) unless Set === names
+      index.reject! { |k, v| !names.include?(k) }
+      self
+    end
+
+    def deep_keep(names)
+      dup.conservative_strip!(names)
+    end
+
+    def deep_keep!(names)
+      names = Array === names ? names.dup : names.to_a
+      assert_strings!(names)
+
+      keepables = dependencies_of(names)
+      shallow_keep!(keepables)
+
+      self
+    end
+
+    def consistent?
+      index.values.all? do |manifest|
+        in_compliance_with?(manifest.dependencies)
+      end
+    end
+
+    def in_compliance_with?(dependencies)
+      dependencies.all? do |dependency|
+        manifest = index[dependency.name]
+        manifest && manifest.satisfies?(dependency)
+      end
+    end
+
+  private
+
+    attr_accessor :index
+
+    def assert_strings!(names)
+      non_strings = names.reject{|name| String === name}
+      non_strings.empty? or raise TypeError, "names must all be strings"
+    end
+
+    # Straightforward breadth-first graph traversal algorithm.
+    def dependencies_of(names)
+      names = Array === names ? names.dup : names.to_a
+      assert_strings!(names)
+
+      deps = Set.new
+      until names.empty?
+        name = names.shift
+        next if deps.include?(name)
+
+        deps << name
+        names.concat index[name].dependencies.map(&:name)
+      end
+      deps.to_a
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/mock.rb

@@ -0,0 +1 @@
+require 'librarian/mock/extension'

data/vendor/librarian/lib/librarian/mock/cli.rb

@@ -0,0 +1,19 @@
+require 'librarian/cli'
+require 'librarian/mock'
+
+module Librarian
+  module Mock
+    class Cli < Librarian::Cli
+
+      module Particularity
+        def root_module
+          Mock
+        end
+      end
+
+      include Particularity
+      extend Particularity
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/mock/dsl.rb

@@ -0,0 +1,15 @@
+require 'librarian/dsl'
+require 'librarian/mock/source'
+
+module Librarian
+  module Mock
+    class Dsl < Librarian::Dsl
+
+      dependency :dep
+
+      source :src => Source::Mock
+
+      shortcut :a, :src => 'source-a'
+    end
+  end
+end

data/vendor/librarian/lib/librarian/mock/environment.rb

@@ -0,0 +1,24 @@
+require "librarian/environment"
+require "librarian/mock/dsl"
+
+module Librarian
+  module Mock
+    class Environment < Environment
+
+      def adapter_name
+        "mock"
+      end
+
+      def install_path
+        nil
+      end
+
+      def registry(options = nil, &block)
+        @registry ||= Source::Mock::Registry.new
+        @registry.merge!(options, &block)
+        @registry
+      end
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/mock/extension.rb

@@ -0,0 +1,9 @@
+require 'librarian/mock/environment'
+
+module Librarian
+  module Mock
+    extend self
+    extend Librarian
+
+  end
+end

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

@@ -0,0 +1 @@
+require 'librarian/mock/source/mock'

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

@@ -0,0 +1,97 @@
+require 'librarian/manifest'
+require 'librarian/mock/source/mock/registry'
+
+module Librarian
+  module Mock
+    module Source
+      class Mock
+
+        class << self
+
+          LOCK_NAME = 'MOCK'
+
+          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, name, options)
+            recognized_options = []
+            unrecognized_options = options.keys - recognized_options
+            unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
+
+            new(environment, name, options)
+          end
+
+        end
+
+        attr_accessor :environment
+        private :environment=
+        attr_reader :name
+
+        def initialize(environment, name, options)
+          self.environment = environment
+          @name = name
+        end
+
+        def to_s
+          name
+        end
+
+        def ==(other)
+          other &&
+          self.class  == other.class &&
+          self.name   == other.name
+        end
+
+        def to_spec_args
+          [name, {}]
+        end
+
+        def to_lock_options
+          {:remote => name}
+        end
+
+        def registry
+          environment.registry[name]
+        end
+
+        def manifest(name, version, dependencies)
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
+        end
+
+        def manifests(name)
+          if d = registry[name]
+            d.map{|v| manifest(name, v[:version], v[:dependencies])}
+          else
+            nil
+          end
+        end
+
+        def install!(manifest)
+        end
+
+        def to_s
+          name
+        end
+
+        def fetch_version(name, extra)
+          extra
+        end
+
+        def fetch_dependencies(name, version, extra)
+          d = registry[name]
+          m = d.find{|v| v[:version] == version.to_s}
+          m[:dependencies]
+        end
+
+      end
+    end
+  end
+end