librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

data/vendor/librarian/lib/librarian/config/file_source.rb

@@ -1,47 +0,0 @@
-require "yaml"
-
-require "librarian/config/source"
-
-module Librarian
-  module Config
-    class FileSource < Source
-
-      attr_accessor :config_path
-      private :config_path=
-
-      def initialize(adapter_name, options = { })
-        super
-
-        self.config_path = options.delete(:config_path) or raise ArgumentError, "must provide config_path"
-      end
-
-      def to_s
-        config_path
-      end
-
-    private
-
-      def load
-        return { } unless File.file?(config_path)
-
-        raw = YAML.load_file(config_path)
-        return { } unless Hash === raw
-
-        translate_raw_to_config(raw)
-      end
-
-      def save(config)
-        raw = translate_config_to_raw(config)
-
-        if config.empty?
-          File.delete(config_path) if File.file?(config_path)
-        else
-          config_dir = File.dirname(config_path)
-          FileUtils.mkpath(config_dir) unless File.directory?(config_dir)
-          File.open(config_path, "wb"){|f| YAML.dump(raw, f)}
-        end
-      end
-
-    end
-  end
-end

data/vendor/librarian/lib/librarian/config/hash_source.rb

@@ -1,33 +0,0 @@
-require "librarian/source"
-
-module Librarian
-  module Config
-    class HashSource < Source
-
-      attr_accessor :name, :raw
-      private :name=, :raw=
-
-      def initialize(adapter_name, options = { })
-        super
-
-        self.name = options.delete(:name) or raise ArgumentError, "must provide name"
-        self.raw = options.delete(:raw) or raise ArgumentError, "must provide raw"
-      end
-
-      def to_s
-        name
-      end
-
-    private
-
-      def load
-        translate_raw_to_config(raw)
-      end
-
-      def save(config)
-        raise Error, "nonsense!"
-      end
-
-    end
-  end
-end

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

@@ -1,149 +0,0 @@
-require "librarian/error"
-
-module Librarian
-  module Config
-    class Source
-
-      RAW_KEY_SUFFIX_VALIDITY_PATTERN =
-        /\A[A-Z0-9_]+\z/
-      CONFIG_KEY_VALIDITY_PATTERN =
-        /\A[a-z][a-z0-9\-]+(?:\.[a-z0-9\-]+)*\z/
-
-      class << self
-        def raw_key_suffix_validity_pattern
-          RAW_KEY_SUFFIX_VALIDITY_PATTERN
-        end
-        def config_key_validity_pattern
-          CONFIG_KEY_VALIDITY_PATTERN
-        end
-      end
-
-      attr_accessor :adapter_name
-      private :adapter_name=
-
-      def initialize(adapter_name, options = { })
-        self.adapter_name = adapter_name
-
-        self.forbidden_keys = options.delete(:forbidden_keys) || []
-      end
-
-      def [](key)
-        load!
-
-        data[key]
-      end
-
-      def []=(key, value)
-        key_permitted?(key) or raise Error, "key not permitted: #{key.inspect}"
-        value_permitted?(key, value) or raise Error, "value for key #{key.inspect} not permitted: #{value.inspect}"
-
-        load!
-        if value.nil?
-          data.delete(key)
-        else
-          data[key] = value
-        end
-        save(data)
-      end
-
-      def keys
-        load!
-
-        data.keys
-      end
-
-    private
-
-      attr_accessor :data, :forbidden_keys
-
-      def load!
-        self.data = load unless data
-      end
-
-      def key_permitted?(key)
-        String === key &&
-        config_key_validity_pattern === key &&
-        !forbidden_keys.any?{|k| k === key}
-      end
-
-      def value_permitted?(key, value)
-        return true if value.nil?
-
-        String === value
-      end
-
-      def raw_key_valid?(key)
-        return false unless key.start_with?(raw_key_prefix)
-
-        suffix = key[raw_key_prefix.size..-1]
-        raw_key_suffix_validity_pattern =~ suffix
-      end
-
-      def raw_key_suffix_validity_pattern
-        self.class.raw_key_suffix_validity_pattern
-      end
-
-      def config_key_valid?(key)
-        config_key_validity_pattern === key
-      end
-
-      def config_key_validity_pattern
-        self.class.config_key_validity_pattern
-      end
-
-      def raw_key_prefix
-        @key_prefix ||= "LIBRARIAN_#{adapter_name.upcase}_"
-      end
-
-      def assert_raw_keys_valid!(raw)
-        bad_keys = raw.keys.reject{|k| raw_key_valid?(k)}
-        unless bad_keys.empty?
-          config_path_s = config_path.to_s.inspect
-          bad_keys_s = bad_keys.map(&:inspect).join(", ")
-          raise Error, "config #{to_s} has bad keys: #{bad_keys_s}"
-        end
-      end
-
-      def assert_config_keys_valid!(config)
-        bad_keys = config.keys.reject{|k| config_key_valid?(k)}
-        unless bad_keys.empty?
-          bad_keys_s = bad_keys.map(&:inspect).join(", ")
-          raise Error, "config has bad keys: #{bad_keys_s}"
-        end
-      end
-
-      def assert_values_valid!(data)
-        bad_data = data.reject{|k, v| String === v}
-        bad_keys = bad_data.keys
-
-        unless bad_keys.empty?
-          bad_keys_s = bad_keys.map(&:inspect).join(", ")
-          raise Error, "config has bad values for keys: #{bad_keys_s}"
-        end
-      end
-
-      def translate_raw_to_config(raw)
-        assert_raw_keys_valid!(raw)
-        assert_values_valid!(raw)
-
-        Hash[raw.map do |key, value|
-          key = key[raw_key_prefix.size .. -1]
-          key = key.downcase.gsub(/__/, ".").gsub(/_/, "-")
-          [key, value]
-        end]
-      end
-
-      def translate_config_to_raw(config)
-        assert_config_keys_valid!(config)
-        assert_values_valid!(config)
-
-        Hash[config.map do |key, value|
-          key = key.gsub(/\./, "__").gsub(/\-/, "_").upcase
-          key = "#{raw_key_prefix}#{key}"
-          [key, value]
-        end]
-      end
-
-    end
-  end
-end

data/vendor/librarian/lib/librarian/dependency.rb

@@ -1,91 +0,0 @@
-require 'rubygems'
-
-module Librarian
-  class Dependency
-
-    class Requirement
-      def initialize(*args)
-        args = initialize_normalize_args(args)
-
-        self.backing = Gem::Requirement.create(*args)
-      end
-
-      def to_gem_requirement
-        backing
-      end
-
-      def satisfied_by?(version)
-        to_gem_requirement.satisfied_by?(version.to_gem_version)
-      end
-
-      def ==(other)
-        to_gem_requirement == other.to_gem_requirement
-      end
-
-      def to_s
-        to_gem_requirement.to_s
-      end
-
-      protected
-
-      attr_accessor :backing
-
-      private
-
-      def initialize_normalize_args(args)
-        args.map do |arg|
-          arg = arg.backing if self.class === arg
-          arg
-        end
-      end
-    end
-
-    attr_accessor :name, :requirement, :source
-    private :name=, :requirement=, :source=
-
-    def initialize(name, requirement, source)
-      assert_name_valid! name
-
-      self.name = name
-      self.requirement = Requirement.new(requirement)
-      self.source = source
-
-      @manifests = nil
-    end
-
-    def manifests
-      @manifests ||= cache_manifests!
-    end
-
-    def cache_manifests!
-      source.manifests(name)
-    end
-
-    def satisfied_by?(manifest)
-      manifest.satisfies?(self)
-    end
-
-    def to_s
-      "#{name} (#{requirement}) <#{source}>"
-    end
-
-    def ==(other)
-      !other.nil? &&
-      self.class        == other.class        &&
-      self.name         == other.name         &&
-      self.requirement  == other.requirement  &&
-      self.source       == other.source
-    end
-
-  private
-
-    def environment
-      source.environment
-    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/dsl.rb

@@ -1,108 +0,0 @@
-require 'librarian/dependency'
-require 'librarian/dsl/receiver'
-require 'librarian/dsl/target'
-
-module Librarian
-  class Dsl
-
-    class Error < Exception
-    end
-
-    attr_accessor :environment
-    private :environment=
-
-    class << self
-
-      def run(environment, specfile = nil, precache_sources = [], &block)
-        new(environment).run(specfile, precache_sources, &block)
-      end
-
-    private
-
-      def dependency(name)
-        dependency_name = name
-        dependency_type = Dependency
-        singleton_class = class << self; self end
-        singleton_class.instance_eval do
-          define_method(:dependency_name) { dependency_name }
-          define_method(:dependency_type) { dependency_type }
-        end
-      end
-
-      define_method(:source_types) { [] }
-
-      def source(options)
-        name = options.keys.first
-        type = options[name]
-        types = source_types
-        types << [name, type]
-        singleton_class = class << self; self end
-        singleton_class.instance_eval do
-          define_method(:source_types) { types }
-        end
-      end
-
-      define_method(:source_shortcuts) { {} }
-
-      def shortcut(name, options)
-        instances = source_shortcuts
-        instances[name] = options
-        singleton_class = class << self; self end
-        singleton_class.instance_eval do
-          define_method(:source_shortcuts) { instances }
-        end
-      end
-
-      def delegate_to_class(*names)
-        names.each do |name|
-          define_method(name) { self.class.send(name) }
-        end
-      end
-
-    end
-
-    delegate_to_class :dependency_name, :dependency_type, :source_types, :source_shortcuts
-
-    def initialize(environment)
-      self.environment = environment
-    end
-
-    def run(specfile = nil, sources = [])
-      Target.new(self).tap do |target|
-        target.precache_sources(sources)
-        debug_named_source_cache("Pre-Cached Sources", target)
-
-        receiver = Receiver.new(target)
-        if block_given?
-          receiver.run(&Proc.new)
-        else
-          case specfile
-          when Specfile, String, Proc
-            receiver.run(specfile)
-          else
-            raise ArgumentError, "specfile must be a #{Specfile}, #{String}, or #{Proc} if no block is given (it was #{specfile.inspect})"
-          end
-        end
-
-        debug_named_source_cache("Post-Cached Sources", target)
-      end.to_spec
-    end
-
-    def debug_named_source_cache(name, target)
-      source_cache = target.source_cache
-      debug { "#{name}:" }
-      source_cache.each do |key, value|
-        type = key[0]
-        attributes = key[1...key.size]
-        debug { "  #{key.inspect}" }
-      end
-    end
-
-  private
-
-    def debug(*args, &block)
-      environment.logger.debug(*args, &block)
-    end
-
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'librarian/specfile'
-
-module Librarian
-  class Dsl
-    class Receiver
-
-      def initialize(target)
-        singleton_class = class << self; self end
-        singleton_class.class_eval do
-          define_method(target.dependency_name) do |*args, &block|
-            target.dependency(*args, &block)
-          end
-          define_method(:source) do |*args, &block|
-            target.source(*args, &block)
-          end
-          target.source_types.each do |source_type|
-            name = source_type[0]
-            define_method(name) do |*args, &block|
-              target.source(name, *args, &block)
-            end
-          end
-        end
-      end
-
-      def run(specfile = nil)
-        if block_given?
-          instance_eval(&Proc.new)
-        else
-          case specfile
-          when Specfile
-            eval(specfile.path.read, instance_binding, specfile.path.to_s, 1)
-          when String
-            eval(specfile, instance_binding)
-          when Proc
-            instance_eval(&specfile)
-          else
-            raise ArgumentError, "specfile must be a #{Specfile}, #{String}, or #{Proc} if no block is given (it was #{specfile.inspect})"
-          end
-        end
-      end
-
-      def instance_binding
-        binding
-      end
-
-    end
-  end
-end