librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

data/vendor/librarian/lib/librarian/chef/templates/Cheffile

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-#^syntax detection
-
-site 'http://community.opscode.com/api/v1'
-
-# cookbook 'chef-client'
-
-# cookbook 'apache2', '>= 1.0.0'
-
-# cookbook 'rvm',
-#   :git => 'https://github.com/fnichol/chef-rvm'
-
-# cookbook 'postgresql',
-#   :git => 'https://github.com/findsyou/cookbooks',
-#   :ref => 'postgresql-improvements'

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

@@ -1,205 +0,0 @@
-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
-
-    include Particularity
-    extend Particularity
-
-    class << self
-      def bin!
-        begin
-          environment = root_module.environment
-          start
-        rescue Librarian::Error => e
-          environment.ui.error e.message
-          environment.ui.debug e.backtrace.join("\n")
-          exit (e.respond_to?(:status_code) ? e.status_code : 1)
-        rescue Interrupt => e
-          environment.ui.error "\nQuitting..."
-          exit 1
-        end
-      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-#{root_module.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"]
-          raise Error, "must set either global or local" unless options["global"] ^ options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
-          environment.config_db[key, scope] = nil
-        elsif value
-          raise Error, "must set either global or local" unless options["global"] ^ options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
-          environment.config_db[key, scope] = value
-        else
-          raise Error, "cannot set both global and local" if options["global"] && options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
-          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
-      resolution.manifests.sort_by(&:name).each do |manifest|
-        source = manifest.source
-        source_manifest = source.manifests(manifest.name).first
-        next if manifest.version == source_manifest.version
-        say "#{manifest.name} (#{manifest.version} -> #{source_manifest.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
-      root_module.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
-
-  end
-end

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

@@ -1,79 +0,0 @@
-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?
-
-        if names.empty?
-          names = manifests.map(&:name).sort if names.empty?
-        else
-          missing_names = names.reject{|name| manifest(name)}
-          unless missing_names.empty?
-            raise Error, "not found: #{missing_names.map(&:inspect).join(', ')}"
-          end
-        end
-
-        names.each do |name|
-          manifest = manifest(name)
-          present_one(manifest, :detailed => full)
-        end
-      end
-
-      def present_one(manifest, options = { })
-        full = options[:detailed]
-
-        say "#{manifest.name} (#{manifest.version})" do
-          if full
-            say "source: #{manifest.source}"
-            unless manifest.dependencies.empty?
-              say "dependencies:" do
-                manifest.dependencies.sort_by(&:name).each do |dependency|
-                  say "#{dependency.name} (#{dependency.requirement})"
-                end
-              end
-            end
-          end
-        end
-      end
-
-      private
-
-      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
-
-    end
-  end
-end

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

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

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

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