librarian-puppet-maestrodev 0.9.7

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

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

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

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

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

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

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