librarian-puppet-lmco 0.9.8.2

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

@@ -0,0 +1,46 @@
+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)
+        specfile = Proc.new if block_given?
+
+        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
+
+      def instance_binding
+        binding
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+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 = [:source, :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, @dependencies)
+      end
+
+      def dependency(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source = source_from_options(options) || @source
+        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
+            @source = source
+            @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
+            @source = source
+            @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,182 @@
+require "pathname"
+require 'net/http'
+require "uri"
+
+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 version
+      VERSION
+    end
+
+    def config_keys
+      %[
+      ]
+    end
+
+    # The HTTP proxy specified in the environment variables:
+    # * HTTP_PROXY
+    # * HTTP_PROXY_USER
+    # * HTTP_PROXY_PASS
+    # Adapted from:
+    #   https://github.com/rubygems/rubygems/blob/v1.8.24/lib/rubygems/remote_fetcher.rb#L276-293
+    def http_proxy_uri
+      @http_proxy_uri ||= begin
+        keys = %w( HTTP_PROXY HTTP_PROXY_USER HTTP_PROXY_PASS )
+        env = Hash[ENV.
+          map{|k, v| [k.upcase, v]}.
+          select{|k, v| keys.include?(k)}.
+          reject{|k, v| v.nil? || v.empty?}]
+
+        uri = env["HTTP_PROXY"] or return
+        uri = "http://#{uri}" unless uri =~ /^(https?|ftp|file):/
+        uri = URI.parse(uri)
+        uri.user ||= env["HTTP_PROXY_USER"]
+        uri.password ||= env["HTTP_PROXY_PASS"]
+        uri
+      end
+    end
+
+    def net_http_class(host)
+      return Net::HTTP if no_proxy?(host)
+
+      @net_http_class ||= begin
+        p = http_proxy_uri
+        p ? Net::HTTP::Proxy(p.host, p.port, p.user, p.password) : Net::HTTP
+      end
+    end
+
+  private
+
+    def environment
+      self
+    end
+
+    def no_proxy?(host)
+      @no_proxy ||= begin
+        list = ENV['NO_PROXY'] || ENV['no_proxy'] || ""
+        list.split(/\s*,\s*/) + %w(localhost 127.0.0.1)
+      end
+      @no_proxy.any? do |host_addr|
+        host.match(Regexp.quote(host_addr)+'$')
+      end
+    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/linter/source_linter.rb

@@ -0,0 +1,55 @@
+module Librarian
+  module Linter
+    class SourceLinter
+
+      class << self
+        def lint!(klass)
+          new(klass).lint!
+        end
+      end
+
+      attr_accessor :klass
+      private :klass=
+
+      def initialize(klass)
+        self.klass = klass
+      end
+
+      def lint!
+        lint_class_responds_to! *[
+          :lock_name,
+          :from_spec_args,
+          :from_lock_options,
+        ]
+
+        lint_instance_responds_to! *[
+          :to_spec_args,
+          :to_lock_options,
+          :manifests,
+          :fetch_version,
+          :fetch_dependencies,
+          :pinned?,
+          :unpin!,
+          :install!,
+        ]
+      end
+
+    private
+
+      def lint_class_responds_to!(*names)
+        missing = names.reject{|name| klass.respond_to?(name)}
+        return if missing.empty?
+
+        raise "class must respond to #{missing.join(', ')}"
+      end
+
+      def lint_instance_responds_to!(*names)
+        missing = names - klass.public_instance_methods.map(&:to_sym)
+        return if missing.empty?
+
+        raise "instance must respond to #{missing.join(', ')}"
+      end
+
+    end
+  end
+end