librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

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

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

@@ -1,154 +0,0 @@
-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
-        raise(Error, "Unable to find module #{name}") if index[name].nil?
-        names.concat index[name].dependencies.map(&:name)
-      end
-      deps.to_a
-    end
-
-  end
-end

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

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

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

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

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

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

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

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

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

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

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