librarian 0.0.1

data/lib/librarian/lockfile/parser.rb

@@ -0,0 +1,102 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/manifest'
+require 'librarian/dependency'
+
+module Librarian
+  class Lockfile
+    class Parser
+
+      class ManifestPlaceholder
+        attr_reader :source, :name, :version, :dependencies
+        def initialize(source, name, version, dependencies)
+          @source, @name, @version, @dependencies = source, name, version, dependencies
+        end
+      end
+
+      include Helpers::Debug
+
+      attr_reader :root_module
+
+      def initialize(root_module)
+        @root_module = root_module
+      end
+
+      def parse(string)
+        string = string.dup
+        source_type_names_map = Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
+        source_type_names = dsl_class.source_types.map{|t| t[1].lock_name}
+        lines = string.split(/(\r?\n)+/).reject{|l| l =~ /^\s*$/}
+        sources = []
+        while source_type_names.include?(lines.first)
+          source = {}
+          source_type_name = lines.shift
+          source[:type] = source_type_names_map[source_type_name]
+          options = {}
+          while lines.first =~ /^ {2}([\w-]+):\s+(.+)$/
+            lines.shift
+            options[$1.to_sym] = $2
+          end
+          source[:options] = options
+          lines.shift # specs
+          manifests = {}
+          while lines.first =~ /^ {4}([\w-]+) \((.*)\)$/
+            lines.shift
+            name = $1
+            manifests[name] = {:version => $2, :dependencies => {}}
+            while lines.first =~ /^ {6}([\w-]+) \((.*)\)$/
+              lines.shift
+              manifests[name][:dependencies][$1] = $2.split(/,\s*/)
+            end
+          end
+          source[:manifests] = manifests
+          sources << source
+        end
+        manifests = compile(sources)
+        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        dependencies = []
+        while lines.first =~ /^ {2}([\w-]+)(?: \((.*)\))?$/
+          lines.shift
+          name, requirement = $1, $2
+          dependencies << Dependency.new(name, requirement, manifests_index[name].source)
+        end
+        Resolution.new(dependencies, manifests)
+      end
+
+    private
+
+      def compile(sources_ast)
+        manifests = {}
+        sources_ast.each do |source_ast|
+          source_type = source_ast[:type]
+          source = source_type.from_lock_options(source_ast[:options])
+          source_ast[:manifests].each do |manifest_name, manifest_ast|
+            manifests[manifest_name] = ManifestPlaceholder.new(
+              source,
+              manifest_name,
+              manifest_ast[:version],
+              manifest_ast[:dependencies].map{|k, v| Dependency.new(k, v, nil)}
+            )
+          end
+        end
+        manifests = manifests.map do |name, manifest|
+          dependencies = manifest.dependencies.map do |d|
+            Dependency.new(d.name, d.requirement, manifests[d.name].source)
+          end
+          manifest.source.manifest(
+            manifest.name,
+            manifest.version,
+            dependencies
+          )
+        end
+        Resolver.new(root_module).sort(manifests)
+      end
+
+      def dsl_class
+        root_module.dsl_class
+      end
+
+    end
+  end
+end

data/lib/librarian/manifest.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+
+require 'librarian/helpers/debug'
+require 'librarian/support/abstract_method'
+
+module Librarian
+  class Manifest
+
+    class Version < Gem::Version
+    end
+
+    include Support::AbstractMethod
+    include Helpers::Debug
+
+    attr_reader :source, :name
+
+    abstract_method :fetch_version!, :fetch_dependencies!
+    abstract_method :install!
+
+    def initialize(source, name)
+      @source = source
+      @name = name
+      @fetched_version = nil
+      @defined_version = nil
+      @fetched_dependencies = nil
+      @defined_dependencies = nil
+    end
+
+    def to_s
+      "#{name}/#{version} <#{source}>"
+    end
+
+    def version
+      @defined_version || @fetched_version ||= _normalize_version(fetch_version!)
+    end
+
+    def version=(version)
+      @defined_version = _normalize_version(version)
+    end
+
+    def version?
+      if @defined_version
+        @fetched_version ||= _normalize_version(fetch_version!)
+        @defined_version == @fetched_version
+      end
+    end
+
+    def dependencies
+      @defined_dependencies || @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+    end
+
+    def dependencies=(dependencies)
+      @defined_dependencies = _normalize_dependencies(dependencies)
+    end
+
+    def dependencies?
+      if @defined_dependencies
+        @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+        @defined_dependencies.zip(@fetched_dependencies).all? do |pair|
+          a, b = *pair
+          a.name == b.name && a.requirement == b.requirement
+        end
+      end
+    end
+
+    def satisfies?(dependency)
+      dependency.requirement.satisfied_by?(version)
+    end
+
+  private
+
+    def root_module
+      source.root_module
+    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{|d| d.name}
+    end
+
+  end
+end

data/lib/librarian/manifest_set.rb

@@ -0,0 +1,131 @@
+require 'set'
+require 'tsort'
+
+module Librarian
+  class ManifestSet
+
+    class GraphHash < Hash
+      include TSort
+      alias tsort_each_node each_key
+      def tsort_each_child(node, &block)
+        self[node].each(&block)
+      end
+    end
+
+    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 sort(manifests)
+        manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
+        manifest_pairs = GraphHash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        manifest_names = manifest_pairs.tsort
+        manifest_names.map{|n| manifests[n]}
+      end
+    private
+      def method_for(manifests)
+        case manifests
+        when Hash
+          :to_hash
+        when Array
+          :to_a
+        end
+      end
+    end
+
+    def initialize(manifests)
+      self.index = Hash === manifests ? manifests.dup : Hash[manifests.map{|m| [m.name, m]}]
+    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)
+      names.each do |name|
+        index.delete(name)
+      end
+      self
+    end
+
+    def deep_strip(names)
+      dup.deep_strip!(names)
+    end
+
+    def deep_strip!(names)
+      names = Array === names ? names.dup : names.to_a
+      until names.empty?
+        name = names.shift
+        manifest = index.delete(name)
+        manifest.dependencies.each do |dependency|
+          names << dependency.name
+        end
+      end
+      self
+    end
+
+    def shallow_keep(names)
+      dup.shallow_keep!(names)
+    end
+
+    def shallow_keep!(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)
+      names = Array === names ? names.dup : names.to_a
+      marks = Set.new
+      until names.empty?
+        keep = names.shift
+        unless marks.include?(keep)
+          marks << keep
+          index[keep].dependencies.each do |d|
+            names << d.name
+          end
+        end
+      end
+      shallow_keep!(marks)
+    end
+
+    def consistent?
+      index.values.all? do |manifest|
+        manifest.dependencies.all? do |dependency|
+          match = index[dependency.name]
+          match && match.satisfies?(dependency)
+        end
+      end
+    end
+
+  private
+
+    attr_accessor :index
+
+  end
+end

data/lib/librarian/mock.rb

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

data/lib/librarian/mock/cli.rb

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

data/lib/librarian/mock/dsl.rb

@@ -0,0 +1,14 @@
+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/extension.rb

@@ -0,0 +1,28 @@
+require 'librarian/specfile'
+require 'librarian/mock/dsl'
+
+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/particularity.rb

@@ -0,0 +1,7 @@
+module Librarian
+  module Particularity
+    def root_module
+      Mock
+    end
+  end
+end

data/lib/librarian/mock/source.rb

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

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

@@ -0,0 +1,88 @@
+require 'librarian/manifest'
+require 'librarian/mock/particularity'
+require 'librarian/mock/source/mock/registry'
+
+module Librarian
+  module Mock
+    module Source
+      class Mock
+
+        class Manifest < Manifest
+          attr_reader :manifest
+          def initialize(source, name, manifest)
+            super(source, name)
+            @manifest = manifest
+          end
+          def fetch_version!
+            manifest[:version]
+          end
+          def fetch_dependencies!
+            manifest[:dependencies]
+          end
+          def install!
+          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})
+          end
+        end
+
+        attr_reader :name
+
+        def initialize(name, options)
+          @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
+          Registry[name]
+        end
+
+        def manifest(name, version, dependencies)
+          Manifest.new(self, name, {:version => version, :dependencies => dependencies})
+        end
+
+        def manifests(dependency)
+          if d = registry[dependency.name]
+            d.map{|v| Manifest.new(self, dependency.name, v)}
+          else
+            nil
+          end
+        end
+
+        def cache!(dependencies)
+        end
+
+        def to_s
+          name
+        end
+
+      end
+    end
+  end
+end