librarianp 0.1.2

data/lib/librarian/source/git/repository.rb

@@ -0,0 +1,193 @@
+require "pathname"
+
+require "librarian/posix"
+
+module Librarian
+  module Source
+    class Git
+      class Repository
+
+        class << self
+          def clone!(environment, path, repository_url)
+            path = Pathname.new(path)
+            path.mkpath
+            git = new(environment, path)
+            git.clone!(repository_url)
+            git
+          end
+
+          def bin
+            @bin ||= Posix.which!("git")
+          end
+
+          def git_version
+            command = %W[#{bin} version --silent]
+            Posix.run!(command).strip =~ /\Agit version (\d+(\.\d+)*)/ && $1
+          end
+        end
+
+        attr_accessor :environment, :path, :git_ops_history
+        private :environment=, :path=, :git_ops_history=
+
+        def initialize(environment, path)
+          self.environment = environment
+          self.path = Pathname.new(path)
+          self.git_ops_history = []
+        end
+
+        def git?
+          path.join('.git').exist?
+        end
+
+        def default_remote
+          "origin"
+        end
+
+        def clone!(repository_url)
+          command = %W(clone #{repository_url} . --quiet)
+          run!(command, :chdir => true)
+        end
+
+        def checkout!(reference, options ={ })
+          command = %W(checkout #{reference} --quiet)
+          command << "--force" if options[:force]
+          run!(command, :chdir => true)
+        end
+
+        def fetch!(remote, options = { })
+          command = %W(fetch #{remote} --quiet)
+          command << "--tags" if options[:tags]
+          run!(command, :chdir => true)
+        end
+
+        def reset_hard!
+          command = %W(reset --hard --quiet)
+          run!(command, :chdir => true)
+        end
+
+        def clean!
+          command = %w(clean -x -d --force --force)
+          run!(command, :chdir => true)
+        end
+
+        def has_commit?(sha)
+          command = %W(log -1 --no-color --format=tformat:%H #{sha})
+          run!(command, :chdir => true).strip == sha
+        rescue Posix::CommandFailure => e
+          false
+        end
+
+        def checked_out?(sha)
+          current_commit_hash == sha
+        end
+
+        def remote_names
+          command = %W(remote)
+          run!(command, :chdir => true).strip.lines.map(&:strip)
+        end
+
+        def remote_branch_names
+          remotes = remote_names.sort_by(&:length).reverse
+
+          command = %W(branch -r --no-color)
+          names = run!(command, :chdir => true).strip.lines.map(&:strip).to_a
+          names.each{|n| n.gsub!(/\s*->.*$/, "")}
+          names.reject!{|n| n =~ /\/HEAD$/}
+          Hash[remotes.map do |r|
+            matching_names = names.select{|n| n.start_with?("#{r}/")}
+            matching_names.each{|n| names.delete(n)}
+            matching_names.each{|n| n.slice!(0, r.size + 1)}
+            [r, matching_names]
+          end]
+        end
+
+        def hash_from(remote, reference)
+          branch_names = remote_branch_names[remote]
+          if branch_names.include?(reference)
+            reference = "#{remote}/#{reference}"
+          end
+
+          command = %W(rev-list #{reference} -1)
+          run!(command, :chdir => true).strip
+        end
+
+        def current_commit_hash
+          command = %W(rev-parse HEAD --quiet)
+          run!(command, :chdir => true).strip!
+        end
+
+      private
+
+        def bin
+          self.class.bin
+        end
+
+        def run!(args, options = { })
+          chdir = options.delete(:chdir)
+          chdir = path.to_s if chdir == true
+
+          silent = options.delete(:silent)
+          pwd = chdir || Dir.pwd
+          git_dir = File.join(path, ".git") if path
+          env = {"GIT_DIR" => git_dir}
+
+          command = [bin]
+          command.concat(args)
+
+          logging_command(command, :silent => silent, :pwd => pwd) do
+            Posix.run!(command, :chdir => chdir, :env => env)
+          end
+        end
+
+        def logging_command(command, options)
+          silent = options.delete(:silent)
+
+          pwd = Dir.pwd
+
+          out = yield
+
+          git_ops_history << command + [{:pwd => pwd}]
+
+          unless silent
+            if out.size > 0
+              out.lines.each do |line|
+                debug { "    --> #{line}" }
+              end
+            else
+              debug { "    --- No output" }
+            end
+          end
+
+          out
+
+        rescue Posix::CommandFailure => e
+
+          git_ops_history << command + [{:pwd => pwd}]
+
+          status, stderr = e.status, e.message
+          unless silent
+            debug { "    --- Exited with #{status}" }
+            if stderr.size > 0
+              stderr.lines.each do |line|
+                debug { "    --> #{line}" }
+              end
+            else
+              debug { "    --- No output" }
+            end
+          end
+
+          raise e
+        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
+  end
+end

data/lib/librarian/source/git.rb

@@ -0,0 +1,172 @@
+require 'fileutils'
+require 'pathname'
+require 'digest'
+
+require 'librarian/error'
+require 'librarian/source/basic_api'
+require 'librarian/source/git/repository'
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Git
+      include BasicApi
+      include Local
+
+      lock_name 'GIT'
+      spec_options [:ref, :path]
+
+      DEFAULTS = {
+        :ref => 'master'
+      }
+
+      attr_accessor :environment
+      private :environment=
+
+      attr_accessor :uri, :ref, :sha, :path
+      private :uri=, :ref=, :sha=, :path=
+
+      def initialize(environment, uri, options)
+        self.environment = environment
+        self.uri = uri
+        self.ref = options[:ref] || DEFAULTS[:ref]
+        self.sha = options[:sha]
+        self.path = options[:path]
+
+        @repository = nil
+        @repository_cache_path = nil
+
+        ref.kind_of?(String) or raise TypeError, "ref must be a String"
+      end
+
+      def to_s
+        path ? "#{uri}##{ref}(#{path})" : "#{uri}##{ref}"
+      end
+
+      def ==(other)
+        other &&
+        self.class  == other.class  &&
+        self.uri    == other.uri    &&
+        self.ref    == other.ref    &&
+        self.path   == other.path   &&
+        (self.sha.nil? || other.sha.nil? || self.sha == other.sha)
+      end
+
+      def to_spec_args
+        options = {}
+        options.merge!(:ref => ref) if ref != DEFAULTS[:ref]
+        options.merge!(:path => path) if path
+        [uri, options]
+      end
+
+      def to_lock_options
+        options = {:remote => uri, :ref => ref, :sha => sha}
+        options.merge!(:path => path) if path
+        options
+      end
+
+      def pinned?
+        !!sha
+      end
+
+      def unpin!
+        @sha = nil
+      end
+
+      def cache!
+        repository_cached? and return or repository_cached!
+
+        unless repository.git?
+          repository.path.rmtree if repository.path.exist?
+          repository.path.mkpath
+          repository.clone!(uri)
+          raise Error, "failed to clone #{uri}" unless repository.git?
+        end
+
+        # Probably unnecessary: nobody should be writing to our cache but us.
+        # Just a precaution.
+        repository_clean_once!
+
+        unless sha
+          repository_update_once!
+          self.sha = fetch_sha_memo
+        end
+
+        unless repository.checked_out?(sha)
+          repository_update_once! unless repository.has_commit?(sha)
+          repository.checkout!(sha)
+          # Probably unnecessary: if git fails to checkout, it should exit
+          # nonzero, and we should expect Librarian::Posix::CommandFailure.
+          raise Error, "failed to checkout #{sha}" unless repository.checked_out?(sha)
+        end
+      end
+
+      # For tests
+      def git_ops_count
+        repository.git_ops_history.size
+      end
+
+    private
+
+      attr_accessor :repository_cached
+      alias repository_cached? repository_cached
+
+      def repository_cached!
+        self.repository_cached = true
+      end
+
+      def repository_cache_path
+        @repository_cache_path ||= begin
+          environment.cache_path + "source/git" + cache_key
+        end
+      end
+
+      def repository
+        @repository ||= begin
+          Repository.new(environment, repository_cache_path)
+        end
+      end
+
+      def filesystem_path
+        @filesystem_path ||= path ? repository.path.join(path) : repository.path
+      end
+
+      def repository_clean_once!
+        remote = repository.default_remote
+        runtime_cache.once ['repository-clean', uri, ref].to_s do
+          repository.reset_hard!
+          repository.clean!
+        end
+      end
+
+      def repository_update_once!
+        remote = repository.default_remote
+        runtime_cache.once ['repository-update', uri, remote, ref].to_s do
+          repository.fetch! remote
+          repository.fetch! remote, :tags => true
+        end
+      end
+
+      def fetch_sha_memo
+        remote = repository.default_remote
+        runtime_cache.memo ['fetch-sha', uri, remote, ref].to_s do
+          repository.hash_from(remote, ref)
+        end
+      end
+
+      def cache_key
+        @cache_key ||= begin
+          uri_part = uri
+          ref_part = "##{ref}"
+          key_source = [uri_part, ref_part].join
+          Digest::MD5.hexdigest(key_source)[0..15]
+        end
+      end
+
+      def runtime_cache
+        @runtime_cache ||= environment.runtime_cache.keyspace(self.class.name)
+      end
+
+    end
+  end
+end

data/lib/librarian/source/local.rb

@@ -0,0 +1,54 @@
+require 'librarian/support/abstract_method'
+
+module Librarian
+  module Source
+    # Requires that the including source class have methods:
+    #   #path
+    #   #environment
+    module Local
+
+      include Support::AbstractMethod
+
+      abstract_method :path, :fetch_version, :fetch_dependencies
+
+      def manifests(name)
+        manifest = Manifest.new(self, name)
+        [manifest].compact
+      end
+
+      def manifest_search_paths(name)
+        @manifest_search_paths ||= { }
+        @manifest_search_paths[name] ||= begin
+          cache!
+          paths = [filesystem_path, filesystem_path.join(name)]
+          paths.select{|s| s.exist?}
+        end
+      end
+
+      def found_path(name)
+        @_found_paths ||= { }
+        @_found_paths[name] ||= begin
+          paths = manifest_search_paths(name)
+          paths.find{|p| manifest?(name, p)}
+        end
+      end
+
+    private
+
+      abstract_method :manifest? # (name, path) -> boolean
+
+      def info(*args, &block)
+        environment.logger.info(*args, &block)
+      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
+end

data/lib/librarian/source/path.rb

@@ -0,0 +1,56 @@
+require 'librarian/source/basic_api'
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Path
+      include BasicApi
+      include Local
+
+      lock_name 'PATH'
+      spec_options []
+
+      attr_accessor :environment
+      private :environment=
+      attr_reader :path
+
+      def initialize(environment, path, options)
+        self.environment = environment
+        @path = path
+      end
+
+      def to_s
+        path.to_s
+      end
+
+      def ==(other)
+        other &&
+        self.class  == other.class &&
+        self.path   == other.path
+      end
+
+      def to_spec_args
+        [path.to_s, {}]
+      end
+
+      def to_lock_options
+        {:remote => path}
+      end
+
+      def pinned?
+        false
+      end
+
+      def unpin!
+      end
+
+      def cache!
+      end
+
+      def filesystem_path
+        @filesystem_path ||= Pathname.new(path).expand_path(environment.project_path)
+      end
+
+    end
+  end
+end

data/lib/librarian/source.rb

@@ -0,0 +1,2 @@
+require 'librarian/source/git'
+require 'librarian/source/path'

data/lib/librarian/spec.rb

@@ -0,0 +1,13 @@
+module Librarian
+  class Spec
+
+    attr_accessor :sources, :dependencies
+    private :sources=, :dependencies=
+
+    def initialize(sources, dependencies)
+      self.sources = sources
+      self.dependencies = dependencies
+    end
+
+  end
+end

data/lib/librarian/spec_change_set.rb

@@ -0,0 +1,173 @@
+require 'librarian/helpers'
+
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+require 'librarian/spec'
+
+module Librarian
+  class SpecChangeSet
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :spec, :lock
+
+    def initialize(environment, spec, lock)
+      self.environment = environment
+      raise TypeError, "can't convert #{spec.class} into #{Spec}" unless Spec === spec
+      raise TypeError, "can't convert #{lock.class} into #{Resolution}" unless Resolution === lock
+      @spec, @lock = spec, lock
+    end
+
+    def same?
+      @same ||= spec.dependencies.sort_by{|d| d.name} == lock.dependencies.sort_by{|d| d.name}
+    end
+
+    def changed?
+      !same?
+    end
+
+    def spec_dependencies
+      @spec_dependencies ||= spec.dependencies
+    end
+    def spec_dependency_names
+      @spec_dependency_names ||= Set.new(spec_dependencies.map{|d| d.name})
+    end
+    def spec_dependency_index
+      @spec_dependency_index ||= Hash[spec_dependencies.map{|d| [d.name, d]}]
+    end
+
+    def lock_dependencies
+      @lock_dependencies ||= lock.dependencies
+    end
+    def lock_dependency_names
+      @lock_dependency_names ||= Set.new(lock_dependencies.map{|d| d.name})
+    end
+    def lock_dependency_index
+      @lock_dependency_index ||= Hash[lock_dependencies.map{|d| [d.name, d]}]
+    end
+
+    def lock_manifests
+      @lock_manifests ||= lock.manifests
+    end
+    def lock_manifests_index
+      @lock_manifests_index ||= ManifestSet.new(lock_manifests).to_hash
+    end
+
+    def removed_dependency_names
+      @removed_dependency_names ||= lock_dependency_names - spec_dependency_names
+    end
+
+    # A dependency which is deleted from the specfile will, in the general case,
+    #   be removed conservatively. This means it might not actually be removed.
+    #   But if the dependency originally declared a source which is now non-
+    #   default, it must be removed, even if another dependency has a transitive
+    #   dependency on the one that was removed (which is the scenario in which
+    #   a conservative removal would not remove it). In this case, we must also
+    #   remove it explicitly so that it can be re-resolved from the default
+    #   source.
+    def explicit_removed_dependency_names
+      @explicit_removed_dependency_names ||= removed_dependency_names.reject do |name|
+        lock_manifest = lock_manifests_index[name]
+        spec.sources.include?(lock_manifest.source)
+      end.to_set
+    end
+
+    def added_dependency_names
+      @added_dependency_names ||= spec_dependency_names - lock_dependency_names
+    end
+
+    def nonmatching_added_dependency_names
+      @nonmatching_added_dependency_names ||= added_dependency_names.reject do |name|
+        spec_dependency = spec_dependency_index[name]
+        lock_manifest = lock_manifests_index[name]
+        if lock_manifest
+          matching = true
+          matching &&= spec_dependency.satisfied_by?(lock_manifest)
+          matching &&= spec_dependency.source == lock_manifest.source
+          matching
+        else
+          false
+        end
+      end.to_set
+    end
+
+    def common_dependency_names
+      @common_dependency_names ||= lock_dependency_names & spec_dependency_names
+    end
+
+    def changed_dependency_names
+      @changed_dependency_names ||= common_dependency_names.reject do |name|
+        spec_dependency = spec_dependency_index[name]
+        lock_dependency = lock_dependency_index[name]
+        lock_manifest = lock_manifests_index[name]
+        same = true
+        same &&= spec_dependency.satisfied_by?(lock_manifest)
+        same &&= spec_dependency.source == lock_dependency.source
+        same
+      end.to_set
+    end
+
+    def deep_keep_manifest_names
+      @deep_keep_manifest_names ||= begin
+        lock_dependency_names - (
+          removed_dependency_names +
+          changed_dependency_names +
+          nonmatching_added_dependency_names
+        )
+      end
+    end
+
+    def shallow_strip_manifest_names
+      @shallow_strip_manifest_names ||= begin
+        explicit_removed_dependency_names + changed_dependency_names
+      end
+    end
+
+    def inspect
+      Helpers.strip_heredoc(<<-INSPECT)
+        <##{self.class.name}:
+          Removed: #{removed_dependency_names.to_a.join(", ")}
+          ExplicitRemoved: #{explicit_removed_dependency_names.to_a.join(", ")}
+          Added: #{added_dependency_names.to_a.join(", ")}
+          NonMatchingAdded: #{nonmatching_added_dependency_names.to_a.join(", ")}
+          Changed: #{changed_dependency_names.to_a.join(", ")}
+          DeepKeep: #{deep_keep_manifest_names.to_a.join(", ")}
+          ShallowStrip: #{shallow_strip_manifest_names.to_a.join(", ")}
+        >
+      INSPECT
+    end
+
+    # Returns an array of those manifests from the previous spec which should be kept,
+    #   based on inspecting the new spec against the locked resolution from the previous spec.
+    def analyze
+      @analyze ||= begin
+        debug { "Analyzing spec and lock:" }
+
+        if same?
+          debug { "  Same!" }
+          return lock.manifests
+        end
+
+        debug { "  Removed:" } ; removed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  ExplicitRemoved:" } ; explicit_removed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  Added:" } ; added_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  NonMatchingAdded:" } ; nonmatching_added_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  Changed:" } ; changed_dependency_names.each { |name| debug { "    #{name}" } }
+        debug { "  DeepKeep:" } ; deep_keep_manifest_names.each { |name| debug { "    #{name}" } }
+        debug { "  ShallowStrip:" } ; shallow_strip_manifest_names.each { |name| debug { "    #{name}" } }
+
+        manifests = ManifestSet.new(lock_manifests)
+        manifests.deep_keep!(deep_keep_manifest_names)
+        manifests.shallow_strip!(shallow_strip_manifest_names)
+        manifests.to_a
+      end
+    end
+
+  private
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+  end
+end

data/lib/librarian/specfile.rb

@@ -0,0 +1,19 @@
+require "pathname"
+
+module Librarian
+  class Specfile
+
+    attr_accessor :environment, :path
+    private :environment=, :path=
+
+    def initialize(environment, path)
+      self.environment = environment
+      self.path = Pathname(path)
+    end
+
+    def read(precache_sources = [])
+      environment.dsl(path, precache_sources)
+    end
+
+  end
+end

data/lib/librarian/support/abstract_method.rb

@@ -0,0 +1,21 @@
+module Librarian
+  module Support
+    module AbstractMethod
+
+      class << self
+        def included(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def abstract_method(*names)
+          names.reject{|name| respond_to?(name)}.each do |name, *args|
+            define_method(name) { raise Exception, "Method #{self.class.name}##{name} is abstract!" }
+          end
+        end
+      end
+
+    end
+  end
+end