librarian 0.0.9 → 0.0.10

data/lib/librarian/source/git.rb

@@ -2,7 +2,6 @@ require 'fileutils'
 require 'pathname'
 require 'digest'
 
-require 'librarian/particularity'
 require 'librarian/source/git/repository'
 require 'librarian/source/local'
 
@@ -10,7 +9,6 @@ module Librarian
   module Source
     class Git
 
-      include Particularity
       include Local
 
       class << self
@@ -18,8 +16,8 @@ module Librarian
         def lock_name
           LOCK_NAME
         end
-        def from_lock_options(options)
-          new(options[:remote], options.reject{|k, v| k == :remote})
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
         end
       end
 
@@ -27,9 +25,12 @@ module Librarian
         :ref => 'master'
       }
 
+      attr_accessor :environment
+      private :environment=
       attr_reader :uri, :ref, :sha, :path
 
-      def initialize(uri, options = {})
+      def initialize(environment, uri, options = {})
+        self.environment = environment
         @uri = uri
         @ref = options[:ref] || DEFAULTS[:ref]
         @sha = options[:sha]
@@ -80,13 +81,13 @@ module Librarian
         @repository_cache_path ||= begin
           dir = path ? "#{uri}/#{path}" : uri
           dir = Digest::MD5.hexdigest(dir)
-          root_module.cache_path.join("source/git/#{dir}")
+          environment.cache_path.join("source/git/#{dir}")
         end
       end
 
       def repository
         @repository ||= begin
-          Repository.new(root_module, repository_cache_path)
+          Repository.new(environment, repository_cache_path)
         end
       end
 

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

@@ -8,10 +8,10 @@ module Librarian
       class Repository
 
         class << self
-          def clone!(root_module, path, repository_url)
+          def clone!(environment, path, repository_url)
             path = Pathname.new(path)
             path.mkpath
-            git = new(root_module, path)
+            git = new(environment, path)
             git.clone!(repository_url)
             git
           end
@@ -19,11 +19,13 @@ module Librarian
 
         include Helpers::Debug
 
-        attr_reader :root_module, :path
+        attr_accessor :environment
+        private :environment=
+        attr_reader :path
 
-        def initialize(root_module, path)
+        def initialize(environment, path)
+          self.environment = environment
           path = Pathname.new(path)
-          @root_module = root_module
           @path = path
         end
 

data/lib/librarian/source/local.rb

@@ -4,7 +4,7 @@ module Librarian
   module Source
     # Requires that the including source class have methods:
     #   #path
-    #   #root_module
+    #   #environment
     module Local
 
       include Support::AbstractMethod

data/lib/librarian/source/path.rb

@@ -1,11 +1,9 @@
-require 'librarian/particularity'
 require 'librarian/source/local'
 
 module Librarian
   module Source
     class Path
 
-      include Particularity
       include Local
 
       class << self
@@ -13,14 +11,17 @@ module Librarian
         def lock_name
           LOCK_NAME
         end
-        def from_lock_options(options)
-          new(options[:remote], options.reject{|k, v| k == :remote})
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
         end
       end
 
+      attr_accessor :environment
+      private :environment=
       attr_reader :path
 
-      def initialize(path, options)
+      def initialize(environment, path, options)
+        self.environment = environment
         @path = path
       end
 
@@ -46,7 +47,7 @@ module Librarian
       end
 
       def filesystem_path
-        @filesystem_path ||= Pathname.new(path).expand_path(root_module.project_path)
+        @filesystem_path ||= Pathname.new(path).expand_path(environment.project_path)
       end
 
     end

data/lib/librarian/spec_change_set.rb

@@ -10,13 +10,14 @@ module Librarian
 
     include Helpers::Debug
 
-    attr_reader :root_module
+    attr_accessor :environment
+    private :environment=
     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
+    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
 

data/lib/librarian/specfile.rb

@@ -1,15 +1,21 @@
+require 'librarian/helpers/debug'
+
 module Librarian
   class Specfile
 
-    attr_reader :root_module, :path, :dependencies, :source
+    include Helpers::Debug
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :path, :dependencies, :source
 
-    def initialize(root_module, path)
-      @root_module = root_module
+    def initialize(environment, path)
+      self.environment = environment
       @path = path
     end
 
     def read(precache_sources = [])
-      root_module.dsl_class.run(self, precache_sources)
+      environment.dsl_class.run(environment, path.read, precache_sources)
     end
 
   end

data/lib/librarian/version.rb

@@ -1,3 +1,3 @@
 module Librarian
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/librarian.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "thor"
 
+  s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "cucumber"
   s.add_development_dependency "aruba"

data/spec/functional/chef/source/git_spec.rb

@@ -3,6 +3,9 @@ require 'securerandom'
 
 require 'librarian'
 require 'librarian/helpers'
+require 'librarian/error'
+require 'librarian/action/resolve'
+require 'librarian/action/install'
 require 'librarian/chef'
 
 module Librarian
@@ -19,6 +22,9 @@ module Librarian
 
         let(:cookbooks_path) { tmp_path.join("cookbooks") }
 
+        # depends on repo_path being defined in each context
+        let(:env) { Environment.new(:project_path => repo_path) }
+
         context "a single dependency with a git source" do
 
           let(:sample_path) { tmp_path.join("sample") }
@@ -65,82 +71,137 @@ module Librarian
             end
           end
 
-          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 }
+          context "resolving" do
+            let(:repo_path) { tmp_path.join("repo/resolve") }
+            before do
+              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) }
+            end
+
+            context "the resolve" do
+              it "should not raise an exception" do
+                expect { Action::Resolve.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Resolve.new(env).run }
 
-            Chef.resolve!
-            repo_path.join("Cheffile.lock").should exist
-            repo_path.join("cookbooks/sample").should_not exist
+              it "should create the lockfile" do
+                repo_path.join("Cheffile.lock").should exist
+              end
+
+              it "should not attempt to install the sample cookbok" do
+                repo_path.join("cookbooks/sample").should_not exist
+              end
+            end
           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 }
+          context "installing" do
+            let(:repo_path) { tmp_path.join("repo/install") }
+            before do
+              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) }
+
+              Action::Resolve.new(env).run
+            end
+
+            context "the install" do
+              it "should not raise an exception" do
+                expect { Action::Install.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Install.new(env).run }
 
-            Chef.install!
-            repo_path.join("Cheffile.lock").should exist
-            repo_path.join("cookbooks/sample").should exist
-            repo_path.join("cookbooks/sample/metadata.rb").should exist
+              it "should create the lockfile" do
+                repo_path.join("Cheffile.lock").should exist
+              end
+
+              it "should create the directory for the cookbook" do
+                repo_path.join("cookbooks/sample").should exist
+              end
+
+              it "should copy the cookbook files into the cookbook directory" do
+                repo_path.join("cookbooks/sample/metadata.rb").should exist
+              end
+            end
           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 }
+          context "resolving and and separately installing" do
+            let(:repo_path) { tmp_path.join("repo/resolve-install") }
+            before do
+              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.resolve!
-            repo_path.join("tmp").rmtree if repo_path.join("tmp").exist?
-            Chef.install!
-            repo_path.join("cookbooks/sample").should exist
-            repo_path.join("cookbooks/sample/metadata.rb").should exist
+              Action::Resolve.new(env).run
+              repo_path.join("tmp").rmtree if repo_path.join("tmp").exist?
+            end
+
+            context "the install" do
+              it "should not raise an exception" do
+                expect { Action::Install.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Install.new(env).run }
+
+              it "should create the directory for the cookbook" do
+                repo_path.join("cookbooks/sample").should exist
+              end
+
+              it "should copy the cookbook files into the cookbook directory" do
+                repo_path.join("cookbooks/sample/metadata.rb").should exist
+              end
+            end
           end
 
-          it "should resolve, change, and resolve" do
-            repo_path = tmp_path.join("repo/resolve-update")
-            repo_path.rmtree if repo_path.exist?
-            repo_path.mkpath
-            repo_path.join("cookbooks").mkpath
-            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
-              git #{cookbooks_path.to_s.inspect}
-              cookbook "first-sample"
-            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 exist
+          context "resolving, changing, and resolving" do
+            let(:repo_path) { tmp_path.join("repo/resolve-update") }
+            before do
+              repo_path.rmtree if repo_path.exist?
+              repo_path.mkpath
+              repo_path.join("cookbooks").mkpath
+              cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+                git #{cookbooks_path.to_s.inspect}
+                cookbook "first-sample"
+              CHEFFILE
+              repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+              Action::Resolve.new(env).run
 
-            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
-              git #{cookbooks_path.to_s.inspect}
-              cookbook "first-sample"
-              cookbook "second-sample"
-            CHEFFILE
-            repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-            Chef.stub!(:project_path) { repo_path }
-            Chef.resolve!
+              cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+                git #{cookbooks_path.to_s.inspect}
+                cookbook "first-sample"
+                cookbook "second-sample"
+              CHEFFILE
+              repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+            end
+
+            context "the second resolve" do
+              it "should not raise an exception" do
+                expect { Action::Resolve.new(env).run }.to_not raise_error
+              end
+            end
           end
 
         end
@@ -168,8 +229,8 @@ module Librarian
           end
 
           context "if no path option is given" do
-            it "should not resolve" do
-              repo_path = tmp_path.join("repo/resolve")
+            let(:repo_path) { tmp_path.join("repo/resolve") }
+            before do
               repo_path.rmtree if repo_path.exist?
               repo_path.mkpath
               repo_path.join("cookbooks").mkpath
@@ -179,15 +240,16 @@ module Librarian
                   :git => #{git_path.to_s.inspect}
               CHEFFILE
               repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-              Chef.stub!(:project_path) { repo_path }
+            end
 
-              expect{ Chef.resolve! }.to raise_error
+            it "should not resolve" do
+              expect{ Action::Resolve.new(env).run }.to raise_error
             end
           end
 
           context "if the path option is wrong" do
-            it "should not resolve" do
-              repo_path = tmp_path.join("repo/resolve")
+            let(:repo_path) { tmp_path.join("repo/resolve") }
+            before do
               repo_path.rmtree if repo_path.exist?
               repo_path.mkpath
               repo_path.join("cookbooks").mkpath
@@ -198,18 +260,19 @@ module Librarian
                   :path => "jelly"
               CHEFFILE
               repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-              Chef.stub!(:project_path) { repo_path }
+            end
 
-              expect{ Chef.resolve! }.to raise_error
+            it "should not resolve" do
+              expect{ Action::Resolve.new(env).run }.to raise_error
             end
           end
 
           context "if the path option is right" do
-            it "should not resolve" do
-              repo_path = tmp_path.join('repo/resolve')
+            let(:repo_path) { tmp_path.join("repo/resolve") }
+            before do
               repo_path.rmtree if repo_path.exist?
               repo_path.mkpath
-              repo_path.join('cookbooks').mkpath
+              repo_path.join("cookbooks").mkpath
               cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
                 #!/usr/bin/env ruby
                 cookbook "sample",
@@ -217,11 +280,20 @@ module Librarian
                   :path => "buttercup"
               CHEFFILE
               repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-              Chef.stub!(:project_path) { repo_path }
+            end
 
-              Chef.resolve!
-              repo_path.join("Cheffile.lock").should exist
-              repo_path.join("cookbooks/sample").should_not exist
+            context "the resolve" do
+              it "should not raise an exception" do
+                expect { Action::Resolve.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Resolve.new(env).run }
+
+              it "should create the lockfile" do
+                repo_path.join("Cheffile.lock").should exist
+              end
             end
           end
 
@@ -229,9 +301,8 @@ module Librarian
 
         context "missing a metadata" do
           let(:git_path) { tmp_path.join("big-git-repo") }
-
-          it "should explain the problem" do
-            repo_path = tmp_path.join("repo/resolve")
+          let(:repo_path) { tmp_path.join("repo/resolve") }
+          before do
             repo_path.rmtree if repo_path.exist?
             repo_path.mkpath
             repo_path.join("cookbooks").mkpath
@@ -240,12 +311,29 @@ module Librarian
                 :git => #{git_path.to_s.inspect}
             CHEFFILE
             repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-            Chef.stub!(:project_path) { repo_path }
+          end
 
-            expect { Chef.resolve! }.
-              to raise_error(Librarian::Error, /no metadata file found/i)
-            repo_path.join("Cheffile.lock").should_not exist
-            repo_path.join("cookbooks/sample").should_not exist
+          context "the resolve" do
+            it "should raise an exception" do
+              expect { Action::Resolve.new(env).run }.to raise_error
+            end
+
+            it "should explain the problem" do
+              expect { Action::Resolve.new(env).run }.
+                to raise_error(Error, /no metadata file found/i)
+            end
+          end
+
+          context "the results" do
+            before { Action::Resolve.new(env).run rescue nil }
+
+            it "should not create the lockfile" do
+              repo_path.join("Cheffile.lock").should_not exist
+            end
+
+            it "should not create the directory for the cookbook" do
+              repo_path.join("cookbooks/sample").should_not exist
+            end
           end
         end