librarian-puppet 0.0.1.pre

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

@@ -0,0 +1,104 @@
+require 'librarian/helpers/debug'
+
+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
+
+      include Helpers::Debug
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def parse(string)
+        string = string.dup
+        source_type_names_map = Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
+        source_type_names = dsl_class.source_types.map{|t| t[1].lock_name}
+        lines = string.split(/(\r|\n|\r\n)+/).select{|l| l =~ /\S/}
+        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
+        manifests = compile(sources)
+        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        dependencies = []
+        while lines.first =~ /^ {2}([\w-]+)(?: \((.*)\))?$/
+          lines.shift
+          name, requirement = $1, $2.split(/,\s*/)
+          dependencies << Dependency.new(name, requirement, manifests_index[name].source)
+        end
+        Resolution.new(dependencies, manifests)
+      end
+
+    private
+
+      def compile(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 = manifests.map do |name, manifest|
+          dependencies = manifest.dependencies.map do |d|
+            Dependency.new(d.name, d.requirement, manifests[d.name].source)
+          end
+          manifest.source.manifest(
+            manifest.name,
+            manifest.version,
+            dependencies
+          )
+        end
+        ManifestSet.sort(manifests)
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+require 'rubygems'
+
+require 'librarian/helpers/debug'
+require 'librarian/support/abstract_method'
+
+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
+
+    include Support::AbstractMethod
+    include Helpers::Debug
+
+    attr_accessor :source, :name, :extra
+    private :source=, :name=, :extra=
+
+    abstract_method :fetch_version!, :fetch_dependencies!
+
+    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 =~ /^\S.*\S$/
+    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