librarian-puppet-maestrodev 0.9.7

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

@@ -0,0 +1,172 @@
+require 'librarian/spec'
+
+module Librarian
+  class Dsl
+    class Target
+
+      class SourceShortcutDefinitionReceiver
+        def initialize(target)
+          singleton_class = class << self; self end
+          singleton_class.class_eval do
+            define_method(:source) do |options|
+              target.source_from_options(options)
+            end
+            target.source_types.each do |source_type|
+              name = source_type[0]
+              define_method(name) do |*args|
+                args.push({}) unless Hash === args.last
+                target.source_from_params(name, *args)
+              end
+            end
+          end
+        end
+      end
+
+      SCOPABLES = [:sources]
+
+      attr_accessor :dsl
+      private :dsl=
+
+      attr_reader :dependency_name, :dependency_type
+      attr_reader :source_types, :source_types_map, :source_types_reverse_map, :source_type_names, :source_shortcuts
+      attr_reader :dependencies, :source_cache, *SCOPABLES
+
+      def initialize(dsl)
+        self.dsl = dsl
+        @dependency_name = dsl.dependency_name
+        @dependency_type = dsl.dependency_type
+        @source_types = dsl.source_types
+        @source_types_map = Hash[source_types]
+        @source_types_reverse_map = Hash[source_types.map{|pair| a, b = pair ; [b, a]}]
+        @source_type_names = source_types.map{|t| t[0]}
+        @source_cache = {}
+        @source_shortcuts = {}
+        @dependencies = []
+        SCOPABLES.each do |scopable|
+          instance_variable_set(:"@#{scopable}", [])
+        end
+        dsl.source_shortcuts.each do |name, param|
+          define_source_shortcut(name, param)
+        end
+      end
+
+      def to_spec
+        Spec.new(@sources.first, @dependencies)
+      end
+
+      def dependency(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source = source_from_options(options) || @sources.last
+        unless source
+          raise Error, "#{dependency_name} #{name} is specified without a source!"
+        end
+        dep = dependency_type.new(name, args, source)
+        @dependencies << dep
+      end
+
+      def source(name, param = nil, options = nil, &block)
+        if !(Hash === name) && [Array, Hash, Proc].any?{|c| c === param} && !options && !block
+          define_source_shortcut(name, param)
+        elsif !(Hash === name) && !param && !options
+          source = source_shortcuts[name]
+          scope_or_directive(block) do
+            @sources = @sources.dup << source
+          end
+        else
+          name, param, options = *normalize_source_options(name, param, options || {})
+          source = source_from_params(name, param, options)
+          scope_or_directive(block) do
+            @sources = @sources.dup << source
+          end
+        end
+      end
+
+      def precache_sources(sources)
+        sources.each do |source|
+          key = [source_types_reverse_map[source.class], *source.to_spec_args]
+          source_cache[key] = source
+        end
+      end
+
+      def scope
+        currents = { }
+        SCOPABLES.each do |scopable|
+          currents[scopable] = instance_variable_get(:"@#{scopable}").dup
+        end
+        yield
+      ensure
+        SCOPABLES.reverse.each do |scopable|
+          instance_variable_set(:"@#{scopable}", currents[scopable])
+        end
+      end
+
+      def scope_or_directive(scoped_block = nil)
+        unless scoped_block
+          yield
+        else
+          scope do
+            yield
+            scoped_block.call
+          end
+        end
+      end
+
+      def normalize_source_options(name, param, options)
+        if name.is_a?(Hash)
+          extract_source_parts(name)
+        else
+          [name, param, options]
+        end
+      end
+
+      def extract_source_parts(options)
+        if name = source_type_names.find{|name| options.key?(name)}
+          options = options.dup
+          param = options.delete(name)
+          [name, param, options]
+        else
+          nil
+        end
+      end
+
+      def source_from_options(options)
+        if options[:source]
+          source_shortcuts[options[:source]]
+        elsif source_parts = extract_source_parts(options)
+          source_from_params(*source_parts)
+        else
+          nil
+        end
+      end
+
+      def source_from_params(name, param, options)
+        source_cache[[name, param, options]] ||= begin
+          type = source_types_map[name]
+          type.from_spec_args(environment, param, options)
+        end
+      end
+
+      def source_from_source_shortcut_definition(definition)
+        case definition
+        when Array
+          source_from_params(*definition)
+        when Hash
+          source_from_options(definition)
+        when Proc
+          receiver = SourceShortcutDefinitionReceiver.new(self)
+          receiver.instance_eval(&definition)
+        end
+      end
+
+      def define_source_shortcut(name, definition)
+        source = source_from_source_shortcut_definition(definition)
+        source_shortcuts[name] = source
+      end
+
+      def environment
+        dsl.environment
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+require "pathname"
+
+require "librarian/support/abstract_method"
+
+require "librarian/error"
+require "librarian/config"
+require "librarian/lockfile"
+require "librarian/logger"
+require "librarian/specfile"
+require "librarian/resolver"
+require "librarian/dsl"
+require "librarian/source"
+
+module Librarian
+  class Environment
+
+    include Support::AbstractMethod
+
+    attr_accessor :ui
+
+    abstract_method :specfile_name, :dsl_class, :install_path
+
+    def initialize(options = { })
+      @pwd = options.fetch(:pwd) { Dir.pwd }
+      @env = options.fetch(:env) { ENV.to_hash }
+      @home = options.fetch(:home) { File.expand_path("~") }
+      @project_path = options[:project_path]
+      @specfile_name = options[:specfile_name]
+    end
+
+    def logger
+      @logger ||= Logger.new(self)
+    end
+
+    def config_db
+      @config_db ||= begin
+        Config::Database.new(adapter_name,
+          :pwd => @pwd,
+          :env => @env,
+          :home => @home,
+          :project_path => @project_path,
+          :specfile_name => default_specfile_name
+        )
+      end
+    end
+
+    def default_specfile_name
+      @default_specfile_name ||= begin
+        capped = adapter_name.capitalize
+        "#{capped}file"
+      end
+    end
+
+    def project_path
+      config_db.project_path
+    end
+
+    def specfile_name
+      config_db.specfile_name
+    end
+
+    def specfile_path
+      config_db.specfile_path
+    end
+
+    def specfile
+      Specfile.new(self, specfile_path)
+    end
+
+    def adapter_name
+      nil
+    end
+
+    def lockfile_name
+      config_db.lockfile_name
+    end
+
+    def lockfile_path
+      config_db.lockfile_path
+    end
+
+    def lockfile
+      Lockfile.new(self, lockfile_path)
+    end
+
+    def ephemeral_lockfile
+      Lockfile.new(self, nil)
+    end
+
+    def resolver
+      Resolver.new(self)
+    end
+
+    def cache_path
+      project_path.join("tmp/librarian/cache")
+    end
+
+    def scratch_path
+      project_path.join("tmp/librarian/scratch")
+    end
+
+    def project_relative_path_to(path)
+      Pathname.new(path).relative_path_from(project_path)
+    end
+
+    def spec
+      specfile.read
+    end
+
+    def lock
+      lockfile.read
+    end
+
+    def dsl(*args, &block)
+      dsl_class.run(self, *args, &block)
+    end
+
+    def dsl_class
+      self.class.name.split("::")[0 ... -1].inject(Object, &:const_get)::Dsl
+    end
+
+    def config_keys
+      %[
+      ]
+    end
+
+  private
+
+    def environment
+      self
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/error.rb

@@ -0,0 +1,4 @@
+module Librarian
+  class Error < StandardError
+  end
+end

data/vendor/librarian/lib/librarian/helpers.rb

@@ -0,0 +1,13 @@
+module Librarian
+  module Helpers
+    extend self
+
+    # [active_support/core_ext/string/strip]
+    def strip_heredoc(string)
+      indent = string.scan(/^[ \t]*(?=\S)/).min
+      indent = indent.respond_to?(:size) ? indent.size : 0
+      string.gsub(/^[ \t]{#{indent}}/, '')
+    end
+
+  end
+end

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,100 @@
+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)
+        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