librarian 0.0.9 → 0.0.10

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.0.10
+
+This release focuses on refactoring some of the internals. There are no functional changes.
+
 ## 0.0.9
 
 * \#11 Fixes a problem where, if the repo is in a path where a component has a space, attempting to resolve a

data/lib/librarian.rb

@@ -1,188 +1,15 @@
-require 'pathname'
-
-require 'librarian/helpers/debug'
-require 'librarian/support/abstract_method'
-
 require 'librarian/version'
-require 'librarian/dependency'
-require 'librarian/manifest_set'
-require 'librarian/particularity'
-require 'librarian/resolver'
-require 'librarian/source'
-require 'librarian/spec_change_set'
-require 'librarian/specfile'
-require 'librarian/lockfile'
-require 'librarian/ui'
+require 'librarian/environment'
 
 module Librarian
   extend self
 
-  include Support::AbstractMethod
-  include Helpers::Debug
-
-  class Error < StandardError
-  end
-
-  attr_accessor :ui
-
-  abstract_method :specfile_name, :dsl_class, :install_path
-
-  def project_path
-    @project_path ||= begin
-      root = Pathname.new(Dir.pwd)
-      root = root.dirname until root.join(specfile_name).exist? || root.dirname == root
-      path = root.join(specfile_name)
-      path.exist? ? root : nil
-    end
-  end
-
-  def specfile_path
-    project_path.join(specfile_name)
-  end
-
-  def specfile
-    Specfile.new(self, specfile_path)
-  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')
+  def environment_class
+    self::Environment
   end
 
-  def project_relative_path_to(path)
-    Pathname.new(path).relative_path_from(project_path)
-  end
-
-  def spec_change_set(spec, lock)
-    SpecChangeSet.new(self, spec, lock)
-  end
-
-  def version
-    VERSION
-  end
-
-  def ensure!
-    unless project_path
-      raise Error, "Cannot find #{specfile_name}!"
-    end
-  end
-
-  def clean!
-    if cache_path.exist?
-      debug { "Deleting #{project_relative_path_to(cache_path)}" }
-      cache_path.rmtree
-    end
-    if install_path.exist?
-      install_path.children.each do |c|
-        debug { "Deleting #{project_relative_path_to(c)}" }
-        c.rmtree unless c.file?
-      end
-    end
-    if lockfile_path.exist?
-      debug { "Deleting #{project_relative_path_to(lockfile_path)}" }
-      lockfile_path.rmtree
-    end
-  end
-
-  def install!
-    resolve!
-    manifests = ManifestSet.sort(lockfile.load(lockfile_path.read).manifests)
-    manifests.each do |manifest|
-      manifest.source.cache!([manifest])
-    end
-    install_path.mkpath unless install_path.exist?
-    manifests.each do |manifest|
-      manifest.install!
-    end
-  end
-
-  def update!(dependency_names)
-    unless lockfile_path.exist?
-      raise Error, "Lockfile missing!"
-    end
-    previous_resolution = lockfile.load(lockfile_path.read)
-    partial_manifests = ManifestSet.deep_strip(previous_resolution.manifests, dependency_names)
-    spec = specfile.read(previous_resolution.sources)
-    spec_changes = spec_change_set(spec, previous_resolution)
-    raise Error, "Cannot update when the specfile has been changed." unless spec_changes.same?
-    resolution = resolver.resolve(spec, partial_manifests)
-    unless resolution.correct?
-      ui.info { "Could not resolve the dependencies." }
-    else
-      lockfile_text = lockfile.save(resolution)
-      debug { "Bouncing #{lockfile_name}" }
-      bounced_lockfile_text = lockfile.save(lockfile.load(lockfile_text))
-      unless bounced_lockfile_text == lockfile_text
-        debug { "lockfile_text: \n#{lockfile_text}"}
-        debug { "bounced_lockfile_text: \n#{bounced_lockfile_text}"}
-        raise Error, "Cannot bounce #{lockfile_name}!"
-      end
-      lockfile_path.open('wb') { |f| f.write(lockfile_text) }
-    end
-  end
-
-  def resolve!(options = {})
-    if options[:force] || !lockfile_path.exist?
-      spec = specfile.read
-      manifests = []
-    else
-      lock = lockfile.read
-      spec = specfile.read(lock.sources)
-      changes = spec_change_set(spec, lock)
-      if changes.same?
-        debug { "The specfile is unchanged: nothing to do." }
-        return
-      end
-      manifests = changes.analyze
-    end
-
-    resolution = resolver.resolve(spec, manifests)
-    unless resolution.correct?
-      raise Error, "Could not resolve the dependencies."
-    else
-      lockfile_text = lockfile.save(resolution)
-      debug { "Bouncing #{lockfile_name}" }
-      bounced_lockfile_text = lockfile.save(lockfile.load(lockfile_text))
-      unless bounced_lockfile_text == lockfile_text
-        debug { "lockfile_text: \n#{lockfile_text}"}
-        debug { "bounced_lockfile_text: \n#{bounced_lockfile_text}"}
-        raise Error, "Cannot bounce #{lockfile_name}!"
-      end
-      lockfile_path.open('wb') { |f| f.write(lockfile_text) }
-    end
-  end
-
-  def dsl(&block)
-    dsl_class.run(&block)
-  end
-
-  def dsl_class
-    self::Dsl
-  end
-
-private
-
-  def root_module
-    self
+  def environment
+    @environment ||= environment_class.new
   end
 
 end

data/lib/librarian/action.rb

@@ -0,0 +1,5 @@
+require "librarian/action/clean"
+require "librarian/action/ensure"
+require "librarian/action/install"
+require "librarian/action/resolve"
+require "librarian/action/update"

data/lib/librarian/action/base.rb

@@ -0,0 +1,22 @@
+require "librarian/helpers/debug"
+
+module Librarian
+  module Action
+    class Base
+
+      include Helpers::Debug
+
+      attr_accessor :environment
+      private :environment=
+
+      attr_accessor :options
+      private :options=
+
+      def initialize(environment, options = { })
+        self.environment = environment
+        self.options = options
+      end
+
+    end
+  end
+end

data/lib/librarian/action/clean.rb

@@ -0,0 +1,56 @@
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Clean < Base
+
+      def run
+        clean_cache_path
+        clean_install_path
+        clean_lockfile_path
+      end
+
+    private
+
+      def clean_cache_path
+        if cache_path.exist?
+          debug { "Deleting #{project_relative_path_to(cache_path)}" }
+          cache_path.rmtree
+        end
+      end
+
+      def clean_install_path
+        if install_path.exist?
+          install_path.children.each do |c|
+            debug { "Deleting #{project_relative_path_to(c)}" }
+            c.rmtree unless c.file?
+          end
+        end
+      end
+
+      def clean_lockfile_path
+        if lockfile_path.exist?
+          debug { "Deleting #{project_relative_path_to(lockfile_path)}" }
+          lockfile_path.rmtree
+        end
+      end
+
+      def cache_path
+        environment.cache_path
+      end
+
+      def install_path
+        environment.install_path
+      end
+
+      def lockfile_path
+        environment.lockfile_path
+      end
+
+      def project_relative_path_to(path)
+        environment.project_relative_path_to(path)
+      end
+
+    end
+  end
+end

data/lib/librarian/action/ensure.rb

@@ -0,0 +1,24 @@
+require "librarian/error"
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Ensure < Base
+
+      def run
+        raise Error, "Cannot find #{specfile_name}!" unless project_path
+      end
+
+    private
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def project_path
+        environment.project_path
+      end
+
+    end
+  end
+end

data/lib/librarian/action/install.rb

@@ -0,0 +1,101 @@
+require "librarian/manifest_set"
+require "librarian/spec_change_set"
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Install < Base
+
+      def run
+        check_preconditions
+
+        perform_installation
+      end
+
+    private
+
+      def check_preconditions
+        check_specfile
+        check_lockfile
+        check_consistent
+      end
+
+      def check_specfile
+        raise Error, "#{specfile_name} missing!" unless specfile_path.exist?
+      end
+
+      def check_lockfile
+        raise Error, "#{lockfile_name} missing!" unless lockfile_path.exist?
+      end
+
+      def check_consistent
+        raise Error, "#{specfile_name} and #{lockfile_name} are out of sync!" unless spec_consistent_with_lock?
+      end
+
+      def perform_installation
+        manifests = sorted_manifests
+
+        cache_manifests(manifests)
+        create_install_path
+        install_manifests(manifests)
+      end
+
+      def cache_manifests(manifests)
+        manifests.each do |manifest|
+          manifest.source.cache!([manifest])
+        end
+      end
+
+      def create_install_path
+        install_path.mkpath unless install_path.exist?
+      end
+
+      def install_manifests(manifests)
+        manifests.each do |manifest|
+          manifest.install!
+        end
+      end
+
+      def sorted_manifests
+        ManifestSet.sort(lock.manifests)
+      end
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def specfile_path
+        environment.specfile_path
+      end
+
+      def lockfile_name
+        environment.lockfile_name
+      end
+
+      def lockfile_path
+        environment.lockfile_path
+      end
+
+      def spec
+        environment.spec
+      end
+
+      def lock
+        environment.lock
+      end
+
+      def spec_change_set(spec, lock)
+        SpecChangeSet.new(environment, spec, lock)
+      end
+
+      def spec_consistent_with_lock?
+        spec_change_set(spec, lock).same?
+      end
+
+      def install_path
+        environment.install_path
+      end
+
+    end
+  end
+end

data/lib/librarian/action/resolve.rb

@@ -0,0 +1,81 @@
+require "librarian/error"
+require "librarian/resolver"
+require "librarian/spec_change_set"
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Resolve < Base
+
+      def run
+        if force? || !lockfile_path.exist?
+          spec = specfile.read
+          manifests = []
+        else
+          lock = lockfile.read
+          spec = specfile.read(lock.sources)
+          changes = spec_change_set(spec, lock)
+          if changes.same?
+            debug { "The specfile is unchanged: nothing to do." }
+            return
+          end
+          manifests = changes.analyze
+        end
+
+        resolution = resolver.resolve(spec, manifests)
+        unless resolution.correct?
+          raise Error, "Could not resolve the dependencies."
+        else
+          lockfile_text = lockfile.save(resolution)
+          debug { "Bouncing #{lockfile_name}" }
+          bounced_lockfile_text = lockfile.save(lockfile.load(lockfile_text))
+          unless bounced_lockfile_text == lockfile_text
+            debug { "lockfile_text: \n#{lockfile_text}"}
+            debug { "bounced_lockfile_text: \n#{bounced_lockfile_text}"}
+            raise Error, "Cannot bounce #{lockfile_name}!"
+          end
+          lockfile_path.open('wb') { |f| f.write(lockfile_text) }
+        end
+      end
+
+    private
+
+      def force?
+        options[:force]
+      end
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def lockfile_name
+        environment.lockfile_name
+      end
+
+      def specfile_path
+        environment.specfile_path
+      end
+
+      def lockfile_path
+        environment.lockfile_path
+      end
+
+      def specfile
+        environment.specfile
+      end
+
+      def lockfile
+        environment.lockfile
+      end
+
+      def resolver
+        Resolver.new(environment)
+      end
+
+      def spec_change_set(spec, lock)
+        SpecChangeSet.new(environment, spec, lock)
+      end
+
+    end
+  end
+end