librarian 0.0.9 → 0.0.10

data/lib/librarian/error.rb

@@ -0,0 +1,4 @@
+module Librarian
+  class Error < StandardError
+  end
+end

data/lib/librarian/helpers/debug.rb

@@ -8,24 +8,24 @@ module Librarian
 
       LIBRARIAN_PATH = Pathname.new('../../../../').expand_path(__FILE__)
 
-      abstract_method :root_module
+      abstract_method :environment
 
     private
 
       def relative_path_to(path)
-        root_module.project_relative_path_to(path)
+        environment.project_relative_path_to(path)
       end
 
       def debug
-        if root_module.ui
-          if root_module.ui.respond_to? :debug_line_numbers and root_module.ui.debug_line_numbers
+        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
-            root_module.ui.debug { "[Librarian] #{yield} [#{loc}]" }
+            ui.debug { "[Librarian] #{yield} [#{loc}]" }
           else
-            root_module.ui.debug { "[Librarian] #{yield}" }
+            ui.debug { "[Librarian] #{yield}" }
           end
         end
       end

data/lib/librarian/lockfile.rb

@@ -8,19 +8,21 @@ module Librarian
 
     include Helpers::Debug
 
-    attr_reader :root_module, :path
+    attr_accessor :environment
+    private :environment=
+    attr_reader :path
 
-    def initialize(root_module, path)
-      @root_module = root_module
+    def initialize(environment, path)
+      self.environment = environment
       @path = path
     end
 
     def save(resolution)
-      Compiler.new(root_module).compile(resolution)
+      Compiler.new(environment).compile(resolution)
     end
 
     def load(string)
-      Parser.new(root_module).parse(string)
+      Parser.new(environment).parse(string)
     end
 
     def read

data/lib/librarian/lockfile/compiler.rb

@@ -6,10 +6,11 @@ module Librarian
 
       include Helpers::Debug
 
-      attr_reader :root_module
+      attr_accessor :environment
+      private :environment=
 
-      def initialize(root_module)
-        @root_module = root_module
+      def initialize(environment)
+        self.environment = environment
       end
 
       def compile(resolution)
@@ -61,7 +62,7 @@ module Librarian
       end
 
       def dsl_class
-        root_module.dsl_class
+        environment.dsl_class
       end
 
     end

data/lib/librarian/lockfile/parser.rb

@@ -17,10 +17,11 @@ module Librarian
 
       include Helpers::Debug
 
-      attr_reader :root_module
+      attr_accessor :environment
+      private :environment=
 
-      def initialize(root_module)
-        @root_module = root_module
+      def initialize(environment)
+        self.environment = environment
       end
 
       def parse(string)
@@ -71,7 +72,7 @@ module Librarian
         manifests = {}
         sources_ast.each do |source_ast|
           source_type = source_ast[:type]
-          source = source_type.from_lock_options(source_ast[:options])
+          source = source_type.from_lock_options(environment, source_ast[:options])
           source_ast[:manifests].each do |manifest_name, manifest_ast|
             manifests[manifest_name] = ManifestPlaceholder.new(
               source,
@@ -95,7 +96,7 @@ module Librarian
       end
 
       def dsl_class
-        root_module.dsl_class
+        environment.dsl_class
       end
 
     end

data/lib/librarian/manifest.rb

@@ -69,8 +69,8 @@ module Librarian
 
   private
 
-    def root_module
-      source.root_module
+    def environment
+      source.environment
     end
 
     def _normalize_version(version)

data/lib/librarian/mock/cli.rb

@@ -1,11 +1,16 @@
 require 'librarian/cli'
 require 'librarian/mock'
-require 'librarian/mock/particularity'
 
 module Librarian
   module Mock
     class Cli < Librarian::Cli
 
+      module Particularity
+        def root_module
+          Mock
+        end
+      end
+
       include Particularity
       extend Particularity
 

data/lib/librarian/mock/dsl.rb

@@ -1,13 +1,10 @@
 require 'librarian/dsl'
-require 'librarian/mock/particularity'
 require 'librarian/mock/source'
 
 module Librarian
   module Mock
     class Dsl < Librarian::Dsl
 
-      include Particularity
-
       dependency :dep
 
       source :src => Source::Mock

data/lib/librarian/mock/environment.rb

@@ -0,0 +1,24 @@
+require "librarian/environment"
+require "librarian/mock/dsl"
+
+module Librarian
+  module Mock
+    class Environment < Environment
+
+      def specfile_name
+        "Mockfile"
+      end
+
+      def install_path
+        nil
+      end
+
+      def registry(options = nil, &block)
+        @registry ||= Source::Mock::Registry.new
+        @registry.merge!(options, &block)
+        @registry
+      end
+    end
+
+  end
+end

data/lib/librarian/mock/extension.rb

@@ -1,28 +1,9 @@
-require 'librarian/specfile'
-require 'librarian/mock/dsl'
+require 'librarian/mock/environment'
 
 module Librarian
   module Mock
     extend self
     extend Librarian
 
-    module Overrides
-      def specfile_name
-        'Mockfile'
-      end
-
-      def install_path
-        nil
-      end
-
-      def registry(options = nil, &block)
-        registry = Source::Mock::Registry
-        registry.clear! if options && options[:clear]
-        registry.merge!(&block) if block
-        registry
-      end
-    end
-
-    extend Overrides
   end
 end

data/lib/librarian/mock/source/mock.rb

@@ -1,5 +1,4 @@
 require 'librarian/manifest'
-require 'librarian/mock/particularity'
 require 'librarian/mock/source/mock/registry'
 
 module Librarian
@@ -23,21 +22,22 @@ module Librarian
           end
         end
 
-        include Particularity
-
         class << self
           LOCK_NAME = 'MOCK'
           def lock_name
             LOCK_NAME
           end
-          def from_lock_options(options)
-            new(options[:remote], options.reject{|k, v| k == :remote})
+          def from_lock_options(environment, options)
+            new(environment, options[:remote], options.reject{|k, v| k == :remote})
           end
         end
 
+        attr_accessor :environment
+        private :environment=
         attr_reader :name
 
-        def initialize(name, options)
+        def initialize(environment, name, options)
+          self.environment = environment
           @name = name
         end
 
@@ -60,7 +60,7 @@ module Librarian
         end
 
         def registry
-          Registry[name]
+          environment.registry[name]
         end
 
         def manifest(name, version, dependencies)

data/lib/librarian/mock/source/mock/registry.rb

@@ -58,19 +58,23 @@ module Librarian
 
           end
 
-          class << self
-            def clear!
-              @sources = nil
-            end
-            def merge!(&block)
-              @sources ||= {}
-              Dsl.run!(@sources, &block) if block
-            end
-            def [](name)
-              @sources ||= {}
-              @sources[name] ||= {}
-            end
+          def initialize
+            clear!
+          end
+          def clear!
+            self.sources = { }
           end
+          def merge!(options = nil, &block)
+            clear! if options && options[:clear]
+            Dsl.run!(sources, &block) if block
+          end
+          def [](name)
+            sources[name] ||= {}
+          end
+
+        private
+
+          attr_accessor :sources
 
         end
       end

data/lib/librarian/resolver.rb

@@ -1,126 +1,15 @@
-require 'librarian/helpers/debug'
-
-require 'librarian/dependency'
+require 'librarian/resolver/implementation'
 require 'librarian/manifest_set'
 require 'librarian/resolution'
 
 module Librarian
   class Resolver
 
-    class Implementation
-      include Helpers::Debug
-
-      attr_reader :resolver, :source, :dependency_source_map
-
-      def initialize(resolver, spec)
-        @resolver = resolver
-        @source = spec.source
-        @dependency_source_map = Hash[spec.dependencies.map{|d| [d.name, d.source]}]
-        @level = 0
-      end
-
-      def resolve(dependencies, manifests = {})
-        resolution = recursive_resolve([], manifests, dependencies.dup)
-        resolution ? resolution[1] : nil
-      end
-
-      def recursive_resolve(dependencies, manifests, queue)
-        if dependencies.empty?
-          queue.each do |dependency|
-            debug { "Scheduling #{dependency}" }
-          end
-        end
-        failure = false
-        until failure || queue.empty?
-          dependency = queue.shift
-          dependencies << dependency
-          debug { "Resolving #{dependency}" }
-          scope do
-            if manifests.key?(dependency.name)
-              unless dependency.satisfied_by?(manifests[dependency.name])
-                debug { "Conflicts with #{manifests[dependency.name]}" }
-                failure = true
-              else
-                debug { "Accords with all prior constraints" }
-                # nothing left to do
-              end
-            else
-              debug { "No known prior constraints" }
-              resolution = nil
-              related_dependencies = dependencies.select{|d| d.name == dependency.name}
-              unless dependency.manifests && dependency.manifests.first
-                debug { "No known manifests" }
-              else
-                debug { "Checking manifests" }
-                scope do
-                  dependency.manifests.each do |manifest|
-                    unless resolution
-                      debug { "Checking #{manifest}" }
-                      scope do
-                        if related_dependencies.all?{|d| d.satisfied_by?(manifest)}
-                          m = manifests.merge(dependency.name => manifest)
-                          a = manifest.dependencies.map { |d|
-                            d.source ? d :
-                            !dependency_source_map.key?(d.name) ?
-                            Dependency.new(d.name, d.requirement, source) :
-                            Dependency.new(d.name, d.requirement, dependency_source_map[d.name])
-                          }
-                          a.each do |d|
-                            debug { "Scheduling #{d}" }
-                          end
-                          q = queue + a
-                          resolution = recursive_resolve(dependencies.dup, m, q)
-                        end
-                        if resolution
-                          debug { "Resolved #{dependency} at #{manifest}" }
-                        else
-                          debug { "Backtracking from #{manifest}" }
-                        end
-                      end
-                    end
-                  end
-                end
-                if resolution
-                  debug { "Resolved #{dependency}" }
-                else
-                  debug { "Failed to resolve #{dependency}" }
-                end
-              end
-              unless resolution
-                failure = true
-              else
-                dependencies, manifests, queue = *resolution
-              end
-            end
-          end
-        end
-        failure ? nil : [dependencies, manifests, queue]
-      end
-
-    private
-
-      def scope
-        @level += 1
-        yield
-      ensure
-        @level -= 1
-      end
-
-      def debug
-        super { '  ' * @level + yield }
-      end
-
-      def root_module
-        resolver.root_module
-      end
-    end
-
-    include Helpers::Debug
-
-    attr_reader :root_module
+    attr_accessor :environment
+    private :environment=
 
-    def initialize(root_module)
-      @root_module = root_module
+    def initialize(environment)
+      self.environment = environment
     end
 
     def resolve(spec, partial_manifests = [])

data/lib/librarian/resolver/implementation.rb

@@ -0,0 +1,117 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/dependency'
+
+module Librarian
+  class Resolver
+    class Implementation
+
+      include Helpers::Debug
+
+      attr_reader :resolver, :source, :dependency_source_map
+
+      def initialize(resolver, spec)
+        @resolver = resolver
+        @source = spec.source
+        @dependency_source_map = Hash[spec.dependencies.map{|d| [d.name, d.source]}]
+        @level = 0
+      end
+
+      def resolve(dependencies, manifests = {})
+        resolution = recursive_resolve([], manifests, dependencies.dup)
+        resolution ? resolution[1] : nil
+      end
+
+      def recursive_resolve(dependencies, manifests, queue)
+        if dependencies.empty?
+          queue.each do |dependency|
+            debug { "Scheduling #{dependency}" }
+          end
+        end
+        failure = false
+        until failure || queue.empty?
+          dependency = queue.shift
+          dependencies << dependency
+          debug { "Resolving #{dependency}" }
+          scope do
+            if manifests.key?(dependency.name)
+              unless dependency.satisfied_by?(manifests[dependency.name])
+                debug { "Conflicts with #{manifests[dependency.name]}" }
+                failure = true
+              else
+                debug { "Accords with all prior constraints" }
+                # nothing left to do
+              end
+            else
+              debug { "No known prior constraints" }
+              resolution = nil
+              related_dependencies = dependencies.select{|d| d.name == dependency.name}
+              unless dependency.manifests && dependency.manifests.first
+                debug { "No known manifests" }
+              else
+                debug { "Checking manifests" }
+                scope do
+                  dependency.manifests.each do |manifest|
+                    unless resolution
+                      debug { "Checking #{manifest}" }
+                      scope do
+                        if related_dependencies.all?{|d| d.satisfied_by?(manifest)}
+                          m = manifests.merge(dependency.name => manifest)
+                          a = manifest.dependencies.map { |d|
+                            d.source ? d :
+                            !dependency_source_map.key?(d.name) ?
+                            Dependency.new(d.name, d.requirement, source) :
+                            Dependency.new(d.name, d.requirement, dependency_source_map[d.name])
+                          }
+                          a.each do |d|
+                            debug { "Scheduling #{d}" }
+                          end
+                          q = queue + a
+                          resolution = recursive_resolve(dependencies.dup, m, q)
+                        end
+                        if resolution
+                          debug { "Resolved #{dependency} at #{manifest}" }
+                        else
+                          debug { "Backtracking from #{manifest}" }
+                        end
+                      end
+                    end
+                  end
+                end
+                if resolution
+                  debug { "Resolved #{dependency}" }
+                else
+                  debug { "Failed to resolve #{dependency}" }
+                end
+              end
+              unless resolution
+                failure = true
+              else
+                dependencies, manifests, queue = *resolution
+              end
+            end
+          end
+        end
+        failure ? nil : [dependencies, manifests, queue]
+      end
+
+    private
+
+      def scope
+        @level += 1
+        yield
+      ensure
+        @level -= 1
+      end
+
+      def debug
+        super { '  ' * @level + yield }
+      end
+
+      def environment
+        resolver.environment
+      end
+
+    end
+  end
+end