librarian-puppet 0.0.1.pre

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

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

@@ -0,0 +1,176 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/spec'
+
+module Librarian
+  class Dsl
+    class Target
+
+      include Helpers::Debug
+
+      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 = [: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.first, @dependencies)
+      end
+
+      def dependency(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source = source_from_options(options) || @sources.last
+        unless source
+          raise Error, "#{dependency_name} #{name} is specified without a source!"
+        end
+        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
+            @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
+            @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,129 @@
+require "pathname"
+
+require "librarian/helpers/debug"
+require "librarian/support/abstract_method"
+
+require "librarian/error"
+require "librarian/lockfile"
+require "librarian/specfile"
+require "librarian/resolver"
+require "librarian/dsl"
+require "librarian/source"
+
+module Librarian
+  class Environment
+
+    include Support::AbstractMethod
+    include Helpers::Debug
+
+    attr_accessor :ui
+
+    abstract_method :specfile_name, :dsl_class, :install_path
+
+    def initialize(options = { })
+      @project_path = options[:project_path]
+      @specfile_name = options[:specfile_name]
+    end
+
+    def project_path
+      @project_path ||= begin
+        root = Pathname.new(Dir.pwd)
+        root = root.dirname until project_path?(root)
+        path = root.join(specfile_name)
+        path.file? ? root : nil
+      end
+    end
+
+    def project_path?(path)
+      path.join(config_name).directory? ||
+      path.join(specfile_name).file? ||
+      path.dirname == path
+    end
+
+    def default_specfile_name
+      @default_specfile_name ||= begin
+        capped = adapter_name.capitalize
+        "#{capped}file"
+      end
+    end
+
+    def specfile_name
+      @specfile_name ||= default_specfile_name
+    end
+
+    def specfile_path
+      project_path.join(specfile_name)
+    end
+
+    def specfile
+      Specfile.new(self, specfile_path)
+    end
+
+    def adapter_name
+      nil
+    end
+
+    def config_name
+      File.join(*[config_prefix, adapter_name].compact)
+    end
+
+    def config_prefix
+      ".librarian"
+    end
+
+    def lockfile_name
+      "#{specfile_name}.lock"
+    end
+
+    def lockfile_path
+      project_path.join(lockfile_name)
+    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
+
+  private
+
+    def environment
+      self
+    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/helpers/debug.rb

@@ -0,0 +1,35 @@
+require 'librarian/support/abstract_method'
+
+module Librarian
+  module Helpers
+    module Debug
+
+      include Support::AbstractMethod
+
+      LIBRARIAN_PATH = Pathname.new('../../../../').expand_path(__FILE__)
+
+      abstract_method :environment
+
+    private
+
+      def relative_path_to(path)
+        environment.project_relative_path_to(path)
+      end
+
+      def debug
+        if ui = environment.ui
+          if ui.respond_to? :debug_line_numbers and ui.debug_line_numbers
+            loc = caller.find{|l| !(l =~ /in `debug'$/)}
+            if loc =~ /^(.+):(\d+):in `(.+)'$/
+              loc = "#{Pathname.new($1).relative_path_from(LIBRARIAN_PATH)}:#{$2}:in `#{$3}'"
+            end
+            ui.debug { "[Librarian] #{yield} [#{loc}]" }
+          else
+            ui.debug { "[Librarian] #{yield}" }
+          end
+        end
+      end
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/lockfile.rb

@@ -0,0 +1,33 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/lockfile/compiler'
+require 'librarian/lockfile/parser'
+
+module Librarian
+  class Lockfile
+
+    include Helpers::Debug
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :path
+
+    def initialize(environment, path)
+      self.environment = environment
+      @path = path
+    end
+
+    def save(resolution)
+      Compiler.new(environment).compile(resolution)
+    end
+
+    def load(string)
+      Parser.new(environment).parse(string)
+    end
+
+    def read
+      load(path.read)
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/lockfile/compiler.rb

@@ -0,0 +1,70 @@
+require 'librarian/helpers/debug'
+
+module Librarian
+  class Lockfile
+    class Compiler
+
+      include Helpers::Debug
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def compile(resolution)
+        out = StringIO.new
+        save_sources(out, resolution.manifests)
+        save_dependencies(out, resolution.dependencies)
+        out.string
+      end
+
+    private
+
+      def save_sources(out, manifests)
+        dsl_class.source_types.map{|t| t[1]}.each do |type|
+          type_manifests = manifests.select{|m| type === m.source}
+          sources = type_manifests.map{|m| m.source}.uniq.sort_by{|s| s.to_s}
+          sources.each do |source|
+            source_manifests = type_manifests.select{|m| source == m.source}
+            save_source(out, source, source_manifests)
+          end
+        end
+      end
+
+      def save_source(out, source, manifests)
+        out.puts "#{source.class.lock_name}"
+        options = source.to_lock_options
+        remote = options.delete(:remote)
+        out.puts "  remote: #{remote}"
+        options.to_a.sort_by{|a| a[0].to_s}.each do |o|
+          out.puts "  #{o[0]}: #{o[1]}"
+        end
+        out.puts "  specs:"
+        manifests.sort_by{|a| a.name}.each do |manifest|
+          out.puts "    #{manifest.name} (#{manifest.version})"
+          manifest.dependencies.sort_by{|a| a.name}.each do |dependency|
+            out.puts "      #{dependency.name} (#{dependency.requirement})"
+          end
+        end
+        out.puts ""
+      end
+
+      def save_dependencies(out, dependencies)
+        out.puts "DEPENDENCIES"
+        dependencies.sort_by{|a| a.name}.each do |d|
+          res = "#{d.name}"
+          res << " (#{d.requirement})" if d.requirement
+          out.puts "  #{res}"
+        end
+        out.puts ""
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+    end
+  end
+end