librarian 0.0.20 → 0.0.21

data/.travis.yml

@@ -3,3 +3,4 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
+  - rbx

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Change Log
 
+## 0.0.21
+
+* \#64. Sources now raise when given unrecognized options in the specfile.
+
+* A new `show` CLI command.
+
+* Changed the `clean` CLI command no longer to delete the lockfile.
+
+* Simplify the architecture of `Librarian::Manifest` vis-a-vis sources. It is no
+  longer a base class for adapters to inherit. Now, sources expose a small
+  interface, which `Librarian::Manifest` can call, for delay-loading attributes.
+
+* The git source now resolves the `git` binary before `chdir`ing.
+
+* Test on Rubinius.
+
 ## 0.0.20
 
 * A command to print outdated dependencies.

data/README.md

@@ -1,4 +1,4 @@
-Librarian
+Librarian [![Build Status](https://secure.travis-ci.org/applicationsonline/librarian.png)](http://travis-ci.org/applicationsonline/librarian)
 =========
 
 Librarian is a framework for writing bundlers, which are tools that resolve,
@@ -19,7 +19,7 @@ Librarian-Chef
 ---------------
 
 Librarian-Chef is a bundler for infrastructure repositories using Chef. You can
-use Librarian-Chef to resolve your infrastructure's cookbook dependencies and
+use Librarian-Chef to resolve your infrastructure's cookbook dependencies,
 fetch them and install them into your infrastructure.
 
 Librarian-Chef is for resolving and fetching third-party, publicly-released
@@ -29,15 +29,15 @@ infrastructure repository.
 
 Librarian-Chef *takes over* your `cookbooks/` directory and manages it for you
 based on your `Cheffile`. Your `Cheffile` becomes the authoritative source for
-what cookbooks your infrastructure repository depends on. You should not modify
+the cookbooks your infrastructure repository depends on. You should not modify
 the contents of your `cookbooks/` directory when using Librarian-Chef. If you
-have custom cookbooks specific to your infrastructure repository that you need,
-those should go in your `site-cookbooks/` directory.
+have custom cookbooks which are specific to your infrastructure repository,
+they should go in your `site-cookbooks/` directory.
 
 ### The Cheffile
 
 Every infrastruture repository that uses Librarian-Chef will have a file named
-`Cheffile` in the root directory of the repository. The full specification for
+`Cheffile` in the root directory of that repository. The full specification for
 which third-party, publicly-rleased cookbooks your infrastructure repository
 depends will go here.
 
@@ -91,10 +91,10 @@ Our infrastructure repository depends on the `rvm` cookbook, but not the one
 from the default source. Instead, the cookbook is to be fetched from the
 specified Git repository and from the specified Git tag only.
 
-We do not have to use a `:ref =>`. If we do not, then Librarian-Chef will assume
-we meant the branch `master`. (In the future, this will be changed to whatever
-branch is the default branch according to the Git remote, which may not be
-`master`.)
+When using a Git source, we do not have to use a `:ref =>`. If we do not,
+then Librarian-Chef will assume we meant the `master` branch. (In the future,
+this will be changed to whatever branch is the default branch according to
+the Git remote, which may not be `master`.)
 
 If we use a `:ref =>`, we can use anything that Git will recognize as a ref.
 This includes any branch name, tag name, SHA, or SHA unique prefix. If we use a
@@ -122,7 +122,7 @@ option.
 
 ### How to Use
 
-Install librarian-chef:
+Install Librarian-Chef:
 
     $ gem install librarian
 
@@ -171,12 +171,11 @@ This is the same `Cheffile` we saw above.
     $ librarian-chef install [--clean] [--verbose]
 
 This command looks at each `cookbook` declaration and fetches the cookbook from
-the source specified for that cookbook, or from the default source if none is
-provided for that cookbook.
+the source specified, or from the default source if none is provided.
 
-Each cookbook is inspected and its dependencies determined, and each dependency
-is also fetched. For example, if you declare `cookbook 'nagios'`, and that
-cookbook depends on other cookbooks such as `'php'`, then those other cookbooks
+Each cookbook is inspected, its dependencies are determined, and each dependency
+is also fetched. For example, if you declare `cookbook 'nagios'`, which
+depends on other cookbooks such as `'php'`, then those other cookbooks
 including `'php'` will be fetched. This goes all the way down the chain of
 dependencies.
 
@@ -193,11 +192,19 @@ Check your `Cheffile` and `Cheffile.lock` into version control:
     $ git add Cheffile.lock
     $ git commit -m "I want these particular versions of these particular cookbooks from these particular."
 
-Make sure you check your Cheffile.lock into version control. This will ensure
+Make sure you check your `Cheffile.lock` into version control. This will ensure
 dependencies do not need to be resolved every run, greatly reducing dependency
 resolution time.
 
-Update your cheffile with new/changed/removed constraints/sources/dependencies:
+Get an overview of your `Cheffile.lock` with:
+
+    $ librarian-chef show
+
+Inspect the details of specific resolved dependencies with:
+
+    $ librarian-chef show NAME1 [NAME2, ...]
+
+Update your `Cheffile` with new/changed/removed constraints/sources/dependencies:
 
     $ cat Cheffile
         site 'http://community.opscode.com/api/v1'

data/features/chef/cli/show.feature

@@ -0,0 +1,65 @@
+Feature: cli/show
+
+
+
+  Background: A simple Cheffile with one cookbook with one dependency
+    Given a file named "cookbook-sources/main/metadata.yaml" with:
+      """
+      name: main
+      version: 1.0.0
+      dependencies:
+        sub: 1.0.0
+      """
+    Given a file named "cookbook-sources/sub/metadata.yaml" with:
+      """
+      name: sub
+      version: 1.0.0
+      dependencies: {}
+      """
+    Given a file named "Cheffile" with:
+      """
+      path 'cookbook-sources'
+      cookbook 'main'
+      """
+    Given I run `librarian-chef install`
+
+
+
+  Scenario: Showing all
+    When I run `librarian-chef show`
+    Then the exit status should be 0
+    Then the output should contain exactly:
+      """
+      main (1.0.0)
+      sub (1.0.0)
+
+      """
+
+
+
+  Scenario: Showing one without dependencies
+    When I run `librarian-chef show sub`
+    Then the exit status should be 0
+    Then the output should contain exactly:
+      """
+      sub (1.0.0)
+        source: cookbook-sources
+
+      """
+
+
+
+  Scenario: Showing one with dependencies
+    When I run `librarian-chef show main`
+    Then the exit status should be 0
+    Then the output should contain exactly:
+      """
+      main (1.0.0)
+        source: cookbook-sources
+        dependencies:
+          sub (= 1.0.0)
+
+      """
+
+
+

data/features/support/env.rb

@@ -1,5 +1,9 @@
 require 'aruba/cucumber'
 
 Before do
-  @aruba_timeout_seconds = 2
+  slow_boot = false
+  slow_boot ||= RUBY_PLATFORM == "java"
+  slow_boot ||= defined?(::Rubinius)
+
+  @aruba_timeout_seconds = slow_boot ? 5 : 2
 end

data/lib/librarian/action/clean.rb

@@ -7,7 +7,6 @@ module Librarian
       def run
         clean_cache_path
         clean_install_path
-        clean_lockfile_path
       end
 
     private
@@ -28,13 +27,6 @@ module Librarian
         end
       end
 
-      def clean_lockfile_path
-        if lockfile_path.exist?
-          debug { "Deleting #{project_relative_path_to(lockfile_path)}" }
-          lockfile_path.rmtree
-        end
-      end
-
       def cache_path
         environment.cache_path
       end
@@ -43,10 +35,6 @@ module Librarian
         environment.install_path
       end
 
-      def lockfile_path
-        environment.lockfile_path
-      end
-
       def project_relative_path_to(path)
         environment.project_relative_path_to(path)
       end

data/lib/librarian/action/install.rb

@@ -42,7 +42,7 @@ module Librarian
 
       def cache_manifests(manifests)
         manifests.each do |manifest|
-          manifest.source.cache!([manifest])
+          manifest.source.cache!([manifest.name])
         end
       end
 

data/lib/librarian/chef/manifest_reader.rb

@@ -0,0 +1,47 @@
+require 'json'
+require 'yaml'
+
+require 'librarian/manifest'
+
+module Librarian
+  module Chef
+    module ManifestReader
+      extend self
+
+      MANIFESTS = %w(metadata.json metadata.yml metadata.yaml metadata.rb)
+
+      def manifest_path(path)
+        MANIFESTS.map{|s| path.join(s)}.find{|s| s.exist?}
+      end
+
+      def read_manifest(name, manifest_path)
+        case manifest_path.extname
+        when ".json" then JSON.parse(manifest_path.read)
+        when ".yml", ".yaml" then YAML.load(manifest_path.read)
+        when ".rb" then compile_manifest(name, manifest_path.dirname)
+        end
+      end
+
+      def compile_manifest(name, path)
+        # Inefficient, if there are many cookbooks with uncompiled metadata.
+        require 'chef/json_compat'
+        require 'chef/cookbook/metadata'
+        md = ::Chef::Cookbook::Metadata.new
+        md.name(name)
+        md.from_file(path.join('metadata.rb').to_s)
+        {"name" => md.name, "version" => md.version, "dependencies" => md.dependencies}
+      end
+
+      def manifest?(name, path)
+        path = Pathname.new(path)
+        !!manifest_path(path)
+      end
+
+      def check_manifest(name, manifest_path)
+        manifest = read_manifest(name, manifest_path)
+        manifest["name"] == name
+      end
+
+    end
+  end
+end

data/lib/librarian/chef/source/local.rb

@@ -1,12 +1,60 @@
-require 'librarian/chef/source/local/manifest'
+require 'librarian/chef/manifest_reader'
 
 module Librarian
   module Chef
     module Source
       module Local
 
-        def manifest_class
-          Manifest
+        def install!(manifest)
+          manifest.source == self or raise ArgumentError
+
+          debug { "Installing #{manifest}" }
+
+          name, version = manifest.name, manifest.version
+          found_path = found_path(name)
+
+          install_path = environment.install_path.join(name)
+          if install_path.exist?
+            debug { "Deleting #{relative_path_to(install_path)}" }
+            install_path.rmtree
+          end
+
+          debug { "Copying #{relative_path_to(found_path)} to #{relative_path_to(install_path)}" }
+          FileUtils.cp_r(found_path, install_path)
+        end
+
+        def fetch_version(name, extra)
+          manifest_data(name)["version"]
+        end
+
+        def fetch_dependencies(name, version, extra)
+          manifest_data(name)["dependencies"]
+        end
+
+      private
+
+        def manifest_data(name)
+          @manifest_data ||= { }
+          @manifest_data[name] ||= fetch_manifest_data(name)
+        end
+
+        def fetch_manifest_data(name)
+          expect_manifest!(name)
+
+          found_path = found_path(name)
+          manifest_path = ManifestReader.manifest_path(found_path)
+          ManifestReader.read_manifest(name, manifest_path)
+        end
+
+        def manifest?(name, path)
+          ManifestReader.manifest?(name, path)
+        end
+
+        def expect_manifest!(name)
+          found_path = found_path(name)
+          return if found_path && ManifestReader.manifest_path(found_path)
+
+          raise Error, "No metadata file found for #{name} from #{self}! If this should be a cookbook, you might consider contributing a metadata file upstream or forking the cookbook to add your own metadata file."
         end
 
       end

data/lib/librarian/chef/source/site.rb

@@ -5,11 +5,12 @@ require 'net/http'
 require 'json'
 require 'digest'
 require 'zlib'
+require 'tmpdir'
 require 'archive/tar/minitar'
 
 require 'librarian/helpers/debug'
 
-require 'librarian/chef/source/site/manifest'
+require 'librarian/chef/manifest_reader'
 
 module Librarian
   module Chef
@@ -18,14 +19,304 @@ module Librarian
 
         include Helpers::Debug
 
+        class Line
+
+          include Helpers::Debug
+
+          attr_accessor :source, :name
+          private :source=, :name=
+
+          def initialize(source, name)
+            self.source = source
+            self.name = name
+          end
+
+          def install_version!(version, install_path)
+            cache_version_unpacked! version
+
+            if install_path.exist?
+              debug { "Deleting #{relative_path_to(install_path)}" }
+              install_path.rmtree
+            end
+
+            unpacked_path = version_unpacked_cache_path(version)
+
+            debug { "Copying #{relative_path_to(unpacked_path)} to #{relative_path_to(install_path)}" }
+            FileUtils.cp_r(unpacked_path, install_path)
+          end
+
+          def manifests
+            version_uris.map do |version_uri|
+              Manifest.new(source, name, version_uri)
+            end
+          end
+
+          def to_version(version_uri)
+            version_uri_metadata(version_uri)["version"]
+          end
+
+          def version_dependencies(version)
+            version_manifest(version)["dependencies"]
+          end
+
+        private
+
+          attr_accessor :metadata_cached
+          alias metadata_cached? metadata_cached
+
+          def environment
+            source.environment
+          end
+
+          def uri
+            @uri ||= URI.parse("#{source.uri}/cookbooks/#{name}")
+          end
+
+          def version_uris
+            metadata["versions"]
+          end
+
+          def version_metadata(version)
+            version_uri = to_version_uri(version)
+            version_uri_metadata(version_uri)
+          end
+
+          def version_uri_metadata(version_uri)
+            @version_uri_metadata ||= { }
+            @version_uri_metadata[version_uri.to_s] ||= begin
+              cache_version_uri_metadata! version_uri
+              parse_local_json(version_uri_metadata_cache_path(version_uri))
+            end
+          end
+
+          def version_manifest(version)
+            version_uri = to_version_uri(version)
+            version_uri_manifest(version_uri)
+          end
+
+          def version_uri_manifest(version_uri)
+            @version_uri_manifest ||= { }
+            @version_uri_manifest[version_uri.to_s] ||= begin
+              cache_version_uri_unpacked! version_uri
+              unpacked_path = version_uri_unpacked_cache_path(version_uri)
+              manifest_path = ManifestReader.manifest_path(unpacked_path)
+              ManifestReader.read_manifest(name, manifest_path)
+            end
+          end
+
+          def metadata
+            @metadata ||= begin
+              cache_metadata!
+              parse_local_json(metadata_cache_path)
+            end
+          end
+
+          def to_version_uri(version)
+            @to_version_uri ||= { }
+            @to_version_uri[version.to_s] ||= begin
+              cache_version! version
+              version_cache_path(version).read
+            end
+          end
+
+          def metadata_cached!
+            self.metadata_cached = true
+          end
+
+          def cache_path
+            @cache_path ||= source.cache_path.join(name)
+          end
+
+          def metadata_cache_path
+            @metadata_cache_path ||= cache_path.join("metadata.json")
+          end
+
+          def version_cache_path(version)
+            @version_cache_path ||= { }
+            @version_cache_path[version.to_s] ||= begin
+              cache_path.join("version").join(version.to_s)
+            end
+          end
+
+          def version_uri_cache_path(version_uri)
+            @version_uri_cache_path ||= { }
+            @version_uri_cache_path[version_uri.to_s] ||= begin
+              cache_path.join("version-uri").join(hexdigest(version_uri))
+            end
+          end
+
+          def version_metadata_cache_path(version)
+            version_uri = to_version_uri(version)
+            version_uri_metadata_cache_path(version_uri)
+          end
+
+          def version_uri_metadata_cache_path(version_uri)
+            @version_uri_metadata_cache_path ||= { }
+            @version_uri_metadata_cache_path[version_uri.to_s] ||= begin
+              version_uri_cache_path(version_uri).join("metadata.json")
+            end
+          end
+
+          def version_package_cache_path(version)
+            version_uri = to_version_uri(version)
+            version_uri_package_cache_path(version_uri)
+          end
+
+          def version_uri_package_cache_path(version_uri)
+            @version_uri_package_cache_path ||= { }
+            @version_uri_package_cache_path[version_uri.to_s] ||= begin
+              version_uri_cache_path(version_uri).join("package.tar.gz")
+            end
+          end
+
+          def version_unpacked_cache_path(version)
+            version_uri = to_version_uri(version)
+            version_uri_unpacked_cache_path(version_uri)
+          end
+
+          def version_uri_unpacked_cache_path(version_uri)
+            @version_uri_unpacked_cache_path ||= { }
+            @version_uri_unpacked_cache_path[version_uri.to_s] ||= begin
+              version_uri_cache_path(version_uri).join("package")
+            end
+          end
+
+          def cache_metadata!
+            metadata_cached? and return or metadata_cached!
+            cache_remote_json! metadata_cache_path, uri
+          end
+
+          def cache_version_uri_metadata!(version_uri)
+            path = version_uri_metadata_cache_path(version_uri)
+            path.file? and return
+
+            cache_remote_json! path, version_uri
+          end
+
+          def cache_version!(version)
+            path = version_cache_path(version)
+            path.file? and return
+
+            version_uris.each do |version_uri|
+              m = version_uri_metadata(version_uri)
+              v = m["version"]
+              if version.to_s == v
+                write! path, version_uri.to_s
+                break
+              end
+            end
+          end
+
+          def cache_version_package!(version)
+            version_uri = to_version_uri(version)
+            cache_version_uri_package! version_uri
+          end
+
+          def cache_version_uri_package!(version_uri)
+            path = version_uri_package_cache_path(version_uri)
+            path.file? and return
+
+            file_uri = version_uri_metadata(version_uri)["file"]
+            cache_remote_object! path, file_uri
+          end
+
+          def cache_version_unpacked!(version)
+            version_uri = to_version_uri(version)
+            cache_version_uri_unpacked! version_uri
+          end
+
+          def cache_version_uri_unpacked!(version_uri)
+            cache_version_uri_package!(version_uri)
+
+            path = version_uri_unpacked_cache_path(version_uri)
+            path.directory? and return
+
+            package_path = version_uri_package_cache_path(version_uri)
+            unpacked_path = version_uri_unpacked_cache_path(version_uri)
+            temp_path = Pathname(Dir.tmpdir)
+
+            Zlib::GzipReader.open(package_path) do |input|
+              Archive::Tar::Minitar.unpack(input, temp_path.to_s)
+            end
+            FileUtils.move(temp_path.join(name), unpacked_path)
+          end
+
+          def cache_remote_json!(path, uri)
+            path = Pathname(path)
+            uri = to_uri(uri)
+
+            path.dirname.mkpath unless path.dirname.directory?
+
+            debug { "Caching #{uri} to #{path}" }
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            request = Net::HTTP::Get.new(uri.path)
+            response = http.start{|http| http.request(request)}
+            unless Net::HTTPSuccess === response
+              raise Error, "Could not get #{uri} because #{response.code} #{response.message}!"
+            end
+            json = response.body
+            JSON.parse(json) # verify that it's really JSON.
+            write! path, json
+          end
+
+          def cache_remote_object!(path, uri)
+            path = Pathname(path)
+            uri = to_uri(uri)
+
+            path.dirname.mkpath unless path.dirname.directory?
+
+            debug { "Caching #{uri} to #{path}" }
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            request = Net::HTTP::Get.new(uri.path)
+            response = http.start{|http| http.request(request)}
+            unless Net::HTTPSuccess === response
+              raise Error, "Could not get #{uri} because #{response.code} #{response.message}!"
+            end
+            write! path, response.body
+          end
+
+          def write!(path, bytes)
+            path.dirname.mkpath
+            path.open("wb"){|f| f.write(bytes)}
+          end
+
+          def parse_local_json(path)
+            JSON.parse(path.read)
+          end
+
+          def hexdigest(bytes)
+            Digest::MD5.hexdigest(bytes)
+          end
+
+          def to_uri(uri)
+            uri = URI(uri) unless URI === uri
+            uri
+          end
+
+        end
+
         class << self
+
           LOCK_NAME = 'SITE'
+
           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 = []
+            unrecognized_options = options.keys - recognized_options
+            unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
+
+            new(environment, uri, options)
+          end
+
         end
 
         attr_accessor :environment
@@ -67,18 +358,26 @@ module Librarian
         def unpin!
         end
 
-        def cache!(dependencies)
-          cache_path.mkpath
-          dependencies.each do |dependency|
-            cache_metadata!(dependency)
-          end
+        def cache!(names)
+        end
+
+        def install!(manifest)
+          manifest.source == self or raise ArgumentError
+
+          name = manifest.name
+          version = manifest.version
+          install_path = install_path(name)
+          line = line(name)
+
+          debug { "Installing: #{manifest}" }
+
+          line.install_version! version, install_path
         end
 
         # NOTE:
         #   Assumes the Opscode Site API responds with versions in reverse sorted order
-        def manifests(dependency)
-          metadata = JSON.parse(metadata_cache_path(dependency).read)
-          metadata['versions'].map{|version_uri| Manifest.new(self, dependency.name, version_uri)}
+        def manifests(name)
+          line(name).manifests
         end
 
         def manifest(name, version, dependencies)
@@ -88,10 +387,6 @@ module Librarian
           manifest
         end
 
-        def install_path(dependency)
-          environment.install_path.join(dependency.name)
-        end
-
         def cache_path
           @cache_path ||= begin
             dir = Digest::MD5.hexdigest(uri)
@@ -99,109 +394,23 @@ module Librarian
           end
         end
 
-        def dependency_cache_path(dependency)
-          cache_path.join(dependency.name)
+        def install_path(name)
+          environment.install_path.join(name)
         end
 
-        def metadata_cache_path(dependency)
-          dependency_cache_path(dependency).join("metadata.json")
+        def fetch_version(name, version_uri)
+          line(name).to_version(version_uri)
         end
 
-        def version_cache_path(dependency, version_uri)
-          dependency_cache_path(dependency).join(Digest::MD5.hexdigest(version_uri))
+        def fetch_dependencies(name, version, version_uri)
+          line(name).version_dependencies(version).map{|k, v| Dependency.new(k, v, nil)}
         end
 
-        def version_metadata_cache_path(dependency, version_uri)
-          version_cache_path(dependency, version_uri).join("version.json")
-        end
-
-        def version_archive_cache_file(dependency, version_uri)
-          Pathname.new("archive.tgz")
-        end
-
-        def version_archive_cache_path(dependency, version_uri)
-          version_archive_cache_file = version_archive_cache_file(dependency, version_uri)
-          version_cache_path(dependency, version_uri).join(version_archive_cache_file)
-        end
-
-        def version_unpacked_cache_file(dependency, version_uri)
-          Pathname.new(dependency.name)
-        end
-
-        def version_unpacked_cache_path(dependency, version_uri)
-          version_unpacked_cache_file = version_unpacked_cache_file(dependency, version_uri)
-          version_cache_path(dependency, version_uri).join(version_unpacked_cache_file)
-        end
-
-        def version_package_cache_file(dependency, version_uri)
-          Pathname.new("package")
-        end
-
-        def version_package_cache_path(dependency, version_uri)
-          version_package_cache_file = version_package_cache_file(dependency, version_uri)
-          version_cache_path(dependency, version_uri).join(version_package_cache_file)
-        end
+      private
 
-        def dependency_uri(dependency)
-          "#{uri}/cookbooks/#{dependency.name}"
-        end
-
-        def cache_metadata!(dependency)
-          dependency_cache_path = cache_path.join(dependency.name)
-          dependency_cache_path.mkpath
-          metadata_cache_path = metadata_cache_path(dependency)
-
-          caching_metadata(dependency.name) do
-            dep_uri = URI.parse(dependency_uri(dependency))
-            debug { "Caching #{dep_uri}" }
-            http = Net::HTTP.new(dep_uri.host, dep_uri.port)
-            request = Net::HTTP::Get.new(dep_uri.path)
-            response = http.start{|http| http.request(request)}
-            unless Net::HTTPSuccess === response
-              raise Error, "Could not cache #{dependency} from #{dep_uri} because #{response.code} #{response.message}!"
-            end
-            metadata_blob = response.body
-            JSON.parse(metadata_blob) # check that it's JSON
-            metadata_cache_path(dependency).open('wb') do |f|
-              f.write(metadata_blob)
-            end
-          end
-        end
-
-        def caching_metadata(name)
-          _metadata_cache[name] = yield unless _metadata_cache.include?(name)
-          _metadata_cache[name]
-        end
-
-        def cache_version_metadata!(dependency, version_uri)
-          version_cache_path = version_cache_path(dependency, version_uri)
-          unless version_cache_path.exist?
-            version_cache_path.mkpath
-            debug { "Caching #{version_uri}" }
-            version_metadata_blob = Net::HTTP.get(URI.parse(version_uri))
-            JSON.parse(version_metadata_blob) # check that it's JSON
-            version_metadata_cache_path(dependency, version_uri).open('wb') do |f|
-              f.write(version_metadata_blob)
-            end
-          end
-        end
-
-        def cache_version_package!(dependency, version_uri, file_uri)
-          version_archive_cache_path = version_archive_cache_path(dependency, version_uri)
-          unless version_archive_cache_path.exist?
-            version_archive_cache_path.open('wb') do |f|
-              f.write(Net::HTTP.get(URI.parse(file_uri)))
-            end
-          end
-          version_package_cache_path = version_package_cache_path(dependency, version_uri)
-          unless version_package_cache_path.exist?
-            dependency_cache_path = dependency_cache_path(dependency)
-            version_unpacked_temp_path = dependency_cache_path.join(dependency.name)
-            Zlib::GzipReader.open(version_archive_cache_path) do |input|
-              Archive::Tar::Minitar.unpack(input, version_unpacked_temp_path.to_s)
-            end
-            FileUtils.move(version_unpacked_temp_path.join(dependency.name), version_package_cache_path)
-          end
+        def line(name)
+          @line ||= { }
+          @line[name] ||= Line.new(self, name)
         end
 
       end