librarianp 0.1.2

data/lib/librarian/manifest.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+
+module Librarian
+  class Manifest
+
+    class Version
+      include Comparable
+
+      def initialize(*args)
+        args = initialize_normalize_args(args)
+
+        self.backing = Gem::Version.new(*args)
+      end
+
+      def to_gem_version
+        backing
+      end
+
+      def <=>(other)
+        to_gem_version <=> other.to_gem_version
+      end
+
+      def to_s
+        to_gem_version.to_s
+      end
+
+      def inspect
+        "#<#{self.class} #{to_s}>"
+      end
+
+      private
+
+      def initialize_normalize_args(args)
+        args.map do |arg|
+          arg = [arg] if self.class === arg
+          arg
+        end
+      end
+
+      attr_accessor :backing
+    end
+
+    attr_accessor :source, :name, :extra
+    private :source=, :name=, :extra=
+
+    def initialize(source, name, extra = nil)
+      assert_name_valid! name
+
+      self.source = source
+      self.name = name
+      self.extra = extra
+    end
+
+    def to_s
+      "#{name}/#{version} <#{source}>"
+    end
+
+    def version
+      defined_version || fetched_version
+    end
+
+    def version=(version)
+      self.defined_version = _normalize_version(version)
+    end
+
+    def version?
+      return unless defined_version
+
+      defined_version == fetched_version
+    end
+
+    def latest
+      @latest ||= source.manifests(name).first
+    end
+
+    def outdated?
+      latest.version > version
+    end
+
+    def dependencies
+      defined_dependencies || fetched_dependencies
+    end
+
+    def dependencies=(dependencies)
+      self.defined_dependencies = _normalize_dependencies(dependencies)
+    end
+
+    def dependencies?
+      return unless defined_dependencies
+
+      defined_dependencies.zip(fetched_dependencies).all? do |(a, b)|
+        a.name == b.name && a.requirement == b.requirement
+      end
+    end
+
+    def satisfies?(dependency)
+      dependency.requirement.satisfied_by?(version)
+    end
+
+    def install!
+      source.install!(self)
+    end
+
+  private
+
+    attr_accessor :defined_version, :defined_dependencies
+
+    def environment
+      source.environment
+    end
+
+    def fetched_version
+      @fetched_version ||= _normalize_version(fetch_version!)
+    end
+
+    def fetched_dependencies
+      @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+    end
+
+    def fetch_version!
+      source.fetch_version(name, extra)
+    end
+
+    def fetch_dependencies!
+      source.fetch_dependencies(name, version, extra)
+    end
+
+    def _normalize_version(version)
+      Version.new(version)
+    end
+
+    def _normalize_dependencies(dependencies)
+      if Hash === dependencies
+        dependencies = dependencies.map{|k, v| Dependency.new(k, v, nil)}
+      end
+      dependencies.sort_by(&:name)
+    end
+
+    def assert_name_valid!(name)
+      name =~ /\A\S(?:.*\S)?\z/ and return
+
+      raise ArgumentError, "name (#{name.inspect}) must be sensible"
+    end
+
+  end
+end

data/lib/librarian/manifest_set.rb

@@ -0,0 +1,150 @@
+require "librarian/algorithms"
+
+module Librarian
+  class ManifestSet
+
+    class << self
+      def shallow_strip(manifests, names)
+        new(manifests).shallow_strip!(names).send(method_for(manifests))
+      end
+      def deep_strip(manifests, names)
+        new(manifests).deep_strip!(names).send(method_for(manifests))
+      end
+      def shallow_keep(manifests, names)
+        new(manifests).shallow_keep!(names).send(method_for(manifests))
+      end
+      def deep_keep(manifests, names)
+        new(manifests).deep_keep!(names).send(method_for(manifests))
+      end
+      def cyclic?(manifests)
+        manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
+        manifest_pairs = Hash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        adj_algs.cyclic?(manifest_pairs)
+      end
+      def sort(manifests)
+        manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
+        manifest_pairs = Hash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        manifest_names = adj_algs.tsort_cyclic(manifest_pairs)
+        manifest_names.map{|n| manifests[n]}
+      end
+    private
+      def method_for(manifests)
+        case manifests
+        when Hash
+          :to_hash
+        when Array
+          :to_a
+        end
+      end
+      def adj_algs
+        Algorithms::AdjacencyListDirectedGraph
+      end
+    end
+
+    def initialize(manifests)
+      self.index = Hash === manifests ? manifests.dup : index_by(manifests, &:name)
+    end
+
+    def to_a
+      index.values
+    end
+
+    def to_hash
+      index.dup
+    end
+
+    def dup
+      self.class.new(index)
+    end
+
+    def shallow_strip(names)
+      dup.shallow_strip!(names)
+    end
+
+    def shallow_strip!(names)
+      assert_strings!(names)
+
+      names.each do |name|
+        index.delete(name)
+      end
+      self
+    end
+
+    def deep_strip(names)
+      dup.deep_strip!(names)
+    end
+
+    def deep_strip!(names)
+      strippables = dependencies_of(names)
+      shallow_strip!(strippables)
+
+      self
+    end
+
+    def shallow_keep(names)
+      dup.shallow_keep!(names)
+    end
+
+    def shallow_keep!(names)
+      assert_strings!(names)
+
+      names = Set.new(names) unless Set === names
+      index.reject! { |k, v| !names.include?(k) }
+      self
+    end
+
+    def deep_keep(names)
+      dup.conservative_strip!(names)
+    end
+
+    def deep_keep!(names)
+      keepables = dependencies_of(names)
+      shallow_keep!(keepables)
+
+      self
+    end
+
+    def consistent?
+      index.values.all? do |manifest|
+        in_compliance_with?(manifest.dependencies)
+      end
+    end
+
+    def in_compliance_with?(dependencies)
+      dependencies.all? do |dependency|
+        manifest = index[dependency.name]
+        manifest && manifest.satisfies?(dependency)
+      end
+    end
+
+  private
+
+    attr_accessor :index
+
+    def assert_strings!(names)
+      non_strings = names.reject{|name| String === name}
+      non_strings.empty? or raise TypeError, "names must all be strings"
+    end
+
+    # Straightforward breadth-first graph traversal algorithm.
+    def dependencies_of(names)
+      names = Array === names ? names.dup : names.to_a
+      assert_strings!(names)
+
+      deps = Set.new
+      until names.empty?
+        name = names.shift
+        next if deps.include?(name)
+
+        deps << name
+        names.concat index[name].dependencies.map(&:name)
+      end
+      deps.to_a
+    end
+
+    def index_by(enum)
+      Hash[enum.map{|obj| [yield(obj), obj]}]
+    end
+
+  end
+end

data/lib/librarian/mock/cli.rb

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

data/lib/librarian/mock/dsl.rb

@@ -0,0 +1,15 @@
+require 'librarian/dsl'
+require 'librarian/mock/source'
+
+module Librarian
+  module Mock
+    class Dsl < Librarian::Dsl
+
+      dependency :dep
+
+      source :src => Source::Mock
+
+      shortcut :a, :src => 'source-a'
+    end
+  end
+end

data/lib/librarian/mock/environment.rb

@@ -0,0 +1,21 @@
+require "librarian/environment"
+require "librarian/mock/dsl"
+require "librarian/mock/version"
+
+module Librarian
+  module Mock
+    class Environment < Environment
+
+      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

@@ -0,0 +1,9 @@
+require 'librarian/mock/environment'
+
+module Librarian
+  module Mock
+    extend self
+    extend Librarian
+
+  end
+end

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

@@ -0,0 +1,83 @@
+module Librarian
+  module Mock
+    module Source
+      class Mock
+        class Registry
+
+          module Dsl
+
+            class Top
+              def initialize(sources)
+                @sources = sources
+              end
+              def source(name, &block)
+                @sources[name] ||= {}
+                Source.new(@sources[name]).instance_eval(&block) if block
+              end
+            end
+
+            class Source
+              def initialize(source)
+                @source = source
+              end
+              def spec(name, version = nil, &block)
+                @source[name] ||= []
+                unless version
+                  Spec.new(@source[name]).instance_eval(&block) if block
+                else
+                  Spec.new(@source[name]).version(version, &block)
+                end
+                @source[name] = @source[name].sort_by{|a| Manifest::Version.new(a[:version])}.reverse
+              end
+            end
+
+            class Spec
+              def initialize(spec)
+                @spec = spec
+              end
+              def version(name, &block)
+                @spec << { :version => name, :dependencies => {} }
+                Version.new(@spec.last[:dependencies]).instance_eval(&block) if block
+              end
+            end
+
+            class Version
+              def initialize(version)
+                @version = version
+              end
+              def dependency(name, *requirement)
+                @version[name] = requirement
+              end
+            end
+
+            class << self
+              def run!(sources, &block)
+                Top.new(sources).instance_eval(&block) if block
+              end
+            end
+
+          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
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'librarian/manifest'
+require 'librarian/source/basic_api'
+require 'librarian/mock/source/mock/registry'
+
+module Librarian
+  module Mock
+    module Source
+      class Mock
+        include Librarian::Source::BasicApi
+
+        lock_name 'MOCK'
+        spec_options []
+
+        attr_accessor :environment
+        private :environment=
+        attr_reader :name
+
+        def initialize(environment, name, options)
+          self.environment = environment
+          @name = name
+        end
+
+        def to_s
+          name
+        end
+
+        def ==(other)
+          other &&
+          self.class  == other.class &&
+          self.name   == other.name
+        end
+
+        def to_spec_args
+          [name, {}]
+        end
+
+        def to_lock_options
+          {:remote => name}
+        end
+
+        def registry
+          environment.registry[name]
+        end
+
+        def manifest(name, version, dependencies)
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
+        end
+
+        def manifests(name)
+          if d = registry[name]
+            d.map{|v| manifest(name, v[:version], v[:dependencies])}
+          else
+            nil
+          end
+        end
+
+        def install!(manifest)
+        end
+
+        def to_s
+          name
+        end
+
+        def fetch_version(name, extra)
+          extra
+        end
+
+        def fetch_dependencies(name, version, extra)
+          d = registry[name]
+          m = d.find{|v| v[:version] == version.to_s}
+          m[:dependencies]
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/mock/source.rb

@@ -0,0 +1 @@
+require 'librarian/mock/source/mock'

data/lib/librarian/mock/version.rb

@@ -0,0 +1,5 @@
+module Librarian
+  module Mock
+    VERSION = "0.1.2"
+  end
+end

data/lib/librarian/mock.rb

@@ -0,0 +1 @@
+require 'librarian/mock/extension'

data/lib/librarian/posix.rb

@@ -0,0 +1,129 @@
+require "open3"
+
+require "librarian/error"
+
+module Librarian
+  module Posix
+
+    class << self
+
+      # Cross-platform way of finding an executable in the $PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      #
+      # From:
+      #   https://github.com/defunkt/hub/commit/353031307e704d860826fc756ff0070be5e1b430#L2R173
+      def which(cmd)
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(';') : ['']
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+          path = File.expand_path(path)
+          exts.each do |ext|
+            exe = File.join(path, cmd + ext)
+            return exe if File.file?(exe) && File.executable?(exe)
+          end
+        end
+        nil
+      end
+
+      def which!(cmd)
+        which(cmd) or raise Error, "cannot find #{cmd}"
+      end
+
+    end
+
+    class CommandFailure < Error
+      class << self
+        def raise!(command, status, message)
+          ex = new(message)
+          ex.command = command
+          ex.status = status
+          ex.set_backtrace caller
+          raise ex
+        end
+      end
+
+      attr_accessor :command, :status
+    end
+
+    class << self
+
+      if defined?(JRuby) # built with jruby-1.7.9 in mind
+
+        def rescuing(*klasses)
+          begin
+            yield
+          rescue *klasses
+          end
+        end
+
+        def run!(command, options = { })
+          out, err = nil, nil
+          chdir = options[:chdir].to_s if options[:chdir]
+          env = options[:env] || { }
+          old_env = Hash[env.keys.map{|k| [k, ENV[k]]}]
+          out, err, wait = nil, nil, nil
+          begin
+            ENV.update env
+            Dir.chdir(chdir || Dir.pwd) do
+              IO.popen3(*command) do |i, o, e, w|
+                rescuing(Errno::EBADF){ i.close } # jruby/1.9 can raise EBADF
+                out, err, wait = o.read, e.read, w
+              end
+            end
+          ensure
+            ENV.update old_env
+          end
+          s = wait ? wait.value : $? # wait is 1.9+-only
+          s.success? or CommandFailure.raise! command, s, err
+          out
+        end
+
+      else
+
+        if RUBY_VERSION < "1.9"
+
+          def run!(command, options = { })
+            i, o, e = IO.pipe, IO.pipe, IO.pipe
+            pid = fork do
+              $stdin.reopen i[0]
+              $stdout.reopen o[1]
+              $stderr.reopen e[1]
+              [i[1], i[0], o[0], e[0]].each &:close
+              ENV.update options[:env] || { }
+              Dir.chdir options[:chdir].to_s if options[:chdir]
+              exec *command
+            end
+            [i[0], i[1], o[1], e[1]].each &:close
+            Process.waitpid pid
+            $?.success? or CommandFailure.raise! command, $?, e[0].read
+            o[0].read
+          ensure
+            [i, o, e].flatten(1).each{|io| io.close unless io.closed?}
+          end
+
+        else
+
+          def run!(command, options = { })
+            i, o, e = IO.pipe, IO.pipe, IO.pipe
+            opts = {:in => i[0], :out => o[1], :err => e[1]}
+            opts[:chdir] = options[:chdir].to_s if options[:chdir]
+            command = command.dup
+            command.unshift options[:env] || { }
+            command.push opts
+            pid = Process.spawn(*command)
+            [i[0], i[1], o[1], e[1]].each &:close
+            Process.waitpid pid
+            $?.success? or CommandFailure.raise! command, $?, e[0].read
+            o[0].read
+          ensure
+            [i, o, e].flatten(1).each{|io| io.close unless io.closed?}
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end