berkshelf 5.5.0 → 5.6.0

data/lib/berkshelf/installer.rb

@@ -1,4 +1,4 @@
-require 'berkshelf/api-client'
+require "berkshelf/api-client"
 
 module Berkshelf
   class Installer
@@ -31,13 +31,14 @@ module Berkshelf
     def run
       lockfile.reduce!
 
-      Berkshelf.formatter.msg('Resolving cookbook dependencies...')
+      Berkshelf.formatter.msg("Resolving cookbook dependencies...")
 
-      dependencies, cookbooks = if lockfile.trusted?
-        install_from_lockfile
-      else
-        install_from_universe
-      end
+      dependencies, cookbooks =
+        if lockfile.trusted?
+          install_from_lockfile
+        else
+          install_from_universe
+        end
 
       Berkshelf.log.debug "  Finished resolving, calculating locks"
 
@@ -59,131 +60,131 @@ module Berkshelf
 
     private
 
-      attr_reader :worker
+    attr_reader :worker
 
-      class Worker
-        include Celluloid
+    class Worker
+      include Celluloid
 
-        attr_reader :berksfile
-        attr_reader :downloader
+      attr_reader :berksfile
+      attr_reader :downloader
 
-        def initialize(berksfile)
-          @berksfile  = berksfile
-          @downloader = Downloader.new(berksfile)
-        end
+      def initialize(berksfile)
+        @berksfile  = berksfile
+        @downloader = Downloader.new(berksfile)
+      end
 
-        # Install a specific dependency.
-        #
-        # @param [Dependency]
-        #   the dependency to install
-        # @return [CachedCookbook]
-        #   the installed cookbook
-        def install(dependency)
-          Berkshelf.log.info "Installing #{dependency}"
+      # Install a specific dependency.
+      #
+      # @param [Dependency]
+      #   the dependency to install
+      # @return [CachedCookbook]
+      #   the installed cookbook
+      def install(dependency)
+        Berkshelf.log.info "Installing #{dependency}"
 
-          if dependency.installed?
-            Berkshelf.log.debug "  Already installed - skipping install"
+        if dependency.installed?
+          Berkshelf.log.debug "  Already installed - skipping install"
 
-            Berkshelf.formatter.use(dependency)
-            dependency.cached_cookbook
-          else
-            name, version = dependency.name, dependency.locked_version.to_s
-            source = berksfile.source_for(name, version)
+          Berkshelf.formatter.use(dependency)
+          dependency.cached_cookbook
+        else
+          name, version = dependency.name, dependency.locked_version.to_s
+          source = berksfile.source_for(name, version)
 
-            # Raise error if our Berksfile.lock has cookbook versions that
-            # can't be found in sources
-            raise MissingLockfileCookbookVersion.new(name, version, 'in any of the sources') unless source
+          # Raise error if our Berksfile.lock has cookbook versions that
+          # can't be found in sources
+          raise MissingLockfileCookbookVersion.new(name, version, "in any of the sources") unless source
 
-            Berkshelf.log.debug "  Downloading #{dependency.name} (#{dependency.locked_version}) from #{source}"
+          Berkshelf.log.debug "  Downloading #{dependency.name} (#{dependency.locked_version}) from #{source}"
 
-            cookbook = source.cookbook(name, version)
+          cookbook = source.cookbook(name, version)
 
-            Berkshelf.log.debug "    => #{cookbook.inspect}"
+          Berkshelf.log.debug "    => #{cookbook.inspect}"
 
-            Berkshelf.formatter.install(source, cookbook)
+          Berkshelf.formatter.install(source, cookbook)
 
-            downloader.download(name, version) do |stash|
-              CookbookStore.import(name, version, stash)
-            end
+          downloader.download(name, version) do |stash|
+            CookbookStore.import(name, version, stash)
           end
         end
       end
+    end
 
-      # Install all the dependencies from the lockfile graph.
-      #
-      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
-      #   the list of installed dependencies and cookbooks
-      def install_from_lockfile
-        Berkshelf.log.info "Installing from lockfile"
-
-        dependencies = lockfile.graph.locks.values
-
-        Berkshelf.log.debug "  Dependencies"
-        dependencies.map do |dependency|
-          Berkshelf.log.debug "    #{dependency}"
-        end
-
-        download_locations(dependencies)
-
-        # Only construct the universe if we are going to install things
-        unless dependencies.all?(&:installed?)
-          Berkshelf.log.debug "  Not all dependencies are installed"
-          build_universe
-        end
+    # Install all the dependencies from the lockfile graph.
+    #
+    # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+    #   the list of installed dependencies and cookbooks
+    def install_from_lockfile
+      Berkshelf.log.info "Installing from lockfile"
 
-        cookbooks = dependencies.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
+      dependencies = lockfile.graph.locks.values
 
-        [dependencies, cookbooks]
+      Berkshelf.log.debug "  Dependencies"
+      dependencies.map do |dependency|
+        Berkshelf.log.debug "    #{dependency}"
       end
 
-      # Resolve and install the dependencies from the "universe", updating the
-      # lockfile appropiately.
-      #
-      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
-      #   the list of installed dependencies and cookbooks
-      def install_from_universe
-        Berkshelf.log.info "Installing from universe"
-
-        dependencies = lockfile.graph.locks.values + berksfile.dependencies
-        dependencies = dependencies.inject({}) do |hash, dependency|
-          # Fancy way of ensuring no duplicate dependencies are used...
-          hash[dependency.name] ||= dependency
-          hash
-        end.values
+      download_locations(dependencies)
 
-        download_locations(dependencies)
+      # Only construct the universe if we are going to install things
+      unless dependencies.all?(&:installed?)
+        Berkshelf.log.debug "  Not all dependencies are installed"
+        build_universe
+      end
 
-        Berkshelf.log.debug "  Creating a resolver"
-        resolver = Resolver.new(berksfile, dependencies)
+      cookbooks = dependencies.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
 
-        # Unlike when installing from the lockfile, we _always_ need to build
-        # the universe when installing from the universe... duh
-        build_universe
+      [dependencies, cookbooks]
+    end
 
-        # Add any explicit dependencies for already-downloaded cookbooks (like
-        # path locations)
-        dependencies.each do |dependency|
-          if dependency.location
-            cookbook = dependency.cached_cookbook
-            Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
-            resolver.add_explicit_dependencies(cookbook)
-          end
+    # Resolve and install the dependencies from the "universe", updating the
+    # lockfile appropiately.
+    #
+    # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+    #   the list of installed dependencies and cookbooks
+    def install_from_universe
+      Berkshelf.log.info "Installing from universe"
+
+      dependencies = lockfile.graph.locks.values + berksfile.dependencies
+      dependencies = dependencies.inject({}) do |hash, dependency|
+        # Fancy way of ensuring no duplicate dependencies are used...
+        hash[dependency.name] ||= dependency
+        hash
+      end.values
+
+      download_locations(dependencies)
+
+      Berkshelf.log.debug "  Creating a resolver"
+      resolver = Resolver.new(berksfile, dependencies)
+
+      # Unlike when installing from the lockfile, we _always_ need to build
+      # the universe when installing from the universe... duh
+      build_universe
+
+      # Add any explicit dependencies for already-downloaded cookbooks (like
+      # path locations)
+      dependencies.each do |dependency|
+        if dependency.location
+          cookbook = dependency.cached_cookbook
+          Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
+          resolver.add_explicit_dependencies(cookbook)
         end
+      end
 
-        Berkshelf.log.debug "  Starting resolution..."
+      Berkshelf.log.debug "  Starting resolution..."
 
-        cookbooks = resolver.resolve.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
+      cookbooks = resolver.resolve.sort.map { |dependency| worker.future.install(dependency) }.map(&:value)
 
-        [dependencies, cookbooks]
-      end
+      [dependencies, cookbooks]
+    end
 
-      def download_locations(dependencies)
-        dependencies.select(&:location).each do |dependency|
-          unless dependency.location.installed?
-            Berkshelf.formatter.fetch(dependency)
-            dependency.location.install
-          end
+    def download_locations(dependencies)
+      dependencies.select(&:location).each do |dependency|
+        unless dependency.location.installed?
+          Berkshelf.formatter.fetch(dependency)
+          dependency.location.install
         end
       end
+    end
   end
 end

data/lib/berkshelf/location.rb

@@ -31,17 +31,17 @@ module Berkshelf
         # Load the correct location from the given options.
         #
         # @return [Class, nil]
-        def klass_from_options(options)
-          options.each do |key, _|
-            id = key.to_s.capitalize
+      def klass_from_options(options)
+        options.each do |key, _|
+          id = key.to_s.capitalize
 
-            begin
-              return Berkshelf.const_get("#{id}Location")
-            rescue NameError; end
-          end
-
-          nil
+          begin
+            return Berkshelf.const_get("#{id}Location")
+          rescue NameError; end
         end
+
+        nil
+      end
     end
   end
 end

data/lib/berkshelf/locations/git.rb

@@ -1,4 +1,4 @@
-require 'buff/shell_out'
+require "buff/shell_out"
 
 module Berkshelf
   class GitLocation < BaseLocation
@@ -22,7 +22,7 @@ module Berkshelf
       @rel      = options[:rel]
 
       # The revision to parse
-      @rev_parse = options[:ref] || options[:branch] || options[:tag] || 'master'
+      @rev_parse = options[:ref] || options[:branch] || options[:tag] || "master"
     end
 
     # @see BaseLoation#installed?
@@ -40,26 +40,26 @@ module Berkshelf
 
       if cached?
         Dir.chdir(cache_path) do
-          git %|fetch --force --tags #{uri} "refs/heads/*:refs/heads/*"|
+          git %{fetch --force --tags #{uri} "refs/heads/*:refs/heads/*"}
         end
       else
-        git %|clone #{uri} "#{cache_path}" --bare --no-hardlinks|
+        git %{clone #{uri} "#{cache_path}" --bare --no-hardlinks}
       end
 
       Dir.chdir(cache_path) do
-        @revision ||= git %|rev-parse #{@rev_parse}|
+        @revision ||= git %{rev-parse #{@rev_parse}}
       end
 
       # Clone into a scratch directory for validations
-      git %|clone --no-checkout "#{cache_path}" "#{scratch_path}"|
+      git %{clone --no-checkout "#{cache_path}" "#{scratch_path}"}
 
       # Make sure the scratch directory is up-to-date and account for rel paths
       Dir.chdir(scratch_path) do
-        git %|fetch --force --tags "#{cache_path}"|
-        git %|reset --hard #{@revision}|
+        git %{fetch --force --tags "#{cache_path}"}
+        git %{reset --hard #{@revision}}
 
         if rel
-          git %|filter-branch --subdirectory-filter "#{rel}" --force|
+          git %{filter-branch --subdirectory-filter "#{rel}" --force}
         end
       end
 
@@ -71,7 +71,7 @@ module Berkshelf
       FileUtils.mv(scratch_path, install_path)
 
       # Remove the git history
-      FileUtils.rm_rf(File.join(install_path, '.git'))
+      FileUtils.rm_rf(File.join(install_path, ".git"))
 
       install_path.chmod(0777 & ~File.umask)
     ensure
@@ -90,11 +90,11 @@ module Berkshelf
 
     def ==(other)
       other.is_a?(GitLocation) &&
-      other.uri == uri &&
-      other.branch == branch &&
-      other.tag == tag &&
-      other.shortref == shortref &&
-      other.rel == rel
+        other.uri == uri &&
+        other.branch == branch &&
+        other.tag == tag &&
+        other.shortref == shortref &&
+        other.rel == rel
     end
 
     def to_s
@@ -149,7 +149,7 @@ module Berkshelf
     # @return [Pathname]
     def cache_path
       Pathname.new(Berkshelf.berkshelf_path)
-        .join('.cache', 'git', Digest::SHA1.hexdigest(uri))
+        .join(".cache", "git", Digest::SHA1.hexdigest(uri))
     end
   end
 end

data/lib/berkshelf/locations/github.rb

@@ -1,6 +1,6 @@
 module Berkshelf
   class GithubLocation < GitLocation
-    HOST = 'github.com'
+    HOST = "github.com"
     def initialize(dependency, options = {})
       protocol = Berkshelf::Config.instance.github_protocol || :https
       case protocol

data/lib/berkshelf/locations/path.rb

@@ -49,8 +49,8 @@ module Berkshelf
 
     def ==(other)
       other.is_a?(PathLocation) &&
-      other.metadata? == metadata? &&
-      other.relative_path == relative_path
+        other.metadata? == metadata? &&
+        other.relative_path == relative_path
     end
 
     def to_lock

data/lib/berkshelf/lockfile.rb

@@ -1,4 +1,4 @@
-require_relative 'dependency'
+require_relative "dependency"
 
 module Berkshelf
   class Lockfile
@@ -24,10 +24,10 @@ module Berkshelf
       end
     end
 
-    DEFAULT_FILENAME = 'Berksfile.lock'.freeze
+    DEFAULT_FILENAME = "Berksfile.lock".freeze
 
-    DEPENDENCIES = 'DEPENDENCIES'.freeze
-    GRAPH        = 'GRAPH'.freeze
+    DEPENDENCIES = "DEPENDENCIES".freeze
+    GRAPH        = "GRAPH".freeze
 
     include Berkshelf::Mixin::Logging
 
@@ -94,7 +94,7 @@ module Berkshelf
     # @return [Boolean]
     #   true if this lockfile is trusted, false otherwise
     def trusted?
-      Berkshelf.log.info 'Checking if lockfile is trusted'
+      Berkshelf.log.info "Checking if lockfile is trusted"
 
       checked = {}
 
@@ -154,7 +154,7 @@ module Berkshelf
     #
     # @return [Boolean]
     def satisfies_transitive?(graph_item, checked, level = 0)
-      indent = ' '*(level + 2)
+      indent = " " * (level + 2)
 
       Berkshelf.log.debug "#{indent}Checking transitive dependencies for #{graph_item}"
 
@@ -204,8 +204,8 @@ module Berkshelf
     #   configuration
     def apply(name, options = {})
       locks = graph.locks.inject({}) do |hash, (name, dependency)|
-         hash[name] = "= #{dependency.locked_version.to_s}"
-         hash
+        hash[name] = "= #{dependency.locked_version}"
+        hash
       end
 
       if options[:envfile]
@@ -297,7 +297,7 @@ module Berkshelf
       unless locked.installed?
         name    = locked.name
         version = locked.locked_version || locked.version_constraint
-        raise CookbookNotFound.new(name, version, 'in the cookbook store')
+        raise CookbookNotFound.new(name, version, "in the cookbook store")
       end
 
       locked.cached_cookbook
@@ -320,11 +320,11 @@ module Berkshelf
 
       json_environment = JSON.parse(File.read(environment_file))
 
-      json_environment['cookbook_versions'] = locks
+      json_environment["cookbook_versions"] = locks
 
       json = JSON.pretty_generate(json_environment)
 
-      File.open(environment_file, 'w'){ |f| f.puts(json) }
+      File.open(environment_file, "w") { |f| f.puts(json) }
 
       Berkshelf.log.info "Updated environment file #{environment_file}"
     end
@@ -395,7 +395,6 @@ module Berkshelf
       end
       Berkshelf.log.debug ""
 
-
       # Unlock any locked dependencies that are no longer in the Berksfile
       Berkshelf.log.debug "Unlocking dependencies no longer in the Berksfile"
 
@@ -441,11 +440,11 @@ module Berkshelf
 
       # Iteratively remove orphan dependencies
       orphans = true
-      while orphans do
+      while orphans
         orphans = false
         graph.each do |cookbook|
           name = cookbook.name
-          unless dependency?(name) or graph.dependency?(name)
+          unless dependency?(name) || graph.dependency?(name)
             Berkshelf.log.debug "#{cookbook} identified as orphan; removing it"
             unlock(name)
             orphans = true
@@ -461,7 +460,6 @@ module Berkshelf
       Berkshelf.log.debug ""
     end
 
-
     # Write the contents of the current statue of the lockfile to disk. This
     # method uses an atomic file write. A temporary file is created, written,
     # and then copied over the existing one. This ensures any partial updates
@@ -473,7 +471,7 @@ module Berkshelf
     def save
       return false if dependencies.empty?
 
-      tempfile = Tempfile.new(['Berksfile',  '.lock'])
+      tempfile = Tempfile.new(["Berksfile", ".lock"])
 
       tempfile.write(to_lock)
 
@@ -509,359 +507,355 @@ module Berkshelf
       "#<Berkshelf::Lockfile #{Pathname.new(filepath).basename}, dependencies: #{dependencies.inspect}>"
     end
 
-    private
-
       # The class responsible for parsing the lockfile and turning it into a
       # useful data structure.
-      class LockfileParser
-        NAME_VERSION         = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'.freeze
-        DEPENDENCY_PATTERN   = /^ {2}#{NAME_VERSION}$/.freeze
-        DEPENDENCIES_PATTERN = /^ {4}#{NAME_VERSION}$/.freeze
-        OPTION_PATTERN       = /^ {4}(.+)\: (.+)/.freeze
+    class LockfileParser
+      NAME_VERSION         = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'.freeze
+      DEPENDENCY_PATTERN   = /^ {2}#{NAME_VERSION}$/
+      DEPENDENCIES_PATTERN = /^ {4}#{NAME_VERSION}$/
+      OPTION_PATTERN       = /^ {4}(.+)\: (.+)/
 
-        # Create a new lockfile parser.
-        #
-        # @param [Lockfile]
-        def initialize(lockfile)
-          @lockfile  = lockfile
-          @berksfile = lockfile.berksfile
-        end
+      # Create a new lockfile parser.
+      #
+      # @param [Lockfile]
+      def initialize(lockfile)
+        @lockfile  = lockfile
+        @berksfile = lockfile.berksfile
+      end
 
-        # Parse the lockfile contents, adding the correct things to the lockfile.
-        #
-        # @return [true]
-        def run
-          @parsed_dependencies = {}
+      # Parse the lockfile contents, adding the correct things to the lockfile.
+      #
+      # @return [true]
+      def run
+        @parsed_dependencies = {}
 
-          contents = File.read(@lockfile.filepath)
+        contents = File.read(@lockfile.filepath)
 
-          if contents.strip.empty?
-            Berkshelf.formatter.warn "Your lockfile at '#{@lockfile.filepath}' " \
-              "is empty. I am going to parse it anyway, but there is a chance " \
-              "that a larger problem is at play. If you manually edited your " \
-              "lockfile, you may have corrupted it."
-          end
+        if contents.strip.empty?
+          Berkshelf.formatter.warn "Your lockfile at '#{@lockfile.filepath}' " \
+            "is empty. I am going to parse it anyway, but there is a chance " \
+            "that a larger problem is at play. If you manually edited your " \
+            "lockfile, you may have corrupted it."
+        end
 
-          if contents.strip[0] == '{'
-            Berkshelf.formatter.warn "It looks like you are using an older " \
-              "version of the lockfile. Attempting to convert..."
-
-            dependencies = "#{Lockfile::DEPENDENCIES}\n"
-            graph        = "#{Lockfile::GRAPH}\n"
-
-            begin
-              hash = JSON.parse(contents)
-            rescue JSON::ParserError
-              Berkshelf.formatter.warn "Could not convert lockfile! This is a " \
-              "problem. You see, previous versions of the lockfile were " \
-              "actually a lie. It lied to you about your version locks, and we " \
-              "are really sorry about that.\n\n" \
-              "Here's the good news - we fixed it!\n\n" \
-              "Here's the bad news - you probably should not trust your old " \
-              "lockfile. You should manually delete your old lockfile and " \
-              "re-run the installer."
-            end
+        if contents.strip[0] == "{"
+          Berkshelf.formatter.warn "It looks like you are using an older " \
+            "version of the lockfile. Attempting to convert..."
+
+          dependencies = "#{Lockfile::DEPENDENCIES}\n"
+          graph        = "#{Lockfile::GRAPH}\n"
+
+          begin
+            hash = JSON.parse(contents)
+          rescue JSON::ParserError
+            Berkshelf.formatter.warn "Could not convert lockfile! This is a " \
+            "problem. You see, previous versions of the lockfile were " \
+            "actually a lie. It lied to you about your version locks, and we " \
+            "are really sorry about that.\n\n" \
+            "Here's the good news - we fixed it!\n\n" \
+            "Here's the bad news - you probably should not trust your old " \
+            "lockfile. You should manually delete your old lockfile and " \
+            "re-run the installer."
+          end
 
-            hash['dependencies'] && hash['dependencies'].sort .each do |name, info|
-              dependencies << "  #{name} (>= 0.0.0)\n"
-              info.each do |key, value|
-                unless key == 'locked_version'
-                  dependencies << "    #{key}: #{value}\n"
-                end
+          hash["dependencies"] && hash["dependencies"].sort .each do |name, info|
+            dependencies << "  #{name} (>= 0.0.0)\n"
+            info.each do |key, value|
+              unless key == "locked_version"
+                dependencies << "    #{key}: #{value}\n"
               end
-
-              graph << "  #{name} (#{info['locked_version']})\n"
             end
 
-            contents = "#{dependencies}\n#{graph}"
+            graph << "  #{name} (#{info['locked_version']})\n"
           end
 
-          contents.split(/(?:\r?\n)+/).each do |line|
-            if line == Lockfile::DEPENDENCIES
-              @state = :dependency
-            elsif line == Lockfile::GRAPH
-              @state = :graph
-            else
-              send("parse_#{@state}", line)
-            end
-          end
-
-          @parsed_dependencies.each do |name, options|
-            graph_item = @lockfile.graph.find(name)
-            options[:locked_version] = graph_item.version if graph_item
+          contents = "#{dependencies}\n#{graph}"
+        end
 
-            dependency = Dependency.new(@berksfile, name, options)
-            @lockfile.add(dependency)
+        contents.split(/(?:\r?\n)+/).each do |line|
+          if line == Lockfile::DEPENDENCIES
+            @state = :dependency
+          elsif line == Lockfile::GRAPH
+            @state = :graph
+          else
+            send("parse_#{@state}", line)
           end
-
-          true
         end
 
-        private
-
-          # Parse a dependency line.
-          #
-          # @param [String] line
-          def parse_dependency(line)
-            if line =~ DEPENDENCY_PATTERN
-              name, version = $1, $2
-
-              @parsed_dependencies[name] ||= {}
-              @parsed_dependencies[name][:constraint] = version if version
-              @current_dependency = @parsed_dependencies[name]
-            elsif line =~ OPTION_PATTERN
-              key, value = $1, $2
-              @current_dependency[key.to_sym] = value
-            end
-          end
+        @parsed_dependencies.each do |name, options|
+          graph_item = @lockfile.graph.find(name)
+          options[:locked_version] = graph_item.version if graph_item
 
-          # Parse a graph line.
-          #
-          # @param [String] line
-          def parse_graph(line)
-            if line =~ DEPENDENCY_PATTERN
-              name, version = $1, $2
-
-              @lockfile.graph.find(name) || @lockfile.graph.add(name, version)
-              @current_lock = name
-            elsif line =~ DEPENDENCIES_PATTERN
-              name, constraint = $1, $2
-              @lockfile.graph.find(@current_lock).add_dependency(name, constraint)
-            end
-          end
+          dependency = Dependency.new(@berksfile, name, options)
+          @lockfile.add(dependency)
+        end
+
+        true
       end
 
-      # The class representing an internal graph.
-      class Graph
-        include Enumerable
+      private
 
-        # Create a new Lockfile graph.
+        # Parse a dependency line.
         #
-        # Some clarifying terminology:
-        #
-        #     yum-epel (0.2.0) <- lock
-        #       yum (~> 3.0)   <- dependency
-        #
-        # @return [Graph]
-        def initialize(lockfile)
-          @lockfile  = lockfile
-          @berksfile = lockfile.berksfile
-          @graph     = {}
-        end
-
-        # @yield [Hash<String]
-        def each(&block)
-          @graph.values.each(&block)
+        # @param [String] line
+      def parse_dependency(line)
+        if line =~ DEPENDENCY_PATTERN
+          name, version = $1, $2
+
+          @parsed_dependencies[name] ||= {}
+          @parsed_dependencies[name][:constraint] = version if version
+          @current_dependency = @parsed_dependencies[name]
+        elsif line =~ OPTION_PATTERN
+          key, value = $1, $2
+          @current_dependency[key.to_sym] = value
         end
+      end
 
-        # The list of locks for this graph. Dependencies are retrieved from the
-        # lockfile, then the Berksfile, and finally a new dependency object is
-        # created if none of those exist.
+        # Parse a graph line.
         #
-        # @return [Hash<String, Dependency>]
-        #   a key-value hash where the key is the name of the cookbook and the
-        #   value is the locked dependency
-        def locks
-          @graph.sort.inject({}) do |hash, (name, item)|
-            dependency = @lockfile.find(name)  ||
-                         @berksfile && @berksfile.find(name) ||
-                         Dependency.new(@berksfile, name)
-
-            # We need to make a copy of the dependency, or else we could be
-            # modifying an existing object that other processes depend on!
-            dependency = dependency.dup
-            dependency.locked_version = item.version unless dependency.locked_version 
-
-            hash[item.name] = dependency
-            hash
-          end
+        # @param [String] line
+      def parse_graph(line)
+        if line =~ DEPENDENCY_PATTERN
+          name, version = $1, $2
+
+          @lockfile.graph.find(name) || @lockfile.graph.add(name, version)
+          @current_lock = name
+        elsif line =~ DEPENDENCIES_PATTERN
+          name, constraint = $1, $2
+          @lockfile.graph.find(@current_lock).add_dependency(name, constraint)
         end
+      end
+    end
 
-        # Find a given dependency in the graph.
-        #
-        # @param [Dependency, String]
-        #   the name/dependency to find
-        #
-        # @return [GraphItem, nil]
-        #   the item for the name
-        def find(dependency)
-          @graph[Dependency.name(dependency)]
-        end
+      # The class representing an internal graph.
+    class Graph
+      include Enumerable
 
-        # Find if the given lock exists?
-        #
-        # @param [Dependency, String]
-        #   the name/dependency to find
-        #
-        # @return [true, false]
-        def lock?(dependency)
-          !find(dependency).nil?
+      # Create a new Lockfile graph.
+      #
+      # Some clarifying terminology:
+      #
+      #     yum-epel (0.2.0) <- lock
+      #       yum (~> 3.0)   <- dependency
+      #
+      # @return [Graph]
+      def initialize(lockfile)
+        @lockfile  = lockfile
+        @berksfile = lockfile.berksfile
+        @graph     = {}
+      end
+
+      # @yield [Hash<String]
+      def each(&block)
+        @graph.values.each(&block)
+      end
+
+      # The list of locks for this graph. Dependencies are retrieved from the
+      # lockfile, then the Berksfile, and finally a new dependency object is
+      # created if none of those exist.
+      #
+      # @return [Hash<String, Dependency>]
+      #   a key-value hash where the key is the name of the cookbook and the
+      #   value is the locked dependency
+      def locks
+        @graph.sort.inject({}) do |hash, (name, item)|
+          dependency = @lockfile.find(name) ||
+            @berksfile && @berksfile.find(name) ||
+            Dependency.new(@berksfile, name)
+
+          # We need to make a copy of the dependency, or else we could be
+          # modifying an existing object that other processes depend on!
+          dependency = dependency.dup
+          dependency.locked_version = item.version unless dependency.locked_version
+
+          hash[item.name] = dependency
+          hash
         end
-        alias_method :has_lock?, :lock?
+      end
 
-        # Determine if this graph contains the given dependency. This method is
-        # used by the lockfile when adding or removing dependencies to see if a
-        # dependency can be safely removed.
-        #
-        # @param [Dependency, String] dependency
-        #   the name/dependency to find
-        #
-        # @option options [String, Array<String>] :ignore
-        #   the list of dependencies to ignore
-        def dependency?(dependency, options = {})
-          name   = Dependency.name(dependency)
-          ignore = Hash[*Array(options[:ignore]).map { |i| [i, true] }.flatten]
+      # Find a given dependency in the graph.
+      #
+      # @param [Dependency, String]
+      #   the name/dependency to find
+      #
+      # @return [GraphItem, nil]
+      #   the item for the name
+      def find(dependency)
+        @graph[Dependency.name(dependency)]
+      end
 
-          @graph.values.each do |item|
-            next if ignore[item.name]
+      # Find if the given lock exists?
+      #
+      # @param [Dependency, String]
+      #   the name/dependency to find
+      #
+      # @return [true, false]
+      def lock?(dependency)
+        !find(dependency).nil?
+      end
+      alias_method :has_lock?, :lock?
 
-            if item.dependencies.key?(name)
-              return true
-            end
-          end
+      # Determine if this graph contains the given dependency. This method is
+      # used by the lockfile when adding or removing dependencies to see if a
+      # dependency can be safely removed.
+      #
+      # @param [Dependency, String] dependency
+      #   the name/dependency to find
+      #
+      # @option options [String, Array<String>] :ignore
+      #   the list of dependencies to ignore
+      def dependency?(dependency, options = {})
+        name   = Dependency.name(dependency)
+        ignore = Hash[*Array(options[:ignore]).map { |i| [i, true] }.flatten]
 
-          false
-        end
-        alias_method :has_dependency?, :dependency?
+        @graph.values.each do |item|
+          next if ignore[item.name]
 
-        # Add each a new {GraphItem} to the graph.
-        #
-        # @param [#to_s] name
-        #   the name of the cookbook
-        # @param [#to_s] version
-        #   the version of the lock
-        #
-        # @return [GraphItem]
-        def add(name, version)
-          @graph[name.to_s] = GraphItem.new(name, version)
+          if item.dependencies.key?(name)
+            return true
+          end
         end
 
-        # Recursively remove any dependencies from the graph unless they exist as
-        # top-level dependencies or nested dependencies.
-        #
-        # @param [Dependency, String] dependency
-        #   the name/dependency to remove
-        #
-        # @option options [String, Array<String>] :ignore
-        #   the list of dependencies to ignore
-        def remove(dependency, options = {})
-          name = Dependency.name(dependency)
+        false
+      end
+      alias_method :has_dependency?, :dependency?
 
-          if @lockfile.dependency?(name)
-            return
-          end
+      # Add each a new {GraphItem} to the graph.
+      #
+      # @param [#to_s] name
+      #   the name of the cookbook
+      # @param [#to_s] version
+      #   the version of the lock
+      #
+      # @return [GraphItem]
+      def add(name, version)
+        @graph[name.to_s] = GraphItem.new(name, version)
+      end
 
-          if dependency?(name, options)
-            return
-          end
+      # Recursively remove any dependencies from the graph unless they exist as
+      # top-level dependencies or nested dependencies.
+      #
+      # @param [Dependency, String] dependency
+      #   the name/dependency to remove
+      #
+      # @option options [String, Array<String>] :ignore
+      #   the list of dependencies to ignore
+      def remove(dependency, options = {})
+        name = Dependency.name(dependency)
+
+        if @lockfile.dependency?(name)
+          return
+        end
+
+        if dependency?(name, options)
+          return
+        end
+
+        # Grab the nested dependencies for this particular entry so we can
+        # recurse and try to remove them from the graph.
+        locked = @graph[name]
+        nested_dependencies = locked && locked.dependencies.keys || []
 
-          # Grab the nested dependencies for this particular entry so we can
-          # recurse and try to remove them from the graph.
-          locked = @graph[name]
-          nested_dependencies = locked && locked.dependencies.keys || []
+        # Now delete the entry
+        @graph.delete(name)
 
-          # Now delete the entry
-          @graph.delete(name)
+        # Recursively try to delete the remaining dependencies for this item
+        nested_dependencies.each(&method(:remove))
+      end
 
-          # Recursively try to delete the remaining dependencies for this item
-          nested_dependencies.each(&method(:remove))
+      # Update the graph with the given cookbooks. This method destroys the
+      # existing dependency graph with this new result!
+      #
+      # @param [Array<CachedCookbook>]
+      #   the list of cookbooks to populate the graph with
+      def update(cookbooks)
+        @graph = {}
+
+        cookbooks.each do |cookbook|
+          @graph[cookbook.cookbook_name.to_s] = GraphItem.new(
+            cookbook.cookbook_name,
+            cookbook.version,
+            cookbook.dependencies
+          )
         end
+      end
 
-        # Update the graph with the given cookbooks. This method destroys the
-        # existing dependency graph with this new result!
-        #
-        # @param [Array<CachedCookbook>]
-        #   the list of cookbooks to populate the graph with
-        def update(cookbooks)
-          @graph = {}
-
-          cookbooks.each do |cookbook|
-            @graph[cookbook.cookbook_name.to_s] = GraphItem.new(
-              cookbook.cookbook_name,
-              cookbook.version,
-              cookbook.dependencies,
-            )
+      # Write the contents of the graph to the lockfile format.
+      #
+      # The resulting format looks like:
+      #
+      #     GRAPH
+      #       apache2 (1.8.14)
+      #       yum-epel (0.2.0)
+      #         yum (~> 3.0)
+      #
+      # @example lockfile.graph.to_lock #=> "GRAPH\n  apache2 (1.18.14)\n..."
+      #
+      # @return [String]
+      #
+      def to_lock
+        out = "#{Lockfile::GRAPH}\n"
+        @graph.sort.each do |name, item|
+          out << "  #{name} (#{item.version})\n"
+
+          unless item.dependencies.empty?
+            item.dependencies.sort.each do |name, constraint|
+              out << "    #{name} (#{constraint})\n"
+            end
           end
         end
 
-        # Write the contents of the graph to the lockfile format.
-        #
-        # The resulting format looks like:
-        #
-        #     GRAPH
-        #       apache2 (1.8.14)
-        #       yum-epel (0.2.0)
-        #         yum (~> 3.0)
-        #
-        # @example lockfile.graph.to_lock #=> "GRAPH\n  apache2 (1.18.14)\n..."
+        out
+      end
+
+      # A single item inside the graph.
+      class GraphItem
+        # The name of the cookbook that corresponds to this graph item.
         #
         # @return [String]
+        #   the name of the cookbook
+        attr_reader :name
+
+        # The locked version for this graph item.
         #
-        def to_lock
-          out = "#{Lockfile::GRAPH}\n"
-          @graph.sort.each do |name, item|
-            out << "  #{name} (#{item.version})\n"
-
-            unless item.dependencies.empty?
-              item.dependencies.sort.each do |name, constraint|
-                out << "    #{name} (#{constraint})\n"
-              end
-            end
-          end
+        # @return [String]
+        #   the locked version of the graph item (as a string)
+        attr_reader :version
 
-          out
+        # The list of dependencies and their constraints.
+        #
+        # @return [Hash<String, String>]
+        #   the list of dependencies for this graph item, where the key
+        #   corresponds to the name of the dependency and the value is the
+        #   version constraint.
+        attr_reader :dependencies
+
+        # Create a new graph item.
+        def initialize(name, version, dependencies = {})
+          @name         = name.to_s
+          @version      = version.to_s
+          @dependencies = dependencies
         end
 
-        private
-
-          # A single item inside the graph.
-          class GraphItem
-            # The name of the cookbook that corresponds to this graph item.
-            #
-            # @return [String]
-            #   the name of the cookbook
-            attr_reader :name
-
-            # The locked version for this graph item.
-            #
-            # @return [String]
-            #   the locked version of the graph item (as a string)
-            attr_reader :version
-
-            # The list of dependencies and their constraints.
-            #
-            # @return [Hash<String, String>]
-            #   the list of dependencies for this graph item, where the key
-            #   corresponds to the name of the dependency and the value is the
-            #   version constraint.
-            attr_reader :dependencies
-
-            # Create a new graph item.
-            def initialize(name, version, dependencies = {})
-              @name         = name.to_s
-              @version      = version.to_s
-              @dependencies = dependencies
-            end
-
-            # Add a new dependency to the list.
-            #
-            # @param [#to_s] name
-            #   the name to use
-            # @param [#to_s] constraint
-            #   the version constraint to use
-            def add_dependency(name, constraint)
-              @dependencies[name.to_s] = constraint.to_s
-            end
+        # Add a new dependency to the list.
+        #
+        # @param [#to_s] name
+        #   the name to use
+        # @param [#to_s] constraint
+        #   the version constraint to use
+        def add_dependency(name, constraint)
+          @dependencies[name.to_s] = constraint.to_s
+        end
 
-            def set_dependencies(dependencies)
-              @dependencies = dependencies.to_hash
-            end
+        def set_dependencies(dependencies)
+          @dependencies = dependencies.to_hash
+        end
 
-            # @private
-            def to_s
-              "#{name} (#{version})"
-            end
-          end
+        # @private
+        def to_s
+          "#{name} (#{version})"
+        end
       end
+    end
   end
 end