librarian 0.0.1

data/lib/librarian/source/path.rb

@@ -0,0 +1,52 @@
+require 'librarian/particularity'
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Path
+
+      include Particularity
+      include Local
+
+      class << self
+        LOCK_NAME = 'PATH'
+        def lock_name
+          LOCK_NAME
+        end
+        def from_lock_options(options)
+          new(options[:remote], options.reject{|k, v| k == :remote})
+        end
+      end
+
+      attr_reader :path
+
+      def initialize(path, options)
+        @path = Pathname.new(path).expand_path(root_module.project_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
+        absolute_path = path.absolute? ? path : path.expand_path(root_module.project_path)
+        relative_path = path.relative? ? path : path.relative_path_from(root_module.project_path)
+        {:remote => relative_path.to_s[0, 3] == '../' ? absolute_path : relative_path}
+      end
+
+      def cache!(dependencies)
+      end
+
+    end
+  end
+end

data/lib/librarian/spec.rb

@@ -0,0 +1,11 @@
+module Librarian
+  class Spec
+
+    attr_reader :source, :dependencies
+
+    def initialize(source, dependencies)
+      @source, @dependencies = source, dependencies
+    end
+
+  end
+end

data/lib/librarian/spec_change_set.rb

@@ -0,0 +1,169 @@
+require 'librarian/helpers'
+require 'librarian/helpers/debug'
+
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+require 'librarian/spec'
+
+module Librarian
+  class SpecChangeSet
+
+    include Helpers::Debug
+
+    attr_reader :root_module
+    attr_reader :spec, :lock
+
+    def initialize(root_module, spec, lock)
+      @root_module = root_module
+      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]
+        lock_manifest.source == spec.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
+
+  end
+end

data/lib/librarian/specfile.rb

@@ -0,0 +1,16 @@
+module Librarian
+  class Specfile
+
+    attr_reader :root_module, :path, :dependencies, :source
+
+    def initialize(root_module, path)
+      @root_module = root_module
+      @path = path
+    end
+
+    def read(precache_sources = [])
+      root_module.dsl_class.run(self, 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

data/lib/librarian/ui.rb

@@ -0,0 +1,64 @@
+require 'rubygems/user_interaction'
+
+module Librarian
+  class UI
+    def warn(message = nil)
+    end
+
+    def debug(message = nil)
+    end
+
+    def error(message = nil)
+    end
+
+    def info(message = nil)
+    end
+
+    def confirm(message = nil)
+    end
+
+    class Shell < UI
+      attr_writer :shell
+      attr_reader :debug_line_numbers
+
+      def initialize(shell)
+        @shell = shell
+        @quiet = false
+        @debug = ENV['DEBUG']
+        @debug_line_numbers = false
+      end
+
+      def debug(message = nil)
+        @shell.say(message || yield) if @debug && !@quiet
+      end
+
+      def info(message = nil)
+        @shell.say(message || yield) if !@quiet
+      end
+
+      def confirm(message = nil)
+        @shell.say(message || yield, :green) if !@quiet
+      end
+
+      def warn(message = nil)
+        @shell.say(message || yield, :yellow)
+      end
+
+      def error(message = nil)
+        @shell.say(message || yield, :red)
+      end
+
+      def be_quiet!
+        @quiet = true
+      end
+
+      def debug!
+        @debug = true
+      end
+
+      def debug_line_numbers!
+        @debug_line_numbers = true
+      end
+    end
+  end
+end

data/lib/librarian/version.rb

@@ -0,0 +1,3 @@
+module Librarian
+  VERSION = "0.0.1"
+end

data/librarian.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "librarian/version"
+
+Gem::Specification.new do |s|
+  s.name        = "librarian"
+  s.version     = Librarian::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jay Feldblum"]
+  s.email       = ["y_feldblum@yahoo.com"]
+  s.homepage    = ""
+  s.summary     = %q{Librarian}
+  s.description = %q{Librarian}
+
+  s.rubyforge_project = "librarian"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "thor"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "aruba"
+
+  s.add_development_dependency "chef", ">= 0.10"
+end

data/spec/chef/git_source_spec.rb

@@ -0,0 +1,93 @@
+require 'pathname'
+require 'securerandom'
+
+require 'librarian'
+require 'librarian/helpers'
+require 'librarian/chef'
+
+module Librarian
+  module Chef
+    module Source
+      describe Git do
+
+        project_path = Pathname.new(__FILE__).expand_path
+        project_path = project_path.dirname until project_path.join("Rakefile").exist?
+        tmp_path = project_path.join("tmp/spec/chef/git-source")
+        sample_path = tmp_path.join('sample')
+        sample_metadata = Helpers.strip_heredoc(<<-METADATA)
+          version '0.6.5'
+        METADATA
+
+        before :all do
+          sample_path.rmtree if sample_path.exist?
+          sample_path.mkpath
+          sample_path.join('metadata.rb').open('wb') { |f| f.write(sample_metadata) }
+          Dir.chdir(sample_path) do
+            `git init`
+            `git add metadata.rb`
+            `git commit -m "Initial commit."`
+          end
+        end
+
+        context "a single dependency with a git source" do
+
+          it "should resolve" do
+            repo_path = tmp_path.join('repo/resolve')
+            repo_path.rmtree if repo_path.exist?
+            repo_path.mkpath
+            repo_path.join('cookbooks').mkpath
+            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+              #!/usr/bin/env ruby
+              cookbook "sample", :git => #{sample_path.to_s.inspect}
+            CHEFFILE
+            repo_path.join('Cheffile').open('wb') { |f| f.write(cheffile) }
+            Chef.stub!(:project_path) { repo_path }
+
+            Chef.resolve!
+            repo_path.join('Cheffile.lock').should be_exist
+            repo_path.join('cookbooks/sample').should_not be_exist
+          end
+
+          it "should install" do
+            repo_path = tmp_path.join('repo/install')
+            repo_path.rmtree if repo_path.exist?
+            repo_path.mkpath
+            repo_path.join('cookbooks').mkpath
+            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+              #!/usr/bin/env ruby
+              cookbook "sample", :git => #{sample_path.to_s.inspect}
+            CHEFFILE
+            repo_path.join('Cheffile').open('wb') { |f| f.write(cheffile) }
+            Chef.stub!(:project_path) { repo_path }
+
+            Chef.install!
+            repo_path.join('Cheffile.lock').should be_exist
+            repo_path.join('cookbooks/sample').should be_exist
+            repo_path.join('cookbooks/sample/metadata.rb').should be_exist
+          end
+
+          it "should resolve and separately install" do
+            repo_path = tmp_path.join('repo/resolve-install')
+            repo_path.rmtree if repo_path.exist?
+            repo_path.mkpath
+            repo_path.join('cookbooks').mkpath
+            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+              #!/usr/bin/env ruby
+              cookbook "sample", :git => #{sample_path.to_s.inspect}
+            CHEFFILE
+            repo_path.join('Cheffile').open('wb') { |f| f.write(cheffile) }
+            Chef.stub!(:project_path) { repo_path }
+
+            Chef.resolve!
+            repo_path.join('tmp').rmtree if repo_path.join('tmp').exist?
+            Chef.install!
+            repo_path.join('cookbooks/sample').should be_exist
+            repo_path.join('cookbooks/sample/metadata.rb').should be_exist
+          end
+
+        end
+
+      end
+    end
+  end
+end