brew_dg 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NWNmM2Q2MmY1MDQwZDE1YWM0NTk5ZWZiYzEwZDBkZDgwNGQ1ODZkNA==
+  data.tar.gz: !binary |-
+    MGY1MjRjYzY2MWJiMzE3YWM3ODgxZjA0OTE1NmVjYjI4YWRlNDIyNQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTllYmE2OGJhZGM0MWJlYWI1NTcxMzkzNmJmZmNiYzllZmQ0N2Q2N2QxMjNm
+    NGQ3MjkyZTYxNjNmNzNlZTZiODA4MGVmNGIxNjQxNjM5ZjI4NzgyMjg5NjBj
+    OGU3Njc1MmZlYjJkOGVmNDMzMGM0ZWMxMzUxYWMxNDJmMjg0MjE=
+  data.tar.gz: !binary |-
+    ZDA1YmE0NDdhNTYwMTJiYTQxNDAxOGNhMzViNWNhODE3YmI2NDI5Zjk2MzE5
+    NTE2NTg5ZGVlNGVmZTZiM2YyOWQ0MjlkODk0NmQ4ZGE4MWY2NWM4OTYyYmMy
+    NjUyMTc5OWRiMmZmZWMyZWNlZmVlMTNjZmQ1ZDY5YWJjMzRlNzI=

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Brian Cobb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# BrewDG
+
+Homebrew Dependency Graphs.
+
+BrewDG allows you to visualize your homebrew package dependencies. It can also take a list of packages, and give you those packages, with each package preceeded by its dependencies (and its dependencies will be preceeded by _its_ dependencies, and so forth).
+
+## Installation
+
+`gem install brew_dg`
+
+**N.B.**: this is not the sort of tool that should be distributed as a gem. See [Gary Bernhardt's comment](https://github.com/garybernhardt/selecta#installation) on this in the `selecta` README. Alas, while `brew_dg` has a couple of bulky dependencies, it'll remain a gem.
+
+## Examples
+
+`brew_dg` is pretty slow since it's issuing and parsing the output of `brew` commands. Which is to say, you may want to have a beverage to sip while using it, particularly on a large number of packages.
+
+1. List packages plus their recommended dependencies. This is what compelled me to write `brew_dg`.
+
+    ```
+    $ brew_dg git postgresql sqlite redis
+    > git readline ossp-uuid postgresql sqlite redis
+    ```
+
+    We've added two packages to the initial list: `ossp-uuid`, which is recommended for `postgresql`, and `readline`, which is recommended for `sqlite`. Note that `readline` is in fact _required_ for `postgresql`; perhaps in the future we will take that into ordering consideration.
+
+2. List all of a package's dependencies, including Optional and Build dependencies.
+
+   ```
+   $ brew_dg -a postgis
+   > readline ossp-uuid postgresql proj geos json-c libpng jpeg giflib libtiff \
+       lzlib libgeotiff sqlite freexl libxml2 pkg-config libspatialite cmake \
+       mysql gdal autoconf automake libtool gpp postgis
+   ```
+
+3. Visualize homebrew dependencies. See [Graph](#graph) for visual details. (Note that these visualizations require graphviz):
+
+    ```
+    $ brew_dg -o library.png
+    $ open library.png
+    ```
+
+4. Visualize a package's recommended and required dependencies (as well as their dependencies)
+
+    ```
+    $ brew_dg -o postgis.png postgis
+    $ open postgis.png
+    ```
+
+    [![](http://f.cl.ly/items/0i041b0u1F0e3n153Z1z/postgis.png)](http://f.cl.ly/items/3g2m3y2e150X1w2d263s/postgis.png)
+
+5. Visualize all of a package's dependencies, including Optional and Build dependencies
+
+  ```
+  $ brew_dg -a -o postgis.png postgis
+  $ open postgis.png
+  ```
+
+## Installation
+
+`gem install brew_dg`
+
+## Synopsis
+
+    brew_dg [options] [package package ...]
+
+## Description
+
+Assuming for the moment that brew_dg is given no options, for each
+package given, brew_dg will display that package, along with its
+Required and Recommended dependencies. brew_dg orders the packages such
+that a given package will not be installed until its Recommended and
+Required dependencies have been installed.
+
+If no options or pacakges are given, brew_dg displays any homebrew
+packages you've installed, along with any uninstalled, Recommended
+dependencies in an order such that a package will not be installed until
+its dependencies have been installed.
+
+The following options allow users to configure and tweak the details of the
+preceeding description:
+
+    -a
+        Display all dependencies, including Optional and Build dependencies.
+
+    -o [file]
+        Draw graph, and write it to file. Directed edges are read as "depends
+        on." If given a directory $DIR, the file will be located at
+        $DIR/library.png. See Graph section for stylistic details.
+
+    -O [file]
+        Draw inverted graph, and write it to file. Directed edges are read as
+        "is a dependency of." If given a directory $DIR, the file will be
+        located at $DIR/library.png. See Graph section for stylistic details.
+
+    -t types
+        Display only dependencies of the comma-delimited types specified. e.g.
+        `-t Recommended,Optional'
+
+## Graph
+
+The graph uses edge and arrow styles to differentiate between dependency
+types.
+
+    Required:    A solid edge with a filled, triangular arrow.
+    Recommended: A solid edge with an empty, triangular arrow.
+    Optional:    A dotted edge with a filled, triangular arrow.
+    Build:       A dotted edge with a tee-shaped arrow.
+

data/bin/brew_dg

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$:.unshift(
+  File.expand_path(File.join(File.expand_path(__FILE__), '..', '..', 'lib'))
+)
+
+require 'brew_dg/cli'
+
+BrewDG::CLI.new(ARGV.dup).execute!

data/lib/brew_dg/cli.rb

@@ -0,0 +1,50 @@
+require 'brew_dg/library'
+require 'brew_dg/option_parser'
+
+module BrewDG
+  class CLI
+
+    def initialize(argv, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+      @argv = argv
+      @stdout = stdout
+      @stderr = stderr
+      @kernel = kernel
+      @configuration = OptionParser.new.parse(@argv).options
+
+      if @argv.any?
+        @packages = @argv
+      end
+    end
+
+    attr_reader :configuration
+
+    def execute!
+      options = {}
+
+      if configuration[:types]
+        options.update(relevant_dependency_types: configuration[:types])
+      end
+
+      if @packages
+        options.update(packages: @packages)
+      end
+
+      library = Library.new(options)
+
+      if configuration[:destination]
+        graph = library.graph
+
+        if configuration[:inverted]
+          visualization = graph.reversal.visualization
+        else
+          visualization = graph.visualization
+        end
+
+        visualization.output(png: configuration[:destination])
+      else
+        @stdout.puts library.installation_order.join(' ')
+      end
+    end
+
+  end
+end

data/lib/brew_dg/dependency_manifest.rb

@@ -0,0 +1,38 @@
+require 'virtus'
+
+module BrewDG
+  class DependencyManifest
+    include Virtus.value_object
+
+    DEPENDENCY_TYPES = %w(Build Required Recommended Optional)
+
+    def self.for_package(package)
+      %x(brew info #{package}).lines.map(&method(:from_output)).compact
+    end
+
+    def self.from_output(line)
+      type_match = line.match(/^(\w+):/)
+      type = type_match && type_match.captures.first
+
+      if DEPENDENCY_TYPES.include?(type)
+        manifest_header = "#{type}: "
+        manifest_parts = line.split(manifest_header)
+
+        if manifest_parts.size == 2
+          manifest_body = manifest_parts.last
+          dependencies = manifest_body.split(', ').map(&:strip)
+        else
+          dependencies = []
+        end
+
+        new(type: type.downcase.intern, dependencies: dependencies)
+      end
+    end
+
+    values do
+      attribute :type, Symbol
+      attribute :dependencies, Array, default: []
+    end
+
+  end
+end

data/lib/brew_dg/graph.rb

@@ -0,0 +1,50 @@
+require 'delegate'
+require 'graphviz'
+require 'plexus'
+
+module BrewDG
+  class Graph < ::Plexus::Digraph
+
+    def visualization
+      visualization = GraphViz.new(:G)
+
+      isolated_vertices.each do |vertex|
+        visualization.add_nodes(vertex.to_s)
+      end
+
+      edges.reduce(visualization) do |visualization, edge|
+        manifest = edge.to_a.last
+
+        left, right = edge.to_a.first(2).map do |package|
+          visualization.add_nodes(package.to_s)
+        end
+
+        visualization.add_edges(left, right, edge_options(manifest))
+        visualization
+      end
+    end
+
+    def isolated_vertices
+      vertices.select do |vertex|
+        in_degree(vertex).zero? && out_degree(vertex).zero?
+      end
+    end
+
+    private
+   
+    def edge_options(manifest)
+      if manifest
+        type = manifest.type
+
+        edge_options = {
+          recommended:  { arrowhead: 'empty' },
+          optional: { style: 'dotted' },
+          build: { style: 'dotted', arrowhead: 'tee' }
+        }.fetch(type, {})
+      else
+        {}
+      end
+    end
+
+  end
+end

data/lib/brew_dg/graph_installation.rb

@@ -0,0 +1,29 @@
+module BrewDG
+  class GraphInstallation
+
+    attr_reader :graph
+
+    def initialize(graph)
+      @graph = graph
+    end
+
+    def list
+      graph.vertices.map { |vertex| for_vertex(vertex) }.flatten.uniq
+    end
+
+    private
+
+    def for_vertex(vertex)
+      if graph.neighborhood(vertex, :out).size.zero?
+        [vertex]
+      else
+        dependency_order = graph.neighborhood(vertex, :out).map do |dependency|
+          for_vertex(dependency)
+        end
+
+        dependency_order + [vertex]
+      end
+    end
+
+  end
+end

data/lib/brew_dg/library.rb

@@ -0,0 +1,74 @@
+require 'brew_dg/dependency_manifest'
+require 'brew_dg/graph'
+require 'brew_dg/graph_installation'
+require 'brew_dg/package'
+require 'brew_dg/queryable_dependencies'
+
+module BrewDG
+  class Library
+
+    def initialize(options = {})
+      @package_cache = options.fetch(:package_cache, {})
+      @packages = options.fetch(:packages) do
+        %x(brew list).lines.map(&:strip)
+      end
+      @relevant_dependency_types = options.fetch(:relevant_dependency_types) do
+        [:required, :recommended]
+      end
+    end
+
+    def graph
+      @packages.reduce(Graph.new) do |graph, name|
+        subgraph = subgraph(name)
+
+        graph.add_edges!(*subgraph.edges)
+        graph.add_vertices!(*subgraph.vertices)
+      end
+    end
+
+    def installation_order
+      installation = GraphInstallation.new(graph)
+      installation.list.map(&:to_s)
+    end
+
+    private
+
+    def subgraph(name)
+      package = package(name)
+
+      Graph.new.tap do |graph|
+        graph.add_vertex!(package)
+
+        manifests = @relevant_dependency_types.map do |type|
+          package.dependencies.of_type(type)
+        end
+
+        manifests.reduce(graph) do |manifest_graph, manifest|
+          manifest.dependencies.reduce(manifest_graph) do |subgraph, dependency|
+            subgraph.add_edge!(package, dependency, manifest)
+            subgraph.add_edges!(*subgraph(dependency.name).edges)
+          end
+        end
+      end
+    end
+
+    def package(name)
+      @package_cache.fetch(name) do
+        manifests = DependencyManifest.for_package(name)
+
+        manifests.map! do |manifest|
+          packages = manifest.dependencies.map(&method(:package))
+
+          DependencyManifest.new(type: manifest.type, dependencies: packages)
+        end
+
+        dependencies = QueryableDependencies.new(manifests)
+
+        Package.new(name: name, dependencies: dependencies).tap do |package|
+          @package_cache.store(name, package)
+        end
+      end
+    end
+
+  end
+end

data/lib/brew_dg/option_parser.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+
+module BrewDG
+  class OptionParser
+
+    def initialize
+      @options = {}
+    end
+
+    attr_reader :options
+
+    def parse(args)
+      tap { parser.parse!(Array(args)) }
+    end
+
+    def parser
+      all_types = [:required, :recommended, :optional, :build]
+
+      ::OptionParser.new do |parser|
+        parser.on('-a') do |a|
+          update(:types, all_types) if a
+        end
+
+        parser.on('-t type1,type2', Array) do |types|
+          types = Array(types).map(&:strip).map(&:downcase).map(&:intern)
+
+          update(:types, types)
+        end
+
+        parser.on('-o [file]') do |file|
+          destination(file)
+        end
+
+        parser.on('-O [file]') do |file|
+          destination(file)
+          update(:inverted, true)
+        end
+      end
+    end
+
+    def update(key, val)
+      options.update(key => val) do |_, oldval, _|
+        oldval
+      end
+    end
+
+    def destination(file)
+      if file
+        file = File.expand_path(file)
+
+        if File.directory?(file)
+          file = File.join(file, 'library.png')
+        end
+      end
+
+      update(:destination, file || STDOUT)
+    end
+
+  end
+end

data/lib/brew_dg/package.rb

@@ -0,0 +1,19 @@
+require 'brew_dg/queryable_dependencies'
+require 'virtus'
+
+module BrewDG
+  class Package
+    include Virtus.value_object
+
+    values do
+      attribute :name, String
+      attribute :dependencies, QueryableDependencies
+    end
+
+    def to_s
+      name
+    end
+
+  end
+end
+

data/lib/brew_dg/queryable_dependencies.rb

@@ -0,0 +1,41 @@
+require 'delegate'
+
+module BrewDG
+  class QueryableDependencies < Delegator
+
+    def initialize(dependency_manifests = [])
+      super
+      @dependency_manifests = dependency_manifests
+    end
+
+    def build
+      of_type(:build)
+    end
+
+    def required
+      of_type(:required)
+    end
+
+    def recommended
+      of_type(:recommended)
+    end
+
+    def optional
+      of_type(:optional)
+    end
+
+    def of_type(type)
+      __getobj__.find { |d| d.type == type } ||
+        DependencyManifest.new(type: type)
+    end
+
+    def __getobj__
+      @dependency_manifests
+    end
+
+    def __setobj__(new_dependency_manifests)
+      @dependency_manifests = new_dependency_manifests
+    end
+
+  end
+end

data/lib/brew_dg.rb

@@ -0,0 +1,5 @@
+require 'brew_dg/library'
+
+module BrewDG
+
+end

data/spec/integration/homebrew_output_spec.rb

@@ -0,0 +1,57 @@
+require 'brew_dg'
+
+module BrewDG
+  describe DependencyManifest do
+
+    it "can determine a package's build dependencies" do
+      manifests = DependencyManifest.for_package('postgis')
+
+      known_build_dependencies = %w(automake libtool gpp)
+      build_manifest = manifests.find { |manifest| manifest.type == :build }
+      build_dependencies = build_manifest.dependencies
+
+      expect(Set.new(known_build_dependencies)).
+        to eql(Set.new(build_dependencies))
+    end
+
+    it "can determine a package's required dependencies" do
+      manifests = DependencyManifest.for_package('postgis')
+
+      known_required_dependencies = %w(postgresql proj geos json-c gdal)
+      required_manifest = manifests.find do |manifest|
+        manifest.type == :required
+      end
+      required_dependencies = required_manifest.dependencies
+
+      expect(Set.new(known_required_dependencies)).
+        to eql(Set.new(required_dependencies))
+    end
+
+    it "can determine a package's recommended dependencies" do
+      manifests = DependencyManifest.for_package('sqlite')
+
+      known_recommended_dependencies = %w(readline)
+      recommended_manifest = manifests.find do |manifest|
+        manifest.type == :recommended
+      end
+      recommended_dependencies = recommended_manifest.dependencies
+
+      expect(Set.new(known_recommended_dependencies)).
+        to eql(Set.new(recommended_dependencies))
+    end
+
+    it "can determine a package's optional dependencies" do
+      manifests = DependencyManifest.for_package('nginx')
+
+      known_optional_dependencies = %w(passenger)
+      optional_manifest = manifests.find do |manifest|
+        manifest.type == :optional
+      end
+      optional_dependencies = optional_manifest.dependencies
+
+      expect(Set.new(known_optional_dependencies)).
+        to eql(Set.new(optional_dependencies))
+    end
+
+  end
+end

data/spec/unit/dependency_manifest_spec.rb

@@ -0,0 +1,64 @@
+require 'brew_dg/dependency_manifest'
+
+module BrewDG
+  describe DependencyManifest do
+
+    it 'infers its type from the beginning of the line' do
+      manifest = "Required: json-c"
+      dependency_manifest = DependencyManifest.from_output(manifest)
+
+      expect(dependency_manifest.type).to eql(:required)
+    end
+
+    it 'knows that dependencies are comma-delimited after the type' do
+      manifest = "Required: json-c, proj, geos"
+      dependency_manifest = DependencyManifest.from_output(manifest)
+
+      expect(dependency_manifest.dependencies).
+        to eql(%w(json-c proj geos))
+    end
+
+    it 'strips newlines from dependencies' do
+      manifest = "Required: json-c, proj, geos\n"
+      dependency_manifest = DependencyManifest.from_output(manifest)
+
+      expect(dependency_manifest.dependencies).
+        to eql(%w(json-c proj geos))
+    end
+
+    it 'does not care if there are dependencies on the line' do
+      manifest = "Required:"
+      dependency_manifest = DependencyManifest.from_output(manifest)
+
+      expect(dependency_manifest.dependencies).to eql([])
+    end
+
+    it 'can determine if a line is a dependency' do
+      invalid_manifests = [
+        ": json-c, proj, geos",
+        "Something: one, two, three",
+        "Nothing",
+        "Ha:",
+        ""
+      ]
+
+      valid_manifests = [
+        "Build:",
+        "Recommended:",
+        "Required:",
+        "Optional:",
+        "Optional: passenger",
+        "Build: libtool, gcc",
+        "Required: geos, proj",
+        "Recommended: ossp-uuid"
+      ]
+
+      invalid_manifests.map! { |manifest| DependencyManifest.from_output(manifest) }
+      valid_manifests.map! { |manifest| DependencyManifest.from_output(manifest) }
+
+      expect(invalid_manifests.any?).to be_false
+      expect(valid_manifests.all?).to be_true
+    end
+
+  end
+end

data/spec/unit/graph_installation_spec.rb

@@ -0,0 +1,62 @@
+require 'brew_dg/graph'
+require 'brew_dg/graph_installation'
+
+module BrewDG
+  describe GraphInstallation do
+
+    it 'is empty for an empty graph' do
+      graph = Graph.new
+      installation = GraphInstallation.new(graph)
+
+      expect(installation.list).to eql([])
+    end
+
+    it 'is the single vertex for a one-vertex graph' do
+      graph = Graph.new.tap do |g|
+        g.add_vertex! 'a'
+      end
+
+      installation = GraphInstallation.new(graph)
+
+      expect(installation.list).to eql(['a'])
+    end
+
+    it 'preserves vertex order' do
+      graph = Graph.new.tap do |g|
+        g.add_vertex! 'a'
+        g.add_vertex! 'b'
+      end
+
+      installation = GraphInstallation.new(graph)
+
+      expect(installation.list).to eql(['a', 'b'])
+    end
+
+    it 'moves from neighborhood to neighborhood from the bottom up' do 
+      graph = Graph.new.tap do |g|
+        g.add_vertices! 'a', 'b', 'c', 'd', 'e'
+        g.add_edge! 'a', 'b'
+        g.add_edge! 'b', 'c'
+        g.add_edge! 'b', 'e'
+        g.add_edge! 'e', 'd'
+      end
+
+      installation = GraphInstallation.new(graph)
+
+      expect(installation.list).to eql(['c', 'd', 'e', 'b', 'a']);
+    end
+
+    it 'does not duplicate vertices' do
+      graph = Graph.new.tap do |g|
+        g.add_vertices! 'a', 'b', 'c'
+        g.add_edge! 'a', 'b'
+        g.add_edge! 'c', 'b'
+      end
+
+      installation = GraphInstallation.new(graph)
+
+      expect(installation.list).to eql(['b', 'a', 'c'])
+    end
+
+  end
+end

data/spec/unit/queryable_dependencies_spec.rb

@@ -0,0 +1,46 @@
+require 'brew_dg/dependency_manifest'
+require 'brew_dg/queryable_dependencies'
+
+module BrewDG
+
+  describe QueryableDependencies do
+
+    it 'knows which manifest is the build manifest' do
+      build = DependencyManifest.new(type: :build)
+      required = DependencyManifest.new(type: :required)
+
+      queryable = QueryableDependencies.new([build, required])
+
+      expect(queryable.build).to eql(build)
+    end
+
+    it 'knows which manifest is the required manifest' do
+      build = DependencyManifest.new(type: :build)
+      required = DependencyManifest.new(type: :required)
+
+      queryable = QueryableDependencies.new([build, required])
+
+      expect(queryable.required).to eql(required)
+    end
+
+    it 'knows which manifest is the recommended manifest' do
+      optional = DependencyManifest.new(type: :optional)
+      recommended = DependencyManifest.new(type: :recommended)
+
+      queryable = QueryableDependencies.new([optional, recommended])
+
+      expect(queryable.recommended).to eql(recommended)
+    end
+
+    it 'knows which manifest is the optional manifest' do
+      optional = DependencyManifest.new(type: :optional)
+      recommended = DependencyManifest.new(type: :recommended)
+
+      queryable = QueryableDependencies.new([optional, recommended])
+
+      expect(queryable.optional).to eql(optional)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: brew_dg
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brian Cobb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: plexus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: bcobb@uwalumni.com
+executables:
+- brew_dg
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/brew_dg/cli.rb
+- lib/brew_dg/dependency_manifest.rb
+- lib/brew_dg/graph.rb
+- lib/brew_dg/graph_installation.rb
+- lib/brew_dg/library.rb
+- lib/brew_dg/option_parser.rb
+- lib/brew_dg/package.rb
+- lib/brew_dg/queryable_dependencies.rb
+- lib/brew_dg.rb
+- README.md
+- LICENSE
+- spec/integration/homebrew_output_spec.rb
+- spec/unit/dependency_manifest_spec.rb
+- spec/unit/graph_installation_spec.rb
+- spec/unit/queryable_dependencies_spec.rb
+- bin/brew_dg
+homepage: https://github.com/bcobb/brew_dg
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Work with homebrew dependencies as graphs
+test_files:
+- spec/integration/homebrew_output_spec.rb
+- spec/unit/dependency_manifest_spec.rb
+- spec/unit/graph_installation_spec.rb
+- spec/unit/queryable_dependencies_spec.rb