librarian-puppet-lmco 0.9.8.2

data/vendor/librarian/lib/librarian/lockfile.rb

@@ -0,0 +1,29 @@
+require 'librarian/lockfile/compiler'
+require 'librarian/lockfile/parser'
+
+module Librarian
+  class Lockfile
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :path
+
+    def initialize(environment, path)
+      self.environment = environment
+      @path = path
+    end
+
+    def save(resolution)
+      Compiler.new(environment).compile(resolution)
+    end
+
+    def load(string)
+      Parser.new(environment).parse(string)
+    end
+
+    def read
+      load(path.read)
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/lockfile/compiler.rb

@@ -0,0 +1,66 @@
+module Librarian
+  class Lockfile
+    class Compiler
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def compile(resolution)
+        out = StringIO.new
+        save_sources(out, resolution.manifests)
+        save_dependencies(out, resolution.dependencies)
+        out.string
+      end
+
+    private
+
+      def save_sources(out, manifests)
+        dsl_class.source_types.map{|t| t[1]}.each do |type|
+          type_manifests = manifests.select{|m| type === m.source}
+          sources = type_manifests.map{|m| m.source}.uniq.sort_by{|s| s.to_s}
+          sources.each do |source|
+            source_manifests = type_manifests.select{|m| source == m.source}
+            save_source(out, source, source_manifests)
+          end
+        end
+      end
+
+      def save_source(out, source, manifests)
+        out.puts "#{source.class.lock_name}"
+        options = source.to_lock_options
+        remote = options.delete(:remote)
+        out.puts "  remote: #{remote}"
+        options.to_a.sort_by{|a| a[0].to_s}.each do |o|
+          out.puts "  #{o[0]}: #{o[1]}"
+        end
+        out.puts "  specs:"
+        manifests.sort_by{|a| a.name}.each do |manifest|
+          out.puts "    #{manifest.name} (#{manifest.version})"
+          manifest.dependencies.sort_by{|a| a.name}.each do |dependency|
+            out.puts "      #{dependency.name} (#{dependency.requirement})"
+          end
+        end
+        out.puts ""
+      end
+
+      def save_dependencies(out, dependencies)
+        out.puts "DEPENDENCIES"
+        dependencies.sort_by{|a| a.name}.each do |d|
+          res = "#{d.name}"
+          res << " (#{d.requirement})" if d.requirement
+          out.puts "  #{res}"
+        end
+        out.puts ""
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/lockfile/parser.rb

@@ -0,0 +1,123 @@
+require 'librarian/manifest'
+require 'librarian/dependency'
+require 'librarian/manifest_set'
+
+module Librarian
+  class Lockfile
+    class Parser
+
+      class ManifestPlaceholder
+        attr_reader :source, :name, :version, :dependencies
+        def initialize(source, name, version, dependencies)
+          @source, @name, @version, @dependencies = source, name, version, dependencies
+        end
+      end
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def parse(string)
+        lines = string.lines.map{|l| l.sub(/\s+\z/, '')}.reject(&:empty?)
+        sources = extract_and_parse_sources(lines)
+        manifests = compile(sources)
+        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        dependencies = extract_and_parse_dependencies(lines, manifests_index)
+        Resolution.new(dependencies, manifests)
+      end
+
+    private
+
+      def extract_and_parse_sources(lines)
+        sources = []
+        while source_type_names.include?(lines.first)
+          source = {}
+          source_type_name = lines.shift
+          source[:type] = source_type_names_map[source_type_name]
+          options = {}
+          while lines.first =~ /^ {2}([\w-]+):\s+(.+)$/
+            lines.shift
+            options[$1.to_sym] = $2
+          end
+          source[:options] = options
+          lines.shift # specs
+          manifests = {}
+          while lines.first =~ /^ {4}([\w-]+) \((.*)\)$/
+            lines.shift
+            name = $1
+            manifests[name] = {:version => $2, :dependencies => {}}
+            while lines.first =~ /^ {6}([\w-]+) \((.*)\)$/
+              lines.shift
+              manifests[name][:dependencies][$1] = $2.split(/,\s*/)
+            end
+          end
+          source[:manifests] = manifests
+          sources << source
+        end
+        sources
+      end
+
+      def extract_and_parse_dependencies(lines, manifests_index)
+        dependencies = []
+        while lines.first =~ /^ {2}([\w-]+)(?: \((.*)\))?$/
+          lines.shift
+          name, requirement = $1, $2.split(/,\s*/)
+          dependencies << Dependency.new(name, requirement, manifests_index[name].source)
+        end
+        dependencies
+      end
+
+      def compile_placeholder_manifests(sources_ast)
+        manifests = {}
+        sources_ast.each do |source_ast|
+          source_type = source_ast[:type]
+          source = source_type.from_lock_options(environment, source_ast[:options])
+          source_ast[:manifests].each do |manifest_name, manifest_ast|
+            manifests[manifest_name] = ManifestPlaceholder.new(
+              source,
+              manifest_name,
+              manifest_ast[:version],
+              manifest_ast[:dependencies].map{|k, v| Dependency.new(k, v, nil)}
+            )
+          end
+        end
+        manifests
+      end
+
+      def compile(sources_ast)
+        manifests = compile_placeholder_manifests(sources_ast)
+        manifests = manifests.map do |name, manifest|
+          dependencies = manifest.dependencies.map do |d|
+            Dependency.new(d.name, d.requirement, manifests[d.name].source)
+          end
+          real = Manifest.new(manifest.source, manifest.name)
+          real.version = manifest.version
+          real.dependencies = manifest.dependencies
+          real
+        end
+        ManifestSet.sort(manifests)
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+      def source_type_names_map
+        @source_type_names_map ||= begin
+          Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
+        end
+      end
+
+      def source_type_names
+        @source_type_names ||= begin
+          dsl_class.source_types.map{|t| t[1].lock_name}
+        end
+      end
+
+    end
+  end
+end

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,140 @@
+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 latest
+      @latest ||= source.manifests(name).first
+    end
+
+    def outdated?
+      latest.version > 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,151 @@
+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 : index_by(manifests, &:name)
+    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)
+      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)
+      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
+
+    def index_by(enum)
+      Hash[enum.map{|obj| [yield(obj), obj]}]
+    end
+
+  end
+end