librarian 0.0.20 → 0.0.21

data/lib/librarian/resolution.rb

@@ -1,4 +1,15 @@
 module Librarian
+  #
+  # Represents the output of the resolution process. Captures the declared
+  # dependencies plus the full set of resolved manifests. The sources are
+  # already known by the dependencies and by the resolved manifests, so they do
+  # not need to be captured explicitly.
+  #
+  # This representation may be produced by the resolver, may be serialized into
+  # a lockfile, and may be deserialized from a lockfile. It is expected that the
+  # lockfile is a direct representation in text of this representation, so that
+  # the serialization-deserialization process is just the identity function.
+  #
   class Resolution
     attr_reader :dependencies, :manifests, :manifests_index
 

data/lib/librarian/source/git.rb

@@ -12,13 +12,25 @@ module Librarian
       include Local
 
       class << self
+
         LOCK_NAME = 'GIT'
+
         def lock_name
           LOCK_NAME
         end
+
         def from_lock_options(environment, options)
           new(environment, options[:remote], options.reject{|k, v| k == :remote})
         end
+
+        def from_spec_args(environment, uri, options)
+          recognized_options = [:ref, :path]
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, uri, options)
+        end
+
       end
 
       DEFAULTS = {
@@ -29,7 +41,7 @@ module Librarian
       private :environment=
       attr_reader :uri, :ref, :sha, :path
 
-      def initialize(environment, uri, options = {})
+      def initialize(environment, uri, options)
         self.environment = environment
         @uri = uri
         @ref = options[:ref] || DEFAULTS[:ref]
@@ -73,7 +85,7 @@ module Librarian
         @sha = nil
       end
 
-      def cache!(dependencies)
+      def cache!(names)
         unless repository.git?
           repository.path.rmtree if repository.path.exist?
           repository.path.mkpath

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

@@ -15,18 +15,40 @@ module Librarian
             git.clone!(repository_url)
             git
           end
+
+          def bin
+            @bin ||= which("git") or raise Error, "cannot find git"
+          end
+
+          private
+
+          # 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.executable?(exe)
+              end
+            end
+            nil
+          end
         end
 
         include Helpers::Debug
 
-        attr_accessor :environment
-        private :environment=
-        attr_reader :path
+        attr_accessor :environment, :path
+        private :environment=, :path=
 
         def initialize(environment, path)
           self.environment = environment
-          path = Pathname.new(path)
-          @path = path
+          self.path = Pathname.new(path)
         end
 
         def git?
@@ -38,57 +60,45 @@ module Librarian
         end
 
         def clone!(repository_url)
-          within do
-            command = "clone #{repository_url} ."
-            run!(command)
-          end
+          command = %W(clone #{repository_url} . --quiet)
+          run!(command, :chdir => true)
         end
 
         def checkout!(reference, options ={ })
-          within do
-            command = "checkout #{reference}"
-            command <<  " --force" if options[:force]
-            run!(command)
-          end
+          command = %W(checkout #{reference} --quiet)
+          command <<  "--force" if options[:force]
+          run!(command, :chdir => true)
         end
 
         def fetch!(remote, options = { })
-          within do
-            command = "fetch #{remote}"
-            command << " --tags" if options[:tags]
-            run!(command)
-          end
+          command = %W(fetch #{remote} --quiet)
+          command << "--tags" if options[:tags]
+          run!(command, :chdir => true)
         end
 
         def reset_hard!
-          within do
-            command = "reset --hard"
-            run!(command)
-          end
+          command = %W(reset --hard --quiet)
+          run!(command, :chdir => true)
         end
 
         def remote_names
-          within do
-            command = "remote"
-            run!(command, false).strip.lines.map(&:strip)
-          end
+          command = %W(remote)
+          run!(command, :chdir => true).strip.lines.map(&:strip)
         end
 
         def remote_branch_names
           remotes = remote_names.sort_by(&:length).reverse
 
-          within do
-            command = "branch -r"
-            names = run!(command, false).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
+          command = %W(branch -r)
+          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)
@@ -97,34 +107,45 @@ module Librarian
             reference = "#{remote}/#{reference}"
           end
 
-          within do
-            command = "rev-parse #{reference}"
-            run!(command).strip
-          end
+          command = %W(rev-parse #{reference} --quiet)
+          run!(command, :chdir => true).strip
         end
 
         def current_commit_hash
-          within do
-            command = "rev-parse HEAD"
-            run!(command).strip!
-          end
+          command = %W(rev-parse HEAD --quiet)
+          run!(command, :chdir => true).strip!
         end
+
       private
 
-        def run!(text, quiet = true)
-          text = "git #{text}"
-          text << " --quiet" if quiet
-          debug { "Running `#{text}` in #{relative_path_to(Dir.pwd)}" }
-          out = Open3.popen3(text) do |i, o, e, t|
-            raise StandardError, e.read unless (t ? t.value : $?).success?
-            o.read
+        def bin
+          self.class.bin
+        end
+
+        def run!(args, options = { })
+          chdir = options.delete(:chdir)
+          chdir = path.to_s if chdir == true
+
+          command = [bin]
+          command.concat(args)
+
+          maybe_within(chdir) do
+            debug { "Running `#{command.join(' ')}` in #{relative_path_to(Dir.pwd)}" }
+            out = Open3.popen3(*command) do |i, o, e, t|
+              raise StandardError, e.read unless (t ? t.value : $?).success?
+              o.read
+            end
+            debug { "    ->  #{out}" } if out.size > 0
+            out
           end
-          debug { "    ->  #{out}" } if out.size > 0
-          out
         end
 
-        def within
-          Dir.chdir(path) { yield }
+        def maybe_within(path)
+          if path
+            Dir.chdir(path) { yield }
+          else
+            yield
+          end
         end
 
       end

data/lib/librarian/source/local.rb

@@ -1,3 +1,4 @@
+require 'librarian/helpers/debug'
 require 'librarian/support/abstract_method'
 
 module Librarian
@@ -7,27 +8,40 @@ module Librarian
     #   #environment
     module Local
 
+      include Helpers::Debug
       include Support::AbstractMethod
 
       abstract_method :path
 
-      def manifests(dependency)
-        manifest = manifest_class.create(self, dependency, filesystem_path)
+      def manifests(name)
+        manifest = Manifest.new(self, name)
         [manifest].compact
       end
 
       def manifest(name, version, dependencies)
-        manifest = manifest_class.create(self, Dependency.new(name, nil, nil), filesystem_path)
+        manifest = Manifest.new(self, name)
         manifest.version = version
         manifest.dependencies = dependencies
         manifest
       end
 
-      def manifest_search_paths(dependency)
-        paths = [filesystem_path, filesystem_path.join(dependency.name)]
+      def manifest_search_paths(name)
+        paths = [filesystem_path, filesystem_path.join(name)]
         paths.select{|s| s.exist?}
       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
+
     end
   end
 end

data/lib/librarian/source/path.rb

@@ -7,13 +7,25 @@ module Librarian
       include Local
 
       class << self
+
         LOCK_NAME = 'PATH'
+
         def lock_name
           LOCK_NAME
         end
+
         def from_lock_options(environment, options)
           new(environment, options[:remote], options.reject{|k, v| k == :remote})
         end
+
+        def from_spec_args(environment, path, options)
+          recognized_options = []
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, path, options)
+        end
+
       end
 
       attr_accessor :environment
@@ -50,7 +62,7 @@ module Librarian
       def unpin!
       end
 
-      def cache!(dependencies)
+      def cache!(names)
       end
 
       def filesystem_path

data/lib/librarian/specfile.rb

@@ -15,7 +15,7 @@ module Librarian
     end
 
     def read(precache_sources = [])
-      environment.dsl_class.run(environment, path.read, precache_sources)
+      environment.dsl(path.read, precache_sources)
     end
 
   end

data/lib/librarian/version.rb

@@ -1,3 +1,3 @@
 module Librarian
-  VERSION = "0.0.20"
+  VERSION = "0.0.21"
 end

data/librarian.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "thor"
+  s.add_dependency "thor", "~> 0.15"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"

data/spec/unit/action/clean_spec.rb

@@ -22,7 +22,6 @@ module Librarian
 
           before do
             action.stub(:clean_install_path)
-            action.stub(:clean_lockfile_path)
           end
 
           context "when the cache path is missing" do
@@ -51,7 +50,6 @@ module Librarian
 
           before do
             action.stub(:clean_cache_path)
-            action.stub(:clean_lockfile_path)
           end
 
           context "when the install path is missing" do
@@ -96,35 +94,6 @@ module Librarian
 
         end
 
-        describe "clearing the lockfile path" do
-
-          before do
-            action.stub(:clean_cache_path)
-            action.stub(:clean_install_path)
-          end
-
-          context "when the lockfile path is missing" do
-            before do
-              env.stub_chain(:lockfile_path, :exist?) { false }
-            end
-
-            it "should not try to clear the lockfile path" do
-              env.lockfile_path.should_receive(:rmtree).never
-            end
-          end
-
-          context "when the lockfile path is present" do
-            before do
-              env.stub_chain(:lockfile_path, :exist?) { true }
-            end
-
-            it "should try to clear the lockfile path" do
-              env.lockfile_path.should_receive(:rmtree).exactly(:once)
-            end
-          end
-
-        end
-
       end
 
     end

data/spec/unit/action/install_spec.rb

@@ -63,8 +63,12 @@ module Librarian
 
         describe "performing the install" do
 
-          let(:manifests) { [mock, mock, mock] }
-          let(:sorted_manifests) { [mock, mock, mock, mock] }
+          def mock_manifest(i)
+            double(:name => "manifest-#{i}")
+          end
+
+          let(:manifests) { 3.times.map{|i| mock_manifest(i)} }
+          let(:sorted_manifests) { 4.times.map{|i| mock_manifest(i + 3)} }
           let(:install_path) { mock }
 
           before do
@@ -83,7 +87,7 @@ module Librarian
             sorted_manifests.each do |manifest|
               source = mock
               manifest.stub(:source) { source }
-              source.should_receive(:cache!).with([manifest]).exactly(:once).ordered
+              source.should_receive(:cache!).with([manifest.name]).exactly(:once).ordered
             end
 
             install_path.stub(:exist?) { false }

data/spec/unit/dsl_spec.rb

@@ -174,6 +174,20 @@ module Librarian
 
       end
 
+      context "validating source options" do
+
+        it "should raise when given unrecognized optiosn options" do
+          expect do
+            env.dsl do
+              dep 'dependency-1',
+                :src => 'source-1',
+                :huh => 'yikes'
+            end
+          end.to raise_error(Error, %{unrecognized options: huh})
+        end
+
+      end
+
     end
 
   end