librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

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

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

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

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

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

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

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

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