librarian-puppet-lmco 0.9.8.2

data/vendor/librarian/lib/librarian/cli.rb

@@ -0,0 +1,223 @@
+require 'thor'
+require 'thor/actions'
+
+require 'librarian'
+require 'librarian/error'
+require 'librarian/action'
+require "librarian/ui"
+
+module Librarian
+  class Cli < Thor
+
+    autoload :ManifestPresenter, "librarian/cli/manifest_presenter"
+
+    include Thor::Actions
+
+    module Particularity
+      def root_module
+        nil
+      end
+    end
+
+    extend Particularity
+
+    class << self
+      def bin!
+        status = with_environment { returning_status { start } }
+        exit status
+      end
+
+      def returning_status
+        yield
+        0
+      rescue Librarian::Error => e
+        environment.ui.error e.message
+        environment.ui.debug e.backtrace.join("\n")
+        e.respond_to?(:status_code) && e.status_code || 1
+      rescue Interrupt => e
+        environment.ui.error "\nQuitting..."
+        1
+      end
+
+      attr_accessor :environment
+
+      def with_environment
+        environment = root_module.environment_class.new
+        self.environment, orig_environment = environment, self.environment
+        yield(environment)
+      ensure
+        self.environment = orig_environment
+      end
+    end
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
+      environment.ui = UI::Shell.new(the_shell)
+      environment.ui.be_quiet! if options["quiet"]
+      environment.ui.debug! if options["verbose"]
+      environment.ui.debug_line_numbers! if options["verbose"] && options["line-numbers"]
+
+      write_debug_header
+    end
+
+    desc "version", "Displays the version."
+    def version
+      say "librarian-#{environment.version}"
+    end
+
+    desc "config", "Show or edit the config."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    option "global", :type => :boolean, :default => false
+    option "local", :type => :boolean, :default => false
+    option "delete", :type => :boolean, :default => false
+    def config(key = nil, value = nil)
+      if key
+        raise Error, "cannot set both value and delete" if value && options["delete"]
+        if options["delete"]
+          scope = config_scope(true)
+          environment.config_db[key, scope] = nil
+        elsif value
+          scope = config_scope(true)
+          environment.config_db[key, scope] = value
+        else
+          scope = config_scope(false)
+          if value = environment.config_db[key, scope]
+            prefix = scope ? "#{key} (#{scope})" : key
+            say "#{prefix}: #{value}"
+          end
+        end
+      else
+        environment.config_db.keys.each do |key|
+          say "#{key}: #{environment.config_db[key]}"
+        end
+      end
+    end
+
+    desc "clean", "Cleans out the cache and install paths."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def clean
+      ensure!
+      clean!
+    end
+
+    desc "update", "Updates and installs the dependencies you specify."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def update(*names)
+      ensure!
+      if names.empty?
+        resolve!(:force => true)
+      else
+        update!(:names => names)
+      end
+      install!
+    end
+
+    desc "outdated", "Lists outdated dependencies."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def outdated
+      ensure!
+      resolution = environment.lock
+      manifests = resolution.manifests.sort_by(&:name)
+      manifests.select(&:outdated?).each do |manifest|
+        say "#{manifest.name} (#{manifest.version} -> #{manifest.latest.version})"
+      end
+    end
+
+    desc "show", "Shows dependencies"
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    option "detailed", :type => :boolean
+    def show(*names)
+      ensure!
+      if environment.lockfile_path.file?
+        manifest_presenter.present(names, :detailed => options["detailed"])
+      else
+        raise Error, "Be sure to install first!"
+      end
+    end
+
+    desc "init", "Initializes the current directory."
+    def init
+      puts "Nothing to do."
+    end
+
+  private
+
+    def environment
+      self.class.environment
+    end
+
+    def ensure!(options = { })
+      Action::Ensure.new(environment, options).run
+    end
+
+    def clean!(options = { })
+      Action::Clean.new(environment, options).run
+    end
+
+    def install!(options = { })
+      Action::Install.new(environment, options).run
+    end
+
+    def resolve!(options = { })
+      Action::Resolve.new(environment, options).run
+    end
+
+    def update!(options = { })
+      Action::Update.new(environment, options).run
+    end
+
+    def manifest_presenter
+      ManifestPresenter.new(self, environment.lock.manifests)
+    end
+
+    def write_debug_header
+      debug { "Ruby Version: #{RUBY_VERSION}" }
+      debug { "Ruby Platform: #{RUBY_PLATFORM}" }
+      debug { "Rubinius Version: #{Rubinius::VERSION}" } if defined?(Rubinius)
+      debug { "JRuby Version: #{JRUBY_VERSION}" } if defined?(JRUBY_VERSION)
+      debug { "Rubygems Version: #{Gem::VERSION}" }
+      debug { "Librarian Version: #{VERSION}" }
+      debug { "Librarian Adapter: #{environment.adapter_name}"}
+      debug { "Project: #{environment.project_path}" }
+      debug { "Specfile: #{relative_path_to(environment.specfile_path)}" }
+      debug { "Lockfile: #{relative_path_to(environment.lockfile_path)}" }
+      debug { "Git: #{Source::Git::Repository.bin}" }
+      debug { "Git Version: #{Source::Git::Repository.new(environment, environment.project_path).version(:silent => true)}" }
+      debug { "Git Environment Variables:" }
+      git_env = ENV.to_a.select{|(k, v)| k =~ /\AGIT/}.sort_by{|(k, v)| k}
+      if git_env.empty?
+        debug { "  (empty)" }
+      else
+        git_env.each do |(k, v)|
+          debug { "  #{k}=#{v}"}
+        end
+      end
+    end
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+    def relative_path_to(path)
+      environment.logger.relative_path_to(path)
+    end
+
+    def config_scope(exclusive)
+      g, l = "global", "local"
+      if exclusive
+        options[g] ^ options[l] or raise Error, "must set either #{g} or #{l}"
+      else
+        options[g] && options[l] and raise Error, "cannot set both #{g} and #{l}"
+      end
+
+      options[g] ? :global : options[l] ? :local : nil
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/cli/manifest_presenter.rb

@@ -0,0 +1,93 @@
+module Librarian
+  class Cli
+    class ManifestPresenter
+
+      attr_accessor :cli, :manifests
+      private :cli=, :manifests=
+
+      def initialize(cli, manifests)
+        self.cli = cli or raise ArgumentError, "cli required"
+        self.manifests = manifests or raise ArgumentError, "manifests required"
+        self.manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+
+        self.scope_level = 0
+      end
+
+      def present(names = [], options = { })
+        full = options[:detailed]
+        full = !names.empty? if full.nil?
+
+        names = manifests.map(&:name).sort if names.empty?
+        assert_no_manifests_missing!(names)
+
+        present_each(names, :detailed => full)
+      end
+
+      def present_one(manifest, options = { })
+        full = options[:detailed]
+
+        say "#{manifest.name} (#{manifest.version})" do
+          full or next
+
+          present_one_source(manifest)
+          present_one_dependencies(manifest)
+        end
+      end
+
+      private
+
+      def present_each(names, options)
+        names.each do |name|
+          manifest = manifest(name)
+          present_one(manifest, options)
+        end
+      end
+
+      def present_one_source(manifest)
+        say "source: #{manifest.source}"
+      end
+
+      def present_one_dependencies(manifest)
+        manifest.dependencies.empty? and return
+
+        say "dependencies:" do
+          deps = manifest.dependencies.sort_by(&:name)
+          deps.each do |dependency|
+            say "#{dependency.name} (#{dependency.requirement})"
+          end
+        end
+      end
+
+      attr_accessor :scope_level, :manifests_index
+
+      def manifest(name)
+        manifests_index[name]
+      end
+
+      def say(string)
+        cli.say "  " * scope_level << string
+        if block_given?
+          scope do
+            yield
+          end
+        end
+      end
+
+      def scope
+        original_scope_level = scope_level
+        self.scope_level = scope_level + 1
+        yield
+      ensure
+        self.scope_level = original_scope_level
+      end
+
+      def assert_no_manifests_missing!(names)
+        missing_names = names.reject{|name| manifest(name)}
+        unless missing_names.empty?
+          raise Error, "not found: #{missing_names.map(&:inspect).join(', ')}"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require "librarian/config/database"
+
+module Librarian
+  module Config
+
+  end
+end

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

@@ -0,0 +1,205 @@
+require "pathname"
+
+require "librarian/config/file_source"
+require "librarian/config/hash_source"
+
+module Librarian
+  module Config
+    class Database
+
+      class << self
+        def library
+          name.split("::").first.downcase
+        end
+      end
+
+      attr_accessor :adapter_name
+      private :adapter_name=
+
+      attr_accessor :root, :assigned_specfile_name
+      private :root=, :assigned_specfile_name=
+
+      attr_accessor :underlying_env, :underlying_pwd, :underlying_home
+      private :underlying_env=, :underlying_pwd=, :underlying_home=
+
+      def initialize(adapter_name, options = { })
+        self.adapter_name = adapter_name or raise ArgumentError, "must provide adapter_name"
+
+        options[:project_path] || options[:pwd] or raise ArgumentError, "must provide project_path or pwd"
+
+        self.root = options[:project_path] && Pathname(options[:project_path])
+        self.assigned_specfile_name = options[:specfile_name]
+        self.underlying_env = options[:env] or raise ArgumentError, "must provide env"
+        self.underlying_pwd = options[:pwd] && Pathname(options[:pwd])
+        self.underlying_home = options[:home] && Pathname(options[:home])
+      end
+
+      def global
+        memo(__method__) { new_file_source(global_config_path) }
+      end
+
+      def env
+        memo(__method__) { HashSource.new(adapter_name, :name => "environment", :raw => env_source_data) }
+      end
+
+      def local
+        memo(__method__) { new_file_source(local_config_path) }
+      end
+
+      def [](key, scope = nil)
+        case scope
+        when "local", :local then local[key]
+        when "env", :env then env[key]
+        when "global", :global then global[key]
+        when nil then local[key] || env[key] || global[key]
+        else raise Error, "bad scope"
+        end
+      end
+
+      def []=(key, scope, value)
+        case scope
+        when "local", :local then local[key] = value
+        when "global", :global then global[key] = value
+        else raise Error, "bad scope"
+        end
+      end
+
+      def keys
+        [local, env, global].inject([]){|a, e| a.concat(e.keys) ; a}.sort.uniq
+      end
+
+      def project_path
+        root || specfile_path.dirname
+      end
+
+      def specfile_path
+        if root
+          root + (assigned_specfile_name || default_specfile_name)
+        else
+          env_specfile_path || default_specfile_path
+        end
+      end
+
+      def specfile_name
+        specfile_path.basename.to_s
+      end
+
+      def lockfile_path
+        project_path + lockfile_name
+      end
+
+      def lockfile_name
+        "#{specfile_name}.lock"
+      end
+
+    private
+
+      def new_file_source(config_path)
+        return unless config_path
+
+        FileSource.new(adapter_name,
+          :config_path => config_path,
+          :forbidden_keys => [config_key, specfile_key]
+        )
+      end
+
+      def global_config_path
+        env_global_config_path || default_global_config_path
+      end
+
+      def env_global_config_path
+        memo(__method__) { env[config_key] }
+      end
+
+      def default_global_config_path
+        underlying_home && underlying_home + config_name
+      end
+
+      def local_config_path
+        root_local_config_path || env_local_config_path || default_local_config_path
+      end
+
+      def root_local_config_path
+        root && root + config_name
+      end
+
+      def env_specfile_path
+        memo(__method__) do
+          path = env[specfile_key]
+          path && Pathname(path)
+        end
+      end
+
+      def default_specfile_path
+        default_project_root_path + (assigned_specfile_name || default_specfile_name)
+      end
+
+      def env_local_config_path
+        return unless env_specfile_path
+
+        env_specfile_path.dirname + config_name
+      end
+
+      def default_local_config_path
+        default_project_root_path + config_name
+      end
+
+      def default_project_root_path
+        if root
+          root
+        else
+          path = underlying_pwd
+          path = path.dirname until project_root_path?(path) || path.dirname == path
+          project_root_path?(path) ? path : underlying_pwd
+        end
+      end
+
+      def project_root_path?(path)
+        File.file?(path + default_specfile_name)
+      end
+
+      def config_key
+        "config"
+      end
+
+      def specfile_key
+        "#{adapter_name}file"
+      end
+
+      def default_specfile_name
+        "#{adapter_name.capitalize}file"
+      end
+
+      def library
+        self.class.library
+      end
+
+      def config_name_prefix
+        ".#{library}"
+      end
+
+      def config_name
+        File.join(*[config_name_prefix, adapter_name, "config"])
+      end
+
+      def raw_key_prefix
+        "#{library.upcase}_#{adapter_name.upcase}_"
+      end
+
+      def env_source_data
+        prefix = raw_key_prefix
+
+        data = underlying_env.dup
+        data.reject!{|k, _| !k.start_with?(prefix) || k.size <= prefix.size}
+        data
+      end
+
+      def memo(key)
+        key = "@#{key}"
+        instance_variable_set(key, yield) unless instance_variable_defined?(key)
+        instance_variable_get(key)
+      end
+
+    end
+  end
+end