librarian-puppet 0.0.1.pre

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

@@ -0,0 +1,15 @@
+#!/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

@@ -0,0 +1,175 @@
+require 'thor'
+require 'thor/actions'
+
+require 'librarian'
+require 'librarian/error'
+require 'librarian/action'
+require "librarian/ui"
+
+require "librarian/helpers/debug"
+
+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
+
+    include Helpers::Debug
+
+    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.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 "clean", "Cleans out the cache and install paths."
+    option "verbose"
+    option "line-numbers"
+    def clean
+      ensure!
+      clean!
+    end
+
+    desc "install", "Resolves and installs all of the dependencies you specify."
+    option "verbose"
+    option "line-numbers"
+    option "clean"
+    def install
+      ensure!
+      clean! if options["clean"]
+      resolve!
+      install!
+    end
+
+    desc "update", "Updates and installs the dependencies you specify."
+    option "verbose"
+    option "line-numbers"
+    def update(*names)
+      ensure!
+      if names.empty?
+        resolve!(:force => true)
+      else
+        update!(:names => names)
+      end
+      install!
+    end
+
+    desc "outdated", "Lists outdated dependencies."
+    option "verbose"
+    option "line-numbers"
+    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"
+    option "line-numbers"
+    option "detailed", :type => :boolean
+    def show(*names)
+      ensure!
+      manifest_presenter.present(names, :detailed => options["detailed"])
+    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
+
+  end
+end

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

@@ -0,0 +1,79 @@
+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/dependency.rb

@@ -0,0 +1,95 @@
+require 'rubygems'
+
+require 'librarian/helpers/debug'
+
+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
+
+    include Helpers::Debug
+
+    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 =~ /^\S.*\S$/
+    end
+
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'librarian/dependency'
+require 'librarian/dsl/receiver'
+require 'librarian/dsl/target'
+require 'librarian/helpers/debug'
+
+module Librarian
+  class Dsl
+
+    include Helpers::Debug
+
+    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
+
+  end
+end